bumpversion

Makefile

@@ -1,8 +1,5 @@
-.PHONY all:
+.PHONY: all
-all: build
+all:
-
-.PHONY: build
-build:
 	make -C src
 	mv src/golsky .
 
@@ -10,8 +7,3 @@ build:
 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,16 +82,17 @@ 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 toggle cells alife state.
+* i: enter "insert" (draw) mode: use left mouse to set cells alife and right
-  Leave with insert mode "space". While in insert mode, use middle mouse
+  button to dead. Leave with "space". While in insert mode, use middle mouse
-  button to drag the grid.
+  button to drag grid.
 * r: reset to 1:1 zoom
 * escape: open menu
 * s: save game state to file (can be loaded with -l)

TODO.md

@@ -20,10 +20,6 @@ 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:
 

src/config.go

@@ -52,7 +52,7 @@ const (
 	DEFAULT_CELLSIZE    = 4
 	DEFAULT_ZOOMFACTOR  = 400
 	DEFAULT_GEOM        = "640x384"
-	DEFAULT_THEME       = "standard"
+	DEFAULT_THEME       = "standard" // "light" // inverse => "dark"
 )
 
 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 toggle a cells alife state.
+- I: enter "insert" (draw) mode: use left mouse to set cells alife and right
-     Leave with insert mode with "space". While in insert mode, use middle mouse
+     button to dead. Leave with "space". While in insert mode, use middle mouse
-     button to drag the grid.
+     button to drag 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,67 +12,57 @@ import (
 	"github.com/tlinden/golsky/rle"
 )
 
