DEV Community: Tim Little

Build an Asteroids Game with Raylib-go

Tim Little — Thu, 09 Oct 2025 04:42:33 +0000

In this tutorial, you’ll learn how to build an Asteroids game using Raylib-go, a lightweight library for game development.

By the end, we will have a complete game with player movement controlled by the keyboard, shooting, collisions, and win/lose states and all in Go.

Demo

Setting up your Go project

First, we need to set up our project and pull Raylib-go.

mkdir go-asteroids
go mod init asteroids
go get -v -u github.com/gen2brain/raylib-go/raylib

Setting up the Game

We start by creating basic game loop functions to initialise the resources, update the state, draw it to the screen and deinitialise the resources.

const (
    screenWidth  = 800
    screenHeight = 400
)

func init() {
    //Builtin go function which runs before main()

    // Setup the raylib window
    rl.InitWindow(screenWidth, screenHeight, "Asteroids")
    rl.SetTargetFPS(60)
}

func draw() {
    rl.BeginDrawing()

    // Set the background to black
    rl.ClearBackground(rl.Black)

    // Draw the score to the screen
    rl.DrawText("Score 0", 10, 10, 20, rl.Gray)

    rl.EndDrawing()

}

func update() {
    //TODO:  Update the state

}

func deinit() {
    rl.CloseWindow()
}

func main() {
    // When the main function ends, call the deinit() function
    defer deinit()

    // Continue the loop until the window is closed or ESC is pressed
    for !rl.WindowShouldClose() {
        draw()
        update()
    }
}

First, we set up a main() function, which starts by deferring the deinit() function. This will ensure that the deinit() function runs at the end of the main() function.We use an init() function, which runs before the main() function. These two functions allow us to set up resources in memory and tear them down when we no longer need them.

In the init() function, we set up the Raylib window and set the FPS.

We create a draw() function to use the new RayLib window to draw to the screen. We start the drawing with BeginDrawing and finish it with EndDrawing. We define our draw methods between those two calls. We set up an update() function, which is called each frame. We will fill that out later.

We simply clear the background with black and then draw a score in the top left corner.

In the main() function, we are called WindowShouldClose, which is a function that allows us to run our game loop until the Raylib window is closed or the ESC key is pressed.

Now, we can run the code:

go run main.go

What we should see is a black window with the score in the top left hand corner.

The code for this section can be found on my GitHub Repo

Drawing a background

It is a great start, though, we want to make this start look like our game. To start, we can add the space background.

We create a new resources/ directory in our project and download the space_background.png into it.

We load the image from a file and display it as our background:

var (
    texBackground rl.Texture2D
)

We start by declaring some global state, with the background text. Next, we need to load the image:

func init() {
    //Builtin go function which runs before main()

    // Setup the raylib window
    rl.InitWindow(screenWidth, screenHeight, "Asteroids")
    rl.SetTargetFPS(60)

    // Load textures
    texBackground = rl.LoadTexture("resources/space_background.png")
}

We load the image from disk using the LoadTextures call and assign it to the texBackground variable.

We need to make sure we are unloading it after the game, so we can do that in the deinit() function.

func deinit() {
    rl.CloseWindow()

    // Unload textures when the game closes
    rl.UnloadTexture(texBackground)
}

To do that, we run the UnloadTexture call.

Now, we can draw the background to the screen:

func draw() {
    rl.BeginDrawing()

    // Set the background to a nebula
    bgSource := rl.Rectangle{X: 0, Y: 0, Width: float32(texBackground.Width), Height: float32(texBackground.Height)}
    bgDest := rl.Rectangle{X: 0, Y: 0, Width: screenWidth, Height: screenHeight}
    rl.DrawTexturePro(texBackground, bgSource, bgDest, rl.Vector2{X: 0, Y: 0}, 0, rl.White)

    // Draw the score to the screen
...

We have a bit of an issue, the image is 1536x1024px, when our window size is only 800x400px. To scale the image to our window, we need to use the DrawTexturePro call.
This call takes the texture we want to draw, a rectangle within that texture and a destination texture on our window to draw it to. It also takes an Origin point, a Rotation and a Color, however, we are not using them.

For the bgSource, which is used to select the part of the image to draw, we create a rectangle to select the whole image. For the bgDest, we select the whole screen in Raylib. We then call the DrawTexturePro to draw the image to the screen.

Let's check to see that our background is being shown:

go run main.go

Which results in:

Beautiful, now it looks ready to start building our game on top of.

The code for this section can be found on my GitHub Repo

Create and draw the player

Next, we can set up the player for the game. This will be a ship that flies around and shoots at the asteroids.

For this, I am going to use Kenney - Simple Space assets. There are some amazingly talented game artists around, and many of them provide assets for free.

We can download the assets and put them into our /resources directory.

Now, we load them into our game. We start by adding another texture to our game state:

var (
+      texTiles      rl.Texture2D
       texBackground rl.Texture2D
)

Then we need to load it in our init() function:

        // Load textures
+       texTiles = rl.LoadTexture("resources/tilesheet.png")
        texBackground = rl.LoadTexture("resources/space_background.png")

Then unload it in our deinit() function:

        // Unload textures when the game closes
        rl.UnloadTexture(texBackground)
+       rl.UnloadTexture(texTiles)
 }

Now that we have the texture loaded into memory, we can start to use it. However, as you may have spotted, the texture is a spritemap, made up of an 8x6 grid of sprites. We want to use one of them for our ship.

Luckily, we already saw a function that would allow us to select a section of the texture and draw it to the screen. We can use the DrawTexturePro to take a smaller section of the original image and then draw that for us.

Let's start by defining our source selection rectangle. We will also create a tileSize to track how large we want the image.

In the consts, we add the tileSize:

const (
    screenWidth  = 800
    screenHeight = 400
+   tileSize     = 64
)

Now, we define our source selection rectangle for the ship:

var (
    texTiles      rl.Texture2D
    texBackground rl.Texture2D
+   spriteRec     rl.Rectangle
)

Then, in the init() function, we can define the sprite source:

    texTiles = rl.LoadTexture("resources/tilesheet.png")
    texBackground = rl.LoadTexture("resources/space_background.png")

+   spriteRec = rl.Rectangle{X: tileSize * 0, Y: tileSize * 2, Width: tileSize, Height: tileSize}
}

We select the ship on the 3rd row (Index 2) on the 1st position (Index 0).

As the tiles on the map are tileSize wide and high. We use that variable to calculate where in the tilemap we want to select. You can see from the image below how we have picked the ship we want.

Now we have our selection, we need to draw it on the screen. To make these easier, we create a Player struct to hold all the player related behaviours.

type Player struct {
    position     rl.Vector2
    speed        rl.Vector2
    size         rl.Vector2
    acceleration float32
    rotation     float32
    isBoosting   bool // We will use this in the next step
}

We create the Player structure with Vectors for the position, speed and size. We have some floats for acceleration and rotation, which we use to move the sprite. Finally, we have a boolean for boosting.

Now we can draw the sprite to the screen:

