moved to codeberg

See
424f62327b

Thanks a lot for the fast support, amazing!

.gitignore

@@ -1,3 +1,9 @@
 golsky
 bak
 dump*
+rect*
+*profile
+*prof
+*lif
+*rle
+svgicons

Makefile

@@ -1,96 +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)
-
-all: buildlocal
-
-
-buildlocal:
-	go build -o $(tool)
-
-install: buildlocal
-	install -d -o $(UID) -g $(GID) $(PREFIX)/bin
-	install -d -o $(UID) -g $(GID) $(PREFIX)/man/man1
-	install -o $(UID) -g $(GID) -m 555 $(tool)  $(PREFIX)/sbin/
-	install -o $(UID) -g $(GID) -m 444 $(tool).1 $(PREFIX)/man/man1/
-
-clean:
-	rm -rf $(tool) coverage.out testdata t/out
-
-test: clean
-	mkdir -p t/out
-	go test ./... $(ARGS)
-
-testlint: test lint
-
-lint:
-	golangci-lint run
-
-lint-full:
-	golangci-lint run --enable-all --exclude-use-default --disable exhaustivestruct,exhaustruct,depguard,interfacer,deadcode,golint,structcheck,scopelint,varcheck,ifshort,maligned,nosnakecase,godot,funlen,gofumpt,cyclop,noctx,gochecknoglobals,paralleltest
-
-testfuzzy: clean
-	go test -fuzz ./... $(ARGS)
-
-singletest:
-	@echo "Call like this: make singletest TEST=TestPrepareColumns ARGS=-v"
-	go test -run $(TEST) $(ARGS)
-
-cover-report:
-	go test ./... -cover -coverprofile=coverage.out
-	go tool cover -html=coverage.out
-
-goupdate:
-	go get -t -u=patch ./...
-
-buildall:
-	./mkrel.sh $(tool) $(VERSION)
-
-release: buildall
-	gh release create $(VERSION) --generate-notes releases/*
-
-show-versions: buildlocal
-	@echo "### golsky version:"
-	@./golsky -V
-
-	@echo
-	@echo "### go module versions:"
-	@go list -m all
-
-	@echo
-	@echo "### go version used for building:"
-	@grep -m 1 go go.mod
-
-# lint:
-# 	golangci-lint run -p bugs -p unused
-
-buildwasm:
-	env GOOS=js GOARCH=wasm go build -o $(tool).wasm $(LDFLAGS) .
-
-zipwasm:
-	zip -r openquell-$(SHORTVERSION).zip index.html $(tool).wasm wasm_exec.js
-
-wasm: buildwasm zipwasm
-	@ls -l $(tool)-$(SHORTVERSION).zip

README.md

@@ -1,12 +1,15 @@
-# golsky - Conway's game of life written in GO
-
-![Golsky Logo](https://github.com/TLINDEN/golsky/blob/main/.github/assets/golskylogo.png)
-
 [![License](https://img.shields.io/badge/license-GPL-blue.svg)](https://github.com/tlinden/golsky/blob/master/LICENSE)
 [![Go Report Card](https://goreportcard.com/badge/github.com/tlinden/golsky)](https://goreportcard.com/report/github.com/tlinden/golsky) 
 
-I wanted to play around a little bit with [**Conways Game of
+# golsky - Conway's game of life written in GO
-Life**](https://conwaylife.com/)
+
+> [!IMPORTANT]
+> This software is now being maintained on [Codeberg](https://codeberg.org/scip/golsky/).
+
+![Golsky Logo](https://github.com/TLINDEN/golsky/blob/main/.github/assets/golskylogo.png)
+
+
+I wanted to play around a little bit with [**Conways Game of Life**](https://conwaylife.com/)
 in golang and here's the  result. It's a simple game using
 [ebitengine](https://github.com/hajimehoshi/ebiten/).
 
@@ -14,11 +17,25 @@ John Conway himself: https://youtu.be/R9Plq-D1gEk?si=yYxs77e9yXxeSNbL
 
 Based on: https://youtu.be/FWSR_7kZuYg?si=ix1dmo76D8AmF25F
 
+# Screenshots
+[![golsky-mainmenu.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-mainmenu.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-mainmenu.png)
+[![golsky-options.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-options.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-options.png)
+[![golsky-bindings.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-bindings.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-bindings.png)
+[![golsky-evolution-trace.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-evolution-trace.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-evolution-trace.png)
+[![golsky-zoom.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-zoom.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-zoom.png)
+[![golsky-debug.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-debug.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-debug.png)
+[![golsky-capture.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-capture.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-capture.png)
+[![golsky-captured.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-captured.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-captured.png)
+[![golsky-dark-theme.png](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/256_golsky-dark-theme.png)](https://github.com/TLINDEN/golsky/blob/main/.github/assets/screenshots/golsky-dark-theme.png)
+
+
+[Youtube video game preview](https://www.youtube.com/watch?v=xEto6Oew16I)
+
 # Features
 
 * flexible parameters as grid and cell size
 * colors can be inverted
-* evolution  tracks can be shown,  with age the cells  color fades and
+* evolution  traces 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 +78,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 tracks
+  -s, --show-evolution             show evolution traces
   -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)
@@ -69,18 +86,22 @@ Usage of ./golsky:
 
 While it runs, there are a couple of commands you can use:
 
-* left mouse click: set a cell to alife (also pauses the game)
+
-* right mouse click: set a cell to dead
 * space: pause or resume the game
 * while game is paused: press n to forward one step
 * page up: speed up
 * page down: slow down
 * Mouse wheel: zoom in or out
-* move mouse while middle mouse button pressed: move canvas
+* move mouse while left mouse button pressed: move canvas
-* escape: reset to 1:1 zoom
+* i: enter "insert" (draw) mode: use left mouse to toggle cells alife state.
+  Leave with insert mode "space". While in insert mode, use middle mouse
+  button to drag the grid.
+* r: reset to 1:1 zoom
+* escape: open menu
 * s: save game state to file (can be loaded with -l)
 * 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 +0,0 @@
-- Implement RLE writing on scene.MarkDone

camera.go

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

config.go

@@ -1,118 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-
-	"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
-}
-
-const (
-	VERSION = "v0.0.6"
-	Alive   = 1
-	Dead    = 0
-)
-
-func GetRLE(filename string) *rle.RLE {
-	if filename == "" {
-		return nil
-	}
-
-	content, err := os.ReadFile(filename)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	parsedRle, err := rle.Parse(string(content))
-	if err != nil {
-		log.Fatalf("failed to load RLE pattern file: %s", err)
-	}
-
-	return &parsedRle
-}
-
-func ParseCommandline() *Config {
-	config := Config{}
-
-	var rule string
-	var rlefile 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.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.Parse()
-
-	// check if we have been given an RLE file to load
-	config.RLE = GetRLE(rlefile)
-	if config.RLE != nil {
-		if config.RLE.Width > config.Width || config.RLE.Height > config.Height {
-			config.Width = config.RLE.Width * 2
-			config.Height = config.RLE.Height * 2
-			fmt.Printf("rlew: %d, rleh: %d, w: %d, h: %d\n",
-				config.RLE.Width, config.RLE.Height, config.Width, config.Height)
-		}
-
-		// 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)
-		}
-	} else if config.Statefile != "" {
-		grid, err := LoadState(config.Statefile)
-		if err != nil {
-			log.Fatalf("failed to load game state: %s", err)
-		}
-
-		config.Width = grid.Width
-		config.Height = grid.Height
-		config.StateGrid = grid
-	}
-
-	config.ScreenWidth = config.Cellsize * config.Width
-	config.ScreenHeight = config.Cellsize * config.Height
-
-	// 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
-}

game.go

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

generics.go

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

go.mod

@@ -1,19 +0,0 @@
-module github.com/tlinden/golsky
-
-go 1.22
-
-require (
-	github.com/hajimehoshi/ebiten/v2 v2.7.4
-	github.com/spf13/pflag v1.0.5
-	golang.org/x/image v0.16.0
-)
-
-require (
-	github.com/alecthomas/repr v0.4.0 // indirect
-	github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 // indirect
-	github.com/ebitengine/hideconsole v1.0.0 // indirect
-	github.com/ebitengine/purego v0.7.0 // indirect
-	github.com/jezek/xgb v1.1.1 // indirect
-	golang.org/x/sync v0.7.0 // indirect
-	golang.org/x/sys v0.20.0 // indirect
-)

go.sum

@@ -1,20 +0,0 @@
-github.com/alecthomas/repr v0.4.0 h1:GhI2A8MACjfegCPVq9f1FLvIBS+DrQ2KQBFZP1iFzXc=
-github.com/alecthomas/repr v0.4.0/go.mod h1:Fr0507jx4eOXV7AlPV6AVZLYrLIuIeSOWtW57eE/O/4=
-github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 h1:48bCqKTuD7Z0UovDfvpCn7wZ0GUZ+yosIteNDthn3FU=
-github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895/go.mod h1:XZdLv05c5hOZm3fM2NlJ92FyEZjnslcMcNRrhxs8+8M=
-github.com/ebitengine/hideconsole v1.0.0 h1:5J4U0kXF+pv/DhiXt5/lTz0eO5ogJ1iXb8Yj1yReDqE=
-github.com/ebitengine/hideconsole v1.0.0/go.mod h1:hTTBTvVYWKBuxPr7peweneWdkUwEuHuB3C1R/ielR1A=
-github.com/ebitengine/purego v0.7.0 h1:HPZpl61edMGCEW6XK2nsR6+7AnJ3unUxpTZBkkIXnMc=
-github.com/ebitengine/purego v0.7.0/go.mod h1:ah1In8AOtksoNK6yk5z1HTJeUkC1Ez4Wk2idgGslMwQ=
-github.com/hajimehoshi/ebiten/v2 v2.7.4 h1:X+heODRQ3Ie9F9QFjm24gEZqQd5FSfR9XuT2XfHwgf8=
-github.com/hajimehoshi/ebiten/v2 v2.7.4/go.mod h1:H2pHVgq29rfm5yeQ7jzWOM3VHsjo7/AyucODNLOhsVY=
-github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
-github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
-github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
-github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
-golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw=
-golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs=
-golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M=
-golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
-golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y=
-golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=

grid.go

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

@@ -1,38 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"log"
-	"os"
-
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-func main() {
-	config := ParseCommandline()
-
-	if config.ShowVersion {
-		fmt.Printf("This is golsky version %s\n", VERSION)
-		os.Exit(0)
-	}
-
-	// grid := [][]int64{
-	// 	{0, 1, 1},
-	// 	{0, 1, 0},
-	// 	{1, 1, 0},
-	// }
-
-	// err := rle.StoreGridToRLE(grid, "test.rle", "B3/S23", 3, 3)
-	// if err != nil {
-	// 	panic(err)
-	// }
-
-	// os.Exit(0)
-
-	game := NewGame(config, Play)
-
-	// main loop
-	if err := ebiten.RunGame(game); err != nil {
-		log.Fatal(err)
-	}
-}

mkrel.sh

@@ -1,69 +0,0 @@
-#!/bin/bash
-
-# Copyright © 2024 Thomas von Dein
-
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see <http://www.gnu.org/licenses/>.
-
-
-# get list with: go tool dist list
-DIST="linux/amd64
-windows/amd64 "
-
-tool="$1"
-version="$2"
-
-if test -z "$version"; then
-  echo "Usage: $0 <tool name> <release version>"
-  exit 1
-fi
-
-rm -rf releases
-mkdir -p releases
-
-
-for D in $DIST; do
-    os=${D/\/*/}
-    arch=${D/*\//}
-    binfile="releases/${tool}-${os}-${arch}-${version}"
-
-    if test "$os" = "windows"; then
-        binfile="${binfile}.exe"
-    fi
-    
-    tardir="${tool}-${os}-${arch}-${version}"
-    tarfile="releases/${tool}-${os}-${arch}-${version}.tar.gz"
-    set -x
-    GOOS=${os} GOARCH=${arch} go build -o ${binfile}
-    set +x
-    continue
-    
-    mkdir -p ${tardir}
-    cp ${binfile} README.md LICENSE ${tardir}/
-    echo 'tool = gfn
-PREFIX = /usr/local
-UID    = root
-GID    = 0
-
-install:
-	install -d -o $(UID) -g $(GID) $(PREFIX)/bin
-	install -d -o $(UID) -g $(GID) $(PREFIX)/man/man1
-	install -o $(UID) -g $(GID) -m 555 $(tool)  $(PREFIX)/sbin/
-	install -o $(UID) -g $(GID) -m 444 $(tool).1 $(PREFIX)/man/man1/' > ${tardir}/Makefile
-    tar cpzf ${tarfile} ${tardir}
-    sha256sum ${binfile} | cut -d' ' -f1 > ${binfile}.sha256
-    sha256sum ${tarfile} | cut -d' ' -f1 > ${tarfile}.sha256
-    rm -rf ${tardir}
-    set +x
-done
-

rle/pattern_parser.go

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

rle/pattern_parser_test.go

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

rle/rle.go

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

rle/rle_test.go

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

rule.go

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

sample-rles/64P2H1V0.rle

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

sample-rles/glider.rle

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

sample-rles/lightweight9.rle

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

sample-rles/p39piheptominohasslerdimer.rle

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

sample-rles/weekender.rle

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

scene-play.go

@@ -1,657 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"image"
-	"image/color"
-	"log"
-	"math/rand"
-	"os"
-
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
-	"github.com/hajimehoshi/ebiten/v2/inpututil"
-	"github.com/hajimehoshi/ebiten/v2/vector"
-	"github.com/tlinden/golsky/rle"
-	"golang.org/x/image/math/f64"
-)
-
-type Images struct {
-	Black, White, Age1, Age2, Age3, Age4, Old *ebiten.Image
-}
-
-type ScenePlay struct {
-	Game   *Game
-	Config *Config
-	Next   SceneName
-	Whoami SceneName
-
-	Grids                                      []*Grid // 2 grids: one current, one next
-	History                                    *Grid   // holds state of past dead cells for evolution tracks
-	Index                                      int     // points to current grid
-	Generations                                int64   // Stats
-	Black, White, Grey, Old                    color.RGBA
-	AgeColor1, AgeColor2, AgeColor3, AgeColor4 color.RGBA
-	TicksElapsed                               int           // tick counter for game speed
-	Tiles                                      Images        // pre-computed tiles for dead and alife cells
-	Camera                                     Camera        // for zoom+move
-	World                                      *ebiten.Image // actual image we render to
-	WheelTurned                                bool          // when user turns wheel multiple times, zoom faster
-	Dragging                                   bool          // middle mouse is pressed, move canvas
-	LastCursorPos                              []int         // used to check if the user is dragging
-	Markmode                                   bool          // enabled with 'c'
-	MarkTaken                                  bool          // true when mouse1 pressed
-	MarkDone                                   bool          // true when mouse1 released, copy cells between Mark+Point
-	Mark, Point                                image.Point   // area to marks+save
-	Paused, RunOneStep                         bool          // mutable flags from config
-	TPG                                        int
-}
-
-func NewPlayScene(game *Game, config *Config) Scene {
-	scene := &ScenePlay{
-		Whoami:     Play,
-		Game:       game,
-		Next:       Play,
-		Config:     config,
-		Paused:     config.Paused,
-		TPG:        config.TPG,
-		RunOneStep: config.RunOneStep,
-	}
-
-	scene.Init()
-
-	return scene
-}
-
-func (scene *ScenePlay) GetNext() SceneName {
-	return scene.Next
-}
-
-func (scene *ScenePlay) ResetNext() {
-	scene.Next = scene.Whoami
-}
-
-func (scene *ScenePlay) SetNext(next SceneName) {
-	scene.Next = next
-}
-
-func (scene *ScenePlay) Clearscreen() bool {
-	return true
-}
-
-func (scene *ScenePlay) CheckRule(state int64, neighbors int64) int64 {
-	var nextstate int64
-
-	// The standard Scene of Life is symbolized in rule-string notation
-	// as B3/S23 (23/3 here).  A cell  is born if it has exactly three
-	// neighbors,  survives if it  has two or three  living neighbors,
-	// and  dies otherwise. The first  number, or list of  numbers, is
-	// what is required for a dead cell to be born.
-
-	if state == 0 && Contains(scene.Config.Rule.Birth, neighbors) {
-		nextstate = Alive
-	} else if state == 1 && Contains(scene.Config.Rule.Death, neighbors) {
-		nextstate = Alive
-	} else {
-		nextstate = Dead
-	}
-
-	return nextstate
-}
-
-// Update all cells according to the current rule
-func (scene *ScenePlay) UpdateCells() {
-	// count ticks so we know when to actually run
-	scene.TicksElapsed++
-
-	if scene.TPG > scene.TicksElapsed {
-		// need to sleep a little more
-		return
-	}
-
-	// next grid index, we just xor 0|1 to 1|0
-	next := scene.Index ^ 1
-
-	// compute life status of cells
-	for y := 0; y < scene.Config.Height; y++ {
-		for x := 0; x < scene.Config.Width; x++ {
-			state := scene.Grids[scene.Index].Data[y][x] // 0|1 == dead or alive
-			neighbors := scene.CountNeighbors(x, y)      // alive neighbor count
-
-			// actually apply the current rules
-			nextstate := scene.CheckRule(state, neighbors)
-
-			// change state of current cell in next grid
-			scene.Grids[next].Data[y][x] = nextstate
-
-			// set history  to current generation so we  can infer the
-			// age of the cell's state  during rendering and use it to
-			// deduce the color to use if evolution tracking is enabled
-			if state != nextstate {
-				scene.History.Data[y][x] = scene.Generations
-			}
-		}
-	}
-
-	// switch grid for rendering
-	scene.Index ^= 1
-
-	// global stats counter
-	scene.Generations++
-
-	if scene.Config.RunOneStep {
-		// setp-wise mode, halt the game
-		scene.Config.RunOneStep = false
-	}
-
-	// reset speed counter
-	scene.TicksElapsed = 0
-}
-
-func (scene *ScenePlay) Reset() {
-	scene.Paused = true
-	scene.InitGrid(nil)
-	scene.Paused = false
-}
-
-// check user input
-func (scene *ScenePlay) CheckInput() {
-	if inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		os.Exit(0)
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
-		fmt.Println("mark mode on")
-		scene.Markmode = true
-		scene.Paused = true
-	}
-
-	if scene.Markmode {
-		return
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) {
-		scene.Paused = !scene.Paused
-	}
-
-	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
-		scene.ToggleCellOnCursorPos(Alive)
-		scene.Paused = true // drawing while running makes no sense
-	}
-
-	if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) {
-		scene.ToggleCellOnCursorPos(Dead)
-		scene.Paused = true // drawing while running makes no sense
-	}
-
-	if ebiten.IsKeyPressed(ebiten.KeyPageDown) {
-		if scene.Config.TPG < 120 {
-			scene.Config.TPG++
-		}
-	}
-
-	if ebiten.IsKeyPressed(ebiten.KeyPageUp) {
-		if scene.TPG > 1 {
-			scene.TPG--
-		}
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyS) {
-		scene.SaveState()
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyR) {
-		scene.Reset()
-	}
-
-	if scene.Paused {
-		if inpututil.IsKeyJustPressed(ebiten.KeyN) {
-			scene.Config.RunOneStep = true
-		}
-	}
-}
-
-// Check dragging input.  move the canvas with the  mouse while pressing
-// the middle mouse button, zoom in and out using the wheel.
-func (scene *ScenePlay) CheckDraggingInput() {
-	if scene.Markmode {
-		return
-	}
-
-	// move canvas
-	if scene.Dragging && !ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
-		// release
-		scene.Dragging = false
-	}
-
-	if !scene.Dragging && ebiten.IsMouseButtonPressed(ebiten.MouseButton1) {
-		// start dragging
-		scene.Dragging = true
-		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
-	}
-
-	if scene.Dragging {
-		x, y := ebiten.CursorPosition()
-
-		if x != scene.LastCursorPos[0] || y != scene.LastCursorPos[1] {
-			// actually drag by mouse cursor pos diff to last cursor pos
-			scene.Camera.Position[0] -= float64(x - scene.LastCursorPos[0])
-			scene.Camera.Position[1] -= float64(y - scene.LastCursorPos[1])
-		}
-
-		scene.LastCursorPos[0], scene.LastCursorPos[1] = ebiten.CursorPosition()
-	}
-
-	// also support the arrow keys to move the canvas
-	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) {
-		scene.Camera.Position[0] -= 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) {
-		scene.Camera.Position[0] += 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) {
-		scene.Camera.Position[1] -= 1
-	}
-	if ebiten.IsKeyPressed(ebiten.KeyArrowDown) {
-		scene.Camera.Position[1] += 1
-	}
-
-	// Zoom
-	_, dy := ebiten.Wheel()
-	step := 1
-
-	if scene.WheelTurned {
-		// if keep scrolling the wheel, zoom faster
-		step = 50
-	} else {
-		scene.WheelTurned = false
-	}
-
-	if dy < 0 {
-		if scene.Camera.ZoomFactor > -2400 {
-			scene.Camera.ZoomFactor -= step
-		}
-	}
-
-	if dy > 0 {
-		if scene.Camera.ZoomFactor < 2400 {
-			scene.Camera.ZoomFactor += step
-		}
-	}
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
-		scene.Camera.Reset()
-	}
-
-}
-
-func (scene *ScenePlay) GetWorldCursorPos() image.Point {
-	worldX, worldY := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
-	return image.Point{
-		X: int(worldX) / scene.Config.Cellsize,
-		Y: int(worldY) / scene.Config.Cellsize,
-	}
-}
-
-func (scene *ScenePlay) CheckMarkInput() {
-	if !scene.Markmode {
-		return
-	}
-
-	if ebiten.IsMouseButtonPressed(ebiten.MouseButton0) {
-		if !scene.MarkTaken {
-			scene.Mark = scene.GetWorldCursorPos()
-			scene.MarkTaken = true
-			scene.MarkDone = false
-		}
-
-		scene.Point = scene.GetWorldCursorPos()
-		//fmt.Printf("Mark: %v, Point: %v\n", scene.Mark, scene.Point)
-	} else if inpututil.IsMouseButtonJustReleased(ebiten.MouseButton0) {
-		scene.Markmode = false
-		scene.MarkTaken = false
-		scene.MarkDone = true
-
-		scene.SaveRectRLE()
-	}
-}
-
-func (scene *ScenePlay) SaveState() {
-	filename := GetFilename(scene.Generations)
-	err := scene.Grids[scene.Index].SaveState(filename)
-	if err != nil {
-		log.Printf("failed to save game state to %s: %s", filename, err)
-	}
-	log.Printf("saved game state to %s at generation %d\n", filename, scene.Generations)
-}
-
-func (scene *ScenePlay) SaveRectRLE() {
-	filename := GetFilenameRLE(scene.Generations)
-
-	if scene.Mark.X == scene.Point.X || scene.Mark.Y == scene.Point.Y {
-		log.Printf("can't save non-rectangle\n")
-		return
-	}
-
-	var width int
-	var height int
-	var startx int
-	var starty int
-
-	if scene.Mark.X < scene.Point.X {
-		// mark left point
-		startx = scene.Mark.X
-		width = scene.Point.X - scene.Mark.X
-	} else {
-		// mark right point
-		startx = scene.Point.X
-		width = scene.Mark.X - scene.Point.X
-	}
-
-	if scene.Mark.Y < scene.Point.Y {
-		// mark above point
-		starty = scene.Mark.Y
-		height = scene.Point.Y - scene.Mark.Y
-	} else {
-		// mark below point
-		starty = scene.Point.Y
-		height = scene.Mark.Y - scene.Point.Y
-	}
-
-	grid := make([][]int64, height)
-
-	for y := 0; y < height; y++ {
-		grid[y] = make([]int64, width)
-
-		for x := 0; x < width; x++ {
-			grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx]
-		}
-	}
-
-	err := rle.StoreGridToRLE(grid, filename, scene.Config.Rule.Definition, width, height)
-	if err != nil {
-		log.Printf("failed to save rect to %s: %s\n", filename, err)
-	} else {
-		log.Printf("saved selected rect to %s at generation %d\n", filename, scene.Generations)
-	}
-
-}
-
-func (scene *ScenePlay) Update() error {
-	scene.CheckInput()
-	scene.CheckDraggingInput()
-	scene.CheckMarkInput()
-
-	if !scene.Paused || scene.RunOneStep {
-		scene.UpdateCells()
-	}
-
-	return nil
-}
-
-// set a cell to alive or dead
-func (scene *ScenePlay) ToggleCellOnCursorPos(alive int64) {
-	// use cursor pos relative to the world
-	worldX, worldY := scene.Camera.ScreenToWorld(ebiten.CursorPosition())
-	x := int(worldX) / scene.Config.Cellsize
-	y := int(worldY) / scene.Config.Cellsize
-
-	//fmt.Printf("cell at %d,%d\n", x, y)
-
-	if x > -1 && y > -1 {
-		scene.Grids[scene.Index].Data[y][x] = alive
-		scene.History.Data[y][x] = 1
-	}
-}
-
-// draw the new grid state
-func (scene *ScenePlay) Draw(screen *ebiten.Image) {
-	// we  fill the whole  screen with  a background color,  the cells
-	// themselfes will be 1px smaller as their nominal size, producing
-	// a nice grey grid with grid lines
-	op := &ebiten.DrawImageOptions{}
-
-	if scene.Config.NoGrid {
-		scene.World.Fill(scene.White)
-	} else {
-		scene.World.Fill(scene.Grey)
-	}
-
-	for y := 0; y < scene.Config.Height; y++ {
-		for x := 0; x < scene.Config.Width; x++ {
-			op.GeoM.Reset()
-			op.GeoM.Translate(float64(x*scene.Config.Cellsize), float64(y*scene.Config.Cellsize))
-
-			age := scene.Generations - scene.History.Data[y][x]
-
-			switch scene.Grids[scene.Index].Data[y][x] {
-			case 1:
-				if age > 50 && scene.Config.ShowEvolution {
-					scene.World.DrawImage(scene.Tiles.Old, op)
-				} else {
-					scene.World.DrawImage(scene.Tiles.Black, op)
-				}
-			case 0:
-				if scene.History.Data[y][x] > 1 && scene.Config.ShowEvolution {
-					switch {
-					case age < 10:
-						scene.World.DrawImage(scene.Tiles.Age1, op)
-					case age < 20:
-						scene.World.DrawImage(scene.Tiles.Age2, op)
-					case age < 30:
-						scene.World.DrawImage(scene.Tiles.Age3, op)
-					default:
-						scene.World.DrawImage(scene.Tiles.Age4, op)
-					}
-				} else {
-					scene.World.DrawImage(scene.Tiles.White, op)
-				}
-			}
-		}
-	}
-
-	if scene.Markmode && scene.MarkTaken {
-		x := float32(scene.Mark.X * scene.Config.Cellsize)
-		y := float32(scene.Mark.Y * scene.Config.Cellsize)
-		w := float32((scene.Point.X - scene.Mark.X) * scene.Config.Cellsize)
-		h := float32((scene.Point.Y - scene.Mark.Y) * scene.Config.Cellsize)
-
-		// fmt.Printf("%d,%d=>%0.0f,%0.0f to %d,%d=>%0.0f,%0.0f\n",
-		// 	scene.Mark.X, scene.Mark.Y, x, y, scene.Point.X, scene.Point.Y, w, h)
-
-		vector.StrokeRect(
-			scene.World,
-			x+1, y+1,
-			w, h,
-			1.0, scene.Old, false,
-		)
-	}
-
-	scene.Camera.Render(scene.World, screen)
-
-	if scene.Config.Debug {
-		paused := ""
-		if scene.Paused {
-			paused = "-- paused --"
-		}
-
-		ebitenutil.DebugPrint(
-			screen,
-			fmt.Sprintf("FPS: %0.2f, TPG: %d, Mem: %0.2f MB, Generations: %d   %s",
-				ebiten.ActualTPS(), scene.TPG, GetMem(), scene.Generations, paused),
-		)
-	}
-}
-
-// FIXME: move these into Grid
-// load a pre-computed pattern from RLE file
-func (scene *ScenePlay) InitPattern() {
-	if scene.Config.RLE != nil {
-		startX := (scene.Config.Width / 2) - (scene.Config.RLE.Width / 2)
-		startY := (scene.Config.Height / 2) - (scene.Config.RLE.Height / 2)
-		var y, x int
-
-		for rowIndex, patternRow := range scene.Config.RLE.Pattern {
-			for colIndex := range patternRow {
-				if scene.Config.RLE.Pattern[rowIndex][colIndex] > 0 {
-					x = colIndex + startX
-					y = rowIndex + startY
-
-					scene.History.Data[y][x] = 1
-					scene.Grids[0].Data[y][x] = 1
-				}
-			}
-		}
-	}
-}
-
-func (scene *ScenePlay) InitGrid(grid *Grid) {
-	if grid != nil {
-		// use pre-loaded grid
-		scene.Grids = []*Grid{
-			grid,
-			NewGrid(grid.Width, grid.Height, 0, false),
-		}
-
-		scene.History = NewGrid(grid.Width, grid.Height, 0, false)
-
-		return
-	}
-
-	grida := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
-	gridb := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
-	history := NewGrid(scene.Config.Width, scene.Config.Height, scene.Config.Density, scene.Config.Empty)
-
-	for y := 0; y < scene.Config.Height; y++ {
-		if !scene.Config.Empty {
-			for x := 0; x < scene.Config.Width; x++ {
-				if rand.Intn(scene.Config.Density) == 1 {
-					history.Data[y][x] = 1
-					grida.Data[y][x] = 1
-				}
-			}
-		}
-	}
-
-	scene.Grids = []*Grid{
-		grida,
-		gridb,
-	}
-
-	scene.History = history
-}
-
-// prepare tile images
-func (scene *ScenePlay) InitTiles() {
-	scene.Grey = color.RGBA{128, 128, 128, 0xff}
-	scene.Old = color.RGBA{255, 30, 30, 0xff}
-
-	scene.Black = color.RGBA{0, 0, 0, 0xff}
-	scene.White = color.RGBA{200, 200, 200, 0xff}
-	scene.AgeColor1 = color.RGBA{255, 195, 97, 0xff} // FIXME: use slice!
-	scene.AgeColor2 = color.RGBA{255, 211, 140, 0xff}
-	scene.AgeColor3 = color.RGBA{255, 227, 181, 0xff}
-	scene.AgeColor4 = color.RGBA{255, 240, 224, 0xff}
-
-	if scene.Config.Invert {
-		scene.White = color.RGBA{0, 0, 0, 0xff}
-		scene.Black = color.RGBA{200, 200, 200, 0xff}
-
-		scene.AgeColor1 = color.RGBA{82, 38, 0, 0xff}
-		scene.AgeColor2 = color.RGBA{66, 35, 0, 0xff}
-		scene.AgeColor3 = color.RGBA{43, 27, 0, 0xff}
-		scene.AgeColor4 = color.RGBA{25, 17, 0, 0xff}
-	}
-
-	scene.Tiles.Black = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.White = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Old = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age1 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age2 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age3 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-	scene.Tiles.Age4 = ebiten.NewImage(scene.Config.Cellsize, scene.Config.Cellsize)
-
-	cellsize := scene.Config.ScreenWidth / scene.Config.Cellsize
-
-	FillCell(scene.Tiles.Black, cellsize, scene.Black)
-	FillCell(scene.Tiles.White, cellsize, scene.White)
-	FillCell(scene.Tiles.Old, cellsize, scene.Old)
-	FillCell(scene.Tiles.Age1, cellsize, scene.AgeColor1)
-	FillCell(scene.Tiles.Age2, cellsize, scene.AgeColor2)
-	FillCell(scene.Tiles.Age3, cellsize, scene.AgeColor3)
-	FillCell(scene.Tiles.Age4, cellsize, scene.AgeColor4)
-}
-
-func (scene *ScenePlay) Init() {
-	// setup the scene
-	var grid *Grid
-
-	if scene.Config.StateGrid != nil {
-		grid = scene.Config.StateGrid
-
-	}
-
-	scene.Camera = Camera{
-		ViewPort: f64.Vec2{
-			float64(scene.Config.ScreenWidth),
-			float64(scene.Config.ScreenHeight),
-		},
-	}
-
-	scene.World = ebiten.NewImage(scene.Config.ScreenWidth, scene.Config.ScreenHeight)
-
-	scene.InitGrid(grid)
-	scene.InitPattern()
-	scene.InitTiles()
-
-	scene.Index = 0
-	scene.TicksElapsed = 0
-
-	scene.LastCursorPos = make([]int, 2)
-}
-
-// count the living neighbors of a cell
-func (scene *ScenePlay) CountNeighbors(x, y int) int64 {
-	var sum int64
-
-	for nbgX := -1; nbgX < 2; nbgX++ {
-		for nbgY := -1; nbgY < 2; nbgY++ {
-			var col, row int
-			if scene.Config.Wrap {
-				// In wrap mode we look at all the 8 neighbors surrounding us.
-				// In case we are on an edge we'll look at the neighbor on the
-				//  other side  of the  grid, thus  wrapping lookahead  around
-				// using the mod() function.
-				col = (x + nbgX + scene.Config.Width) % scene.Config.Width
-				row = (y + nbgY + scene.Config.Height) % scene.Config.Height
-
-			} else {
-				// In traditional grid mode the edges are deadly
-				if x+nbgX < 0 || x+nbgX >= scene.Config.Width || y+nbgY < 0 || y+nbgY >= scene.Config.Height {
-					continue
-				}
-				col = x + nbgX
-				row = y + nbgY
-			}
-
-			sum += scene.Grids[scene.Index].Data[row][col]
-		}
-	}
-
-	// don't count ourselfes though
-	sum -= scene.Grids[scene.Index].Data[y][x]
-
-	return sum
-}
-
-// fill a cell with the given color
-func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
-	vector.DrawFilledRect(
-		tile,
-		float32(1),
-		float32(1),
-		float32(cellsize-1),
-		float32(cellsize-1),
-		col, false,
-	)
-}

scene.go

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

system.go

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