read board initialization from file and add some examples

Author: CozyDoomer

app/Main.hs

@@ -1,7 +1,9 @@
 module Main where
 
 import Lib
-import System.Posix.Unistd
+import Control.Concurrent
+
+import Data.Array
 
 {-
  clear screen
@@ -10,14 +12,15 @@ import System.Posix.Unistd
  recursive call with updated board
 -}
 gameOfLife :: Board -> IO ()
-gameOfLife b =  if not $ isBoardEmpty b then
-                    do clearScreen
-                       displayBoard b
-                       usleep 500000
-                       gameOfLife $ updateBoard b
-                else
-                    do clearScreen
-                       putStr "Done.\n"
+gameOfLife b = if not $ isBoardEmpty b then
+                  do clearScreen
+                     displayBoard b
+                     threadDelay 500000
+                     gameOfLife $ updateBoard b
+               else
+                  do clearScreen
+                     putStr "Done.\n"
 
 main :: IO()
-main = gameOfLife rpentominoPredecessor
+main = do board <- createBoard "examples/blinker_block.txt"
+          gameOfLife board

examples/blinker_block.txt

@@ -0,0 +1,10 @@
+          
+          
+          
+  OOO     
+          
+          
+     OO   
+     OO   
+          
+          

examples/rpentomino_predecessor.txt

@@ -0,0 +1,30 @@
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+            O                 
+                              
+        OOO OO                
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              
+                              

package.yaml

@@ -1,5 +1,5 @@
 name:                game-of-life
-version:             0.1.1.0
+version:             0.2.1.0
 github:              "cozyDoomer/game-of-life-haskell"
 license:             "GPLv3"
 author:              "Christian Unterrainer"
@@ -15,7 +15,7 @@ description:         Please see the README on GitHub at https://github.com/cozyD
 dependencies:
 - base >= 4.7 && < 5
 - array
-- unix
+- polyparse
 
 library:
   source-dirs: src

src/Lib.hs

@@ -2,38 +2,30 @@ module Lib where
 
 import Data.Array
 
-width :: Int
-width = 20
-
-height :: Int
-height = 20
-
 -- Board type using Data.Array with custom Show typeclass
 newtype Board = B (Array (Int, Int) String)
 
 instance Show Board where
     show (B b) = showRows b 0
 
+unpack :: Board -> Array (Int, Int) String
+unpack (B b) = b
+
 showRows :: Array (Int, Int) String -> Int -> String
-showRows r i
-                                          -- tail recursion
+showRows r i                              -- tail recursion
     | i < maxRow = "|" ++ rowStr ++ "|\n" ++ showRows r (i+1)
     |  otherwise = "|" ++ rowStr ++ "|\n"
     where maxRow = fst . snd $ bounds r
           maxCol = snd . snd $ bounds r
           rowStr = concat [ r ! (i, j) ++ " " | j <- [0 .. maxCol] ]
 
-unpack :: Board -> Array (Int, Int) String
-unpack (B b) = b
-
--- example boards
-rpentominoPredecessor :: Board
-rpentominoPredecessor = B (listArray ((0, 0), (width-1, height-1)) [ if i `elem` alive then "O" else " " | i <- [0..width*height] ])
-    where alive = [207, 208, 209, 191, 211, 212]
-
-blinkerAndBlock :: Board
-blinkerAndBlock = B (listArray ((0, 0), (width-1, height-1)) [ if i `elem` alive then "O" else " " | i <- [0..width*height] ])
-    where alive = [204, 205, 206, 232, 233, 252, 253]
+createBoard :: String -> IO Board
+createBoard s = do fileString <- readFile s
+                   -- TODO: read line wise
+                   let height = (length $ filter (== '\n') fileString) + 1
+                   let fileList = fmap (\x -> [x]) (filter (/= '\n') fileString)
+                   let width = length fileList `div` height
+                   pure $ B (listArray ((0, 0), (width-1, height-1)) fileList)
 
 -- command line related
 clearScreen :: IO ()
@@ -44,15 +36,17 @@ displayBoard b = putStr $ show b
 
 -- count living neighbors; when out of bounds continue on the other side of the board
 countNeighbors :: (Int, Int) -> Board -> Int
-countNeighbors p b = length . filter (== "O") . map (\i -> boardArray ! i) $ map handleOverflow neighborIndices
+countNeighbors p b = length . filter (== "O") . map (\i -> boardArray ! i) $ map (handleOverflow (width, height)) neighborIndices
     where boardArray = unpack b
+          width = fst . snd $ bounds boardArray
+          height = snd . snd $ bounds boardArray
           neighborIndices = [ (i, j) | i <- [fst p + 1, fst p, fst p - 1],
                                        j <- [snd p + 1, snd p, snd p - 1],
                                        i /= fst p || j /= snd p]
 
-handleOverflow :: (Int, Int) -> (Int, Int)
-handleOverflow (i,j) = (i `mod` width,
-                        j `mod` height)
+handleOverflow :: (Int, Int) -> (Int, Int) -> (Int, Int)
+handleOverflow (width, height) (i,j) = (i `mod` width,
+                                        j `mod` height)
 
 -- game of life logic for each cell: https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life#Rules
 nextCellValue :: (Int, Int) -> Board -> String
@@ -63,7 +57,6 @@ nextCellValue (i,j) b
     where boardArray = unpack b
           neighborCount = countNeighbors (i, j) b
 
--- 
 updateBoard :: Board -> Board
 updateBoard b = B (boardArray // [(i, nextCellValue i b) | i <- indices boardArray])
     where boardArray = unpack b