func (p *Player) Draw() {
    destTexture := rl.Rectangle{X: p.position.X, Y: p.position.Y, Width: p.size.X, Height: p.size.Y}
    rl.DrawTexturePro(
        texTiles,
        spriteRec,
        destTexture,
        rl.Vector2{X: p.size.X / 2, Y: p.size.Y / 2},
        p.rotation,
        rl.White,
    )
}

We define a destTexture, similar to the way we did the background; however, instead of covering the whole screen, we want the sprite to appear in the centre of the screen.

We need to create the new player when we start the game. For this, we create a variable in the state and a little helper function to do all the initialisation:

var (
    texTiles      rl.Texture2D
    texBackground rl.Texture2D
    spriteRec     rl.Rectangle
+   player        Player
)

New initGame() function:

func initGame() {
    player = Player{
        position:     rl.Vector2{X: 400, Y: 200},
        speed:        rl.Vector2{X: 0.0, Y: 0.0},
        size:         rl.Vector2{X: tileSize, Y: tileSize},
        rotation:     0.0,
        acceleration: 0.0,
        isBoosting:   false,
    }
}

We need to add the new initialisation of the game to the init() function:

...
    texBackground = rl.LoadTexture("resources/space_background.png")

    spriteRec = rl.Rectangle{X: tileSize * 0, Y: tileSize * 2, Width: tileSize, Height: tileSize}

+   initGame()
}

Now we have a player object, we need to add it to the draw() in the main game loop:

...
    rl.DrawTexturePro(texBackground, bgSource, bgDest, rl.Vector2{X: 0, Y: 0}, 0, rl.White)

+   //Draw the player
+   player.Draw()

    // Draw the score to the screen
    rl.DrawText("Score 0", 10, 10, 20, rl.Gray)
...

Looks like that is all we need to draw the player, let's give it a shot and see if it works:

go run .

We should see our background image, and our new sprite drawn into the window in the middle of the screen:

Great!

We are successfully using the tilemap and drawing a sprite to the screen.

The code for this section can be found on my GitHub Repo

Implementing player movement

Next, we start to give the game some life, with some movement.

We want to move the player using the keyboard. So we will need to set up some code to manage the keyboard inputs and manipulate our sprite accordingly.

Let's start by creating some constants for the speed of the player and the rotation speed. This allows us to tweak it later.

const (
    screenWidth   = 800
    screenHeight  = 400
    tileSize      = 64
+   rotationSpeed = 2.0
+   playerSpeed   = 6.0
)

Now we have our variables, we can create an Update() method on our Player struct to move the player when the keyboard is used:

func (p *Player) Update() {

    // Rotate the player with the arrow keys
    if rl.IsKeyDown(rl.KeyLeft) {
        player.rotation -= rotationSpeed
    }
    if rl.IsKeyDown(rl.KeyRight) {
        player.rotation += rotationSpeed
    }

    // Accelerate the player with up
    if rl.IsKeyDown(rl.KeyUp) {
        if player.acceleration < 0.9 {
            player.acceleration += 0.1
        }
    }
    // Decellerate the player with down
    if rl.IsKeyDown(rl.KeyDown) {
        if player.acceleration > 0 {
            player.acceleration -= 0.05
        }
        if player.acceleration < 0 {
            player.acceleration = 0

        }
    }

    // Get the direction the sprite is pointing
    direction := getDirectionVector(player.rotation)

    // Start to move to the direction
    player.speed = rl.Vector2Scale(direction, playerSpeed)

    // Accelerate in that direction
    player.position.X += player.speed.X * player.acceleration
    player.position.Y -= player.speed.Y * player.acceleration

    // To void losing our ship, we wrap around the screen
    wrapPosition(&p.position, tileSize)
}

We start by capturing the KeyLeft and KeyRight events, then rotate the ship based on the direction. We capture KeyUp and KeyDown for acceleration.

To make it a little more realistic, the ship has no friction (Just like space!), so we need to actively decelerate to slow down.

We use the getDirectionVector to translate our rotation into a vector, and we use that vector to change the direction of the ship with the speed attribute. We then add the acceleration and the speed to the position to move the ship in that direction.

Finally, we use the wrapPosition function to wrap the position so our ship is not lost in space as soon as we leave the screen.

We need to create our getDirectionVector() function:

func getDirectionVector(rotation float32) rl.Vector2 {
    // Convert the rotation to radians
    radians := float64(rotation) * rl.Deg2rad

    // Return the vector of the direction we are pointing at
    return rl.Vector2{
        X: float32(math.Sin(radians)),
        Y: float32(math.Cos(radians)),
    }
}

And our wrapPostion() function:

func wrapPosition(pos *rl.Vector2, objectSize float32) {
    // If we go off the left side of the screen
    if pos.X > screenWidth+objectSize {
        pos.X = -objectSize
    }
    // If we go off the right side of the screen
    if pos.X < -objectSize {
        pos.X = screenWidth + objectSize
    }
    // If we go off the bottom of the screen
    if pos.Y > screenHeight+objectSize {
        pos.Y = -objectSize
    }
    // If we go off the top of the screen
    if pos.Y < -objectSize {
        pos.Y = screenHeight + objectSize
    }
}

Finally, we can replace our Update() method with the main game loop to move the ship each frame:

func update() {
    player.Update()
}

Let's run go run main.go to see if we can move the ship.

Amazing!

Our player is moving based on the keypresses from the arrow keys.

The code for this section can be found on my GitHub Repo

Adding a booster

To give the game a little moe realism, let's add a boost to the little ship, so it looks like that is how the ship is moving.

We already have the isBoosting attribute on the Player struct. Let's use that.

We will select another sprite from the tilemap and draw it only when we are boosting.

var (
    texTiles      rl.Texture2D
    texBackground rl.Texture2D
    spriteRec     rl.Rectangle
+   boostRec      rl.Rectangle
    player        Player
)

We create a new selection rectangle from the tilemap in the global game state.

        texBackground = rl.LoadTexture("resources/space_background.png")

+       // Sprites for the ship and it boost
        spriteRec = rl.Rectangle{X: tileSize * 0, Y: tileSize * 2, Width: tileSize, Height: tileSize}
+       boostRec = rl.Rectangle{X: tileSize * 7, Y: tileSize * 5, Width: tileSize, Height: tileSize}

        initGame()

