add profiling support and window geom options to force geometry

.gitignore

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

Makefile

@@ -0,0 +1,96 @@
+# 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)
+
+all: buildlocal
+
+
+buildlocal:
+	go build -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

README.md

@@ -1,15 +1,12 @@
-[![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) 
-
 # golsky - Conway's game of life written in GO
 
-> [!IMPORTANT]
-> This software is now being maintained on [Codeberg](https://codeberg.org/scip/golsky/).
-
 ![Golsky Logo](https://github.com/TLINDEN/golsky/blob/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) 
 
-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/).
 
@@ -17,25 +14,11 @@ John Conway himself: https://youtu.be/R9Plq-D1gEk?si=yYxs77e9yXxeSNbL
 
 Based on: https://youtu.be/FWSR_7kZuYg?si=ix1dmo76D8AmF25F
 
-# Screenshots
-[![golsky-mainmenu.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-mainmenu.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-mainmenu.png)
-[![golsky-options.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-options.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-options.png)
-[![golsky-bindings.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-bindings.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-bindings.png)
-[![golsky-evolution-trace.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-evolution-trace.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-evolution-trace.png)
-[![golsky-zoom.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-zoom.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-zoom.png)
-[![golsky-debug.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-debug.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-debug.png)
-[![golsky-capture.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-capture.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-capture.png)
-[![golsky-captured.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-captured.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-captured.png)
-[![golsky-dark-theme.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-dark-theme.png)](https://github.com/TLINDEN/golsky/blob/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
 * colors can be inverted
-* evolution  traces can be shown,  with age the cells  color fades and
+* evolution  tracks can be shown,  with age the cells  color fades and
   old life cells will be drawn in red
 * game grid lines can be enabled or disabled
 * game speed can be adjusted on startup and in-game
@@ -78,7 +61,7 @@ Usage of ./golsky:
   -p, --paused                     do not start simulation (use space to start)
   -f, --rle-file string            RLE pattern file
   -r, --rule string                game rule (default "B3/S23")
-  -s, --show-evolution             show evolution traces
+  -s, --show-evolution             show evolution tracks
   -t, --ticks-per-generation int   game speed: the higher the slower (default: 10) (default 10)
   -v, --version                    show version
   -W, --width int                  grid width in cells (default 40)
@@ -86,22 +69,18 @@ Usage of ./golsky:
 
 While it runs, there are a couple of commands you can use:
 
-
+* left mouse click: set a cell to alife (also pauses the game)
+* right mouse click: set a cell to dead
 * space: pause or resume the game
 * while game is paused: press n to forward one step
 * page up: speed up
 * page down: slow down
 * Mouse wheel: zoom in or out
-* move mouse while left mouse button pressed: move canvas
-* i: enter "insert" (draw) mode: use left mouse to toggle cells alife state.
-  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
+* move mouse while middle mouse button pressed: move canvas
+* escape: reset to 1:1 zoom
 * s: save game state to file (can be loaded with -l)
 * c: enter copy mode. Mark a rectangle with the mouse, when you
   release the mous button it is being saved to an RLE file
-* d: toggle debug output 
 * q: quit
 
 # Report bugs

TODO.md

@@ -0,0 +1 @@
+- Implement RLE writing on scene.MarkDone

camera.go

@@ -0,0 +1,68 @@
+package main
+
+import (
+	"fmt"
+	"math"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"golang.org/x/image/math/f64"
+)
+
+type Camera struct {
+	ViewPort   f64.Vec2
+	Position   f64.Vec2
+	ZoomFactor int
+}
+
+func (c *Camera) String() string {
+	return fmt.Sprintf(
+		"T: %.1f, S: %d",
+		c.Position, c.ZoomFactor,
+	)
+}
+
+func (c *Camera) viewportCenter() f64.Vec2 {
+	return f64.Vec2{
+		c.ViewPort[0] * 0.5,
+		c.ViewPort[1] * 0.5,
+	}
+}
+
+func (c *Camera) worldMatrix() ebiten.GeoM {
+	m := ebiten.GeoM{}
+	m.Translate(-c.Position[0], -c.Position[1])
+
+	// We want to scale and rotate around center of image / screen
+	m.Translate(-c.viewportCenter()[0], -c.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])
+	return m
+}
+
+func (c *Camera) Render(world, screen *ebiten.Image) {
+	screen.DrawImage(world, &ebiten.DrawImageOptions{
+		GeoM: c.worldMatrix(),
+	})
+}
+
+func (c *Camera) ScreenToWorld(posX, posY int) (float64, float64) {
+	inverseMatrix := c.worldMatrix()
+	if inverseMatrix.IsInvertible() {
+		inverseMatrix.Invert()
+		return inverseMatrix.Apply(float64(posX), float64(posY))
+	} else {
+		// When scaling it can happened that matrix is not invertable
+		return math.NaN(), math.NaN()
+	}
+}
+
+func (c *Camera) Reset() {
+	c.Position[0] = 0
+	c.Position[1] = 0
+	c.ZoomFactor = 0
+}

config.go

@@ -0,0 +1,198 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime/pprof"
+	"strconv"
+	"strings"
+
+	"github.com/spf13/pflag"
+	"github.com/tlinden/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      bool     // game modi
+	ShowEvolution, NoGrid, 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
+
+	// for internal profiling
+	ProfileFile     string
+	ProfileDraw     bool
+	ProfileMaxLoops int64
+}
+
+const (
+	VERSION = "v0.0.7"
+	Alive   = 1
+	Dead    = 0
+)
+
+// parse given window geometry and adjust game settings according to it
+func (config *Config) ParseGeom(geom string) error {
+	if geom == "" {
+		config.ScreenWidth = config.Cellsize * config.Width
+		config.ScreenHeight = config.Cellsize * config.Height
+		return nil
+	}
+
+	// force a geom
+	geometry := strings.Split(geom, "x")
+	if len(geometry) != 2 {
+		return errors.New("failed to parse -g parameters, expecting WIDTHxHEIGHT")
+	}
+
+	width, err := strconv.Atoi(geometry[0])
+	if err != nil {
+		return errors.New("failed to parse width, expecting integer")
+	}
+
+	height, err := strconv.Atoi(geometry[1])
+	if err != nil {
+		return errors.New("failed to parse height, expecting integer")
+	}
+
+	// adjust dimensions, account for  grid width+height so that cells
+	// fit into window
+	config.ScreenWidth = width - (width % config.Width)
+	config.ScreenHeight = height - (height % config.Height)
+	config.Cellsize = config.ScreenWidth / config.Width
+
+	return nil
+}
+
+// check if we have  been given an RLE file to load,  then load it and
+// adjust game settings accordingly
+func (config *Config) ParseRLE(rlefile string) error {
+	if rlefile == "" {
+		return nil
+	}
+
+	rleobj, err := rle.GetRLE(rlefile)
+	if err != nil {
+		return err
+	}
+
+	if rleobj == nil {
+		return errors.New("failed to load RLE file (uncatched module error)")
+	}
+
+	config.RLE = rleobj
+
+	// adjust geometry if needed
+	if config.RLE.Width > config.Width || config.RLE.Height > config.Height {
+		config.Width = config.RLE.Width * 2
+		config.Height = config.RLE.Height * 2
+		config.Cellsize = config.ScreenWidth / config.Width
+	}
+
+	// RLE needs an empty grid
+	config.Empty = true
+
+	// it may come with its own rule
+	if config.RLE.Rule != "" {
+		config.Rule = ParseGameRule(config.RLE.Rule)
+	}
+
+	return nil
+}
+
+// parse a state file, if given, and adjust game settings accordingly
+func (config *Config) ParseStatefile(statefile string) 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
+	}
+
+	fd, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+
+	return nil
+}
+
+func ParseCommandline() (*Config, error) {
+	config := Config{}
+
+	var (
+		rule, rlefile, geom string
+	)
+
+	// commandline params, most configure directly config flags
+	pflag.IntVarP(&config.Width, "width", "W", 40, "grid width in cells")
+	pflag.IntVarP(&config.Height, "height", "H", 40, "grid height in cells")
+	pflag.IntVarP(&config.Cellsize, "cellsize", "c", 8, "cell size in pixels")
+	pflag.StringVarP(&geom, "geom", "g", "", "window geometry in WxH in pixels, overturns -c")
+
+	pflag.IntVarP(&config.Density, "density", "D", 10, "density of random cells")
+	pflag.IntVarP(&config.TPG, "ticks-per-generation", "t", 10,
+		"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(&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)")
+	pflag.BoolVarP(&config.Debug, "debug", "d", false, "show debug info")
+	pflag.BoolVarP(&config.NoGrid, "nogrid", "n", false, "do not 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 tracks")
+	pflag.BoolVarP(&config.Wrap, "wrap-around", "w", false, "wrap around grid mode")
+
+	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()
+
+	err := config.ParseGeom(geom)
+	if err != nil {
+		return nil, err
+	}
+
+	err = config.ParseRLE(rlefile)
+	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)
+	}
+
+	return &config, nil
+}

game.go

@@ -0,0 +1,67 @@
+package main
+
+import "github.com/hajimehoshi/ebiten/v2"
+
+type Game struct {
+	ScreenWidth, ScreenHeight, Cellsize int
+	Scenes                              map[SceneName]Scene
+	CurrentScene                        SceneName
+	Config                              *Config
+}
+
+func NewGame(config *Config, startscene SceneName) *Game {
+	game := &Game{
+		Config:       config,
+		Scenes:       map[SceneName]Scene{},
+		ScreenWidth:  config.ScreenWidth,
+		ScreenHeight: config.ScreenHeight,
+	}
+
+	// setup scene[s]
+	game.CurrentScene = startscene
+	game.Scenes[Play] = NewPlayScene(game, config)
+
+	// setup environment
+	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
+	ebiten.SetWindowTitle("golsky - conway's game of life")
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+
+	return game
+}
+
+func (game *Game) GetCurrentScene() Scene {
+	return game.Scenes[game.CurrentScene]
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+func (game *Game) Update() error {
+	scene := game.GetCurrentScene()
+	scene.Update()
+
+	next := scene.GetNext()
+
+	if next != game.CurrentScene {
+		// make sure we stay on the selected scene
+		scene.ResetNext()
+
+		// finally switch
+		game.CurrentScene = next
+	}
+
+	return nil
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	scene := game.GetCurrentScene()
+
+	if scene.Clearscreen() {
+		ebiten.SetScreenClearedEveryFrame(true)
+	} else {
+		ebiten.SetScreenClearedEveryFrame(false)
+	}
+
+	scene.Draw(screen)
+}

generics.go

@@ -0,0 +1,12 @@
+package main
+
+// find an item in a list, generic variant
+func Contains[E comparable](s []E, v E) bool {
+	for _, vs := range s {
+		if v == vs {
+			return true
+		}
+	}
+
+	return false
+}

go.mod

@@ -0,0 +1,19 @@
+module github.com/tlinden/golsky
+
+go 1.22
+
+require (
+	github.com/hajimehoshi/ebiten/v2 v2.7.4
+	github.com/spf13/pflag v1.0.5
+	golang.org/x/image v0.16.0
+)
+
+require (
+	github.com/alecthomas/repr v0.4.0 // indirect
+	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/jezek/xgb v1.1.1 // indirect
+	golang.org/x/sync v0.7.0 // indirect
+	golang.org/x/sys v0.20.0 // indirect
+)

go.sum

@@ -0,0 +1,20 @@
+github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
+github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
+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=
+github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
+github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
+golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
+golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
+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=

grid.go

@@ -0,0 +1,153 @@
+package main
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"math/rand"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+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
+}
+
+func (grid *Grid) Clone() *Grid {
+	newgrid := &Grid{}
+
+	newgrid.Width = grid.Width
+	newgrid.Height = grid.Height
+	newgrid.Data = grid.Data
+
+	return newgrid
+}
+
+func (grid *Grid) Clear() {
+	for y := range grid.Data {
+		for x := range grid.Data[y] {
+			grid.Data[y][x] = 0
+		}
+	}
+}
+
+func (grid *Grid) FillRandom(game *ScenePlay) {
+	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 GetFilename(generations int64) string {
+	now := time.Now()
+	return fmt.Sprintf("dump-%s-%d.gol", now.Format("20060102150405"), generations)
+}
+
+func GetFilenameRLE(generations int64) string {
+	now := time.Now()
+	return fmt.Sprintf("rect-%s-%d.rle", now.Format("20060102150405"), generations)
+}
+
+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
+}
+
+func LoadState(filename string) (*Grid, error) {
+	fd, err := os.Open(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	scanner := bufio.NewScanner(fd)
+
+	scanner.Split(bufio.ScanLines)
+
+	grid := &Grid{}
+
+	for scanner.Scan() {
+		items := strings.Split(scanner.Text(), "")
+		row := make([]int64, len(items))
+
+		for idx, item := range items {
+			num, err := strconv.ParseInt(item, 10, 64)
+			if err != nil {
+				return nil, err
+			}
+
+			if num > 1 {
+				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 {
+		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
+}

main.go

@@ -0,0 +1,80 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+	"time"
+
+	_ "net/http/pprof"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func main() {
+	config, err := ParseCommandline()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	if config.ShowVersion {
+		fmt.Printf("This is golsky version %s\n", VERSION)
+		os.Exit(0)
+	}
+
+	game := NewGame(config, Play)
+
+	if config.ProfileFile != "" {
+		// enable cpu profiling and use fake game loop
+		fd, err := os.Create(config.ProfileFile)
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer fd.Close()
+
+		pprof.StartCPUProfile(fd)
+		defer pprof.StopCPUProfile()
+
+		Ebitfake(game)
+
+		pprof.StopCPUProfile()
+		fd.Close()
+
+		os.Exit(0)
+	}
+
+	// main loop
+	if err := ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}
+
+// fake game  loop, required to be  able to profile the  program using
+// pprof. Otherwise any kind of program  exit leads to an empty profile
+// file.
+func Ebitfake(game *Game) {
+	screen := ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+
+	var loops int64
+
+	for {
+		err := game.Update()
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		if game.Config.ProfileDraw {
+			game.Draw(screen)
+		}
+
+		fmt.Print(".")
+		time.Sleep(16 * time.Millisecond) // around 60 TPS
+
+		if loops >= game.Config.ProfileMaxLoops {
+			break
+		}
+
+		loops++
+	}
+}

mkrel.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+
+# 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/>.
+
+
+# get list with: go tool dist list
+DIST="linux/amd64
+windows/amd64 "
+
+tool="$1"
+version="$2"
+
+if test -z "$version"; then
+  echo "Usage: $0 <tool name> <release version>"
+  exit 1
+fi
+
+rm -rf releases
+mkdir -p releases
+
+
+for D in $DIST; do
+    os=${D/\/*/}
+    arch=${D/*\//}
+    binfile="releases/${tool}-${os}-${arch}-${version}"
+
+    if test "$os" = "windows"; then
+        binfile="${binfile}.exe"
+    fi
+    
+    tardir="${tool}-${os}-${arch}-${version}"
+    tarfile="releases/${tool}-${os}-${arch}-${version}.tar.gz"
+    set -x
+    GOOS=${os} GOARCH=${arch} go build -o ${binfile}
+    set +x
+    continue
+    
+    mkdir -p ${tardir}
+    cp ${binfile} README.md LICENSE ${tardir}/
+    echo 'tool = gfn
+PREFIX = /usr/local
+UID    = root
+GID    = 0
+
+install:
+	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/' > ${tardir}/Makefile
+    tar cpzf ${tarfile} ${tardir}
+    sha256sum ${binfile} | cut -d' ' -f1 > ${binfile}.sha256
+    sha256sum ${tarfile} | cut -d' ' -f1 > ${tarfile}.sha256
+    rm -rf ${tardir}
+    set +x
+done
+

rle/pattern_parser.go

@@ -0,0 +1,159 @@
+package rle
+
+import (
+	"strconv"
+)
+
+type TokenType string
+
+type Token struct {
+	Type    TokenType
+	Literal string
+}
+
+const (
+	RUN_COUNT  = "RUN_COUNT"
+	DEAD_CELL  = "DEAD_CELL"
+	ALIVE_CELL = "ALIVE_CELL"
+	EOL        = "EOL"
+	EOP        = "EOP"
+)
+
+type Lexer struct {
+	input        string
+	position     int
+	readPosition int
+	char         byte
+}
+
+func NewLexer(input string) *Lexer {
+	l := &Lexer{input: input}
+	l.readChar()
+	return l
+}
+
+func (l *Lexer) NextToken() Token {
+	var tok Token
+
+	l.skipWhitespace()
+
+	switch l.char {
+	case '$':
+		tok = newToken(EOL, l.char)
+	case '!':
+		tok = newToken(EOP, l.char)
+	case 'b':
+		tok = newToken(DEAD_CELL, l.char)
+	case 'o':
+		tok = newToken(ALIVE_CELL, l.char)
+	default:
+		if isDigit(l.char) {
+			tok.Type = RUN_COUNT
+			tok.Literal = l.readNumber()
+			return tok
+		}
+	}
+
+	l.readChar()
+	return tok
+}
+
+func newToken(tokenType TokenType, char byte) Token {
+	return Token{Type: tokenType, Literal: string(char)}
+}
+
+type PatternParser struct {
+	lexer        *Lexer
+	currentToken Token
+	peekToken    Token
+}
+
+func NewParser(lexer *Lexer) *PatternParser {
+	p := &PatternParser{
+		lexer: lexer,
+	}
+	p.nextToken()
+	p.nextToken()
+
+	return p
+}
+
+func (pp *PatternParser) ParsePattern(width, height int) [][]int {
+	result := make([][]int, height)
+
+	row := make([]int, width)
+	var rowIndex int
+	var colIndex int
+	for {
+		switch pp.currentToken.Type {
+		case RUN_COUNT:
+			count, _ := strconv.Atoi(pp.currentToken.Literal)
+			for i := 0; i < count; i++ {
+				switch pp.peekToken.Type {
+				case ALIVE_CELL:
+					row[rowIndex+i] = 1
+				case DEAD_CELL:
+					row[rowIndex+i] = 0
+				case EOL:
+					result[colIndex] = row
+					row = make([]int, width)
+					rowIndex = -1
+					colIndex++
+				}
+			}
+
+			if pp.peekToken.Type != EOL {
+				rowIndex += count - 1
+			}
+			pp.nextToken()
+		case ALIVE_CELL:
+			row[rowIndex] = 1
+		case DEAD_CELL:
+			row[rowIndex] = 0
+		case EOL:
+			result[colIndex] = row
+			row = make([]int, width)
+			rowIndex = -1
+			colIndex++
+		case EOP:
+			result[colIndex] = row
+			return result
+		}
+		rowIndex++
+		pp.nextToken()
+	}
+}
+
+func (pp *PatternParser) nextToken() {
+	pp.currentToken = pp.peekToken
+	pp.peekToken = pp.lexer.NextToken()
+}
+
+func isDigit(char byte) bool {
+	return '0' <= char && char <= '9'
+}
+
+func (l *Lexer) readChar() {
+	if l.readPosition >= len(l.input) {
+		l.char = 0
+	} else {
+		l.char = l.input[l.readPosition]
+	}
+	l.position = l.readPosition
+	l.readPosition++
+}
+
+func (l *Lexer) readNumber() string {
+	position := l.position
+	for isDigit(l.char) {
+		l.readChar()
+	}
+
+	return l.input[position:l.position]
+}
+
+func (l *Lexer) skipWhitespace() {
+	for l.char == ' ' || l.char == '\t' || l.char == '\n' || l.char == '\r' {
+		l.readChar()
+	}
+}

rle/pattern_parser_test.go

@@ -0,0 +1,163 @@
+package rle
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestNextToken(t *testing.T) {
+	input := "bo$2bo$3o!"
+
+	tests := []struct {
+		expectedType    TokenType
+		expectedLiteral string
+	}{
+		{DEAD_CELL, "b"},
+		{ALIVE_CELL, "o"},
+		{EOL, "$"},
+		{RUN_COUNT, "2"},
+		{DEAD_CELL, "b"},
+		{ALIVE_CELL, "o"},
+		{EOL, "$"},
+		{RUN_COUNT, "3"},
+		{ALIVE_CELL, "o"},
+		{EOP, "!"},
+	}
+
+	l := NewLexer(input)
+
+	for _, test := range tests {
+		token := l.NextToken()
+
+		if token.Type != test.expectedType {
+			t.Errorf("Token typ not correct")
+		}
+
+		if token.Literal != test.expectedLiteral {
+			t.Errorf("Literal not correct")
+		}
+	}
+}
+
+func TestParsePattern(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected [][]int
+		width    int
+		height   int
+	}{
+		{
+			input: "bo$2bo$3o!",
+			expected: [][]int{
+				{0, 1, 0},
+				{0, 0, 1},
+				{1, 1, 1},
+			},
+			width:  3,
+			height: 3,
+		},
+		{
+			input: `24bo$22bobo$12b2o6b2o12b2o$11bo3bo4b2o12b2o$2o8bo5bo3b2o$2o8bo3bob2o4b
+							obo$10bo5bo7bo$11bo3bo$12b2o!`,
+			expected: [][]int{
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+				{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+			},
+			width:  36,
+			height: 9,
+		},
+		{
+			input: `20b2o$
+							20b2o4$
+							9b2o$
+							8bo2bo10b2o$
+							9b2o11bo$
+							22bo12bo$
+							23bo10bobo$
+							34bobo$
+							35bo7$
+							32bo2bo$
+							33b3o$
+							2o38b2o$
+							2o38b2o$
+							6b3o$
+							6bo2bo7$
+							6bo$
+							5bobo$
+							5bobo10bo$
+							6bo12bo$
+							19bo11b2o$
+							18b2o10bo2bo$
+							31b2o4$
+							20b2o$
+							20b2o!`,
+			expected: [][]int{
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0},
+				{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+				{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+				{0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+			},
+			width:  42,
+			height: 42,
+		},
+	}
+
+	for _, test := range tests {
+		l := NewLexer(test.input)
+		pp := NewParser(l)
+		result := pp.ParsePattern(test.width, test.height)
+
+		if !reflect.DeepEqual(result, test.expected) {
+			t.Fatalf(
+				"Patterns do not match.\nExpected: %v\nGot: %v",
+				test.expected,
+				result,
+			)
+		}
+	}
+}

rle/rle.go

@@ -0,0 +1,195 @@
+// original source: https://github.com/nhoffmann/life by N.Hoffmann 2020.
+package rle
+
+import (
+	"fmt"
+	"os"
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+type RLE struct {
+	Rule    string  // rule
+	Width   int     // x
+	Height  int     // y
+	Pattern [][]int // The actual pattern
+
+	inputLines       []string
+	headerLineIndex  int
+	patternLineIndex int
+}
+
+// wrapper to load a RLE file
+func GetRLE(filename string) (*RLE, error) {
+	if filename == "" {
+		return nil, nil
+	}
+
+	content, err := os.ReadFile(filename)
+	if err != nil {
+		return nil, err
+	}
+
+	parsedRle, err := Parse(string(content))
+	if err != nil {
+		return nil, fmt.Errorf("failed to load RLE pattern file: %s", err)
+	}
+
+	return &parsedRle, nil
+}
+
+func Parse(input string) (RLE, error) {
+	rle := RLE{
+		inputLines: strings.Split(input, "\n"),
+	}
+
+	rle.partitionFile()
+
+	err := rle.parseComments()
+	if err != nil {
+		return RLE{}, err
+	}
+	err = rle.parseHeader()
+	if err != nil {
+		return RLE{}, err
+	}
+	err = rle.parsePattern()
+	if err != nil {
+		return RLE{}, err
+	}
+
+	return rle, nil
+}
+
+func (rle *RLE) partitionFile() error {
+	for index, line := range rle.inputLines {
+		cleanLine := removeWhitespace(line)
+		if strings.HasPrefix(cleanLine, "x=") {
+			rle.headerLineIndex = index
+			rle.patternLineIndex = index + 1
+			return nil
+		}
+	}
+
+	return fmt.Errorf("invalid input: Header is missing")
+}
+
+func (rle *RLE) parseComments() error {
+	return nil
+}
+
+func (rle *RLE) parseHeader() (err error) {
+	headerLine := removeWhitespace(rle.inputLines[rle.headerLineIndex])
+
+	headerElements := strings.SplitN(headerLine, ",", 3)
+
+	rle.Width, err = strconv.Atoi(strings.TrimPrefix(headerElements[0], "x="))
+	if err != nil {
+		return err
+	}
+	rle.Height, err = strconv.Atoi(strings.TrimPrefix(headerElements[1], "y="))
+	if err != nil {
+		return err
+	}
+
+	rle.Pattern = make([][]int, rle.Width)
+
+	// check wehter a rule is present, since it's optional
+	if len(headerElements) == 3 {
+		rle.Rule = strings.TrimPrefix(headerElements[2], "rule=")
+	}
+
+	return nil
+}
+
+func (rle *RLE) parsePattern() error {
+	patternString := strings.Join(rle.inputLines[rle.patternLineIndex:], "")
+
+	l := NewLexer(patternString)
+	pp := NewParser(l)
+
+	rle.Pattern = pp.ParsePattern(rle.Width, rle.Height)
+
+	return nil
+}
+
+func removeWhitespace(input string) string {
+	re := regexp.MustCompile(` *\t*\r*\n*`)
+	return re.ReplaceAllString(input, "")
+}
+
+// Store a grid to an RLE file
+func StoreGridToRLE(grid [][]int64, filename, rule string, width, height int) error {
+	fd, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+
+	var pattern string
+
+	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"
+			}
+		}
+
+		// if first row is: 001011110, then line is now:
+		//                  bboboooob
+
+		encoded := RunLengthEncode(line)
+
+		// and now its:     2bob4ob
+		pattern += encoded
+
+		if y != height-1 {
+			pattern += "$"
+		}
+	}
+
+	pattern += "!"
+
+	wrapped := ""
+	for idx, char := range pattern {
+		if idx%70 == 0 && idx != 0 {
+			wrapped += "\n"
+		}
+		wrapped += string(char)
+	}
+
+	_, err = fmt.Fprintf(fd, "#N %s\nx = %d, y = %d, rule = %s\n%s\n",
+		filename, width, height, rule, wrapped)
+
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// by peterSO on
+// https://codereview.stackexchange.com/questions/238893/run-length-encoding-in-golang
+func RunLengthEncode(s string) string {
+	e := make([]byte, 0, len(s))
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		j := i + 1
+		for ; j <= len(s); j++ {
+			if j < len(s) && s[j] == c {
+				continue
+			}
+			if j-i > 1 {
+				e = strconv.AppendInt(e, int64(j-i), 10)
+			}
+			e = append(e, c)
+			break
+		}
+		i = j - 1
+	}
+	return string(e)
+}

rle/rle_test.go

@@ -0,0 +1,84 @@
+package rle
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestRLE(t *testing.T) {
+	t.Run("Parse", func(t *testing.T) {
+		tests := []struct {
+			input           string
+			expectedPattern [][]int
+			expectedComment string
+			expectedWidth   int
+			expectedHeight  int
+			expectedRule    string
+		}{
+			{
+				input: `#C This is a glider.
+				x = 3, y = 3
+				bo$2bo$3o!`,
+				expectedPattern: [][]int{
+					{0, 1, 0},
+					{0, 0, 1},
+					{1, 1, 1},
+				},
+				expectedWidth:  3,
+				expectedHeight: 3,
+				expectedRule:   "",
+			},
+			{
+				input: `#N Gosper glider gun
+				#C This was the first gun discovered.
+				#C As its name suggests, it was discovered by Bill Gosper.
+				x = 36, y = 9, rule = B3/S23
+				24bo$22bobo$12b2o6b2o12b2o$11bo3bo4b2o12b2o$2o8bo5bo3b2o$2o8bo3bob2o4b
+				obo$10bo5bo7bo$11bo3bo$12b2o!`,
+				expectedPattern: [][]int{
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+					{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+					{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+				},
+				expectedWidth:  36,
+				expectedHeight: 9,
+				expectedRule:   "B3/S23",
+			},
+		}
+
+		for _, test := range tests {
+			rle, err := Parse(test.input)
+
+			if err != nil {
+				t.Error(err)
+			}
+
+			if rle.Width != test.expectedWidth {
+				t.Errorf("Width dos not match")
+			}
+
+			if rle.Height != test.expectedHeight {
+				t.Errorf("Height does not match")
+			}
+
+			if rle.Rule != test.expectedRule {
+				t.Errorf("Rule does not match")
+			}
+
+			if !reflect.DeepEqual(rle.Pattern, test.expectedPattern) {
+				t.Errorf(
+					"Patterns do not match.\nExpected: %v\nGot: %v",
+					test.expectedPattern,
+					rle.Pattern,
+				)
+			}
+		}
+	})
+
+}

rule.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"log"
+	"strconv"
+	"strings"
+)
+
+// a GOL rule
+type Rule struct {
+	Definition string
+	Birth      []int64
+	Death      []int64
+}
+
+// parse one part of a GOL rule into rule slice
+func NumbersToList(numbers string) []int64 {
+	list := []int64{}
+
+	items := strings.Split(numbers, "")
+	for _, item := range items {
+		num, err := strconv.ParseInt(item, 10, 64)
+		if err != nil {
+			log.Fatalf("failed to parse game rule part <%s>: %s", numbers, err)
+		}
+
+		list = append(list, num)
+	}
+
+	return list
+}
+
+// parse GOL rule, used in CheckRule()
+func ParseGameRule(rule string) *Rule {
+	parts := strings.Split(rule, "/")
+
+	if len(parts) < 2 {
+		log.Fatalf("Invalid game rule <%s>", rule)
+	}
+
+	golrule := &Rule{Definition: rule}
+
+	for _, part := range parts {
+		if part[0] == 'B' {
+			golrule.Birth = NumbersToList(part[1:])
+		} else {
+			golrule.Death = NumbersToList(part[1:])
+		}
+	}
+
+	return golrule
+}

sample-rles/64P2H1V0.rle

@@ -0,0 +1,3 @@
+x = 8, y = 31, rule = B3/S23
+o$4o$2b2o$5bo$2b4o$6bo$2bo2b3o$4b3o$5bo$ob3o$2o2bo$b3o$bo$3bo$bobo$4bo$bobo$
+3bo$bo$b3o$2o2bo$ob3o$5bo$4b3o$2bo2b3o$6bo$2b4o$5bo$2b2o$4o$o!

sample-rles/glider.rle

@@ -0,0 +1,2 @@
+x = 3, y = 3, rule = B3/S23
+3o$2bo$bo!

sample-rles/lightweight9.rle

@@ -0,0 +1,4 @@
+x = 33, y = 10, rule = B3/S23
+5b3o17b3o$4bo3bo3bo7bo3bo3bo$3b2o4bob3o5b3obo4b2o$2bobob2obo3b2o3b2o3bob2obob
+o$b2obo4bobo2b2ob2o2bobo4bob2o$o4bo3bo4bo3bo4bo3bo4bo$14b5o$2o9b2obo3bob2o9b
+2o$11b2obo3bob2o$11b2obobobob2o!

sample-rles/p39piheptominohasslerdimer.rle

@@ -0,0 +1,8 @@
+#N p39piheptominohasslerdimer.rle
+#C https://conwaylife.com/wiki/P39_pi-heptomino_hassler
+#C https://www.conwaylife.com/patterns/p39piheptominohasslerdimer.rle
+x = 51, y = 30, rule = B3/S23
+9b2o$8bobo$8bo$3bob2ob2o$3b2obo$6bo$6b2o27b2o$35b2o4$22b2o3b2o$22bobo
+2b2o$10b3o10bo$2obo6bobo25bobo6b2obo$ob2o6bobo25bobo6bob2o$27bo10b3o$
+22b2o2bobo$22b2o3b2o4$14b2o$14b2o27b2o$44bo$44bob2o$41b2ob2obo$42bo$
+40bobo$40b2o!

sample-rles/weekender.rle

@@ -0,0 +1,13 @@
+#N 244p7h3v0.rle
+#C https://conwaylife.com/wiki/232P7H3V0
+#C https://www.conwaylife.com/patterns/244p7h3v0.rle
+x = 51, y = 52, rule = B3/S23
+19b3o9b3o$18bo3bo7bo3bo$17bobo3bo5bo3bobo$17bo3b2o7b2o3bo$17b3o3bo5bo
+3b3o$16bo3b2ob3ob3ob2o3bo$16b2o2bo3b2ob2o3bo2b2o$15b3o3b5ob5o3b3o$23bo
+5bo$20bo11bo$15bo4bo11bo4bo$15bo4b4o5b4o4bo$19bo4bo3bo4bo$18b2ob3o5b3o
+b2o$18b2obo3bobo3bob2o$14b3o7b2ob2o7b3o$13bo3b2o4bobobobo4b2o3bo$12bo
+3bo19bo3bo$12bo9b3o3b3o9bo$16bo6b2o3b2o6bo$11bo12bo3bo12bo$11bo2b2o5bo
+9bo5b2o2bo$12b2o8bo7bo8b2o$10bo12bo5bo12bo$9b3o29b3o$8b2o2bo27bo2b2o$
+11b2o27b2o$11bo29bo2$8bo35bo$9b2o31b2o$7bo2bo31bo2bo$6bo39bo$5b2o39b2o
+$4b4o37b4o$3bo45bo$3b3o41b3o$2bo47bo$4b2o41b2o$6bo39bo$4b2o41b2o$5bo
+41bo$4bo43bo$4bo43bo$2b2o$2obo$o$2o$bo3bo$4bo$o2bo$o!

scene-play.go

@@ -0,0 +1,657 @@
+package main
+
+import (
+	"fmt"
+	"image"
+	"image/color"
+	"log"
+	"math/rand"
+	"os"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+	"github.com/tlinden/golsky/rle"
+	"golang.org/x/image/math/f64"
+)
+
+type Images struct {
+	Black, White, Age1, Age2, Age3, Age4, Old *ebiten.Image
+}
+
+type ScenePlay struct {
+	Game   *Game
+	Config *Config
+	Next   SceneName
+	Whoami SceneName
+
+	Grids                                      []*Grid // 2 grids: one current, one next
+	History                                    *Grid   // holds state of past dead cells for evolution tracks
+	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                                      *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
+	Markmode                                   bool          // enabled with 'c'
+	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
+	Paused, RunOneStep                         bool          // mutable flags from config
+	TPG                                        int
+}
+
+func NewPlayScene(game *Game, config *Config) Scene {
+	scene := &ScenePlay{
+		Whoami:     Play,
+		Game:       game,
+		Next:       Play,
+		Config:     config,
+		Paused:     config.Paused,
+		TPG:        config.TPG,
+		RunOneStep: config.RunOneStep,
+	}
+
+	scene.Init()
+
+	return scene
+}
+
+func (scene *ScenePlay) GetNext() SceneName {
+	return scene.Next
+}
+
+func (scene *ScenePlay) ResetNext() {
+	scene.Next = scene.Whoami
+}
+
+func (scene *ScenePlay) SetNext(next SceneName) {
+	scene.Next = next
+}
+
+func (scene *ScenePlay) Clearscreen() bool {
+	return true
+}
+
+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. The first  number, or list of  numbers, is
+	// what is required for a dead cell to be born.
+
+	if state == 0 && Contains(scene.Config.Rule.Birth, neighbors) {
+		nextstate = Alive
+	} else if state == 1 && Contains(scene.Config.Rule.Death, neighbors) {
+		nextstate = Alive
+	} else {
+		nextstate = Dead
+	}
+
+	return nextstate
+}
+
+// Update all cells according to the current rule
+func (scene *ScenePlay) UpdateCells() {
+	// count ticks so we know when to actually run
+	scene.TicksElapsed++
+
+	if scene.TPG > scene.TicksElapsed {
+		// need to sleep a little more
+		return
+	}
+
+	// next grid index, we just xor 0|1 to 1|0
+	next := scene.Index ^ 1
+
+	// 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
+
+			// actually apply the current rules
+			nextstate := scene.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			scene.Grids[next].Data[y][x] = nextstate
+
+			// 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 tracking is enabled
+			if state != nextstate {
+				scene.History.Data[y][x] = scene.Generations
+			}
+		}
+	}
+
+	// switch grid for rendering
+	scene.Index ^= 1
+
+	// global stats counter
+	scene.Generations++
+
+	if scene.Config.RunOneStep {
+		// setp-wise mode, halt the game
+		scene.Config.RunOneStep = false
+	}
+
+	// reset speed counter
+	scene.TicksElapsed = 0
+}
+
+func (scene *ScenePlay) Reset() {
+	scene.Paused = true
+	scene.InitGrid(nil)
+	scene.Paused = false
+}
+
+// check user input
+func (scene *ScenePlay) CheckInput() {
+	if inpututil.IsKeyJustPressed(ebiten.KeyQ) {
+		os.Exit(0)
+	}
+
+	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
+		fmt.Println("mark mode on")
+		scene.Markmode = true
+		scene.Paused = true
+	}
+
+	if scene.Markmode {
+		return
+	}
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) {
+		scene.Paused = !scene.Paused
+	}
+
+	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
+		scene.ToggleCellOnCursorPos(Alive)
+		scene.Paused = true // drawing while running makes no sense
+	}
+
+	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) {
+		scene.ToggleCellOnCursorPos(Dead)
+		scene.Paused = true // drawing while running makes no sense
+	}
+
+	if ebiten.IsKeyPressed(ebiten.KeyPageDown) {
+		if scene.Config.TPG < 120 {
+			scene.Config.TPG++
+		}
+	}
+
+	if ebiten.IsKeyPressed(ebiten.KeyPageUp) {
+		if scene.TPG > 1 {
+			scene.TPG--
+		}
+	}
+
+	if inpututil.IsKeyJustPressed(ebiten.KeyS) {
+		scene.SaveState()
+	}
+
+	if inpututil.IsKeyJustPressed(ebiten.KeyR) {
+		scene.Reset()
+	}
+
+	if scene.Paused {
+		if inpututil.IsKeyJustPressed(ebiten.KeyN) {
+			scene.Config.RunOneStep = true
+		}
+	}
+}
+
+// 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() {
+	if scene.Markmode {
+		return
+	}
+
+	// move canvas
+	if scene.Dragging && !ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
+		// release
+		scene.Dragging = false
+	}
+
+	if !scene.Dragging && ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
+		// start dragging
+		scene.Dragging = true
+		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
+	}
+
+	if scene.Dragging {
+		x, y := ebiten.CursorPosition()
+
+		if x != scene.LastCursorPos[0] || y != scene.LastCursorPos[1] {
+			// actually drag by mouse cursor pos diff to last cursor pos
+			scene.Camera.Position[0] -= float64(x - scene.LastCursorPos[0])
+			scene.Camera.Position[1] -= float64(y - scene.LastCursorPos[1])
+		}
+
+		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
+	}
+
+	// also support the arrow keys to move the canvas
+	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) {
+		scene.Camera.Position[0] -= 1
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) {
+		scene.Camera.Position[0] += 1
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) {
+		scene.Camera.Position[1] -= 1
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowDown) {
+		scene.Camera.Position[1] += 1
+	}
+
+	// Zoom
+	_, dy := ebiten.Wheel()
+	step := 1
+
+	if scene.WheelTurned {
+		// if keep scrolling the wheel, zoom faster
+		step = 50
+	} else {
+		scene.WheelTurned = false
+	}
+
+	if dy < 0 {
+		if scene.Camera.ZoomFactor > -2400 {
+			scene.Camera.ZoomFactor -= step
+		}
+	}
+
+	if dy > 0 {
+		if scene.Camera.ZoomFactor < 2400 {
+			scene.Camera.ZoomFactor += step
+		}
+	}
+
+	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
+		scene.Camera.Reset()
+	}
+
+}
+
+func (scene *ScenePlay) GetWorldCursorPos() image.Point {
+	worldX, worldY := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
+	return image.Point{
+		X: int(worldX) / scene.Config.Cellsize,
+		Y: int(worldY) / scene.Config.Cellsize,
+	}
+}
+
+func (scene *ScenePlay) CheckMarkInput() {
+	if !scene.Markmode {
+		return
+	}
+
+	if ebiten.IsMouseButtonPressed(ebiten.MouseButton0) {
+		if !scene.MarkTaken {
+			scene.Mark = scene.GetWorldCursorPos()
+			scene.MarkTaken = true
+			scene.MarkDone = false
+		}
+
+		scene.Point = scene.GetWorldCursorPos()
+		//fmt.Printf("Mark: %v, Point: %v\n", scene.Mark, scene.Point)
+	} else if inpututil.IsMouseButtonJustReleased(ebiten.MouseButton0) {
+		scene.Markmode = false
+		scene.MarkTaken = false
+		scene.MarkDone = true
+
+		scene.SaveRectRLE()
+	}
+}
+
+func (scene *ScenePlay) SaveState() {
+	filename := GetFilename(scene.Generations)
+	err := scene.Grids[scene.Index].SaveState(filename)
+	if err != nil {
+		log.Printf("failed to save game state to %s: %s", filename, err)
+	}
+	log.Printf("saved game state to %s at generation %d\n", filename, scene.Generations)
+}
+
+func (scene *ScenePlay) SaveRectRLE() {
+	filename := GetFilenameRLE(scene.Generations)
+
+	if scene.Mark.X == scene.Point.X || scene.Mark.Y == scene.Point.Y {
+		log.Printf("can't save non-rectangle\n")
+		return
+	}
+
+	var width int
+	var height int
+	var startx int
+	var starty int
+
+	if scene.Mark.X < scene.Point.X {
+		// mark left point
+		startx = scene.Mark.X
+		width = scene.Point.X - scene.Mark.X
+	} else {
+		// mark right point
+		startx = scene.Point.X
+		width = scene.Mark.X - scene.Point.X
+	}
+
+	if scene.Mark.Y < scene.Point.Y {
+		// mark above point
+		starty = scene.Mark.Y
+		height = scene.Point.Y - scene.Mark.Y
+	} else {
+		// mark below point
+		starty = scene.Point.Y
+		height = scene.Mark.Y - scene.Point.Y
+	}
+
+	grid := make([][]int64, height)
+
+	for y := 0; y < height; y++ {
+		grid[y] = make([]int64, width)
+
+		for x := 0; x < width; x++ {
+			grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx]
+		}
+	}
+
+	err := rle.StoreGridToRLE(grid, filename, scene.Config.Rule.Definition, width, height)
+	if err != nil {
+		log.Printf("failed to save rect to %s: %s\n", filename, err)
+	} else {
+		log.Printf("saved selected rect to %s at generation %d\n", filename, scene.Generations)
+	}
+
+}
+
+func (scene *ScenePlay) Update() error {
+	scene.CheckInput()
+	scene.CheckDraggingInput()
+	scene.CheckMarkInput()
+
+	if !scene.Paused || scene.RunOneStep {
+		scene.UpdateCells()
+	}
+
+	return nil
+}
+
+// set a cell to alive or dead
+func (scene *ScenePlay) ToggleCellOnCursorPos(alive int64) {
+	// 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
+
+	//fmt.Printf("cell at %d,%d\n", x, y)
+
+	if x > -1 && y > -1 {
+		scene.Grids[scene.Index].Data[y][x] = alive
+		scene.History.Data[y][x] = 1
+	}
+}
+
+// draw the new grid state
+func (scene *ScenePlay) Draw(screen *ebiten.Image) {
+	// we  fill the whole  screen with  a background color,  the cells
+	// themselfes will be 1px smaller as their nominal size, producing
+	// a nice grey grid with grid lines
+	op := &ebiten.DrawImageOptions{}
+
+	if scene.Config.NoGrid {
+		scene.World.Fill(scene.White)
+	} else {
+		scene.World.Fill(scene.Grey)
+	}
+
+	for y := 0; y < scene.Config.Height; y++ {
+		for x := 0; x < scene.Config.Width; x++ {
+			op.GeoM.Reset()
+			op.GeoM.Translate(float64(x*scene.Config.Cellsize), float64(y*scene.Config.Cellsize))
+
+			age := scene.Generations - scene.History.Data[y][x]
+
+			switch scene.Grids[scene.Index].Data[y][x] {
+			case 1:
+				if age > 50 && scene.Config.ShowEvolution {
+					scene.World.DrawImage(scene.Tiles.Old, op)
+				} else {
+					scene.World.DrawImage(scene.Tiles.Black, op)
+				}
+			case 0:
+				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)
+					}
+				} else {
+					scene.World.DrawImage(scene.Tiles.White, op)
+				}
+			}
+		}
+	}
+
+	if scene.Markmode && scene.MarkTaken {
+		x := float32(scene.Mark.X * scene.Config.Cellsize)
+		y := float32(scene.Mark.Y * scene.Config.Cellsize)
+		w := float32((scene.Point.X - scene.Mark.X) * scene.Config.Cellsize)
+		h := float32((scene.Point.Y - scene.Mark.Y) * scene.Config.Cellsize)
+
+		// fmt.Printf("%d,%d=>%0.0f,%0.0f to %d,%d=>%0.0f,%0.0f\n",
+		// 	scene.Mark.X, scene.Mark.Y, x, y, scene.Point.X, scene.Point.Y, w, h)
+
+		vector.StrokeRect(
+			scene.World,
+			x+1, y+1,
+			w, h,
+			1.0, scene.Old, false,
+		)
+	}
+
+	scene.Camera.Render(scene.World, screen)
+
+	if scene.Config.Debug {
+		paused := ""
+		if scene.Paused {
+			paused = "-- paused --"
+		}
+
+		ebitenutil.DebugPrint(
+			screen,
+			fmt.Sprintf("FPS: %0.2f, TPG: %d, Mem: %0.2f MB, Generations: %d   %s",
+				ebiten.ActualTPS(), scene.TPG, GetMem(), scene.Generations, paused),
+		)
+	}
+}
+
+// FIXME: move these into Grid
+// load a pre-computed pattern from RLE file
+func (scene *ScenePlay) InitPattern() {
+	if scene.Config.RLE != nil {
+		startX := (scene.Config.Width / 2) - (scene.Config.RLE.Width / 2)
+		startY := (scene.Config.Height / 2) - (scene.Config.RLE.Height / 2)
+		var y, x int
+
+		for rowIndex, patternRow := range scene.Config.RLE.Pattern {
+			for colIndex := range patternRow {
+				if scene.Config.RLE.Pattern[rowIndex][colIndex] > 0 {
+					x = colIndex + startX
+					y = rowIndex + startY
+
+					scene.History.Data[y][x] = 1
+					scene.Grids[0].Data[y][x] = 1
+				}
+			}
+		}
+	}
+}
+
+func (scene *ScenePlay) InitGrid(grid *Grid) {
+	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)
+
+	for y := 0; y < scene.Config.Height; y++ {
+		if !scene.Config.Empty {
+			for x := 0; x < scene.Config.Width; x++ {
+				if rand.Intn(scene.Config.Density) == 1 {
+					history.Data[y][x] = 1
+					grida.Data[y][x] = 1
+				}
+			}
+		}
+	}
+
+	scene.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	scene.History = history
+}
+
+// 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() {
+	// 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),
+		},
+	}
+
+	scene.World = ebiten.NewImage(scene.Config.ScreenWidth, scene.Config.ScreenHeight)
+
+	scene.InitGrid(grid)
+	scene.InitPattern()
+	scene.InitTiles()
+
+	scene.Index = 0
+	scene.TicksElapsed = 0
+
+	scene.LastCursorPos = make([]int, 2)
+}
+
+// count the living neighbors of a cell
+func (scene *ScenePlay) CountNeighbors(x, y int) int64 {
+	var sum int64
+
+	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]
+		}
+	}
+
+	// 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-1),
+		float32(cellsize-1),
+		col, false,
+	)
+}

scene.go

@@ -0,0 +1,25 @@
+package main
+
+import "github.com/hajimehoshi/ebiten/v2"
+
+// Wrapper for  different screens  to be  shown, as  Welcome, Options,
+// About, Menu Level and of course the actual game
+// Scenes are responsible for screen clearing! That way a scene is able
+// to render its content onto the running level, e.g. the options scene
+// etc.
+
+type SceneName int
+
+type Scene interface {
+	SetNext(SceneName)
+	GetNext() SceneName
+	ResetNext()
+	Clearscreen() bool
+	Update() error
+	Draw(screen *ebiten.Image)
+}
+
+const (
+	Menu = iota // main top level menu
+	Play        // actual playing happens here
+)

system.go

@@ -0,0 +1,11 @@
+package main
+
+import "runtime"
+
+// returns current memory usage in MB
+func GetMem() float64 {
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	return float64(m.Alloc) / 1024 / 1024
+}