-// equals grid height, is being used to access grid elements and must be global
+type Cell struct {
-var STRIDE int
+	State         uint8
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
 
-type Neighbor struct {
+func (cell *Cell) Count() uint8 {
-	X, Y int
+	var count uint8
+
+	for idx := 0; idx < cell.NeighborCount; idx++ {
+		count += cell.Neighbors[idx].State
+	}
+
+	return count
 }
 
 type Grid struct {
-	Data          []uint8
+	Data   [][]*Cell
-	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(config *Config) *Grid {
-	STRIDE = config.Height
-	if config.Width > config.Height {
-		STRIDE = config.Width
-	}
-
-	size := STRIDE * STRIDE
-
 	grid := &Grid{
-		Data:          make([]uint8, size),
+		Data:   make([][]*Cell, config.Height),
-		NeighborCount: make([]int, size),
-		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+STRIDE*x] = 0
+			grid.Data[y][x] = &Cell{}
 		}
 	}
 
-	// in a second pass, collect positions to the neighbors of each cell
+	// in a second pass, collect pointers 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
@@ -99,83 +89,16 @@ func (grid *Grid) SetupNeighbors(x, y int) {
 				continue
 			}
 
-			neighbors = append(neighbors, Neighbor{X: col, Y: row})
+			grid.Data[y][x].Neighbors[idx] = grid.Data[row][col]
-			grid.NeighborCount[y+STRIDE*x]++
+			grid.Data[y][x].NeighborCount++
 			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 {
+func (grid *Grid) CountNeighbors(x, y int) uint8 {
-	var count uint8
+	return grid.Data[y][x].Count()
-
-	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
@@ -189,30 +112,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+STRIDE*x] = grid.Data[y+STRIDE*x]
+			other.Data[y][x] = grid.Data[y][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+STRIDE*x] = 0
+			grid.Data[y][x].State = 0
-// 		}
+		}
-// 	}
+	}
-// }
+}
 
 // initialize with random life cells using the given density
 func (grid *Grid) FillRandom() {
 	if !grid.Empty {
-		for y := 0; y < grid.Config.Height; y++ {
+		for y := range grid.Data {
-			for x := 0; x < grid.Config.Width; x++ {
+			for x := range grid.Data[y] {
 				if rand.Intn(grid.Config.Density) == 1 {
-					grid.Data[y+STRIDE*x] = 1
+					grid.Data[y][x].State = 1
 				}
 			}
 		}
@@ -222,7 +145,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+STRIDE*x] == 1 {
+			if grid.Data[y][x].State == 1 {
 				fmt.Print("XX")
 			} else {
 				fmt.Print("  ")
@@ -245,7 +168,7 @@ func (grid *Grid) LoadRLE(pattern *rle.RLE) {
 					x = colIndex + startX
 					y = rowIndex + startY
 
-					grid.Data[y+STRIDE*x] = 1
+					grid.Data[y][x].State = 1
 				}
 			}
 		}
@@ -353,10 +276,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 := 0; y < grid.Config.Height; y++ {
+	for y := range grid.Data {
-		for x := 0; x < grid.Config.Width; x++ {
+		for _, cell := range grid.Data[y] {
 			row := "."
-			if grid.Data[y+STRIDE*x] == 1 {
+			if cell.State == 1 {
 				row = "o"
 			}
 

src/play.go

@@ -100,35 +100,34 @@ 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 {
-	switch (9 * state) + neighbors {
+	var nextstate uint8
+
+	check := (9 * state) + neighbors
+
+	switch check {
 	case 11:
 		fallthrough
 	case 12:
 		fallthrough
 	case 3:
-		return Alive
+		nextstate = Alive
+	default:
+		nextstate = Dead
 	}
 
-	return Dead
+	return nextstate
 }
 
-/*
- * 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) {
@@ -156,24 +155,21 @@ 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 < height; y++ {
+	for y := 0; y < scene.Config.Height; y++ {
 
 		go func() {
 			defer wg.Done()
 
-			for x := 0; x < width; x++ {
+			for x := 0; x < scene.Config.Width; x++ {
-				state := scene.Grids[scene.Index].Data[y+STRIDE*x] // 0|1 == dead or alive
+				state := scene.Grids[scene.Index].Data[y][x].State // 0|1 == dead or alive
-				neighbors := scene.Grids[scene.Index].Counter(x, y)
+				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+STRIDE*x] = nextstate
+				scene.Grids[next].Data[y][x].State = nextstate
 
 				if scene.Config.ShowEvolution {
 					// set history  to current generation so we  can infer the
@@ -268,8 +264,10 @@ func (scene *ScenePlay) CheckInput() {
 func (scene *ScenePlay) CheckDrawingInput() {
 	if scene.Config.Drawmode {
 		switch {
-		case inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft):
+		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft):
-			scene.ToggleCellOnCursorPos()
+			scene.ToggleCellOnCursorPos(Alive)
+		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight):
+			scene.ToggleCellOnCursorPos(Dead)
 		case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
 			scene.Config.Drawmode = false
 		}
@@ -421,7 +419,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)+STRIDE*(x+startx)]
+			grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx].State
 		}
 	}
 
@@ -467,14 +465,14 @@ func (scene *ScenePlay) Update() error {
 }
 
 // set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos() {
+func (scene *ScenePlay) ToggleCellOnCursorPos(alive uint8) {
 	// 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+STRIDE*x] ^= 1
+		scene.Grids[scene.Index].Data[y][x].State = alive
 		scene.History.Age[y][x] = 1
 	}
 }
@@ -500,7 +498,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+STRIDE*x] == 1 {
+				if scene.Grids[scene.Index].Data[y][x].State == 1 {
 					scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
 				}
 			}
@@ -517,7 +515,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+STRIDE*x] {
+	switch scene.Grids[scene.Index].Data[y][x].State {
 	case Alive:
 		if age > 50 && scene.Config.ShowEvolution {
 			scene.World.DrawImage(scene.Theme.Tile(ColOld), op)

src/theme.go

@@ -42,10 +42,10 @@ var THEMES = map[string]ThemeDef{
 		dead: "5a5a5a",
 		old:  "ff1e1e",
 		grid: "808080",
-		age3: "6c6059",
+		age1: "735f52",
-		age2: "735f52",
+		age2: "6c6059",
-		age1: "7b5e4b",
+		age3: "635d59",
-		age4: "635d59",
+		age4: "7b5e4b",
 	},
 	"dark": {
 		life: "c8c8c8",

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

@@ -87,17 +87,6 @@ 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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,306 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,306 +0,0 @@
-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,7 +238,35 @@ func (game *Game) Draw(screen *ebiten.Image) {
 }
 
 func main() {
-	size := 1500
+	//x := 1
+	//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,
@@ -247,7 +275,7 @@ func main() {
 		Density:   8,
 		TPG:       10,
 		Debug:     false,
-		Profile:   true,
+		Profile:   false,
 		Gridlines: false,
 	}