How to resolve the algorithm Conway's Game of Life step by step in the Tcl programming language

Published on 12 May 2024 09:40 PM
#Tcl

How to resolve the algorithm Conway's Game of Life step by step in the Tcl programming language

Table of Contents

Problem Statement

The Game of Life is a   cellular automaton   devised by the British mathematician   John Horton Conway   in 1970.   It is the best-known example of a cellular automaton. Conway's game of life is described   here: A cell   C   is represented by a   1   when alive,   or   0   when dead,   in an   m-by-m   (or m×m)   square array of cells. We calculate   N   - the sum of live cells in C's   eight-location neighbourhood,   then cell   C   is alive or dead in the next generation based on the following table: Assume cells beyond the boundary are always dead. The "game" is actually a zero-player game, meaning that its evolution is determined by its initial state, needing no input from human players.   One interacts with the Game of Life by creating an initial configuration and observing how it evolves.

Although you should test your implementation on more complex examples such as the   glider   in a larger universe,   show the action of the blinker   (three adjoining cells in a row all alive),   over three generations, in a 3 by 3 grid.

Let's start with the solution:

Step by Step solution about How to resolve the algorithm Conway's Game of Life step by step in the Tcl programming language

Source code in the tcl programming language

package require Tcl 8.5 

proc main {} {
    evolve 3 blinker [initialize_tableau {3 3} {{0 1} {1 1} {2 1}}]
    evolve 5 glider  [initialize_tableau {4 4} {{0 1} {1 2} {2 0} {2 1} {2 2}}]
}

proc evolve {generations name tableau} {
    for {set gen 1} {$gen <= $generations} {incr gen} {
        puts "$name generation $gen:"
        print $tableau
        set tableau [next_generation $tableau]
    }
    puts ""
}

proc initialize_tableau {size initial_life} {
    lassign $size ::max_x ::max_y 
    set tableau [blank_tableau]
    foreach point $initial_life {
        lset tableau {*}$point 1
    }
    return $tableau
}

proc blank_tableau {} {
    return [lrepeat $::max_x [lrepeat $::max_y 0]]
}

proc print {tableau} {
    foreach row $tableau {puts [string map {0 . 1 #} [join $row]]}
}

proc next_generation {tableau} {
    set new [blank_tableau]
    for {set x 0} {$x < $::max_x} {incr x} {
        for {set y 0} {$y < $::max_y} {incr y} {
            lset new $x $y [fate [list $x $y] $tableau]
        }
    }
    return $new
}

proc fate {point tableau} {
    set current [value $point $tableau]
    set neighbours [sum_neighbours $point $tableau]
    return [expr {($neighbours == 3) || ($neighbours == 2 && $current == 1)}]
}

proc value {point tableau} {
    return [lindex $tableau {*}$point]
}

proc sum_neighbours {point tableau} {
    set sum 0
    foreach neighbour [get_neighbours $point] {
        incr sum [value $neighbour $tableau]
    }
    return $sum
}

proc get_neighbours {point} {
    lassign $point x y
    set results [list]
    foreach x_off {-1 0 1} {
        foreach y_off {-1 0 1} {
            if { ! ($x_off == 0 && $y_off == 0)} {
                set i [expr {$x + $x_off}] 
                set j [expr {$y + $y_off}]
                if {(0 <= $i && $i < $::max_x) && (0 <= $j && $j < $::max_y)} {
                    lappend results [list $i $j]
                }
            }
        }
    }
    return $results
}

main

You may also check:How to resolve the algorithm Probabilistic choice step by step in the Nim programming language
You may also check:How to resolve the algorithm Mutual recursion step by step in the Wren programming language
You may also check:How to resolve the algorithm Roman numerals/Decode step by step in the Euphoria programming language
You may also check:How to resolve the algorithm Functional coverage tree step by step in the Wren programming language
You may also check:How to resolve the algorithm Polynomial regression step by step in the zkl programming language