Forem: Sean Callaway

Grogue: A Roguelike Tutorial in Go (Part 4)

Sean Callaway — Tue, 12 Mar 2024 18:58:09 +0000

Happy New Year and welcome back to part 4 of my Rougelike tutorial in Go! (EDIT: It's been 2024 for a while now, as I've been busy and wasn't able to get this published when I initially intended.)

We now have a dungeon that we can move around, but we're not really exploring it if we can see it all from start. We should implement a "field of view" for the player to allow only a limited range around them to be seen.

This can be a rather complicated thing to code, but luckily norendren had already created a library that will do the hard work for us.

Let's start by adding the following import to level.go:

    "github.com/norendren/go-fov/fov"

Then add an *fov.View to the Level structure.

    PlayerView *fov.View

We also need to instantiate this View, so in NewLevel() add the following:

    l.PlayerView = fov.New()

Save the file and run go mod tidy to pull down the new library.

The next thing to do is to modify our Level's Draw() to only render what the player can see. We'll do this by wrapping the four lines inside the nested loops in an if statement, as seen below.

// Draw the current level to 'screen'.
func (level *Level) Draw(screen *ebiten.Image) {
    gd := NewGameData()
    for x := 0; x < gd.ScreenWidth; x++ {
        for y := 0; y < gd.ScreenHeight; y++ {  // NEW
            if level.PlayerView.IsVisible(x, y) {
                tile := level.Tiles[GetIndexFromCoords(x, y)]
                op := &ebiten.DrawImageOptions{}
                op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
                screen.DrawImage(tile.Image, op)
            } // NEW
        }
    }
}

For this to work, we need to tell the event system to calculate the player's field of view. Add the new line to the if !tile.Blocked {} in HandleInput() in event.go:

    if !tile.Blocked {
        g.Player.X += dx
        g.Player.Y += dy
        g.CurrentLevel.PlayerView.Compute(g.CurrentLevel, g.Player.X, g.Player.Y, 8)  // NEW
    }

At this time, you may notice that your editor (or the go CLI, if you tried to run) complains about g.CurrentLevel in the call to Compute().

./event.go:27:37: cannot use g.CurrentLevel (variable of type *Level) as fov.GridMap value in argument to g.CurrentLevel.PlayerView.Compute: *Level does not implement fov.GridMap (missing method InBounds)

This library needs us to add a few functions to Level{}, so let's go back to level.go and add them now.

// Determine if tile coordinates are on the screen.
func (level Level) InBounds(x int, y int) bool {
    gd := NewGameData()
    if x < 0 || x > gd.ScreenWidth || y < 0 || y > gd.ScreenHeight {
        return false
    }
    return true
}

// Determines if a tile at a given coordinate can be seen through.
func (level Level) IsOpaque(x int, y int) bool {
    return level.Tiles[GetIndexFromCoords(x, y)].Opaque
}

Now if we run the game, it should look something like this.

Drawing the Past

It would be cool if we showed the map tiles that we've already seen (though not the monsters that may have moved into those rooms). In order to implement such a change, we should add a flag to our MapTile{} to indicate whether or not it has been seen.

    Seen    bool

This should be set to false by default in NewTile().

    tile := MapTile{
        PixelX:  x,
        PixelY:  y,
        Blocked: blocked,
        Opaque:  opaque,
        Seen:    false,   // NEW
        Image:   image,
    }

We'll want to render these seen-but-out-of-sight tiles in a different color, so we'll use the colorm portion of the Ebitengine. Add the following line to your imports in level.go:

    "github.com/hajimehoshi/ebiten/v2/colorm"

Refactor the inside of the nested for loops in Draw() again.

            idx := GetIndexFromCoords(x, y)
            tile := level.Tiles[idx]
            if level.PlayerView.IsVisible(x, y) {
                op := &ebiten.DrawImageOptions{}
                op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
                screen.DrawImage(tile.Image, op)
                level.Tiles[idx].Seen = true
            } else if tile.Seen {
                op := &colorm.DrawImageOptions{}
                var colorM colorm.ColorM
                op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
                colorM.Translate(0, 0, 50, 0.75)
                colorm.DrawImage(screen, tile.Image, colorM, op)
            }

We move the assignment of the tile variable outside of the if statement, as we need it in both conditions. The visible condition should look the same, except that we set the tile's Seen flag to true.

The else if part is more interesting. We use the colorm package to do the GeoM transformation (placing it in the right part of the screen), to perform a color matrix transformation (tinting it blue), and to draw the tinted image.

Run the game and you'll see something like this after moving around a bit.

Slowing Down

With FOV done, we should solve the main issue we currently have: the player moves too fast. Instead of moving the player on each call to Game.Update(), let's ensure some time has passed first.

In main.go add the following to our Game struct:

    TickCount    int

and set it to zero in NewGame():

    g.TickCount = 0

Now, modify Game.Update() to increment TickCount and only call HandleInput() when TickCount is greater than five.

func (g *Game) Update() error {
    g.TickCount++

    if g.TickCount > 5 {
        HandleInput(g)
        g.TickCount = 0
    }
    return nil
}

When you run the game now, the player should move at a much more reasonable rate.

You can view the complete source code here and if you have any questions, please feel free to ask them in the comments.

Grogue: A Roguelike Tutorial in Go (Part 3)

Sean Callaway — Fri, 27 Oct 2023 20:58:50 +0000

In Part 1, we create the dungeon as a large, empty room with walls around the edge. In this part, we'll modify our dungeon generation code to start by filling the entire map with walls and then carving out rooms and connecting them with tunnels.

Start by creating a structure we'll use to create our rooms. Add the following code to level.go:

type RectangularRoom struct {
    X1 int
    Y1 int
    X2 int
    Y2 int
}

// Create a new RectangularRoom structure.
func NewRectangularRoom(x int, y int, width int, height int) RectangularRoom {
    return RectangularRoom{
        X1: x,
        Y1: y,
        X2: x + width,
        Y2: y + height,
    }
}

The constructor takes the x and y coordinates of the top-level corner and computes the bottom right corner based on the width and height parameters.

In order to create tunnels between rooms, we'll also need a function to calculate the center of the room.

// Returns the tile coordinates of the center of the RectangularRoom.
func (r *RectangularRoom) Center() (int, int) {
    centerX := (r.X1 + r.X2) / 2
    centerY := (r.Y1 + r.Y2) / 2
    return centerX, centerY
}

To ensure that our rooms are surrounded by at least one layer of wall tile, we should create a function that returns the interior of the room:

// Returns the tile coordinates of the interior of the RectangularRoom.
func (r *RectangularRoom) Interior() (int, int, int, int) {
    return r.X1 + 1, r.X2 - 1, r.Y1 + 1, r.Y2 - 1
}

Using this, we can modify our createTiles() function, but we also want to keep track of our rooms, so we should add a slice of Rooms to our Level structure first.

type Level struct {
    Tiles []MapTile
    Rooms []RectangularRoom  // NEW
}

Then let's refactor createTiles() to make a pair of rooms. (Don't worry, we'll get to procedural generation later.)

func (level *Level) createTiles() {
    gd := NewGameData()
    tiles := make([]MapTile, gd.ScreenHeight*gd.ScreenWidth)

    // Fill with wall tiles
    for x := 0; x < gd.ScreenWidth; x++ {
        for y := 0; y < gd.ScreenHeight; y++ {
            idx := GetIndexFromCoords(x, y)
            wall, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileWall)
            if err != nil {
                log.Fatal(err)
            }
            tiles[idx] = wall
        }
    }
    level.Tiles = tiles

    room1 := NewRectangularRoom(25, 15, 10, 15)
    room2 := NewRectangularRoom(40, 15, 10, 15)
    level.Rooms = append(level.Rooms, room1, room2)

    for _, room := range level.Rooms {
        x1, x2, y1, y2 := room.Interior()
        for x := x1; x <= x2; x++ {
            for y := y1; y <= y2; y++ {
                idx := GetIndexFromCoords(x, y)
                floor, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileFloor)
                if err != nil {
                    log.Fatal(err)
                }
                level.Tiles[idx] = floor
            }
        }
    }
}

