move to codeberg (#10)

See
424f62327b

Thanks a lot for the fast support, amazing!

.gitignore

@@ -6,3 +6,4 @@ rect*
 *prof
 *lif
 *rle
+svgicons

.goreleaser.yaml

@@ -0,0 +1,65 @@
+# vim: set ts=2 sw=2 tw=0 fo=cnqoj
+
+version: 2
+
+before:
+  hooks:
+    - go mod tidy
+
+gitea_urls:
+  api: https://codeberg.org/api/v1
+  download: https://codeberg.org
+  
+builds:
+  - env:
+      - CGO_ENABLED=0
+    goos:
+      - linux
+      - freebsd
+
+archives:
+  - formats: [tar.gz]
+    # this name template makes the OS and Arch compatible with the results of `uname`.
+    name_template: >-
+      {{ .ProjectName }}_
+      {{- title .Os }}_
+      {{- if eq .Arch "amd64" }}x86_64
+      {{- else if eq .Arch "386" }}i386
+      {{- else }}{{ .Arch }}{{ end }}
+      {{- if .Arm }}v{{ .Arm }}{{ end }}_{{ .Tag }}
+    # use zip for windows archives
+    format_overrides:
+      - goos: windows
+        formats: [zip]
+      - goos: linux
+        formats: [tar.gz,binary]
+    files:
+      - src: "*.md"
+        strip_parent: true
+      - src: Makefile.dist
+        dst: Makefile
+    wrap_in_directory: true
+
+changelog:
+  sort: asc
+  filters:
+    exclude:
+      - "^docs:"
+      - "^test:"
+  groups:
+    - title: Improved
+      regexp: '^.*?(feat|add|new)(\([[:word:]]+\))??!?:.+$'
+      order: 0
+    - title: Fixed
+      regexp: '^.*?(bug|fix)(\([[:word:]]+\))??!?:.+$'
+      order: 1
+    - title: Changed
+      order: 999
+
+release:
+  header: "# Release Notes"
+  footer: >-
+
+    ---
+
+    Full Changelog: [{{ .PreviousTag }}...{{ .Tag }}](https://codeberg.org/scip/golsky/compare/{{ .PreviousTag }}...{{ .Tag }})

Makefile

@@ -1,4 +1,103 @@
-.PHONY: all
-all:
-	make -C src
-	mv src/golsky .
+# Copyright © 2024 Thomas von Dein
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+
+#
+# no need to modify anything below
+tool      = golsky
+VERSION   = $(shell grep VERSION main.go | head -1 | cut -d '"' -f2)
+archs     = darwin freebsd linux windows
+PREFIX    = /usr/local
+UID       = root
+GID       = 0
+HAVE_POD := $(shell pod2text -h 2>/dev/null)
+#TAGS      = -tags=ebitenginedebug
+
+all: buildlocal
+
+
+buildlocal:
+	go build $(TAGS) -o $(tool)
+
+install: buildlocal
+	install -d -o $(UID) -g $(GID) $(PREFIX)/bin
+	install -d -o $(UID) -g $(GID) $(PREFIX)/man/man1
+	install -o $(UID) -g $(GID) -m 555 $(tool)  $(PREFIX)/sbin/
+	install -o $(UID) -g $(GID) -m 444 $(tool).1 $(PREFIX)/man/man1/
+
+clean:
+	rm -rf $(tool) coverage.out testdata t/out
+
+test: clean
+	mkdir -p t/out
+	go test ./... $(ARGS)
+
+testlint: test lint
+
+lint:
+	golangci-lint run
+
+lint-full:
+	golangci-lint run --enable-all --exclude-use-default --disable exhaustivestruct,exhaustruct,depguard,interfacer,deadcode,golint,structcheck,scopelint,varcheck,ifshort,maligned,nosnakecase,godot,funlen,gofumpt,cyclop,noctx,gochecknoglobals,paralleltest
+
+testfuzzy: clean
+	go test -fuzz ./... $(ARGS)
+
+singletest:
+	@echo "Call like this: make singletest TEST=TestPrepareColumns ARGS=-v"
+	go test -run $(TEST) $(ARGS)
+
+cover-report:
+	go test ./... -cover -coverprofile=coverage.out
+	go tool cover -html=coverage.out
+
+goupdate:
+	go get -t -u=patch ./...
+
+buildall:
+	./mkrel.sh $(tool) $(VERSION)
+
+release: buildall
+	gh release create $(VERSION) --generate-notes releases/*
+
+show-versions: buildlocal
+	@echo "### golsky version:"
+	@./golsky -V
+
+	@echo
+	@echo "### go module versions:"
+	@go list -m all
+
+	@echo
+	@echo "### go version used for building:"
+	@grep -m 1 go go.mod
+
+# lint:
+# 	golangci-lint run -p bugs -p unused
+
+buildwasm:
+	env GOOS=js GOARCH=wasm go build -o $(tool).wasm $(LDFLAGS) .
+
+zipwasm:
+	zip -r openquell-$(SHORTVERSION).zip index.html $(tool).wasm wasm_exec.js
+
+wasm: buildwasm zipwasm
+	@ls -l $(tool)-$(SHORTVERSION).zip
+
+
+.PHONY: profile
+profile: build
+	./golsky -W 1500 -H 1500 -d --profile-file cpu.profile
+	go tool pprof --http localhost:8888 golsky cpu.profile

Makefile.dist

@@ -0,0 +1,18 @@
+# -*-make-*-
+
+.PHONY: install all
+
+tool   = rpn
+PREFIX = /usr/local
+UID    = root
+GID    = 0
+
+all:
+	@echo "Type 'sudo make install' to install the tool."
+	@echo "To change prefix, type 'sudo make install PREFIX=/opt'"
+
+install:
+	install -d -o $(UID) -g $(GID) $(PREFIX)/bin
+	install -d -o $(UID) -g $(GID) $(PREFIX)/share/doc
+	install -o $(UID) -g $(GID) -m 555 $(tool)  $(PREFIX)/sbin/
+	install -o $(UID) -g $(GID) -m 444 *.md $(PREFIX)/share/doc/

README.md

@@ -1,12 +1,11 @@
 # golsky - Conway's game of life written in GO
 
-![Golsky Logo](https://github.com/TLINDEN/golsky/blob/main/.github/assets/golskylogo.png)
+![Golsky Logo](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/golskylogo.png)
 
-[![License](https://img.shields.io/badge/license-GPL-blue.svg)](https://github.com/tlinden/golsky/blob/master/LICENSE)
-[![Go Report Card](https://goreportcard.com/badge/github.com/tlinden/golsky)](https://goreportcard.com/report/github.com/tlinden/golsky) 
+[![License](https://img.shields.io/badge/license-GPL-blue.svg)](https://codeberg.org/scip/golsky/blob/master/LICENSE)
+[![Go Report Card](https://goreportcard.com/badge/codeberg.org/scip/golsky)](https://goreportcard.com/report/codeberg.org/scip/golsky) 
 
-I wanted to play around a little bit with [**Conways Game of
-Life**](https://conwaylife.com/)
+I wanted to play around a little bit with [**Conways Game of Life**](https://conwaylife.com/)
 in golang and here's the  result. It's a simple game using
 [ebitengine](https://github.com/hajimehoshi/ebiten/).
 
@@ -14,6 +13,20 @@ John Conway himself: https://youtu.be/R9Plq-D1gEk?si=yYxs77e9yXxeSNbL
 
 Based on: https://youtu.be/FWSR_7kZuYg?si=ix1dmo76D8AmF25F
 
+# Screenshots
+[![golsky-mainmenu.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-mainmenu.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-mainmenu.png)
+[![golsky-options.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-options.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-options.png)
+[![golsky-bindings.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-bindings.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-bindings.png)
+[![golsky-evolution-trace.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-evolution-trace.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-evolution-trace.png)
+[![golsky-zoom.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-zoom.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-zoom.png)
+[![golsky-debug.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-debug.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-debug.png)
+[![golsky-capture.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-capture.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-capture.png)
+[![golsky-captured.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-captured.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-captured.png)
+[![golsky-dark-theme.png](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/256_golsky-dark-theme.png)](https://codeberg.org/scip/golsky/raw/branch/main/.github/assets/screenshots/golsky-dark-theme.png)
+
+
+[Youtube video game preview](https://www.youtube.com/watch?v=xEto6Oew16I)
+
 # Features
 
 * flexible parameters as grid and cell size
@@ -69,14 +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 middle mouse button pressed: move canvas
+* move mouse while left mouse button pressed: move canvas
+* i: enter "insert" (draw) mode: use left mouse to toggle cells alife state.
+  Leave with insert mode "space". While in insert mode, use middle mouse
+  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)
@@ -87,7 +102,7 @@ While it runs, there are a couple of commands you can use:
 
 # Report bugs
 
-[Please open an issue](https://github.com/TLINDEN/golsky/issues). Thanks!
+[Please open an issue](https://codeberg.org/scip/golsky/issues). Thanks!
 
 # License
 

TODO.md

@@ -1,25 +1,30 @@
 - add all other options like size etc
-- do not process history if turned off
 - add gif export
-- add toolbar
-- turn input ifs to switch
-- add insert mode for edit like vi
-- use left mouse to drag grid unless insert mode is active
-- keep supporting middle mouse to drag so that dragging is possible in insert mode
+- add toolbar (not working yet, see branch trackui)
+- only draw visible part of the world
 - print current mode to the bottom like pause, insert and mark
 - add https://www.ibiblio.org/lifepatterns/october1970.html
-- use uint8 or bool, history needs not be larger than 256 anyway
 - history: dont count age but do calc to get index to age tile based on cell age
 - maybe pre calc neighbors as 8 slice of pointers to neighboring cells to faster do the count
+  see various-tests/perf-2dim-pointers/: it's NOT faster :(
+- use an array of 8 pointers to neighbors. on edge just add either fake dead neighbors or the wrap around neighbors.
+- try arche ecs variant with either a component of the cells neighbors or using relations.
 - https://mattnakama.com/blog/go-branchless-coding/
 - add performance measurements, see:
-  DrawTriangles: https://github.com/TLINDEN/testgol
-  WritePixels:   https://github.com/TLINDEN/testgol/tree/wrpixels
+  DrawTriangles: https://codeberg.org/scip/testgol
+  WritePixels:   https://codeberg.org/scip/testgol/tree/wrpixels
 https://www.tasnimzotder.com/blog/optimizing-game-of-life-algorithm
-
+- pre-draw the grid separately to a cache grid image, then during
+  rendering, first draw the dead background, then the life cells, and
+  lastly the grid - if enabled. If disabled, there's be no gap between
+  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

cmd/camera.go

@@ -1,6 +1,6 @@
 // this comes from the camera example but I enhanced it a little bit
 
-package main
+package cmd
 
 import (
 	"fmt"

cmd/config.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"errors"
@@ -10,29 +10,31 @@ import (
 	"strings"
 
 	"github.com/spf13/pflag"
-	"github.com/tlinden/golsky/rle"
+	"codeberg.org/scip/golsky/rle"
 )
 
 // all the settings comming from commandline, but maybe tweaked later from the UI
 type Config struct {
-	Width, Height, Cellsize, Density       int // measurements
-	ScreenWidth, ScreenHeight              int
-	TPG                                    int      // ticks per generation/game speed, 1==max
-	Debug, Empty, Invert, Paused, Markmode bool     // game modi
-	ShowEvolution, ShowGrid, RunOneStep    bool     // flags
-	Rule                                   *Rule    // which rule to use, default: B3/S23
-	RLE                                    *rle.RLE // loaded GOL pattern from RLE file
-	Statefile                              string   // load game state from it if non-nil
-	StateGrid                              *Grid    // a grid from a statefile
-	Wrap                                   bool     // wether wraparound mode is in place or not
-	ShowVersion                            bool
-	UseShader                              bool // to use a shader to render alife cells
-	Restart, RestartGrid, RestartCache     bool
-	StartWithMenu                          bool
-	Zoomfactor                             int
-	ZoomOutFactor                          int
-	InitialCamPos                          []float64
-	DelayedStart                           bool // if true game, we wait. like pause but program induced
+	Width, Height, Cellsize, Density         int // measurements
+	ScreenWidth, ScreenHeight                int
+	TPG                                      int      // ticks per generation/game speed, 1==max
+	Debug, Empty, Paused, Markmode, Drawmode bool     // game modi
+	ShowEvolution, ShowGrid, RunOneStep      bool     // flags
+	Rule                                     *Rule    // which rule to use, default: B3/S23
+	RLE                                      *rle.RLE // loaded GOL pattern from RLE file
+	Statefile                                string   // load game state from it if non-nil
+	StateGrid                                *Grid    // a grid from a statefile
+	Wrap                                     bool     // wether wraparound mode is in place or not
+	ShowVersion                              bool
+	UseShader                                bool // to use a shader to render alife cells
+	Restart, RestartGrid, RestartCache       bool
+	StartWithMenu                            bool
+	Zoomfactor                               int
+	ZoomOutFactor                            int
+	InitialCamPos                            []float64
+	DelayedStart                             bool // if true game, we wait. like pause but program induced
+	Theme                                    string
+	ThemeManager                             ThemeManager
 
 	// for internal profiling
 	ProfileFile     string
@@ -41,19 +43,39 @@ type Config struct {
 }
 
 const (
-	VERSION = "v0.0.8"
+	VERSION = "v0.0.9"
 	Alive   = 1
 	Dead    = 0
 
 	DEFAULT_GRID_WIDTH  = 600
 	DEFAULT_GRID_HEIGHT = 400
 	DEFAULT_CELLSIZE    = 4
-	DEFAULT_ZOOMFACTOR  = 150
+	DEFAULT_ZOOMFACTOR  = 400
 	DEFAULT_GEOM        = "640x384"
+	DEFAULT_THEME       = "standard"
 )
 
+const KEYBINDINGS string = `
+- SPACE: pause or resume the game
+- N: while game is paused: forward one step
+- PAGE UP: speed up
+- 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.
+     Leave with insert mode with "space". While in insert mode, use middle mouse
+     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)
+- C: enter mark mode. Mark a rectangle with the mouse, when you
+     release the mouse buttonx it is being saved to an RLE file
+- D: toggle debug output 
+- Q: quit game
+`
+
 func (config *Config) SetupCamera() {
-	config.Zoomfactor = DEFAULT_ZOOMFACTOR
+	config.Zoomfactor = DEFAULT_ZOOMFACTOR / config.Cellsize
 
 	// calculate the initial cam pos. It is negative if the total grid
 	// size  is smaller than  the screen  in a centered  position, but
@@ -107,7 +129,7 @@ func (config *Config) ParseGeom(geom string) error {
 	config.ScreenWidth = width
 	config.ScreenHeight = height
 
-	config.Cellsize = DEFAULT_CELLSIZE
+	//config.Cellsize = DEFAULT_CELLSIZE
 
 	return nil
 }
@@ -201,18 +223,20 @@ func ParseCommandline() (*Config, error) {
 	pflag.StringVarP(&rlefile, "pattern-file", "f", "", "RLE or LIF pattern file")
 
 	pflag.BoolVarP(&config.ShowVersion, "version", "v", false, "show version")
+	pflag.BoolVarP(&config.ShowGrid, "show-grid", "g", false, "draw grid lines")
+	pflag.BoolVarP(&config.ShowEvolution, "show-evolution", "s", false, "show evolution traces")
+
 	pflag.BoolVarP(&config.Paused, "paused", "p", false, "do not start simulation (use space to start)")
 	pflag.BoolVarP(&config.Debug, "debug", "d", false, "show debug info")
-	pflag.BoolVarP(&config.ShowGrid, "show-grid", "g", false, "draw grid lines")
 	pflag.BoolVarP(&config.Empty, "empty", "e", false, "start with an empty screen")
-	pflag.BoolVarP(&config.Invert, "invert", "i", false, "invert colors (dead cell: black)")
-	pflag.BoolVarP(&config.ShowEvolution, "show-evolution", "s", false, "show evolution traces")
+
+	// style
+	pflag.StringVarP(&config.Theme, "theme", "T", DEFAULT_THEME, "color theme: standard, dark, light (default: standard)")
+
 	pflag.BoolVarP(&config.Wrap, "wrap-around", "w", false, "wrap around grid mode")
 	pflag.BoolVarP(&config.UseShader, "use-shader", "k", false, "use shader for cell rendering")
 
 	pflag.StringVarP(&config.ProfileFile, "profile-file", "", "", "enable profiling")
-	pflag.BoolVarP(&config.ProfileDraw, "profile-draw", "", false, "profile draw method (default false)")
-	pflag.Int64VarP(&config.ProfileMaxLoops, "profile-max-loops", "", 10, "how many loops to execute (default 10)")
 
 	pflag.Parse()
 
@@ -234,6 +258,8 @@ func ParseCommandline() (*Config, error) {
 
 	config.SetupCamera()
 
+	config.ThemeManager = NewThemeManager(config.Theme, config.Cellsize)
+
 	//repr.Println(config)
 	return &config, nil
 }
@@ -246,8 +272,8 @@ func (config *Config) ToggleDebugging() {
 	config.Debug = !config.Debug
 }
 
-func (config *Config) ToggleInvert() {
-	config.Invert = !config.Invert
+func (config *Config) SwitchTheme(theme string) {
+	config.ThemeManager.SetCurrentTheme(theme)
 	config.RestartCache = true
 }
 

cmd/game.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"github.com/hajimehoshi/ebiten/v2"
@@ -10,7 +10,6 @@ type Game struct {
 	CurrentScene                                    SceneName
 	Config                                          *Config
 	Scale                                           float32
-	Screen                                          *ebiten.Image
 }
 
 func NewGame(config *Config, startscene SceneName) *Game {
@@ -26,6 +25,7 @@ func NewGame(config *Config, startscene SceneName) *Game {
 	game.Scenes[Play] = NewPlayScene(game, config)
 	game.Scenes[Menu] = NewMenuScene(game, config)
 	game.Scenes[Options] = NewOptionsScene(game, config)
+	game.Scenes[Keybindings] = NewKeybindingsScene(game, config)
 
 	// setup environment
 	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
@@ -33,7 +33,6 @@ func NewGame(config *Config, startscene SceneName) *Game {
 	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
 	ebiten.SetScreenClearedEveryFrame(true)
 
-	game.Screen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
 	return game
 }
 

cmd/generics.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 // find an item in a list, generic variant
 func Contains[E comparable](s []E, v E) bool {
@@ -10,3 +10,10 @@ func Contains[E comparable](s []E, v E) bool {
 
 	return false
 }
+
+func Exists[K comparable, V any](m map[K]V, v K) bool {
+	if _, ok := m[v]; ok {
+		return true
+	}
+	return false
+}

cmd/grid.go

@@ -0,0 +1,383 @@
+package cmd
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"math/rand"
+	"os"
+	"strings"
+	"time"
+
+	"codeberg.org/scip/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          []uint8
+	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),
+		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.Config = grid.Config
+	newgrid.Data = grid.Data
+
+	return newgrid
+}
+
+// copy data
+// func (grid *Grid) Copy(other *Grid) {
+// 	for y := range grid.Data {
+// 		for x := range grid.Data[y] {
+// 			other.Data[y+STRIDE*x] = grid.Data[y+STRIDE*x]
+// 		}
+// 	}
+// }
+
+// delete all contents
+// func (grid *Grid) Clear() {
+// 	for y := range grid.Data {
+// 		for x := range grid.Data[y] {
+// 			grid.Data[y+STRIDE*x] = 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 x := 0; x < grid.Config.Width; x++ {
+				if rand.Intn(grid.Config.Density) == 1 {
+					grid.Data[y+STRIDE*x] = 1
+				}
+			}
+		}
+	}
+}
+
+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 {
+				fmt.Print("XX")
+			} else {
+				fmt.Print("  ")
+			}
+		}
+		fmt.Println()
+	}
+}
+
+// initialize using a given RLE pattern
+func (grid *Grid) LoadRLE(pattern *rle.RLE) {
+	if pattern != nil {
+		startX := (grid.Config.Width / 2) - (pattern.Width / 2)
+		startY := (grid.Config.Height / 2) - (pattern.Height / 2)
+		var y, x int
+
+		for rowIndex, patternRow := range pattern.Pattern {
+			for colIndex := range patternRow {
+				if pattern.Pattern[rowIndex][colIndex] > 0 {
+					x = colIndex + startX
+					y = rowIndex + startY
+
+					grid.Data[y+STRIDE*x] = 1
+				}
+			}
+		}
+
+		//grid.Dump()
+	}
+}
+
+// load a lif file parameters like R and P are not supported yet
+func LoadLIF(filename string) (*rle.RLE, error) {
+	fd, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := bufio.NewScanner(fd)
+
+	scanner.Split(bufio.ScanLines)
+
+	gothead := false
+
+	grid := &rle.RLE{}
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		items := strings.Split(line, "")
+
+		if len(items) < 0 {
+			continue
+		}
+
+		if strings.Contains(line, "# r") {
+			parts := strings.Split(line, " ")
+			if len(parts) == 2 {
+				grid.Rule = parts[1]
+			}
+
+			continue
+		}
+
+		if items[0] == "#" {
+			if gothead {
+				break
+			}
+
+			continue
+		}
+
+		gothead = true
+
+		row := make([]int, len(items))
+
+		for idx, item := range items {
+			switch item {
+			case ".":
+				row[idx] = 0
+			case "o":
+				fallthrough
+			case "*":
+				row[idx] = 1
+			default:
+				return nil, errors.New("cells must be . or o")
+			}
+		}
+
+		grid.Pattern = append(grid.Pattern, row)
+	}
+
+	// sanity check the grid
+	explen := 0
+	rows := 0
+	first := true
+	for _, row := range grid.Pattern {
+		length := len(row)
+
+		if first {
+			explen = length
+			first = false
+		}
+
+		if explen != length {
+			return nil, fmt.Errorf(
+				fmt.Sprintf("all rows must be in the same length, got: %d, expected: %d",
+					length, explen))
+		}
+
+		rows++
+	}
+
+	grid.Width = explen
+	grid.Height = rows
+
+	return grid, nil
+}
+
+// save  the contents  of  the  whole grid  as  a  simple lif  alike
+// file. One line per row, 0 for dead and 1 for life cell.
+// file format: https://conwaylife.com/wiki/Life_1.05
+func (grid *Grid) SaveState(filename, rule string) error {
+	file, err := os.Create(filename)
+	if err != nil {
+		return fmt.Errorf("failed to open state file: %w", err)
+	}
+	defer file.Close()
+
+	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 x := 0; x < grid.Config.Width; x++ {
+			row := "."
+			if grid.Data[y+STRIDE*x] == 1 {
+				row = "o"
+			}
+
+			_, err := file.WriteString(row)
+			if err != nil {
+				return fmt.Errorf("failed to write to state file: %w", err)
+			}
+		}
+		file.WriteString("\n")
+	}
+
+	return nil
+}
+
+// generate filenames for dumps
+func GetFilename(generations int64) string {
+	now := time.Now()
+	return fmt.Sprintf("dump-%s-%d.lif", now.Format("20060102150405"), generations)
+}
+
+func GetFilenameRLE(generations int64) string {
+	now := time.Now()
+	return fmt.Sprintf("rect-%s-%d.rle", now.Format("20060102150405"), generations)
+}

cmd/keybindings.go

@@ -0,0 +1,98 @@
+package cmd
+
+import (
+	"image/color"
+
+	"github.com/ebitenui/ebitenui"
+	"github.com/ebitenui/ebitenui/widget"
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type SceneKeybindings struct {
+	Game      *Game
+	Config    *Config
+	Next      SceneName
+	Prev      SceneName
+	Whoami    SceneName
+	Ui        *ebitenui.UI
+	FontColor color.RGBA
+	First     bool
+}
+
+func NewKeybindingsScene(game *Game, config *Config) Scene {
+	scene := &SceneKeybindings{
+		Whoami:    Keybindings,
+		Game:      game,
+		Next:      Keybindings,
+		Config:    config,
+		FontColor: color.RGBA{255, 30, 30, 0xff},
+	}
+
+	scene.Init()
+
+	return scene
+}
+
+func (scene *SceneKeybindings) GetNext() SceneName {
+	return scene.Next
+}
+
+func (scene *SceneKeybindings) SetPrevious(prev SceneName) {
+	scene.Prev = prev
+}
+
+func (scene *SceneKeybindings) ResetNext() {
+	scene.Next = scene.Whoami
+}
+
+func (scene *SceneKeybindings) SetNext(next SceneName) {
+	scene.Next = next
+}
+
+func (scene *SceneKeybindings) Update() error {
+	scene.Ui.Update()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
+		scene.Config.DelayedStart = false
+		scene.Leave()
+	}
+
+	return nil
+
+}
+
+func (scene *SceneKeybindings) IsPrimary() bool {
+	return false
+}
+
+func (scene *SceneKeybindings) Draw(screen *ebiten.Image) {
+	scene.Ui.Draw(screen)
+}
+
+func (scene *SceneKeybindings) Leave() {
+	scene.SetNext(Play)
+}
+
+func (scene *SceneKeybindings) Init() {
+	rowContainer := NewRowContainer("Key Bindings")
+
+	bindings := widget.NewText(
+		widget.TextOpts.WidgetOpts(widget.WidgetOpts.LayoutData(widget.RowLayoutData{
+			Stretch: true,
+		})),
+		widget.TextOpts.Text(KEYBINDINGS, *FontRenderer.FontSmall, color.NRGBA{0xdf, 0xf4, 0xff, 0xff}))
+
+	cancel := NewMenuButton("Back",
+		func(args *widget.ButtonClickedEventArgs) {
+			scene.Leave()
+		})
+
+	rowContainer.AddChild(bindings)
+	rowContainer.AddChild(cancel)
+
+	scene.Ui = &ebitenui.UI{
+		Container: rowContainer.Container(),
+	}
+
+}

cmd/loader-fonts.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"log"

cmd/loader-shaders.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"bytes"

cmd/loader-sprites.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"embed"

cmd/menu.go

@@ -1,8 +1,7 @@
-package main
+package cmd
 
 import (
 	"image/color"
-	"os"
 
 	"github.com/ebitenui/ebitenui"
 	"github.com/ebitenui/ebitenui/widget"
@@ -19,6 +18,7 @@ type SceneMenu struct {
 	Ui        *ebitenui.UI
 	FontColor color.RGBA
 	First     bool
+	Exit      bool
 }
 
 func NewMenuScene(game *Game, config *Config) Scene {
@@ -54,6 +54,10 @@ func (scene *SceneMenu) SetNext(next SceneName) {
 func (scene *SceneMenu) Update() error {
 	scene.Ui.Update()
 
+	if scene.Exit {
+		return ebiten.Termination
+	}
+
 	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
 		scene.Config.DelayedStart = false
 		scene.Leave()
@@ -104,6 +108,11 @@ func (scene *SceneMenu) Init() {
 			scene.SetNext(Options)
 		})
 
+	bindings := NewMenuButton("Show Key Bindings",
+		func(args *widget.ButtonClickedEventArgs) {
+			scene.SetNext(Keybindings)
+		})
+
 	separator1 := NewSeparator(3)
 	separator2 := NewSeparator(3)
 	separator3 := NewSeparator(10)
@@ -115,7 +124,7 @@ func (scene *SceneMenu) Init() {
 
 	quit := NewMenuButton("Exit Golsky",
 		func(args *widget.ButtonClickedEventArgs) {
-			os.Exit(0)
+			scene.Exit = true
 		})
 
 	rowContainer.AddChild(empty)
@@ -123,6 +132,7 @@ func (scene *SceneMenu) Init() {
 	rowContainer.AddChild(separator1)
 	rowContainer.AddChild(options)
 	rowContainer.AddChild(copy)
+	rowContainer.AddChild(bindings)
 	rowContainer.AddChild(separator2)
 	rowContainer.AddChild(cancel)
 	rowContainer.AddChild(separator3)

cmd/options.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"image/color"
@@ -69,55 +69,67 @@ func (scene *SceneOptions) Draw(screen *ebiten.Image) {
 }
 
 func (scene *SceneOptions) SetInitialValue(w *widget.LabeledCheckbox, value bool) {
-	var intval int
 	if value {
-		intval = 1
+		w.SetState(
+			widget.WidgetChecked,
+		)
 	}
-
-	w.SetState(
-		widget.WidgetState(intval),
-	)
 }
 
 func (scene *SceneOptions) Init() {
 	rowContainer := NewRowContainer("Options")
 
 	pause := NewCheckbox("Pause",
+		scene.Config.Paused,
 		func(args *widget.CheckboxChangedEventArgs) {
 			scene.Config.TogglePaused()
 		})
 
 	debugging := NewCheckbox("Debugging",
+		scene.Config.Debug,
 		func(args *widget.CheckboxChangedEventArgs) {
 			scene.Config.ToggleDebugging()
 		})
-	scene.SetInitialValue(debugging, scene.Config.Debug)
-
-	invert := NewCheckbox("Invert",
-		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.ToggleInvert()
-		})
-	scene.SetInitialValue(invert, scene.Config.Invert)
 
 	gridlines := NewCheckbox("Show grid lines",
+		scene.Config.ShowGrid,
 		func(args *widget.CheckboxChangedEventArgs) {
 			scene.Config.ToggleGridlines()
 		})
-	scene.SetInitialValue(gridlines, scene.Config.ShowGrid)
 
 	evolution := NewCheckbox("Show evolution traces",
+		scene.Config.ShowEvolution,
 		func(args *widget.CheckboxChangedEventArgs) {
 			scene.Config.ToggleEvolution()
 		})
-	scene.SetInitialValue(evolution, scene.Config.ShowEvolution)
 
 	wrap := NewCheckbox("Wrap around edges",
+		scene.Config.Wrap,
 		func(args *widget.CheckboxChangedEventArgs) {
 			scene.Config.ToggleWrap()
 		})
-	scene.SetInitialValue(wrap, scene.Config.Wrap)
+
+	themenames := make([]string, len(THEMES))
+	i := 0
+	for name := range THEMES {
+		themenames[i] = name
+		i++
+	}
+
+	themes := NewCombobox(
+		themenames,
+		scene.Config.Theme,
+		func(args *widget.ListComboButtonEntrySelectedEventArgs) {
+			scene.Config.SwitchTheme(args.Entry.(ListEntry).Name)
+		})
+
+	themelabel := NewLabel("Themes")
+	combocontainer := NewColumnContainer()
+	combocontainer.AddChild(themes)
+	combocontainer.AddChild(themelabel)
 
 	separator := NewSeparator(3)
+	separator2 := NewSeparator(3)
 
 	cancel := NewMenuButton("Close",
 		func(args *widget.ButtonClickedEventArgs) {
@@ -126,11 +138,16 @@ func (scene *SceneOptions) Init() {
 
 	rowContainer.AddChild(pause)
 	rowContainer.AddChild(debugging)
-	rowContainer.AddChild(invert)
 	rowContainer.AddChild(gridlines)
 	rowContainer.AddChild(evolution)
 	rowContainer.AddChild(wrap)
+
 	rowContainer.AddChild(separator)
+
+	rowContainer.AddChild(combocontainer)
+
+	rowContainer.AddChild(separator2)
+
 	rowContainer.AddChild(cancel)
 
 	scene.Ui = &ebitenui.UI{

cmd/play.go

@@ -1,15 +1,16 @@
-package main
+package cmd
 
 import (
 	"fmt"
 	"image"
-	"image/color"
 	"log"
+	"sync"
+	"unsafe"
 
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/inpututil"
 	"github.com/hajimehoshi/ebiten/v2/vector"
-	"github.com/tlinden/golsky/rle"
+	"codeberg.org/scip/golsky/rle"
 	"golang.org/x/image/math/f64"
 )
 
@@ -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
@@ -30,24 +46,23 @@ type ScenePlay struct {
 
 	Clear bool
 
-	Grids                                      []*Grid // 2 grids: one current, one next
-	History                                    *Grid   // holds state of past dead cells for evolution traces
-	Index                                      int     // points to current grid
-	Generations                                int64   // Stats
-	Black, White, Grey, Old                    color.RGBA
-	AgeColor1, AgeColor2, AgeColor3, AgeColor4 color.RGBA
-	TicksElapsed                               int           // tick counter for game speed
-	Tiles                                      Images        // pre-computed tiles for dead and alife cells
-	Camera                                     Camera        // for zoom+move
-	World, Cache                               *ebiten.Image // actual image we render to
-	WheelTurned                                bool          // when user turns wheel multiple times, zoom faster
-	Dragging                                   bool          // middle mouse is pressed, move canvas
-	LastCursorPos                              []int         // used to check if the user is dragging
-	MarkTaken                                  bool          // true when mouse1 pressed
-	MarkDone                                   bool          // true when mouse1 released, copy cells between Mark+Point
-	Mark, Point                                image.Point   // area to marks+save
-	RunOneStep                                 bool          // mutable flags from config
-	TPG                                        int
+	Grids         []*Grid       // 2 grids: one current, one next
+	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
+	Camera        Camera        // for zoom+move
+	World, Cache  *ebiten.Image // actual image we render to
+	WheelTurned   bool          // when user turns wheel multiple times, zoom faster
+	Dragging      bool          // middle mouse is pressed, move canvas
+	LastCursorPos []float64     // used to check if the user is dragging
+	MarkTaken     bool          // true when mouse1 pressed
+	MarkDone      bool          // true when mouse1 released, copy cells between Mark+Point
+	Mark, Point   image.Point   // area to marks+save
+	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 {
@@ -85,16 +100,36 @@ func (scene *ScenePlay) SetNext(next SceneName) {
 	scene.Next = next
 }
 
-func (scene *ScenePlay) CheckRule(state int64, neighbors int64) int64 {
-	var nextstate int64
+/* 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 {
+	case 11:
+		fallthrough
+	case 12:
+		fallthrough
+	case 3:
+		return Alive
+	}
 
-	// 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.
+	return Dead
+}
 
-	if state == 0 && 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 == 1 && Contains(scene.Config.Rule.Death, neighbors) {
 		nextstate = Alive
@@ -118,27 +153,43 @@ 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 x := 0; x < scene.Config.Width; x++ {
-			state := scene.Grids[scene.Index].Data[y][x] // 0|1 == dead or alive
-			neighbors := scene.CountNeighbors(x, y)      // alive neighbor count
+	for y := 0; y < height; y++ {
 
-			// actually apply the current rules
-			nextstate := scene.CheckRule(state, neighbors)
+		go func() {
+			defer wg.Done()
 
-			// change state of current cell in next grid
-			scene.Grids[next].Data[y][x] = nextstate
+			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)
 
-			// set history  to current generation so we  can infer the
-			// age of the cell's state  during rendering and use it to
-			// deduce the color to use if evolution tracing is enabled
-			if state != nextstate {
-				scene.History.Data[y][x] = scene.Generations
+				// 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
+
+				if scene.Config.ShowEvolution {
+					// set history  to current generation so we  can infer the
+					// age of the cell's state  during rendering and use it to
+					// deduce the color to use if evolution tracing is enabled
+					// 60FPS:
+					if state != nextstate {
+						scene.History.Age[y][x] = scene.Generations
+					}
+				}
 			}
-		}
+		}()
 	}
 
+	wg.Wait()
+
 	// switch grid for rendering
 	scene.Index ^= 1
 
@@ -170,54 +221,40 @@ func (scene *ScenePlay) CheckExit() error {
 }
 
 func (scene *ScenePlay) CheckInput() {
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
+	// primary functions, always available
+	switch {
+	case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
 		scene.SetNext(Menu)
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyO) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyO):
 		scene.SetNext(Options)
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyC):
 		scene.Config.Markmode = true
+		scene.Config.Drawmode = false
+		scene.Config.Paused = true
+	case inpututil.IsKeyJustPressed(ebiten.KeyI):
+		scene.Config.Drawmode = true
 		scene.Config.Paused = true
 	}
 
 	if scene.Config.Markmode {
+		// no need to check any more input in mark mode
 		return
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) {
+	switch {
+	case inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter):
 		scene.Config.TogglePaused()
-	}
-
-	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
-		scene.ToggleCellOnCursorPos(Alive)
-		scene.Config.Paused = true // drawing while running makes no sense
-	}
-
-	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) {
-		scene.ToggleCellOnCursorPos(Dead)
-		scene.Config.Paused = true // drawing while running makes no sense
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageDown) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyPageDown):
 		if scene.TPG < 120 {
 			scene.TPG++
 		}
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageUp) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyPageUp):
 		if scene.TPG >= 1 {
 			scene.TPG--
 		}
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyS) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyS):
 		scene.SaveState()
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyD) {
+	case inpututil.IsKeyJustPressed(ebiten.KeyD):
 		scene.Config.Debug = !scene.Config.Debug
 	}
 
@@ -228,6 +265,17 @@ func (scene *ScenePlay) CheckInput() {
 	}
 }
 
+func (scene *ScenePlay) CheckDrawingInput() {
+	if scene.Config.Drawmode {
+		switch {
+		case inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft):
+			scene.ToggleCellOnCursorPos()
+		case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
+			scene.Config.Drawmode = false
+		}
+	}
+}
+
 // Check dragging input.  move the canvas with the  mouse while pressing
 // the middle mouse button, zoom in and out using the wheel.
 func (scene *ScenePlay) CheckDraggingInput() {
@@ -235,20 +283,26 @@ func (scene *ScenePlay) CheckDraggingInput() {
 		return
 	}
 
+	dragbutton := ebiten.MouseButtonLeft
+
+	if scene.Config.Drawmode {
+		dragbutton = ebiten.MouseButtonMiddle
+	}
+
 	// move canvas
-	if scene.Dragging && !ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
+	if scene.Dragging && !ebiten.IsMouseButtonPressed(dragbutton) {
 		// release
 		scene.Dragging = false
 	}
 
-	if !scene.Dragging && ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
+	if !scene.Dragging && ebiten.IsMouseButtonPressed(dragbutton) {
 		// start dragging
 		scene.Dragging = true
-		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
+		scene.LastCursorPos[0], scene.LastCursorPos[1] = scene.Camera.ScreenToWorld(ebiten.CursorPosition())
 	}
 
 	if scene.Dragging {
-		x, y := ebiten.CursorPosition()
+		x, y := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
 
 		if x != scene.LastCursorPos[0] || y != scene.LastCursorPos[1] {
 			// actually drag by mouse cursor pos diff to last cursor pos
@@ -256,20 +310,18 @@ func (scene *ScenePlay) CheckDraggingInput() {
 			scene.Camera.Position[1] -= float64(y - scene.LastCursorPos[1])
 		}
 
-		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
+		scene.LastCursorPos[0], scene.LastCursorPos[1] = scene.Camera.ScreenToWorld(ebiten.CursorPosition())
 	}
 
 	// also support the arrow keys to move the canvas
-	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) {
+	switch {
+	case ebiten.IsKeyPressed(ebiten.KeyArrowLeft):
 		scene.Camera.Position[0] -= 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) {
+	case ebiten.IsKeyPressed(ebiten.KeyArrowRight):
 		scene.Camera.Position[0] += 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) {
+	case ebiten.IsKeyPressed(ebiten.KeyArrowUp):
 		scene.Camera.Position[1] -= 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowDown) {
+	case ebiten.IsKeyPressed(ebiten.KeyArrowDown):
 		scene.Camera.Position[1] += 1
 	}
 
@@ -363,13 +415,13 @@ func (scene *ScenePlay) SaveRectRLE() {
 		height = scene.Mark.Y - scene.Point.Y
 	}
 
-	grid := make([][]int64, height)
+	grid := make([][]uint8, height)
 
 	for y := 0; y < height; y++ {
-		grid[y] = make([]int64, 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)]
 		}
 	}
 
@@ -393,7 +445,7 @@ func (scene *ScenePlay) Update() error {
 
 	if scene.Config.RestartCache {
 		scene.Config.RestartCache = false
-		scene.InitTiles()
+		scene.Theme = scene.Config.ThemeManager.GetCurrentTheme()
 		scene.InitCache()
 		return nil
 	}
@@ -403,6 +455,7 @@ func (scene *ScenePlay) Update() error {
 	}
 
 	scene.CheckInput()
+	scene.CheckDrawingInput()
 	scene.CheckDraggingInput()
 	scene.CheckMarkInput()
 
@@ -414,15 +467,15 @@ func (scene *ScenePlay) Update() error {
 }
 
 // set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos(alive int64) {
+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.History.Data[y][x] = 1
+		scene.Grids[scene.Index].Data[y+STRIDE*x] ^= 1
+		scene.History.Age[y][x] = 1
 	}
 }
 
@@ -436,8 +489,6 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 	op.GeoM.Translate(0, 0)
 	scene.World.DrawImage(scene.Cache, op)
 
-	var age int64
-
 	for y := 0; y < scene.Config.Height; y++ {
 		for x := 0; x < scene.Config.Width; x++ {
 			op.GeoM.Reset()
@@ -446,29 +497,11 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 				float64(y*scene.Config.Cellsize),
 			)
 
-			age = scene.Generations - scene.History.Data[y][x]
-
-			switch scene.Grids[scene.Index].Data[y][x] {
-			case Alive:
-				if age > 50 && scene.Config.ShowEvolution {
-					scene.World.DrawImage(scene.Tiles.Old, op)
-
-				} else {
-					scene.World.DrawImage(scene.Tiles.Black, op)
-				}
-			case Dead:
-				// only draw dead cells in case evolution trace is enabled
-				if scene.History.Data[y][x] > 1 && scene.Config.ShowEvolution {
-					switch {
-					case age < 10:
-						scene.World.DrawImage(scene.Tiles.Age1, op)
-					case age < 20:
-						scene.World.DrawImage(scene.Tiles.Age2, op)
-					case age < 30:
-						scene.World.DrawImage(scene.Tiles.Age3, op)
-					default:
-						scene.World.DrawImage(scene.Tiles.Age4, op)
-					}
+			if scene.Config.ShowEvolution {
+				scene.DrawEvolution(screen, x, y, op)
+			} else {
+				if scene.Grids[scene.Index].Data[y+STRIDE*x] == 1 {
+					scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
 				}
 			}
 		}
@@ -479,11 +512,33 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 	scene.Camera.Render(scene.World, screen)
 
 	scene.DrawDebug(screen)
+}
 
-	op.GeoM.Reset()
-	op.GeoM.Translate(0, 0)
+func (scene *ScenePlay) DrawEvolution(screen *ebiten.Image, x, y int, op *ebiten.DrawImageOptions) {
+	age := scene.Generations - scene.History.Age[y][x]
 
-	scene.Game.Screen.DrawImage(screen, op)
+	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)
+		} else {
+			scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
+		}
+	case Dead:
+		// only draw dead cells in case evolution trace is enabled
+		if scene.History.Age[y][x] > 1 && scene.Config.ShowEvolution {
+			switch {
+			case age < 10:
+				scene.World.DrawImage(scene.Theme.Tile(ColAge1), op)
+			case age < 20:
+				scene.World.DrawImage(scene.Theme.Tile(ColAge2), op)
+			case age < 30:
+				scene.World.DrawImage(scene.Theme.Tile(ColAge3), op)
+			default:
+				scene.World.DrawImage(scene.Theme.Tile(ColAge4), op)
+			}
+		}
+	}
 }
 
 func (scene *ScenePlay) DrawMark(screen *ebiten.Image) {
@@ -497,7 +552,7 @@ func (scene *ScenePlay) DrawMark(screen *ebiten.Image) {
 			scene.World,
 			x+1, y+1,
 			w, h,
-			1.0, scene.Old, false,
+			1.0, scene.Theme.Color(ColOld), false,
 		)
 	}
 }
@@ -513,6 +568,10 @@ func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
 			paused = "-- mark --"
 		}
 
+		if scene.Config.Drawmode {
+			paused = "-- insert --"
+		}
+
 		x, y := ebiten.CursorPosition()
 		debug := fmt.Sprintf(
 			DEBUG_FORMAT,
@@ -525,10 +584,10 @@ func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
 		FontRenderer.Renderer.SetSizePx(10 + int(scene.Game.Scale*10))
 		FontRenderer.Renderer.SetTarget(screen)
 
-		FontRenderer.Renderer.SetColor(scene.Black)
+		FontRenderer.Renderer.SetColor(scene.Theme.Color(ColLife))
 		FontRenderer.Renderer.Draw(debug, 31, 31)
 
-		FontRenderer.Renderer.SetColor(scene.Old)
+		FontRenderer.Renderer.SetColor(scene.Theme.Color(ColOld))
 		FontRenderer.Renderer.Draw(debug, 30, 30)
 
 		fmt.Println(debug)
@@ -539,18 +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)
-	scene.History.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.Grey)
-	} else {
-		scene.Cache.Fill(scene.White)
-	}
+	scene.Cache.Fill(scene.Theme.Color(ColGrid))
 
 	for y := 0; y < scene.Config.Height; y++ {
 		for x := 0; x < scene.Config.Width; x++ {
@@ -560,68 +625,26 @@ func (scene *ScenePlay) InitCache() {
 				float64(y*scene.Config.Cellsize),
 			)
 
-			scene.Cache.DrawImage(scene.Tiles.White, op)
+			scene.Cache.DrawImage(scene.Theme.Tile(ColDead), op)
 		}
 	}
 }
 
 // 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)
-	gridb := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
-	history := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
+	grida := NewGrid(scene.Config)
+	gridb := NewGrid(scene.Config)
 
 	// startup is delayed until user has selected options
 	grida.FillRandom()
-	grida.Copy(history)
 
 	scene.Grids = []*Grid{
 		grida,
 		gridb,
 	}
 
-	scene.History = history
-}
+	scene.History = NewHistory(scene.Config.Height, scene.Config.Width)
 
-// prepare tile images
-func (scene *ScenePlay) InitTiles() {
-	scene.Grey = color.RGBA{128, 128, 128, 0xff}
-	scene.Old = color.RGBA{255, 30, 30, 0xff}
-
-	scene.Black = color.RGBA{0, 0, 0, 0xff}
-	scene.White = color.RGBA{200, 200, 200, 0xff}
-	scene.AgeColor1 = color.RGBA{255, 195, 97, 0xff} // FIXME: use slice!
-	scene.AgeColor2 = color.RGBA{255, 211, 140, 0xff}
-	scene.AgeColor3 = color.RGBA{255, 227, 181, 0xff}
-	scene.AgeColor4 = color.RGBA{255, 240, 224, 0xff}
-
-	if scene.Config.Invert {
-		scene.White = color.RGBA{0, 0, 0, 0xff}
-		scene.Black = color.RGBA{200, 200, 200, 0xff}
-
-		scene.AgeColor1 = color.RGBA{82, 38, 0, 0xff}
-		scene.AgeColor2 = color.RGBA{66, 35, 0, 0xff}
-		scene.AgeColor3 = color.RGBA{43, 27, 0, 0xff}
-		scene.AgeColor4 = color.RGBA{25, 17, 0, 0xff}
-	}
-
-	scene.Tiles.Black = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.White = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Old = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age1 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age2 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age3 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age4 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-
-	cellsize := scene.Config.ScreenWidth / scene.Config.Cellsize
-
-	FillCell(scene.Tiles.Black, cellsize, scene.Black)
-	FillCell(scene.Tiles.White, cellsize, scene.White)
-	FillCell(scene.Tiles.Old, cellsize, scene.Old)
-	FillCell(scene.Tiles.Age1, cellsize, scene.AgeColor1)
-	FillCell(scene.Tiles.Age2, cellsize, scene.AgeColor2)
-	FillCell(scene.Tiles.Age3, cellsize, scene.AgeColor3)
-	FillCell(scene.Tiles.Age4, cellsize, scene.AgeColor4)
 }
 
 func (scene *ScenePlay) Init() {
@@ -649,10 +672,12 @@ func (scene *ScenePlay) Init() {
 		scene.Config.Height*scene.Config.Cellsize,
 	)
 
-	scene.InitTiles()
+	scene.Theme = scene.Config.ThemeManager.GetCurrentTheme()
 	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
@@ -665,7 +690,7 @@ func (scene *ScenePlay) Init() {
 	scene.Index = 0
 	scene.TicksElapsed = 0
 
-	scene.LastCursorPos = make([]int, 2)
+	scene.LastCursorPos = make([]float64, 2)
 
 	if scene.Config.Zoomfactor < 0 || scene.Config.Zoomfactor > 0 {
 		scene.Camera.ZoomFactor = scene.Config.Zoomfactor
@@ -674,48 +699,14 @@ func (scene *ScenePlay) Init() {
 	scene.Camera.Setup()
 }
 
-// count the living neighbors of a cell
-func (scene *ScenePlay) CountNeighbors(x, y int) int64 {
-	var sum int64
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
 
-	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
-				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 += scene.Grids[scene.Index].Data[row][col]
-		}
+func (scene *ScenePlay) InitRuleCheckFunc() {
+	if scene.Config.Rule.Definition == "B3/S23" {
+		scene.RuleCheckFunc = scene.CheckRuleB3S23
+	} else {
+		scene.RuleCheckFunc = scene.CheckRuleGeneric
 	}
-
-	// don't count ourselfes though
-	sum -= scene.Grids[scene.Index].Data[y][x]
-
-	return sum
-}
-
-// fill a cell with the given color
-func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
-	vector.DrawFilledRect(
-		tile,
-		float32(1),
-		float32(1),
-		float32(cellsize),
-		float32(cellsize),
-		col, false,
-	)
 }

cmd/rule.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import (
 	"log"
@@ -9,22 +9,22 @@ import (
 // a GOL rule
 type Rule struct {
 	Definition string
-	Birth      []int64
-	Death      []int64
+	Birth      []uint8
+	Death      []uint8
 }
 
 // parse one part of a GOL rule into rule slice
-func NumbersToList(numbers string) []int64 {
-	list := []int64{}
+func NumbersToList(numbers string) []uint8 {
+	list := []uint8{}
 
 	items := strings.Split(numbers, "")
 	for _, item := range items {
-		num, err := strconv.ParseInt(item, 10, 64)
+		num, err := strconv.Atoi(item)
 		if err != nil {
 			log.Fatalf("failed to parse game rule part <%s>: %s", numbers, err)
 		}
 
-		list = append(list, num)
+		list = append(list, uint8(num))
 	}
 
 	return list

cmd/scene.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import "github.com/hajimehoshi/ebiten/v2"
 
@@ -24,4 +24,5 @@ const (
 	Menu = iota // main top level menu
 	Play        // actual playing happens here
 	Options
+	Keybindings
 )

cmd/system.go

@@ -1,4 +1,4 @@
-package main
+package cmd
 
 import "runtime"
 

cmd/theme.go

@@ -0,0 +1,189 @@
+package cmd
+
+import (
+	"fmt"
+	"image/color"
+	"log"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+// Color definitions. ColLife could be black or white depending on theme
+const (
+	ColLife = iota
+	ColDead
+	ColOld
+	ColAge1
+	ColAge2
+	ColAge3
+	ColAge4
+	ColGrid
+)
+
+// A Theme defines  how the grid and the cells  are colored. We define
+// the  colors and  the  actual tile  images here,  so  that they  are
+// 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 {
+	life, dead, grid, old, age1, age2, age3, age4 string
+}
+
+var THEMES = map[string]ThemeDef{
+	"standard": {
+		life: "e15f0b",
+		dead: "5a5a5a",
+		old:  "ff1e1e",
+		grid: "808080",
+		age3: "6c6059",
+		age2: "735f52",
+		age1: "7b5e4b",
+		age4: "635d59",
+	},
+	"dark": {
+		life: "c8c8c8",
+		dead: "000000",
+		old:  "ff1e1e",
+		grid: "808080",
+		age1: "522600",
+		age2: "422300",
+		age3: "2b1b00",
+		age4: "191100",
+	},
+	"light": {
+		life: "000000",
+		dead: "c8c8c8",
+		old:  "ff1e1e",
+		grid: "808080",
+		age1: "ffc361",
+		age2: "ffd38c",
+		age3: "ffe3b5",
+		age4: "fff0e0",
+	},
+}
+
+// create a new theme
+func NewTheme(def ThemeDef, cellsize int, name string) Theme {
+	theme := Theme{
+		Name: name,
+		Colors: map[int]color.RGBA{
+			ColLife: HexColor2RGBA(def.life),
+			ColDead: HexColor2RGBA(def.dead),
+			ColGrid: HexColor2RGBA(def.grid),
+			ColAge1: HexColor2RGBA(def.age1),
+			ColAge2: HexColor2RGBA(def.age2),
+			ColAge3: HexColor2RGBA(def.age3),
+			ColAge4: HexColor2RGBA(def.age4),
+			ColOld:  HexColor2RGBA(def.old),
+		},
+	}
+
+	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, 0)
+
+		theme.GridTiles[cid] = ebiten.NewImage(cellsize, cellsize)
+		FillCell(theme.GridTiles[cid], cellsize, col, 1)
+	}
+
+	return theme
+}
+
+// return  the tile  image  for  the requested  color  type. panic  if
+// 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]
+}
+
+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
+}
+
+// Manager is used to easily switch themes from cli or menu
+func NewThemeManager(initial string, cellsize int) ThemeManager {
+	manager := ThemeManager{
+		Theme: initial,
+	}
+
+	manager.Themes = make(map[string]Theme, len(THEMES))
+
+	for name, def := range THEMES {
+		manager.Themes[name] = NewTheme(def, cellsize, name)
+	}
+
+	return manager
+}
+
+func (manager *ThemeManager) GetCurrentTheme() Theme {
+	return manager.Themes[manager.Theme]
+}
+
+func (manager *ThemeManager) GetCurrentThemeName() string {
+	return manager.Theme
+}
+
+func (manager *ThemeManager) SetCurrentTheme(theme string) {
+	if Exists(manager.Themes, theme) {
+		manager.Theme = theme
+	}
+}
+
+// Fill a cell with the given color.
+//
+// We do not  draw the cell at  0,0 of it's position but  at 1,1. This
+// creates a top and lef  transparent. By using a different background
+// for the whole grid we can then  decide wether to show grid lines or
+// not.
+//
+// If no  gridlines are  selected the background  will just  be filled
+// with the DEAD  color. However, IF we are to  show the gridlines, we
+// fill it  with a lighter color.  The transparent edges of  all tiles
+// then create the grid.
+//
+// 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, x int) {
+	vector.DrawFilledRect(
+		tile,
+		float32(x),
+		float32(x),
+		float32(cellsize),
+		float32(cellsize),
+		col, false,
+	)
+}
+
+func HexColor2RGBA(hex string) color.RGBA {
+	var r, g, b uint8
+
+	_, err := fmt.Sscanf(hex, "%02x%02x%02x", &r, &g, &b)
+	if err != nil {
+		log.Fatalf("failed to parse hex color: %s", err)
+	}
+
+	return color.RGBA{r, g, b, 255}
+}

cmd/widgets.go

@@ -0,0 +1,305 @@
+package cmd
+
+import (
+	"image/color"
+
+	"github.com/ebitenui/ebitenui/image"
+	"github.com/ebitenui/ebitenui/widget"
+)
+
+func NewMenuButton(
+	text string,
+	action func(args *widget.ButtonClickedEventArgs)) *widget.Button {
+
+	buttonImage, _ := LoadButtonImage()
+
+	return widget.NewButton(
+		widget.ButtonOpts.WidgetOpts(
+			widget.WidgetOpts.LayoutData(widget.RowLayoutData{
+				Position:  widget.RowLayoutPositionCenter,
+				Stretch:   true,
+				MaxWidth:  200,
+				MaxHeight: 100,
+			}),
+		),
+
+		widget.ButtonOpts.Image(buttonImage),
+
+		widget.ButtonOpts.Text(text, *FontRenderer.FontSmall, &widget.ButtonTextColor{
+			Idle: color.NRGBA{0xdf, 0xf4, 0xff, 0xff},
+		}),
+
+		widget.ButtonOpts.TextPadding(widget.Insets{
+			Left:   5,
+			Right:  5,
+			Top:    5,
+			Bottom: 5,
+		}),
+
+		widget.ButtonOpts.ClickedHandler(action),
+	)
+}
+
+func NewCheckbox(
+	text string,
+	initialvalue bool,
+	action func(args *widget.CheckboxChangedEventArgs)) *widget.LabeledCheckbox {
+
+	checkboxImage, _ := LoadCheckboxImage()
+	buttonImage, _ := LoadButtonImage()
+
+	var state widget.WidgetState
+	if initialvalue {
+		state = widget.WidgetChecked
+	}
+
+	return widget.NewLabeledCheckbox(
+		widget.LabeledCheckboxOpts.CheckboxOpts(
+			widget.CheckboxOpts.ButtonOpts(
+				widget.ButtonOpts.Image(buttonImage),
+			),
+			widget.CheckboxOpts.Image(checkboxImage),
+			widget.CheckboxOpts.StateChangedHandler(action),
+			widget.CheckboxOpts.InitialState(state),
+		),
+		widget.LabeledCheckboxOpts.LabelOpts(
+			widget.LabelOpts.Text(text, *FontRenderer.FontSmall,
+				&widget.LabelColor{
+					Idle: color.NRGBA{0xdf, 0xf4, 0xff, 0xff},
+				}),
+		),
+	)
+}
+
+func NewSeparator(padding int) widget.PreferredSizeLocateableWidget {
+	c := widget.NewContainer(
+		widget.ContainerOpts.Layout(widget.NewRowLayout(
+			widget.RowLayoutOpts.Direction(widget.DirectionVertical),
+			widget.RowLayoutOpts.Padding(widget.Insets{
+				Top:    padding,
+				Bottom: 0,
+			}))),
+		widget.ContainerOpts.WidgetOpts(
+			widget.WidgetOpts.LayoutData(
+				widget.RowLayoutData{Stretch: true})))
+	return c
+}
+
+type ListEntry struct {
+	id   int
+	Name string
+}
+
+func NewCombobox(items []string, selected string,
+	action func(args *widget.ListComboButtonEntrySelectedEventArgs)) *widget.ListComboButton {
+	buttonImage, _ := LoadButtonImage()
+
+	entries := make([]any, 0, len(items))
+	idxselected := 0
+	for i, item := range items {
+		entries = append(entries, ListEntry{i, item})
+		if items[i] == selected {
+			idxselected = i
+		}
+	}
+
+	comboBox := widget.NewListComboButton(
+		widget.ListComboButtonOpts.SelectComboButtonOpts(
+			widget.SelectComboButtonOpts.ComboButtonOpts(
+				//Set the max height of the dropdown list
+				widget.ComboButtonOpts.MaxContentHeight(150),
+				//Set the parameters for the primary displayed button
+				widget.ComboButtonOpts.ButtonOpts(
+					widget.ButtonOpts.Image(buttonImage),
+					widget.ButtonOpts.TextPadding(widget.NewInsetsSimple(5)),
+					widget.ButtonOpts.Text("", *FontRenderer.FontSmall, &widget.ButtonTextColor{
+						Idle:     color.White,
+						Disabled: color.White,
+					}),
+					widget.ButtonOpts.WidgetOpts(
+						//Set how wide the button should be
+						widget.WidgetOpts.MinSize(50, 0),
+						//Set the combobox's position
+						widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
+							HorizontalPosition: widget.AnchorLayoutPositionCenter,
+							VerticalPosition:   widget.AnchorLayoutPositionCenter,
+						})),
+				),
+			),
+		),
+		widget.ListComboButtonOpts.ListOpts(
+			//Set how wide the dropdown list should be
+			widget.ListOpts.ContainerOpts(
+				widget.ContainerOpts.WidgetOpts(widget.WidgetOpts.MinSize(50, 0)),
+			),
+			//Set the entries in the list
+			widget.ListOpts.Entries(entries),
+			widget.ListOpts.ScrollContainerOpts(
+				//Set the background images/color for the dropdown list
+				widget.ScrollContainerOpts.Image(&widget.ScrollContainerImage{
+					Idle:     image.NewNineSliceColor(color.NRGBA{100, 100, 100, 255}),
+					Disabled: image.NewNineSliceColor(color.NRGBA{100, 100, 100, 255}),
+					Mask:     image.NewNineSliceColor(color.NRGBA{100, 100, 100, 255}),
+				}),
+			),
+			widget.ListOpts.SliderOpts(
+				//Set the background images/color for the background of the slider track
+				widget.SliderOpts.Images(&widget.SliderTrackImage{
+					Idle:  image.NewNineSliceColor(color.NRGBA{100, 100, 100, 255}),
+					Hover: image.NewNineSliceColor(color.NRGBA{100, 100, 100, 255}),
+				}, buttonImage),
+				widget.SliderOpts.MinHandleSize(5),
+				//Set how wide the track should be
+				widget.SliderOpts.TrackPadding(widget.NewInsetsSimple(2))),
+			//Set the font for the list options
+			widget.ListOpts.EntryFontFace(*FontRenderer.FontSmall),
+			//Set the colors for the list
+			widget.ListOpts.EntryColor(&widget.ListEntryColor{
+				Selected:                   color.NRGBA{254, 255, 255, 255},
+				Unselected:                 color.NRGBA{254, 255, 255, 255},
+				SelectedBackground:         HexColor2RGBA(THEMES["standard"].life),
+				SelectedFocusedBackground:  HexColor2RGBA(THEMES["standard"].old),
+				FocusedBackground:          HexColor2RGBA(THEMES["standard"].old),
+				DisabledUnselected:         HexColor2RGBA(THEMES["standard"].grid),
+				DisabledSelected:           HexColor2RGBA(THEMES["standard"].grid),
+				DisabledSelectedBackground: HexColor2RGBA(THEMES["standard"].grid),
+			}),
+			//Padding for each entry
+			widget.ListOpts.EntryTextPadding(widget.NewInsetsSimple(5)),
+		),
+		//Define how the entry is displayed
+		widget.ListComboButtonOpts.EntryLabelFunc(
+			func(e any) string {
+				//Button Label function, visible if not open
+				return e.(ListEntry).Name
+			},
+			func(e any) string {
+				//List Label function, visible items if open
+				return e.(ListEntry).Name
+			}),
+		//Callback when a new entry is selected
+		widget.ListComboButtonOpts.EntrySelectedHandler(action),
+	)
+
+	//Select the middle entry -- optional
+	comboBox.SetSelectedEntry(entries[idxselected])
+
+	return comboBox
+}
+
+func NewLabel(text string) *widget.Text {
+	return widget.NewText(
+		widget.TextOpts.Text(text, *FontRenderer.FontSmall, color.White),
+		widget.TextOpts.Position(widget.TextPositionCenter, widget.TextPositionCenter),
+		widget.TextOpts.WidgetOpts(
+			widget.WidgetOpts.LayoutData(widget.RowLayoutData{
+				Position: widget.RowLayoutPositionCenter,
+			}),
+		),
+	)
+
+}
+
+/////////////// containers
+
+type RowContainer struct {
+	Root *widget.Container
+	Row  *widget.Container
+}
+
+func (container *RowContainer) AddChild(child widget.PreferredSizeLocateableWidget) {
+	container.Row.AddChild(child)
+}
+
+func (container *RowContainer) Container() *widget.Container {
+	return container.Root
+}
+
+// set arg to false if no background needed
+func NewRowContainer(title string) *RowContainer {
+	buttonImageHover := image.NewNineSlice(Assets["button-9slice3"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
+
+	uiContainer := widget.NewContainer(
+		widget.ContainerOpts.Layout(widget.NewAnchorLayout()),
+	)
+
+	titleLabel := widget.NewText(
+		widget.TextOpts.WidgetOpts(widget.WidgetOpts.LayoutData(widget.RowLayoutData{
+			Stretch: true,
+		})),
+		widget.TextOpts.Text(title, *FontRenderer.FontNormal, color.NRGBA{0xdf, 0xf4, 0xff, 0xff}))
+
+	rowContainer := widget.NewContainer(
+		widget.ContainerOpts.WidgetOpts(
+			widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
+				HorizontalPosition: widget.AnchorLayoutPositionCenter,
+				VerticalPosition:   widget.AnchorLayoutPositionCenter,
+			}),
+		),
+		widget.ContainerOpts.Layout(widget.NewRowLayout(
+			widget.RowLayoutOpts.Direction(widget.DirectionVertical),
+			widget.RowLayoutOpts.Padding(widget.NewInsetsSimple(8)),
+			widget.RowLayoutOpts.Spacing(0),
+		)),
+		widget.ContainerOpts.BackgroundImage(buttonImageHover),
+	)
+
+	rowContainer.AddChild(titleLabel)
+
+	uiContainer.AddChild(rowContainer)
+
+	return &RowContainer{
+		Root: uiContainer,
+		Row:  rowContainer,
+	}
+}
+
+func NewColumnContainer() *widget.Container {
+	colcontainer := widget.NewContainer(
+		widget.ContainerOpts.Layout(
+			widget.NewGridLayout(
+				widget.GridLayoutOpts.Columns(2),
+				widget.GridLayoutOpts.Spacing(5, 0),
+			),
+		),
+	)
+
+	return colcontainer
+}
+
+func LoadButtonImage() (*widget.ButtonImage, error) {
+	idle := image.NewNineSlice(Assets["button-9slice2"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
+	hover := image.NewNineSlice(Assets["button-9slice3"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
+	pressed := image.NewNineSlice(Assets["button-9slice1"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
+
+	return &widget.ButtonImage{
+		Idle:    idle,
+		Hover:   hover,
+		Pressed: pressed,
+	}, nil
+}
+
+func LoadComboLabelImage() *widget.ButtonImageImage {
+	return &widget.ButtonImageImage{
+		Idle:     Assets["checkbox-9slice2"],
+		Disabled: Assets["checkbox-9slice2"],
+	}
+}
+
+func LoadCheckboxImage() (*widget.CheckboxGraphicImage, error) {
+	unchecked := &widget.ButtonImageImage{
+		Idle:     Assets["checkbox-9slice2"],
+		Disabled: Assets["checkbox-9slice2"],
+	}
+
+	checked := &widget.ButtonImageImage{
+		Idle:     Assets["checkbox-9slice1"],
+		Disabled: Assets["checkbox-9slice1"],
+	}
+
+	return &widget.CheckboxGraphicImage{
+		Checked:   checked,
+		Unchecked: unchecked,
+		Greyed:    unchecked,
+	}, nil
+}

go.mod

@@ -1,4 +1,4 @@
-module github.com/tlinden/golsky
+module codeberg.org/scip/golsky
 
 go 1.22
 
@@ -13,9 +13,10 @@ 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/ebitenui/ebitenui v0.5.6 // indirect
+	github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
+	github.com/mlange-42/arche v0.13.0 // indirect
 	github.com/tinne26/etxt v0.0.8 // indirect
 	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 // indirect
 	golang.org/x/sync v0.7.0 // indirect

go.sum

@@ -8,12 +8,16 @@ github.com/ebitengine/purego v0.7.0 h1:HPZpl61edMGCEW6XK2nsR6+7AnJ3unUxpTZBkkIXn
 github.com/ebitengine/purego v0.7.0/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ=
 github.com/ebitenui/ebitenui v0.5.6 h1:qyJRU5j+lQo1lamxB48IBwMxMfz1xNb5iWUayCtA0Wk=
 github.com/ebitenui/ebitenui v0.5.6/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
+github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21 h1:dElhYGyf+FYY+makAndUQNOSDwFSFYyFWziPwQrPObY=
+github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 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=
+github.com/mlange-42/arche v0.13.0 h1:ef0fu9qC2KIr8wIlVs+CgeQ5CSUJ8A1Hut6nXYdf+xk=
+github.com/mlange-42/arche v0.13.0/go.mod h1:bFktKnvGDj2kP01xar79z0hKwGHdnoaEZR8HWmJkIyU=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/tinne26/etxt v0.0.8 h1:rjb58jkMkapRGLmhBMWnT76E/nMTXC5P1Q956BRZkoc=

main.go

@@ -8,6 +8,7 @@ import (
 
 	_ "net/http/pprof"
 
+	"codeberg.org/scip/golsky/cmd"
 	"github.com/hajimehoshi/ebiten/v2"
 )
 
@@ -18,22 +19,22 @@ func main() {
 		directstart = true
 	}
 
-	config, err := ParseCommandline()
+	config, err := cmd.ParseCommandline()
 	if err != nil {
 		log.Fatal(err)
 	}
 
 	if config.ShowVersion {
-		fmt.Printf("This is golsky version %s\n", VERSION)
+		fmt.Printf("This is golsky version %s\n", cmd.VERSION)
 		os.Exit(0)
 	}
 
-	start := Play
+	start := cmd.Play
 	if !directstart {
-		start = Menu
+		start = cmd.Menu
 		config.DelayedStart = true
 	}
-	game := NewGame(config, SceneName(start))
+	game := cmd.NewGame(config, cmd.SceneName(start))
 
 	if config.ProfileFile != "" {
 		// enable  cpu profiling. Do  NOT use q  to stop the  game but

rle/rle.go

@@ -120,7 +120,7 @@ func removeWhitespace(input string) string {
 }
 
 // Store a grid to an RLE file
-func StoreGridToRLE(grid [][]int64, 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
@@ -131,12 +131,12 @@ func StoreGridToRLE(grid [][]int64, filename, rule string, width, height int) er
 	for y := 0; y < height; y++ {
 		line := ""
 		for x := 0; x < width; x++ {
-			switch grid[y][x] {
-			case 0:
-				line += "b"
-			case 1:
-				line += "o"
+			char := "b"
+			if grid[y][x] == 1 {
+				char = "o"
 			}
+
+			line += char
 		}
 
 		// if first row is: 001011110, then line is now:

src/Makefile

@@ -1,97 +0,0 @@
-# Copyright © 2024 Thomas von Dein
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-
-#
-# no need to modify anything below
-tool      = golsky
-VERSION   = $(shell grep VERSION main.go | head -1 | cut -d '"' -f2)
-archs     = darwin freebsd linux windows
-PREFIX    = /usr/local
-UID       = root
-GID       = 0
-HAVE_POD := $(shell pod2text -h 2>/dev/null)
-#TAGS      = -tags=ebitenginedebug
-
-all: buildlocal
-
-
-buildlocal:
-	go build $(TAGS) -o $(tool)
-
-install: buildlocal
-	install -d -o $(UID) -g $(GID) $(PREFIX)/bin
-	install -d -o $(UID) -g $(GID) $(PREFIX)/man/man1
-	install -o $(UID) -g $(GID) -m 555 $(tool)  $(PREFIX)/sbin/
-	install -o $(UID) -g $(GID) -m 444 $(tool).1 $(PREFIX)/man/man1/
-
-clean:
-	rm -rf $(tool) coverage.out testdata t/out
-
-test: clean
-	mkdir -p t/out
-	go test ./... $(ARGS)
-
-testlint: test lint
-
-lint:
-	golangci-lint run
-
-lint-full:
-	golangci-lint run --enable-all --exclude-use-default --disable exhaustivestruct,exhaustruct,depguard,interfacer,deadcode,golint,structcheck,scopelint,varcheck,ifshort,maligned,nosnakecase,godot,funlen,gofumpt,cyclop,noctx,gochecknoglobals,paralleltest
-
-testfuzzy: clean
-	go test -fuzz ./... $(ARGS)
-
-singletest:
-	@echo "Call like this: make singletest TEST=TestPrepareColumns ARGS=-v"
-	go test -run $(TEST) $(ARGS)
-
-cover-report:
-	go test ./... -cover -coverprofile=coverage.out
-	go tool cover -html=coverage.out
-
-goupdate:
-	go get -t -u=patch ./...
-
-buildall:
-	./mkrel.sh $(tool) $(VERSION)
-
-release: buildall
-	gh release create $(VERSION) --generate-notes releases/*
-
-show-versions: buildlocal
-	@echo "### golsky version:"
-	@./golsky -V
-
-	@echo
-	@echo "### go module versions:"
-	@go list -m all
-
-	@echo
-	@echo "### go version used for building:"
-	@grep -m 1 go go.mod
-
-# lint:
-# 	golangci-lint run -p bugs -p unused
-
-buildwasm:
-	env GOOS=js GOARCH=wasm go build -o $(tool).wasm $(LDFLAGS) .
-
-zipwasm:
-	zip -r openquell-$(SHORTVERSION).zip index.html $(tool).wasm wasm_exec.js
-
-wasm: buildwasm zipwasm
-	@ls -l $(tool)-$(SHORTVERSION).zip

src/grid.go

@@ -1,244 +0,0 @@
-package main
-
-import (
-	"bufio"
-	"errors"
-	"fmt"
-	"math/rand"
-	"os"
-	"strings"
-	"time"
-
-	"github.com/tlinden/golsky/rle"
-)
-
-type Grid struct {
-	Data                   [][]int64
-	Width, Height, Density int
-	Empty                  bool
-}
-
-// Create new empty grid and allocate Data according to provided dimensions
-func NewGrid(width, height, density int, empty bool) *Grid {
-	grid := &Grid{
-		Height:  height,
-		Width:   width,
-		Density: density,
-		Data:    make([][]int64, height),
-		Empty:   empty,
-	}
-
-	for y := 0; y < height; y++ {
-		grid.Data[y] = make([]int64, width)
-	}
-
-	return grid
-}
-
-// Create a new 1:1 instance
-func (grid *Grid) Clone() *Grid {
-	newgrid := &Grid{}
-
-	newgrid.Width = grid.Width
-	newgrid.Height = grid.Height
-	newgrid.Data = grid.Data
-
-	return newgrid
-}
-
-// copy data
-func (grid *Grid) Copy(other *Grid) {
-	for y := range grid.Data {
-		for x := range grid.Data[y] {
-			other.Data[y][x] = grid.Data[y][x]
-		}
-	}
-}
-
-// delete all contents
-func (grid *Grid) Clear() {
-	for y := range grid.Data {
-		for x := range grid.Data[y] {
-			grid.Data[y][x] = 0
-		}
-	}
-}
-
-// initialize with random life cells using the given density
-func (grid *Grid) FillRandom() {
-	if !grid.Empty {
-		for y := range grid.Data {
-			for x := range grid.Data[y] {
-				if rand.Intn(grid.Density) == 1 {
-					grid.Data[y][x] = 1
-				}
-			}
-		}
-	}
-}
-
-func (grid *Grid) Dump() {
-	for y := 0; y < grid.Height; y++ {
-		for x := 0; x < grid.Width; x++ {
-			if grid.Data[y][x] == 1 {
-				fmt.Print("XX")
-			} else {
-				fmt.Print("  ")
-			}
-		}
-		fmt.Println()
-	}
-}
-
-// initialize using a given RLE pattern
-func (grid *Grid) LoadRLE(pattern *rle.RLE) {
-	if pattern != nil {
-		startX := (grid.Width / 2) - (pattern.Width / 2)
-		startY := (grid.Height / 2) - (pattern.Height / 2)
-		var y, x int
-
-		for rowIndex, patternRow := range pattern.Pattern {
-			for colIndex := range patternRow {
-				if pattern.Pattern[rowIndex][colIndex] > 0 {
-					x = colIndex + startX
-					y = rowIndex + startY
-
-					grid.Data[y][x] = 1
-				}
-			}
-		}
-
-		//grid.Dump()
-	}
-}
-
-// load a lif file parameters like R and P are not supported yet
-func LoadLIF(filename string) (*rle.RLE, error) {
-	fd, err := os.Open(filename)
-	if err != nil {
-		return nil, err
-	}
-
-	scanner := bufio.NewScanner(fd)
-
-	scanner.Split(bufio.ScanLines)
-
-	gothead := false
-
-	grid := &rle.RLE{}
-
-	for scanner.Scan() {
-		line := scanner.Text()
-		items := strings.Split(line, "")
-
-		if len(items) < 0 {
-			continue
-		}
-
-		if strings.Contains(line, "# r") {
-			parts := strings.Split(line, " ")
-			if len(parts) == 2 {
-				grid.Rule = parts[1]
-			}
-
-			continue
-		}
-
-		if items[0] == "#" {
-			if gothead {
-				break
-			}
-
-			continue
-		}
-
-		gothead = true
-
-		row := make([]int, len(items))
-
-		for idx, item := range items {
-			switch item {
-			case ".":
-				row[idx] = 0
-			case "o":
-				fallthrough
-			case "*":
-				row[idx] = 1
-			default:
-				return nil, errors.New("cells must be . or o")
-			}
-		}
-
-		grid.Pattern = append(grid.Pattern, row)
-	}
-
-	// sanity check the grid
-	explen := 0
-	rows := 0
-	first := true
-	for _, row := range grid.Pattern {
-		length := len(row)
-
-		if first {
-			explen = length
-			first = false
-		}
-
-		if explen != length {
-			return nil, fmt.Errorf(
-				fmt.Sprintf("all rows must be in the same length, got: %d, expected: %d",
-					length, explen))
-		}
-
-		rows++
-	}
-
-	grid.Width = explen
-	grid.Height = rows
-
-	return grid, nil
-}
-
-// save  the contents  of  the  whole grid  as  a  simple lif  alike
-// file. One line per row, 0 for dead and 1 for life cell.
-// file format: https://conwaylife.com/wiki/Life_1.05
-func (grid *Grid) SaveState(filename, rule string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("failed to open state file: %w", err)
-	}
-	defer file.Close()
-
-	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 _, cell := range grid.Data[y] {
-			row := ""
-			switch cell {
-			case 1:
-				row += "o"
-			case 0:
-				row += "."
-			}
-
-			_, err := file.WriteString(row)
-			if err != nil {
-				return fmt.Errorf("failed to write to state file: %w", err)
-			}
-		}
-		file.WriteString("\n")
-	}
-
-	return nil
-}
-
-// generate filenames for dumps
-func GetFilename(generations int64) string {
-	now := time.Now()
-	return fmt.Sprintf("dump-%s-%d.lif", now.Format("20060102150405"), generations)
-}
-
-func GetFilenameRLE(generations int64) string {
-	now := time.Now()
-	return fmt.Sprintf("rect-%s-%d.rle", now.Format("20060102150405"), generations)
-}

src/widgets.go

@@ -1,161 +0,0 @@
-package main
-
-import (
-	"image/color"
-
-	"github.com/ebitenui/ebitenui/image"
-	"github.com/ebitenui/ebitenui/widget"
-)
-
-func NewMenuButton(
-	text string,
-	action func(args *widget.ButtonClickedEventArgs)) *widget.Button {
-
-	buttonImage, _ := LoadButtonImage()
-
-	return widget.NewButton(
-		widget.ButtonOpts.WidgetOpts(
-			widget.WidgetOpts.LayoutData(widget.RowLayoutData{
-				Position:  widget.RowLayoutPositionCenter,
-				Stretch:   true,
-				MaxWidth:  200,
-				MaxHeight: 100,
-			}),
-		),
-
-		widget.ButtonOpts.Image(buttonImage),
-
-		widget.ButtonOpts.Text(text, *FontRenderer.FontSmall, &widget.ButtonTextColor{
-			Idle: color.NRGBA{0xdf, 0xf4, 0xff, 0xff},
-		}),
-
-		widget.ButtonOpts.TextPadding(widget.Insets{
-			Left:   5,
-			Right:  5,
-			Top:    5,
-			Bottom: 5,
-		}),
-
-		widget.ButtonOpts.ClickedHandler(action),
-	)
-}
-
-func NewCheckbox(
-	text string,
-	action func(args *widget.CheckboxChangedEventArgs)) *widget.LabeledCheckbox {
-
-	checkboxImage, _ := LoadCheckboxImage()
-	buttonImage, _ := LoadButtonImage()
-
-	return widget.NewLabeledCheckbox(
-		widget.LabeledCheckboxOpts.CheckboxOpts(
-			widget.CheckboxOpts.ButtonOpts(
-				widget.ButtonOpts.Image(buttonImage),
-			),
-			widget.CheckboxOpts.Image(checkboxImage),
-			widget.CheckboxOpts.StateChangedHandler(action),
-		),
-		widget.LabeledCheckboxOpts.LabelOpts(
-			widget.LabelOpts.Text(text, *FontRenderer.FontSmall,
-				&widget.LabelColor{
-					Idle: color.NRGBA{0xdf, 0xf4, 0xff, 0xff},
-				}),
-		),
-	)
-}
-
-func NewSeparator(padding int) widget.PreferredSizeLocateableWidget {
-	c := widget.NewContainer(
-		widget.ContainerOpts.Layout(widget.NewRowLayout(
-			widget.RowLayoutOpts.Direction(widget.DirectionVertical),
-			widget.RowLayoutOpts.Padding(widget.Insets{
-				Top:    padding,
-				Bottom: 0,
-			}))),
-		widget.ContainerOpts.WidgetOpts(
-			widget.WidgetOpts.LayoutData(
-				widget.RowLayoutData{Stretch: true})))
-	return c
-}
-
-type RowContainer struct {
-	Root *widget.Container
-	Row  *widget.Container
-}
-
-func (container *RowContainer) AddChild(child widget.PreferredSizeLocateableWidget) {
-	container.Row.AddChild(child)
-}
-
-func (container *RowContainer) Container() *widget.Container {
-	return container.Root
-}
-
-// set arg to false if no background needed
-func NewRowContainer(title string) *RowContainer {
-	buttonImageHover := image.NewNineSlice(Assets["button-9slice3"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
-
-	uiContainer := widget.NewContainer(
-		widget.ContainerOpts.Layout(widget.NewAnchorLayout()),
-	)
-
-	titleLabel := widget.NewText(
-		widget.TextOpts.WidgetOpts(widget.WidgetOpts.LayoutData(widget.RowLayoutData{
-			Stretch: true,
-		})),
-		widget.TextOpts.Text(title, *FontRenderer.FontNormal, color.NRGBA{0xdf, 0xf4, 0xff, 0xff}))
-
-	rowContainer := widget.NewContainer(
-		widget.ContainerOpts.WidgetOpts(
-			widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
-				HorizontalPosition: widget.AnchorLayoutPositionCenter,
-				VerticalPosition:   widget.AnchorLayoutPositionCenter,
-			}),
-		),
-		widget.ContainerOpts.Layout(widget.NewRowLayout(
-			widget.RowLayoutOpts.Direction(widget.DirectionVertical),
-			widget.RowLayoutOpts.Padding(widget.NewInsetsSimple(8)),
-			widget.RowLayoutOpts.Spacing(0),
-		)),
-		widget.ContainerOpts.BackgroundImage(buttonImageHover),
-	)
-
-	rowContainer.AddChild(titleLabel)
-
-	uiContainer.AddChild(rowContainer)
-
-	return &RowContainer{
-		Root: uiContainer,
-		Row:  rowContainer,
-	}
-}
-
-func LoadButtonImage() (*widget.ButtonImage, error) {
-	idle := image.NewNineSlice(Assets["button-9slice2"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
-	hover := image.NewNineSlice(Assets["button-9slice3"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
-	pressed := image.NewNineSlice(Assets["button-9slice1"], [3]int{3, 3, 3}, [3]int{3, 3, 3})
-
-	return &widget.ButtonImage{
-		Idle:    idle,
-		Hover:   hover,
-		Pressed: pressed,
-	}, nil
-}
-
-func LoadCheckboxImage() (*widget.CheckboxGraphicImage, error) {
-	unchecked := &widget.ButtonImageImage{
-		Idle:     Assets["checkbox-9slice2"],
-		Disabled: Assets["checkbox-9slice2"],
-	}
-
-	checked := &widget.ButtonImageImage{
-		Idle:     Assets["checkbox-9slice1"],
-		Disabled: Assets["checkbox-9slice1"],
-	}
-
-	return &widget.CheckboxGraphicImage{
-		Checked:   checked,
-		Unchecked: unchecked,
-		Greyed:    unchecked,
-	}, nil
-}

various-tests/README.md

@@ -0,0 +1,12 @@
+## Various performance tests
+
+Running with 1500x1500 grid 5k times
+
+| Variation                    | Description                                                                 | Duration          |
+|------------------------------|-----------------------------------------------------------------------------|-------------------|
+| perf-2dim                    | uses 2d grid of bools, no tuning                                            | 00:03:14          |
+| perf-2dim-pointers           | use 2d grid of `Cell{Neighbors,NeighborCount}`s using pointers to neighbors | 00:03:35/00:04:75 |
+| perf-2dim-pointers-array     | same as above but array of neighbors instead of slice                       | 00:02:40          |
+| perf-2dim-pointers-all-array | use arrays for everything, static 1500x1500                                 | infinite, aborted |
+| perf-1dim                    | use 1d grid of bools, access using y*x, no further tuning                   | 00:03:24          |
+| perf-ecs                     | use arche ecs, unusable                                                     | 00:14:51          |

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

@@ -0,0 +1,3 @@
+module perf
+
+go 1.22

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

@@ -0,0 +1,117 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+	"unsafe"
+)
+
+const (
+	dim     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+var max int
+
+// https://dev.to/chigbeef_77/bool-int-but-stupid-in-go-3jb3
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func Count(grid []bool, x, y int) int {
+	var sum int
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= dim || y+nbgY < 0 || y+nbgY >= dim {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			state := grid[row*col]
+			intstate := bool2int(state)
+			sum += intstate
+		}
+	}
+
+	sum -= bool2int(grid[y*x])
+
+	return sum
+}
+
+func Init() []bool {
+	max = dim * dim
+
+	grid := make([]bool, max)
+
+	for y := 0; y < dim; y++ {
+		for x := 0; x < dim; x++ {
+			if rand.Intn(density) == 1 {
+				grid[y*x] = true
+			}
+		}
+	}
+
+	return grid
+}
+
+func Loop(grid []bool) {
+	c := 0
+	for i := 0; i < loops; i++ {
+		for y := 0; y < dim; y++ {
+			for x := 0; x < dim; x++ {
+				state := grid[y*x]
+				neighbors := Count(grid, x, y)
+				if state && neighbors > 1 {
+					if debug {
+						fmt.Printf("Loop %d - cell at %d,%d is %t and has %d living neighbors\n", i, x, y, state, neighbors)
+					}
+					c = 1
+				}
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	grid := Init()
+
+	// main loop
+	Loop(grid)
+}

various-tests/perf-2dim-pointers-all-array/go.mod

@@ -0,0 +1,3 @@
+module perf
+
+go 1.22

various-tests/perf-2dim-pointers-all-array/main.go

@@ -0,0 +1,141 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+	"time"
+	"unsafe"
+)
+
+const (
+	max     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+type Cell struct {
+	State         bool
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+type Grid [1500][1500]Cell
+
+// https://dev.to/chigbeef_77/bool-int-but-stupid-in-go-3jb3
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) {
+	cell.NeighborCount = 0
+
+	for _, neighbor := range cell.Neighbors {
+		cell.NeighborCount += bool2int(neighbor.State)
+	}
+}
+
+func SetNeighbors(grid Grid, x, y int) {
+	cells := []*Cell{}
+	deadcell := &Cell{}
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= max || y+nbgY < 0 || y+nbgY >= max {
+				cells = append(cells, deadcell)
+			} else {
+
+				col = x + nbgX
+				row = y + nbgY
+
+				if col == x && row == y {
+					// do not add self
+					continue
+				}
+
+				cells = append(cells, &grid[row][col])
+			}
+		}
+	}
+
+	for idx, cell := range cells {
+		grid[y][x].Neighbors[idx] = cell
+	}
+}
+
+func Init() Grid {
+	grid := Grid{}
+
+	for y := 0; y < max; y++ {
+		for x := 0; x < max; x++ {
+			if rand.Intn(density) == 1 {
+				grid[y][x].State = true
+			}
+		}
+	}
+
+	for y := 0; y < max; y++ {
+		for x := 0; x < max; x++ {
+			SetNeighbors(grid, x, y)
+		}
+	}
+
+	return grid
+}
+
+func Loop(grid Grid) {
+	c := 0
+	for i := 0; i < loops; i++ {
+		for y := 0; y < max; y++ {
+			for x := 0; x < max; x++ {
+				cell := &grid[y][x]
+				state := cell.State
+
+				cell.Count(x, y)
+
+				if state && cell.NeighborCount > 1 {
+					if debug {
+						fmt.Printf(
+							"Loop %d - cell at %d,%d is %t and has %d living neighbors\n",
+							i, x, y, state, cell.NeighborCount)
+					}
+					c = 1
+				}
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+func main() {
+	// 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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	grid := Init()
+
+	// main loop
+	loopstart := time.Now()
+
+	Loop(grid)
+
+	loopend := time.Now()
+	diff := loopstart.Sub(loopend)
+	fmt.Printf("Loop took %.04f\n", diff.Seconds())
+}

various-tests/perf-2dim-pointers-array/go.mod

@@ -0,0 +1,3 @@
+module perf
+
+go 1.22

various-tests/perf-2dim-pointers-array/main.go

@@ -0,0 +1,139 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+	"time"
+	"unsafe"
+)
+
+const (
+	max     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+type Cell struct {
+	State         bool
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+// https://dev.to/chigbeef_77/bool-int-but-stupid-in-go-3jb3
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) {
+	cell.NeighborCount = 0
+
+	for _, neighbor := range cell.Neighbors {
+		cell.NeighborCount += bool2int(neighbor.State)
+	}
+}
+
+func SetNeighbors(grid [][]Cell, x, y int) {
+	cells := []*Cell{}
+	deadcell := &Cell{}
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= max || y+nbgY < 0 || y+nbgY >= max {
+				cells = append(cells, deadcell)
+			} else {
+
+				col = x + nbgX
+				row = y + nbgY
+
+				if col == x && row == y {
+					// do not add self
+					continue
+				}
+
+				cells = append(cells, &grid[row][col])
+			}
+		}
+	}
+
+	for idx, cell := range cells {
+		grid[y][x].Neighbors[idx] = cell
+	}
+}
+
+func Init() [][]Cell {
+	grid := make([][]Cell, max)
+	for y := 0; y < max; y++ {
+		grid[y] = make([]Cell, max)
+		for x := 0; x < max; x++ {
+			if rand.Intn(density) == 1 {
+				grid[y][x].State = true
+			}
+		}
+	}
+
+	for y := 0; y < max; y++ {
+		for x := 0; x < max; x++ {
+			SetNeighbors(grid, x, y)
+		}
+	}
+
+	return grid
+}
+
+func Loop(grid [][]Cell) {
+	c := 0
+	for i := 0; i < loops; i++ {
+		for y := 0; y < max; y++ {
+			for x := 0; x < max; x++ {
+				cell := &grid[y][x]
+				state := cell.State
+
+				cell.Count(x, y)
+
+				if state && cell.NeighborCount > 1 {
+					if debug {
+						fmt.Printf(
+							"Loop %d - cell at %d,%d is %t and has %d living neighbors\n",
+							i, x, y, state, cell.NeighborCount)
+					}
+					c = 1
+				}
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+func main() {
+	// 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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	grid := Init()
+
+	// main loop
+	loopstart := time.Now()
+
+	Loop(grid)
+
+	loopend := time.Now()
+	diff := loopstart.Sub(loopend)
+	fmt.Printf("Loop took %.04f\n", diff.Seconds())
+}

various-tests/perf-2dim-pointers/go.mod

@@ -0,0 +1,3 @@
+module perf
+
+go 1.22

various-tests/perf-2dim-pointers/main.go

@@ -0,0 +1,137 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+	"time"
+	"unsafe"
+)
+
+const (
+	max     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+type Cell struct {
+	State         bool
+	Neighbors     []*Cell
+	NeighborCount int
+}
+
+// https://dev.to/chigbeef_77/bool-int-but-stupid-in-go-3jb3
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) {
+	cell.NeighborCount = 0
+
+	for _, neighbor := range cell.Neighbors {
+		cell.NeighborCount += bool2int(neighbor.State)
+	}
+}
+
+func SetNeighbors(grid [][]Cell, x, y int) {
+	cells := []*Cell{}
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= max || y+nbgY < 0 || y+nbgY >= max {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			if col == x && row == y {
+				continue
+			}
+
+			cells = append(cells, &grid[row][col])
+		}
+	}
+
+	grid[y][x].Neighbors = make([]*Cell, len(cells))
+	for idx, cell := range cells {
+		grid[y][x].Neighbors[idx] = cell
+	}
+}
+
+func Init() [][]Cell {
+	grid := make([][]Cell, max)
+	for y := 0; y < max; y++ {
+		grid[y] = make([]Cell, max)
+		for x := 0; x < max; x++ {
+			if rand.Intn(density) == 1 {
+				grid[y][x].State = true
+			}
+		}
+	}
+
+	for y := 0; y < max; y++ {
+		for x := 0; x < max; x++ {
+			SetNeighbors(grid, x, y)
+		}
+	}
+
+	return grid
+}
+
+func Loop(grid [][]Cell) {
+	c := 0
+	for i := 0; i < loops; i++ {
+		for y := 0; y < max; y++ {
+			for x := 0; x < max; x++ {
+				cell := &grid[y][x]
+				state := cell.State
+
+				cell.Count(x, y)
+
+				if state && cell.NeighborCount > 1 {
+					if debug {
+						fmt.Printf(
+							"Loop %d - cell at %d,%d is %t and has %d living neighbors\n",
+							i, x, y, state, cell.NeighborCount)
+					}
+					c = 1
+				}
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+func main() {
+	// 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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	grid := Init()
+
+	// main loop
+	loopstart := time.Now()
+
+	Loop(grid)
+
+	loopend := time.Now()
+	diff := loopstart.Sub(loopend)
+	fmt.Printf("Loop took %.04f\n", diff.Seconds())
+}

various-tests/perf-2dim/go.mod

@@ -0,0 +1,3 @@
+module perf
+
+go 1.22

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

@@ -0,0 +1,102 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+	"unsafe"
+)
+
+const (
+	max     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+// https://dev.to/chigbeef_77/bool-int-but-stupid-in-go-3jb3
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func Count(grid [][]bool, x, y int) int {
+	var sum int
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= max || y+nbgY < 0 || y+nbgY >= max {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			state := grid[row][col]
+			intstate := bool2int(state)
+			sum += intstate
+		}
+	}
+
+	sum -= bool2int(grid[y][x])
+
+	return sum
+}
+
+func Init() [][]bool {
+	grid := make([][]bool, max)
+	for y := 0; y < max; y++ {
+		grid[y] = make([]bool, max)
+		for x := 0; x < max; x++ {
+			if rand.Intn(density) == 1 {
+				grid[y][x] = true
+			}
+		}
+	}
+
+	return grid
+}
+
+func Loop(grid [][]bool) {
+	c := 0
+	for i := 0; i < loops; i++ {
+		for y := 0; y < max; y++ {
+			for x := 0; x < max; x++ {
+				state := grid[y][x]
+				neighbors := Count(grid, x, y)
+				if state && neighbors > 1 {
+					if debug {
+						fmt.Printf("Loop %d - cell at %d,%d is %t and has %d living neighbors\n", i, x, y, state, neighbors)
+					}
+					c = 1
+				}
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+func main() {
+	// 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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	grid := Init()
+
+	// main loop
+	Loop(grid)
+}

various-tests/perf-ecs/go.mod

@@ -0,0 +1,5 @@
+module perf
+
+go 1.22
+
+require github.com/mlange-42/arche v0.13.0 // indirect

various-tests/perf-ecs/go.sum

@@ -0,0 +1,2 @@
+github.com/mlange-42/arche v0.13.0 h1:ef0fu9qC2KIr8wIlVs+CgeQ5CSUJ8A1Hut6nXYdf+xk=
+github.com/mlange-42/arche v0.13.0/go.mod h1:bFktKnvGDj2kP01xar79z0hKwGHdnoaEZR8HWmJkIyU=

various-tests/perf-ecs/main.go

@@ -0,0 +1,145 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+
+	"github.com/mlange-42/arche/ecs"
+	"github.com/mlange-42/arche/generic"
+)
+
+const (
+	max     int  = 1500
+	loops   int  = 5000
+	density int  = 8
+	debug   bool = false
+)
+
+// components
+type Pos struct {
+	X, Y, GridX, GridY int
+}
+
+type Cell struct {
+	State     bool
+	Neighbors [8]ecs.Entity
+}
+
+type ECS struct {
+	World  *ecs.World
+	Filter *generic.Filter2[Pos, Cell]
+	Map    *generic.Map2[Pos, Cell]
+}
+
+func (cell *Cell) NeighborCount(ECS *ECS) int {
+	sum := 0
+
+	for _, neighbor := range cell.Neighbors {
+		if ECS.World.Alive(neighbor) {
+			_, cel := ECS.Map.Get(neighbor)
+			if cel.State {
+				sum++
+			}
+		}
+	}
+
+	return sum
+}
+
+func Loop(ECS *ECS) {
+	c := 0
+
+	for i := 0; i < loops; i++ {
+		query := ECS.Filter.Query(ECS.World)
+
+		for query.Next() {
+			_, cel := query.Get()
+			if cel.State && cel.NeighborCount(ECS) > 1 {
+				c = 1
+			}
+		}
+	}
+
+	if c > 1 {
+		c = 0
+	}
+}
+
+func SetupWorld() *ECS {
+	world := ecs.NewWorld()
+
+	builder := generic.NewMap2[Pos, Cell](&world)
+
+	// we need a temporary grid in order to find out neighbors
+	grid := [max][max]ecs.Entity{}
+
+	// setup entities
+	for y := 0; y < max; y++ {
+		for x := 0; x < max; x++ {
+			e := builder.New()
+			pos, cell := builder.Get(e)
+			pos.X = x
+			pos.Y = y // pos.GridX = x*cellsize
+
+			cell.State = false
+			if rand.Intn(density) == 1 {
+				cell.State = true
+			}
+
+			// store to tmp grid
+			grid[y][x] = e
+		}
+	}
+
+	// global filter
+	filter := generic.NewFilter2[Pos, Cell]()
+
+	query := filter.Query(&world)
+
+	for query.Next() {
+		pos, cel := query.Get()
+
+		n := 0
+		for x := -1; x < 2; x++ {
+			for y := -1; y < 2; y++ {
+				XX := pos.X + x
+				YY := pos.Y + y
+				if XX < 0 || XX >= max || YY < 0 || YY >= max {
+					continue
+				}
+
+				if pos.X != XX || pos.Y != YY {
+					cel.Neighbors[n] = grid[XX][YY]
+					n++
+				}
+			}
+		}
+	}
+
+	return &ECS{World: &world, Filter: filter, Map: &builder}
+}
+
+func main() {
+	// 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")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	// init
+	fmt.Print("Setup ... ")
+	ECS := SetupWorld()
+	fmt.Println("done")
+	fmt.Println(ECS.World.Stats())
+
+	// main loop
+	Loop(ECS)
+}

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;
+}

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,24 +238,7 @@ func (game *Game) Draw(screen *ebiten.Image) {
 }
 
 func main() {
-	//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)
-}
-
-func _main() {
-	size := 800
+	size := 1500
 
 	game := &Game{
 		Width:     size,
@@ -264,7 +247,7 @@ func _main() {
 		Density:   8,
 		TPG:       10,
 		Debug:     false,
-		Profile:   false,
+		Profile:   true,
 		Gridlines: false,
 	}