I decided to implement this in F#. With all the code involving the user interface, it was nearly 300 lines of code. Pretty neat!<\/p>\n
\n![](\"\/blog\/wp-content\/uploads\/2008\/05\/gameoflife.png\")
<\/p>\n
Using the game<\/h3>\n
The life’s arena can take several sizes:<\/p>\n
- \n
- Tiny: 15 x 10<\/li>\n
- Small: 30 x 20<\/li>\n
- Medium: 60 x 40<\/li>\n
- Large: 120 x 80<\/li>\n
- Huge: 150 x 100<\/li>\n<\/ul>\n
The size can be changed from the Game > Size menu.<\/p>\n
The following commands are available from the menu:<\/p>\n
- \n
- Reset (Ctrl + R): Resets the game, all cells die<\/li>\n
- Randomize (Ctrl + G): Randomly initialize alive cells<\/li>\n
- Start\/Stop (Ctrl + B): Starts or stops continuos creation of new generations<\/li>\n
- Step (Ctrl + N): Creates a new generation of cells<\/li>\n<\/ul>\n
In addition the followin commands are available from the File menu:<\/p>\n
- \n
- Save (Ctrl + S): saves game to a bitmap file called gameolife_
.bmp; this file is created in the working folder<\/li>\n - Save As… (Ctrl + Shift + S): saves the game to a file, giving you the possibility to chose the location and format (bmp, jpg, gif and png)<\/li>\n<\/ul>\n
Note<\/strong>: The state of the game can be changed (killing cells, making others alive) simply by clicking with the mouse on the game panel.<\/p>\n
Implementation in F#<\/h3>\n
Some comments on the implementation of the game. For more have a look at the code.<\/p>\n
I defined two records, one called Cell and one called World. The cell reprezents a cell and has a flag called Alive (which is self explanatory), and World represents the ‘arena of life’, containing a matrix of Cells.<\/p>\n
\r\ntype Cell =\r\n { Alive : bool;}\r\n\r\ntype World =\r\n { Width : int;\r\n Height : int;\r\n Cells: Cell[,];}\r\n<\/pre>\nVarious arena sizes are defined in a descriminated union and the mapping between that and values for width and height are done in this function:<\/p>\n
\r\ntype GameSize =\r\n | Tiny\r\n | Small\r\n | Medium\r\n | Large\r\n | Huge\r\n\r\nlet sizeMapping (size:GameSize) = \r\n match size with\r\n | Tiny -> (15,10)\r\n | Small -> (30, 20)\r\n | Medium -> (60, 40)\r\n | Large -> (120, 80)\r\n | Huge -> (150, 100)\r\n<\/pre>\n
A next generation of cells is computed based on the rules of the game. For each cell the number of alived neighbors is computed and then the state of the cell is changes (if necessary).<\/p>\n
\r\nlet nextGeneration (world:World) =\r\n let alive = {new Cell with Alive = true}\r\n let dead = {new Cell with Alive = false}\r\n let newcells = Array2.create world.Width world.Height dead\r\n for i = 0 to world.Width - 1 do\r\n for j = 0 to world.Height - 1 do\r\n let ncount = neighbors world j i\r\n match world.Cells.(i,j).Alive with\r\n | true -> if ncount = 2 || ncount = 3 then newcells.(i,j) <- alive\r\n else newcells.(i,j) <- dead\r\n | _ -> if ncount = 3 then newcells.(i,j) <- alive\r\n else newcells.(i,j) <- dead\r\n done\r\n done\r\n { world with Cells = newcells}\r\n<\/pre>\nFor computing the number of neighbors, I considered 9 cases:<\/p>\n
- \n
- cell is one of the four corners<\/li>\n
- cell is on one of the four edges (not a corner)<\/li>\n
- cell is anywhere else in the matrix<\/li>\n<\/ul>\n
Depending on this position a list of neighbors is created and folded to compute the number of alive neighboring cells.<\/p>\n
\r\nlet sum (neighbors:Cell list) =\r\n neighbors |> List.fold_left (fun sum x -> if x.Alive then sum+1 else sum) 0\r\n\r\nlet neighbors (world:World) row col =\r\n match row, col with\r\n | _,_ when row = 0 && col = 0 -> sum [world.Cells.(1,0);world.Cells.(1,1);world.Cells.(0,1)]\r\n | _,_ when row = 0 && col = world.Width-1 -> sum [world.Cells.(world.Width-2,0);world.Cells.(world.Width-2,1);world.Cells.(world.Width-1,1)]\r\n | _,_ when row = world.Height-1 && col = 0 -> sum [world.Cells.(0, world.Height-2);world.Cells.(1, world.Height-2);world.Cells.(1,world.Height-1)]\r\n | _,_ when row = world.Height-1 && col = world.Width-1 -> sum [world.Cells.(world.Width-1, world.Height-2);world.Cells.(world.Width-2, world.Height-2);world.Cells.(world.Width-2,world.Height-1)]\r\n | _,_ when row = 0 && col > 0 && col < world.Width-1 -> sum [world.Cells.(col-1,0);world.Cells.(col-1,1);world.Cells.(col,1);world.Cells.(col+1,1);world.Cells.(col+1,0);]\r\n | _,_ when row = world.Height-1 && col > 0 && col < world.Width-1 -> sum [world.Cells.(col-1,row);world.Cells.(col-1,row-1);world.Cells.(col,row-1);world.Cells.(col+1,row-1);world.Cells.(col+1,row);]\r\n | _,_ when col = 0 && row > 0 && row < world.Height-1 -> sum [world.Cells.(0,row-1);world.Cells.(1,row-1);world.Cells.(1,row);world.Cells.(1,row+1);world.Cells.(0,row+1);]\r\n | _,_ when col = world.Width-1 && row > 0 && row < world.Height-1 -> sum [world.Cells.(col,row-1);world.Cells.(col-1,row-1);world.Cells.(col-1,row);world.Cells.(col-1,row+1);world.Cells.(col,row+1);]\r\n | _,_ -> sum [world.Cells.(col-1,row-1);world.Cells.(col,row-1);world.Cells.(col+1,row-1);world.Cells.(col+1,row);world.Cells.(col+1,row+1);world.Cells.(col,row+1);world.Cells.(col-1,row+1);world.Cells.(col-1,row);]\r\n<\/pre>\n
The rest is basically user interface code. But I made a parallel version of the game, when then computation of the next generation of cells is parallelized with the Parallel FX framework. Here is how the function looks.<\/p>\n
\r\nlet nextGeneration (world:World) =\r\n let alive = {new Cell with Alive = true}\r\n let dead = {new Cell with Alive = false}\r\n let newcells = Array2.create world.Width world.Height dead\r\n Parallel.For(0, world.Width, (fun i ->\r\n for j = 0 to world.Height - 1 do\r\n let ncount = neighbors world j i\r\n match world.Cells.(i,j).Alive with\r\n | true -> if ncount = 2 || ncount = 3 then newcells.(i,j) <- alive\r\n else newcells.(i,j) <- dead\r\n | _ -> if ncount = 3 then newcells.(i,j) <- alive\r\n else newcells.(i,j) <- dead\r\n done\r\n ))\r\n { world with Cells = newcells}\r\n<\/pre>\nSource code<\/h3>\n
Here are the available downloads<\/p>\n
- \n
- un-parallelized version, GameOfLife.zip<\/a><\/li>\n
- parallelized version, GameOfLife.Parallel.zip<\/a><\/li>\n<\/ul>\n
<\/p>\n","protected":false},"excerpt":{"rendered":"
The Game of Life is a cellular automaton devised by the John Horton Conway in 1970. It is the best-known example of a cellular automaton. It consists of a collection of cells which, based on a few mathematical rules, can live, die or multiply. Depending on the initial conditions, the cells form various patterns throughout … Read more<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_uag_custom_page_level_css":"","advgb_blocks_editor_width":"","advgb_blocks_columns_visual_guide":"","_jetpack_newsletter_access":"","_jetpack_dont_email_post_to_subs":false,"_jetpack_newsletter_tier_id":0,"_jetpack_memberships_contains_paywalled_content":false,"_jetpack_feature_clip_id":0,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":false,"jetpack_social_options":{"image_generator_settings":{"template":"highway","default_image_id":0,"font":"","enabled":false},"version":2},"jetpack_post_was_ever_published":false},"categories":[37],"tags":[51,50,49,47],"class_list":["post-123","post","type-post","status-publish","format-standard","hentry","category-fsharp","tag-automata","tag-f","tag-gameoflife","tag-parallel"],"aioseo_notices":[],"aioseo_head":"\n\t\t\n\t\n\t\n\t\n\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t\n\t\t
- parallelized version, GameOfLife.Parallel.zip<\/a><\/li>\n<\/ul>\n
- un-parallelized version, GameOfLife.zip<\/a><\/li>\n
- Save As… (Ctrl + Shift + S): saves the game to a file, giving you the possibility to chose the location and format (bmp, jpg, gif and png)<\/li>\n<\/ul>\n
- Save (Ctrl + S): saves game to a bitmap file called gameolife_