ConwaysGameOfLifeInGroovy/GameOfLifeScript.groovy at master · hofftodd/ConwaysGameOfLifeInGroovy · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
class GameOfLife {

	int generations
	int dimensions
	def board

	GameOfLife(generations = 5, dimensions = 5) {
		this.generations = generations
		this.dimensions = dimensions
		this.board = createBlinkerBoard()
	}

	static def createBlinkerBoard() {
		[
			[].withDefault{0},
			[0,0,1].withDefault{0},
			[0,0,1].withDefault{0},
			[0,0,1].withDefault{0}
		].withDefault{[]}
	}

	static def createGliderBoard() {
		[
			[].withDefault{0},
			[0,0,1].withDefault{0},
			[0,0,0,1].withDefault{0},
			[0,1,1,1].withDefault{0}
		].withDefault{[]}
	}

	static def getValue(board, point) {
		def x,y
		(x,y) = point
		if(x < 0 || y < 0) {
			return 0
		}
		board[x][y] ? 1 : 0
	}

	static def countNeighbors(board, point) {
		def x,y
		(x,y) = point
		def neighbors = 0
		neighbors += getValue(board, [x-1,y-1])
		neighbors += getValue(board, [x-1,y])
		neighbors += getValue(board, [x-1,y+1])
		neighbors += getValue(board, [x,y-1])
		neighbors += getValue(board, [x,y+1])
		neighbors += getValue(board, [x+1,y-1])
		neighbors += getValue(board, [x+1,y])
		neighbors += getValue(board, [x+1,y+1])
		neighbors
	}

	static def conwaysRule(currentValue, neighbors) {
		def newValue = 0
		if(neighbors == 3 || (currentValue && neighbors == 2)) {
			newValue = 1
		}
		newValue
	}

	static def createNextGeneration(currentBoard, dimensions) {
		def newBoard = [].withDefault{[].withDefault{0}}
		(0..(dimensions-1)).each { row ->
			(0..(dimensions-1)).each { column ->
				def point = [row, column]
				def currentValue = getValue(currentBoard, point)
				def neighbors = countNeighbors(currentBoard, point)
				newBoard[row][column] = conwaysRule(currentValue, neighbors)
			}
		}
		newBoard
	}

	static def printBoard(generationCount, board, dimensions) {
		println "Generation ${generationCount}"
		println '*' * 80
		(0..(dimensions-1)).each { row ->
			(0..(dimensions-1)).each { column ->
				print board[row][column] ? 'X' : '.'
			}
			print System.getProperty('line.separator')
		}
		println ''
	}

	def start() {
		(1..generations).each { generation ->
			printBoard(generation, this.board, this.dimensions)
			this.board = createNextGeneration(this.board, this.dimensions)
		}
	}

}

// Blinker
def game = new GameOfLife()
game.start()

// Glider
game = new GameOfLife(10, 10)
game.board = game.createGliderBoard()
game.start()