temporary variant using a shader instead of direct draw

.gitignore

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

Makefile

@@ -1,4 +1,96 @@
-.PHONY: all
+# Copyright © 2024 Thomas von Dein
-all:
+
-	make -C src
+# This program is free software: you can redistribute it and/or modify
-	mv src/golsky .
+# 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

@@ -18,7 +18,7 @@ Based on: https://youtu.be/FWSR_7kZuYg?si=ix1dmo76D8AmF25F
 
 * 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
@@ -61,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)
@@ -77,12 +77,10 @@ While it runs, there are a couple of commands you can use:
 * page down: slow down
 * Mouse wheel: zoom in or out
 * move mouse while middle mouse button pressed: move canvas
-* r: reset to 1:1 zoom
+* escape: reset to 1:1 zoom
-* escape: open menu
 * 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

@@ -1,46 +1 @@
-- add all other options like size etc
+- Implement RLE writing on scene.MarkDone
-- 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
-
-- Speed
-  https://conwaylife.com/forums/viewtopic.php?f=7&t=3237
-  
-- Patterns:
-
-A   Catagolue   textcensus   of,  say,   period-2   oscillators   from
-non-symmetrical soups can be found at
-
-https://catagolue.hatsya.com/textcensus/b3s23/C1/xp2
-
-The URL is made by just adding the prefix "text" to the word "census",
-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.

camera.go

@@ -1,5 +1,3 @@
-// this comes from the camera example but I enhanced it a little bit
-
 package main
 
 import (
@@ -14,9 +12,6 @@ type Camera struct {
 	ViewPort   f64.Vec2
 	Position   f64.Vec2
 	ZoomFactor int
-	InitialZoomFactor int
-	InitialPosition   f64.Vec2
-	ZoomOutFactor     int
 }
 
 func (c *Camera) String() string {
@@ -37,17 +32,15 @@ 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(-viewportCenter[0], -viewportCenter[1])
+	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(viewportCenter[0], viewportCenter[1])
+	m.Translate(c.viewportCenter()[0], c.viewportCenter()[1])
 	return m
 }
 
@@ -68,14 +61,8 @@ func (c *Camera) ScreenToWorld(posX, posY int) (float64, float64) {
 	}
 }
 
-func (c *Camera) Setup() {
-	c.Position[0] = c.InitialPosition[0]
-	c.Position[1] = c.InitialPosition[1]
-	c.ZoomFactor = c.InitialZoomFactor
-}
-
 func (c *Camera) Reset() {
-	c.Position[0] = c.InitialPosition[0]
+	c.Position[0] = 0
-	c.Position[1] = c.InitialPosition[1]
+	c.Position[1] = 0
-	c.ZoomFactor = c.ZoomOutFactor
+	c.ZoomFactor = 0
 }

config.go

@@ -0,0 +1,205 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"runtime/pprof"
+	"strconv"
+	"strings"
+
+	"github.com/alecthomas/repr"
+	"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)
+
+	if config.ScreenWidth == 0 || config.ScreenHeight == 0 {
+		return errors.New("the number of requested cells don't fit into the requested window size")
+	}
+
+	config.Cellsize = config.ScreenWidth / config.Width
+
+	repr.Println(config)
+	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,69 @@
+package main
+
+import "github.com/hajimehoshi/ebiten/v2"
+
+type Game struct {
+	ScreenWidth, ScreenHeight, Cellsize int
+	Scenes                              map[SceneName]Scene
+	CurrentScene                        SceneName
+	Config                              *Config
+	Shader                              *ebiten.Shader
+}
+
+func NewGame(config *Config, shader *ebiten.Shader, startscene SceneName) *Game {
+	game := &Game{
+		Config:       config,
+		Scenes:       map[SceneName]Scene{},
+		ScreenWidth:  config.ScreenWidth,
+		ScreenHeight: config.ScreenHeight,
+		Shader:       shader,
+	}
+
+	// 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)
+}

go.mod

@@ -13,12 +13,7 @@ require (
 	github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 // indirect
 	github.com/ebitengine/hideconsole v1.0.0 // indirect
 	github.com/ebitengine/purego v0.7.0 // indirect
-	github.com/ebitenui/ebitenui v0.5.6 // indirect
-	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
-	github.com/tinne26/etxt v0.0.8 // indirect
-	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 // indirect
 	golang.org/x/sync v0.7.0 // indirect
 	golang.org/x/sys v0.20.0 // indirect
-	golang.org/x/text v0.15.0 // indirect
 )

go.sum

@@ -6,27 +6,15 @@ github.com/ebitengine/hideconsole v1.0.0 h1:5J4U0kXF+pv/DhiXt5/lTz0eO5ogJ1iXb8Yj
 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/ebitenui/ebitenui v0.5.6 h1:qyJRU5j+lQo1lamxB48IBwMxMfz1xNb5iWUayCtA0Wk=
-github.com/ebitenui/ebitenui v0.5.6/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
-github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
-github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/hajimehoshi/ebiten/v2 v2.7.4 h1:X+heODRQ3Ie9F9QFjm24gEZqQd5FSfR9XuT2XfHwgf8=
 github.com/hajimehoshi/ebiten/v2 v2.7.4/go.mod h1:H2pHVgq29rfm5yeQ7jzWOM3VHsjo7/AyucODNLOhsVY=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-github.com/tinne26/etxt v0.0.8 h1:rjb58jkMkapRGLmhBMWnT76E/nMTXC5P1Q956BRZkoc=