Our first nested loops now fill the entire level with wall tiles. We then create new rooms and add them to the level's list of rooms. Finally, we iterate through all of the level's rooms and carve out their interiors by making them floor tiles.

Unfortunately, our player isn't in a room anymore, so let's modify NewGame() in main.go to put the player in the center of the first room by changing the line where we create the player.

    startX, startY := g.CurrentLevel.Rooms[0].Center()
    player, err := NewEntity(startX, startY, "player")

Run the game and you'll find the player in the first of two rooms.

Tunneling Along

That's cool and all, but the player is trapped in the first room. That just won't do. We need to create tunnels between rooms.

Let's start be creating a pair of private helper functions that will create vertical and horizontal tunnels.

// Create a vertical tunnel.
func (level *Level) createVerticalTunnel(y1 int, y2 int, x int) {
    gd := NewGameData()
    for y := min(y1, y2); y < max(y1, y2)+1; y++ {
        idx := GetIndexFromCoords(x, y)

        if idx > 0 && idx < gd.ScreenHeight*gd.ScreenWidth {
            floor, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileFloor)
            if err != nil {
                log.Fatal(err)
            }
            level.Tiles[idx] = floor
        }
    }
}

// Create a horizontal tunnel.
func (level *Level) createHorizontalTunnel(x1 int, x2 int, y int) {
    gd := NewGameData()
    for x := min(x1, x2); x < max(x1, x2)+1; x++ {
        idx := GetIndexFromCoords(x, y)

        if idx > 0 && idx < gd.ScreenHeight*gd.ScreenWidth {
            floor, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileFloor)
            if err != nil {
                log.Fatal(err)
            }
            level.Tiles[idx] = floor
        }
    }
}

createVerticalTunnel() takes three arguments: a starting position on the Y-axis, an ending position on the Y-axis, and the X-coordinate. It then converts all tiles from x, y1 to x, y2 into floor tiles. createHorizontalTunnel() does the same thing, but on the X-axis instead of the Y.

We'll use both of these to tunnel from one room to another.

// Tunnel from this first room to second room.
func (level *Level) tunnelBetween(first *RectangularRoom, second *RectangularRoom) {
    startX, startY := first.Center()
    endX, endY := second.Center()

    if rand.Intn(2) == 0 {
        // Tunnel horizontally, then vertically
        level.createHorizontalTunnel(startX, endX, startY)
        level.createVerticalTunnel(startY, endY, endX)
    } else {
        // Tunnel vertically, then horizontally
        level.createVerticalTunnel(startY, endY, startX)
        level.createHorizontalTunnel(startX, endX, endY)
    }
}

This private function takes two RectangularRooms as arguments and tunnels from one to the next. It generates a random number (don't forget to add "math/rand" to your list of imports!) and uses that to determine whether to first tunnel vertically or horizontally. It then utilizes those helper functions to do the actual tunneling.

We can now use this function inside createTiles() to connect the two rooms we made.

    // Carve out rooms
    for roomNum, room := range level.Rooms {  // NEW
        x1, x2, y1, y2 := room.Interior()
        for x := x1; x <= x2; x++ {
            for y := y1; y <= y2; y++ {
                idx := GetIndexFromCoords(x, y)
                floor, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileFloor)
                if err != nil {
                    log.Fatal(err)
                }
                level.Tiles[idx] = floor
            }
        }
        if roomNum > 0 { // NEW
            level.tunnelBetween(&level.Rooms[roomNum-1], &level.Rooms[roomNum])  // NEW
        }  // NEW
    }

