ebiten/examples/life/main.go

191 lines
4.3 KiB
Go
Raw Normal View History

2016-07-07 17:26:38 +02:00
// The MIT License (MIT)
//
// Copyright (c) 2015-2016 Martin Lindhe
// Copyright (c) 2016 Hajime Hoshi
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
// +build example jsgo
2016-07-07 17:26:38 +02:00
package main
import (
"log"
"math/rand"
"time"
2020-10-03 19:35:13 +02:00
"github.com/hajimehoshi/ebiten/v2"
2016-07-07 17:26:38 +02:00
)
2020-05-09 22:34:06 +02:00
func init() {
rand.Seed(time.Now().UnixNano())
}
2018-01-28 14:39:54 +01:00
// World represents the game state.
2016-07-07 17:26:38 +02:00
type World struct {
2018-05-12 17:33:11 +02:00
area []bool
width int
height int
2016-07-07 17:26:38 +02:00
}
2018-01-28 14:39:54 +01:00
// NewWorld creates a new world.
2018-01-28 14:47:35 +01:00
func NewWorld(width, height int, maxInitLiveCells int) *World {
w := &World{
2018-05-12 17:33:11 +02:00
area: make([]bool, width*height),
width: width,
height: height,
2017-06-03 18:54:05 +02:00
}
2018-01-28 14:47:35 +01:00
w.init(maxInitLiveCells)
return w
}
// init inits world with a random state.
func (w *World) init(maxLiveCells int) {
for i := 0; i < maxLiveCells; i++ {
2018-05-12 17:33:11 +02:00
x := rand.Intn(w.width)
y := rand.Intn(w.height)
w.area[y*w.width+x] = true
2016-07-07 17:26:38 +02:00
}
}
2018-01-28 14:39:54 +01:00
// Update game state by one tick.
func (w *World) Update() {
2018-05-12 17:33:11 +02:00
width := w.width
height := w.height
next := make([]bool, width*height)
2016-07-07 17:26:38 +02:00
for y := 0; y < height; y++ {
for x := 0; x < width; x++ {
2018-05-12 17:33:11 +02:00
pop := neighbourCount(w.area, width, height, x, y)
2016-07-07 17:26:38 +02:00
switch {
case pop < 2:
// rule 1. Any live cell with fewer than two live neighbours
// dies, as if caused by under-population.
2018-05-12 17:33:11 +02:00
next[y*width+x] = false
2016-07-07 17:26:38 +02:00
2018-05-12 17:33:11 +02:00
case (pop == 2 || pop == 3) && w.area[y*width+x]:
2016-07-07 17:26:38 +02:00
// rule 2. Any live cell with two or three live neighbours
// lives on to the next generation.
2018-05-12 17:33:11 +02:00
next[y*width+x] = true
2016-07-07 17:26:38 +02:00
case pop > 3:
// rule 3. Any live cell with more than three live neighbours
// dies, as if by over-population.
2018-05-12 17:33:11 +02:00
next[y*width+x] = false
2016-07-07 17:26:38 +02:00
case pop == 3:
// rule 4. Any dead cell with exactly three live neighbours
// becomes a live cell, as if by reproduction.
2018-05-12 17:33:11 +02:00
next[y*width+x] = true
2016-07-07 17:26:38 +02:00
}
}
}
w.area = next
}
2018-01-28 14:47:35 +01:00
// Draw paints current game state.
func (w *World) Draw(pix []byte) {
2018-05-12 17:33:11 +02:00
for i, v := range w.area {
if v {
pix[4*i] = 0xff
pix[4*i+1] = 0xff
pix[4*i+2] = 0xff
pix[4*i+3] = 0xff
} else {
pix[4*i] = 0
pix[4*i+1] = 0
pix[4*i+2] = 0
pix[4*i+3] = 0
2016-07-07 17:26:38 +02:00
}
}
}
2018-01-28 14:47:35 +01:00
func max(a, b int) int {
if a < b {
return b
2016-07-07 17:26:38 +02:00
}
2018-01-28 14:47:35 +01:00
return a
}
2016-07-07 17:26:38 +02:00
2018-01-28 14:47:35 +01:00
func min(a, b int) int {
if a < b {
return a
}
return b
2016-07-07 17:26:38 +02:00
}
2018-01-28 14:47:35 +01:00
// neighbourCount calculates the Moore neighborhood of (x, y).
2018-05-12 17:33:11 +02:00
func neighbourCount(a []bool, width, height, x, y int) int {
2018-01-28 14:47:35 +01:00
c := 0
2018-05-12 17:33:11 +02:00
for j := -1; j <= 1; j++ {
for i := -1; i <= 1; i++ {
if i == 0 && j == 0 {
continue
}
x2 := x + i
y2 := y + j
if x2 < 0 || y2 < 0 || width <= x2 || height <= y2 {
2018-01-28 14:47:35 +01:00
continue
}
2018-05-12 17:33:11 +02:00
if a[y2*width+x2] {
2018-01-28 14:47:35 +01:00
c++
}
}
2016-07-07 17:26:38 +02:00
}
2018-01-28 14:47:35 +01:00
return c
2016-07-07 17:26:38 +02:00
}
const (
screenWidth = 320
screenHeight = 240
)
2020-05-09 22:34:06 +02:00
type Game struct {
world *World
2020-05-09 22:34:06 +02:00
pixels []byte
}
2016-07-07 17:26:38 +02:00
func (g *Game) Update() error {
2020-05-09 22:34:06 +02:00
g.world.Update()
return nil
}
2018-01-28 14:47:35 +01:00
2020-05-09 22:34:06 +02:00
func (g *Game) Draw(screen *ebiten.Image) {
if g.pixels == nil {
g.pixels = make([]byte, screenWidth*screenHeight*4)
2017-05-16 03:35:58 +02:00
}
2020-05-09 22:34:06 +02:00
g.world.Draw(g.pixels)
screen.ReplacePixels(g.pixels)
}
2018-01-28 14:47:35 +01:00
2020-05-09 22:34:06 +02:00
func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
return screenWidth, screenHeight
2016-07-07 17:26:38 +02:00
}
func main() {
2020-05-09 22:34:06 +02:00
g := &Game{
world: NewWorld(screenWidth, screenHeight, int((screenWidth*screenHeight)/10)),
}
ebiten.SetWindowSize(screenWidth*2, screenHeight*2)
ebiten.SetWindowTitle("Game of Life (Ebiten Demo)")
if err := ebiten.RunGame(g); err != nil {
2016-07-07 17:26:38 +02:00
log.Fatal(err)
}
}