Kuldeep Singh
Kuldeep Singh

Follow

Kuldeep Singh

Follow
Building Snake Game In Golang: Complete Guide

Building Snake Game In Golang: Complete Guide

Learn Golang By Building A Snake Game: A Complete Guide

Kuldeep Singh's photo
Kuldeep Singh
·May 17, 2023·

6 min read

Table of contents

  • Setting Up Your Go Environment
  • Introduction to Ebiten
  • Setting Up the Game Environment
  • Creating the Snake Structure
  • Implementing the Food
  • Handling User Input and Game Updates
  • Drawing the Game Objects
  • Restarting the Game
  • Running Game
  • Conclusion

Learning a new programming language can be a daunting task, but working on a fun project like building a game can make the process enjoyable and effective. In this tutorial, we will learn Golang by creating a simple snake game. Golang, or Go, is an open-source programming language designed by Google that makes it easy to build simple, reliable, and efficient software.

By the end of this tutorial, you will have a basic understanding of Go and its core concepts, such as variables, functions, loops, and structs, as well as a working snake game to show off your new skills.

Setting Up Your Go Environment

Before you start building the game, You need to set up your Go environment. You can download Go from the official website at https://golang.org/dl/. Once Go is installed, Make sure to set up your GOPATH and configure your environment variables correctly.

Introduction to Ebiten

For building a 2d game we are going to use the Ebiten package. Ebiten is a 2D game library for Go that makes it easy to develop cross-platform games. Ebiten provides essential game features, Such as drawing images and handling user input. To get started with Ebiten, Install the library by running the following command:

go get -u github.com/hajimehoshi/ebiten/v2

Setting Up the Game Environment

Begin by creating a new Go file and importing the required packages, such as fmt, log, math/rand, time, and github.com/hajimehoshi/ebiten/v2. Next, create constants for the screen width and height, and tile size.

const (
    screenWidth  = 320
    screenHeight = 240
    tileSize     = 5
)

The main function should initialize the game state and call ebiten.RunGame() to start the game loop.

func main() {
    rand.Seed(time.Now().UnixNano())
    game := &Game{
        snake:    NewSnake(),
        food:     NewFood(),
        gameOver: false,
        ticks:    0,
        speed:    10,
    }
    ebiten.SetWindowSize(screenWidth*2, screenHeight*2)
    ebiten.SetWindowTitle("Snake Game")
    if err := ebiten.RunGame(game); err != nil {
        log.Fatal(err)
    }
}

This code sets up a basic Ebiten game window with a size of 640×480 pixels.

Creating the Snake Structure

Create a Point struct to represent x and y coordinates, and a Snake struct to represent the snake's body, direction, and growth counter.

type Point struct {
    X int
    Y int
}

type Snake struct {
    Body        []Point
    Direction   Point
    GrowCounter int
}

Now implement a NewSnake() function to create a new snake instance and a Move() method to update the snake's position based on its direction. The Move() method should also handle the snake's growth by keeping or removing the tail segment based on the GrowCounter.

func NewSnake() *Snake {
    return &Snake{
        Body: []Point{
            {X: screenWidth / tileSize / 2, Y: screenHeight / tileSize / 2},
        },
        Direction: Point{X: 1, Y: 0},
    }
}

func (s *Snake) Move() {
    newHead := Point{
        X: s.Body[0].X + s.Direction.X,
        Y: s.Body[0].Y + s.Direction.Y,
    }
    s.Body = append([]Point{newHead}, s.Body...)

    if s.GrowCounter > 0 {
        s.GrowCounter--
    } else {
        s.Body = s.Body[:len(s.Body)-1]
    }
}

NewSnake function initializes the snake with a single body part located in the center of the screen and sets the initial direction to the right.

Move function calculates the new head position based on the current head position and direction. It then adds the new head to the body and removes the tail unless the snake is growing.

Implementing the Food

Now Create a Food struct to represent the food’s position and a NewFood() function to create a new food instance with a random position on the game screen.

type Food struct {
    Position Point
}

func NewFood() *Food {
    return &Food{
        Position: Point{
            X: rand.Intn(screenWidth / tileSize),
            Y: rand.Intn(screenHeight / tileSize),
        },
    }
}

Handling User Input and Game Updates

Create a Game struct to represent the game state, including the snake, food, score, speed, and game over the flag.

type Game struct {
    snake         *Snake
    food          *Food
    score         int
    gameOver      bool
    ticks         int
    updateCounter int
    speed         int
}

Implement the Update() method for the Game struct to handle user input, update the snake's position, check for collisions, and handle the snake eating the food. If the snake eats the food, increment the score and update the food position.