We changed the start of the for loop from for _, room to for roomNum, room because we now need to know which room we're working on. After the room is carved, we then tunnel from this room, to the previous room (if there is a previous room).

If you run the game now, it should look like this.

More Rooms

Now that our room and tunnel functions work, it's time to move on to the actual dungeon generation. It'll be fairly simple: place rooms one at a time, make sure they don't overlap, then connect them with tunnels.

To do that, we'll need a function to determine if two rooms overlap.

// Determines if this room intersects with otherRoom.
func (r *RectangularRoom) IntersectsWith(otherRoom RectangularRoom) bool {
    return r.X1 <= otherRoom.X2 && r.X2 >= otherRoom.X1 && r.Y1 <= otherRoom.Y2 && r.Y2 >= otherRoom.Y1
}

We'll need a few more variables in GameData to determine the minimum and maximum size of the rooms as well as the maximum number of rooms one floor can have.

type GameData struct {
    ScreenWidth  int
    ScreenHeight int
    TileWidth    int
    TileHeight   int
    MaxRoomSize  int  // NEW
    MinRoomSize  int  // NEW
    MaxRooms     int  // NEW
}

// Creates a new instance of the static game data.
func NewGameData() GameData {
    gd := GameData{
        ScreenWidth:  80,
        ScreenHeight: 50,
        TileWidth:    16,
        TileHeight:   16,
        MaxRoomSize:  10,  // NEW
        MinRoomSize:  6,   // NEW
        MaxRooms:     30,  // NEW
    }
    return gd
}

With these variables in place, modify createTiles() replacing

    room1 := NewRectangularRoom(25, 15, 10, 15)
    room2 := NewRectangularRoom(40, 15, 10, 15)
    level.Rooms = append(level.Rooms, room1, room2)

with the following:

    for i := 0; i <= gd.MaxRooms; i++ {
        // generate width and height as random numbers between gd.MinRoomSize and gd.MaxRoomSize
        width := rand.Intn(gd.MaxRoomSize-gd.MinRoomSize+1) + gd.MinRoomSize
        height := rand.Intn(gd.MaxRoomSize-gd.MinRoomSize+1) + gd.MinRoomSize

        xPos := rand.Intn(gd.ScreenWidth - width)
        yPos := rand.Intn(gd.ScreenHeight - height)

        newRoom := NewRectangularRoom(xPos, yPos, width, height)

        isOkay := true
        for _, room := range level.Rooms {
            // check through all existing rooms to ensure newRoom doesn't intersect
            if newRoom.IntersectsWith(room) {
                isOkay = false
                break
            }
        }

        if isOkay {
            level.Rooms = append(level.Rooms, newRoom)
        }
    }

This one is a bit complicated, so let's break it apart.

width := rand.Intn(gd.MaxRoomSize-gd.MinRoomSize+1) + gd.MinRoomSize
height := rand.Intn(gd.MaxRoomSize-gd.MinRoomSize+1) + gd.MinRoomSize

