Conway's Life | Powershell

Question

I have been working on creating a basic Conway's Game of Life simulator in Powershell to get more familiar with the language. But my current code is incorrectly counting # of neighboring cells, so the game is not working. I believe my wrapping is correct, from what I can tell, but something seems to be 'up' with my neighbor count.

Here is the code:

function next-gen{
    param([System.Array]$origM)

    $tmpM = $origM

    For($x=0; $x -lt $tmpM.GetUpperBound(0); $x++ ){
        For($y=0; $y -lt $tmpM.GetUpperBound(1); $y++){
            $neighborCount = getNeighbors $tmpM $x $y
            if($neighborCount -lt 2 -OR $neighborCount -gt 3){
                $tmpM[$x,$y] = 0
            }
            elseif($neighborCount -eq 3){
                $tmpM[$x, $y] = 1
            }
        } 
    }
    $Global:origM = $tmpM
}

function getNeighbors{
    param(
        [System.Array]$g,
        [Int]$x,
        [Int]$y
    )
    $newX=0
    $newY=0
    $count=0

    for($newX = -1; $newX -le 1; $newX++){
        for($newY = -1; $newY -le 1; $newY++){
            if($g[$(wrap $x $newX),$(wrap $y $newY)]){
                $count++
            }
        }
    }
    return $count
}

function wrap{
    param(
        [Int]$z,
        [Int]$zEdge
    )

    $z+=$zEdge
    If($z -lt 0){
        $z += $size
    }
    ElseIf($z -ge $size){
        $z -= $:size
    }
    return $z
}

function printBoard{
    0..$m.GetUpperBound(0) | 
    % { $dim1=$_; (0..$m.GetUpperBound(1) | % { $m[$dim1, $_] }) -join ' ' }
    write-host ""
}
#board is always a square, size represents both x and y
$size = 5

$m = New-Object 'int[,]' ($size, $size)
$m[2,1] = 1
$m[2,2] = 1
$m[2,3] = 1

clear
printBoard

For($x=0; $x -lt 1; $x++){
    next-gen $m
    printBoard
    write-host ""
}

With the board setup in the above demo, the result of should be a blinker:

Gen0

0 0 0 0 0
0 0 0 0 0
0 1 1 1 0
0 0 0 0 0
0 0 0 0 0

Gen1

0 0 0 0 0
0 0 1 0 0
0 0 1 0 0
0 0 1 0 0
0 0 0 0 0

For those unfamiliar, the rules can be found here: Wikipedia - Conway's Game of Life

Answer 1

I added some debugging code (with write-verbose), and found where the error(s) were.

First, you were checking neighbors in the $tmpm array (which was being updated) rather than the current generation). Second, you were setting $global:OrigM when you meant $Global:M at the end of then next-gen function, but it actually has to be $script:M, because the variable exists in the script scope, not the global one.

Also, getNeighbors mistakenly also considered the target position itself as a neighbor instead of just the 8 surrounding positions.

function next-gen{
    param([System.Array]$origM)
    $size=1+$origM.GetUpperBound(0) 
    $tmpM = New-Object 'int[,]' ($size, $size)

    For($x=0; $x -lt $size; $x++ ){
        For($y=0; $y -lt $size; $y++){
            $neighborCount = getNeighbors $origm $x $y
            if($neighborCount -lt 2 -OR $neighborCount -gt 3){
                $tmpM[$x,$y] = 0
                write-verbose "Clearing $x,$y"
            }
            elseif($neighborCount -eq 3 -or $OrigM[$x,$y] -eq 1){
                $tmpM[$x, $y] = 1
                write-verbose "Setting $x,$y"
            }
        } 
    }
     $script:M = $tmpM
}

function getNeighbors{
    param(
        [System.Array]$g,
        [Int]$x,
        [Int]$y
    )
    $newX=0
    $newY=0
    $count=0

    for($newX = -1; $newX -le 1; $newX++){
        for($newY = -1; $newY -le 1; $newY++){
            if($newX -ne 0 -or $newY -ne 0){
                $neighborx=wrap $x $newx
                $neighborY=wrap $y $newY
                write-verbose "x=$x y=$y Nx=$neighborx Ny=$neighborY"
                if($g[$neighborx,$neighborY] -eq 1){
                    write-verbose "Neighbor at $neighborx, $neighborY is Set!"
                    $count++
                }
            }
        }
    }
    write-verbose "x=$x y=$y Neighbor count = $count"
    return $count
}

