Nice way to do this in modern OO C-like language?

Question

I have Tiles which represent the tiles in a game's 2-dimensional world. The tiles can have walls on any number of their 4 sides. I have something like this at the moment:

interface Tile {
    boolean isWallAtTop();
    boolean isWallAtRight();
    boolean isWallAtLeft();
    boolean isWallAtBottom();
}

Somewhere else I also have 16 images, one for each possible tile wall configuration. Something like this:

static final Image WALLS_ALL_AROUND = ...
static final Image WALL_ON_TOP_AND_RIGHT = ...
/* etc etc all 16 possibilities */

I want to write a

static Image getWallImage(Tile tile)

What I'd like to avoid is the torture of going through the possibilities like

if (tile.isWallTop && tile.isWallRight 
    && !tile.isWallBottom && !tile.isWallLeft) {
    return WALL_ON_TOP_AND_RIGHT;
}

Does anyone know a cuter way to do this?

Answer 1

Can't you do something with flag enums ?

Answer 2

Go go gadget bitmasks. Use a 4 bit mask for each tile, stating which side has a wall.

A B C D

Bit A indicates a wall on the top, B the right, C the bottom, D the left. Define constants to help you that you can just logically intersect with the mask, i.e.

if (tile.Walls & (WALL_LEFT | WALL_RIGHT))
  // Do stuff

For finding the image, this 4 bit mask produces the 16 possibilities. Use it as an index into an images "array", so you can directly find the correct image without any effort.

Answer 3

You should put the wall configuration into a single variable and build a mapping of this variable to the tile images.

Answer 4

Do the tile objects have any other properties? If not (or if you can factor out those), you could make the tile objects themselves into an enumeration of 16 constants with a Tile.getImage() method that returns a fixed image passed to the constructor. This is known as the Flyweight pattern:

class Tile {
    public final boolean isWallAtTop;
    public final boolean isWallAtRight;
    public final boolean isWallAtLeft;
    public final boolean isWallAtBottom;
    public final Image image;

    private Tile(boolean top, boolean right, boolean left, 
                 boolean bottom, Image image)
    {
        this.isWallAtTop = top;
        this.isWallAtRight = right;
        this.isWallAtLeft = left;
        this.isWallAtBottom = bottom;
        this.image = image;
    }

    public static final Tile WALLS_ALL_AROUND = 
        new Tile(true, true, true, true, new Image("allWalls.png"))
    // more constants here, plus other methods that work with
    // only the wall data
}

In Java, you could even implement this as a "real" enum.

For a map that consists of tiles, you could either have a simple 2-dimensional array of Tile references, or if you need other data for individual tiles, have another SpecificTile class that contains the "other data" and a reference to one of the Tile objects above.

Answer 5

I suggest creating a bit flag enum like the following.

[Flags]
public enum WallLocations
{
    None = 0,
    Left = 1,
    Right = 2,
    Top = 4,
    Bottom = 8
}

Then you can use a dictionary to map from the wall locations to the images.

Dictionary<WallLocations, Image> map = new Dictionary<WallLocations, Image>();

map.Add(WallLocations.None, image0000);
map.Add(WallLocations.Left, image1000);
map.Add(WallLocations.Right, image0100);
map.Add(WallLocations.Top, image0010);
map.Add(WallLocations.Bottom, image0001);
map.Add(WallLocations.Left | WallLocations.Right, image1100);
// ....

At least in C# you could also extend the enum definition with all 16 cases.

[Flags]
public enum WallLocations
{
    None = 0,

    Left = 1,
    Right = 2,
    Top = 4,
    Bottom = 8,

    LeftAndRight = Left | Right,
    LeftAndTop = Left | Top,
    LeftAndBottom = Left | Bottom,
    RightAndTop = Right | Top,
    RightAndBottom = Left | Bottom,
    TopAndBottom = Top | Bottom,

    AllExceptLeft = Right | Top | Bottom,
    AllExceptRight = Left | Top | Bottom,
    AllExceptTop = Left | Right | Bottom,
    AllExceptBottom = Left | Right | Top,

    All = Left | Right | Top | Bottom
}

Answer 6

Instead of making WALLS_ALL_AROUND an image, make it an object that includes the image, and also any other logic necessary for dealing with allowed movements and whatnot. The in a Location object you can just set the walls property to that WALLS_ALL_AROUND, which you can query for the image and have deal with your other wall-related logic.

Since you only need sixteen instances of these (immutable) objects for each set of images (each one is probably a singleton sublcass of Tile if you have only one set of images), you also save memory.

Answer 7

A decent OO solution would probably involve the Strategy Pattern. One possible implementation would be to have a WallConfiguration class, and a WallFactory to create them. A Tile would then contain a WallConfiguration. Implementation (C++ style) would look something like this:

class Tile
{
private:
    WallConfiguration walls;
    // Other Tile data

public:
    enum Walls
    { 
        TOP,
        BOTTOM,
        LEFT,
        RIGHT,
        TOP_RIGHT,
        TOP_LEFT
        // Fill in the rest
    }; //Enums have a place!
    Tile(Walls wall)
    {
        walls = WallFactory.getConfiguration(wall);
    }

One of the interesting advantages to this is that now, when you add the ability to blow up walls (and c'mon...you know you're going to, 'cuz we all like blowing things up), you can add that responsibility to the WallConfiguration class, which will know how to get the proper instance of itself when you blow up the left wall, for example.