scip/golsky
1
0
Fork 0
mirror of https://codeberg.org/scip/golsky.git synced 2025-12-16 20:20:57 +01:00
Code Issues Packages Projects Releases Wiki Activity

use cells instead of only bools, use pointer list to all neighbors

Browse Source
This commit is contained in:
Thomas von Dein
2024-06-14 17:53:58 +02:00
parent 45e5fc7e3b
commit c7be9ab3ee
2 changed files with 97 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

111
src/grid.go
View File

@@ -12,35 +12,100 @@ import (
"github.com/tlinden/golsky/rle"
)
type Cell struct {
State bool
Neighbors [8]*Cell
NeighborCount int
}
func (cell *Cell) Count() int {
count := 0
for idx := 0; idx < cell.NeighborCount; idx++ {
count += bool2int(cell.Neighbors[idx].State)
}
return count
}
type Grid struct {
Data [][]bool
Width, Height, Density int
Empty bool
Data [][]*Cell
Empty bool
Config *Config
}
// Create new empty grid and allocate Data according to provided dimensions
func NewGrid(width, height, density int, empty bool) *Grid {
func NewGrid(config *Config) *Grid {
grid := &Grid{
Height: height,
Width: width,
Density: density,
Data: make([][]bool, height),
Empty: empty,
Data: make([][]*Cell, config.Height),
Empty: config.Empty,
Config: config,
}
for y := 0; y < height; y++ {
grid.Data[y] = make([]bool, width)
// first setup the cells
for y := 0; y < config.Height; y++ {
grid.Data[y] = make([]*Cell, config.Width)
for x := 0; x < config.Width; x++ {
grid.Data[y][x] = &Cell{}
}
}
// in a second pass, collect pointers to the neighbors of each cell
for y := 0; y < config.Height; y++ {
for x := 0; x < config.Width; x++ {
grid.SetupNeighbors(x, y)
}
}
return grid
}
func (grid *Grid) SetupNeighbors(x, y int) {
idx := 0
for nbgY := -1; nbgY < 2; nbgY++ {
for nbgX := -1; nbgX < 2; nbgX++ {
var col, row int
if grid.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 + grid.Config.Width) % grid.Config.Width
row = (y + nbgY + grid.Config.Height) % grid.Config.Height
} else {
// In traditional grid mode the edges are deadly
if x+nbgX < 0 || x+nbgX >= grid.Config.Width || y+nbgY < 0 || y+nbgY >= grid.Config.Height {
continue
}
col = x + nbgX
row = y + nbgY
}
if col == x && row == y {
continue
}
grid.Data[y][x].Neighbors[idx] = grid.Data[row][col]
grid.Data[y][x].NeighborCount++
idx++
}
}
}
// count the living neighbors of a cell
func (grid *Grid) CountNeighbors(x, y int) int {
return grid.Data[y][x].Count()
}
// Create a new 1:1 instance
func (grid *Grid) Clone() *Grid {
newgrid := &Grid{}
newgrid.Width = grid.Width
newgrid.Height = grid.Height
newgrid.Config = grid.Config
newgrid.Data = grid.Data
return newgrid
@@ -59,7 +124,7 @@ func (grid *Grid) Copy(other *Grid) {
func (grid *Grid) Clear() {
for y := range grid.Data {
for x := range grid.Data[y] {
grid.Data[y][x] = false
grid.Data[y][x].State = false
}
}
}
@@ -69,8 +134,8 @@ func (grid *Grid) FillRandom() {
if !grid.Empty {
for y := range grid.Data {
for x := range grid.Data[y] {
if rand.Intn(grid.Density) == 1 {
grid.Data[y][x] = true
if rand.Intn(grid.Config.Density) == 1 {
grid.Data[y][x].State = true
}
}
}
@@ -78,9 +143,9 @@ func (grid *Grid) FillRandom() {
}
func (grid *Grid) Dump() {
for y := 0; y < grid.Height; y++ {
for x := 0; x < grid.Width; x++ {
if grid.Data[y][x] {
for y := 0; y < grid.Config.Height; y++ {
for x := 0; x < grid.Config.Width; x++ {
if grid.Data[y][x].State {
fmt.Print("XX")
} else {
fmt.Print(" ")
@@ -93,8 +158,8 @@ func (grid *Grid) Dump() {
// initialize using a given RLE pattern
func (grid *Grid) LoadRLE(pattern *rle.RLE) {
if pattern != nil {
startX := (grid.Width / 2) - (pattern.Width / 2)
startY := (grid.Height / 2) - (pattern.Height / 2)
startX := (grid.Config.Width / 2) - (pattern.Width / 2)
startY := (grid.Config.Height / 2) - (pattern.Height / 2)
var y, x int
for rowIndex, patternRow := range pattern.Pattern {
@@ -103,7 +168,7 @@ func (grid *Grid) LoadRLE(pattern *rle.RLE) {
x = colIndex + startX
y = rowIndex + startY
grid.Data[y][x] = true
grid.Data[y][x].State = true
}
}
}
@@ -214,7 +279,7 @@ func (grid *Grid) SaveState(filename, rule string) error {
for y := range grid.Data {
for _, cell := range grid.Data[y] {
row := "."
if cell {
if cell.State {
row = "o"
}

57
src/play.go
View File

@@ -119,14 +119,14 @@ func (scene *ScenePlay) UpdateCells() {
// 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
state := scene.Grids[scene.Index].Data[y][x].State // 0|1 == dead or alive
neighbors := scene.Grids[scene.Index].CountNeighbors(x, y)
// 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
scene.Grids[next].Data[y][x].State = nextstate
if scene.Config.ShowEvolution {
// set history to current generation so we can infer the
@@ -136,9 +136,6 @@ func (scene *ScenePlay) UpdateCells() {
if state != nextstate {
scene.History[y][x] = scene.Generations
}
// 10FPS:
//scene.History.Data[y][x] = (state ^ (1 ^ nextstate)) * (scene.Generations - scene.History.Data[y][x])
}
}
}
@@ -376,7 +373,7 @@ func (scene *ScenePlay) SaveRectRLE() {
grid[y] = make([]bool, width)
for x := 0; x < width; x++ {
grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx]
grid[y][x] = scene.Grids[scene.Index].Data[y+starty][x+startx].State
}
}
@@ -429,7 +426,7 @@ func (scene *ScenePlay) ToggleCellOnCursorPos(alive bool) {
y := int(worldY) / scene.Config.Cellsize
if x > -1 && y > -1 && x < scene.Config.Width && y < scene.Config.Height {
scene.Grids[scene.Index].Data[y][x] = alive
scene.Grids[scene.Index].Data[y][x].State = alive
scene.History[y][x] = 1
}
}
@@ -455,7 +452,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
if scene.Config.ShowEvolution {
scene.DrawEvolution(screen, x, y, op)
} else {
if scene.Grids[scene.Index].Data[y][x] {
if scene.Grids[scene.Index].Data[y][x].State {
scene.World.DrawImage(scene.Theme.Tile(ColLife), op)
}
}
@@ -472,7 +469,7 @@ func (scene *ScenePlay) Draw(screen *ebiten.Image) {
func (scene *ScenePlay) DrawEvolution(screen *ebiten.Image, x, y int, op *ebiten.DrawImageOptions) {
age := scene.Generations - scene.History[y][x]
switch scene.Grids[scene.Index].Data[y][x] {
switch scene.Grids[scene.Index].Data[y][x].State {
case Alive:
if age > 50 && scene.Config.ShowEvolution {
scene.World.DrawImage(scene.Theme.Tile(ColOld), op)
@@ -580,8 +577,8 @@ func (scene *ScenePlay) InitCache() {
// initialize grid[s], either using pre-computed from state or rle file, or random
func (scene *ScenePlay) InitGrid() {
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)
grida := NewGrid(scene.Config)
gridb := NewGrid(scene.Config)
// startup is delayed until user has selected options
grida.FillRandom()
@@ -650,39 +647,3 @@ func (scene *ScenePlay) Init() {
func bool2int(b bool) int {
return int(*(*byte)(unsafe.Pointer(&b)))
}
// count the living neighbors of a cell
func (scene *ScenePlay) CountNeighbors(x, y int) int {
var sum int
grid := scene.Grids[scene.Index].Data
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 += bool2int(grid[row][col])
}
}
// don't count ourselfes though
sum -= bool2int(grid[y][x])
return sum
}