function wrap{
    param(
        [Int]$z,
        [Int]$zEdge
    )

    $z+=$zEdge
    If($z -lt 0){
        $z += $size
    }
    ElseIf($z -ge $size){
        $z -= $size
    }
    return $z
}

function printBoard{
    0..$m.GetUpperBound(0) | 
    % { $dim1=$_; (0..$m.GetUpperBound(1) | % { $m[$dim1, $_] }) -join ' ' }
    write-host ""
}
#board is always a square, size represents both x and y
$size = 5

$m = New-Object 'int[,]' ($size, $size)
$m[2,1] = 1
$m[2,2] = 1
$m[2,3] = 1

clear
printBoard

For($x=0; $x -lt 1; $x++){
    next-gen $m
    printBoard
    write-host ""
}

P.S. Your bounds checking in the loops in next-gen were off by 1, and I made it start with a clean board rather than re-using the last gen (since you explicitly set each position, it doesn't really matter).

Answer 2

Mike Shepard's helpful answer already provides a working solution and an explanation of the problems with the code in the question.

Let me complement it with a refactored version that:

• updates the board variable in-place via a [ref] (by-reference) variable so that successive calls work as desired.

• has a flexible display function that allows specifying the number of generations to show, whether to update the display in-place, and how long to pause between generations.

  • If you run the code as-is, 5 generations are shown, updated in-place, pausing 1 sec. between generations.

• uses function names more in line with PowerShell's naming conventions.

• makes the code more robust, such as by:

  • avoiding the use of script-level (or global) variables altogether.
    • As an aside: global variables are session-global and stay in scope after a script exits; if "script-global" variables are needed, use the $script: scope; that script scope (not the global one) is the default for variables created without an explicit scope at the top level of your script.
  • using strongly typed [int[,]] parameters for the parameters receiving the board.
  • preventing references to uninitialized variables.

^{Note: A working implementation of the full game with interactive features can be found in this Gist; works in both Windows PowerShell v3+ and PowerShell Core.}

---

$ErrorActionPreference = 'Stop' # Abort on all unhandled errors.
Set-StrictMode -version 1 # Prevent use of uninitialized variables.

# Given a board as $m_ref, calculates the next generation and assigns it
# back to $m_ref.
function update-generation {
    param(
      [ref] [int[,]]$m_ref  # the by-reference board variable (matrix)
    )

    # Create a new, all-zero clone of the current board (matrix) to 
    # receive the new generation.
    $m_new = New-Object 'int[,]' ($m_ref.Value.GetLength(0), $m_ref.Value.GetLength(1))

    For($x=0; $x -le $m_new.GetUpperBound(0); $x++ ){
        For($y=0; $y -le $m_new.GetUpperBound(1); $y++){
            # Get the count of live neighbors.
            # Note that the *original* matrix must be used to:
            #  - determine the live neighbors
            #  - inspect the current state
            # because the game rules must be applied *simultaneously*.
            $neighborCount = get-LiveNeighborCount $m_ref.Value $x $y
            if ($m_ref.Value[$x,$y]) { # currently LIVE cell
              # A live cell with 2 or 3 neighbors lives, all others die.
              $m_new[$x,$y] = [int] ($neighborCount -eq 2 -or $neighborCount -eq 3)
            } else { # curently DEAD cell
              # A currently dead cell is resurrected if it has 3 live neighbors.
              $m_new[$x,$y] = [int] ($neighborCount -eq 3)
            }
            $null = $m_new[$x,$y]
        } 
    }

    # Assign the new generation to the by-reference board variable.
    $m_ref.Value = $m_new
}

# Get the count of live neighbors for board position $x, $y.
function get-LiveNeighborCount{
  param(
      [int[,]]$m, # the board (matrix)
      [Int]$x,
      [Int]$y
  )

  $xLength = $m.GetLength(0)
  $yLength = $m.GetLength(1)

  $count = 0
  for($xOffset = -1; $xOffset -le 1; $xOffset++) {
    for($yOffset = -1; $yOffset -le 1; $yOffset++) {
      if (-not ($xOffset -eq 0 -and $yOffset -eq 0)) { # skip the position at hand itself
        if($m[(get-wrappedIndex $xLength ($x + $xOffset)),(get-wrappedIndex $yLength ($y + $yOffset))]) {
          $count++
        }
      }
    }
  }
  # Output the count.
  $count
}

# Given a potentially out-of-bounds index along a dimension of a given length, 
# return the wrapped-around-the-edges value.
function get-wrappedIndex{
  param(
      [Int]$length,
      [Int]$index
  )

  If($index -lt 0){
    $index += $length
  }
  ElseIf($index -ge $length){
    $index -= $length
  }
  # Output the potentially wrapped index.
  $index
}

# Print a single generation's board.
function show-board {
  param(
    [int[,]] $m # the board (matrix)
  )
  0..$m.GetUpperBound(0) |
    ForEach-Object { 
      $dim1=$_
      (0..$m.GetUpperBound(1) | ForEach-Object { $m[$dim1, $_] }) -join ' ' 
    }
}

# Show successive generations.
function show-generations {

  param(
    [int[,]] $Board,
    [uint32] $Count = [uint32]::MaxValue,
    [switch] $InPlace,
    [int] $MilliSecsToPause
  )

  # Print the initial board (the 1st generation).
  Clear-Host
  show-board $Board

  # Print the specified number of generations or 
  # indefinitely, until Ctrl+C is pressed.
  [uint32] $i = 1
  while (++$i -le $Count -or $Count -eq [uint32]::MaxValue) {

    # Calculate the next generation.
    update-generation ([ref] $Board)

    if ($MilliSecsToPause) {
      Start-Sleep -Milliseconds $MilliSecsToPause
    }
    if ($InPlace) {
      Clear-Host
    } else {
      '' # Output empty line before new board is printed.
    }

    # Print this generation.
    show-board $Board

  } 

}

# Board is always a square, $size represents both x and y.
$size = 5
$board = New-Object 'int[,]' ($size, $size)

# Seed the board.
$board[2,1] = 1
$board[2,2] = 1
$board[2,3] = 1

# Determine how many generations to show and how to show them.
$htDisplayParams = @{
  Count = 5         # How many generations to show (1 means: just the initial state);
                    # omit this entry to keep going indefinitely.
  InPlace = $True   # Whether to print subsequent generations in-place.
  MilliSecsToPause = 1000 # To slow down updates.
}

# Start showing the generations.
show-generations -Board $board @htDisplayParams

Answer 3

WARNING: What are about to see is extremely hackish and... graphic in nature. No really, this code is sloppy even for a newbie so I apologize.

Here is the version that outputs in B/W to the console. It also randomly generates a # of seeds for you if you want. It isn't pretty and I'm at work so no time to spend on it currently :) hoping to github this weekend a version that is neat.

$ErrorActionPreference = 'Stop' # Abort on all unhandled errors.
Set-StrictMode -version 1 # Prevent use of uninitialized variables.

# Given a board as $m_ref, calculates the next generation and assigns it
# back to $m_ref.
function update-generation {
    param(
      [ref] [int[,]]$m_ref  # the by-reference board variable (matrix)
    )

    # Create a new, all-zero clone of the current board (matrix) to 
    # receive the new generation.
    $m_new = New-Object 'int[,]' ($m_ref.Value.GetLength(0), $m_ref.Value.GetLength(1))

    For($x=0; $x -le $m_new.GetUpperBound(0); $x++ ){
        For($y=0; $y -le $m_new.GetUpperBound(1); $y++){
            # Get the count of live neighbors.
            # Note that the *original* matrix must be used to:
            #  - determine the live neighbors
            #  - inspect the current state
            # because the game rules must be applied *simultaneously*.
            $neighborCount = get-LiveNeighborCount $m_ref.Value $x $y
            if ($m_ref.Value[$x,$y]) { # currently LIVE cell
              # A live cell with 2 or 3 neighbors lives, all others die.
              $m_new[$x,$y] = [int] ($neighborCount -eq 2 -or $neighborCount -eq 3)
            } else { # curently DEAD cell
              # A currently dead cell is resurrected if it has 3 live neighbors.
              $m_new[$x,$y] = [int] ($neighborCount -eq 3)
            }
            $null = $m_new[$x,$y]
        } 
    }

    # Assign the new generation to the by-reference board variable.
    $m_ref.Value = $m_new
}

# Get the count of live neighbors for board position $x, $y.
function get-LiveNeighborCount{
  param(
      [int[,]]$m, # the board (matrix)
      [Int]$x,
      [Int]$y
  )

  $xLength = $m.GetLength(0)
  $yLength = $m.GetLength(1)

  $count = 0
  for($xOffset = -1; $xOffset -le 1; $xOffset++) {
    for($yOffset = -1; $yOffset -le 1; $yOffset++) {
      if (-not ($xOffset -eq 0 -and $yOffset -eq 0)) { # skip the position at hand itself
        if($m[(get-wrappedIndex $xLength ($x + $xOffset)),(get-wrappedIndex $yLength ($y + $yOffset))]) {
          $count++
        }
      }
    }
  }
  # Output the count.
  $count
}

# Given a potentially out-of-bounds index along a dimension of a given length, 
# return the wrapped-around-the-edges value.
function get-wrappedIndex{
  param(
      [Int]$length,
      [Int]$index
  )

  If($index -lt 0){
    $index += $length
  }
  ElseIf($index -ge $length){
    $index -= $length
  }
  # Output the potentially wrapped index.
  $index
}

# Print a single generation's board.
function show-board {
  param(
    [int[,]] $m # the board (matrix)
  )
  0..$m.GetUpperBound(0) |
    ForEach-Object { 
      $dim1=$_
      (0..$m.GetUpperBound(1) | ForEach-Object { $m[$dim1, $_] }) -join ' ' 
    }
}

# Show successive generations.
function show-generations {

  param(
    [int[,]] $Board,
    [uint32] $Count = [uint32]::MaxValue,
    [switch] $InPlace,
    [int] $MilliSecsToPause
  )

  # Print the initial board (the 1st generation).


  Clear-Host
  #show-board $Board
  drawIt $Board
  # Print the specified number of generations or 
  # indefinitely, until Ctrl+C is pressed.
  [uint32] $i = 1
  while (++$i -le $Count -or $Count -eq [uint32]::MaxValue) {

    # Calculate the next generation.
    update-generation ([ref] $Board)

    if ($MilliSecsToPause) {
      Start-Sleep -Milliseconds $MilliSecsToPause
    }
    if ($InPlace) {
      Clear-Host
    } else {
      '' # Output empty line before new board is printed.
    }

    # Print this generation.
    #show-board $Board
    drawIt $Board
  } 

}

function drawIt{
    param([int[,]]$m_ref)


     For($x=0; $x -le $m_ref.GetUpperBound(0); $x++ ){
        For($y=0; $y -le $m_ref.GetUpperBound(1); $y++){
            $val = $m_ref[$x,$y]
           If($val -eq 1){
               $cellColor = 'White'
           }
           Else{
               $cellColor = 'Black'
           }
           #write-host $cellColor.GetType()
           Write-Host " " -NoNewline -BackgroundColor $CellColor
           Write-Host " " -NoNewline
        }
        Write-Host '' #start a new line
    }

}

# Board is always a square, $size represents both x and y.
$size = 10 #change this to change size of the board
$board = New-Object 'int[,]' ($size, $size)
$seedCount = 17 #change this to change # of alive cells to start with
# Seed the board.
for($seed = 0; $seed -lt $seedCount ; $seed ++){
    $board[$(Get-random -Maximum ($size -1)),$(Get-random -Maximum ($size -1))] = 1
}

# Determine how many generations to show and how to show them.
$htDisplayParams = @{
  Count = 25         # how many generations to show (1 means: just the initial state)
                    # omit this entry to keep going indefinitely
  InPlace = $True   # whether to print subsequent generations in-place
  MilliSecsToPause = 1000 # To slow down updates
}

# Start showing the generations.
show-generations -Board $board @htDisplayParams

Big thanks to mklement0 & Mike Shepard for taking their time to help and offer guidance and suggestions.