This uses rand.Intn() to generate random widths and heights between gd.MinRoomSize (if rand.Intn() returns 0) and gd.MaxRoomSize (if rand.Intn() returns it's maximum value, which is gd.MaxRoomSize-gd.MinRoomSize in this case).

xPos := rand.Intn(gd.ScreenWidth - width)
yPos := rand.Intn(gd.ScreenHeight - height)

We then do a similar thing to grab the x- and y-coordinates of the top-left corner of the room, but ensure that our room doesn't extend off the edge of the map.

newRoom := NewRectangularRoom(xPos, yPos, width, height)

isOkay := true
for _, room := range level.Rooms {
    // check through all existing rooms to ensure newRoom doesn't intersect
    if newRoom.IntersectsWith(room) {
        isOkay = false
        break
    }
}

After creating a room with the new random specifications, we loop through all of the previously placed rooms and see if this new room intersects with them. If it does, we flag this room as not okay and stop the loop.

if isOkay {
    level.Rooms = append(level.Rooms, newRoom)
}

If we made it through the whole list without finding an intersection, we then add the room to the level's list of rooms.

Not too bad, right?

If you run the game now, you should see something similar to the following (but not the same, because it's random).

That's it! We have a functioning dungeon generation algorithm.

You can view the complete source code here and if you have any questions, please feel free to ask them in the comments.

Grogue: A Roguelike Tutorial in Go (Part 2)

Sean Callaway — Mon, 16 Oct 2023 14:00:30 +0000

Now that we're drawing the map on the screen, we need to add a player and have them move around on the map. Before diving in and creating a Player structure, we should probably consider how we want to handle all of the creatures or entities that will be moving around the map.

Let's create a structure that represents not just the player, but just about everything we may want to represent on the map: enemies, items, and whatever else we dream up.

Create a new file called entity.go and add in the the following structure and constructor function:


package main

import (
    "github.com/hajimehoshi/ebiten/v2"
    "github.com/hajimehoshi/ebiten/v2/ebitenutil"
)

type Entity struct {
    X     int
    Y     int
    Image *ebiten.Image
}

// Create an Entity object at tile coordinates 'x, y' represented by a PNG named 'imageName'.
func NewEntity(x int, y int, imageName string) (Entity, error) {
    image, _, err := ebitenutil.NewImageFromFile("assets/" + imageName + ".png")
    if err != nil {
        return Entity{}, err
    }

    entity := Entity{
        X:     x,
        Y:     y,
        Image: image,
    }
    return entity, nil
}

This should look familiar, as it's very similar to what we did with MapTile{} in the previous part. Our constructor takes three arguments:

x: the tile coordinate on the x-axis of the map
y: the tile coordinate on the y-axis of the map
imageName: the root of the PNG filename in the assets folder that will represent this entity

As usual when loading an image, we return the error if there is one, otherwise, we return the new Entity{}.

The other function an entity needs is the ability to move. Let's add that now.

// Move the entity by a given amount.
func (entity *Entity) Move(dx int, dy int) {
    entity.X += dx
    entity.Y += dy
}

In main.go, add a slice of Entities.

type Game struct {
    Levels []Level
    Entity []Entity  // NEW
}

The player also needs to be instantiated in NewGame(). Add this block before the return statement.

    player, err := NewEntity(40, 25, "player")
    if err != nil {
        log.Fatal(err)
    }
    g.Entities = append(g.Entities, player)

We do need to add a player asset, so grab that here and save it as assets/player.png. This sprite is from Tri-Tachyon on OpenGameArt.

With that downloaded, we need a system to render all of our Entities on the map. Create a new file called render.go and add the following contents:

package main

import "github.com/hajimehoshi/ebiten/v2"

// Renders all of the entities in a given game onto screen.
func RenderEntities(g *Game, level Level, screen *ebiten.Image) {
    for _, entity := range g.Entities {
        idx := GetIndexFromCoords(entity.X, entity.Y)
        tile := level.Tiles[idx]
        op := &ebiten.DrawImageOptions{}
        op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
        screen.DrawImage(entity.Image, op)
    }
}

This iterates though all of the Entities in game, determines where they belong on the screen, and draws them. Of course nothing calls this function yet, so nothing gets drawn, but we're about to change that. Add a call to the function at the end of the Draw() function in main.go:

    RenderEntities(g, level, screen)

Now, run the game using go run . and you'll see the player drawn in the middle of the screen.

Moving Around

With our player drawn on the screen, now we need to move them around. We'll want to make the player Entity a bit easier to access, though, so let's add a pointer to the player in the Game:

type Game struct {
    Levels   []Level
    Entities []Entity
    Player   *Entity  // NEW
}

// Creates a new Game object and initializes the data.
func NewGame() *Game {
    g := &Game{}
    g.Levels = append(g.Levels, NewLevel())

    player, err := NewEntity(40, 25, "player")
    if err != nil {
        log.Fatal(err)
    }
    g.Entities = append(g.Entities, player)
    g.Player = &g.Entities[0]  // NEW
    return g
}

We can now access the player using g.Player instead of having to determine where it is in the Entities slice. It would be nice if we could access the current level that way, too, so add a Level pointer called CurrentLevel to the Game structure:

    CurrentLevel *Level

and assign it in NewGame() after appending NewLevel() to g.Levels:

    g.CurrentLevel = &g.Levels[0]

This will be very useful when we have more than just a single level.

Now create a new file called event.go and include the following:

package main

import "github.com/hajimehoshi/ebiten/v2"

// Handle user input, including moving the player.
func HandleInput(g *Game) {
    dx := 0
    dy := 0

    // Player Movement
    if ebiten.IsKeyPressed(ebiten.KeyW) {
        dy = -1
    } else if ebiten.IsKeyPressed(ebiten.KeyS) {
        dy = 1
    }
    if ebiten.IsKeyPressed(ebiten.KeyA) {
        dx = -1
    } else if ebiten.IsKeyPressed(ebiten.KeyD) {
        dx = 1
    }

    newPos := GetIndexFromCoords(g.Player.X+dx, g.Player.Y+dy)
    tile := g.CurrentLevel.Tiles[newPos]
    if !tile.Blocked {
        g.Player.X += dx
        g.Player.Y += dy
    }
}

This function checks for WASD key inputs and sets the movement delta appropriately. Then, it finds the tile that the movement would put the player in and checks to see if it is blocked. If it's not, we move adjust the player's position appropriately.

Add a call to this new function at the top of Update() in main.go

    HandleInput(g)

then run the game. Use the WASD keys and watch the player zip around the screen (we'll fix the speed later).

Part 2 is now complete! We've laid the groundwork for generating dungeons and moving through them and will start building actual dungeons in the next part.

You can view the complete source code here and if you have any questions, please feel free to ask them in the comments.

Grogue: A Roguelike Tutorial in Go (Part 1)

Sean Callaway — Tue, 10 Oct 2023 15:33:25 +0000

Welcome to part one of this series which will help you create your a roguelike game written in Go! This is based largely on the Roguebasin libtcod tutorial, which has proven very helpful in getting fledgling roguelike-devs off the ground.

If you haven't already completed the steps outlined in Part 0, please go back and do that now.

With our dependencies installed and validated, let's grab a few neat tiles created by by Jere Sikstus. Download wall.png and floor.png and place them in a folder called assets/ inside our project folder.

Humble Beginnings

Let's refactor our Hello, World from Part 0 into something we can continue to use.

Go ahead and remove the contents of the Draw() and add a new function just beneath the definition of the Game type.

// Creates a new Game object and initializes the data.
func NewGame() *Game {
    g := &Game{}
    return g
}

This constructor will create a new Game object for us, which is currently empty, but will be expanded as we continue along.

Now change the contents of our main function:

func main() {
    g := NewGame()
    ebiten.SetWindowTitle("Grogue")
    ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)

    if err := ebiten.RunGame(g); err != nil {
        log.Fatal(err)
    }
}

This code should be fairly self-explanitory: create a new game, set the window title to "Grogue," allow the window to be resized, then run the game and log any crashes.

Run your code with go run . and you should see the following:

The Simplest of Maps

We've created an empty window. It's a start, but we still have more to do in this part.

Let's create a new file called level.go, which will hold our code related to the game's level. Add the following to the file:

package main

import (
    "log"

    "github.com/hajimehoshi/ebiten/v2"
    "github.com/hajimehoshi/ebiten/v2/ebitenutil"
)

This should look similar to the top of main.go in part 0.

Create a struct for holding our static game data:

type GameData struct {
    ScreenWidth int
    ScreenHeight int
    TileWidth int
    TileHeight int
}

and create a constructor to go with it:

// Creates a new instance of the static game data.
func NewGameData() GameData {
    gd := GameData{
        ScreenWidth: 80,
        ScreenHeight: 50,
        TileWidth: 16,
        TileHeight: 16,
    }
    return gd
}

Here we set that our tiles are 16x16 and that our screen is 80 tiles wide and 50 tiles high. However, if you multiply these values, you'll notice that it doesn't match the screen size we set in the Layout() function in main.go. So, let's fix that.

func (g *Game) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
    gd := NewGameData()
    return gd.TileWidth * gd.ScreenWidth, gd.TileHeight * gd.ScreenHeight
}

This will utilize that GameData struct we just created to calculate the size of the window, so we shouldn't need to change this again if we decided to modify the values inside NewGameData().

Since most roguelikes are tile-based, we should probably create a structure to hold our individual tiles on the map.

type MapTile struct {
    PixelX int
    PixelY int
    Blocked bool
    Opaque bool
    Image *ebiten.Image
}

This hold the X and Y values (PixelX and PixelY, respectively) of the upper left corner of the tile, whether or not this tile blocks creatures' movement, whether or not the tile can been seen through, and a pointer to the ebiten.Image object storing the actual graphic for the tile.

Since we will be storing each of our 4,000 (80 columns x 50 rows) tiles in one of these, we should optimize their storage which means storing them in a single slice instead of a two dimensional array. We'll then create a quick helper function to return the index of the tile based on X and Y coordinates.

// Returns the logical index of the map slice from given X and Y tile coordinates.
func GetIndexFromCoords(x int, y int) int {
    gd := NewGameData()
    return (y * gd.ScreenWidth) + x
}

Since we'll be creating a lot of tiles, we should create a MapTile constructor.

const (
    TileFloor string = "floor"
    TileWall  string = "wall"
)

// Creates a MapTile of a given type at pixels x, y.
//
//  Supported types include 'Floor' and 'Wall'
func NewTile(x int, y int, tileType string) (MapTile, error) {
    blocked := true
    opaque := true

    image, _, err := ebitenutil.NewImageFromFile("assets/" + tileType + ".png")
    if err != nil {
        return MapTile{}, err
    }

    if tileType == TileFloor {
        blocked = false
        opaque = false
    }

    tile := MapTile{
        PixelX:  x,
        PixelY:  y,
        Blocked: blocked,
        Opaque:  opaque,
        Image:   image,
    }
    return tile, nil
}

This defines a set of constants for the types of tiles we have and makes it easier to extend later when we want to add doors or stairs.

Then, we utilize ebitenutil.NewImageFromFile() to load one of the tiles we added, set the properties of the tile, and return it. Since we're using PNG images, we'll need to add _ "image/png" to the import section, making it look like this:

import (
    _ "image/png"
    "log"

    "github.com/hajimehoshi/ebiten/v2"
    "github.com/hajimehoshi/ebiten/v2/ebitenutil"
)

Since we are going to be creating a lot of tiles, we should probably have something better than a simple slice to store them. Create a new structure called Level and give it a constructor.

type Level struct {
    Tiles []MapTile
}

// Creates a new Level object
func NewLevel() Level {
    l := Level{}
    return l
}

Once we have those in place, let's create a private function that builds the initial map: all floor tiles bordered by a wall.

// Creates a simple map in level.Tiles
func (level *Level) createTiles() {
    gd := NewGameData()
    tiles := make([]MapTile, gd.ScreenHeight*gd.ScreenWidth)

    for x := 0; x < gd.ScreenWidth; x++ {
        for y := 0; y < gd.ScreenHeight; y++ {
            idx := GetIndexFromCoords(x, y)
            if x == 0 || x == gd.ScreenWidth-1 || y == 0 || y == gd.ScreenHeight-1 {
                wall, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileWall)
                if err != nil {
                    log.Fatal(err)
                }
                tiles[idx] = wall
            } else {
                floor, err := NewTile(x*gd.TileWidth, y*gd.TileHeight, TileFloor)
                if err != nil {
                    log.Fatal(err)
                }
                tiles[idx] = floor
            }
        }
    }
    level.Tiles = tiles
}