func (g *Game) Update() error {
    if g.gameOver {
        if inpututil.IsKeyJustPressed(ebiten.KeyR) {
            g.restart()
        }
        return nil
    }

    g.updateCounter++
    if g.updateCounter < g.speed {
        return nil
    }
    g.updateCounter = 0

    // Update the snake's position
    g.snake.Move()

    if ebiten.IsKeyPressed(ebiten.KeyLeft) && g.snake.Direction.X == 0 {
        g.snake.Direction = Point{X: -1, Y: 0}
    } else if ebiten.IsKeyPressed(ebiten.KeyRight) && g.snake.Direction.X == 0 {
        g.snake.Direction = Point{X: 1, Y: 0}
    } else if ebiten.IsKeyPressed(ebiten.KeyUp) && g.snake.Direction.Y == 0 {
        g.snake.Direction = Point{X: 0, Y: -1}
    } else if ebiten.IsKeyPressed(ebiten.KeyDown) && g.snake.Direction.Y == 0 {
        g.snake.Direction = Point{X: 0, Y: 1}
    }

    head := g.snake.Body[0]
    if head.X < 0 || head.Y < 0 || head.X >= screenWidth/tileSize || head.Y >= screenHeight/tileSize {
        g.gameOver = true
        g.speed = 10
    }

    for _, part := range g.snake.Body[1:] {
        if head.X == part.X && head.Y == part.Y {
            g.gameOver = true
            g.speed = 10
        }
    }

    if head.X == g.food.Position.X && head.Y == g.food.Position.Y {
        g.score++
        g.snake.GrowCounter += 1
        g.food = NewFood()
        g.score++
        g.food = NewFood()
        g.snake.GrowCounter = 1

        // Decrease speed (with a lower limit)
        if g.speed > 2 {
            g.speed--
        }
    }

    return nil
}

In the update function, we're handling, game over logic, speed, user input, and restart game functionalities.

Drawing the Game Objects

Implement the Draw() method for the Game struct to render the game objects, such as the snake, food, and game over the screen. Use Ebiten's drawing functions, like DrawRect(), to draw the snake and food as rectangles and the text.Draw() function to display the score and game over message.

func (g *Game) Draw(screen *ebiten.Image) {
    // Draw background
    screen.Fill(color.RGBA{0, 0, 0, 255})

    // Draw snake
    for _, p := range g.snake.Body {
        ebitenutil.DrawRect(screen, float64(p.X*tileSize), float64(p.Y*tileSize), tileSize, tileSize, color.RGBA{0, 255, 0, 255})
    }

    // Draw food
    ebitenutil.DrawRect(screen, float64(g.food.Position.X*tileSize), float64(g.food.Position.Y*tileSize), tileSize, tileSize, color.RGBA{255, 0, 0, 255})

    // Create a font.Face
    face := basicfont.Face7x13

    // Draw game over text
    if g.gameOver {
        text.Draw(screen, "Game Over", face, screenWidth/2-40, screenHeight/2, color.White)
        text.Draw(screen, "Press 'R' to restart", face, screenWidth/2-60, screenHeight/2+16, color.White)
    }

    // Draw score
    scoreText := fmt.Sprintf("Score: %d", g.score)
    text.Draw(screen, scoreText, face, 5, screenHeight-5, color.White)
}

Restarting the Game

At last, implement a restart() method for the Game struct to reset the game state when the player presses 'R' after a game is over.

func (g *Game) restart() {
    g.snake = NewSnake()
    g.score = 0
    g.gameOver = false
    g.food = NewFood()
    g.speed = 10
}

This code checks if the R key is pressed when the game is over, and if so, it restarts the game by calling the restart method. The restart method resets the game state, including the snake, score, and gameOver flag.

Running Game

Follow me on Twitter and message me, and I’ll send you the full working code at once.

Conclusion

Congratulations! You’ve now built a simple snake game using Golang and the Ebiten library. In the process, you’ve learned the basics of Golang, including variables, functions, loops, and structs, as well as how to handle user input and collisions in a game.

You can further enhance this game by adding more features such as different levels, obstacles, or power-ups. The possibilities are endless, and you now have a solid foundation to build upon as you continue learning Golang through game development. Happy coding!

If you’re interested in learning more about programming and related topics, we invite you to check out our website programmingeeksclub.com. We offer valuable resources and insights.

You can find us on Twitter and Facebook.

Download my first ebook about mastering markdown, from here: Download, reviews and recommendations are appreciated.

Did you find this article valuable?

Support Kuldeep Singh by becoming a sponsor. Any amount is appreciated!

See recent sponsors Learn more about Hashnode Sponsors
 
Share this