tuning fail

.gitignore

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

README.md

@@ -24,6 +24,7 @@ Based on: https://youtu.be/FWSR_7kZuYg?si=ix1dmo76D8AmF25F
 [![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

TODO.md

@@ -1,24 +1,30 @@
 - add all other options like size etc
 - add gif export
-- add toolbar
+- add toolbar (not working yet, see branch trackui)
-- turn input ifs to switch
 - only draw visible part of the world
-- use themes instead of the current weird color lists
 - print current mode to the bottom like pause, insert and mark
 - add https://www.ibiblio.org/lifepatterns/october1970.html
 - history: dont count age but do calc to get index to age tile based on cell age
 - maybe pre calc neighbors as 8 slice of pointers to neighboring cells to faster do the count
+  see various-tests/perf-2dim-pointers/: it's NOT faster :(
+- use an array of 8 pointers to neighbors. on edge just add either fake dead neighbors or the wrap around neighbors.
+- try arche ecs variant with either a component of the cells neighbors or using relations.
 - https://mattnakama.com/blog/go-branchless-coding/
 - add performance measurements, see:
   DrawTriangles: https://github.com/TLINDEN/testgol
   WritePixels:   https://github.com/TLINDEN/testgol/tree/wrpixels
 https://www.tasnimzotder.com/blog/optimizing-game-of-life-algorithm
-
+- pre-draw the grid separately to a cache grid image, then during
-- show gridlines menu has no effect of grid was enabled with -g
+  rendering, first draw the dead background, then the life cells, and
-
+  lastly the grid - if enabled. If disabled, there's be no gap between
+  the cells anymore.
 - Speed
   https://conwaylife.com/forums/viewtopic.php?f=7&t=3237
-  
+  Look at try-pointers-and-cells branch, we're using pre-calculated
+  neighbor list of pointers to cells, but it's only a liiiiitle bit
+  better :(
+
+
 - Patterns:
 
 A   Catagolue   textcensus   of,  say,   period-2   oscillators   from

go.mod

@@ -13,9 +13,10 @@ require (
 	github.com/ebitengine/gomobile v0.0.0-20240518074828-e86332849895 // indirect
 	github.com/ebitengine/hideconsole v1.0.0 // indirect
 	github.com/ebitengine/purego v0.7.0 // indirect
-	github.com/ebitenui/ebitenui v0.5.8-0.20240608230235-27496c28f409 // indirect
+	github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21 // indirect
 	github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 // indirect
 	github.com/jezek/xgb v1.1.1 // indirect
+	github.com/mlange-42/arche v0.13.0 // indirect
 	github.com/tinne26/etxt v0.0.8 // indirect
 	golang.org/x/exp v0.0.0-20240222234643-814bf88cf225 // indirect
 	golang.org/x/sync v0.7.0 // indirect

go.sum

@@ -10,14 +10,14 @@ github.com/ebitenui/ebitenui v0.5.6 h1:qyJRU5j+lQo1lamxB48IBwMxMfz1xNb5iWUayCtA0
 github.com/ebitenui/ebitenui v0.5.6/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
 github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21 h1:dElhYGyf+FYY+makAndUQNOSDwFSFYyFWziPwQrPObY=
 github.com/ebitenui/ebitenui v0.5.8-0.20240608175527-424f62327b21/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
-github.com/ebitenui/ebitenui v0.5.8-0.20240608230235-27496c28f409 h1:wsPobs+O3ZmZvhtNtmnMkaB1FRM7tuZ60P0/jegRQGg=
-github.com/ebitenui/ebitenui v0.5.8-0.20240608230235-27496c28f409/go.mod h1:I0rVbTOUi7gWKTPet2gzbvhOdkHp5pJXMM6c6b3dRoE=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0 h1:DACJavvAHhabrF08vX0COfcOBJRhZ8lUbR+ZWIs0Y5g=
 github.com/golang/freetype v0.0.0-20170609003504-e2365dfdc4a0/go.mod h1:E/TSTwGwJL78qG/PmXZO1EjYhfJinVAhrmmHX6Z8B9k=
 github.com/hajimehoshi/ebiten/v2 v2.7.4 h1:X+heODRQ3Ie9F9QFjm24gEZqQd5FSfR9XuT2XfHwgf8=
 github.com/hajimehoshi/ebiten/v2 v2.7.4/go.mod h1:H2pHVgq29rfm5yeQ7jzWOM3VHsjo7/AyucODNLOhsVY=
 github.com/jezek/xgb v1.1.1 h1:bE/r8ZZtSv7l9gk6nU0mYx51aXrvnyb44892TwSaqS4=
 github.com/jezek/xgb v1.1.1/go.mod h1:nrhwO0FX/enq75I7Y7G8iN1ubpSGZEiA3v9e9GyRFlk=
+github.com/mlange-42/arche v0.13.0 h1:ef0fu9qC2KIr8wIlVs+CgeQ5CSUJ8A1Hut6nXYdf+xk=
+github.com/mlange-42/arche v0.13.0/go.mod h1:bFktKnvGDj2kP01xar79z0hKwGHdnoaEZR8HWmJkIyU=
 github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
 github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
 github.com/tinne26/etxt v0.0.8 h1:rjb58jkMkapRGLmhBMWnT76E/nMTXC5P1Q956BRZkoc=

src/config.go

@@ -278,10 +278,8 @@ func (config *Config) SwitchTheme(theme string) {
 }
 
 func (config *Config) ToggleGridlines() {
-	fmt.Printf("toggle grid lines, current: %t\n", config.ShowGrid)
 	config.ShowGrid = !config.ShowGrid
 	config.RestartCache = true
-	fmt.Printf("toggle grid lines, new: %t\n", config.ShowGrid)
 }
 
 func (config *Config) ToggleEvolution() {

src/game.go

@@ -23,7 +23,6 @@ func NewGame(config *Config, startscene SceneName) *Game {
 	// setup scene[s]
 	game.CurrentScene = startscene
 	game.Scenes[Play] = NewPlayScene(game, config)
-	game.Scenes[Toolbar] = NewToolbarScene(game, config)
 	game.Scenes[Menu] = NewMenuScene(game, config)
 	game.Scenes[Options] = NewOptionsScene(game, config)
 	game.Scenes[Keybindings] = NewKeybindingsScene(game, config)
@@ -48,22 +47,16 @@ func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
 }
 
 func (game *Game) Update() error {
-	currentscene := game.GetCurrentScene()
+	scene := game.GetCurrentScene()
 
-	for _, scene := range game.Scenes {
+	if quit := scene.Update(); quit != nil {
-		if scene.IsPrimary() || scene == currentscene {
+		return quit
-			if quit := scene.Update(); quit != nil {
-				return quit
-			}
-
-		}
 	}
 
-	next := currentscene.GetNext()
+	next := scene.GetNext()
-
 	if next != game.CurrentScene {
 		game.Scenes[next].SetPrevious(game.CurrentScene)
-		currentscene.ResetNext()
+		scene.ResetNext()
 		game.CurrentScene = next
 	}
 
@@ -72,7 +65,6 @@ func (game *Game) Update() error {
 
 func (game *Game) Draw(screen *ebiten.Image) {
 	// first draw primary scene[s], although there are only 1
-	skip := false
 	for current, scene := range game.Scenes {
 		if scene.IsPrimary() {
 			// primary scenes always draw
@@ -80,16 +72,11 @@ func (game *Game) Draw(screen *ebiten.Image) {
 
 			if current == game.CurrentScene {
 				// avoid to redraw it in the next step
-				skip = true
+				return
-				break
 			}
 		}
 	}
 
-	if skip {
-		return
-	}
-
 	scene := game.GetCurrentScene()
 	scene.Draw(screen)
 }

src/menu.go

@@ -1,9 +1,7 @@
 package main
 
 import (
-	"fmt"
 	"image/color"
-	"os"
 
 	"github.com/ebitenui/ebitenui"
 	"github.com/ebitenui/ebitenui/widget"
@@ -20,6 +18,7 @@ type SceneMenu struct {
 	Ui        *ebitenui.UI
 	FontColor color.RGBA
 	First     bool
+	Exit      bool
 }
 
 func NewMenuScene(game *Game, config *Config) Scene {
@@ -55,6 +54,10 @@ func (scene *SceneMenu) SetNext(next SceneName) {
 func (scene *SceneMenu) Update() error {
 	scene.Ui.Update()
 
+	if scene.Exit {
+		return ebiten.Termination
+	}
+
 	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
 		scene.Config.DelayedStart = false
 		scene.Leave()
@@ -102,7 +105,6 @@ func (scene *SceneMenu) Init() {
 
 	options := NewMenuButton("Options",
 		func(args *widget.ButtonClickedEventArgs) {
-			fmt.Println("menu => options")
 			scene.SetNext(Options)
 		})
 
@@ -122,7 +124,7 @@ func (scene *SceneMenu) Init() {
 
 	quit := NewMenuButton("Exit Golsky",
 		func(args *widget.ButtonClickedEventArgs) {
-			os.Exit(0)
+			scene.Exit = true
 		})
 
 	rowContainer.AddChild(empty)

src/options.go

@@ -1,10 +1,8 @@
 package main
 
 import (
-	"fmt"
 	"image/color"
 
-	"github.com/alecthomas/repr"
 	"github.com/ebitenui/ebitenui"
 	"github.com/ebitenui/ebitenui/widget"
 	"github.com/hajimehoshi/ebiten/v2"
@@ -96,8 +94,6 @@ func (scene *SceneOptions) Init() {
 	gridlines := NewCheckbox("Show grid lines",
 		scene.Config.ShowGrid,
 		func(args *widget.CheckboxChangedEventArgs) {
-			fmt.Println("CHECKBOX CALLED")
-			repr.Println(args.State)
 			scene.Config.ToggleGridlines()
 		})
 

src/play.go

@@ -6,7 +6,6 @@ import (
 	"log"
 	"unsafe"
 
-	uiinput "github.com/ebitenui/ebitenui/input"
 	"github.com/hajimehoshi/ebiten/v2"
 	"github.com/hajimehoshi/ebiten/v2/inpututil"
 	"github.com/hajimehoshi/ebiten/v2/vector"
@@ -19,7 +18,7 @@ type Images struct {
 }
 
 const (
-	DEBUG_FORMAT = "FPS: %0.2f, TPG: %d, M: %0.2fMB, Generations: %d\nScale: %.02f, Zoom: %d, Cam: %.02f,%.02f Cursor: %d,%d  %s, UI Active: %t"
+	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 {
@@ -175,50 +174,40 @@ func (scene *ScenePlay) CheckExit() error {
 }
 
 func (scene *ScenePlay) CheckInput() {
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
+	// primary functions, always available
+	switch {
+	case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
 		scene.SetNext(Menu)
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyO):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyO) {
 		scene.SetNext(Options)
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyC):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyC) {
 		scene.Config.Markmode = true
 		scene.Config.Drawmode = false
 		scene.Config.Paused = true
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyI):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyI) {
 		scene.Config.Drawmode = true
 		scene.Config.Paused = true
 	}
 
 	if scene.Config.Markmode {
+		// no need to check any more input in mark mode
 		return
 	}
 
-	if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) {
+	switch {
+	case inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter):
 		scene.Config.TogglePaused()
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyPageDown):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageDown) {
 		if scene.TPG < 120 {
 			scene.TPG++
 		}
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyPageUp):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyPageUp) {
 		if scene.TPG >= 1 {
 			scene.TPG--
 		}
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyS):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyS) {
 		scene.SaveState()
-	}
+	case inpututil.IsKeyJustPressed(ebiten.KeyD):
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyD) {
 		scene.Config.Debug = !scene.Config.Debug
 	}
 
@@ -231,15 +220,12 @@ func (scene *ScenePlay) CheckInput() {
 
 func (scene *ScenePlay) CheckDrawingInput() {
 	if scene.Config.Drawmode {
-		if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) {
+		switch {
+		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft):
 			scene.ToggleCellOnCursorPos(Alive)
-		}
+		case ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight):
-
-		if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) {
 			scene.ToggleCellOnCursorPos(Dead)
-		}
+		case inpututil.IsKeyJustPressed(ebiten.KeyEscape):
-
-		if inpututil.IsKeyJustPressed(ebiten.KeyEscape) {
 			scene.Config.Drawmode = false
 		}
 	}
@@ -283,16 +269,14 @@ func (scene *ScenePlay) CheckDraggingInput() {
 	}
 
 	// also support the arrow keys to move the canvas
-	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) {
+	switch {
+	case ebiten.IsKeyPressed(ebiten.KeyArrowLeft):
 		scene.Camera.Position[0] -= 1
-	}
+	case ebiten.IsKeyPressed(ebiten.KeyArrowRight):
-	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) {
 		scene.Camera.Position[0] += 1
-	}
+	case ebiten.IsKeyPressed(ebiten.KeyArrowUp):
-	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) {
 		scene.Camera.Position[1] -= 1
-	}
+	case ebiten.IsKeyPressed(ebiten.KeyArrowDown):
-	if ebiten.IsKeyPressed(ebiten.KeyArrowDown) {
 		scene.Camera.Position[1] += 1
 	}
 
@@ -425,12 +409,11 @@ func (scene *ScenePlay) Update() error {
 		return quit
 	}
 
-	if !uiinput.UIActive {
+	scene.CheckInput()
-		scene.CheckInput()
+	scene.CheckDrawingInput()
-		scene.CheckDrawingInput()
+	scene.CheckDraggingInput()
-		scene.CheckDraggingInput()
+	scene.CheckMarkInput()
-		scene.CheckMarkInput()
+
-	}
 	if !scene.Config.Paused || scene.RunOneStep {
 		scene.UpdateCells()
 	}
@@ -484,9 +467,6 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
 	scene.Camera.Render(scene.World, screen)
 
 	scene.DrawDebug(screen)
-
-	// draw the toolbar directly from here, because otherwise it flickers
-	scene.Game.Scenes[Toolbar].Draw(screen)
 }
 
 func (scene *ScenePlay) DrawEvolution(screen *ebiten.Image, x, y int, op *ebiten.DrawImageOptions) {
@@ -554,7 +534,7 @@ func (scene *ScenePlay) DrawDebug(screen *ebiten.Image) {
 			scene.Game.Scale, scene.Camera.ZoomFactor,
 			scene.Camera.Position[0], scene.Camera.Position[1],
 			x, y,
-			paused, uiinput.UIActive)
+			paused)
 
 		FontRenderer.Renderer.SetSizePx(10 + int(scene.Game.Scale*10))
 		FontRenderer.Renderer.SetTarget(screen)

src/scene.go

@@ -25,5 +25,4 @@ const (
 	Play        // actual playing happens here
 	Options
 	Keybindings
-	Toolbar
 )

src/theme.go

@@ -38,32 +38,32 @@ var THEMES = map[string]ThemeDef{
 	"standard": {
 		life: "e15f0b",
 		dead: "5a5a5a",
+		old:  "ff1e1e",
 		grid: "808080",
-		old:  "7b5e4b",
 		age1: "735f52",
 		age2: "6c6059",
 		age3: "635d59",
-		age4: "808080",
+		age4: "7b5e4b",
 	},
 	"dark": {
 		life: "c8c8c8",
 		dead: "000000",
 		old:  "ff1e1e",
+		grid: "808080",
 		age1: "522600",
 		age2: "422300",
 		age3: "2b1b00",
 		age4: "191100",
-		grid: "808080",
 	},
 	"light": {
 		life: "000000",
 		dead: "c8c8c8",
 		old:  "ff1e1e",
+		grid: "808080",
 		age1: "ffc361",
 		age2: "ffd38c",
 		age3: "ffe3b5",
 		age4: "fff0e0",
-		grid: "808080",
 	},
 }
 

src/toolbar.go

@@ -1,95 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"image/color"
-
-	"github.com/ebitenui/ebitenui"
-	"github.com/ebitenui/ebitenui/widget"
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/inpututil"
-)
-
-type SceneToolbar struct {
-	Game      *Game
-	Config    *Config
-	Next      SceneName
-	Prev      SceneName
-	Whoami    SceneName
-	Ui        *ebitenui.UI
-	FontColor color.RGBA
-}
-
-func NewToolbarScene(game *Game, config *Config) Scene {
-	scene := &SceneToolbar{
-		Whoami:    Toolbar,
-		Game:      game,
-		Next:      Toolbar,
-		Config:    config,
-		FontColor: color.RGBA{255, 30, 30, 0xff},
-	}
-
-	scene.Init()
-
-	return scene
-}
-
-func (scene *SceneToolbar) GetNext() SceneName {
-	return scene.Next
-}
-
-func (scene *SceneToolbar) SetPrevious(prev SceneName) {
-	scene.Prev = prev
-}
-
-func (scene *SceneToolbar) ResetNext() {
-	scene.Next = scene.Whoami
-}
-
-func (scene *SceneToolbar) SetNext(next SceneName) {
-	scene.Next = next
-}
-
-func (scene *SceneToolbar) IsPrimary() bool {
-	return true
-}
-
-func (scene *SceneToolbar) Update() error {
-	scene.Ui.Update()
-
-	if inpututil.IsKeyJustPressed(ebiten.KeyEscape) || inpututil.IsKeyJustPressed(ebiten.KeyQ) {
-		scene.SetNext(Play)
-	}
-
-	return nil
-
-}
-
-func (scene *SceneToolbar) Draw(screen *ebiten.Image) {
-	scene.Ui.Draw(screen)
-}
-
-func (scene *SceneToolbar) SetInitialValue(w *widget.LabeledCheckbox, value bool) {
-	if value {
-		w.SetState(
-			widget.WidgetChecked,
-		)
-	}
-}
-
-func (scene *SceneToolbar) Init() {
-	rowContainer := NewTopRowContainer("Toolbar")
-
-	options := NewToolbarButton(Assets["options"],
-		func(args *widget.ButtonClickedEventArgs) {
-			fmt.Println("options")
-			scene.SetNext(Options)
-		})
-
-	rowContainer.AddChild(options)
-
-	scene.Ui = &ebitenui.UI{
-		Container: rowContainer.Container(),
-	}
-
-}

src/widgets.go

@@ -5,7 +5,6 @@ import (
 
 	"github.com/ebitenui/ebitenui/image"
 	"github.com/ebitenui/ebitenui/widget"
-	"github.com/hajimehoshi/ebiten/v2"
 )
 
 func NewMenuButton(
@@ -41,32 +40,6 @@ func NewMenuButton(
 	)
 }
 
-func NewToolbarButton(
-	icon *ebiten.Image,
-	action func(args *widget.ButtonClickedEventArgs)) *widget.Container {
-
-	buttonImage, _ := LoadButtonImage()
-
-	iconContainer := widget.NewContainer(
-		widget.ContainerOpts.Layout(widget.NewStackedLayout()),
-		widget.ContainerOpts.WidgetOpts(widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
-			HorizontalPosition: widget.AnchorLayoutPositionCenter,
-			VerticalPosition:   widget.AnchorLayoutPositionCenter,
-		})),
-	)
-
-	button := widget.NewButton(
-		widget.ButtonOpts.Image(buttonImage),
-		widget.ButtonOpts.ClickedHandler(action),
-	)
-
-	iconContainer.AddChild(button)
-
-	iconContainer.AddChild(widget.NewGraphic(widget.GraphicOpts.Image(icon)))
-
-	return iconContainer
-}
-
 func NewCheckbox(
 	text string,
 	initialvalue bool,
@@ -242,37 +215,6 @@ func (container *RowContainer) Container() *widget.Container {
 	return container.Root
 }
 
-// setup a top level toolbar container
-func NewTopRowContainer(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()),
-	)
-
-	rowContainer := widget.NewContainer(
-		widget.ContainerOpts.WidgetOpts(
-			widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
-				HorizontalPosition: widget.AnchorLayoutPositionStart,
-				VerticalPosition:   widget.AnchorLayoutPositionStart,
-			}),
-		),
-		widget.ContainerOpts.Layout(widget.NewRowLayout(
-			widget.RowLayoutOpts.Direction(widget.DirectionVertical),
-			widget.RowLayoutOpts.Padding(widget.NewInsetsSimple(8)),
-			widget.RowLayoutOpts.Spacing(0),
-		)),
-		widget.ContainerOpts.BackgroundImage(buttonImageHover),
-	)
-
-	uiContainer.AddChild(rowContainer)
-
-	return &RowContainer{
-		Root: uiContainer,
-		Row:  rowContainer,
-	}
-}
-
 // 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})

various-tests/README.md

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

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

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

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

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

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

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

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

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

various-tests/perf-ecs/go.mod

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

various-tests/perf-ecs/go.sum

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

various-tests/perf-ecs/main.go

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

various-tests/writepixel-pointers-int/go.mod

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

various-tests/writepixel-pointers-int/go.sum

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

various-tests/writepixel-pointers-int/main.go

@@ -0,0 +1,306 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"runtime/pprof"
+	"unsafe"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Cell struct {
+	State         uint8
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) uint8 {
+	var sum uint8
+
+	for idx := 0; idx < cell.NeighborCount; idx++ {
+		sum += cell.Neighbors[idx].State
+	}
+
+	return sum
+}
+
+func SetNeighbors(grid [][]*Cell, x, y, width, height int) {
+	idx := 0
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= width || y+nbgY < 0 || y+nbgY >= height {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			if col == x && row == y {
+				continue
+			}
+
+			grid[y][x].Neighbors[idx] = grid[row][col]
+			grid[y][x].NeighborCount++
+			idx++
+		}
+	}
+}
+
+type Grid struct {
+	Data                   [][]*Cell
+	Width, Height, Density int
+}
+
+// Create new empty grid and allocate Data according to provided dimensions
+func NewGrid(width, height, density int) *Grid {
+	grid := &Grid{
+		Height:  height,
+		Width:   width,
+		Density: density,
+		Data:    make([][]*Cell, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]*Cell, width)
+		for x := 0; x < width; x++ {
+			grid.Data[y][x] = &Cell{}
+
+			if rand.Intn(density) == 1 {
+				grid.Data[y][x].State = 1
+			}
+		}
+	}
+
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			SetNeighbors(grid.Data, x, y, width, height)
+		}
+	}
+
+	return grid
+}
+
+type Game struct {
+	Width, Height, Cellsize, Density int
+	ScreenWidth, ScreenHeight        int
+	Grids                            []*Grid
+	Index                            int
+	Elapsed                          int64
+	TPG                              int64 // adjust game speed independently of TPS
+	Pause, Debug, Profile, Gridlines bool
+	Pixels                           []byte
+	OffScreen                        *ebiten.Image
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+// live console output of the grid
+func (game *Game) DebugDump() {
+	cmd := exec.Command("clear")
+	cmd.Stdout = os.Stdout
+	cmd.Run()
+
+	if game.Debug {
+		for y := 0; y < game.Height; y++ {
+			for x := 0; x < game.Width; x++ {
+				if game.Grids[game.Index].Data[y][x].State == 1 {
+					fmt.Print("XX")
+				} else {
+					fmt.Print("  ")
+				}
+			}
+			fmt.Println()
+		}
+	}
+	fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
+}
+
+func (game *Game) Init() {
+	// setup two grids, one for display, one for next state
+	grida := NewGrid(game.Width, game.Height, game.Density)
+	gridb := NewGrid(game.Width, game.Height, game.Density)
+
+	game.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	game.Pixels = make([]byte, game.ScreenWidth*game.ScreenHeight*4)
+
+	game.OffScreen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+}
+
+// count the living neighbors of a cell
+func (game *Game) CountNeighbors(x, y int) uint8 {
+	return game.Grids[game.Index].Data[y][x].Count(x, y)
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state uint8, neighbors uint8) uint8 {
+	var nextstate uint8
+
+	if state == 1 && neighbors == 3 {
+		nextstate = 1
+	} else if state == 1 && (neighbors == 2 || neighbors == 3) {
+		nextstate = 1
+	} else {
+		nextstate = 0
+	}
+
+	return nextstate
+}
+
+// we only  update the cells if  we are not  in pause state or  if the
+// game timer (TPG) is elapsed.
+func (game *Game) UpdateCells() {
+	if game.Pause {
+		return
+	}
+
+	if game.Elapsed < game.TPG {
+		game.Elapsed++
+		return
+	}
+
+	// next grid index. we only have to, so we just xor it
+	next := game.Index ^ 1
+
+	// calculate cell life state, this is the actual game of life
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			state := game.Grids[game.Index].Data[y][x].State
+			neighbors := game.CountNeighbors(x, y)
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x].State = nextstate
+		}
+	}
+
+	// switch grid for rendering
+	game.Index ^= 1
+
+	game.Elapsed = 0
+
+	game.UpdatePixels()
+}
+
+func (game *Game) Update() error {
+	game.UpdateCells()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
+		game.Pause = !game.Pause
+	}
+
+	return nil
+}
+
+/*
+*
+r, g, b := color(it)
+
+	78             p := 4 * (i + j*screenWidth)
+	79             gm.offscreenPix[p] = r
+	80             gm.offscreenPix[p+1] = g
+	81             gm.offscreenPix[p+2] = b
+	82             gm.offscreenPix[p+3] = 0xff
+*/
+func (game *Game) UpdatePixels() {
+	var col byte
+
+	gridx := 0
+	gridy := 0
+	idx := 0
+
+	for y := 0; y < game.ScreenHeight; y++ {
+		for x := 0; x < game.ScreenWidth; x++ {
+			gridx = x / game.Cellsize
+			gridy = y / game.Cellsize
+
+			col = 0xff
+			if game.Grids[game.Index].Data[gridy][gridx].State == 1 {
+				col = 0x0
+			}
+
+			if game.Gridlines {
+				if x%game.Cellsize == 0 || y%game.Cellsize == 0 {
+					col = 128
+				}
+			}
+
+			idx = 4 * (x + y*game.ScreenWidth)
+
+			game.Pixels[idx] = col
+			game.Pixels[idx+1] = col
+			game.Pixels[idx+2] = col
+			game.Pixels[idx+3] = 0xff
+
+			idx++
+		}
+	}
+
+	game.OffScreen.WritePixels(game.Pixels)
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	screen.DrawImage(game.OffScreen, nil)
+	game.DebugDump()
+}
+
+func main() {
+	size := 1500
+
+	game := &Game{
+		Width:     size,
+		Height:    size,
+		Cellsize:  4,
+		Density:   8,
+		TPG:       10,
+		Debug:     false,
+		Profile:   true,
+		Gridlines: false,
+	}
+
+	game.ScreenWidth = game.Width * game.Cellsize
+	game.ScreenHeight = game.Height * game.Cellsize
+
+	game.Init()
+
+	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
+	ebiten.SetWindowTitle("triangle conway's game of life")
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+
+	if game.Profile {
+		fd, err := os.Create("cpu.profile")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer fd.Close()
+
+		pprof.StartCPUProfile(fd)
+		defer pprof.StopCPUProfile()
+	}
+
+	if err := ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}

various-tests/writepixel-pointers/go.mod

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

various-tests/writepixel-pointers/go.sum

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

various-tests/writepixel-pointers/main.go

@@ -0,0 +1,306 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"math/rand"
+	"os"
+	"os/exec"
+	"runtime/pprof"
+	"unsafe"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type Images struct {
+	Black, White *ebiten.Image
+}
+
+type Cell struct {
+	State         bool
+	Neighbors     [8]*Cell
+	NeighborCount int
+}
+
+func bool2int(b bool) int {
+	return int(*(*byte)(unsafe.Pointer(&b)))
+}
+
+func (cell *Cell) Count(x, y int) int {
+	sum := 0
+
+	for idx := 0; idx < cell.NeighborCount; idx++ {
+		sum += bool2int(cell.Neighbors[idx].State)
+	}
+
+	return sum
+}
+
+func SetNeighbors(grid [][]*Cell, x, y, width, height int) {
+	idx := 0
+	for nbgX := -1; nbgX < 2; nbgX++ {
+		for nbgY := -1; nbgY < 2; nbgY++ {
+			var col, row int
+
+			if x+nbgX < 0 || x+nbgX >= width || y+nbgY < 0 || y+nbgY >= height {
+				continue
+			}
+
+			col = x + nbgX
+			row = y + nbgY
+
+			if col == x && row == y {
+				continue
+			}
+
+			grid[y][x].Neighbors[idx] = grid[row][col]
+			grid[y][x].NeighborCount++
+			idx++
+		}
+	}
+}
+
+type Grid struct {
+	Data                   [][]*Cell
+	Width, Height, Density int
+}
+
+// Create new empty grid and allocate Data according to provided dimensions
+func NewGrid(width, height, density int) *Grid {
+	grid := &Grid{
+		Height:  height,
+		Width:   width,
+		Density: density,
+		Data:    make([][]*Cell, height),
+	}
+
+	for y := 0; y < height; y++ {
+		grid.Data[y] = make([]*Cell, width)
+		for x := 0; x < width; x++ {
+			grid.Data[y][x] = &Cell{}
+
+			if rand.Intn(density) == 1 {
+				grid.Data[y][x].State = true
+			}
+		}
+	}
+
+	for y := 0; y < height; y++ {
+		for x := 0; x < width; x++ {
+			SetNeighbors(grid.Data, x, y, width, height)
+		}
+	}
+
+	return grid
+}
+
+type Game struct {
+	Width, Height, Cellsize, Density int
+	ScreenWidth, ScreenHeight        int
+	Grids                            []*Grid
+	Index                            int
+	Elapsed                          int64
+	TPG                              int64 // adjust game speed independently of TPS
+	Pause, Debug, Profile, Gridlines bool
+	Pixels                           []byte
+	OffScreen                        *ebiten.Image
+}
+
+func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return game.ScreenWidth, game.ScreenHeight
+}
+
+// live console output of the grid
+func (game *Game) DebugDump() {
+	cmd := exec.Command("clear")
+	cmd.Stdout = os.Stdout
+	cmd.Run()
+
+	if game.Debug {
+		for y := 0; y < game.Height; y++ {
+			for x := 0; x < game.Width; x++ {
+				if game.Grids[game.Index].Data[y][x].State {
+					fmt.Print("XX")
+				} else {
+					fmt.Print("  ")
+				}
+			}
+			fmt.Println()
+		}
+	}
+	fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
+}
+
+func (game *Game) Init() {
+	// setup two grids, one for display, one for next state
+	grida := NewGrid(game.Width, game.Height, game.Density)
+	gridb := NewGrid(game.Width, game.Height, game.Density)
+
+	game.Grids = []*Grid{
+		grida,
+		gridb,
+	}
+
+	game.Pixels = make([]byte, game.ScreenWidth*game.ScreenHeight*4)
+
+	game.OffScreen = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
+}
+
+// count the living neighbors of a cell
+func (game *Game) CountNeighbors(x, y int) int {
+	return game.Grids[game.Index].Data[y][x].Count(x, y)
+}
+
+// the heart of the game
+func (game *Game) CheckRule(state bool, neighbors int) bool {
+	var nextstate bool
+
+	if state && neighbors == 3 {
+		nextstate = true
+	} else if state && (neighbors == 2 || neighbors == 3) {
+		nextstate = true
+	} else {
+		nextstate = false
+	}
+
+	return nextstate
+}
+
+// we only  update the cells if  we are not  in pause state or  if the
+// game timer (TPG) is elapsed.
+func (game *Game) UpdateCells() {
+	if game.Pause {
+		return
+	}
+
+	if game.Elapsed < game.TPG {
+		game.Elapsed++
+		return
+	}
+
+	// next grid index. we only have to, so we just xor it
+	next := game.Index ^ 1
+
+	// calculate cell life state, this is the actual game of life
+	for y := 0; y < game.Height; y++ {
+		for x := 0; x < game.Width; x++ {
+			state := game.Grids[game.Index].Data[y][x].State
+			neighbors := game.CountNeighbors(x, y)
+
+			// actually apply the current rules
+			nextstate := game.CheckRule(state, neighbors)
+
+			// change state of current cell in next grid
+			game.Grids[next].Data[y][x].State = nextstate
+		}
+	}
+
+	// switch grid for rendering
+	game.Index ^= 1
+
+	game.Elapsed = 0
+
+	game.UpdatePixels()
+}
+
+func (game *Game) Update() error {
+	game.UpdateCells()
+
+	if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
+		game.Pause = !game.Pause
+	}
+
+	return nil
+}
+
+/*
+*
+r, g, b := color(it)
+
+	78             p := 4 * (i + j*screenWidth)
+	79             gm.offscreenPix[p] = r
+	80             gm.offscreenPix[p+1] = g
+	81             gm.offscreenPix[p+2] = b
+	82             gm.offscreenPix[p+3] = 0xff
+*/
+func (game *Game) UpdatePixels() {
+	var col byte
+
+	gridx := 0
+	gridy := 0
+	idx := 0
+
+	for y := 0; y < game.ScreenHeight; y++ {
+		for x := 0; x < game.ScreenWidth; x++ {
+			gridx = x / game.Cellsize
+			gridy = y / game.Cellsize
+
+			col = 0xff
+			if game.Grids[game.Index].Data[gridy][gridx].State {
+				col = 0x0
+			}
+
+			if game.Gridlines {
+				if x%game.Cellsize == 0 || y%game.Cellsize == 0 {
+					col = 128
+				}
+			}
+
+			idx = 4 * (x + y*game.ScreenWidth)
+
+			game.Pixels[idx] = col
+			game.Pixels[idx+1] = col
+			game.Pixels[idx+2] = col
+			game.Pixels[idx+3] = 0xff
+
+			idx++
+		}
+	}
+
+	game.OffScreen.WritePixels(game.Pixels)
+}
+
+func (game *Game) Draw(screen *ebiten.Image) {
+	screen.DrawImage(game.OffScreen, nil)
+	game.DebugDump()
+}
+
+func main() {
+	size := 1500
+
+	game := &Game{
+		Width:     size,
+		Height:    size,
+		Cellsize:  4,
+		Density:   8,
+		TPG:       10,
+		Debug:     false,
+		Profile:   true,
+		Gridlines: false,
+	}
+
+	game.ScreenWidth = game.Width * game.Cellsize
+	game.ScreenHeight = game.Height * game.Cellsize
+
+	game.Init()
+
+	ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
+	ebiten.SetWindowTitle("triangle conway's game of life")
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+
+	if game.Profile {
+		fd, err := os.Create("cpu.profile")
+		if err != nil {
+			log.Fatal(err)
+		}
+		defer fd.Close()
+
+		pprof.StartCPUProfile(fd)
+		defer pprof.StopCPUProfile()
+	}
+
+	if err := ebiten.RunGame(game); err != nil {
+		log.Fatal(err)
+	}
+}

various-tests/writepixel/main.go

@@ -238,35 +238,7 @@ func (game *Game) Draw(screen *ebiten.Image) {
 }
 
 func main() {
-	//x := 1
+	size := 1500
-	//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)
-
-	a := 1
-	b := 1
-	//gen := 100
-	hist := 0
-	for gen := 0; gen < 50; gen++ {
-		fmt.Println((a ^ (1 ^ b)) * (gen - hist))
-		if gen == 25 {
-			a = 0
-		}
-	}
-}
-
-func _main() {
-	size := 800
 
 	game := &Game{
 		Width:     size,
@@ -275,7 +247,7 @@ func _main() {
 		Density:   8,
 		TPG:       10,
 		Debug:     false,
-		Profile:   false,
+		Profile:   true,
 		Gridlines: false,
 	}