[HN Gopher] Show HN: Game of Life in 32 bytes of assembler
       ___________________________________________________________________
        
       Show HN: Game of Life in 32 bytes of assembler
        
       Author : HellMood
       Score  : 34 points
       Date   : 2020-04-30 10:56 UTC (12 hours ago)
        
 (HTM) web link (www.pouet.net)
 (TXT) w3m dump (www.pouet.net)
        
       | [deleted]
        
       | HellMood wrote:
       | (source included in the link, writeup will follow) To my
       | knowledge, the first implementation ever in 32 bytes. This builds
       | upon the 65 bytes version of Vladislav Kaipetsky, Tenie Remmel
       | and Mark Andreas from 1998.
       | 
       | Edit: The writeup is now available :
       | http://www.sizecoding.org/wiki/Game_of_Life_32b
        
         | jnurmine wrote:
         | The modbyte trick is clever.
         | 
         | The writeup sure brought back memories.
         | 
         | Over 20 years ago I made a 2-player graphical worm game for
         | DOS. I still have it in a zip. It is 123 bytes long and back
         | then I couldn't squeeze more out of it.
         | 
         | After reading that writeup I feel like there's so much bloat in
         | that 123 bytes!
        
           | zorbash wrote:
           | Please make it available online!
        
             | jnurmine wrote:
             | I can make it available here :)
             | 
             | Here's the binary:                 uBMAzRC6AKCOwovyM/+xAYvp
             | +rraA+yoCHX77KgIdPsmgDWRdDCQkORgityyBDqHawF0C5CQ/sP+       
             | ynXy6wmQKtzQ44uPcwED+YD0BIf+h+k793W/tAyA9ATA7AKK1IDCQbgDAM0
             | QtALNIcMeIBEfJCYX       Jf//AQDA/kAB
             | 
             | Copy that to a file and then: "base64 -d blah.txt >
             | worms.com"
             | 
             | Make sure there are no spaces in the beginning of the
             | lines.
             | 
             | This is from the original document:                 "This
             | is a version of the worm game for two players.       Game
             | objective is to stay alive longer than the other worm!
             | You die if you eat yourself, ie. you are going RIGHT and
             | you press LEFT.              Move the worm with the
             | following keys:          PLAYER A:  (topmost worm)
             | W           A   D             S                 PLAYER B:
             | (lower worm)             I           J   L             K
             | Winner is indicated by player letter, "A" or "B".       An
             | even game is indicated by a "C". An even game means that
             | the worms       ate each others heads, and nobody won."
             | 
             | Edit: correct base64 formatting
        
       | basementcat wrote:
       | twt86 link below...
       | 
       | http://twt86.co?c=xSQgswcIBKfALQWRAkFeAkD8AoCcAEt18ooE%2BdLY...
        
       | exikyut wrote:
       | Doesn't quite hold a candle to this, but one might argue the
       | tangential relatedness of the 1691-byte IOCCC entry from 1991
       | which drew the Game of Life on the root X server window without
       | using Xlib.
       | 
       | I'm completely naive about Life implementations, so I don't know
       | if the approach this entry used is especially interesting, but
       | it's certainly a fascinating read
       | (https://www.ioccc.org/1991/davidguy.hint):
       | 
       |  _The algorithm used to compute the next generation is based on
       | the observation that a cell 's state in the next generation is a
       | boolean function of its current state, and the states of its 8
       | neighbors (ie, a boolean function from 9 bits to 1 bit). This
       | function can be computed by a boolean circuit. In addition,
       | intermediate values computed by the circuit can be shared between
       | neighboring cells, reducing the number of gates per cell
       | required._
       | 
       |  _These ideas have been used before, to compute the next
       | generation through a series of bit blits. Instead of doing this,
       | we map values in the circuit to bits in registers, so that the
       | next generation can be computed efficiently within registers,
       | minimizing memory accesses._
       | 
       |  _As a result, the computation of the next generation is
       | performed with about 1.6 instructions per life cell, consisting
       | of .125 memory accesses, .17 shifts, and 1.3 logic operations.
       | The net result is that the time to transfer the bits to the X
       | server, and for the X server to draw them on the screen,
       | dominates the time to compute the next generation._
       | 
       | I'm not sure what I did last time I tried to get this working and
       | failed; it works great on Debian 10 with GCC 8.3 etc:
       | 
       | $ wget https://www.ioccc.org/1991/davidguy.fix.c
       | 
       | $ gcc -o davidguy davidguy.fix.c -m32
       | 
       | $ xhost +
       | 
       | $ ./davidguy
       | 
       | If your X server is not :0, change the last character of the
       | ".slo.-W00,tmhw.W/" string to be one less in ASCII to the display
       | number (ie 0 -> /, 1 -> 0, 2 -> 1, etc).
       | 
       | The main reason I added this comment was out of curiosity about
       | the technical competence/interestingness of the implementation.
        
       | eps wrote:
       | This is truly incredible.
        
         | [deleted]
        
       | [deleted]
        
       | Marazan wrote:
       | I'm blown away. I can't even begin to think how to encode GoL in
       | such a small program.
       | 
       | Jaw dropping.
        
       ___________________________________________________________________
       (page generated 2020-04-30 23:00 UTC)