Now update the Level constructor to call CreateTiles(), adding the following line before the return call:

    l.createTiles()

We should also create a Draw() function that draws the current level.

// Draw the current level to 'screen'.
func (level *Level) Draw(screen *ebiten.Image) {
    gd := NewGameData()
    for x := 0; x < gd.ScreenWidth; x++ {
        for y := 0; y < gd.ScreenHeight; y++ {
            tile := level.Tiles[GetIndexFromCoords(x, y)]
            op := &ebiten.DrawImageOptions{}
            op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
            screen.DrawImage(tile.Image, op)
        }
    }
}

With that complete, we're finished with level.go for this part. Save the file and return to main.go.

In our Game struct, add the following:

    Levels []Level

and add the following line to the NewGame() function just above the return statement:

    g.Levels = append(g.Levels, NewLevel())

Now the game will load our map as the first level.

Finally, we need to go into the Draw() function and have it actually draw the map.

    gd := NewGameData()
    level := g.Levels[0]
    for x := 0; x < gd.ScreenWidth; x++ {
        for y := 0; y < gd.ScreenHeight; y++ {
            tile := level.Tiles[GetIndexFromCoords(x, y)]
            op := &ebiten.DrawImageOptions{}
            op.GeoM.Translate(float64(tile.PixelX), float64(tile.PixelY))
            screen.DrawImage(tile.Image, op)
        }
    }

