int64 => uint8

- renamed scene files
- fixed options back using scene.Prev
- fixed initial zooming (finally)
- fixed reset zoom (key r)
- fixed initial size, now works with state loading as well

.gitignore

@@ -3,3 +3,6 @@ bak
 dump*
 rect*
 *profile
+*prof
+*lif
+*rle

Makefile

@@ -1,97 +1,4 @@
-# Copyright © 2024 Thomas von Dein
+.PHONY: all
-
+all:
-# This program is free software: you can redistribute it and/or modify
+	make -C src
-# it under the terms of the GNU General Public License as published by
+	mv src/golsky .
-# 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

TODO.md

@@ -1,17 +1,46 @@
 - 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
+- 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
+- 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
+https://www.tasnimzotder.com/blog/optimizing-game-of-life-algorithm
 
-- changing options mid-game has no effect in most cases, even after a restart
+- Speed
+  https://conwaylife.com/forums/viewtopic.php?f=7&t=3237
   
-- Statefile loading does not work correclty anymore. With larger grids
+- Patterns:
-  everything  is empty.  With square  grids part  of the  grid is  cut
-  off. Smaller grids load though
 
-- Also  when loading a state  file, centering doesn't work  anymore, I
+A   Catagolue   textcensus   of,  say,   period-2   oscillators   from
-  think the geom calculation is overthrown by the parser func. So, put
+non-symmetrical soups can be found at
-  this calc into its own func and  always call. Or - as stated below -
-  put it onto camera.go and call from Init().
 
-- Zoom 0 on reset only  works when world<screen.  otherwise zoom would
+https://catagolue.hatsya.com/textcensus/b3s23/C1/xp2
-  be negative So, on Init() memoize  centered camera position or add a
+
-  Center() function  to camera.go.  Then on  reset calculate  the zoom
+The URL is made by just adding the prefix "text" to the word "census",
-  level so that the world fits into the screen.
+in any URL linked to from a Catagolue census page such as this one:
+
+https://catagolue.hatsya.com/census/b3s23/C1
+
+Format:
+https://conwaylife.com/wiki/Apgcode
+
+
+Collections:
+
+https://conwaylife.com/wiki/Pattern_of_the_Year
+https://www.ibiblio.org/lifepatterns/
+https://entropymine.com/jason/life/
+https://github.com/Matthias-Merzenich/jslife-moving
+https://conwaylife.com/ref/mniemiec/lifepage.htm
+https://conwaylife.com/wiki/Spaceship ff.

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

src/Makefile

@@ -0,0 +1,97 @@
+# 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/camera.go