We then select the tile we want to use. We want to use the yellow thrust pattern, which makes it look like the ship is activating its engine.

 func (p *Player) Draw() {
        destTexture := rl.Rectangle{X: p.position.X, Y: p.position.Y, Width: p.size.X, Height: p.size.Y}
+       if p.isBoosting {
+               rl.DrawTexturePro(
+                       texTiles,
+                       boostRec,
+                       destTexture,
+                       rl.Vector2{X: p.size.X / 2, Y: p.size.Y/2 - 40},
+                       p.rotation,
+                       rl.White,
+               )
+       }
        rl.DrawTexturePro(

We update the Draw() method on the Player struct to check if we are boosting; if we are, draw the boost sprite under the ship sprite.

        if rl.IsKeyDown(rl.KeyRight) {
                player.rotation += rotationSpeed
        }
+       // Default to not boosting
+       player.isBoosting = false

        // Accelerate the player with up
        if rl.IsKeyDown(rl.KeyUp) {
            if player.acceleration < 0.9 {
                player.acceleration += 0.1
            }
+            player.isBoosting = true
        }

Finally, we add a toggle on the acceleration action so isBoosting is true when accelerating and defaults to false when we are not.

Let's run the game with go run main.go

It now looks like our ship is using its engines to speed up!

The code for this section can be found on my GitHub Repo

Defining our Asteroids

Now that we have the player boosting and moving, we need to add the asteroids to the scene, so the player has something to dodge and shoot.

We start by following the same sprite selection pattern as before. We create a rectangle to select and we initialise it.

We also need a place to store the asteroids:

var (
    texTiles      rl.Texture2D
    texBackground rl.Texture2D
    spriteRec     rl.Rectangle
    boostRec      rl.Rectangle
+   asteroidRec   rl.Rectangle
+   asteroids     []Asteroid
    player        Player
)

We create an asteroidRec to select the sprite and an asteroids slice to store them in.

const (
    screenWidth      = 800
    screenHeight     = 400
    tileSize         = 64
    rotationSpeed    = 2.0
    playerSpeed      = 6.0
+   initialAsteroids = 5
)

We also add a constant for how many asteroids we want to spawn in to start with.

In the classic Asteroids manner, we are going to start with large asteroids. When we shoot them, they will break apart and spawn smaller asteroids.

To do this, we need a way to track the size of the asteroid. We can use an enum for this, though. Go does not have an enum construct; we can use the iota to create one:

// Enum for storing the size of the asteroid
type AsteroidSize int

const (
    Large AsteroidSize = iota
    Medium
    Small
)

Here, we create a new type AsteroidSize and provide it with three named options Large, Medium and Small. Under the hood, these are ints. However, we can now use them to make our code easier to read.

Now to create the Asteroid:

type Asteroid struct {
    position     rl.Vector2
    speed        rl.Vector2
    size         rl.Vector2
    asteroidSize AsteroidSize
}

func (a *Asteroid) Draw() {
    // Draw the asteroid to the screen
    destTexture := rl.Rectangle{X: a.position.X, Y: a.position.Y, Width: a.size.X, Height: a.size.Y}
    rl.DrawTexturePro(
        texTiles,
        asteroidRec,
        destTexture,
        rl.Vector2{X: a.size.X / 2, Y: a.size.Y / 2},
        0.0,
        rl.White,
    )
}

func (a *Asteroid) Update() {
    // Move the asteroid in its direction
    a.position = rl.Vector2Add(a.position, a.speed)

    // Wrap the position, so they are always on screen
    wrapPosition(&a.position, a.size.X)
}

We start with the Asteroid, which contains the position, size and speed vectors. We have the new asteroidSize to determine how big to draw the sprite.

We create the Draw() method to draw the sprite onto the screen.

In the Update() method, we add the speed to the position to move the asteroid and ensure that our asteroids wrap around the screen.

Creating Asteroids

Now that we have our Asteroid defined, we can start to create some when the game initialises. To do this, we create a helper function to generate a Large Asteroid in a random place, with a random speed and direction.

// Asteroid helper functions
func createLargeAsteroid() Asteroid {

    // Generate a random edge of the screen to spawn
    randomEdge := rl.GetRandomValue(0, 3)
    var position rl.Vector2

    // Generate a random position on screen
    randomX := float32(rl.GetRandomValue(0, screenWidth))
    randomY := float32(rl.GetRandomValue(0, screenHeight))

    switch randomEdge {
    case 0:
        position = rl.Vector2{X: randomX, Y: +tileSize}
    case 1:
        position = rl.Vector2{X: screenWidth + tileSize, Y: randomY}
    case 2:
        position = rl.Vector2{X: randomX, Y: screenHeight + tileSize}
    case 3:
        position = rl.Vector2{X: -tileSize, Y: randomY}
    }

    // Generate a random speed and direction for the asteroid
    speed := rl.Vector2{
        X: float32(rl.GetRandomValue(-10, 10)) / 10,
        Y: float32(rl.GetRandomValue(-10, 10)) / 10,
    }

    // Create the large asteroid
    return createAsteroid(Large, position, speed)
}

This function uses the getRandomValue function to generate a number between 0 and 3, which represent different sides of the screen. Then it creates a vector with a random speed. Finally, it passes it to another helper function to create the Asteroid.

func createAsteroid(asteroidSize AsteroidSize, position, speed rl.Vector2) Asteroid {

    // Scale the image of the asteroid based on the asteroidSize
    var size rl.Vector2
    switch asteroidSize {
    case Large:
        size = rl.Vector2{X: tileSize * 1.0, Y: tileSize * 1.0}
    case Medium:
        size = rl.Vector2{X: tileSize * 0.7, Y: tileSize * 0.7}
    case Small:
        size = rl.Vector2{X: tileSize * 0.4, Y: tileSize * 0.4}
    }

    // Create the asteroid
    return Asteroid{
        position:     position,
        speed:        speed,
        size:         size,
        asteroidSize: asteroidSize,
    }
}

This function takes in a size and its vectors and creates an Asteroid of that size at the vectors. The helper function can be reused later when we want to create more asteroids.

Finally, we need to update the initGame() function to create our initial set of asteroids.

func initGame() {
+    // Create the asteroids field
+    asteroids = nil
+    for range initialAsteroids {
+        asteroids = append(asteroids, createLargeAsteroid())
+    }

    // Create the player
    player = Player{

We will also need to define our selection rectangle in the init() function, for the asset in the tile map:

    // Sprites for the ship and it boost
    spriteRec = rl.Rectangle{X: tileSize * 0, Y: tileSize * 2, Width: tileSize, Height: tileSize}
    boostRec = rl.Rectangle{X: tileSize * 7, Y: tileSize * 5, Width: tileSize, Height: tileSize}

+    // Sprite for the asteroid
+    asteroidRec = rl.Rectangle{X: tileSize * 1, Y: tileSize * 4, Width: tileSize, Height: tileSize}
+
    initGame()
}

Now, let's run the game with go run main.go and see what we have:

We now have moving Asteroids!

The game is really coming to life now.

The code for this section can be found on my GitHub Repo

Enable collision detection

Next, let's add some interaction to the elements in the game.

We will start with collision detection between the player ship and the asteroids.

We will start with the consequence. The game should end when an asteroid hits the player.

We start by creating a Game Over mechanic by adding a global state for it:

var (
    texTiles      rl.Texture2D
    texBackground rl.Texture2D
    spriteRec     rl.Rectangle
    boostRec      rl.Rectangle
    asteroidRec   rl.Rectangle
    asteroids     []Asteroid
    player        Player
+   gameOver      bool
)

We initialise that to be false in the initGame() function:

func initGame() {
+
+   // Start with it not being game over
+   gameOver = false
+
    // Create the asteroids field
    asteroids = nil

When the game is over, we want our game to stop. We can do this by only running the update when it is NOT gameover:

func update() {
    // If it is not game over, update the frame
    if !gameOver {
        // Update the player
        player.Update()

        // Update the asteroid field
        for i := range asteroids {
            asteroids[i].Update()
        }

    }
}

Next, we draw the Game Over to the screen.

    // Draw the asteroid field
    for i := range asteroids {
        asteroids[i].Draw()
    }

+    if gameOver {
+        drawCenteredText("Game over", screenHeight/2, 50, rl.Red)
+    }

    // Draw the score to the screen
    rl.DrawText("Score 0", 10, 10, 20, rl.Gray)

We use a little helper function called drawCenteredText to measure how big our text is and then centre the text.

func drawCenteredText(text string, y, fontSize int32, color rl.Color) {
    textWidth := rl.MeasureText(text, fontSize)
    rl.DrawText(text, screenWidth/2-textWidth/2, y, fontSize, color)
}

Great, now we can terminate the game when an Asteroid hits the player.

Let's check for collisions in our update() function:

        for i := range asteroids {
            asteroids[i].Update()
        }

+        checkCollisions()

    }

Now we can define our function, which detects when the player has collided with an Asteroid:

func checkCollisions() {
    for i := len(asteroids) - 1; i >= 0; i-- {
        // Check for collision between player and asteroid
        if rl.CheckCollisionCircles(
            player.position,
            player.size.X/4,
            asteroids[i].position,
            asteroids[i].size.X/4,
        ) {
            gameOver = true

        }
    }
}

We loop through each asteroid, starting from the end of the slice to the front. For each asteroid, we run the CheckCollisionCircles function. This takes a position and a radius. We use the player's position and size. We do the same with the asteroid, including scaling the radius to ensure the boundary is around the object.

When there is a collision, we set gameOver to true.

Ok, let's see if this works:

Great, we are now detecting the collision between the player and the asteroids.

The code for this section can be found on my GitHub Repo

Making our ship shoot

Now that we have our asteroids able to end our game, it is time for us to equip our ship with the ability to fight back.

We will provide our ship with lasers to blast the asteroids.

First, let's create a struct for our laser:

type Shot struct {
    position rl.Vector2
    speed    rl.Vector2
    radius   float32
    active   bool
}

func (s *Shot) Draw() {
    if s.active {
        rl.DrawCircleV(s.position, s.radius, rl.Yellow)
    }
}

func (s *Shot) Update() {
    if s.active {
        s.position.X += s.speed.X
        s.position.Y -= s.speed.Y

        if s.position.X < 0 || s.position.X > screenWidth || s.position.Y < 0 || s.position.Y > screenHeight {
            s.active = false
        }
    }
}

Here we create a new Shot, which has the positional and size attributes with the addition of an active flag to determine if the shot should be drawn. We provide a Draw() and Update() method for rendering and moving the shot.

We need to create a slice to store our shots, then loop through them to update and draw them to the screen. So we start by creating some global state and some constants:

In the const

    playerSpeed      = 6.0
+   shotSpeed        = 8.0
+   maxShots         = 10
    initialAsteroids = 5

In the var

    player        Player
    gameOver      bool
+   shots         []Shot
)

We then initialise our slice in the init() function:

    asteroidRec = rl.Rectangle{X: tileSize * 1, Y: tileSize * 4, Width: tileSize, Height: tileSize}

+   // Create the shots
+   shots = make([]Shot, maxShots)

    initGame()

and update the initGame() to initalise the state:


        asteroids = append(asteroids, createLargeAsteroid())
    }

+   // Create the laser shots
+   for i := range shots {
+       shots[i].active = false
+   }

    // Create the player
    player = Player{

Now that we have our shots, we need to draw them and update them. Let's update game loopsdraw() to include the shots.

        asteroids[i].Draw()
    }

+   // Draw the shots
+   for i := range shots {
+       shots[i].Draw()
+   }

    if gameOver {

And the game loops update():

            asteroids[i].Update()
        }

+       // Update the shots
+       for i := range shots {
+           shots[i].Update()
+       }

        checkCollisions()

So we can now create, draw and update the shots when they are active. Let's create a way to fire a shot:

In the player's Update(), we add the ability to shoot when the Space bar is pressed:

    player.isBoosting = false

+   // Fire the lasers
+   if rl.IsKeyPressed(rl.KeySpace) {
+       fireShot()
+   }

    // Accelerate the player with up
    if rl.IsKeyDown(rl.KeyUp) {

Now we need the fireShot() function:

func fireShot() {
    for i := range shots {
        // Find the first inactive shot
        if !shots[i].active {
            // Start at the players position
            shots[i].position = player.position
            shots[i].active = true

            // Get the players direction
            shotDirection := getDirectionVector(player.rotation)

            // Get the initial velocity
            shotVelocity := rl.Vector2Scale(shotDirection, shotSpeed)
            // Account for the players speed
            playerVelocity := rl.Vector2Scale(player.speed, player.acceleration)

            // Fire the shot, relative to the players speed
            shots[i].speed = rl.Vector2Add(playerVelocity, shotVelocity)

            shots[i].radius = 2
            // Break after one shot
            break
        }
    }
}

To fire a shot, we loop through all the shots and find the first inactive one. We then set its position and direction to the same as the players.
As the ship could be moving, we want to fire the laser at a constant speed relative to the ship.
We do this by adding the player's speed onto the speed of our shot, to give it relative speed, so it looks like the shots are always faster than the ship.

Let's check our game to see if it is working by running go run main.go

Great, our ship now has weapons!

Though the lasers are not strong enough, they are passing right through the asteroids. Let's add some shot collisions so we can destroy the asteroids.

The code for this section can be found on my GitHub Repo

Implement asteroid splitting

We want our asteroids to split when they are hit. To do this, we will need to spawn more asteroid objects when the collision between the shot and the asteroid occurs.

The asteroids should get progressively smaller and faster. The behaviour we will use is:

Large -> 2 Medium
Medium -> 4 Small
Small -> Destroyed

Let's start by adding a counter for how many asteroids we have destroyed:

func checkCollisions() {
    for i := len(asteroids) - 1; i >= 0; i-- {
        // Check for collision between player and asteroid
        if rl.CheckCollisionCircles(
            player.position,
            player.size.X/4,
            asteroids[i].position,
            asteroids[i].size.X/4,
        ) {
            gameOver = true

        }

+       // Check for a collision between shots and the asteroid
+       for j := range shots {
+           // Loop through all the active shots
+           if shots[j].active {
+               // If it has collided with an asteroid
+               if rl.CheckCollisionCircles(
+                   shots[j].position,
+                   shots[j].radius,
+                   asteroids[i].position,
+                   asteroids[i].size.X/2,
+               ) {
+                   // Destroy the shot and split the asteroid
+                   shots[j].active = false
+
+                   // The asteroid shot split according to our rules
+                   splitAsteroid(asteroids[i])
+
+                   // Remove the original asteroid from the slice
+                   asteroids = append(asteroids[:i], asteroids[i+1:]...)
+
+                   // Increase our score
+                   asteriodsDestroyed++
+                   break
+               }
+           }
+
+       }
+   }
}

We loop through all the shots and check if they have hit an asteroid; if they have, we split the asteroid.
We use a separate function that contains our splitting called splitAsteroid().

func splitAsteroid(asteroid Asteroid) {
    // Do nothing for small
    if asteroid.asteroidSize == Small {
        return

    }

    // Work out how many splits to do
    var newSize AsteroidSize
    var split int
    if asteroid.asteroidSize == Large {
        newSize = Medium
        split = 2
    } else {
        newSize = Small
        split = 4
    }

    // Create the new smaller asteroids
    for range split {
        angle := float64(rl.GetRandomValue(0, 360))
        direction := getDirectionVector(float32(angle))
        speed := rl.Vector2Scale(direction, 2.0)
        newAsteroid := createAsteroid(newSize, asteroid.position, speed)
        asteroids = append(asteroids, newAsteroid)
    }
}

We start by checking how big the asteroid is. If it's small, we don't need to do anything.
If it is large or medium, we set out many splits we need to do and the new size, then use the createAsteroid function we created earlier to create a new asteroid.
We add that asteroid to the asteroids slice so I can be rendered into our game.

Finally, we are taking note of how many asteroids we have destroyed. Let's use this as our score.

In the draw() function, let's display the score:

        // Draw the score to the screen
-       rl.DrawText("Score 0", 10, 10, 20, rl.Gray)
+       rl.DrawText(fmt.Sprintf("Score %d", asteriodsDestroyed), 10, 10, 20, rl.Gray)

        rl.EndDrawing()

Ok, moment of truth, let's see if this is working. Run go run main.go:

It is working!

We are hitting the asteroid, and it is splitting apart. Our score is increasing, and we need to start dodging the debris.

The code for this section can be found on my GitHub Repo

Introduce a Game flow

Finally, let's make the game more playable. With a failure end state and a victory end state. We will also add a pause feature so players can stop the game.

Add two new states to var:

    gameOver           bool
+   paused             bool
+   victory            bool
    shots              []Shot

Set the initial state of the game in the initGame() function:

func initGame() {

+   // Start with it not being game over, pauses or victory
+   gameOver = false
+   victory = false
+   paused = false
+ 
+   // Reset score
+   asteriodsDestroyed = 0
...

We need a way to detect when the state changes. The update function is the perfect place for that:

func update() {
+   // If there are no asteroids left, we in
+   if len(asteroids) == 0 {
+       victory = true
+   }
+
+   // Toggle paused
+   if rl.IsKeyDown('P') {
+       paused = !paused
+   }
+
+   // Restart the game
+   if (gameOver || victory) && rl.IsKeyPressed('R') {
+       initGame()
+   }
+
+   // If it is not game over, update the frame
+   if !paused && !victory && !gameOver {
        // Update the player
        player.Update()

We call the initGame function again when we want to restart, as that function resets all the state, it restarts our game for us.

Finally, we need to update the draw() function to draw the UI for our players.

    if gameOver {
        drawCenteredText("Game over", screenHeight/2, 50, rl.Red)
+       drawCenteredText("Press R to restart", screenHeight/2+60, 20, rl.DarkGray)
+   }
+
+   if victory {
+       drawCenteredText("YOU WIN!", screenHeight/2, 50, rl.Gray)
+       drawCenteredText("Press R to restart", screenHeight/2+60, 20, rl.RayWhite)
    }

    // Draw the score to the screen
    rl.DrawText(fmt.Sprintf("Score %d", asteriodsDestroyed), 10, 10, 20, rl.Gray)
+   pauseTextSize := rl.MeasureText("[P]ause", 20)
+   rl.DrawText("[P]ause", screenWidth-pauseTextSize-10, 10, 20, rl.Gray)

    rl.EndDrawing()

Let's look at the final result with go run main.go:

The game now has four states: Running, Victory, Paused and GameOver.

The code for this section can be found on my GitHub Repo

Conclusion

Congratulations, We’ve built a full Asteroids-style game in Go using Raylib-go.

In this tutorial, we covered:

Creating windows with Raylib-go
Drawing textures and sprites from tilemaps
Implementing player movement with keyboard input
Adding physics-based acceleration and rotation
Creating dynamic game objects (asteroids)
Collision detection between game entities
Implementing shooting mechanics
Game flow management (pause, victory, game over states)

The complete source code is available on GitHub. Fork it, experiment with it, and share your improvements!

This project demonstrates how tools like Raylib make game development accessible while teaching fundamental concepts like collision detection, state management, and real-time rendering that apply across many domains.

If you found this useful, consider giving it a clap or sharing!

Build a Water Simulation in Go with Raylib-go

Tim Little — Fri, 26 Sep 2025 06:02:01 +0000

In this blog post, we will use raylib-go to create a lightweight water simulation for 2D games.

Water simulation

This post aims to create a simulation of water which flows naturally and presents the illusion of flow and volume. Fluid Simulation is a huge topic. To keep things simple, we will use cellular automation to update each cell.

Each cell will follow a set of rules:

Gravity — droplets fall straight down if there's space.
Side Flow — when blocked, water spreads left and right.
Pressure — when blocked on both sides, it flows diagonally.

Game setup

First, we set up the Go module and install the raylib-go package.

mkdir go-watersim
go mod init watersim
go get -v -u github.com/gen2brain/raylib-go/raylib

We create a Game struct to hold our game state and to manage the game loop. We create a Draw() method to draw its state to the screen by using the Draw() function on our Droplet, which represents the water.

type Game struct {
 Width    int
 Height   int
 State    [][]Droplet // 2D grid of water droplets [y][x]
 tileSize int
}

func (g *Game) Draw() {
 // Loop through each cell and call the cells Draw() method
 for y := range g.State {
  for x := 0; x < len(g.State[y]); x++ {
   g.State[y][x].Draw(x, y, g.tileSize)
  }
 }
}

Next, we create the Droplet entity and create a Draw() method to draw a single water droplet to the screen, represented by a blue square. To work with the cellular simulation, we convert the coordinates to cells.

type Droplet struct {
 volume float64 // How much water this cell contains (0.0 to 1.0)
 size   int
}

func (d *Droplet) Draw(x, y, tileSize int) {
 // Convert grid coordinates to pixel coordinates
 pixelX := x * tileSize
 pixelY := y * tileSize

 if d.volume > 0 {
  // Draw the blue water rectangle
  rl.DrawRectangle(int32(pixelX), int32(pixelY), int32(tileSize), int32(tileSize), rl.Blue)
 }
}

Next, we need to create the Game and its initial cellular state. To assist, we create helper functions to set up the Game and to create the initial state.

func NewGame(width, height, tileSize int) *Game {
 // Create a new game
 g := &Game{Width: width, Height: height, tileSize: tileSize}

 // Create the new game state
 // divide pixel dimensions by tile size to get grid size
 g.State = CreateGameState(g.Width/g.tileSize, g.Height/g.tileSize, tileSize)

 return g
}

func CreateGameState(newWidth, newHeight, tileSize int) [][]Droplet {
 // Create a new game state
 newState := make([][]Droplet, newHeight)

 // Loop through each row
 for y := range newHeight {

  // Create the columns
  newState[y] = make([]Droplet, newWidth)

  // Loop through each cell and create a Droplet
  for x := range newState[y] {
   newState[y][x] = Droplet{
    size: tileSize,
   }
  }
 }
 return newState
}

Finally, we update our main() function to initialise the raylib window and uses the new helper functions to create the game state and draw it to the screen.

 // Setup the new game
 var game = NewGame(800, 400, 10)

 // Initialize Raylib graphics window
 rl.InitWindow(int32(game.Width), int32(game.Height), "Water simulation")
 defer rl.CloseWindow()

 // Create a single water droplet and add it to the screen
 droplet := Droplet{size: game.tileSize, volume: 1.0}
 game.State[100/game.tileSize][400/game.tileSize] = droplet

 // Setup the frame per second rate
 rl.SetTargetFPS(20)

 // Main loop
 for !rl.WindowShouldClose() {

  // Begin to draw and set the background to black
  rl.BeginDrawing()
  rl.ClearBackground(rl.Black)

  // Draw the game state
  game.Draw()

  rl.EndDrawing()
 }

This provides us with a cellular grid, with a single water droplet drawn to the screen. Let's confirm this by running the program.

go run main.go

Water droplet on a black background

We see our Raylib window with a single blue square drawn on it, representing our water droplet. Not very impressive at the moment!

The code for this section of the guide is available on GitHub.

Logic Rules

We begin to bring life to the game by following logical rules to move the water in a fluid-like manner.

Flow and pressure rules for simulation

We start with the impact of gravity, which flows downwards and fills the cell below it. If there is no more water, the interaction is complete. If there is water remaining, the droplet will flow to the sides and diagonally.

Gravity

Gravity pulls the water droplet down at a constant rate. For our simulation, we need to check that the cell directly below the droplet has space, then transfer part of our volume to it.

To ensure there is space, we loop through the state from the bottom upwards. This ensures lower cells are processed first, to prevent water from "teleporting" through other cells.

We create an Update() method on the Game struct to process each frame. We apply the rules to the cell and then draw the new state to the screen.

func (g *Game) Update() {
 // Create a new state to avoid modifying the current state while reading it
 newState := CreateGameState(len(g.State[0]), len(g.State), g.tileSize)

 // Copy current state to new state
 for y := range g.State {
  copy(newState[y], g.State[y])
 }

 // Process the simulation from the bottom upwards
 for y := len(g.State) - 1; y >= 0; y-- {
  for x := range g.State[y] {

   // Only process cells that contain water
   if g.State[y][x].volume > 0 {

    // Check if we are at the bottom boundary
    if y+1 < len(g.State) {
     processWaterCell(x, y, &newState)
    }
   }
  }
 }

 // Replace old state with new calculated state
 g.State = newState

}

We create a new frame and copy the current state into it. We loop from the bottom to ensure we are not overfilling.

For each cell, we run the processWaterCell() method on it, which will apply our logical rules to the Droplet.

func processWaterCell(x, y int, newState *[][]Droplet) {
 // Try to flow downwards, as if by gravity
 fill(&(*newState)[y][x], &(*newState)[y+1][x], 1.0, 0.5)
}

This function is simple for now, it transfers the volume from the current cell to the one below it.

We use a fill() function, which transfers volume from one cell to another, and we use the remainder() function to calculate how much space is left in the target cell before transferring the volume to the new one. We rate limit the transfer with the flowRate to help the simulation feel smooth.

// Calculate how much more water a droplet can hold
func remainder(droplet Droplet, maxVolume float64) float64 {
 return maxVolume - droplet.volume
}

// Fill transfers water between two droplets at a controlled rate
func fill(current, target *Droplet, maxVolume, flowRate float64) {

 // Calculate how much water can be transferred
 transfer := remainder(*target, maxVolume)

 // Limit transfer to the flow rate (prevents instant teleportation)
 if transfer > flowRate {
  transfer = flowRate
 }

 // Move water from source to target
 current.volume -= transfer
 target.volume += transfer
}

Finally, we include our Update() method in our game loop to update the droplets:

                // Draw the game state
                game.Draw()

+               // Update the game state based on the rules
+               game.Update()
+
                rl.EndDrawing()

Now we can run the simulation and confirm we have a water droplet affected by gravity.

go run .

Water droplet affected by gravity

It works!

The water droplet is falling to the ground and stopping when it reaches the bottom of the screen.

However, it is getting duplicated as it falls, so two cells look like they are full.

We can resolve this by changing the height based on its volume and checking if the cell above has volume. If it does, we can fill from the top, if not, we fill from the bottom.

func (g *Game) Draw() {
 // Loop through each cell and call the cells Draw() method
 for y := range g.State {
  for x := 0; x < len(g.State[y]); x++ {

   // Check if there is water above this cell
   hasWaterAbove := y > 0 && g.State[y-1][x].volume > 0

   g.State[y][x].Draw(x, y, g.tileSize, hasWaterAbove)
  }
 }
}

We update our Game.Draw() method to check if there is water in the cell above. We pass this to the Droplet.Draw() method to decide on where to start filling from.

func (d *Droplet) Draw(x, y, tileSize int, hasWaterAbove bool) {
 // Convert grid coordinates to pixel coordinates
 pixelX := x * tileSize
 pixelY := y * tileSize

 if d.volume > 0 {
  // Calculate visual height based on water volume
  // Full volume (1.0) = full tile height, half volume (0.5) = half height
  height := int(float64(tileSize) * d.volume)

  // Fill up from the bottom
  offsetY := tileSize - height

  // If water above, fill from the top instead
  if hasWaterAbove {
   offsetY = 0
  }

  // Draw the blue water rectangle
  rl.DrawRectangle(int32(pixelX), int32(pixelY+offsetY), int32(tileSize), int32(height), rl.Blue)
 }

The Droplet.Draw() method calculates how high each cell should be based on volume and offsets the drawing by the volume amount to fill from the bottom. If there is water above it, we fill from the top.

Let's run our game now and see what the result is:

go run .

Smooth water fall

It looks much smoother now. The droplet is falling in a continuous motion to the bottom.

The code for this section can be found in the GitHub repository

Start a flow of water

Currently, we are generating a single droplet. However, we want a flow of water to see how the droplets interact with each other.

We do this by creating a helper function to generate Droplet objects.

func CreateWaterGenerator(x, y, tileSize int, state *[][]Droplet) {
 droplet := Droplet{size: tileSize, volume: 1.0}
 (*state)[y][x] = droplet
}

We replace the manual creation of the Droplet in the main game loop and count the number of frames to add water regularly.

-       // Create a single water droplet and add it to the screen
-       droplet := Droplet{size: game.tileSize, volume: 1.0}
-       game.State[100/game.tileSize][400/game.tileSize] = droplet
+       // Set up a counter, so we can spawn new water at a rate
+       frameCount := 0
+       flowStartX := 100 / game.tileSize
+       flowStartY := 100 / game.tileSize
+       CreateWaterGenerator(flowStartX, flowStartY, game.tileSize, &game.State)

        // Setup the frame per second rate
        rl.SetTargetFPS(20)

        // Main loop
        for !rl.WindowShouldClose() {
+               frameCount++

                // Begin to draw and set the background to black
                rl.BeginDrawing()
                rl.ClearBackground(rl.Black)

+               // Add new water every 5 frames (creates continuous water stream)
+               if frameCount%5 == 0 {
+                       CreateWaterGenerator(flowStartX, flowStartY, game.tileSize, &game.State)
+                       CreateWaterGenerator(flowStartX+1, flowStartY, game.tileSize, &game.State)
+                       CreateWaterGenerator(flowStartX-1, flowStartY, game.tileSize, &game.State)
+               }
+

Now, we run the program, we expect there to be water dripping from a point at the top of the screen.

go run .

Ah, that does not look right!

On the plus side, we have our Droplet objects continually following. On the downside, they are stacking on top of each other. We address that by adding sideways flow in the next section.

The code for this section can be found in the GitHub repository

Flow (Sideways)

The stacking is happening as droplets are incompressible and cannot flow downwards anymore. To fix this, we update our code to flow sideways.

We start by checking that there is water still in the cell. If there is, we start to flow the water out to the side cells.

 func processWaterCell(x, y int, newState *[][]Droplet) {
        // Try to flow downwards, as if by gravity
        fill(&(*newState)[y][x], &(*newState)[y+1][x], 1.0, 0.5)
+
+       // If all water flowed down, no need to continue
+       if (*newState)[y][x].volume == 0 {
+               return
+       }
+
+       // If water can still flow down, don't try other directions yet
+       if canFlowDown(x, y, newState) {
+               return
+       }
+
+       // Water spreads sideways when blocked below
+       tryHorizontalFlow(x, y, newState)
+
 }

The canFlowDown() checks if there is still space to flow downwards, if there is, we exit and process the remainder in the next frame.

The tryHorizontalFlow() method cascades to the left and the right. It checks the next 3 cells and adds a fraction of the remaining volume to the cells. This allows the water to "settle" when it cannot flow downwards.

func canFlowDown(x, y int, state *[][]Droplet) bool {
 return y+1 < len(*state) && (*state)[y+1][x].volume < 1.0
}

func tryHorizontalFlow(x, y int, state *[][]Droplet) {
 current := &(*state)[y][x]

 // Only cascade if there's water below
 hasWaterBelow := y+1 < len(*state) && (*state)[y+1][x].volume > 0.5
 if !hasWaterBelow {
  return
 }

 // Cascade right - distribute to multiple cells
 for offset := 1; offset <= 3 && x+offset < len((*state)[y]); offset++ {
  target := &(*state)[y][x+offset]
  if target.volume < current.volume {
   flowRate := (current.volume - target.volume) * 0.1 / float64(offset)
   fill(current, target, 1.0, flowRate)
  }
 }

 // Cascade left - distribute to multiple cells
 for offset := 1; offset <= 3 && x-offset >= 0; offset++ {
  target := &(*state)[y][x-offset]
  if target.volume < current.volume {
   flowRate := (current.volume - target.volume) * 0.1 / float64(offset)
   fill(current, target, 1.0, flowRate)
  }
 }
}

Now, when we run, we expect to see the water flow to the sides, with the surrounding cells taking a percentage of the water.

go run .

Sideways Flow

Excellent, the water is flowing to the side, spreading out and flowing along the bottom of the screen.

There is still stacking, and the effect is rather blocky at the edges. This is a result of volume still being in the current cell after the downward and sideways movement. Let's fix that in the next section.

The code for this section can be found in the GitHub repository

Pressure (diagonal)

To present a smoother flow of water, we can introduce more pressure dynamics. As water is incompressible, we would need the water to flow in all downward trajectories. Let's update the processWaterCell() function to try diagonal transfer when there is still volume.

 func processWaterCell(x, y int, newState *[][]Droplet) {
        // Try to flow downwards, as if by gravity
        fill(&(*newState)[y][x], &(*newState)[y+1][x], 1.0, 0.5)

        // If all water flowed down, no need to continue
        if (*newState)[y][x].volume == 0 {
                return
        }

        // If water can still flow down, don't try other directions yet
        if canFlowDown(x, y, newState) {
                return
        }

        // Water spreads sideways when blocked below
        tryHorizontalFlow(x, y, newState)

+       if (*newState)[y][x].volume > 0 {
+               tryDiagonalFlow(x, y, newState)
+       }
+
 }

We add a tryDiagonalFlow() function to flow diagonally. It checks that the target cell is within bounds and then transfers volume if there is space.

func tryDiagonalFlow(x, y int, state *[][]Droplet) {
 current := &(*state)[y][x]

 // Flow diagonally down-right if space is available
 if x+1 < len((*state)[y]) && y+1 < len(*state) && (*state)[y+1][x+1].volume < 1.0 {
  fill(current, &(*state)[y+1][x+1], 1.0, 0.25)
 }

 // Flow diagonally down-left if space is available
 if x > 0 && y+1 < len(*state) && (*state)[y+1][x-1].volume < 1.0 {
  fill(current, &(*state)[y+1][x-1], 1.0, 0.25)
 }
}

Let's run the program. We expect the water flow to be smoother and less blocky.

go run .

Smooth flow

Great! The water is smoother and is slowly filling the screen in tiny increments.

The code for this section can be found in the GitHub repository

Obstacles

At the moment, the water is falling to the bottom and flowing outwards. It is not very impressive.

Let's update the scene to include obstacles that the water interacts with. The water should be blocked by the obstacles and to flow over it like natural water.

We start by adding a flag to our cell to indicate if it is an obstacle.

 type Droplet struct {
-       volume float64 // How much water this cell contains (0.0 to 1.0)
-       size   int
+       volume     float64 // How much water this cell contains (0.0 to 1.0)
+       size       int
+       isObstacle bool // Is this cell an obstacle?
 }

We updated the Draw() method to draw an obstacle in brown rather than blue.

 func (d *Droplet) Draw(x, y, tileSize int, hasWaterAbove bool) {
        // Convert grid coordinates to pixel coordinates
        pixelX := x * tileSize
        pixelY := y * tileSize

+       if d.isObstacle {
+               // Draw obstacle as brown rectangle
+               rl.DrawRectangle(int32(pixelX), int32(pixelY), int32(tileSize), int32(tileSize), rl.Brown)
+       }
+
        if d.volume > 0 {
                // Calculate visual height based on water volume
                // Full volume (1.0) = full tile height, half volume (0.5) = half height
                height := int(float64(tileSize) * d.volume)

Next, we update our collision logic in our rules to ensure we are only flowing to cells which are not obstacles.

We start with the canFlowDown function:

 func canFlowDown(x, y int, state *[][]Droplet) bool {
-       return y+1 < len(*state) && (*state)[y+1][x].volume < 1.0
+       return y+1 < len(*state) && (*state)[y+1][x].volume < 1.0 && !(*state)[y+1][x].isObstacle
 }

Then the tryHorizontalFlow() function:

 func tryHorizontalFlow(x, y int, state *[][]Droplet) {
        current := &(*state)[y][x]

        // Only cascade if there's water below
        hasWaterBelow := y+1 < len(*state) && (*state)[y+1][x].volume > 0.5
        if !hasWaterBelow {
                return
        }

        // Cascade right - distribute to multiple cells
        for offset := 1; offset <= 3 && x+offset < len((*state)[y]); offset++ {
                target := &(*state)[y][x+offset]
-               if target.volume < current.volume {
+               if target.volume < current.volume && !target.isObstacle {
                        flowRate := (current.volume - target.volume) * 0.1 / float64(offset)
                        fill(current, target, 1.0, flowRate)
                }
        }

        // Cascade left - distribute to multiple cells
        for offset := 1; offset <= 3 && x-offset >= 0; offset++ {
                target := &(*state)[y][x-offset]
-               if target.volume < current.volume {
+               if target.volume < current.volume && !target.isObstacle {
                        flowRate := (current.volume - target.volume) * 0.1 / float64(offset)
                        fill(current, target, 1.0, flowRate)
                }
        }
 }

And finally the tryDiagonalFlow() function:

 func tryDiagonalFlow(x, y int, state *[][]Droplet) {
        current := &(*state)[y][x]

        // Flow diagonally down-right if space is available
-       if x+1 < len((*state)[y]) && y+1 < len(*state) && (*state)[y+1][x+1].volume < 1.0 {
+       if x+1 < len((*state)[y]) && y+1 < len(*state) && (*state)[y+1][x+1].volume < 1.0 && !(*state)[y+1][x+1].isObstacle {
                fill(current, &(*state)[y+1][x+1], 1.0, 0.25)
        }

        // Flow diagonally down-left if space is available
-       if x > 0 && y+1 < len(*state) && (*state)[y+1][x-1].volume < 1.0 {
+       if x > 0 && y+1 < len(*state) && (*state)[y+1][x-1].volume < 1.0 && !(*state)[y+1][x-1].isObstacle {
                fill(current, &(*state)[y+1][x-1], 1.0, 0.25)
        }
 }

We will also need to update the main gravity logic in the processWaterCell() function:

 func processWaterCell(x, y int, newState *[][]Droplet) {
-       // Try to flow downwards, as if by gravity
-       fill(&(*newState)[y][x], &(*newState)[y+1][x], 1.0, 0.5)
+       // Try to flow downwards, as if by gravity (but not into obstacles)
+       if y+1 < len(*newState) && !(*newState)[y+1][x].isObstacle {
+               fill(&(*newState)[y][x], &(*newState)[y+1][x], 1.0, 0.5)
+       }

Great!

Now we create some helper functions to create the obstacles on the screen.

func CreateHorizontalObstacle(x, y, size int, state *[][]Droplet) {
 for offset := range size {
  (*state)[y][x+offset].isObstacle = true
  (*state)[y+1][x+offset].isObstacle = true
  (*state)[y+2][x+offset].isObstacle = true
 }
}
func CreateVerticleObstacle(x, y, size int, state *[][]Droplet) {
 for offset := range size {
  (*state)[y+offset][x].isObstacle = true
  (*state)[y+offset][x+1].isObstacle = true
  (*state)[y+offset][x+2].isObstacle = true
 }
}

While we are looking at object creation, we can simplify the water generation code by using the same looping method.

func CreateWaterGenerator(x, y, tileSize int, state *[][]Droplet) {
-       droplet := Droplet{size: tileSize, volume: 1.0}
-       (*state)[y][x] = droplet
+       for xOffset := 0; xOffset <= 4; xOffset++ {
+               droplet := Droplet{size: tileSize, volume: 1.0}
+               (*state)[y][x+xOffset] = droplet
+
+       }
 }

Finally, we can update our main() function to add obstacles to block the path of the water and to DRY up the water generation code:

  func main() {
        // Setup the new game
        var game = NewGame(800, 400, 10)

        // Initialize Raylib graphics window
        rl.InitWindow(int32(game.Width), int32(game.Height), "Water simulation")
        defer rl.CloseWindow()

        // Set up a counter, so we can spawn new water at a rate
        frameCount := 0
-       flowStartX := 100 / game.tileSize
+       flowStartX := 400 / game.tileSize
        flowStartY := 100 / game.tileSize
        CreateWaterGenerator(flowStartX, flowStartY, game.tileSize, &game.State)

+       CreateVerticleObstacle(30, 20, 10, &game.State)
+
+       CreateHorizontalObstacle(0, 30, 50, &game.State)
+       CreateHorizontalObstacle(40, 20, 40, &game.State)
+

        // Setup the frame per second rate
        rl.SetTargetFPS(20)

        // Main loop
        for !rl.WindowShouldClose() {
                frameCount++

                // Begin to draw and set the background to black
                rl.BeginDrawing()
                rl.ClearBackground(rl.Black)

                // Add new water every 5 frames (creates continuous water stream)
-               if frameCount%5 == 0 {
+               if frameCount%3 == 0 {
                        CreateWaterGenerator(flowStartX, flowStartY, game.tileSize, &game.State)
-                       CreateWaterGenerator(flowStartX+1, flowStartY, game.tileSize, &game.State)
-                       CreateWaterGenerator(flowStartX-1, flowStartY, game.tileSize, &game.State)
                }

Moment of truth…

Let's run the code and see if it is flowing over the obstacles as we expect:

go run .

Water flowing down obstacles

Amazing, the water is flowing downwards until it reaches the obstacles, then it flows across the top of the obstacle until it reaches the side of the screen or another obstacle.

There is still stacking when water is falling on top of other water.

Insight: This doesn't really behave like water.
What we've built behaves more like sand than water. This approach is lightweight and fun for games that need falling particles like sand traps, dust, lava.

It might have been better to call this Sand Simulation!

Sand Simulation

The code for this section can be found in the GitHub repository

Closing the gap

This method works for a simple game that requires sand physics. Think of a sand avalanche in a side scroller that traps the player.

However, the water implementation would need some modification. It needs to calculate pressure, velocity and momentum to get the natural fluid motion.

We could go deeper, we would need to add water tension, viscosity and turbulence. The simulation would need to solve the Navier–Stokes equations for flow behaviours. An excellent example of this is Sebastian Lague's Simulating Fluids.

Conclusion

In this post, we:

Created a simple water/sand simulator using raylib-go
Use a simple set of rules to simulate complex behaviours
Added obstacles that the water would flow across

If you found this useful, consider giving it a clap or sharing! You can also check out the GitHub repo and try modifying the rules to create lava, smoke, or sand effects.

Next up, I am going to look into building a simple game with raylib-go, to explore more of the raylib library and to have a bit of fun with the output.

Also published to: