using only one dimensional grid by calculating y+STRIDE*x

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)

TODO.md

@@ -20,7 +20,11 @@ https://www.tasnimzotder.com/blog/optimizing-game-of-life-algorithm
   the cells anymore.
 - Speed
   https://conwaylife.com/forums/viewtopic.php?f=7&t=3237
-  
+  Look at try-pointers-and-cells branch, we're using pre-calculated
+  neighbor list of pointers to cells, but it's only a liiiiitle bit
+  better :(
+
+
 - Patterns:
 
 A   Catagolue   textcensus   of,  say,   period-2   oscillators   from

src/config.go

@@ -52,7 +52,7 @@ const (
 	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,45 +12,46 @@ import (
 	"github.com/tlinden/golsky/rle"
 )
 
-type Cell struct {
+// equals grid height, is being used to access grid elements and must be global
-	State         uint8
+var STRIDE int
-	Neighbors     [8]*Cell
-	NeighborCount int
-}
 
-func (cell *Cell) Count() uint8 {
+type Neighbor struct {
-	var count uint8
+	X, Y int
-
-	for idx := 0; idx < cell.NeighborCount; idx++ {
-		count += cell.Neighbors[idx].State
-	}
-
-	return count
 }
 
 type Grid struct {
-	Data   [][]*Cell
+	Data          []uint8
-	Empty  bool
+	NeighborCount []int
-	Config *Config
+	Neighbors     [][]Neighbor
+	Empty         bool
+	Config        *Config
 }
 
 // Create new empty grid and allocate Data according to provided dimensions
 func NewGrid(config *Config) *Grid {
+	STRIDE = config.Height
+	if config.Width > config.Height {
+		STRIDE = config.Width
+	}
+
+	size := STRIDE * STRIDE
+
 	grid := &Grid{
-		Data:   make([][]*Cell, config.Height),
+		Data:          make([]uint8, size),
-		Empty:  config.Empty,
+		NeighborCount: make([]int, size),
-		Config: config,
+		Neighbors:     make([][]Neighbor, size),
+		Empty:         config.Empty,
+		Config:        config,
 	}
 
 	// first setup the cells
 	for y := 0; y < config.Height; y++ {
-		grid.Data[y] = make([]*Cell, config.Width)
 		for x := 0; x < config.Width; x++ {
-			grid.Data[y][x] = &Cell{}
+			grid.Data[y+STRIDE*x] = 0
 		}
 	}
 
-	// in a second pass, collect pointers to the neighbors of each cell
+	// 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)
@@ -63,6 +64,8 @@ func NewGrid(config *Config) *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
@@ -89,16 +92,29 @@ func (grid *Grid) SetupNeighbors(x, y int) {
 				continue
 			}
 
-			grid.Data[y][x].Neighbors[idx] = grid.Data[row][col]
+			neighbors = append(neighbors, Neighbor{X: col, Y: row})
-			grid.Data[y][x].NeighborCount++
+			grid.NeighborCount[y+STRIDE*x]++
 			idx++
 		}
 	}
+
+	grid.Neighbors[y+STRIDE*x] = neighbors
 }
 
 // count the living neighbors of a cell
 func (grid *Grid) CountNeighbors(x, y int) uint8 {
-	return grid.Data[y][x].Count()
+	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
@@ -112,30 +128,30 @@ func (grid *Grid) Clone() *Grid {
 }
 
 // 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].State = 0
+// 			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.Config.Density) == 1 {
-					grid.Data[y][x].State = 1
+					grid.Data[y+STRIDE*x] = 1
 				}
 			}
 		}