@@ -1,3 +1,5 @@
+// this comes from the camera example but I enhanced it a little bit
+
 package main
 
 import (
@@ -12,6 +14,9 @@ type Camera struct {
 	ViewPort          f64.Vec2
 	Position          f64.Vec2
 	ZoomFactor        int
+	InitialZoomFactor int
+	InitialPosition   f64.Vec2
+	ZoomOutFactor     int
 }
 
 func (c *Camera) String() string {
@@ -32,15 +37,17 @@ func (c *Camera) worldMatrix() ebiten.GeoM {
 	m := ebiten.GeoM{}
 	m.Translate(-c.Position[0], -c.Position[1])
 
+	viewportCenter := c.viewportCenter()
+
 	// We want to scale and rotate around center of image / screen
-	m.Translate(-c.viewportCenter()[0], -c.viewportCenter()[1])
+	m.Translate(-viewportCenter[0], -viewportCenter[1])
 
 	m.Scale(
 		math.Pow(1.01, float64(c.ZoomFactor)),
 		math.Pow(1.01, float64(c.ZoomFactor)),
 	)
 
-	m.Translate(c.viewportCenter()[0], c.viewportCenter()[1])
+	m.Translate(viewportCenter[0], viewportCenter[1])
 	return m
 }
 
@@ -61,8 +68,14 @@ func (c *Camera) ScreenToWorld(posX, posY int) (float64, float64) {
 	}
 }
 
-func (c *Camera) Reset() {
+func (c *Camera) Setup() {
-	c.Position[0] = 0
+	c.Position[0] = c.InitialPosition[0]
-	c.Position[1] = 0
+	c.Position[1] = c.InitialPosition[1]
-	c.ZoomFactor = 0
+	c.ZoomFactor = c.InitialZoomFactor
+}
+
+func (c *Camera) Reset() {
+	c.Position[0] = c.InitialPosition[0]
+	c.Position[1] = c.InitialPosition[1]
+	c.ZoomFactor = c.ZoomOutFactor
 }

src/config.go

@@ -30,6 +30,7 @@ type Config struct {
 	Restart, RestartGrid, RestartCache     bool
 	StartWithMenu                          bool
 	Zoomfactor                             int
+	ZoomOutFactor                          int
 	InitialCamPos                          []float64
 	DelayedStart                           bool // if true game, we wait. like pause but program induced
 
@@ -51,6 +52,40 @@ const (
 	DEFAULT_GEOM        = "640x384"
 )
 
+func (config *Config) SetupCamera() {
+	config.Zoomfactor = DEFAULT_ZOOMFACTOR
+
+	// calculate the initial cam pos. It is negative if the total grid
+	// size  is smaller than  the screen  in a centered  position, but
+	// it's zero if it's equal or larger than the screen.
+	config.InitialCamPos = make([]float64, 2)
+
+	config.InitialCamPos[0] = float64(((config.ScreenWidth - (config.Width * config.Cellsize)) / 2) * -1)
+	if config.Width*config.Cellsize >= config.ScreenWidth {
+		// must be positive if world wider than screen
+		config.InitialCamPos[0] = math.Abs(config.InitialCamPos[0])
+	}
+
+	// same for Y
+	config.InitialCamPos[1] = float64(((config.ScreenHeight - (config.Height * config.Cellsize)) / 2) * -1)
+	if config.Height*config.Cellsize > config.ScreenHeight {
+		config.InitialCamPos[1] = math.Abs(config.InitialCamPos[1])
+	}
+
+	// Calculate  zoom out factor, which  shows 100% of the  world. We
+	// need to reverse math.Pow(1.01,  $zoomfactor) to get the correct
+	// percentage of  the world to show.  I.e: with  a ScreenHeight of
+	// 384px and a world of 800px the factor to show 100% of the world
+	// is  -75: math.Log(384/800) / math.Log(1.01).  The 1.01 constant
+	// is being used in camera.go:worldMatrix().
+
+	// FIXME: determine if the diff is larger on width, then calc with
+	// width instead of height
+	config.ZoomOutFactor = int(
+		math.Log(float64(config.ScreenHeight)/(float64(config.Height)*float64(config.Cellsize))) /
+			math.Log(1.01))
+}
+
 // parse given window geometry and adjust game settings according to it
 func (config *Config) ParseGeom(geom string) error {
 	// force a geom
@@ -73,40 +108,37 @@ func (config *Config) ParseGeom(geom string) error {
 	config.ScreenHeight = height
 
 	config.Cellsize = DEFAULT_CELLSIZE
-	config.Zoomfactor = DEFAULT_ZOOMFACTOR
-
-	// calculate the initial cam pos. It is negative if the total grid
-	// size  is smaller than  the screen  in a centered  position, but
-	// it's zero if it's equal or larger than the screen.
-	config.InitialCamPos = make([]float64, 2)
-
-	config.InitialCamPos[0] = float64(((config.ScreenWidth - (config.Width * config.Cellsize)) / 2) * -1)
-	if config.Width*config.Cellsize >= config.ScreenWidth {
-		// must be positive if world wider than screen
-		config.InitialCamPos[0] = math.Abs(config.InitialCamPos[0])
-	}
-
-	if config.Height*config.Cellsize > config.ScreenHeight {
-		config.InitialCamPos[1] = math.Abs(float64(((config.ScreenHeight - (config.Height * config.Cellsize)) / 2)))
-	}
 
 	return nil
 }
 
-// check if we have  been given an RLE file to load,  then load it and
+// check if we have  been given an RLE or LIF file  to load, then load
-// adjust game settings accordingly
+// it and adjust game settings accordingly
 func (config *Config) ParseRLE(rlefile string) error {
 	if rlefile == "" {
 		return nil
 	}
 
-	rleobj, err := rle.GetRLE(rlefile)
+	var rleobj *rle.RLE
+
+	if strings.HasSuffix(rlefile, ".lif") {
+		lifobj, err := LoadLIF(rlefile)
 		if err != nil {
 			return err
 		}
 
+		rleobj = lifobj
+	} else {
+		rleobject, err := rle.GetRLE(rlefile)
+		if err != nil {
+			return err
+		}
+
+		rleobj = rleobject
+	}
+
 	if rleobj == nil {
-		return errors.New("failed to load RLE file (uncatched module error)")
+		return errors.New("failed to load pattern file (uncatched module error)")
 	}
 
 	config.RLE = rleobj
@@ -132,25 +164,6 @@ func (config *Config) ParseRLE(rlefile string) error {
 	return nil
 }
 
-// parse a state file, if given, and adjust game settings accordingly
-func (config *Config) ParseStatefile() error {
-	if config.Statefile == "" {
-		return nil
-	}
-
-	grid, err := LoadState(config.Statefile)
-	if err != nil {
-		return fmt.Errorf("failed to load game state: %s", err)
-	}
-
-	config.Width = grid.Width
-	config.Height = grid.Height
-	config.Cellsize = config.ScreenWidth / config.Width
-	config.StateGrid = grid
-
-	return nil
-}
-
 func (config *Config) EnableCPUProfiling(filename string) error {
 	if filename == "" {
 		return nil
@@ -185,8 +198,7 @@ func ParseCommandline() (*Config, error) {
 		"game speed: the higher the slower (default: 10)")
 
 	pflag.StringVarP(&rule, "rule", "r", "B3/S23", "game rule")
-	pflag.StringVarP(&rlefile, "rle-file", "f", "", "RLE pattern file")
+	pflag.StringVarP(&rlefile, "pattern-file", "f", "", "RLE or LIF pattern file")
-	pflag.StringVarP(&config.Statefile, "load-state-file", "l", "", "game state file")
 
 	pflag.BoolVarP(&config.ShowVersion, "version", "v", false, "show version")
 	pflag.BoolVarP(&config.Paused, "paused", "p", false, "do not start simulation (use space to start)")
@@ -214,17 +226,14 @@ func ParseCommandline() (*Config, error) {
 		return nil, err
 	}
 
-	err = config.ParseStatefile()
-	if err != nil {
-		return nil, err
-	}
-
 	// load  rule from commandline  when no  rule came from  RLE file,
 	// default is B3/S23, aka conways game of life
 	if config.Rule == nil {
 		config.Rule = ParseGameRule(rule)
 	}
 
+	config.SetupCamera()
+
 	//repr.Println(config)
 	return &config, nil
 }
@@ -234,7 +243,6 @@ func (config *Config) TogglePaused() {
 }
 
 func (config *Config) ToggleDebugging() {
-	fmt.Println("DEBUG TOGGLED")
 	config.Debug = !config.Debug
 }
 
@@ -247,3 +255,11 @@ func (config *Config) ToggleGridlines() {
 	config.ShowGrid = !config.ShowGrid
 	config.RestartCache = true
 }
+
+func (config *Config) ToggleEvolution() {
+	config.ShowEvolution = !config.ShowEvolution
+}
+
+func (config *Config) ToggleWrap() {
+	config.Wrap = !config.Wrap
+}

src/game.go

@@ -49,10 +49,14 @@ func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
 
 func (game *Game) Update() error {
 	scene := game.GetCurrentScene()
-	scene.Update()
+
+	if quit := scene.Update(); quit != nil {
+		return quit
+	}
 
 	next := scene.GetNext()
 	if next != game.CurrentScene {
+		game.Scenes[next].SetPrevious(game.CurrentScene)
 		scene.ResetNext()
 		game.CurrentScene = next
 	}

src/grid.go

@@ -6,7 +6,6 @@ import (
 	"fmt"
 	"math/rand"
 	"os"
-	"strconv"
 	"strings"
 	"time"
 
@@ -14,7 +13,7 @@ import (
 )
 
 type Grid struct {
-	Data                   [][]int64
+	Data                   [][]uint8
 	Width, Height, Density int
 	Empty                  bool
 }
@@ -25,12 +24,12 @@ func NewGrid(width, height, density int, empty bool) *Grid {
 		Height:  height,
 		Width:   width,
 		Density: density,
-		Data:    make([][]int64, height),
+		Data:    make([][]uint8, height),
 		Empty:   empty,
 	}
 
 	for y := 0; y < height; y++ {
-		grid.Data[y] = make([]int64, width)
+		grid.Data[y] = make([]uint8, width)
 	}
 
 	return grid
@@ -113,30 +112,8 @@ func (grid *Grid) LoadRLE(pattern *rle.RLE) {
 	}
 }
 
-// save  the contents  of  the  whole grid  as  a  simple mcell  alike
+// load a lif file parameters like R and P are not supported yet
-// file. One line per row, 0 for dead and 1 for life cell.
+func LoadLIF(filename string) (*rle.RLE, error) {
-func (grid *Grid) SaveState(filename string) error {
-	file, err := os.Create(filename)
-	if err != nil {
-		return fmt.Errorf("failed to open state file: %w", err)
-	}
-	defer file.Close()
-
-	for y := range grid.Data {
-		for _, cell := range grid.Data[y] {
-			_, err := file.WriteString(strconv.FormatInt(cell, 10))
-			if err != nil {
-				return fmt.Errorf("failed to write to state file: %w", err)
-			}
-		}
-		file.WriteString("\n")
-	}
-
-	return nil
-}
-
-// the reverse of the above, load a mcell file
-func LoadState(filename string) (*Grid, error) {
 	fd, err := os.Open(filename)
 	if err != nil {
 		return nil, err
@@ -146,33 +123,60 @@ func LoadState(filename string) (*Grid, error) {
 
 	scanner.Split(bufio.ScanLines)
 
-	grid := &Grid{}
+	gothead := false
+
+	grid := &rle.RLE{}
 
 	for scanner.Scan() {
-		items := strings.Split(scanner.Text(), "")
+		line := scanner.Text()
-		row := make([]int64, len(items))
+		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 {
-			num, err := strconv.ParseInt(item, 10, 64)
+			switch item {
-			if err != nil {
+			case ".":
-				return nil, err
+				row[idx] = 0
+			case "o":
+				fallthrough
+			case "*":
+				row[idx] = 1
+			default:
+				return nil, errors.New("cells must be . or o")
+			}
 		}
 
-			if num > 1 {
+		grid.Pattern = append(grid.Pattern, row)
-				return nil, errors.New("cells must be 0 or 1")
-			}
-
-			row[idx] = num
-		}
-
-		grid.Data = append(grid.Data, row)
 	}
 
 	// sanity check the grid
 	explen := 0
 	rows := 0
 	first := true
-	for _, row := range grid.Data {
+	for _, row := range grid.Pattern {
 		length := len(row)
 
 		if first {
@@ -195,13 +199,46 @@ func LoadState(filename string) (*Grid, error) {
 	return grid, nil
 }
 
-// generate filenames for dumps
+// save  the contents  of  the  whole grid  as  a  simple lif  alike
-func GetFilename(generations int64) string {
+// file. One line per row, 0 for dead and 1 for life cell.
-	now := time.Now()
+// file format: https://conwaylife.com/wiki/Life_1.05
-	return fmt.Sprintf("dump-%s-%d.gol", now.Format("20060102150405"), generations)
+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
 }
 
-func GetFilenameRLE(generations int64) string {
+// generate filenames for dumps
+func GetFilename(generations uint64) string {
+	now := time.Now()
+	return fmt.Sprintf("dump-%s-%d.lif", now.Format("20060102150405"), generations)
+}
+
+func GetFilenameRLE(generations uint64) string {
 	now := time.Now()
 	return fmt.Sprintf("rect-%s-%d.rle", now.Format("20060102150405"), generations)
 }

src/menu.go

@@ -14,6 +14,7 @@ type SceneMenu struct {
 	Game      *Game
 	Config    *Config
 	Next      SceneName
+	Prev      SceneName
 	Whoami    SceneName
 	Ui        *ebitenui.UI
 	FontColor color.RGBA
@@ -38,6 +39,10 @@ func (scene *SceneMenu) GetNext() SceneName {
 	return scene.Next
 }
 
+func (scene *SceneMenu) SetPrevious(prev SceneName) {
+	scene.Prev = prev
+}
+
 func (scene *SceneMenu) ResetNext() {
 	scene.Next = scene.Whoami
 }
@@ -99,9 +104,9 @@ func (scene *SceneMenu) Init() {
 			scene.SetNext(Options)
 		})
 
-	separator1 := NewSeparator()
+	separator1 := NewSeparator(3)
-	separator2 := NewSeparator()
+	separator2 := NewSeparator(3)
-	separator3 := NewSeparator()
+	separator3 := NewSeparator(10)
 
 	cancel := NewMenuButton("Back",
 		func(args *widget.ButtonClickedEventArgs) {

src/options.go

@@ -13,6 +13,7 @@ type SceneOptions struct {
 	Game      *Game
 	Config    *Config
 	Next      SceneName
+	Prev      SceneName
 	Whoami    SceneName
 	Ui        *ebitenui.UI
 	FontColor color.RGBA
@@ -36,6 +37,10 @@ func (scene *SceneOptions) GetNext() SceneName {
 	return scene.Next
 }
 
+func (scene *SceneOptions) SetPrevious(prev SceneName) {
+	scene.Prev = prev
+}
+
 func (scene *SceneOptions) ResetNext() {
 	scene.Next = scene.Whoami
 }
@@ -90,7 +95,7 @@ func (scene *SceneOptions) Init() {
 
 	invert := NewCheckbox("Invert",
 		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.Invert = true
+			scene.Config.ToggleInvert()
 		})
 	scene.SetInitialValue(invert, scene.Config.Invert)
 
@@ -100,17 +105,31 @@ func (scene *SceneOptions) Init() {
 		})
 	scene.SetInitialValue(gridlines, scene.Config.ShowGrid)
 
-	separator := NewSeparator()
+	evolution := NewCheckbox("Show evolution traces",
+		func(args *widget.CheckboxChangedEventArgs) {
+			scene.Config.ToggleEvolution()
+		})
+	scene.SetInitialValue(evolution, scene.Config.ShowEvolution)
+
+	wrap := NewCheckbox("Wrap around edges",
+		func(args *widget.CheckboxChangedEventArgs) {
+			scene.Config.ToggleWrap()
+		})
+	scene.SetInitialValue(wrap, scene.Config.Wrap)
+
+	separator := NewSeparator(3)
 
 	cancel := NewMenuButton("Close",
 		func(args *widget.ButtonClickedEventArgs) {
-			scene.SetNext(Menu)
+			scene.SetNext(scene.Prev)
 		})
 
 	rowContainer.AddChild(pause)
 	rowContainer.AddChild(debugging)
 	rowContainer.AddChild(invert)
 	rowContainer.AddChild(gridlines)
+	rowContainer.AddChild(evolution)
+	rowContainer.AddChild(wrap)
 	rowContainer.AddChild(separator)
 	rowContainer.AddChild(cancel)
 

src/play.go

@@ -5,7 +5,6 @@ import (
 	"image"
 	"image/color"
 	"log"
-	"os"
 
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/inpututil"
@@ -26,14 +25,15 @@ type ScenePlay struct {
 	Game   *Game
 	Config *Config
 	Next   SceneName
+	Prev   SceneName
 	Whoami SceneName
 
 	Clear bool
 
 	Grids                                      []*Grid    // 2 grids: one current, one next
-	History                                    *Grid   // holds state of past dead cells for evolution traces
+	History                                    [][]uint64 // holds state of past dead cells for evolution traces
 	Index                                      int        // points to current grid
-	Generations                                int64   // Stats
+	Generations                                uint64     // Stats
 	Black, White, Grey, Old                    color.RGBA
 	AgeColor1, AgeColor2, AgeColor3, AgeColor4 color.RGBA
 	TicksElapsed                               int           // tick counter for game speed
@@ -73,6 +73,10 @@ func (scene *ScenePlay) GetNext() SceneName {
 	return scene.Next
 }
 
+func (scene *ScenePlay) SetPrevious(prev SceneName) {
+	scene.Prev = prev
+}
+
 func (scene *ScenePlay) ResetNext() {
 	scene.Next = scene.Whoami
 }
@@ -81,8 +85,8 @@ func (scene *ScenePlay) SetNext(next SceneName) {
 	scene.Next = next
 }
 
-func (scene *ScenePlay) CheckRule(state int64, neighbors int64) int64 {
+func (scene *ScenePlay) CheckRule(state uint8, neighbors uint8) uint8 {
-	var nextstate int64
+	var nextstate uint8
 
 	// The standard Scene of Life is symbolized in rule-string notation
 	// as B3/S23 (23/3 here).  A cell  is born if it has exactly three
@@ -129,8 +133,9 @@ func (scene *ScenePlay) UpdateCells() {
 			// 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
+			// FIXME: unbranch somehow
 			if state != nextstate {
-				scene.History.Data[y][x] = scene.Generations
+				scene.History[y][x] = scene.Generations
 			}
 		}
 	}
@@ -152,22 +157,29 @@ func (scene *ScenePlay) UpdateCells() {
 
 func (scene *ScenePlay) Reset() {
 	scene.Config.Paused = true
-	scene.InitGrid(nil)
+	scene.InitGrid()
 	scene.Config.Paused = false
 }
 
 // check user input
-func (scene *ScenePlay) CheckInput() {
+func (scene *ScenePlay) CheckExit() error {
 	if inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		os.Exit(0)
+		return ebiten.Termination
 	}
 
+	return nil
+}
+
+func (scene *ScenePlay) CheckInput() {
 	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
 		scene.SetNext(Menu)
 	}
 
+	if inpututil.IsKeyJustPressed(ebiten.KeyO) {
+		scene.SetNext(Options)
+	}
+
 	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
-		fmt.Println("mark mode on")
 		scene.Config.Markmode = true
 		scene.Config.Paused = true
 	}
@@ -288,6 +300,10 @@ func (scene *ScenePlay) CheckMarkInput() {
 		return
 	}
 
+	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
+		scene.Config.Markmode = false
+	}
+
 	if ebiten.IsMouseButtonPressed(ebiten.MouseButton0) {
 		if !scene.MarkTaken {
 			scene.Mark = scene.GetWorldCursorPos()
@@ -308,7 +324,7 @@ func (scene *ScenePlay) CheckMarkInput() {
 
 func (scene *ScenePlay) SaveState() {
 	filename := GetFilename(scene.Generations)
-	err := scene.Grids[scene.Index].SaveState(filename)
+	err := scene.Grids[scene.Index].SaveState(filename, scene.Config.Rule.Definition)
 	if err != nil {
 		log.Printf("failed to save game state to %s: %s", filename, err)
 	}
@@ -348,10 +364,10 @@ 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]
@@ -370,7 +386,8 @@ func (scene *ScenePlay) SaveRectRLE() {
 func (scene *ScenePlay) Update() error {
 	if scene.Config.Restart {
 		scene.Config.Restart = false
-		scene.InitGrid(nil)
+		scene.Generations = 0
+		scene.InitGrid()
 		scene.InitCache()
 		return nil
 	}
@@ -382,6 +399,10 @@ func (scene *ScenePlay) Update() error {
 		return nil
 	}
 
+	if quit := scene.CheckExit(); quit != nil {
+		return quit
+	}
+
 	scene.CheckInput()
 	scene.CheckDraggingInput()
 	scene.CheckMarkInput()
@@ -394,15 +415,15 @@ func (scene *ScenePlay) Update() error {
 }
 
 // set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos(alive int64) {
+func (scene *ScenePlay) ToggleCellOnCursorPos(state uint8) {
 	// use cursor pos relative to the world
 	worldX, worldY := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
 	x := int(worldX) / scene.Config.Cellsize
 	y := int(worldY) / scene.Config.Cellsize
 
 	if x > -1 && y > -1 && x < scene.Config.Width && y < scene.Config.Height {
-		scene.Grids[scene.Index].Data[y][x] = alive
+		scene.Grids[scene.Index].Data[y][x] = state
-		scene.History.Data[y][x] = 1
+		scene.History[y][x] = 1
 	}
 }
 
@@ -416,7 +437,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 	op.GeoM.Translate(0, 0)
 	scene.World.DrawImage(scene.Cache, op)
 
-	var age int64
+	var age uint64
 
 	for y := 0; y < scene.Config.Height; y++ {
 		for x := 0; x < scene.Config.Width; x++ {
@@ -426,7 +447,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 				float64(y*scene.Config.Cellsize),
 			)
 
-			age = scene.Generations - scene.History.Data[y][x]
+			age = scene.Generations - scene.History[y][x]
 
 			switch scene.Grids[scene.Index].Data[y][x] {
 			case Alive:
@@ -438,7 +459,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 				}
 			case Dead:
 				// only draw dead cells in case evolution trace is enabled
-				if scene.History.Data[y][x] > 1 && scene.Config.ShowEvolution {
+				if scene.History[y][x] > 1 && scene.Config.ShowEvolution {
 					switch {
 					case age < 10:
 						scene.World.DrawImage(scene.Tiles.Age1, op)
@@ -489,6 +510,10 @@ func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
 			paused = "-- paused --"
 		}
 
+		if scene.Config.Markmode {
+			paused = "-- mark --"
+		}
+
 		x, y := ebiten.CursorPosition()
 		debug := fmt.Sprintf(
 			DEBUG_FORMAT,
@@ -515,7 +540,6 @@ 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)
 }
 
 // pre-render offscreen cache image
@@ -542,19 +566,7 @@ func (scene *ScenePlay) InitCache() {
 }
 
 // initialize grid[s], either using pre-computed from state or rle file, or random
-func (scene *ScenePlay) InitGrid(grid *Grid) {
+func (scene *ScenePlay) InitGrid() {
-	if grid != nil {
-		// use pre-loaded grid
-		scene.Grids = []*Grid{
-			grid,
-			NewGrid(grid.Width, grid.Height, 0, false),
-		}
-
-		scene.History = NewGrid(grid.Width, grid.Height, 0, false)
-
-		return
-	}
-
 	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)
@@ -568,7 +580,10 @@ func (scene *ScenePlay) InitGrid(grid *Grid) {
 		gridb,
 	}
 
-	scene.History = history
+	scene.History = make([][]uint64, scene.Config.Height)
+	for y := 0; y < scene.Config.Height; y++ {
+		scene.History[y] = make([]uint64, scene.Config.Width)
+	}
 }
 
 // prepare tile images
@@ -614,17 +629,17 @@ func (scene *ScenePlay) InitTiles() {
 
 func (scene *ScenePlay) Init() {
 	// setup the scene
-	var grid *Grid
-
-	if scene.Config.StateGrid != nil {
-		grid = scene.Config.StateGrid
-	}
-
 	scene.Camera = Camera{
 		ViewPort: f64.Vec2{
 			float64(scene.Config.ScreenWidth),
 			float64(scene.Config.ScreenHeight),
 		},
+		InitialZoomFactor: scene.Config.Zoomfactor,
+		InitialPosition: f64.Vec2{
+			scene.Config.InitialCamPos[0],
+			scene.Config.InitialCamPos[1],
+		},
+		ZoomOutFactor: scene.Config.ZoomOutFactor,
 	}
 
 	scene.World = ebiten.NewImage(
@@ -642,10 +657,10 @@ func (scene *ScenePlay) Init() {
 
 	if scene.Config.DelayedStart && !scene.Config.Empty {
 		scene.Config.Empty = true
-		scene.InitGrid(grid)
+		scene.InitGrid()
 		scene.Config.Empty = false
 	} else {
-		scene.InitGrid(grid)
+		scene.InitGrid()
 	}
 
 	scene.InitPattern()
@@ -659,13 +674,12 @@ func (scene *ScenePlay) Init() {
 		scene.Camera.ZoomFactor = scene.Config.Zoomfactor
 	}
 
-	scene.Camera.Position[0] = scene.Config.InitialCamPos[0]
+	scene.Camera.Setup()
-	scene.Camera.Position[1] = scene.Config.InitialCamPos[1]
 }
 
 // count the living neighbors of a cell
-func (scene *ScenePlay) CountNeighbors(x, y int) int64 {
+func (scene *ScenePlay) CountNeighbors(x, y int) uint8 {
-	var sum int64
+	var sum uint8
 
 	for nbgX := -1; nbgX < 2; nbgX++ {
 		for nbgY := -1; nbgY < 2; nbgY++ {
@@ -703,8 +717,8 @@ func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
 		tile,
 		float32(1),
 		float32(1),
-		float32(cellsize-1),
+		float32(cellsize),
-		float32(cellsize-1),
+		float32(cellsize),
 		col, false,
 	)
 }

src/rule.go

@@ -9,22 +9,22 @@ import (
 // a GOL rule
 type Rule struct {
 	Definition string
-	Birth      []int64
+	Birth      []uint8
-	Death      []int64
+	Death      []uint8
 }
 
 // parse one part of a GOL rule into rule slice
-func NumbersToList(numbers string) []int64 {
+func NumbersToList(numbers string) []uint8 {
-	list := []int64{}
+	list := []uint8{}
 
 	items := strings.Split(numbers, "")
 	for _, item := range items {
-		num, err := strconv.ParseInt(item, 10, 64)
+		num, err := strconv.ParseInt(item, 10, 8)
 		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

src/scene.go

@@ -13,6 +13,7 @@ type SceneName int
 type Scene interface {
 	SetNext(SceneName)
 	GetNext() SceneName
+	SetPrevious(SceneName)
 	ResetNext()
 	Update() error
 	Draw(screen *ebiten.Image)

src/widgets.go

@@ -64,12 +64,12 @@ func NewCheckbox(
 	)
 }
 
-func NewSeparator() widget.PreferredSizeLocateableWidget {
+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:    3,
+				Top:    padding,
 				Bottom: 0,
 			}))),
 		widget.ContainerOpts.WidgetOpts(

various-tests/drawtriangles/go.mod

@@ -0,0 +1,13 @@
+module drawminimal
+
+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/drawtriangles/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/drawtriangles/main.go

@@ -0,0 +1,362 @@
+package main
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"log"
+	"math/rand"
+	"os"
+	"runtime/pprof"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+var (
+	blackImage    = ebiten.NewImage(3, 3)
+	blackSubImage = blackImage.SubImage(image.Rect(1, 1, 2, 2)).(*ebiten.Image)
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Grid struct {
+	Data                   [][]int64
+	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([][]int64, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]int64, width)
+	}
+
+	return grid
+}
+
+// live console output of the grid
+func (grid *Grid) Dump() {
+	/*
+		cmd := exec.Command("clear")
+		cmd.Stdout = os.Stdout
+		cmd.Run()
+
+		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()
+		}
+	*/
+	fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
+}
+
+type Game struct {
+	Width, Height, Cellsize, Density int
+	ScreenWidth, ScreenHeight        int
+	Grids                            []*Grid
+	Index                            int
+	Black, White, Grey               color.RGBA
+	Tiles                            Images
+	Cache                            *ebiten.Image
+	Elapsed                          int64
+	TPG                              int64 // adjust game speed independently of TPS
+	Vertices                         []ebiten.Vertex
+	Indices                          []uint16
+	Pause, Debug                     bool
+}
+
+// fill a cell
+func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
+	vector.DrawFilledRect(
+		tile,
+		float32(1),
+		float32(1),
+		float32(cellsize-1),
+		float32(cellsize-1),
+		col, false,
+	)
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+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)
+
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			if rand.Intn(game.Density) == 1 {
+				grida.Data[y][x] = 1
+			}
+		}
+
+	}
+
+	game.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	// setup colors
+	game.Grey = color.RGBA{128, 128, 128, 0xff}
+	game.Black = color.RGBA{0, 0, 0, 0xff}
+	game.White = color.RGBA{200, 200, 200, 0xff}
+
+	game.Tiles.White = ebiten.NewImage(game.Cellsize, game.Cellsize)
+	game.Cache = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+
+	FillCell(game.Tiles.White, game.Cellsize, game.White)
+	game.Cache.Fill(game.Grey)
+
+	// draw the offscreen image
+	op := &ebiten.DrawImageOptions{}
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			op.GeoM.Reset()
+			op.GeoM.Translate(float64(x*game.Cellsize), float64(y*game.Cellsize))
+			game.Cache.DrawImage(game.Tiles.White, op)
+		}
+	}
+
+	blackSubImage.Fill(game.Black)
+
+	lenvertices := game.ScreenHeight * game.ScreenWidth
+	game.Vertices = make([]ebiten.Vertex, lenvertices)
+	game.Indices = make([]uint16, lenvertices+(lenvertices/2))
+}
+
+// count the living neighbors of a cell
+func (game *Game) CountNeighbors(x, y int) int64 {
+	var sum int64
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			// 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 + game.Width) % game.Width
+			row = (y + nbgY + game.Height) % game.Height
+
+			sum += game.Grids[game.Index].Data[row][col]
+		}
+	}
+
+	// don't count ourselfes though
+	sum -= game.Grids[game.Index].Data[y][x]
+
+	return sum
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state int64, neighbors int64) int64 {
+	var nextstate int64
+
+	if state == 0 && 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
+
+	// reset vertices
+	// FIXME: fails!
+	game.ClearVertices()
+
+	// 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] // 0|1 == dead or alive
+			neighbors := game.CountNeighbors(x, y)     // alive neighbor count
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x] = nextstate
+		}
+	}
+
+	// calculate triangles for rendering
+	game.UpdateTriangles()
+
+	// switch grid for rendering
+	game.Index ^= 1
+
+	game.Elapsed = 0
+
+	if game.Debug {
+		game.Grids[next].Dump()
+	}
+}
+
+func (game *Game) Update() error {
+	game.UpdateCells()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
+		game.Pause = !game.Pause
+	}
+
+	return nil
+}
+
+func (game *Game) ClearVertices() {
+	// FIXME: fails
+	for i := 0; i < len(game.Vertices); i++ {
+		game.Vertices[i] = ebiten.Vertex{}
+		// game.Vertices[i].DstX = 0
+		// game.Vertices[i].DstY = 1
+	}
+
+	game.Indices = game.Indices[:len(game.Indices)]
+}
+
+// create the triangles needed for rendering. Actual rendering doesn't
+// happen here but in Draw()
+func (game *Game) UpdateTriangles() {
+	var base uint16 = 0
+	var index uint16 = 0
+
+	idx := 0
+
+	// iterate over every cell
+	for celly := 0; celly < game.Height; celly++ {
+		for cellx := 0; cellx < game.Width; cellx++ {
+
+			// if the cell is alife
+			if game.Grids[game.Index].Data[celly][cellx] == 1 {
+
+				/* iterate over the cell's corners:
+				0   1
+
+				2   3
+				*/
+				for i := 0; i < 2; i++ {
+					for j := 0; j < 2; j++ {
+
+						// calculate the corner position
+						x := (cellx * game.Cellsize) + (i * game.Cellsize) + 1
+						y := (celly * game.Cellsize) + (j * game.Cellsize) + 1
+
+						if i == 1 {
+							x -= 1
+						}
+						if j == 1 {
+							y -= 1
+						}
+
+						// setup the vertex
+						game.Vertices[idx].DstX = float32(x)
+						game.Vertices[idx].DstY = float32(y)
+						game.Vertices[idx].SrcX = 1
+						game.Vertices[idx].SrcY = 1
+						game.Vertices[idx].ColorR = float32(game.Black.R)
+						game.Vertices[idx].ColorG = float32(game.Black.G)
+						game.Vertices[idx].ColorB = float32(game.Black.B)
+						game.Vertices[idx].ColorA = 1
+
+						idx++
+					}
+				}
+			}
+
+			// indices for first triangle
+			game.Indices[index] = base
+			game.Indices[index+1] = base + 1
+			game.Indices[index+2] = base + 3
+
+			// for the second one
+			game.Indices[index+3] = base
+			game.Indices[index+4] = base + 2
+			game.Indices[index+5] = base + 3
+
+			index += 6 // 3 indicies per triangle
+
+			base += 4 // 4 vertices per cell
+		}
+	}
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	op := &ebiten.DrawImageOptions{}
+
+	op.GeoM.Translate(0, 0)
+	screen.DrawImage(game.Cache, op)
+
+	triop := &ebiten.DrawTrianglesOptions{}
+	screen.DrawTriangles(game.Vertices, game.Indices, blackSubImage, triop)
+}
+
+func main() {
+	size := 200
+
+	game := &Game{
+		Width:    size,
+		Height:   size,
+		Cellsize: 4,
+		Density:  5,
+		TPG:      5,
+		Debug:    true,
+	}
+
+	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)
+
+	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/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/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/main.go

@@ -0,0 +1,288 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"runtime/pprof"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Grid struct {
+	Data                   [][]int64
+	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([][]int64, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]int64, width)
+	}
+
+	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] == 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)
+
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			if rand.Intn(game.Density) == 1 {
+				grida.Data[y][x] = 1
+			}
+		}
+
+	}
+
+	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) int64 {
+	var sum int64
+
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			// 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 + game.Width) % game.Width
+			row = (y + nbgY + game.Height) % game.Height
+
+			sum += game.Grids[game.Index].Data[row][col]
+		}
+	}
+
+	// don't count ourselfes though
+	sum -= game.Grids[game.Index].Data[y][x]
+
+	return sum
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state int64, neighbors int64) int64 {
+	var nextstate int64
+
+	if state == 0 && 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] // 0|1 == dead or alive
+			neighbors := game.CountNeighbors(x, y)     // alive neighbor count
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x] = 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] == 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() {
+	// state := 1
+	// nextstate := 0
+	v := 0
+
+	for i := 0; i < 600; i++ {
+		v = ((v + 1) & 255)
+		fmt.Println(i, i&255)
+	}
+}
+
+func _main() {
+	size := 800
+
+	game := &Game{
+		Width:     size,
+		Height:    size,
+		Cellsize:  4,
+		Density:   8,
+		TPG:       10,
+		Debug:     false,
+		Profile:   false,
+		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)
+	}
+}