https://github.com/akkartik/mu/blob/main/life.mu

      1 # Conway's Game of Life
      2 #
      3 # To build:
      4 #   $ ./translate life.mu
      5 # To run:
      6 #   $ qemu-system-i386 code.img
      7
      8 fn state _grid: (addr array boolean), x: int, y: int -> _/eax: boolean {
      9   # clip at the edge
     10   compare x, 0
     11   {
     12     break-if->=
     13     return 0/false
     14   }
     15   compare y, 0
     16   {
     17     break-if->=
     18     return 0/false
     19   }
     20   compare x, 0x100/width
     21   {
     22     break-if-<
     23     return 0/false
     24   }
     25   compare y, 0xc0/height
     26   {
     27     break-if-<
     28     return 0/false
     29   }
     30   var idx/eax: int <- copy y
     31   idx <- shift-left 8/log2width
     32   idx <- add x
     33   var grid/esi: (addr array boolean) <- copy _grid
     34   var result/eax: (addr boolean) <- index grid, idx
     35   return *result
     36 }
     37
     38 fn set-state _grid: (addr array boolean), x: int, y: int, val: boolean {
     39   # don't bother checking bounds
     40   var idx/eax: int <- copy y
     41   idx <- shift-left 8/log2width
     42   idx <- add x
     43   var grid/esi: (addr array boolean) <- copy _grid
     44   var result/eax: (addr boolean) <- index grid, idx
     45   var src/ecx: boolean <- copy val
     46   copy-to *result, src
     47 }
     48
     49 fn num-live-neighbors grid: (addr array boolean), x: int, y: int -> _/eax: int {
     50   var result/edi: int <- copy 0
     51   # row above: zig
     52   decrement y
     53   decrement x
     54   var s/eax: boolean <- state grid, x, y
     55   {
     56     compare s, 0/false
     57     break-if-=
     58     result <- increment
     59   }
     60   increment x
     61   s <- state grid, x, y
     62   {
     63     compare s, 0/false
     64     break-if-=
     65     result <- increment
     66   }
     67   increment x
     68   s <- state grid, x, y
     69   {
     70     compare s, 0/false
     71     break-if-=
     72     result <- increment
     73   }
     74   # curr row: zag
     75   increment y
     76   s <- state grid, x, y
     77   {
     78     compare s, 0/false
     79     break-if-=
     80     result <- increment
     81   }
     82   subtract-from x, 2
     83   s <- state grid, x, y
     84   {
     85     compare s, 0/false
     86     break-if-=
     87     result <- increment
     88   }
     89   # row below: zig
     90   increment y
     91   s <- state grid, x, y
     92   {
     93     compare s, 0/false
     94     break-if-=
     95     result <- increment
     96   }
     97   increment x
     98   s <- state grid, x, y
     99   {
    100     compare s, 0/false
    101     break-if-=
    102     result <- increment
    103   }
    104   increment x
    105   s <- state grid, x, y
    106   {
    107     compare s, 0/false
    108     break-if-=
    109     result <- increment
    110   }
    111   return result
    112 }
    113
    114 fn step old-grid: (addr array boolean), new-grid: (addr array boolean) {
    115   var y/ecx: int <- copy 0
    116   {
    117     compare y, 0xc0/height
    118     break-if->=
    119     var x/edx: int <- copy 0
    120     {
    121       compare x, 0x100/width
    122       break-if->=
    123       var n/eax: int <- num-live-neighbors old-grid, x, y
    124       # if neighbors < 2, die of loneliness
    125       {
    126         compare n, 2
    127         break-if->=
    128         set-state new-grid, x, y, 0/dead
    129       }
    130       # if neighbors > 3, die of overcrowding
    131       {
    132         compare n, 3
    133         break-if-<=
    134         set-state new-grid, x, y, 0/dead
    135       }
    136       # if neighbors = 2, preserve state
    137       {
    138         compare n, 2
    139         break-if-!=
    140         var old-state/eax: boolean <- state old-grid, x, y
    141         set-state new-grid, x, y, old-state
    142       }
    143       # if neighbors = 3, cell quickens to life
    144       {
    145         compare n, 3
    146         break-if-!=
    147         set-state new-grid, x, y, 1/live
    148       }
    149       x <- increment
    150       loop
    151     }
    152     y <- increment
    153     loop
    154   }
    155 }
    156
    157 # color a square of size 'side' starting at x*side, y*side
    158 fn render-square _x: int, _y: int, color: int {
    159   var y/edx: int <- copy _y
    160   y <- shift-left 2/log2side
    161   var side/ebx: int <- copy 1
    162   side <- shift-left 2/log2side
    163   var ymax/ecx: int <- copy y
    164   ymax <- add side
    165   {
    166     compare y, ymax
    167     break-if->=
    168     {
    169       var x/eax: int <- copy _x
    170       x <- shift-left 2/log2side
    171       var xmax/ecx: int <- copy x
    172       xmax <- add side
    173       {
    174         compare x, xmax
    175         break-if->=
    176         pixel-on-real-screen x, y, color
    177         x <- increment
    178         loop
    179       }
    180     }
    181     y <- increment
    182     loop
    183   }
    184 }
    185
    186 fn render grid: (addr array boolean) {
    187   var y/ecx: int <- copy 0
    188   {
    189     compare y, 0xc0/height
    190     break-if->=
    191     var x/edx: int <- copy 0
    192     {
    193       compare x, 0x100/width
    194       break-if->=
    195       var state/eax: boolean <- state grid, x, y
    196       compare state, 0/false
    197       {
    198         break-if-=
    199         render-square x, y, 3/cyan
    200       }
    201       compare state, 0/false
    202       {
    203         break-if-!=
    204         render-square x, y, 0/black
    205       }
    206       x <- increment
    207       loop
    208     }
    209     y <- increment
    210     loop
    211   }
    212 }
    213
    214 fn main screen: (addr screen), keyboard: (addr keyboard), data-disk: (addr disk) {
    215 #?   # allocate on the stack
    216 #?   var grid1-storage: (array boolean 0xc000)  # width * height
    217 #?   var grid1/esi: (addr array boolean) <- address grid1-storage
    218 #?   var grid2-storage: (array boolean 0xc000)  # width * height
    219 #?   var grid2/edi: (addr array boolean) <- address grid2-storage
    220   # allocate on the heap
    221   var grid1-storage: (handle array boolean)
    222   var grid1-ah/eax: (addr handle array boolean) <- address grid1-storage
    223   populate grid1-ah, 0xc000  # width * height
    224   var _grid1/eax: (addr array boolean) <- lookup *grid1-ah
    225   var grid1/esi: (addr array boolean) <- copy _grid1
    226   var grid2-storage: (handle array boolean)
    227   var grid2-ah/eax: (addr handle array boolean) <- address grid2-storage
    228   populate grid2-ah, 0xc000  # width * height
    229   var _grid2/eax: (addr array boolean) <- lookup *grid2-ah
    230   var grid2/edi: (addr array boolean) <- copy _grid2
    231   # initialize grid1
    232   set-state grid1, 0x80, 0x5f, 1/live
    233   set-state grid1, 0x81, 0x5f, 1/live
    234   set-state grid1, 0x7f, 0x60, 1/live
    235   set-state grid1, 0x80, 0x60, 1/live
    236   set-state grid1, 0x80, 0x61, 1/live
    237   # render grid1
    238   render grid1
    239   {
    240     var key/eax: byte <- read-key keyboard
    241     compare key, 0
    242 #?     loop-if-=  # press key to step
    243     break-if-!=  # press key to quit  # comment this out to run under bochs; I'm not sure why there's a newline in the keyboard buffer
    244     # iter: grid1 -> grid2
    245     step grid1, grid2
    246     render grid2
    247     # iter: grid2 -> grid1
    248     step grid2, grid1
    249     render grid1
    250     loop
    251   }
    252 }