-github.com/tinne26/etxt v0.0.8/go.mod h1:QM/hlNkstsKC39elTFNKAR34xsMb9QoVosf+g9wlYxM=
-github.com/tinne26/etxt v0.0.9-alpha.6.0.20240409152929-91bfc562becc h1:+USGSXbkrRAy6bz3Qm4GUczhqeXe7XlRfkRexCSFxkw=
-github.com/tinne26/etxt v0.0.9-alpha.6.0.20240409152929-91bfc562becc/go.mod h1:Icbd4bDjrXag1oYIhB51CrkMYqRb7YMv0AsrOSfNKfU=
-golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 h1:LfspQV/FYTatPTr/3HzIcmiUFH7PGP+OQ6mgDYo3yuQ=
-golang.org/x/exp v0.0.0-20240222234643-814bf88cf225/go.mod h1:CxmFvTBINI24O/j8iY7H1xHzx2i4OsyguNBmN/uPtqc=
 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=
-golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk=
-golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=

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,110 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"runtime/pprof"
+	"time"
+
+	_ "net/http/pprof"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+var Shader string = `
+//kage:unit pixels
+
+package main
+
+var Alife int
+
+func Fragment(_ vec4, pos vec2, _ vec4) vec4 {
+	if Alife == 1 {
+		return vec4(0.0)
+	}
+
+	return vec4(1.0)
+}
+`
+
+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)
+	}
+
+	shader, err := ebiten.NewShader([]byte(Shader))
+	if err != nil {
+		fmt.Println(Shader)
+		log.Fatalf("failed to compile shader: %s\n", err)
+	}
+
+	game := NewGame(config, shader, 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)
+	}
+
+	fd, err := os.Create("cpu.profile")
+	if err != nil {
+		log.Fatal(err)
+	}
+	defer fd.Close()
+
+	pprof.StartCPUProfile(fd)
+	defer pprof.StopCPUProfile()
+	// 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++
+	}
+}

scene-play.go

