add ebiten example (a tiny snake game, powered by ebiten)

Signed-off-by: Simon Waldherr <[email protected]>

Author: SimonWaldherr

non-std-lib/ebiten.go

@@ -0,0 +1,215 @@
+package main
+
+import (
+	"fmt"
+	"image/color"
+	"log"
+	"math/rand"
+	"time"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/ebitenutil"
+)
+
+const (
+	screenWidth  = 320 // Width of the playing field
+	screenHeight = 240 // Height of the playing field
+	gridSize     = 10  // Size of each segment of the snake and the food
+	initialSpeed = 8   // Initial speed of the snake
+	margin       = 2   // Margin to prevent food from appearing at the edge
+)
+
+type Game struct {
+	snake      []Position // Position of the snake
+	direction  Direction  // Current movement direction
+	food       Position   // Position of the food
+	score      int        // Player's score
+	gameOver   bool       // Game status
+	speed      int        // Game speed
+	frameCount int        // Counts frames to control the speed
+}
+
+type Position struct {
+	X int
+	Y int
+}
+
+type Direction struct {
+	X int
+	Y int
+}
+
+// Layout defines the size of the game window
+func (g *Game) Layout(outsideWidth, outsideHeight int) (int, int) {
+	return screenWidth, screenHeight
+}
+
+// Update contains the game logic that is updated every frame
+func (g *Game) Update() error {
+	// If "Escape" is pressed, the game ends
+	if ebiten.IsKeyPressed(ebiten.KeyEscape) {
+		return fmt.Errorf("Game ended")
+	}
+
+	// If the game is over, it can be restarted by pressing the spacebar
+	if g.gameOver {
+		if ebiten.IsKeyPressed(ebiten.KeySpace) {
+			*g = *NewGame() // Reset the game
+		}
+		return nil
+	}
+
+	// Process input (change direction)
+	g.handleInput()
+
+	// Count frames and control snake movement
+	g.frameCount++
+	if g.frameCount%g.speed != 0 {
+		return nil
+	}
+
+	// Move the snake
+	g.moveSnake()
+
+	// Check for collisions (with the wall or itself)
+	g.checkCollisions()
+
+	return nil
+}
+
+// handleInput processes the player's keyboard input
+func (g *Game) handleInput() {
+	// Change direction, but prevent the snake from reversing directly
+	if ebiten.IsKeyPressed(ebiten.KeyArrowUp) && g.direction.Y == 0 {
+		g.direction = Direction{X: 0, Y: -1}
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowDown) && g.direction.Y == 0 {
+		g.direction = Direction{X: 0, Y: 1}
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowLeft) && g.direction.X == 0 {
+		g.direction = Direction{X: -1, Y: 0}
+	}
+	if ebiten.IsKeyPressed(ebiten.KeyArrowRight) && g.direction.X == 0 {
+		g.direction = Direction{X: 1, Y: 0}
+	}
+}
+
+// moveSnake moves the snake and checks if it has reached the food
+func (g *Game) moveSnake() {
+	// New head position based on the current direction
+	newHead := Position{
+		X: g.snake[0].X + g.direction.X*gridSize,
+		Y: g.snake[0].Y + g.direction.Y*gridSize,
+	}
+
+	// Add the new head to the snake
+	g.snake = append([]Position{newHead}, g.snake...)
+
+	// Check if the snake has reached the food
+	if newHead == g.food {
+		g.score++ // Increase score
+		g.spawnFood()
+
+		// Increase speed every 5 points until a limit is reached
+		if g.score%5 == 0 && g.speed > 2 {
+			g.speed--
+		}
+	} else {
+		// Remove the last tail segment to move the snake
+		g.snake = g.snake[:len(g.snake)-1]
+	}
+}
+
+// checkCollisions checks if the snake collides with the wall or itself
+func (g *Game) checkCollisions() {
+	head := g.snake[0]
+
+	// Collision with the wall
+	if head.X < 0 || head.Y < 0 || head.X >= screenWidth || head.Y >= screenHeight {
+		g.gameOver = true
+	}
+
+	// Collision with itself
+	for _, segment := range g.snake[1:] {
+		if head == segment {
+			g.gameOver = true
+			break
+		}
+	}
+}
+
+// Draw draws the snake, food, and score on the screen
+func (g *Game) Draw(screen *ebiten.Image) {
+	// Set background to black
+	screen.Fill(color.Black)
+
+	// Draw the snake (white color)
+	for _, segment := range g.snake {
+		ebitenutil.DrawRect(screen, float64(segment.X), float64(segment.Y), gridSize, gridSize, color.White)
+	}
+
+	// Draw the food (red color)
+	ebitenutil.DrawRect(screen, float64(g.food.X), float64(g.food.Y), gridSize, gridSize, color.RGBA{255, 0, 0, 255})
+
+	// Display score and game-over message
+	if g.gameOver {
+		msg := fmt.Sprintf("Game Over! Score: %d\nPress 'Space' to restart.", g.score)
+		ebitenutil.DebugPrintAt(screen, msg, screenWidth/2-80, screenHeight/2)
+	} else {
+		msg := fmt.Sprintf("Score: %d", g.score)
+		ebitenutil.DebugPrint(screen, msg)
+	}
+}
+
+// spawnFood generates a new food object at a random valid position
+func (g *Game) spawnFood() {
+	rand.Seed(time.Now().UnixNano())
+
+	// Random position within the playing field, but not directly at the edge (with margin)
+	for {
+		g.food = Position{
+			X: rand.Intn(screenWidth/gridSize-2*margin)*gridSize + margin*gridSize,
+			Y: rand.Intn(screenHeight/gridSize-2*margin)*gridSize + margin*gridSize,
+		}
+
+		// Ensure the food doesn't appear on the snake
+		collision := false
+		for _, segment := range g.snake {
+			if g.food == segment {
+				collision = true
+				break
+			}
+		}
+		// If there's no collision, the position is valid
+		if !collision {
+			break
+		}
+	}
+}
+
+// NewGame initializes a new game
+func NewGame() *Game {
+	return &Game{
+		snake: []Position{{
+			X: screenWidth / 2,
+			Y: screenHeight / 2},
+		}, // Start the snake in the middle
+		direction: Direction{X: 0, Y: -1}, // Start moving upwards
+		speed:     initialSpeed,           // Initial speed
+		food: Position{
+			X: rand.Intn(screenWidth/gridSize-2*margin)*gridSize + margin*gridSize,
+			Y: rand.Intn(screenHeight/gridSize-2*margin)*gridSize + margin*gridSize,
+		},
+	}
+}
+
+// main starts the game
+func main() {
+	ebiten.SetWindowSize(screenWidth*2, screenHeight*2) // Window size
+	ebiten.SetWindowTitle("Snake Game")                 // Window title
+
+	// Run the game
+	if err := ebiten.RunGame(NewGame()); err != nil {
+		log.Fatal(err)
+	}
+}