mirror of
https://codeberg.org/scip/golsky.git
synced 2025-12-16 20:20:57 +01:00
363 lines
8.0 KiB
Go
363 lines
8.0 KiB
Go
package main
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"image/color"
|
|
"log"
|
|
"math/rand"
|
|
"os"
|
|
"runtime/pprof"
|
|
|
|
"github.com/hajimehoshi/ebiten/v2"
|
|
"github.com/hajimehoshi/ebiten/v2/inpututil"
|
|
"github.com/hajimehoshi/ebiten/v2/vector"
|
|
)
|
|
|
|
var (
|
|
blackImage = ebiten.NewImage(3, 3)
|
|
blackSubImage = blackImage.SubImage(image.Rect(1, 1, 2, 2)).(*ebiten.Image)
|
|
)
|
|
|
|
type Images struct {
|
|
Black, White *ebiten.Image
|
|
}
|
|
|
|
type Grid struct {
|
|
Data [][]int64
|
|
Width, Height, Density int
|
|
}
|
|
|
|
// Create new empty grid and allocate Data according to provided dimensions
|
|
func NewGrid(width, height, density int) *Grid {
|
|
grid := &Grid{
|
|
Height: height,
|
|
Width: width,
|
|
Density: density,
|
|
Data: make([][]int64, height),
|
|
}
|
|
|
|
for y := 0; y < height; y++ {
|
|
grid.Data[y] = make([]int64, width)
|
|
}
|
|
|
|
return grid
|
|
}
|
|
|
|
// live console output of the grid
|
|
func (grid *Grid) Dump() {
|
|
/*
|
|
cmd := exec.Command("clear")
|
|
cmd.Stdout = os.Stdout
|
|
cmd.Run()
|
|
|
|
for y := 0; y < grid.Height; y++ {
|
|
for x := 0; x < grid.Width; x++ {
|
|
if grid.Data[y][x] == 1 {
|
|
fmt.Print("XX")
|
|
} else {
|
|
fmt.Print(" ")
|
|
}
|
|
}
|
|
fmt.Println()
|
|
}
|
|
*/
|
|
fmt.Printf("FPS: %0.2f\n", ebiten.ActualTPS())
|
|
}
|
|
|
|
type Game struct {
|
|
Width, Height, Cellsize, Density int
|
|
ScreenWidth, ScreenHeight int
|
|
Grids []*Grid
|
|
Index int
|
|
Black, White, Grey color.RGBA
|
|
Tiles Images
|
|
Cache *ebiten.Image
|
|
Elapsed int64
|
|
TPG int64 // adjust game speed independently of TPS
|
|
Vertices []ebiten.Vertex
|
|
Indices []uint16
|
|
Pause, Debug bool
|
|
}
|
|
|
|
// fill a cell
|
|
func FillCell(tile *ebiten.Image, cellsize int, col color.RGBA) {
|
|
vector.DrawFilledRect(
|
|
tile,
|
|
float32(1),
|
|
float32(1),
|
|
float32(cellsize-1),
|
|
float32(cellsize-1),
|
|
col, false,
|
|
)
|
|
}
|
|
|
|
func (game *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
|
|
return game.ScreenWidth, game.ScreenHeight
|
|
}
|
|
|
|
func (game *Game) Init() {
|
|
// setup two grids, one for display, one for next state
|
|
grida := NewGrid(game.Width, game.Height, game.Density)
|
|
gridb := NewGrid(game.Width, game.Height, game.Density)
|
|
|
|
for y := 0; y < game.Height; y++ {
|
|
for x := 0; x < game.Width; x++ {
|
|
if rand.Intn(game.Density) == 1 {
|
|
grida.Data[y][x] = 1
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
game.Grids = []*Grid{
|
|
grida,
|
|
gridb,
|
|
}
|
|
|
|
// setup colors
|
|
game.Grey = color.RGBA{128, 128, 128, 0xff}
|
|
game.Black = color.RGBA{0, 0, 0, 0xff}
|
|
game.White = color.RGBA{200, 200, 200, 0xff}
|
|
|
|
game.Tiles.White = ebiten.NewImage(game.Cellsize, game.Cellsize)
|
|
game.Cache = ebiten.NewImage(game.ScreenWidth, game.ScreenHeight)
|
|
|
|
FillCell(game.Tiles.White, game.Cellsize, game.White)
|
|
game.Cache.Fill(game.Grey)
|
|
|
|
// draw the offscreen image
|
|
op := &ebiten.DrawImageOptions{}
|
|
for y := 0; y < game.Height; y++ {
|
|
for x := 0; x < game.Width; x++ {
|
|
op.GeoM.Reset()
|
|
op.GeoM.Translate(float64(x*game.Cellsize), float64(y*game.Cellsize))
|
|
game.Cache.DrawImage(game.Tiles.White, op)
|
|
}
|
|
}
|
|
|
|
blackSubImage.Fill(game.Black)
|
|
|
|
lenvertices := game.ScreenHeight * game.ScreenWidth
|
|
game.Vertices = make([]ebiten.Vertex, lenvertices)
|
|
game.Indices = make([]uint16, lenvertices+(lenvertices/2))
|
|
}
|
|
|
|
// count the living neighbors of a cell
|
|
func (game *Game) CountNeighbors(x, y int) int64 {
|
|
var sum int64
|
|
|
|
for nbgX := -1; nbgX < 2; nbgX++ {
|
|
for nbgY := -1; nbgY < 2; nbgY++ {
|
|
var col, row int
|
|
|
|
// Wrap mode we look at all the 8 neighbors surrounding
|
|
// us. In case we are on an edge we'll look at the
|
|
// neighbor on the other side of the grid, thus wrapping
|
|
// lookahead around using the mod() function.
|
|
col = (x + nbgX + game.Width) % game.Width
|
|
row = (y + nbgY + game.Height) % game.Height
|
|
|
|
sum += game.Grids[game.Index].Data[row][col]
|
|
}
|
|
}
|
|
|
|
// don't count ourselfes though
|
|
sum -= game.Grids[game.Index].Data[y][x]
|
|
|
|
return sum
|
|
}
|
|
|
|
// the heart of the game
|
|
func (game *Game) CheckRule(state int64, neighbors int64) int64 {
|
|
var nextstate int64
|
|
|
|
if state == 0 && neighbors == 3 {
|
|
nextstate = 1
|
|
} else if state == 1 && (neighbors == 2 || neighbors == 3) {
|
|
nextstate = 1
|
|
} else {
|
|
nextstate = 0
|
|
}
|
|
|
|
return nextstate
|
|
}
|
|
|
|
// we only update the cells if we are not in pause state or if the
|
|
// game timer (TPG) is elapsed.
|
|
func (game *Game) UpdateCells() {
|
|
if game.Pause {
|
|
return
|
|
}
|
|
|
|
if game.Elapsed < game.TPG {
|
|
game.Elapsed++
|
|
return
|
|
}
|
|
|
|
// next grid index. we only have to, so we just xor it
|
|
next := game.Index ^ 1
|
|
|
|
// reset vertices
|
|
// FIXME: fails!
|
|
game.ClearVertices()
|
|
|
|
// calculate cell life state, this is the actual game of life
|
|
for y := 0; y < game.Height; y++ {
|
|
for x := 0; x < game.Width; x++ {
|
|
state := game.Grids[game.Index].Data[y][x] // 0|1 == dead or alive
|
|
neighbors := game.CountNeighbors(x, y) // alive neighbor count
|
|
|
|
// actually apply the current rules
|
|
nextstate := game.CheckRule(state, neighbors)
|
|
|
|
// change state of current cell in next grid
|
|
game.Grids[next].Data[y][x] = nextstate
|
|
}
|
|
}
|
|
|
|
// calculate triangles for rendering
|
|
game.UpdateTriangles()
|
|
|
|
// switch grid for rendering
|
|
game.Index ^= 1
|
|
|
|
game.Elapsed = 0
|
|
|
|
if game.Debug {
|
|
game.Grids[next].Dump()
|
|
}
|
|
}
|
|
|
|
func (game *Game) Update() error {
|
|
game.UpdateCells()
|
|
|
|
if inpututil.IsKeyJustPressed(ebiten.KeySpace) {
|
|
game.Pause = !game.Pause
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (game *Game) ClearVertices() {
|
|
// FIXME: fails
|
|
for i := 0; i < len(game.Vertices); i++ {
|
|
game.Vertices[i] = ebiten.Vertex{}
|
|
// game.Vertices[i].DstX = 0
|
|
// game.Vertices[i].DstY = 1
|
|
}
|
|
|
|
game.Indices = game.Indices[:len(game.Indices)]
|
|
}
|
|
|
|
// create the triangles needed for rendering. Actual rendering doesn't
|
|
// happen here but in Draw()
|
|
func (game *Game) UpdateTriangles() {
|
|
var base uint16 = 0
|
|
var index uint16 = 0
|
|
|
|
idx := 0
|
|
|
|
// iterate over every cell
|
|
for celly := 0; celly < game.Height; celly++ {
|
|
for cellx := 0; cellx < game.Width; cellx++ {
|
|
|
|
// if the cell is alife
|
|
if game.Grids[game.Index].Data[celly][cellx] == 1 {
|
|
|
|
/* iterate over the cell's corners:
|
|
0 1
|
|
|
|
2 3
|
|
*/
|
|
for i := 0; i < 2; i++ {
|
|
for j := 0; j < 2; j++ {
|
|
|
|
// calculate the corner position
|
|
x := (cellx * game.Cellsize) + (i * game.Cellsize) + 1
|
|
y := (celly * game.Cellsize) + (j * game.Cellsize) + 1
|
|
|
|
if i == 1 {
|
|
x -= 1
|
|
}
|
|
if j == 1 {
|
|
y -= 1
|
|
}
|
|
|
|
// setup the vertex
|
|
game.Vertices[idx].DstX = float32(x)
|
|
game.Vertices[idx].DstY = float32(y)
|
|
game.Vertices[idx].SrcX = 1
|
|
game.Vertices[idx].SrcY = 1
|
|
game.Vertices[idx].ColorR = float32(game.Black.R)
|
|
game.Vertices[idx].ColorG = float32(game.Black.G)
|
|
game.Vertices[idx].ColorB = float32(game.Black.B)
|
|
game.Vertices[idx].ColorA = 1
|
|
|
|
idx++
|
|
}
|
|
}
|
|
}
|
|
|
|
// indices for first triangle
|
|
game.Indices[index] = base
|
|
game.Indices[index+1] = base + 1
|
|
game.Indices[index+2] = base + 3
|
|
|
|
// for the second one
|
|
game.Indices[index+3] = base
|
|
game.Indices[index+4] = base + 2
|
|
game.Indices[index+5] = base + 3
|
|
|
|
index += 6 // 3 indicies per triangle
|
|
|
|
base += 4 // 4 vertices per cell
|
|
}
|
|
}
|
|
}
|
|
|
|
func (game *Game) Draw(screen *ebiten.Image) {
|
|
op := &ebiten.DrawImageOptions{}
|
|
|
|
op.GeoM.Translate(0, 0)
|
|
screen.DrawImage(game.Cache, op)
|
|
|
|
triop := &ebiten.DrawTrianglesOptions{}
|
|
screen.DrawTriangles(game.Vertices, game.Indices, blackSubImage, triop)
|
|
}
|
|
|
|
func main() {
|
|
size := 200
|
|
|
|
game := &Game{
|
|
Width: size,
|
|
Height: size,
|
|
Cellsize: 4,
|
|
Density: 5,
|
|
TPG: 5,
|
|
Debug: true,
|
|
}
|
|
|
|
game.ScreenWidth = game.Width * game.Cellsize
|
|
game.ScreenHeight = game.Height * game.Cellsize
|
|
|
|
game.Init()
|
|
|
|
ebiten.SetWindowSize(game.ScreenWidth, game.ScreenHeight)
|
|
ebiten.SetWindowTitle("triangle conway's game of life")
|
|
ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
|
|
|
|
fd, err := os.Create("cpu.profile")
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
defer fd.Close()
|
|
|
|
pprof.StartCPUProfile(fd)
|
|
defer pprof.StopCPUProfile()
|
|
|
|
if err := ebiten.RunGame(game); err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
}
|