@@ -5,8 +5,11 @@ import (
 	"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"
@@ -17,21 +20,14 @@ type Images struct {
 	Black, White, Age1, Age2, Age3, Age4, Old *ebiten.Image
 }
 
-const (
-	DEBUG_FORMAT = "FPS: %0.2f, TPG: %d, M: %0.2fMB, Generations: %d\nScale: %.02f, Zoom: %d, Cam: %.02f,%.02f Cursor: %d,%d  %s"
-)
-
 type 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                                    *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
@@ -39,17 +35,16 @@ type ScenePlay struct {
 	TicksElapsed                               int           // tick counter for game speed
 	Tiles                                      Images        // pre-computed tiles for dead and alife cells
 	Camera                                     Camera        // for zoom+move
-	World, Cache                               *ebiten.Image // actual image we render to
+	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
-	RunOneStep                                 bool          // mutable flags from config
+	Paused, RunOneStep                         bool          // mutable flags from config
 	TPG                                        int
-	Pixels                                     []byte
-	PixelColor                                 []byte
 }
 
 func NewPlayScene(game *Game, config *Config) Scene {
@@ -58,6 +53,7 @@ func NewPlayScene(game *Game, config *Config) Scene {
 		Game:       game,
 		Next:       Play,
 		Config:     config,
+		Paused:     config.Paused,
 		TPG:        config.TPG,
 		RunOneStep: config.RunOneStep,
 	}
@@ -67,18 +63,10 @@ func NewPlayScene(game *Game, config *Config) Scene {
 	return scene
 }
 
-func (scene *ScenePlay) IsPrimary() bool {
-	return true
-}
-
 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
 }
@@ -87,6 +75,10 @@ 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
 
@@ -132,16 +124,14 @@ func (scene *ScenePlay) UpdateCells() {
 			// change state of current cell in next grid
 			scene.Grids[next].Data[y][x] = nextstate
 
-			if scene.Config.ShowEvolution {
 			// set history  to current generation so we  can infer the
 			// age of the cell's state  during rendering and use it to
-				// deduce the color to use if evolution tracing is enabled
+			// 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
@@ -158,130 +148,50 @@ func (scene *ScenePlay) UpdateCells() {
 	scene.TicksElapsed = 0
 }
 
-// 2: works but still too slow
-func (scene *ScenePlay) UpdatePixels() {
-	var col byte
-	width := scene.World.Bounds().Dx()
-	idx := 0
-
-	for y := 0; y < scene.Config.Height; y++ {
-		for x := 0; x < scene.Config.Width; x++ {
-			col = scene.PixelColor[scene.Grids[scene.Index].Data[y][x]]
-
-			ypx := y * scene.Config.Cellsize
-			for Y := ypx; Y < ypx+scene.Config.Cellsize; Y++ {
-				xpx := x * scene.Config.Cellsize
-				for X := xpx; X < xpx+scene.Config.Cellsize; X++ {
-					idx = 4 * (X + Y*width)
-
-					scene.Pixels[idx] = col
-					scene.Pixels[idx+1] = col
-					scene.Pixels[idx+2] = col
-					scene.Pixels[idx+3] = 0xff
-
-					idx++
-				}
-			}
-		}
-	}
-
-	scene.Cache.WritePixels(scene.Pixels)
-}
-
-// 1: works, but a little slower than 2
-func (scene *ScenePlay) _UpdatePixels() {
-	var col byte
-
-	gridx := 0
-	gridy := 0
-	idx := 0
-
-	width := scene.World.Bounds().Dx()
-	height := scene.World.Bounds().Dy()
-
-	for y := 0; y < height; y++ {
-		gridy = y / scene.Config.Cellsize // compute once per row
-
-		for x := 0; x < width; x++ {
-			gridx = x / scene.Config.Cellsize
-
-			col = scene.PixelColor[scene.Grids[scene.Index].Data[gridy][gridx]]
-
-			if scene.Config.ShowGrid {
-				if x%scene.Config.Cellsize == 0 || y%scene.Config.Cellsize == 0 {
-					col = scene.PixelColor[2]
-				}
-			}
-
-			idx = 4 * (x + y*width)
-
-			scene.Pixels[idx] = col
-			scene.Pixels[idx+1] = col
-			scene.Pixels[idx+2] = col
-			scene.Pixels[idx+3] = 0xff
-
-			idx++
-		}
-	}
-
-	scene.Cache.WritePixels(scene.Pixels)
-}
-
 func (scene *ScenePlay) Reset() {
-	scene.Config.Paused = true
+	scene.Paused = true
-	scene.InitGrid()
+	scene.InitGrid(nil)
-	scene.Config.Paused = false
+	scene.Paused = false
 }
 
 // check user input
-func (scene *ScenePlay) CheckExit() error {
-	if inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		return ebiten.Termination
-	}
-
-	return nil
-}
-
 func (scene *ScenePlay) CheckInput() {
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
+	if inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		scene.SetNext(Menu)
+		os.Exit(0)
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyO) {
-		scene.SetNext(Options)
 	}
 
 	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
-		scene.Config.Markmode = true
+		fmt.Println("mark mode on")
-		scene.Config.Paused = true
+		scene.Markmode = true
+		scene.Paused = true
 	}
 
-	if scene.Config.Markmode {
+	if scene.Markmode {
 		return
 	}
 
 	if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) {
-		scene.Config.TogglePaused()
+		scene.Paused = !scene.Paused
 	}
 
 	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
 		scene.ToggleCellOnCursorPos(Alive)
-		scene.Config.Paused = true // drawing while running makes no sense
+		scene.Paused = true // drawing while running makes no sense
 	}
 
 	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) {
 		scene.ToggleCellOnCursorPos(Dead)
-		scene.Config.Paused = true // drawing while running makes no sense
+		scene.Paused = true // drawing while running makes no sense
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageDown) {
+	if ebiten.IsKeyPressed(ebiten.KeyPageDown) {
-		if scene.TPG < 120 {
+		if scene.Config.TPG < 120 {
-			scene.TPG++
+			scene.Config.TPG++
 		}
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageUp) {
+	if ebiten.IsKeyPressed(ebiten.KeyPageUp) {
-		if scene.TPG >= 1 {
+		if scene.TPG > 1 {
 			scene.TPG--
 		}
 	}
@@ -290,11 +200,11 @@ func (scene *ScenePlay) CheckInput() {
 		scene.SaveState()
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeyD) {
+	if inpututil.IsKeyJustPressed(ebiten.KeyR) {
-		scene.Config.Debug = !scene.Config.Debug
+		scene.Reset()
 	}
 
-	if scene.Config.Paused {
+	if scene.Paused {
 		if inpututil.IsKeyJustPressed(ebiten.KeyN) {
 			scene.Config.RunOneStep = true
 		}
@@ -304,7 +214,7 @@ func (scene *ScenePlay) CheckInput() {
 // 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.Config.Markmode {
+	if scene.Markmode {
 		return
 	}
 
@@ -348,12 +258,28 @@ func (scene *ScenePlay) CheckDraggingInput() {
 
 	// Zoom
 	_, dy := ebiten.Wheel()
+	step := 1
 
-	if dy != 0 {
+	if scene.WheelTurned {
-		scene.Camera.ZoomFactor += (int(dy) * 5)
+		// if keep scrolling the wheel, zoom faster
+		step = 50
+	} else {
+		scene.WheelTurned = false
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeyR) {
+	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()
 	}
 
@@ -368,14 +294,10 @@ func (scene *ScenePlay) GetWorldCursorPos() image.Point {
 }
 
 func (scene *ScenePlay) CheckMarkInput() {
-	if !scene.Config.Markmode {
+	if !scene.Markmode {
 		return
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
-		scene.Config.Markmode = false
-	}
-
 	if ebiten.IsMouseButtonPressed(ebiten.MouseButton0) {
 		if !scene.MarkTaken {
 			scene.Mark = scene.GetWorldCursorPos()
@@ -386,7 +308,7 @@ func (scene *ScenePlay) CheckMarkInput() {
 		scene.Point = scene.GetWorldCursorPos()
 		//fmt.Printf("Mark: %v, Point: %v\n", scene.Mark, scene.Point)
 	} else if inpututil.IsMouseButtonJustReleased(ebiten.MouseButton0) {
-		scene.Config.Markmode = false
+		scene.Markmode = false
 		scene.MarkTaken = false
 		scene.MarkDone = true
 
@@ -396,7 +318,7 @@ func (scene *ScenePlay) CheckMarkInput() {
 
 func (scene *ScenePlay) SaveState() {
 	filename := GetFilename(scene.Generations)
-	err := scene.Grids[scene.Index].SaveState(filename, scene.Config.Rule.Definition)
+	err := scene.Grids[scene.Index].SaveState(filename)
 	if err != nil {
 		log.Printf("failed to save game state to %s: %s", filename, err)
 	}
@@ -456,30 +378,11 @@ func (scene *ScenePlay) SaveRectRLE() {
 }
 
 func (scene *ScenePlay) Update() error {
-	if scene.Config.Restart {
-		scene.Config.Restart = false
-		scene.Generations = 0
-		scene.InitGrid()
-		scene.InitCache()
-		return nil
-	}
-
-	if scene.Config.RestartCache {
-		scene.Config.RestartCache = false
-		scene.InitTiles()
-		scene.InitCache()
-		return nil
-	}
-
-	if quit := scene.CheckExit(); quit != nil {
-		return quit
-	}
-
 	scene.CheckInput()
 	scene.CheckDraggingInput()
 	scene.CheckMarkInput()
 
-	if !scene.Config.Paused || scene.RunOneStep {
+	if !scene.Paused || scene.RunOneStep {
 		scene.UpdateCells()
 	}
 
@@ -493,7 +396,9 @@ func (scene *ScenePlay) ToggleCellOnCursorPos(alive int64) {
 	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 {
+	//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
 	}
@@ -504,36 +409,46 @@ 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{}
+	//op := &ebiten.DrawImageOptions{}
+	shaderop := &ebiten.DrawRectShaderOptions{}
 
-	scene.UpdatePixels()
+	fmt.Println(ebiten.ActualFPS())
 
-	op.GeoM.Translate(0, 0)
+	if scene.Config.NoGrid {
-	scene.World.DrawImage(scene.Cache, op)
+		scene.World.Fill(scene.White)
-
+	} else {
-	/*
+		scene.World.Fill(scene.Grey)
-		var age int64
+	}
 
 	for y := 0; y < scene.Config.Height; y++ {
 		for x := 0; x < scene.Config.Width; x++ {
-				op.GeoM.Reset()
+			// op.GeoM.Reset()
-				op.GeoM.Translate(
+			// op.GeoM.Translate(float64(x*scene.Config.Cellsize), float64(y*scene.Config.Cellsize))
-					float64(x*scene.Config.Cellsize),
+			// age := scene.Generations - scene.History.Data[y][x]
-					float64(y*scene.Config.Cellsize),
+
+			shaderop.GeoM.Reset()
+			shaderop.Uniforms = map[string]any{
+				"Alife": scene.Grids[scene.Index].Data[y][x],
+			}
+
+			shaderop.GeoM.Translate(float64(x*scene.Config.Cellsize), float64(y*scene.Config.Cellsize))
+
+			scene.World.DrawRectShader(
+				scene.Config.Cellsize,
+				scene.Config.Cellsize,
+				scene.Game.Shader,
+				shaderop,
 			)
 
-				age = scene.Generations - scene.History.Data[y][x]
+			/*
-
 				   			switch scene.Grids[scene.Index].Data[y][x] {
-				case Alive:
+				case 1:
 					if age > 50 && scene.Config.ShowEvolution {
 						scene.World.DrawImage(scene.Tiles.Old, op)
-
 					} else {
 						scene.World.DrawImage(scene.Tiles.Black, op)
 					}
-				case Dead:
+				case 0:
-					// only draw dead cells in case evolution trace is enabled
 					if scene.History.Data[y][x] > 1 && scene.Config.ShowEvolution {
 						switch {
 						case age < 10:
@@ -545,30 +460,24 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 						default:
 							scene.World.DrawImage(scene.Tiles.Age4, op)
 						}
-					}
+					} else {
-				}
+						scene.World.DrawImage(scene.Tiles.White, op)
 					}
 				    }
 			*/
-	scene.DrawMark(scene.World)
 
-	scene.Camera.Render(scene.World, screen)
+		}
-
-	scene.DrawDebug(screen)
-
-	op.GeoM.Reset()
-	op.GeoM.Translate(0, 0)
-
-	scene.Game.Screen.DrawImage(screen, op)
 	}
 
-func (scene *ScenePlay) DrawMark(screen *ebiten.Image) {
+	if scene.Markmode && scene.MarkTaken {
-	if scene.Config.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,
@@ -576,80 +485,72 @@ func (scene *ScenePlay) DrawMark(screen *ebiten.Image) {
 			1.0, scene.Old, false,
 		)
 	}
-}
 
-func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
+	scene.Camera.Render(scene.World, screen)
+
 	if scene.Config.Debug {
 		paused := ""
-		if scene.Config.Paused {
+		if scene.Paused {
 			paused = "-- paused --"
 		}
 
-		if scene.Config.Markmode {
+		ebitenutil.DebugPrint(
-			paused = "-- mark --"
+			screen,
-		}
+			fmt.Sprintf("FPS: %0.2f, TPG: %d, Mem: %0.2f MB, Generations: %d   %s",
-
+				ebiten.ActualTPS(), scene.TPG, GetMem(), scene.Generations, paused),
-		x, y := ebiten.CursorPosition()
+		)
-		debug := fmt.Sprintf(
+	}
-			DEBUG_FORMAT,
-			ebiten.ActualTPS(), scene.TPG, GetMem(), scene.Generations,
-			scene.Game.Scale, scene.Camera.ZoomFactor,
-			scene.Camera.Position[0], scene.Camera.Position[1],
-			x, y,
-			paused)
-
-		FontRenderer.Renderer.SetSizePx(10 + int(scene.Game.Scale*10))
-		FontRenderer.Renderer.SetTarget(screen)
-
-		FontRenderer.Renderer.SetColor(scene.Black)
-		FontRenderer.Renderer.Draw(debug, 31, 31)
-
-		FontRenderer.Renderer.SetColor(scene.Old)
-		FontRenderer.Renderer.Draw(debug, 30, 30)
-
-		fmt.Println(debug)
-	}
-
 }
 
+// FIXME: move these into Grid
 // load a pre-computed pattern from RLE file
 func (scene *ScenePlay) InitPattern() {
-	scene.Grids[0].LoadRLE(scene.Config.RLE)
+	if scene.Config.RLE != nil {
-	scene.History.LoadRLE(scene.Config.RLE)
+		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
 				}
-
-// pre-render offscreen cache image
-func (scene *ScenePlay) InitCache() {
-	op := &ebiten.DrawImageOptions{}
-
-	if scene.Config.ShowGrid {
-		scene.Cache.Fill(scene.Grey)
-	} else {
-		scene.Cache.Fill(scene.White)
 			}
-
-	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),
-			)
-
-			scene.Cache.DrawImage(scene.Tiles.White, op)
 		}
 	}
 }
 
-// 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)
 
-	// startup is delayed until user has selected options
+	for y := 0; y < scene.Config.Height; y++ {
-	grida.FillRandom()
+		if !scene.Config.Empty {
-	grida.Copy(history)
+			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,
@@ -702,59 +603,30 @@ 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(
+	scene.World = ebiten.NewImage(scene.Config.ScreenWidth, scene.Config.ScreenHeight)
-		scene.Config.Width*scene.Config.Cellsize,
-		scene.Config.Height*scene.Config.Cellsize,
-	)
-
-	scene.Cache = ebiten.NewImage(
-		scene.Config.Width*scene.Config.Cellsize,
-		scene.Config.Height*scene.Config.Cellsize,
-	)
-
-	scene.Pixels = make([]byte, scene.World.Bounds().Dx()*scene.World.Bounds().Dy()*scene.Config.Cellsize)
-
-	scene.InitTiles()
-	scene.InitCache()
-
-	if scene.Config.DelayedStart && !scene.Config.Empty {
-		scene.Config.Empty = true
-		scene.InitGrid()
-		scene.Config.Empty = false
-	} else {
-		scene.InitGrid()
-	}
 
+	scene.InitGrid(grid)
 	scene.InitPattern()
+	scene.InitTiles()
 
 	scene.Index = 0
 	scene.TicksElapsed = 0
 
 	scene.LastCursorPos = make([]int, 2)
-
-	if scene.Config.Zoomfactor < 0 || scene.Config.Zoomfactor > 0 {
-		scene.Camera.ZoomFactor = scene.Config.Zoomfactor
-	}
-
-	scene.Camera.Setup()
-
-	scene.PixelColor = make([]byte, 3)
-	scene.PixelColor[0] = 0xff
-	scene.PixelColor[1] = 0x00
-	scene.PixelColor[2] = 0xff
 }
 
 // count the living neighbors of a cell
@@ -797,8 +669,8 @@ func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
 		tile,
 		float32(1),
 		float32(1),
-		float32(cellsize),
+		float32(cellsize-1),
-		float32(cellsize),
+		float32(cellsize-1),
 		col, false,
 	)
 }

scene.go

@@ -13,15 +13,13 @@ type SceneName int
 type Scene interface {
 	SetNext(SceneName)
 	GetNext() SceneName
-	SetPrevious(SceneName)
 	ResetNext()
+	Clearscreen() bool
 	Update() error
 	Draw(screen *ebiten.Image)
-	IsPrimary() bool // if true, this scene will be always drawn
 }
 
 const (
 	Menu = iota // main top level menu
 	Play        // actual playing happens here
-	Options
 )

src/Makefile

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

src/assets/shaders/row.kg

@@ -1,13 +0,0 @@
-//kage:unit pixels
-
-package main
-
-var Alife int
-
-func Fragment(_ vec4, pos vec2, _ vec4) vec4 {
-        if Alife == 1 {
-                return vec4(0.0)
-        }
-
-        return vec4(1.0)
-}

src/config.go

@@ -1,265 +0,0 @@
-package main
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"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, Markmode bool     // game modi
-	ShowEvolution, ShowGrid, RunOneStep    bool     // flags
-	Rule                                   *Rule    // which rule to use, default: B3/S23
-	RLE                                    *rle.RLE // loaded GOL pattern from RLE file
-	Statefile                              string   // load game state from it if non-nil
-	StateGrid                              *Grid    // a grid from a statefile
-	Wrap                                   bool     // wether wraparound mode is in place or not
-	ShowVersion                            bool
-	UseShader                              bool // to use a shader to render alife cells
-	Restart, RestartGrid, RestartCache     bool
-	StartWithMenu                          bool
-	Zoomfactor                             int
-	ZoomOutFactor                          int
-	InitialCamPos                          []float64
-	DelayedStart                           bool // if true game, we wait. like pause but program induced
-
-	// for internal profiling
-	ProfileFile     string
-	ProfileDraw     bool
-	ProfileMaxLoops int64
-}
-
-const (
-	VERSION = "v0.0.8"
-	Alive   = 1
-	Dead    = 0
-
-	DEFAULT_GRID_WIDTH  = 600
-	DEFAULT_GRID_HEIGHT = 400
-	DEFAULT_CELLSIZE    = 4
-	DEFAULT_ZOOMFACTOR  = 150
-	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
-	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")
-	}
-
-	config.ScreenWidth = width
-	config.ScreenHeight = height
-
-	config.Cellsize = DEFAULT_CELLSIZE
-
-	return nil
-}
-
-// check if we have  been given an RLE or LIF file  to load, then load
-// it and adjust game settings accordingly
-func (config *Config) ParseRLE(rlefile string) error {
-	if rlefile == "" {
-		return nil
-	}
-
-	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 pattern 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
-	}
-
-	fmt.Printf("width: %d, screenwidth: %d, rlewidth: %d, cellsize: %d\n",
-		config.Width, config.ScreenWidth, config.RLE.Width, config.Cellsize)
-
-	// 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
-}
-
-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", DEFAULT_GRID_WIDTH, "grid width in cells")
-	pflag.IntVarP(&config.Height, "height", "H", DEFAULT_GRID_HEIGHT, "grid height in cells")
-	pflag.IntVarP(&config.Cellsize, "cellsize", "c", 8, "cell size in pixels")
-	pflag.StringVarP(&geom, "geom", "G", DEFAULT_GEOM, "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, "pattern-file", "f", "", "RLE or LIF pattern 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.ShowGrid, "show-grid", "g", false, "draw grid lines")
-	pflag.BoolVarP(&config.Empty, "empty", "e", false, "start with an empty screen")
-	pflag.BoolVarP(&config.Invert, "invert", "i", false, "invert colors (dead cell: black)")
-	pflag.BoolVarP(&config.ShowEvolution, "show-evolution", "s", false, "show evolution traces")
-	pflag.BoolVarP(&config.Wrap, "wrap-around", "w", false, "wrap around grid mode")
-	pflag.BoolVarP(&config.UseShader, "use-shader", "k", false, "use shader for cell rendering")
-
-	pflag.StringVarP(&config.ProfileFile, "profile-file", "", "", "enable profiling")
-	pflag.BoolVarP(&config.ProfileDraw, "profile-draw", "", false, "profile draw method (default false)")
-	pflag.Int64VarP(&config.ProfileMaxLoops, "profile-max-loops", "", 10, "how many loops to execute (default 10)")
-
-	pflag.Parse()
-
-	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)
-	}
-
-	config.SetupCamera()
-
-	//repr.Println(config)
-	return &config, nil
-}
-
-func (config *Config) TogglePaused() {
-	config.Paused = !config.Paused
-}
-
-func (config *Config) ToggleDebugging() {
-	config.Debug = !config.Debug
-}
-
-func (config *Config) ToggleInvert() {
-	config.Invert = !config.Invert
-	config.RestartCache = true
-}
-
-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

@@ -1,83 +0,0 @@
-package main
-
-import (
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-type Game struct {
-	ScreenWidth, ScreenHeight, ReadlWidth, Cellsize int
-	Scenes                                          map[SceneName]Scene
-	CurrentScene                                    SceneName
-	Config                                          *Config
-	Scale                                           float32
-	Screen                                          *ebiten.Image
-}
-
-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)
-	game.Scenes[Menu] = NewMenuScene(game, config)
-	game.Scenes[Options] = NewOptionsScene(game, config)
-
-	// setup environment
-	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
-	ebiten.SetWindowTitle("golsky - conway's game of life")
-	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
-	ebiten.SetScreenClearedEveryFrame(true)
-
-	game.Screen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
-	return game
-}
-
-func (game *Game) GetCurrentScene() Scene {
-	return game.Scenes[game.CurrentScene]
-}
-
-func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
-	game.ReadlWidth = outsideWidth
-	game.Scale = float32(game.ScreenWidth) / float32(outsideWidth)
-	return game.ScreenWidth, game.ScreenHeight
-}
-
-func (game *Game) Update() error {
-	scene := game.GetCurrentScene()
-
-	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
-	}
-
-	return nil
-}
-
-func (game *Game) Draw(screen *ebiten.Image) {
-	// first draw primary scene[s], although there are only 1
-	for current, scene := range game.Scenes {
-		if scene.IsPrimary() {
-			// primary scenes always draw
-			scene.Draw(screen)
-
-			if current == game.CurrentScene {
-				// avoid to redraw it in the next step
-				return
-			}
-		}
-	}
-
-	scene := game.GetCurrentScene()
-	scene.Draw(screen)
-}

src/grid.go

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

src/loader-fonts.go

@@ -1,113 +0,0 @@
-package main
-
-import (
-	"log"
-
-	"github.com/golang/freetype/truetype"
-	"github.com/tinne26/etxt"
-	"golang.org/x/image/font"
-)
-
-var FontRenderer = LoadFonts("assets/fonts")
-
-const (
-	GameFont       string = "NotoSans-Regular"
-	GameFontETXT   string = "Noto Sans"
-	FontSizeBig    int    = 48
-	FontSizeNormal int    = 24
-	FontSizeSmall  int    = 12
-)
-
-type Texter struct {
-	Renderer   *etxt.Renderer
-	FontNormal *font.Face
-	FontBig    *font.Face
-	FontSmall  *font.Face
-}
-
-func LoadFonts(dir string) Texter {
-	// load the font for use with ebitenui
-	fontbytes, err := assetfs.ReadFile(dir + "/" + GameFont + ".ttf")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	gamefont, err := truetype.Parse(fontbytes)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	gameface := truetype.NewFace(gamefont, &truetype.Options{
-		Size:    float64(FontSizeNormal),
-		DPI:     72,
-		Hinting: font.HintingFull,
-	})
-
-	biggameface := truetype.NewFace(gamefont, &truetype.Options{
-		Size:    float64(FontSizeBig),
-		DPI:     72,
-		Hinting: font.HintingFull,
-	})
-
-	smallgameface := truetype.NewFace(gamefont, &truetype.Options{
-		Size:    float64(FontSizeSmall),
-		DPI:     72,
-		Hinting: font.HintingFull,
-	})
-
-	// load the font for use with etxt
-	fontlib := etxt.NewFontLibrary()
-	_, _, err = fontlib.ParseEmbedDirFonts(dir, assetfs)
-	if err != nil {
-		log.Fatalf("Error while loading fonts: %s", err.Error())
-	}
-
-	/*
-		err = fontlib.EachFont(
-			func(fontName string, font *etxt.Font) error {
-				fmt.Printf("font: %s\n", fontName)
-				return nil
-			})
-		if err != nil {
-			log.Fatal(err)
-		}
-	*/
-
-	if !fontlib.HasFont(GameFontETXT) {
-		log.Fatal("missing font: " + GameFontETXT)
-	}
-
-	err = fontlib.EachFont(checkMissingRunes)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	renderer := etxt.NewStdRenderer()
-
-	glyphsCache := etxt.NewDefaultCache(10 * 1024 * 1024) // 10MB
-	renderer.SetCacheHandler(glyphsCache.NewHandler())
-	renderer.SetFont(fontlib.GetFont(GameFontETXT))
-
-	return Texter{
-		Renderer:   renderer,
-		FontNormal: &gameface,
-		FontBig:    &biggameface,
-		FontSmall:  &smallgameface,
-	}
-}
-
-// helper function used with FontLibrary.EachFont to make sure
-// all loaded fonts contain the characters or alphabet we want
-func checkMissingRunes(name string, font *etxt.Font) error {
-	const letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
-	const symbols = "0123456789 .,;:!?-()[]{}_&#@"
-
-	missing, err := etxt.GetMissingRunes(font, letters+symbols)
-	if err != nil {
-		return err
-	}
-	if len(missing) > 0 {
-		log.Fatalf("Font '%s' missing runes: %s", name, string(missing))
-	}
-	return nil
-}

src/loader-shaders.go

@@ -1,49 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"log"
-	"log/slog"
-	"path"
-	"strings"
-
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-type ShaderRegistry map[string]*ebiten.Shader
-
-var Shaders = LoadShaders("assets/shaders")
-
-func LoadShaders(dir string) ShaderRegistry {
-	shaders := ShaderRegistry{}
-
-	entries, err := assetfs.ReadDir(dir)
-	if err != nil {
-		log.Fatalf("failed to read shaders dir %s: %s", dir, err)
-	}
-
-	for _, file := range entries {
-		path := path.Join(dir, file.Name())
-		fd, err := assetfs.Open(path)
-		if err != nil {
-			log.Fatalf("failed to open shader file %s: %s", file.Name(), err)
-		}
-		defer fd.Close()
-
-		name := strings.TrimSuffix(file.Name(), ".kg")
-
-		buf := new(bytes.Buffer)
-		buf.ReadFrom(fd)
-
-		shader, err := ebiten.NewShader([]byte(buf.Bytes()))
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		shaders[name] = shader
-
-		slog.Debug("loaded shader asset", "path", path)
-	}
-
-	return shaders
-}

src/loader-sprites.go

@@ -1,69 +0,0 @@
-package main
-
-import (
-	"embed"
-	"image"
-	_ "image/png"
-	"io/fs"
-	"log"
-	"path"
-	"strings"
-
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-// Maps image name to image data
-type AssetRegistry map[string]*ebiten.Image
-
-// A helper to pass the registry easier around
-type assetData struct {
-	Registry AssetRegistry
-}
-
-//go:embed assets/sprites/*.png assets/fonts/*.ttf assets/shaders/*.kg
-var assetfs embed.FS
-
-// Called at build time, creates the global asset and animation registries
-var Assets = LoadImages("assets/sprites")
-
-// load pngs and json files
-func LoadImages(dir string) AssetRegistry {
-	Registry := AssetRegistry{}
-
-	// we use embed.FS to iterate over all files in ./assets/
-	entries, err := assetfs.ReadDir(dir)
-	if err != nil {
-		log.Fatalf("failed to read assets dir %s: %s", dir, err)
-	}
-
-	for _, imagefile := range entries {
-		path := path.Join(dir, imagefile.Name())
-
-		fd, err := assetfs.Open(path)
-		if err != nil {
-			log.Fatalf("failed to open file %s: %s", imagefile.Name(), err)
-		}
-		defer fd.Close()
-
-		switch {
-		case strings.HasSuffix(path, ".png"):
-			name, image := ReadImage(imagefile, fd)
-			Registry[name] = image
-		}
-	}
-
-	return Registry
-}
-
-func ReadImage(imagefile fs.DirEntry, fd fs.File) (string, *ebiten.Image) {
-	name := strings.TrimSuffix(imagefile.Name(), ".png")
-
-	img, _, err := image.Decode(fd)
-	if err != nil {
-		log.Fatalf("failed to decode image %s: %s", imagefile.Name(), err)
-	}
-
-	image := ebiten.NewImageFromImage(img)
-
-	return name, image
-}

src/main.go

@@ -1,55 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"runtime/pprof"
-
-	_ "net/http/pprof"
-
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-func main() {
-	var directstart bool
-
-	if len(os.Args) > 1 {
-		directstart = true
-	}
-
-	config, err := ParseCommandline()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	if config.ShowVersion {
-		fmt.Printf("This is golsky version %s\n", VERSION)
-		os.Exit(0)
-	}
-
-	start := Play
-	if !directstart {
-		start = Menu
-		config.DelayedStart = true
-	}
-	game := NewGame(config, SceneName(start))
-
-	if config.ProfileFile != "" {
-		// enable  cpu profiling. Do  NOT use q  to stop the  game but
-		// close the window to get a profile
-		fd, err := os.Create(config.ProfileFile)
-		if err != nil {
-			log.Fatal(err)
-		}
-		defer fd.Close()
-
-		pprof.StartCPUProfile(fd)
-		defer pprof.StopCPUProfile()
-	}
-
-	// main loop
-	if err := ebiten.RunGame(game); err != nil {
-		log.Fatal(err)
-	}
-}

src/menu.go

@@ -1,135 +0,0 @@
-package main
-
-import (
-	"image/color"
-	"os"
-
-	"github.com/ebitenui/ebitenui"
-	"github.com/ebitenui/ebitenui/widget"
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/inpututil"
-)
-
-type SceneMenu struct {
-	Game      *Game
-	Config    *Config
-	Next      SceneName
-	Prev      SceneName
-	Whoami    SceneName
-	Ui        *ebitenui.UI
-	FontColor color.RGBA
-	First     bool
-}
-
-func NewMenuScene(game *Game, config *Config) Scene {
-	scene := &SceneMenu{
-		Whoami:    Menu,
-		Game:      game,
-		Next:      Menu,
-		Config:    config,
-		FontColor: color.RGBA{255, 30, 30, 0xff},
-	}
-
-	scene.Init()
-
-	return scene
-}
-
-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
-}
-
-func (scene *SceneMenu) SetNext(next SceneName) {
-	scene.Next = next
-}
-
-func (scene *SceneMenu) Update() error {
-	scene.Ui.Update()
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		scene.Config.DelayedStart = false
-		scene.Leave()
-	}
-
-	return nil
-
-}
-
-func (scene *SceneMenu) IsPrimary() bool {
-	return false
-}
-
-func (scene *SceneMenu) Draw(screen *ebiten.Image) {
-	scene.Ui.Draw(screen)
-}
-
-func (scene *SceneMenu) Leave() {
-	scene.SetNext(Play)
-}
-
-func (scene *SceneMenu) Init() {
-	rowContainer := NewRowContainer("Main Menu")
-
-	empty := NewMenuButton("Start with empty grid",
-		func(args *widget.ButtonClickedEventArgs) {
-			scene.Config.Empty = true
-			scene.Config.Restart = true
-			scene.Leave()
-		})
-
-	random := NewMenuButton("Start with random patterns",
-		func(args *widget.ButtonClickedEventArgs) {
-			scene.Config.Empty = false
-			scene.Config.Restart = true
-			scene.Leave()
-		})
-
-	copy := NewMenuButton("Save Copy as RLE",
-		func(args *widget.ButtonClickedEventArgs) {
-			scene.Config.Markmode = true
-			scene.Config.Paused = true
-			scene.Leave()
-		})
-
-	options := NewMenuButton("Options",
-		func(args *widget.ButtonClickedEventArgs) {
-			scene.SetNext(Options)
-		})
-
-	separator1 := NewSeparator(3)
-	separator2 := NewSeparator(3)
-	separator3 := NewSeparator(10)
-
-	cancel := NewMenuButton("Back",
-		func(args *widget.ButtonClickedEventArgs) {
-			scene.Leave()
-		})
-
-	quit := NewMenuButton("Exit Golsky",
-		func(args *widget.ButtonClickedEventArgs) {
-			os.Exit(0)
-		})
-
-	rowContainer.AddChild(empty)
-	rowContainer.AddChild(random)
-	rowContainer.AddChild(separator1)
-	rowContainer.AddChild(options)
-	rowContainer.AddChild(copy)
-	rowContainer.AddChild(separator2)
-	rowContainer.AddChild(cancel)
-	rowContainer.AddChild(separator3)
-	rowContainer.AddChild(quit)
-
-	scene.Ui = &ebitenui.UI{
-		Container: rowContainer.Container(),
-	}
-
-}

src/options.go

@@ -1,140 +0,0 @@
-package main
-
-import (
-	"image/color"
-
-	"github.com/ebitenui/ebitenui"
-	"github.com/ebitenui/ebitenui/widget"
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/inpututil"
-)
-
-type SceneOptions struct {
-	Game      *Game
-	Config    *Config
-	Next      SceneName
-	Prev      SceneName
-	Whoami    SceneName
-	Ui        *ebitenui.UI
-	FontColor color.RGBA
-}
-
-func NewOptionsScene(game *Game, config *Config) Scene {
-	scene := &SceneOptions{
-		Whoami:    Options,
-		Game:      game,
-		Next:      Options,
-		Config:    config,
-		FontColor: color.RGBA{255, 30, 30, 0xff},
-	}
-
-	scene.Init()
-
-	return scene
-}
-
-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
-}
-
-func (scene *SceneOptions) SetNext(next SceneName) {
-	scene.Next = next
-}
-
-func (scene *SceneOptions) IsPrimary() bool {
-	return false
-}
-
-func (scene *SceneOptions) Update() error {
-	scene.Ui.Update()
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		scene.SetNext(Play)
-	}
-
-	return nil
-
-}
-
-func (scene *SceneOptions) Draw(screen *ebiten.Image) {
-	scene.Ui.Draw(screen)
-}
-
-func (scene *SceneOptions) SetInitialValue(w *widget.LabeledCheckbox, value bool) {
-	var intval int
-	if value {
-		intval = 1
-	}
-
-	w.SetState(
-		widget.WidgetState(intval),
-	)
-}
-
-func (scene *SceneOptions) Init() {
-	rowContainer := NewRowContainer("Options")
-
-	pause := NewCheckbox("Pause",
-		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.TogglePaused()
-		})
-
-	debugging := NewCheckbox("Debugging",
-		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.ToggleDebugging()
-		})
-	scene.SetInitialValue(debugging, scene.Config.Debug)
-
-	invert := NewCheckbox("Invert",
-		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.ToggleInvert()
-		})
-	scene.SetInitialValue(invert, scene.Config.Invert)
-
-	gridlines := NewCheckbox("Show grid lines",
-		func(args *widget.CheckboxChangedEventArgs) {
-			scene.Config.ToggleGridlines()
-		})
-	scene.SetInitialValue(gridlines, scene.Config.ShowGrid)
-
-	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(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)
-
-	scene.Ui = &ebitenui.UI{
-		Container: rowContainer.Container(),
-	}
-
-}

src/widgets.go

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

various-tests/drawtriangles/go.mod

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

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

various-tests/drawtriangles/main.go

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

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

various-tests/writepixel/go.sum

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

various-tests/writepixel/main.go

@@ -1,294 +0,0 @@
-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() {
-	//x := 1
-	//y := 0
-	col := 1 >> 0xff
-
-	fmt.Printf("col: %d\n", col)
-
-	x := 1
-	y := 2
-	c := 4
-
-	xm := x & (c - 1)
-	ym := y & (c - 1)
-
-	fmt.Println(xm & ym)
-}
-
-func _main() {
-	size := 800
-
-	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)
-	}
-}