Now if you run the game (go run .), you should see the following:

That's it for this part. We've added the basic structures to hold a map, a very simple map creation function, and have rendered it to the screen.

You can view the complete source code here and if you have any questions, please feel free to ask them in the comments.

Grogue: A Roguelike Tutorial in Go (Part 0)

Sean Callaway — Mon, 09 Oct 2023 18:46:27 +0000

Are you interested in the Go programming language and creating a roguelike game? This tutorial will help you build the basics of a roguelike game in thirteen parts. Those parts will be:

Drawing on the Screen
Entities and the Map
Generating a Dungeon
Field of View
Enemies
Doing Damage (and Taking Some, Too)
Adding an Interface
Items and Inventory
Ranged Attacks
Saving and Loading
Deeper into the Dungeon
Increasing the Difficulty (of the Game)
Gearing Up

In this part 0, we'll get the base of the project set up.

Prior Knowledge

This tutorial assumes you have a basic knowledge of Go and are capable of running commands on your operating system's command-line interface.

Installation

To follow along with this tutorial, you'll need Go version 1.21 or later. On MacOS, you can use Homebrew to install this (brew install go). Instructions for other operating systems can be found here.

You'll also need an IDE with support for Go such as Visual Studio Code, GoLand, or Sublime Text.

Hello, World!

In the folder where you keep your projects (~/Projects, for me), create a new folder called grogue and move into it.

mkdir grogue
cd grogue

Then, initialize the Go project.

go mod init grogue

Now, create a new file main.go and add the following contents:

package main

import (
    "log"

    "github.com/hajimehoshi/ebiten/v2"
    "github.com/hajimehoshi/ebiten/v2/ebitenutil"
)

type Game struct{}

func (g *Game) Update() error {
    return nil
}

func (g *Game) Draw(screen *ebiten.Image) {
    ebitenutil.DebugPrint(screen, "Hello, World!")
}

func (g *Game) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
    return 320, 240
}

func main() {
    ebiten.SetWindowSize(640, 480)
    ebiten.SetWindowTitle("Hello, World!")
    if err := ebiten.RunGame(&Game{}); err != nil {
        log.Fatal(err)
    }
}

Run go mod tidy to pull in the dependencies for our project (the Ebitengine) then run the project with go run ..

You should see a window that looks something like this:

If that works, you're ready for Part 1, which will be out soon!

Source Code

The complete source code for this part is available here.