diff --git a/README.md b/README.md new file mode 100644 index 0000000..74302dc --- /dev/null +++ b/README.md @@ -0,0 +1,56 @@ +# Conway's game of life + +I wanted to play around a little bit with GOL in golang and here's the +result. It's a simple game using +[ebitengine](https://github.com/hajimehoshi/ebiten/). + +# Build and install + +Just execute: `go build .` and use the resulting executable. + +You'll need the golang toolchain. + +# Usage + +The game has a couple of commandline options: + +```default + +Usage of ./gameoflife: + -c, --cellsize int cell size in pixels (default 8) + -d, --debug show debug info + -D, --density int density of random cells (default 10) + -e, --empty start with an empty screen + -H, --height int grid height in cells (default 40) + -i, --invert invert colors (dead cell: black) + -r, --rule string game rule (default "B3/S23") + -s, --show-evolution show evolution tracks + -t, --tps int game speed in ticks per second (default 60) + -v, --version show version + -W, --width int grid width in cells (default 40) +``` + +While it runs, there are a couple of commands you can use: + +* left mouse click: set a cell to alife +* right mouse click: set a cell to dead +* space: pause or resume the game +* q: quit +* up arrow: speed up +* down arrow: slow down +* page up: speed up more +* page down: slow down more + +# Report bugs + +[Please open an issue](https://github.com/TLINDEN/gameoflife/issues). Thanks! + +# License + +This work is licensed under the terms of the General Public Licens +version 3. + +# Author + +Copyleft (c) 2024 Thomas von Dein + diff --git a/TODO.md b/TODO.md new file mode 100644 index 0000000..84bbb86 --- /dev/null +++ b/TODO.md @@ -0,0 +1,9 @@ +https://conwaylife.com/wiki/Run_Length_Encoded + +e.g.: +https://github.com/nhoffmann/life/tree/master/rle +https://github.com/sachaos/go-life/tree/master/format/rle + +rle files: +https://catagolue.hatsya.com/object/xq2_32mmgozg0igke72z1n2q1z0qgm1z31i2bsogzggqq261z1/b3s23 +https://copy.sh/life/examples/ diff --git a/go.mod b/go.mod index 410cbde..015bda3 100644 --- a/go.mod +++ b/go.mod @@ -2,14 +2,21 @@ module gameoflife go 1.22 -require github.com/hajimehoshi/ebiten/v2 v2.7.3 +require ( + github.com/hajimehoshi/ebiten/v2 v2.7.4 + github.com/spf13/pflag v1.0.5 + github.com/tinne26/etxt v0.0.8 + github.com/tinne26/fonts/liberation/lbrtserif v0.0.0-20230317183620-0b634734e4ec +) require ( github.com/alecthomas/repr v0.4.0 // indirect - github.com/ebitengine/gomobile v0.0.0-20240329170434-1771503ff0a8 // 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.6.0 // indirect - golang.org/x/sys v0.18.0 // indirect + golang.org/x/image v0.16.0 // indirect + golang.org/x/sync v0.7.0 // indirect + golang.org/x/sys v0.20.0 // indirect + golang.org/x/text v0.15.0 // indirect ) diff --git a/go.sum b/go.sum index a27cc0a..e63d56e 100644 --- a/go.sum +++ b/go.sum @@ -1,18 +1,26 @@ 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-20240329170434-1771503ff0a8 h1:5e8X7WEdOWrjrKvgaWF6PRnDvJicfrkEnwAkWtMN74g= -github.com/ebitengine/gomobile v0.0.0-20240329170434-1771503ff0a8/go.mod h1:tWboRRNagZwwwis4QIgEFG1ZNFwBJ3LAhSLAXAAxobQ= +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.3 h1:lDpj8KbmmjzwD19rsjXNkyelicu0XGvklZW6/tjrgNs= -github.com/hajimehoshi/ebiten/v2 v2.7.3/go.mod h1:1vjyPw+h3n30rfTOpIsbWRXSxZ0Oz1cYc6Tq/2DKoQg= +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/image v0.15.0 h1:kOELfmgrmJlw4Cdb7g/QGuB3CvDrXbqEIww/pNtNBm8= -golang.org/x/image v0.15.0/go.mod h1:HUYqC05R2ZcZ3ejNQsIHQDQiwWM4JBqmm6MKANTp4LE= -golang.org/x/sync v0.6.0 h1:5BMeUDZ7vkXGfEr1x9B4bRcTH4lpkTkpdh0T/J+qjbQ= -golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= -golang.org/x/sys v0.18.0 h1:DBdB3niSjOA/O0blCZBqDefyWNYveAYMNF1Wum0DYQ4= -golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA= +github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg= +github.com/tinne26/etxt v0.0.8 h1:rjb58jkMkapRGLmhBMWnT76E/nMTXC5P1Q956BRZkoc= +github.com/tinne26/etxt v0.0.8/go.mod h1:QM/hlNkstsKC39elTFNKAR34xsMb9QoVosf+g9wlYxM= +github.com/tinne26/fonts/liberation/lbrtserif v0.0.0-20230317183620-0b634734e4ec h1:CUSt85il4uQxLjlVhup44P7gpaZmkYooIHmCLjq85vg= +github.com/tinne26/fonts/liberation/lbrtserif v0.0.0-20230317183620-0b634734e4ec/go.mod h1:4BN4bFDBeF9+E97yjko9Pe7x8WgY4Ek6oiOYa1KDgpE= +golang.org/x/image v0.16.0 h1:9kloLAKhUufZhA12l5fwnx2NZW39/we1UhBesW433jw= +golang.org/x/image v0.16.0/go.mod h1:ugSZItdV4nOxyqp56HmXwH0Ry0nBCpjnZdpDaIHdoPs= +golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= +golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sys v0.20.0 h1:Od9JTbYCk261bKm4M/mw7AklTlFYIa0bIp9BgSm1S8Y= +golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/text v0.15.0 h1:h1V/4gjBv8v9cjcR6+AR5+/cIYK5N/WAgiv4xlsEtAk= +golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU= diff --git a/main.go b/main.go index 9f2df34..8954e71 100644 --- a/main.go +++ b/main.go @@ -1,12 +1,26 @@ package main import ( + "fmt" "image/color" "log" "math/rand" + "os" + "strconv" + "strings" + "github.com/alecthomas/repr" "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/spf13/pflag" +) + +const ( + VERSION = "v0.0.1" + Alive = 1 + Dead = 0 ) type Grid struct { @@ -14,18 +28,54 @@ type Grid struct { } type Game struct { - Grids []*Grid // 2 grids: one current, one next - Index int // points to current grid - Width, Height, Cellsize int - ScreenWidth, ScreenHeight int - Black, White color.RGBA + Grids []*Grid // 2 grids: one current, one next + History *Grid + Index int // points to current grid + Width, Height, Cellsize, Density int + ScreenWidth, ScreenHeight int + Generations int + Black, White, Grey, Beige color.RGBA + Speed int + Debug, Paused, Empty, Invert, ShowEvolution bool + Rule *Rule } func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) { return game.ScreenWidth, game.ScreenHeight } -func (game *Game) Update() error { +func (game *Game) CheckRule(state, neighbors int) int { + var nextstate int + + // The standard Game 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(game.Rule.Birth, neighbors) { + nextstate = 1 + } else if state == 1 && Contains(game.Rule.Death, neighbors) { + nextstate = 1 + } else { + nextstate = 0 + } + + return nextstate +} + +// 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 +} + +func (game *Game) UpdateCells() { // compute cells next := game.Index ^ 1 // next grid index, we just xor 0|1 to 1|0 @@ -33,62 +83,191 @@ func (game *Game) Update() error { for x := 0; x < game.Width; x++ { state := game.Grids[game.Index].Data[y][x] // 0|1 == dead or alive neighbors := CountNeighbors(game, x, y) // alive neighbor count - var nextstate int - // the actual game of life rules - if state == 0 && neighbors == 3 { - nextstate = 1 - } else if state == 1 && (neighbors < 2 || neighbors > 3) { - nextstate = 0 - } else { - nextstate = state - } + // actually apply the current rules + nextstate := game.CheckRule(state, neighbors) // change state of current cell in next grid game.Grids[next].Data[y][x] = nextstate + + if state == 1 { + game.History.Data[y][x] = 1 + } } } // switch grid for rendering game.Index ^= 1 + // global counter + game.Generations++ +} + +// a GOL rule +type Rule struct { + Birth []int + Death []int +} + +// parse one part of a GOL rule into rule slice +func NumbersToList(numbers string) []int { + list := []int{} + + items := strings.Split(numbers, "") + for _, item := range items { + num, err := strconv.Atoi(item) + 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{} + + for _, part := range parts { + if part[0] == 'B' { + golrule.Birth = NumbersToList(part[1:]) + } else { + golrule.Death = NumbersToList(part[1:]) + } + } + + return golrule +} + +// check user input +func (game *Game) CheckInput() { + if inpututil.IsKeyJustPressed(ebiten.KeyQ) { + os.Exit(0) + } + + if inpututil.IsKeyJustPressed(ebiten.KeySpace) || inpututil.IsKeyJustPressed(ebiten.KeyEnter) { + game.Paused = !game.Paused + } + + if ebiten.IsMouseButtonPressed(ebiten.MouseButtonLeft) { + ToggleCell(game, Alive) + game.Paused = true // drawing while running makes no sense + } + + if ebiten.IsMouseButtonPressed(ebiten.MouseButtonRight) { + ToggleCell(game, Dead) + game.Paused = true // drawing while running makes no sense + } + + if inpututil.IsKeyJustPressed(ebiten.KeyArrowDown) { + if game.Speed > 1 { + game.Speed-- + ebiten.SetTPS(game.Speed) + } + } + + if inpututil.IsKeyJustPressed(ebiten.KeyArrowUp) { + if game.Speed < 120 { + game.Speed++ + ebiten.SetTPS(game.Speed) + } + } + + if inpututil.IsKeyJustPressed(ebiten.KeyPageDown) { + switch { + case game.Speed > 5: + game.Speed -= 5 + case game.Speed <= 5: + game.Speed = 1 + } + + ebiten.SetTPS(game.Speed) + } + + if inpututil.IsKeyJustPressed(ebiten.KeyPageUp) { + if game.Speed <= 115 { + game.Speed += 5 + ebiten.SetTPS(game.Speed) + } + } +} + +func (game *Game) Update() error { + game.CheckInput() + + if !game.Paused { + game.UpdateCells() + } + return nil } +// fill a cell with the given color +func FillCell(screen *ebiten.Image, x, y, cellsize int, col color.RGBA) { + vector.DrawFilledRect( + screen, + float32(x*cellsize+1), + float32(y*cellsize+1), + float32(cellsize-1), + float32(cellsize-1), + col, false, + ) +} + +// set a cell to alive or dead +func ToggleCell(game *Game, alive int) { + xPX, yPX := ebiten.CursorPosition() + x := xPX / game.Cellsize + y := yPX / game.Cellsize + + //fmt.Printf("cell at %d,%d\n", x, y) + + game.Grids[game.Index].Data[y][x] = alive + game.History.Data[y][x] = 1 +} + +// draw the new grid state func (game *Game) 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 + screen.Fill(game.Grey) + for y := 0; y < game.Height; y++ { for x := 0; x < game.Width; x++ { - currentcolor := game.White - if game.Grids[game.Index].Data[y][x] == 1 { - currentcolor = game.Black - } - - vector.DrawFilledRect(screen, - float32(x*game.Cellsize), - float32(y*game.Cellsize), - float32(game.Cellsize), - float32(game.Cellsize), - currentcolor, false) - - if currentcolor == game.White { - // draw black - vector.DrawFilledRect(screen, - float32(x*game.Cellsize), - float32(y*game.Cellsize), - float32(game.Cellsize), - float32(game.Cellsize), - game.Black, false) - // then fill with 1px lesser rect in white - // thus creating grid lines - vector.DrawFilledRect(screen, - float32(x*game.Cellsize+1), - float32(y*game.Cellsize+1), - float32(game.Cellsize-1), - float32(game.Cellsize-1), - game.White, false) + switch game.Grids[game.Index].Data[y][x] { + case 1: + FillCell(screen, x, y, game.Cellsize, game.Black) + case 0: + if game.History.Data[y][x] == 1 && game.ShowEvolution { + FillCell(screen, x, y, game.Cellsize, game.Beige) + } else { + FillCell(screen, x, y, game.Cellsize, game.White) + } } } } + + if game.Debug { + paused := "" + if game.Paused { + paused = "-- paused --" + } + + ebitenutil.DebugPrint( + screen, + fmt.Sprintf("FPS: %d, Generations: %d %s", + game.Speed, game.Generations, paused), + ) + } } func (game *Game) Init() { @@ -98,12 +277,19 @@ func (game *Game) Init() { grid := &Grid{Data: make([][]int, game.Height)} gridb := &Grid{Data: make([][]int, game.Height)} + history := &Grid{Data: make([][]int, game.Height)} for y := 0; y < game.Height; y++ { grid.Data[y] = make([]int, game.Width) gridb.Data[y] = make([]int, game.Width) - for x := 0; x < game.Width; x++ { - grid.Data[y][x] = rand.Intn(2) + history.Data[y] = make([]int, game.Width) + if !game.Empty { + for x := 0; x < game.Width; x++ { + if rand.Intn(game.Density) == 1 { + history.Data[y][x] = 1 + grid.Data[y][x] = 1 + } + } } } @@ -112,12 +298,23 @@ func (game *Game) Init() { gridb, } + game.History = history + game.Black = color.RGBA{0, 0, 0, 0xff} - game.White = color.RGBA{0xff, 0xff, 0xff, 0xff} + game.White = color.RGBA{200, 200, 200, 0xff} + game.Grey = color.RGBA{128, 128, 128, 0xff} + game.Beige = color.RGBA{0xff, 0xf8, 0xdc, 0xff} + + if game.Invert { + game.White = color.RGBA{0, 0, 0, 0xff} + game.Black = color.RGBA{200, 200, 200, 0xff} + game.Beige = color.RGBA{0x8b, 0x1a, 0x1a, 0xff} + } game.Index = 0 } +// count the living neighbors of a cell func CountNeighbors(game *Game, x, y int) int { sum := 0 @@ -139,15 +336,41 @@ func CountNeighbors(game *Game, x, y int) int { } func main() { - game := &Game{Width: 180, Height: 160, Cellsize: 15} + game := &Game{} + showversion := false + var rule string + + pflag.IntVarP(&game.Width, "width", "W", 40, "grid width in cells") + pflag.IntVarP(&game.Height, "height", "H", 40, "grid height in cells") + pflag.IntVarP(&game.Cellsize, "cellsize", "c", 8, "cell size in pixels") + pflag.IntVarP(&game.Speed, "tps", "t", 60, "game speed in ticks per second") + pflag.IntVarP(&game.Density, "density", "D", 10, "density of random cells") + pflag.StringVarP(&rule, "rule", "r", "B3/S23", "game rule") + pflag.BoolVarP(&showversion, "version", "v", false, "show version") + pflag.BoolVarP(&game.Debug, "debug", "d", false, "show debug info") + pflag.BoolVarP(&game.Empty, "empty", "e", false, "start with an empty screen") + pflag.BoolVarP(&game.Invert, "invert", "i", false, "invert colors (dead cell: black)") + pflag.BoolVarP(&game.ShowEvolution, "show-evolution", "s", false, "show evolution tracks") + + pflag.Parse() + + if showversion { + fmt.Printf("This is gameoflife version %s\n", VERSION) + os.Exit(0) + } + + game.Rule = ParseGameRule(rule) + + repr.Print(game.Rule.Birth) + repr.Print(game.Rule.Death) game.Init() ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight) ebiten.SetWindowTitle("Game of life") - ebiten.SetTPS(30) + ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled) + ebiten.SetTPS(game.Speed) if err := ebiten.RunGame(game); err != nil { log.Fatal(err) } - }