@@ -145,7 +161,7 @@ func (grid *Grid) FillRandom() {
 func (grid *Grid) Dump() {
 	for y := 0; y < grid.Config.Height; y++ {
 		for x := 0; x < grid.Config.Width; x++ {
-			if grid.Data[y][x].State == 1 {
+			if grid.Data[y+STRIDE*x] == 1 {
 				fmt.Print("XX")
 			} else {
 				fmt.Print("  ")
@@ -168,7 +184,7 @@ func (grid *Grid) LoadRLE(pattern *rle.RLE) {
 					x = colIndex + startX
 					y = rowIndex + startY
 
-					grid.Data[y][x].State = 1
+					grid.Data[y+STRIDE*x] = 1
 				}
 			}
 		}
@@ -276,10 +292,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.State == 1 {
+			if grid.Data[y+STRIDE*x] == 1 {
 				row = "o"
 			}
 

src/play.go

@@ -100,34 +100,35 @@ func (scene *ScenePlay) SetNext(next SceneName) {
 	scene.Next = next
 }
 
+/* The standard Scene of Life is symbolized in rule-string notation
+ * 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 {
-	var nextstate uint8
+	switch (9 * state) + neighbors {
-
-	check := (9 * state) + neighbors
-
-	switch check {
 	case 11:
 		fallthrough
 	case 12:
 		fallthrough
 	case 3:
-		nextstate = Alive
+		return Alive
-	default:
-		nextstate = Dead
 	}
 
-	return nextstate
+	return Dead
 }
 
+/*
+ * 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
 
-	// The standard Scene of Life is symbolized in rule-string notation
-	// 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 != 1 && Contains(scene.Config.Rule.Birth, neighbors) {
 		nextstate = Alive
 	} else if state == 1 && Contains(scene.Config.Rule.Death, neighbors) {
@@ -155,21 +156,24 @@ func (scene *ScenePlay) UpdateCells() {
 	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++ {
 
 		go func() {
 			defer wg.Done()
 
-			for x := 0; x < scene.Config.Width; x++ {
+			for x := 0; x < width; x++ {
-				state := scene.Grids[scene.Index].Data[y][x].State // 0|1 == dead or alive
+				state := scene.Grids[scene.Index].Data[y+STRIDE*x] // 0|1 == dead or alive
 				neighbors := scene.Grids[scene.Index].CountNeighbors(x, y)
 
 				// actually apply the current rules
 				nextstate := scene.RuleCheckFunc(state, neighbors)
 
 				// change state of current cell in next grid
-				scene.Grids[next].Data[y][x].State = nextstate
+				scene.Grids[next].Data[y+STRIDE*x] = nextstate
 
 				if scene.Config.ShowEvolution {
 					// set history  to current generation so we  can infer the
@@ -264,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
 		}
@@ -419,7 +421,7 @@ func (scene *ScenePlay) SaveRectRLE() {
 		grid[y] = make([]uint8, width)
 
 		for x := 0; x < width; x++ {
-			grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx].State
+			grid[y][x] = scene.Grids[scene.Index].Data[(y+starty)+STRIDE*(x+startx)]
 		}
 	}
 
@@ -465,14 +467,14 @@ func (scene *ScenePlay) Update() error {
 }
 
 // set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos(alive uint8) {
+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].State = alive
+		scene.Grids[scene.Index].Data[y+STRIDE*x] ^= 1
 		scene.History.Age[y][x] = 1
 	}
 }
@@ -498,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].State == 1 {
+				if scene.Grids[scene.Index].Data[y+STRIDE*x] == 1 {
 					scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
 				}
 			}
@@ -515,7 +517,7 @@ 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.Age[y][x]
 
-	switch scene.Grids[scene.Index].Data[y][x].State {
+	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)

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/writepixel-pointers-int/go.mod

@@ -0,0 +1,13 @@
+module testgol
+
+go 1.22
+
+require (
+	github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 // indirect
+	github.com/ebitengine/hideconsole v1.0.0 // indirect
+	github.com/ebitengine/purego v0.7.0 // indirect
+	github.com/hajimehoshi/ebiten/v2 v2.7.4 // indirect
+	github.com/jezek/xgb v1.1.1 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+)

various-tests/writepixel-pointers-int/go.sum

@@ -0,0 +1,14 @@
+github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 h1:48bCqKTuD7Z0UovDfvpCn7wZ0GUZ+yosIteNDthn3FU=
+github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895/go.mod h1:XZdLv05c5hOZm3fM2NlJ92FyEZjnslcMcNRrhxs8+8M=
+github.com/ebitengine/hideconsole v1.0.0 h1:5J4U0kXF+pv/DhiXt5/lTz0eO5ogJ1iXb8Yj1yReDqE=
+github.com/ebitengine/hideconsole v1.0.0/go.mod h1:hTTBTvVYWKBuxPr7peweneWdkUwEuHuB3C1R/ielR1A=
+github.com/ebitengine/purego v0.7.0 h1:HPZpl61edMGCEW6XK2nsR6+7AnJ3unUxpTZBkkIXnMc=
+github.com/ebitengine/purego v0.7.0/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ=
+github.com/hajimehoshi/ebiten/v2 v2.7.4 h1:X+heODRQ3Ie9F9QFjm24gEZqQd5FSfR9XuT2XfHwgf8=
+github.com/hajimehoshi/ebiten/v2 v2.7.4/go.mod h1:H2pHVgq29rfm5yeQ7jzWOM3VHsjo7/AyucODNLOhsVY=
+github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
+github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

various-tests/writepixel-pointers-int/main.go

@@ -0,0 +1,306 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"runtime/pprof"
+	"unsafe"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Cell struct {
+	State         uint8
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) uint8 {
+	var sum uint8
+
+	for idx := 0; idx < cell.NeighborCount; idx++ {
+		sum += cell.Neighbors[idx].State
+	}
+
+	return sum
+}
+
+func SetNeighbors(grid [][]*Cell, x, y, width, height int) {
+	idx := 0
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= width || y+nbgY < 0 || y+nbgY >= height {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			if col == x && row == y {
+				continue
+			}
+
+			grid[y][x].Neighbors[idx] = grid[row][col]
+			grid[y][x].NeighborCount++
+			idx++
+		}
+	}
+}
+
+type Grid struct {
+	Data                   [][]*Cell
+	Width, Height, Density int
+}
+
+// Create new empty grid and allocate Data according to provided dimensions
+func NewGrid(width, height, density int) *Grid {
+	grid := &Grid{
+		Height:  height,
+		Width:   width,
+		Density: density,
+		Data:    make([][]*Cell, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]*Cell, width)
+		for x := 0; x < width; x++ {
+			grid.Data[y][x] = &Cell{}
+
+			if rand.Intn(density) == 1 {
+				grid.Data[y][x].State = 1
+			}
+		}
+	}
+
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			SetNeighbors(grid.Data, x, y, width, height)
+		}
+	}
+
+	return grid
+}
+
+type Game struct {
+	Width, Height, Cellsize, Density int
+	ScreenWidth, ScreenHeight        int
+	Grids                            []*Grid
+	Index                            int
+	Elapsed                          int64
+	TPG                              int64 // adjust game speed independently of TPS
+	Pause, Debug, Profile, Gridlines bool
+	Pixels                           []byte
+	OffScreen                        *ebiten.Image
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+// live console output of the grid
+func (game *Game) DebugDump() {
+	cmd := exec.Command("clear")
+	cmd.Stdout = os.Stdout
+	cmd.Run()
+
+	if game.Debug {
+		for y := 0; y < game.Height; y++ {
+			for x := 0; x < game.Width; x++ {
+				if game.Grids[game.Index].Data[y][x].State == 1 {
+					fmt.Print("XX")
+				} else {
+					fmt.Print("  ")
+				}
+			}
+			fmt.Println()
+		}
+	}
+	fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
+}
+
+func (game *Game) Init() {
+	// setup two grids, one for display, one for next state
+	grida := NewGrid(game.Width, game.Height, game.Density)
+	gridb := NewGrid(game.Width, game.Height, game.Density)
+
+	game.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	game.Pixels = make([]byte, game.ScreenWidth*game.ScreenHeight*4)
+
+	game.OffScreen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+}
+
+// count the living neighbors of a cell
+func (game *Game) CountNeighbors(x, y int) uint8 {
+	return game.Grids[game.Index].Data[y][x].Count(x, y)
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state uint8, neighbors uint8) uint8 {
+	var nextstate uint8
+
+	if state == 1 && neighbors == 3 {
+		nextstate = 1
+	} else if state == 1 && (neighbors == 2 || neighbors == 3) {
+		nextstate = 1
+	} else {
+		nextstate = 0
+	}
+
+	return nextstate
+}
+
+// we only  update the cells if  we are not  in pause state or  if the
+// game timer (TPG) is elapsed.
+func (game *Game) UpdateCells() {
+	if game.Pause {
+		return
+	}
+
+	if game.Elapsed < game.TPG {
+		game.Elapsed++
+		return
+	}
+
+	// next grid index. we only have to, so we just xor it
+	next := game.Index ^ 1
+
+	// calculate cell life state, this is the actual game of life
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			state := game.Grids[game.Index].Data[y][x].State
+			neighbors := game.CountNeighbors(x, y)
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x].State = nextstate
+		}
+	}
+
+	// switch grid for rendering
+	game.Index ^= 1
+
+	game.Elapsed = 0
+
+	game.UpdatePixels()
+}
+
+func (game *Game) Update() error {
+	game.UpdateCells()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
+		game.Pause = !game.Pause
+	}
+
+	return nil
+}
+
+/*
+*
+r, g, b := color(it)
+
+	78             p := 4 * (i + j*screenWidth)
+	79             gm.offscreenPix[p] = r
+	80             gm.offscreenPix[p+1] = g
+	81             gm.offscreenPix[p+2] = b
+	82             gm.offscreenPix[p+3] = 0xff
+*/
+func (game *Game) UpdatePixels() {
+	var col byte
+
+	gridx := 0
+	gridy := 0
+	idx := 0
+
+	for y := 0; y < game.ScreenHeight; y++ {
+		for x := 0; x < game.ScreenWidth; x++ {
+			gridx = x / game.Cellsize
+			gridy = y / game.Cellsize
+
+			col = 0xff
+			if game.Grids[game.Index].Data[gridy][gridx].State == 1 {
+				col = 0x0
+			}
+
+			if game.Gridlines {
+				if x%game.Cellsize == 0 || y%game.Cellsize == 0 {
+					col = 128
+				}
+			}
+
+			idx = 4 * (x + y*game.ScreenWidth)
+
+			game.Pixels[idx] = col
+			game.Pixels[idx+1] = col
+			game.Pixels[idx+2] = col
+			game.Pixels[idx+3] = 0xff
+
+			idx++
+		}
+	}
+
+	game.OffScreen.WritePixels(game.Pixels)
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	screen.DrawImage(game.OffScreen, nil)
+	game.DebugDump()
+}
+
+func main() {
+	size := 1500
+
+	game := &Game{
+		Width:     size,
+		Height:    size,
+		Cellsize:  4,
+		Density:   8,
+		TPG:       10,
+		Debug:     false,
+		Profile:   true,
+		Gridlines: false,
+	}
+
+	game.ScreenWidth = game.Width * game.Cellsize
+	game.ScreenHeight = game.Height * game.Cellsize
+
+	game.Init()
+
+	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
+	ebiten.SetWindowTitle("triangle conway's game of life")
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+
+	if game.Profile {
+		fd, err := os.Create("cpu.profile")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer fd.Close()
+
+		pprof.StartCPUProfile(fd)
+		defer pprof.StopCPUProfile()
+	}
+
+	if err := ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}

various-tests/writepixel-pointers/go.mod

@@ -0,0 +1,13 @@
+module testgol
+
+go 1.22
+
+require (
+	github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 // indirect
+	github.com/ebitengine/hideconsole v1.0.0 // indirect
+	github.com/ebitengine/purego v0.7.0 // indirect
+	github.com/hajimehoshi/ebiten/v2 v2.7.4 // indirect
+	github.com/jezek/xgb v1.1.1 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+)

various-tests/writepixel-pointers/go.sum

@@ -0,0 +1,14 @@
+github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 h1:48bCqKTuD7Z0UovDfvpCn7wZ0GUZ+yosIteNDthn3FU=
+github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895/go.mod h1:XZdLv05c5hOZm3fM2NlJ92FyEZjnslcMcNRrhxs8+8M=
+github.com/ebitengine/hideconsole v1.0.0 h1:5J4U0kXF+pv/DhiXt5/lTz0eO5ogJ1iXb8Yj1yReDqE=
+github.com/ebitengine/hideconsole v1.0.0/go.mod h1:hTTBTvVYWKBuxPr7peweneWdkUwEuHuB3C1R/ielR1A=
+github.com/ebitengine/purego v0.7.0 h1:HPZpl61edMGCEW6XK2nsR6+7AnJ3unUxpTZBkkIXnMc=
+github.com/ebitengine/purego v0.7.0/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ=
+github.com/hajimehoshi/ebiten/v2 v2.7.4 h1:X+heODRQ3Ie9F9QFjm24gEZqQd5FSfR9XuT2XfHwgf8=
+github.com/hajimehoshi/ebiten/v2 v2.7.4/go.mod h1:H2pHVgq29rfm5yeQ7jzWOM3VHsjo7/AyucODNLOhsVY=
+github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
+github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
+golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

various-tests/writepixel-pointers/main.go

@@ -0,0 +1,306 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"runtime/pprof"
+	"unsafe"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Cell struct {
+	State         bool
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) int {
+	sum := 0
+
+	for idx := 0; idx < cell.NeighborCount; idx++ {
+		sum += bool2int(cell.Neighbors[idx].State)
+	}
+
+	return sum
+}
+
+func SetNeighbors(grid [][]*Cell, x, y, width, height int) {
+	idx := 0
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= width || y+nbgY < 0 || y+nbgY >= height {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			if col == x && row == y {
+				continue
+			}
+
+			grid[y][x].Neighbors[idx] = grid[row][col]
+			grid[y][x].NeighborCount++
+			idx++
+		}
+	}
+}
+
+type Grid struct {
+	Data                   [][]*Cell
+	Width, Height, Density int
+}
+
+// Create new empty grid and allocate Data according to provided dimensions
+func NewGrid(width, height, density int) *Grid {
+	grid := &Grid{
+		Height:  height,
+		Width:   width,
+		Density: density,
+		Data:    make([][]*Cell, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]*Cell, width)
+		for x := 0; x < width; x++ {
+			grid.Data[y][x] = &Cell{}
+
+			if rand.Intn(density) == 1 {
+				grid.Data[y][x].State = true
+			}
+		}
+	}
+
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			SetNeighbors(grid.Data, x, y, width, height)
+		}
+	}
+
+	return grid
+}
+
+type Game struct {
+	Width, Height, Cellsize, Density int
+	ScreenWidth, ScreenHeight        int
+	Grids                            []*Grid
+	Index                            int
+	Elapsed                          int64
+	TPG                              int64 // adjust game speed independently of TPS
+	Pause, Debug, Profile, Gridlines bool
+	Pixels                           []byte
+	OffScreen                        *ebiten.Image
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+// live console output of the grid
+func (game *Game) DebugDump() {
+	cmd := exec.Command("clear")
+	cmd.Stdout = os.Stdout
+	cmd.Run()
+
+	if game.Debug {
+		for y := 0; y < game.Height; y++ {
+			for x := 0; x < game.Width; x++ {
+				if game.Grids[game.Index].Data[y][x].State {
+					fmt.Print("XX")
+				} else {
+					fmt.Print("  ")
+				}
+			}
+			fmt.Println()
+		}
+	}
+	fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
+}
+
+func (game *Game) Init() {
+	// setup two grids, one for display, one for next state
+	grida := NewGrid(game.Width, game.Height, game.Density)
+	gridb := NewGrid(game.Width, game.Height, game.Density)
+
+	game.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	game.Pixels = make([]byte, game.ScreenWidth*game.ScreenHeight*4)
+
+	game.OffScreen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+}
+
+// count the living neighbors of a cell
+func (game *Game) CountNeighbors(x, y int) int {
+	return game.Grids[game.Index].Data[y][x].Count(x, y)
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state bool, neighbors int) bool {
+	var nextstate bool
+
+	if state && neighbors == 3 {
+		nextstate = true
+	} else if state && (neighbors == 2 || neighbors == 3) {
+		nextstate = true
+	} else {
+		nextstate = false
+	}
+
+	return nextstate
+}
+
+// we only  update the cells if  we are not  in pause state or  if the
+// game timer (TPG) is elapsed.
+func (game *Game) UpdateCells() {
+	if game.Pause {
+		return
+	}
+
+	if game.Elapsed < game.TPG {
+		game.Elapsed++
+		return
+	}
+
+	// next grid index. we only have to, so we just xor it
+	next := game.Index ^ 1
+
+	// calculate cell life state, this is the actual game of life
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			state := game.Grids[game.Index].Data[y][x].State
+			neighbors := game.CountNeighbors(x, y)
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x].State = nextstate
+		}
+	}
+
+	// switch grid for rendering
+	game.Index ^= 1
+
+	game.Elapsed = 0
+
+	game.UpdatePixels()
+}
+
+func (game *Game) Update() error {
+	game.UpdateCells()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
+		game.Pause = !game.Pause
+	}
+
+	return nil
+}
+
+/*
+*
+r, g, b := color(it)
+
+	78             p := 4 * (i + j*screenWidth)
+	79             gm.offscreenPix[p] = r
+	80             gm.offscreenPix[p+1] = g
+	81             gm.offscreenPix[p+2] = b
+	82             gm.offscreenPix[p+3] = 0xff
+*/
+func (game *Game) UpdatePixels() {
+	var col byte
+
+	gridx := 0
+	gridy := 0
+	idx := 0
+
+	for y := 0; y < game.ScreenHeight; y++ {
+		for x := 0; x < game.ScreenWidth; x++ {
+			gridx = x / game.Cellsize
+			gridy = y / game.Cellsize
+
+			col = 0xff
+			if game.Grids[game.Index].Data[gridy][gridx].State {
+				col = 0x0
+			}
+
+			if game.Gridlines {
+				if x%game.Cellsize == 0 || y%game.Cellsize == 0 {
+					col = 128
+				}
+			}
+
+			idx = 4 * (x + y*game.ScreenWidth)
+
+			game.Pixels[idx] = col
+			game.Pixels[idx+1] = col
+			game.Pixels[idx+2] = col
+			game.Pixels[idx+3] = 0xff
+
+			idx++
+		}
+	}
+
+	game.OffScreen.WritePixels(game.Pixels)
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	screen.DrawImage(game.OffScreen, nil)
+	game.DebugDump()
+}
+
+func main() {
+	size := 1500
+
+	game := &Game{
+		Width:     size,
+		Height:    size,
+		Cellsize:  4,
+		Density:   8,
+		TPG:       10,
+		Debug:     false,
+		Profile:   true,
+		Gridlines: false,
+	}
+
+	game.ScreenWidth = game.Width * game.Cellsize
+	game.ScreenHeight = game.Height * game.Cellsize
+
+	game.Init()
+
+	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
+	ebiten.SetWindowTitle("triangle conway's game of life")
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+
+	if game.Profile {
+		fd, err := os.Create("cpu.profile")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer fd.Close()
+
+		pprof.StartCPUProfile(fd)
+		defer pprof.StopCPUProfile()
+	}
+
+	if err := ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}

various-tests/writepixel/main.go

@@ -238,35 +238,7 @@ func (game *Game) Draw(screen *ebiten.Image) {
 }
 
 func main() {
-	//x := 1
+	size := 1500
-	//y := 0
-	col := 1 >> 0xff
-
-	fmt.Printf("col: %d\n", col)
-
-	x := 1
-	y := 2
-	c := 4
-
-	xm := x & (c - 1)
-	ym := y & (c - 1)
-
-	fmt.Println(xm & ym)
-
-	a := 1
-	b := 1
-	//gen := 100
-	hist := 0
-	for gen := 0; gen < 50; gen++ {
-		fmt.Println((a ^ (1 ^ b)) * (gen - hist))
-		if gen == 25 {
-			a = 0
-		}
-	}
-}
-
-func _main() {
-	size := 800
 
 	game := &Game{
 		Width:     size,
@@ -275,7 +247,7 @@ func _main() {
 		Density:   8,
 		TPG:       10,
 		Debug:     false,
-		Profile:   false,
+		Profile:   true,
 		Gridlines: false,
 	}