Merge branch 'main' of github.com:TLINDEN/gameoflife

Makefile

@@ -1,5 +1,8 @@
-.PHONY: all
+.PHONY all:
-all:
+all: build
+
+.PHONY: build
+build:
 	make -C src
 	mv src/golsky .
 
@@ -7,3 +10,8 @@ all:
 clean:
 	make -C src clean
 	rm -f dump* rect*
+
+.PHONY: profile
+profile: build
+	./golsky -W 1500 -H 1500 -d --profile-file cpu.profile
+	go tool pprof --http localhost:8888 golsky cpu.profile

README.md

@@ -82,17 +82,16 @@ Usage of ./golsky:
 
 While it runs, there are a couple of commands you can use:
 
-* left mouse click: set a cell to alife (also pauses the game)
+
-* right mouse click: set a cell to dead
 * space: pause or resume the game
 * while game is paused: press n to forward one step
 * page up: speed up
 * page down: slow down
 * Mouse wheel: zoom in or out
 * move mouse while left mouse button pressed: move canvas
-* i: enter "insert" (draw) mode: use left mouse to set cells alife and right
+* i: enter "insert" (draw) mode: use left mouse to toggle cells alife state.
-  button to dead. Leave with "space". While in insert mode, use middle mouse
+  Leave with insert mode "space". While in insert mode, use middle mouse
-  button to drag grid.
+  button to drag the grid.
 * r: reset to 1:1 zoom
 * escape: open menu
 * s: save game state to file (can be loaded with -l)

rle/rle.go

@@ -120,7 +120,7 @@ func removeWhitespace(input string) string {
 }
 
 // Store a grid to an RLE file
