From 9082edf03ffb274d44343433bb0ae31cafec4ef7 Mon Sep 17 00:00:00 2001 From: David Linus Briemann Date: Tue, 8 Oct 2019 17:54:23 +0200 Subject: [PATCH] Add new example: squirals (#952) --- .gitignore | 1 + examples/squiral/main.go | 351 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 352 insertions(+) create mode 100644 examples/squiral/main.go diff --git a/.gitignore b/.gitignore index 4392f62e4..27ed88c2d 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,4 @@ *~ *.aar *.apk +.vscode diff --git a/examples/squiral/main.go b/examples/squiral/main.go new file mode 100644 index 000000000..d4e14d6d3 --- /dev/null +++ b/examples/squiral/main.go @@ -0,0 +1,351 @@ +// Copyright 2019 The Ebiten Authors +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// +build example jsgo + +// This demo is inspired by the xscreensaver 'squirals'. + +package main + +import ( + "fmt" + "image/color" + "math/rand" + "time" + + "github.com/hajimehoshi/ebiten" + "github.com/hajimehoshi/ebiten/ebitenutil" + "github.com/hajimehoshi/ebiten/inpututil" +) + +const ( + width = 800 + height = 600 + scale = 1 + numOfSquirals = width / 32 +) + +type palette struct { + name string + colors []color.Color +} + +var ( + background = color.Black + + palettes = []palette{ + { + name: "sand dunes", + colors: []color.Color{ + color.RGBA{0xF2, 0x74, 0x05, 0xFF}, // #F27405 + color.RGBA{0xD9, 0x52, 0x04, 0xFF}, // #D95204 + color.RGBA{0x40, 0x18, 0x01, 0xFF}, // #401801 + color.RGBA{0xA6, 0x2F, 0x03, 0xFF}, // #A62F03 + color.RGBA{0x73, 0x2A, 0x19, 0xFF}, // #732A19 + }, + }, + { + name: "mono desert sand", + colors: []color.Color{ + color.RGBA{0x7F, 0x6C, 0x52, 0xFF}, // #7F6C52 + color.RGBA{0xFF, 0xBA, 0x58, 0xFF}, // #FFBA58 + color.RGBA{0xFF, 0xD9, 0xA5, 0xFF}, // #FFD9A5 + color.RGBA{0x7F, 0x50, 0x0F, 0xFF}, // #7F500F + color.RGBA{0xCC, 0xAE, 0x84, 0xFF}, // #CCAE84 + }, + }, + { + name: "land sea gradient", + colors: []color.Color{ + color.RGBA{0x00, 0xA2, 0xE8, 0xFF}, // #00A2E8 + color.RGBA{0x67, 0xA3, 0xF5, 0xFF}, // #67A3F5 + color.RGBA{0xFF, 0xFF, 0xD5, 0xFF}, // #FFFFD5 + color.RGBA{0xDD, 0xE8, 0x0C, 0xFF}, // #DDE80C + color.RGBA{0x74, 0x9A, 0x0D, 0xFF}, // #749A0D + }, + }, + } + selectedPalette = 0 + colorCycle = 0 + canvas *ebiten.Image + auto *automaton + // blocker is an arbitrary color used to prevent the + // squirals from leaving the canvas. + blocker = color.RGBA{0, 0, 0, 254} + + // dirCycles defines by offset which direction a squiral + // should try next for the two cases: + // clockwise: + // 1. try to turn right (index+1) + // 2. try to go straight (index+0) + // 3. try to turn left (index+3) + // counter-clockwise: + // 1. try to turn left (index+3) + // 2. try to go straight (index+0) + // 3. try to turn right (index+1) + dirCycles = [2][3]int{ + [3]int{1, 0, 3}, // cw + [3]int{3, 0, 1}, // ccw + } + + // dirs contains vectors for the directions: east, south, west, north + // in the specified order. + dirs = [4]vec2{vec2{1, 0}, vec2{0, 1}, vec2{-1, 0}, vec2{0, -1}} + + // neighbors defines neighboring cells depending on the moving + // direction of the squiral: + // index of 0 -> squiral moves vertically, + // index of 1 -> squiral moves horizontally. + // These neighbors are tested for "collisions" during simulation. + neighbors = [2][2]vec2{ + [2]vec2{vec2{0, 1}, vec2{0, -1}}, // east, west + [2]vec2{vec2{1, 0}, vec2{-1, 0}}, // south, north + } +) + +type vec2 struct { + x int + y int +} + +type squiral struct { + speed int + pos vec2 + dir int + rot int + col color.Color + dead bool +} + +func (s *squiral) spawn() { + s.dead = false + + rx := rand.Intn(width-4) + 2 + ry := rand.Intn(height-4) + 2 + + for dx := -2; dx <= 2; dx++ { + for dy := -2; dy <= 2; dy++ { + tx, ty := rx+dx, ry+dy + if auto.colorMap[tx][ty] != background { + s.dead = true + return + } + } + } + + s.speed = rand.Intn(5) + 1 + s.pos.x = rx + s.pos.y = ry + s.dir = rand.Intn(4) + + colorCycle = (colorCycle + 1) % len(palettes[selectedPalette].colors) + s.col = palettes[selectedPalette].colors[colorCycle] + + s.rot = rand.Intn(2) +} + +func (s *squiral) step(debug int) { + if s.dead { + return + } + x, y := s.pos.x, s.pos.y // shorthands + + change := rand.Intn(1000) + if change < 2 { + // On 0.2% of iterations, switch rotation direction. + s.rot = (s.rot + 1) % 2 + } + + // 1. try to advance the spiral in its rotation + // direction (clockwise or counter-clockwise). + for _, next := range dirCycles[s.rot] { + dir := (s.dir + next) % 4 + off := dirs[dir] + // Peek all targets by priority. + target := vec2{ + x: x + off.x, + y: y + off.y, + } + if auto.colorMap[target.x][target.y] == background { + // If the target is free we need to also check the + // surrounding cells. + + // a. Test if next cell in direction dir does not have + // the same color as this squiral. + ntarg := vec2{ + x: target.x + off.x, + y: target.y + off.y, + } + if auto.colorMap[ntarg.x][ntarg.y] == s.col { + // If this has the same color, we cannot go into this direction, + // to avoid ugly blocks of equal color. + continue // try next direction + } + + // b. Test all outer fields for the color of the + // squiral itself. + horivert := dir % 2 + xtarg := vec2{} + set := true + for _, out := range neighbors[horivert] { + xtarg.x = target.x + out.x + xtarg.y = target.y + out.y + + // If one of the outer targets equals the squiral's + // color, again continue with next direction. + if auto.colorMap[xtarg.x][xtarg.y] == s.col { + // If this is not free we cannot go into this direction. + set = false + break // try next direction + } + + xtarg.x = ntarg.x + out.x + xtarg.y = ntarg.y + out.y + + // If one of the outer targets equals the squiral's + // color, again continue with next direction. + if auto.colorMap[xtarg.x][xtarg.y] == s.col { + // If this is not free we cannot go into this direction. + set = false + break // try next direction + } + } + + if set { + s.pos = target + s.dir = dir + // 2. set the color of this squiral to its + // current position. + setpix(s.pos, s.col) + return + } + } + } + + s.dead = true +} + +type automaton struct { + squirals [numOfSquirals]squiral + colorMap [width][height]color.Color +} + +func (au *automaton) init() { + // Init the test grid with color (0,0,0,0) and the borders of + // it with color(0,0,0,254) as a blocker color, so the squirals + // cannot escape the scene. + for x := 0; x < width; x++ { + for y := 0; y < height; y++ { + if x == 0 || x == width-1 || y == 0 || y == height-1 { + auto.colorMap[x][y] = blocker + } else { + auto.colorMap[x][y] = background + } + } + } + + for i := 0; i < numOfSquirals; i++ { + auto.squirals[i].spawn() + } +} + +func (au *automaton) step() { + for i := 0; i < numOfSquirals; i++ { + for s := 0; s < au.squirals[i].speed; s++ { + au.squirals[i].step(i) + if au.squirals[i].dead { + au.squirals[i].spawn() + } + } + } +} + +func setpix(xy vec2, col color.Color) { + canvas.Set(xy.x, xy.y, col) + auto.colorMap[xy.x][xy.y] = col +} + +func init() { + rand.Seed(time.Now().UnixNano()) + c, _ := ebiten.NewImage(width, height, ebiten.FilterDefault) + canvas = c + canvas.Fill(background) + + auto = &automaton{} + auto.init() +} + +func update(screen *ebiten.Image) error { + reset := false + + if inpututil.IsKeyJustPressed(ebiten.KeyB) { + if background == color.White { + background = color.Black + } else { + background = color.White + } + reset = true + } else if inpututil.IsKeyJustPressed(ebiten.KeyT) { + selectedPalette = (selectedPalette + 1) % len(palettes) + reset = true + } else if inpututil.IsKeyJustPressed(ebiten.KeyR) { + reset = true + } + + if reset { + canvas.Fill(background) + auto.init() + } + + auto.step() + + if ebiten.IsDrawingSkipped() { + return nil + } + + draw(screen) + + return nil +} + +func draw(screen *ebiten.Image) { + screen.DrawImage(canvas, nil) + ebitenutil.DebugPrintAt( + screen, + fmt.Sprintf("TPS: %0.2f, FPS: %0.2f", ebiten.CurrentTPS(), ebiten.CurrentFPS()), + 1, 0, + ) + ebitenutil.DebugPrintAt( + screen, + "[r]: respawn", + 1, 16, + ) + ebitenutil.DebugPrintAt( + screen, + "[b]: toggle background (white/black)", + 1, 32, + ) + ebitenutil.DebugPrintAt( + screen, + fmt.Sprintf("[t]: cycle theme (current: %s)", palettes[selectedPalette].name), + 1, 48, + ) +} + +func main() { + ebiten.SetMaxTPS(250) + if err := ebiten.Run(update, width, height, scale, "Squirals"); err != nil { + panic(err) + } +}