-func StoreGridToRLE(grid [][]bool, filename, rule string, width, height int) error {
+func StoreGridToRLE(grid [][]uint8, filename, rule string, width, height int) error {
 	fd, err := os.Create(filename)
 	if err != nil {
 		return err
@@ -132,7 +132,7 @@ func StoreGridToRLE(grid [][]bool, filename, rule string, width, height int) err
 		line := ""
 		for x := 0; x < width; x++ {
 			char := "b"
-			if grid[y][x] {
+			if grid[y][x] == 1 {
 				char = "o"
 			}
 

src/config.go

@@ -43,16 +43,16 @@ type Config struct {
 }
 
 const (
-	VERSION = "v0.0.8"
+	VERSION = "v0.0.9"
-	Alive   = true
+	Alive   = 1
-	Dead    = false
+	Dead    = 0
 
 	DEFAULT_GRID_WIDTH  = 600
 	DEFAULT_GRID_HEIGHT = 400
 	DEFAULT_CELLSIZE    = 4
 	DEFAULT_ZOOMFACTOR  = 400
 	DEFAULT_GEOM        = "640x384"
-	DEFAULT_THEME       = "standard" // "light" // inverse => "dark"
+	DEFAULT_THEME       = "standard"
 )
 
 const KEYBINDINGS string = `
@@ -62,9 +62,9 @@ const KEYBINDINGS string = `
 - PAGE DOWN: slow down
 - MOUSE WHEEL: zoom in or out
 - LEFT MOUSE BUTTON: use to drag canvas, keep clicked and move mouse
-- I: enter "insert" (draw) mode: use left mouse to set cells alife and right
+- I: enter "insert" (draw) mode: use left mouse to toggle a cells alife state.
-     button to dead. Leave with "space". While in insert mode, use middle mouse
+     Leave with insert mode with "space". While in insert mode, use middle mouse
-     button to drag grid.
+     button to drag the grid.
 - R: reset to 1:1 zoom
 - ESCAPE: open menu, o: open options menu
 - S: save game state to file (can be loaded with -l)

src/grid.go

@@ -12,65 +12,207 @@ import (
 	"github.com/tlinden/golsky/rle"
 )
 
+// equals grid height, is being used to access grid elements and must be global
+var STRIDE int
+
+type Neighbor struct {
+	X, Y int
+}
+
 type Grid struct {
-	Data                   [][]bool
+	Data          []uint8
-	Width, Height, Density int
+	NeighborCount []int
+	Neighbors     [][]Neighbor
 	Empty         bool
+	Config        *Config
+	Counter       func(x, y int) uint8
 }
 
 // Create new empty grid and allocate Data according to provided dimensions
-func NewGrid(width, height, density int, empty bool) *Grid {
+func NewGrid(config *Config) *Grid {
-	grid := &Grid{
+	STRIDE = config.Height
-		Height:  height,
+	if config.Width > config.Height {
-		Width:   width,
+		STRIDE = config.Width
-		Density: density,
-		Data:    make([][]bool, height),
-		Empty:   empty,
 	}
 
-	for y := 0; y < height; y++ {
+	size := STRIDE * STRIDE
-		grid.Data[y] = make([]bool, width)
+
+	grid := &Grid{
+		Data:          make([]uint8, size),
+		NeighborCount: make([]int, size),
+		Neighbors:     make([][]Neighbor, size),
+		Empty:         config.Empty,
+		Config:        config,
+	}
+
+	// first setup the cells
+	for y := 0; y < config.Height; y++ {
+		for x := 0; x < config.Width; x++ {
+			grid.Data[y+STRIDE*x] = 0
+		}
+	}
+
+	// in a second pass, collect positions to the neighbors of each cell
+	for y := 0; y < config.Height; y++ {
+		for x := 0; x < config.Width; x++ {
+			grid.SetupNeighbors(x, y)
+		}
+	}
+
+	if grid.Config.Wrap {
+		grid.Counter = grid.CountNeighborsWrap
+	} else {
+		grid.Counter = grid.CountNeighbors
 	}
 
 	return grid
 }
 
+func (grid *Grid) SetupNeighbors(x, y int) {
+	idx := 0
+
+	var neighbors []Neighbor
+
+	for nbgY := -1; nbgY < 2; nbgY++ {
+		for nbgX := -1; nbgX < 2; nbgX++ {
+			var col, row int
+
+			if grid.Config.Wrap {
+				// In wrap mode we look at all the 8 neighbors surrounding us.
+				// In case we are on an edge we'll look at the neighbor on the
+				//  other side  of the  grid, thus  wrapping lookahead  around
+				// using the mod() function.
+				col = (x + nbgX + grid.Config.Width) % grid.Config.Width
+				row = (y + nbgY + grid.Config.Height) % grid.Config.Height
+
+			} else {
+				// In traditional grid mode the edges are deadly
+				if x+nbgX < 0 || x+nbgX >= grid.Config.Width || y+nbgY < 0 || y+nbgY >= grid.Config.Height {
+					continue
+				}
+
+				col = x + nbgX
+				row = y + nbgY
+			}
+
+			if col == x && row == y {
+				continue
+			}
+
+			neighbors = append(neighbors, Neighbor{X: col, Y: row})
+			grid.NeighborCount[y+STRIDE*x]++
+			idx++
+		}
+	}
+
+	grid.Neighbors[y+STRIDE*x] = neighbors
+}
+
+func (grid *Grid) CountNeighborsWrap(x, y int) uint8 {
+	var sum uint8
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			// In wrap mode we look at all the 8 neighbors surrounding us.
+			// In case we are on an edge we'll look at the neighbor on the
+			//  other side  of the  grid, thus  wrapping lookahead  around
+			// using the mod() function.
+			col = (x + nbgX + grid.Config.Width) % grid.Config.Width
+			row = (y + nbgY + grid.Config.Height) % grid.Config.Height
+
+			sum += grid.Data[row+STRIDE*col]
+		}
+	}
+
+	// don't count ourselfes though
+	sum -= grid.Data[y+STRIDE*x]
+
+	return sum
+}
+
+func (grid *Grid) CountNeighbors(x, y int) uint8 {
+	var sum uint8
+
+	width := grid.Config.Width
+	height := grid.Config.Height
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			xnbgX := x + nbgX
+			ynbgY := y + nbgY
+
+			// In traditional grid mode the edges are deadly
+			if xnbgX < 0 || xnbgX >= width || ynbgY < 0 || ynbgY >= height {
+				continue
+			}
+			col = xnbgX
+			row = ynbgY
+
+			sum += grid.Data[row+STRIDE*col]
+		}
+	}
+
+	// don't count ourselfes though
+	sum -= grid.Data[y+STRIDE*x]
+
+	return sum
+}
+
+// count the living neighbors of a cell
+func (grid *Grid) _CountNeighbors(x, y int) uint8 {
+	var count uint8
+
+	pos := y + STRIDE*x
+	neighbors := grid.Neighbors[pos]
+	neighborCount := grid.NeighborCount[pos]
+
+	for idx := 0; idx < neighborCount; idx++ {
+		neighbor := neighbors[idx]
+		count += grid.Data[neighbor.Y+STRIDE*neighbor.X]
+	}
+
+	return count
+}
+
 // Create a new 1:1 instance
 func (grid *Grid) Clone() *Grid {
 	newgrid := &Grid{}
 
-	newgrid.Width = grid.Width
+	newgrid.Config = grid.Config
-	newgrid.Height = grid.Height
 	newgrid.Data = grid.Data
 
 	return newgrid
 }
 
 // copy data
-func (grid *Grid) Copy(other *Grid) {
+// func (grid *Grid) Copy(other *Grid) {
-	for y := range grid.Data {
+// 	for y := range grid.Data {
-		for x := range grid.Data[y] {
+// 		for x := range grid.Data[y] {
-			other.Data[y][x] = grid.Data[y][x]
+// 			other.Data[y+STRIDE*x] = grid.Data[y+STRIDE*x]
-		}
+// 		}
-	}
+// 	}
-}
+// }
 
 // delete all contents
-func (grid *Grid) Clear() {
+// func (grid *Grid) Clear() {
-	for y := range grid.Data {
+// 	for y := range grid.Data {
-		for x := range grid.Data[y] {
+// 		for x := range grid.Data[y] {
-			grid.Data[y][x] = false
+// 			grid.Data[y+STRIDE*x] = 0
-		}
+// 		}
-	}
+// 	}
-}
+// }
 
 // initialize with random life cells using the given density
 func (grid *Grid) FillRandom() {
 	if !grid.Empty {
-		for y := range grid.Data {
+		for y := 0; y < grid.Config.Height; y++ {
-			for x := range grid.Data[y] {
+			for x := 0; x < grid.Config.Width; x++ {
-				if rand.Intn(grid.Density) == 1 {
+				if rand.Intn(grid.Config.Density) == 1 {
-					grid.Data[y][x] = true
+					grid.Data[y+STRIDE*x] = 1
 				}
 			}
 		}
@@ -78,9 +220,9 @@ func (grid *Grid) FillRandom() {
 }
 
 func (grid *Grid) Dump() {
-	for y := 0; y < grid.Height; y++ {
+	for y := 0; y < grid.Config.Height; y++ {
-		for x := 0; x < grid.Width; x++ {
+		for x := 0; x < grid.Config.Width; x++ {
-			if grid.Data[y][x] {
+			if grid.Data[y+STRIDE*x] == 1 {
 				fmt.Print("XX")
 			} else {
 				fmt.Print("  ")
@@ -93,8 +235,8 @@ func (grid *Grid) Dump() {
 // initialize using a given RLE pattern
 func (grid *Grid) LoadRLE(pattern *rle.RLE) {
 	if pattern != nil {
-		startX := (grid.Width / 2) - (pattern.Width / 2)
+		startX := (grid.Config.Width / 2) - (pattern.Width / 2)
-		startY := (grid.Height / 2) - (pattern.Height / 2)
+		startY := (grid.Config.Height / 2) - (pattern.Height / 2)
 		var y, x int
 
 		for rowIndex, patternRow := range pattern.Pattern {
@@ -103,7 +245,7 @@ func (grid *Grid) LoadRLE(pattern *rle.RLE) {
 					x = colIndex + startX
 					y = rowIndex + startY
 
-					grid.Data[y][x] = true
+					grid.Data[y+STRIDE*x] = 1
 				}
 			}
 		}
@@ -211,10 +353,10 @@ func (grid *Grid) SaveState(filename, rule string) error {
 
 	fmt.Fprintf(file, "#Life 1.05\n#R %s\n#D golsky state file\n#P -1 -1\n", rule)
 
-	for y := range grid.Data {
+	for y := 0; y < grid.Config.Height; y++ {
-		for _, cell := range grid.Data[y] {
+		for x := 0; x < grid.Config.Width; x++ {
 			row := "."
-			if cell {
+			if grid.Data[y+STRIDE*x] == 1 {
 				row = "o"
 			}
 

src/play.go

@@ -4,6 +4,7 @@ import (
 	"fmt"
 	"image"
 	"log"
+	"sync"
 	"unsafe"
 
 	"github.com/hajimehoshi/ebiten/v2"
@@ -21,6 +22,21 @@ const (
 	DEBUG_FORMAT = "FPS: %0.2f, TPG: %d, M: %0.2fMB, Generations: %d\nScale: %.02f, Zoom: %d, Cam: %.02f,%.02f Cursor: %d,%d  %s"
 )
 
+type History struct {
+	Age [][]int64
+}
+
+func NewHistory(height, width int) History {
+	hist := History{}
+
+	hist.Age = make([][]int64, height)
+	for y := 0; y < height; y++ {
+		hist.Age[y] = make([]int64, width)
+	}
+
+	return hist
+}
+
 type ScenePlay struct {
 	Game   *Game
 	Config *Config
@@ -31,7 +47,7 @@ type ScenePlay struct {
 	Clear bool
 
 	Grids         []*Grid       // 2 grids: one current, one next
-	History       [][]int64     // holds state of past dead cells for evolution traces
+	History       History       // holds state of past dead cells for evolution traces
 	Index         int           // points to current grid
 	Generations   int64         // Stats
 	TicksElapsed  int           // tick counter for game speed
@@ -46,6 +62,7 @@ type ScenePlay struct {
 	RunOneStep    bool          // mutable flags from config
 	TPG           int           // current game speed (ticks per game)
 	Theme         Theme
+	RuleCheckFunc func(uint8, uint8) uint8
 }
 
 func NewPlayScene(game *Game, config *Config) Scene {
@@ -83,18 +100,38 @@ func (scene *ScenePlay) SetNext(next SceneName) {
 	scene.Next = next
 }
 
-func (scene *ScenePlay) CheckRule(state bool, neighbors int) bool {
+/* The standard Scene of Life is symbolized in rule-string notation
-	var nextstate bool
+ * as B3/S23 (23/3 here).  A cell  is born if it has exactly three
+ * neighbors,  survives if it  has two or three  living neighbors,
+ * and  dies otherwise.
+ * we  abbreviate the calculation: if  state is 0 and  3 neighbors
+ * are a life, check will be just  3. If the cell is alive, 9 will
+ * be added  to the life neighbors (to avoid  a collision with the
+ * result 3), which will be 11|12 in case of 2|3 life neighbors.
+ */
+func (scene *ScenePlay) CheckRuleB3S23(state uint8, neighbors uint8) uint8 {
+	switch (9 * state) + neighbors {
+	case 11:
+		fallthrough
+	case 12:
+		fallthrough
+	case 3:
+		return Alive
+	}
 
-	// The standard Scene of Life is symbolized in rule-string notation
+	return Dead
-	// as B3/S23 (23/3 here).  A cell  is born if it has exactly three
+}
-	// neighbors,  survives if it  has two or three  living neighbors,
-	// and  dies otherwise. The first  number, or list of  numbers, is
-	// what is required for a dead cell to be born.
 
-	if !state && Contains(scene.Config.Rule.Birth, neighbors) {
+/*
+ * The generic  rule checker is able  to calculate cell state  for any
+ * GOL rul, including B3/S23.
+ */
+func (scene *ScenePlay) CheckRuleGeneric(state uint8, neighbors uint8) uint8 {
+	var nextstate uint8
+
+	if state != 1 && Contains(scene.Config.Rule.Birth, neighbors) {
 		nextstate = Alive
-	} else if state && Contains(scene.Config.Rule.Death, neighbors) {
+	} else if state == 1 && Contains(scene.Config.Rule.Death, neighbors) {
 		nextstate = Alive
 	} else {
 		nextstate = Dead
@@ -116,17 +153,27 @@ func (scene *ScenePlay) UpdateCells() {
 	// next grid index, we just xor 0|1 to 1|0
 	next := scene.Index ^ 1
 
+	var wg sync.WaitGroup
+	wg.Add(scene.Config.Height)
+
+	width := scene.Config.Width
+	height := scene.Config.Height
+
 	// compute life status of cells
-	for y := 0; y < scene.Config.Height; y++ {
+	for y := 0; y < height; y++ {
-		for x := 0; x < scene.Config.Width; x++ {
+
-			state := scene.Grids[scene.Index].Data[y][x] // 0|1 == dead or alive
+		go func() {
-			neighbors := scene.CountNeighbors(x, y)      // alive neighbor count
+			defer wg.Done()
+
+			for x := 0; x < width; x++ {
+				state := scene.Grids[scene.Index].Data[y+STRIDE*x] // 0|1 == dead or alive
+				neighbors := scene.Grids[scene.Index].Counter(x, y)
 
 				// actually apply the current rules
-			nextstate := scene.CheckRule(state, neighbors)
+				nextstate := scene.RuleCheckFunc(state, neighbors)
 
 				// change state of current cell in next grid
-			scene.Grids[next].Data[y][x] = nextstate
+				scene.Grids[next].Data[y+STRIDE*x] = nextstate
 
 				if scene.Config.ShowEvolution {
 					// set history  to current generation so we  can infer the
@@ -134,14 +181,14 @@ func (scene *ScenePlay) UpdateCells() {
 					// deduce the color to use if evolution tracing is enabled
 					// 60FPS:
 					if state != nextstate {
-					scene.History[y][x] = scene.Generations
+						scene.History.Age[y][x] = scene.Generations
+					}
+				}
+			}
+		}()
 	}
 
-				// 10FPS:
+	wg.Wait()
-				//scene.History.Data[y][x] = (state ^ (1 ^ nextstate)) * (scene.Generations - scene.History.Data[y][x])
-			}
-		}
-	}
 
 	// switch grid for rendering
 	scene.Index ^= 1
@@ -221,10 +268,8 @@ func (scene *ScenePlay) CheckInput() {
 func (scene *ScenePlay) CheckDrawingInput() {
 	if scene.Config.Drawmode {
 		switch {
-		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft):
+		case inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft):
-			scene.ToggleCellOnCursorPos(Alive)
+			scene.ToggleCellOnCursorPos()
-		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight):
-			scene.ToggleCellOnCursorPos(Dead)
 		case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
 			scene.Config.Drawmode = false
 		}
@@ -370,13 +415,13 @@ func (scene *ScenePlay) SaveRectRLE() {
 		height = scene.Mark.Y - scene.Point.Y
 	}
 
-	grid := make([][]bool, height)
+	grid := make([][]uint8, height)
 
 	for y := 0; y < height; y++ {
-		grid[y] = make([]bool, width)
+		grid[y] = make([]uint8, width)
 
 		for x := 0; x < width; x++ {
-			grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx]
+			grid[y][x] = scene.Grids[scene.Index].Data[(y+starty)+STRIDE*(x+startx)]
 		}
 	}
 
@@ -422,15 +467,15 @@ func (scene *ScenePlay) Update() error {
 }
 
 // set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos(alive bool) {
+func (scene *ScenePlay) ToggleCellOnCursorPos() {
 	// use cursor pos relative to the world
 	worldX, worldY := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
 	x := int(worldX) / scene.Config.Cellsize
 	y := int(worldY) / scene.Config.Cellsize
 
 	if x > -1 && y > -1 && x < scene.Config.Width && y < scene.Config.Height {
-		scene.Grids[scene.Index].Data[y][x] = alive
+		scene.Grids[scene.Index].Data[y+STRIDE*x] ^= 1
-		scene.History[y][x] = 1
+		scene.History.Age[y][x] = 1
 	}
 }
 
@@ -455,7 +500,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 			if scene.Config.ShowEvolution {
 				scene.DrawEvolution(screen, x, y, op)
 			} else {
-				if scene.Grids[scene.Index].Data[y][x] {
+				if scene.Grids[scene.Index].Data[y+STRIDE*x] == 1 {
 					scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
 				}
 			}
@@ -470,9 +515,9 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 }
 
 func (scene *ScenePlay) DrawEvolution(screen *ebiten.Image, x, y int, op *ebiten.DrawImageOptions) {
-	age := scene.Generations - scene.History[y][x]
+	age := scene.Generations - scene.History.Age[y][x]
 
-	switch scene.Grids[scene.Index].Data[y][x] {
+	switch scene.Grids[scene.Index].Data[y+STRIDE*x] {
 	case Alive:
 		if age > 50 && scene.Config.ShowEvolution {
 			scene.World.DrawImage(scene.Theme.Tile(ColOld), op)
@@ -481,7 +526,7 @@ func (scene *ScenePlay) DrawEvolution(screen *ebiten.Image, x, y int, op *ebiten
 		}
 	case Dead:
 		// only draw dead cells in case evolution trace is enabled
-		if scene.History[y][x] > 1 && scene.Config.ShowEvolution {
+		if scene.History.Age[y][x] > 1 && scene.Config.ShowEvolution {
 			switch {
 			case age < 10:
 				scene.World.DrawImage(scene.Theme.Tile(ColAge1), op)
@@ -553,17 +598,24 @@ func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
 // load a pre-computed pattern from RLE file
 func (scene *ScenePlay) InitPattern() {
 	scene.Grids[0].LoadRLE(scene.Config.RLE)
+
+	// rule might have changed
+	scene.InitRuleCheckFunc()
 }
 
 // pre-render offscreen cache image
 func (scene *ScenePlay) InitCache() {
+	// setup theme
+	scene.Theme.SetGrid(scene.Config.ShowGrid)
+
+	if !scene.Config.ShowGrid {
+		scene.Cache.Fill(scene.Theme.Color(ColDead))
+		return
+	}
+
 	op := &ebiten.DrawImageOptions{}
 
-	if scene.Config.ShowGrid {
 	scene.Cache.Fill(scene.Theme.Color(ColGrid))
-	} else {
-		scene.Cache.Fill(scene.Theme.Color(ColDead))
-	}
 
 	for y := 0; y < scene.Config.Height; y++ {
 		for x := 0; x < scene.Config.Width; x++ {
@@ -580,8 +632,8 @@ func (scene *ScenePlay) InitCache() {
 
 // initialize grid[s], either using pre-computed from state or rle file, or random
 func (scene *ScenePlay) InitGrid() {
-	grida := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
+	grida := NewGrid(scene.Config)
-	gridb := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
+	gridb := NewGrid(scene.Config)
 
 	// startup is delayed until user has selected options
 	grida.FillRandom()
@@ -591,10 +643,8 @@ func (scene *ScenePlay) InitGrid() {
 		gridb,
 	}
 
-	scene.History = make([][]int64, scene.Config.Height)
+	scene.History = NewHistory(scene.Config.Height, scene.Config.Width)
-	for y := 0; y < scene.Config.Height; y++ {
+
-		scene.History[y] = make([]int64, scene.Config.Width)
-	}
 }
 
 func (scene *ScenePlay) Init() {
@@ -626,6 +676,8 @@ func (scene *ScenePlay) Init() {
 	scene.InitCache()
 
 	if scene.Config.DelayedStart && !scene.Config.Empty {
+		// do not fill the grid when the main menu comes up first, the
+		// user decides interactively what to do
 		scene.Config.Empty = true
 		scene.InitGrid()
 		scene.Config.Empty = false
@@ -651,38 +703,10 @@ func bool2int(b bool) int {
 	return int(*(*byte)(unsafe.Pointer(&b)))
 }
 
-// count the living neighbors of a cell
+func (scene *ScenePlay) InitRuleCheckFunc() {
-func (scene *ScenePlay) CountNeighbors(x, y int) int {
+	if scene.Config.Rule.Definition == "B3/S23" {
-	var sum int
+		scene.RuleCheckFunc = scene.CheckRuleB3S23
-
-	grid := scene.Grids[scene.Index].Data
-
-	for nbgX := -1; nbgX < 2; nbgX++ {
-		for nbgY := -1; nbgY < 2; nbgY++ {
-			var col, row int
-			if scene.Config.Wrap {
-				// In wrap mode we look at all the 8 neighbors surrounding us.
-				// In case we are on an edge we'll look at the neighbor on the
-				//  other side  of the  grid, thus  wrapping lookahead  around
-				// using the mod() function.
-				col = (x + nbgX + scene.Config.Width) % scene.Config.Width
-				row = (y + nbgY + scene.Config.Height) % scene.Config.Height
-
 	} else {
-				// In traditional grid mode the edges are deadly
+		scene.RuleCheckFunc = scene.CheckRuleGeneric
-				if x+nbgX < 0 || x+nbgX >= scene.Config.Width || y+nbgY < 0 || y+nbgY >= scene.Config.Height {
-					continue
-				}
-				col = x + nbgX
-				row = y + nbgY
-			}
-
-			sum += bool2int(grid[row][col])
 	}
 }
-
-	// don't count ourselfes though
-	sum -= bool2int(grid[y][x])
-
-	return sum
-}

src/rule.go

@@ -9,13 +9,13 @@ import (
 // a GOL rule
 type Rule struct {
 	Definition string
-	Birth      []int
+	Birth      []uint8
-	Death      []int
+	Death      []uint8
 }
 
 // parse one part of a GOL rule into rule slice
-func NumbersToList(numbers string) []int {
+func NumbersToList(numbers string) []uint8 {
-	list := []int{}
+	list := []uint8{}
 
 	items := strings.Split(numbers, "")
 	for _, item := range items {
@@ -24,7 +24,7 @@ func NumbersToList(numbers string) []int {
 			log.Fatalf("failed to parse game rule part <%s>: %s", numbers, err)
 		}
 
-		list = append(list, num)
+		list = append(list, uint8(num))
 	}
 
 	return list

src/theme.go

@@ -26,8 +26,10 @@ const (
 // readily available from play.go
 type Theme struct {
 	Tiles     map[int]*ebiten.Image
+	GridTiles map[int]*ebiten.Image
 	Colors    map[int]color.RGBA
 	Name      string
+	ShowGrid  bool
 }
 
 type ThemeDef struct {
@@ -40,10 +42,10 @@ var THEMES = map[string]ThemeDef{
 		dead: "5a5a5a",
 		old:  "ff1e1e",
 		grid: "808080",
-		age1: "735f52",
+		age3: "6c6059",
-		age2: "6c6059",
+		age2: "735f52",
-		age3: "635d59",
+		age1: "7b5e4b",
-		age4: "7b5e4b",
+		age4: "635d59",
 	},
 	"dark": {
 		life: "c8c8c8",
@@ -84,10 +86,14 @@ func NewTheme(def ThemeDef, cellsize int, name string) Theme {
 	}
 
 	theme.Tiles = make(map[int]*ebiten.Image, 6)
+	theme.GridTiles = make(map[int]*ebiten.Image, 6)
 
 	for cid, col := range theme.Colors {
 		theme.Tiles[cid] = ebiten.NewImage(cellsize, cellsize)
-		FillCell(theme.Tiles[cid], cellsize, col)
+		FillCell(theme.Tiles[cid], cellsize, col, 0)
+
+		theme.GridTiles[cid] = ebiten.NewImage(cellsize, cellsize)
+		FillCell(theme.GridTiles[cid], cellsize, col, 1)
 	}
 
 	return theme
@@ -97,6 +103,10 @@ func NewTheme(def ThemeDef, cellsize int, name string) Theme {
 // unknown type is being used, which is ok, since the code is the only
 // user anyway
 func (theme *Theme) Tile(col int) *ebiten.Image {
+	if theme.ShowGrid {
+		return theme.GridTiles[col]
+	}
+
 	return theme.Tiles[col]
 }
 
@@ -104,6 +114,10 @@ func (theme *Theme) Color(col int) color.RGBA {
 	return theme.Colors[col]
 }
 
+func (theme *Theme) SetGrid(showgrid bool) {
+	theme.ShowGrid = showgrid
+}
+
 type ThemeManager struct {
 	Theme  string
 	Themes map[string]Theme
@@ -152,11 +166,11 @@ func (manager *ThemeManager) SetCurrentTheme(theme string) {
 //
 // So we don't draw a grid, we just left a grid behind, which saves us
 // from a lot of drawing operations.
-func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
+func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA, x int) {
 	vector.DrawFilledRect(
 		tile,
-		float32(1),
+		float32(x),
-		float32(1),
+		float32(x),
 		float32(cellsize),
 		float32(cellsize),
 		col, false,

various-tests/perf-1dim/main.go

@@ -87,6 +87,17 @@ func Loop(grid []bool) {
 }
 
 func main() {
+	grid := make([]int, 50*50)
+
+	for y := 0; y < 50; y++ {
+		for x := 0; x < 50; x++ {
+			grid[y+50*x] = 1
+			fmt.Printf("%d,%d => %d\n", x, y, x+50*y)
+		}
+	}
+}
+
+func xmain() {
 	// enable  cpu profiling. Do  NOT use q  to stop the  game but
 	// close the window to get a profile
 	fd, err := os.Create("cpu.profile")

various-tests/raygol/.gitignore

@@ -0,0 +1,2 @@
+golsky
+*.o

various-tests/raygol/Makefile

@@ -0,0 +1,33 @@
+CFLAGS = -Wall -Wextra -Werror -O2 -g 
+LDFLAGS= -L/usr/local/lib -lraylib -lGL -lm -lpthread -ldl -lrt -lX11 -g
+CC     = clang
+OBJS   = main.o game.o grid.o
+DST    = golsky
+PREFIX = /usr/local
+UID    = root
+GID    = 0
+MAN    = udpxd.1
+
+.PHONY: all
+all: $(DST)
+
+$(DST): $(OBJS)
+	$(CC) $(OBJS) $(LDFLAGS) -o $(DST)
+
+%.o: %.c
+	$(CC) -c $(CFLAGS) $*.c -o $*.o
+
+.PHONY: clean
+clean:
+	rm -f *.o $(DST)
+
+.PHONY: install
+install: $(DST)
+	install -d -o $(UID) -g $(GID) $(PREFIX)/sbin
+	install -d -o $(UID) -g $(GID) $(PREFIX)/man/man1
+	install -o $(UID) -g $(GID) -m 555 $(DST) $(PREFIX)/sbin/
+	install -o $(UID) -g $(GID) -m 444 $(MAN) $(PREFIX)/man/man1/
+
+.PHONY: run
+run:
+	LD_LIBRARY_PATH=/usr/local/lib ./golsky

various-tests/raygol/game.c

@@ -0,0 +1,48 @@
+#include "game.h"
+#include <stdio.h>
+
+Game *Init(int width, int height, int gridwidth, int gridheight, int density) {
+  struct Game *game = malloc(sizeof(struct Game));
+
+  game->ScreenWidth = width;
+  game->ScreenHeight = height;
+  game->Cellsize = width / gridwidth;
+  game->Width = gridwidth;
+  game->Height = gridheight;
+
+  InitWindow(width, height, "golsky");
+  SetTargetFPS(60);
+
+  game->Grid = NewGrid(gridwidth, gridheight, density);
+
+  return game;
+}
+
+void Update(Game *game) {
+  if (IsKeyDown(KEY_Q)) {
+    game->Done = true;
+    exit(0);
+  }
+}
+
+void Draw(Game *game) {
+  BeginDrawing();
+
+  ClearBackground(RAYWHITE);
+
+  for (int y = 0; y < game->Width; y++) {
+    for (int x = 0; x < game->Height; x++) {
+      if (game->Grid->Data[y][x] == 1) {
+        DrawRectangle(x * game->Cellsize, y * game->Cellsize, game->Cellsize,
+                      game->Cellsize, GREEN);
+      } else {
+        DrawRectangle(x * game->Cellsize, y * game->Cellsize, game->Cellsize,
+                      game->Cellsize, RAYWHITE);
+      }
+    }
+  }
+
+  DrawText("TEST", game->ScreenWidth / 2, 10, 20, RED);
+
+  EndDrawing();
+}

various-tests/raygol/game.h

@@ -0,0 +1,25 @@
+#ifndef _HAVE_GAME_H
+#define _HAVE_GAME_H
+
+#include "grid.h"
+#include "raylib.h"
+#include <stdlib.h>
+
+typedef struct Game {
+  // Camera2D Camera;
+  int ScreenWidth;
+  int ScreenHeight;
+  int Cellsize;
+
+  // Grid dimensions
+  int Width;
+  int Height;
+  bool Done;
+  Grid *Grid;
+} Game;
+
+Game *Init(int width, int height, int gridwidth, int gridheight, int density);
+void Update(Game *game);
+void Draw(Game *game);
+
+#endif

various-tests/raygol/grid.c

@@ -0,0 +1,28 @@
+#include "grid.h"
+
+Grid *NewGrid(int width, int height, int density) {
+  Grid *grid = malloc(sizeof(struct Grid));
+  grid->Width = width;
+  grid->Height = height;
+  grid->Density = density;
+
+  grid->Data = malloc(height * sizeof(int *));
+  for (int y = 0; y < grid->Height; y++) {
+    grid->Data[y] = malloc(width * sizeof(int *));
+  }
+
+  FillRandom(grid);
+
+  return grid;
+}
+
+void FillRandom(Grid *grid) {
+  int r;
+  for (int y = 0; y < grid->Width; y++) {
+    for (int x = 0; x < grid->Height; x++) {
+      r = GetRandomValue(0, grid->Density);
+      if (r == 1)
+        grid->Data[y][x] = r;
+    }
+  }
+}

various-tests/raygol/grid.h

@@ -0,0 +1,18 @@
+#ifndef _HAVE_GRID_H
+#define _HAVE_GRID_H
+
+#include "raylib.h"
+#include <stdio.h>
+#include <stdlib.h>
+
+typedef struct Grid {
+  int Width;
+  int Height;
+  int Density;
+  int **Data;
+} Grid;
+
+Grid *NewGrid(int width, int height, int density);
+void FillRandom(Grid *grid);
+
+#endif

various-tests/raygol/main.c

@@ -0,0 +1,15 @@
+#include "game.h"
+#include "raylib.h"
+
+int main(void) {
+  Game *game = Init(800, 800, 10, 10, 8);
+
+  while (!WindowShouldClose()) {
+    Update(game);
+    Draw(game);
+  }
+
+  CloseWindow();
+  free(game);
+  return 0;
+}