1 of 5

TileNodeNetwork

Introduction

The TileNodeNetwork object is a type of NodeNetwork which is designed specifically for tile-based games. Since the TileNodeNetwork object inherits from NodeNetwork, all available methods in NodeNetwork are available in TileNodeNetwork. Therefore, you should check out the NodeNetwork page for additional information and features on the TileNodeNetwork object. Normally a TileNodeNetwork is used when creating a game which uses tile maps.

For information on creating a TileNodeNetwork in the FlatRedBall Editor (this isthe most common approach), see the FlatRedBall Editor TileNodeNetwork page.

Benefits of the TileNodeNetwork

The TileNodeNetwork offers the following benefits:

Simple addition of tiles on a grid-based system using four or eight-way movement.
Quick index based ( O(1) ) tile finding
Concept of tile occupation to prevent multiple characters moving on the same tile.

Example - Creating a TileNodeNetwork In Code

The following code creates a TileNodeNetwork that is 10X10 with has a seed (bottom left tile) at 0,0. Add the following using statement:

using FlatRedBall.AI.Pathfinding;

Add the following to Initialize after initializing FlatRedBall:

float xSeed = 0;
float ySeed = 0;
float distanceBetweenNodes = 32;
int numberOfNodesX = 10;
int numberofNodesY = 10;

TileNodeNetwork tileNodeNetwork = new TileNodeNetwork(
    xSeed, 
    ySeed, 
    distanceBetweenNodes, 
    numberOfNodesX, 
    numberofNodesY, 
    DirectionalType.Four);

tileNodeNetwork.FillCompletely();

tileNodeNetwork.Visible = true;

Example - Creating a TileNodeNetwork from a TileMap in Code

The following code can be used to create a TileNodeNetwork using a loaded TMX file:

// Assuming WorldMap is a valid Tiled map

var tileNodeNetwork = new TileNodeNetwork(GridWidth / 2f,
    -WorldMap.Height + GridWidth / 2f,
    GridWidth,
    MathFunctions.RoundToInt(WorldMap.Width / WorldMap.WidthPerTile.Value),
    MathFunctions.RoundToInt(WorldMap.Height / WorldMap.HeightPerTile.Value)
    DirectionalType.Eight);

const string nameToLookFor = "PathTile";

foreach(var layer in WorldMap.MapLayers)
{
    var indexes = layer.NamedTileOrderedIndexes.ContainsKey(nameToLookFor) ? 
        layer.NamedTileOrderedIndexes[nameToLookFor] : null;

    if (indexes != null)
    {
        var count = indexes.Count;
        for (int i = count - 1; i > -1; i--)
        {
            float tileLeftX, tileBottomY;
            layer.GetBottomLeftWorldCoordinateForOrderedTile(indexes[i], out tileLeftX, out tileBottomY);
        
            // If we use the bottom-left position for adding a node network, floating point error may cause
            // the node to be positioned in one of four tiles that touch the corner. Shift the position up and
            // to the right to avoid this by GridWidth/2
            tileNodeNetwork.AddAndLinkTiledNodeWorld(tileLeftX + GridWidth/2.0f, tileBottomY + GridWidth/2.0f);
        }
    }
}

Note that the example above uses a name (PathTile) for simplicity, but you can also use properties. You simply have to convert the properties to a list of names:

...
var tileNamesForPath = WorldMap.TileProperties
                .Where(item => item.Value
                .Any(customProperty => customProperty.Name == "IsPath" && (string)customProperty.Value == "true"))
                .Select(item => item.Key)
                .ToArray();



foreach(var layer in WorldMap.MapLayers)
{
    foreach(var nameToLookFor in tileNamesForPath)
    {
        var indexes = layer.NamedTileOrderedIndexes.ContainsKey(nameToLookFor) ? 
            layer.NamedTileOrderedIndexes[nameToLookFor] : null;

        if (indexes != null)
        {
            ...
        }
    }
}

AddAndLinkTiledNode

Introduction

AddAndLinkTiledNode adds a new PositionedNode at the argument X, Y index at the argument DirectionType, or using the default DirectionType specified in the constructor if one isn't specified. This method uses indexes, where 0,0 is the bottom left of the TileNodeNetwork. Each index represents one tile, so if your TileNodeNetwork has a tile size of 16, then an X value of 1 would translate to 16 pixels further to the right than an X index of 0.

Code Example - Adding nodes manually

The following code adds a few nodes to a TileNodeNetwork using X,Y indexes.

void CustomInitialize()
{
    var left = -150;
    var bottom = -150;
    var gridSize = 32;
    var numberOfTilesWide = 30;
    var numberOfTilesTall = 30;

    var tileNodeNetwork = new TileNodeNetwork(left, bottom,
        gridSize, numberOfTilesWide, numberOfTilesTall, DirectionalType.Four);

    // add nodes at some positions at index X, Y
    // Note this is index and not world positions, 
    // so 0,0 will always be the bottom-left location
    // of the node network regardless of its actual world
    // position
    tileNodeNetwork.AddAndLinkTiledNode(0, 0);
    tileNodeNetwork.AddAndLinkTiledNode(1, 0);
    tileNodeNetwork.AddAndLinkTiledNode(2, 0);
    tileNodeNetwork.AddAndLinkTiledNode(3, 0);


    tileNodeNetwork.AddAndLinkTiledNode(2, 1);
    tileNodeNetwork.AddAndLinkTiledNode(3, 1);
    tileNodeNetwork.AddAndLinkTiledNode(4, 1);
    tileNodeNetwork.AddAndLinkTiledNode(5, 1);


    tileNodeNetwork.AddAndLinkTiledNode(2, 2);
    tileNodeNetwork.AddAndLinkTiledNode(2, 3);
    tileNodeNetwork.AddAndLinkTiledNode(2, 4);
    tileNodeNetwork.AddAndLinkTiledNode(2, 5);

    // So we can see the node network changes
    tileNodeNetwork.Visible = true;
}

Code Example - Adding Nodes with the Cursor

The following code can be used to add nodes with the cursor when the PrimaryDown value is true (left mouse button). The following code could be added to CustomActivity of a Screen which has access to a TileNodeNetwork.

var cursor = GuiManager.Cursor;

if(cursor.PrimaryDown)
{
    TileNodeNetwork.WorldToIndex(cursor.WorldX, cursor.WorldY, out int xIndex, out int yIndex);

    var nodeAtPoint = TileNodeNetwork.TiledNodeAt(xIndex, yIndex);
    if(nodeAtPoint == null)
    {
        TileNodeNetwork.AddAndLinkTiledNode(xIndex, yIndex);
        TileNodeNetwork.UpdateShapes();
    }
}

AddAndLinkTiledNodeWorld

Introduction

AddAndLinkTiledNodeWorld adds a new node at the given position, and links it to any adjacent nodes following the DirectionalType specified in the argument call, or using the default DirectionalType specified in the TileNodeNetwork's constructor.

Code Example: Adding Nodes by Clicking

The following code can be added to a screen to allow the user to click the mouse and add new nodes. Newly-created nodes will be connected to adjacent nodes using the DirectionType specified in the constructor (four-way).

// Define the TileNodeNetwork at class scope
// so we can access it in both CustomInitialize
// and CustomActivity
TileNodeNetwork tileNodeNetwork;

void CustomInitialize()
{
    var left = -200;
    var bottom = -200;
    var gridSize = 32;
    var numberOfTilesWide = 40;
    var numberOfTilesTall = 40;

    tileNodeNetwork = new TileNodeNetwork(left, bottom,
        gridSize, numberOfTilesWide, numberOfTilesTall, DirectionalType.Four);

    // So we can see the node network changes
    tileNodeNetwork.Visible = true;

    // So we can see the cursor
    FlatRedBallServices.Game.IsMouseVisible = true;
}

void CustomActivity(bool firstTimeCalled)
{
    var cursor = FlatRedBall.Gui.GuiManager.Cursor;

    if(cursor.PrimaryClick)
    {
        var worldX = cursor.WorldXAt(0);
        var worldY = cursor.WorldYAt(0);

        // See if there is an existing node there:
        var existingNode = tileNodeNetwork.TiledNodeAtWorld(worldX, worldY);

        if(existingNode == null)
        {
            tileNodeNetwork.AddAndLinkTiledNodeWorld(worldX, worldY);

            // So we can see the newly-added shapes
            tileNodeNetwork.UpdateShapes();
        }
    }
}

OccupyTileWorld

Introduction

OccupyTileWorld marks the tile at the given location (in world coordinates) as occupied. Occupied tiles can have an occupier which can be checked with the GetOccupier function. Note that occupied tiles will still be considered in pathfinding.

Code Example

The following code shows how to check if a tile is occupied, and if so, to move a character to the given tile. To keep the code shorter, it only considers moving in one direction.

// Assumes Player is a valid entity
if(InputManager.Keyboard.KeyDown(Keys.Right))
{
    var isTileOccupied = tileNodeNetwork.IsTileOccupiedWorld(
        Player.X + 16, // assumes tiles are 16 pixels
        Player.Y);

    if(!isTileOccupied)
    {
        // un-occupy the current tile:
        tileNodeNetwork.Unoccupy(this);

        tileNodeNetwork.OccupyTileWorld(
            Player.X + 16, 
            Player.Y,
            Player);

        // Move the player to the tile, either by setting the position
        // directly, or by setting velocity or doing some other form of 
        // interpolation.
    }
}

SetCosts

Introduction

Many games which have tile maps which also require pathfinding often include different terrain types. For example, a map may include regular terrain, water, and mountains. Terrain is important because certain units may be able to travel over certain terrain faster than other terrain. The SetCosts method allows for specifying the cost of travelling over certain terrain types quickly without modifying the cost of travelling across each Link in the NodeNetwork manually.

How it works

The SetCosts method requires the following steps:

The costs of each terrain type must be defined. These are defined in a float array
Each point on the tile which is not of the default type must have its terrain type set through the PositionedNode's PropertyField variable.
The TileNodeNetwork's SetCost method must be called with the float array containing the cost of each terrain as the argument.

Code Example

The following pieces of code show how a TileNodeNetwork can be set up for different terrain types. First the terrain types must be defined. Since they will be reused in multiple places we'll use an enum:

The following code assumes that tileNodeNetworkInstance is a valid TileNodeNetwork instance which has already hadd its nodes added:

TileNodeNetwork

Introduction

For information on creating a TileNodeNetwork in the FlatRedBall Editor (this isthe most common approach), see the FlatRedBall Editor TileNodeNetwork page.

Benefits of the TileNodeNetwork

The TileNodeNetwork offers the following benefits:

Simple addition of tiles on a grid-based system using four or eight-way movement.
Quick index based ( O(1) ) tile finding
Concept of tile occupation to prevent multiple characters moving on the same tile.

Example - Creating a TileNodeNetwork In Code

The following code creates a TileNodeNetwork that is 10X10 with has a seed (bottom left tile) at 0,0. Add the following using statement:

using FlatRedBall.AI.Pathfinding;

Add the following to Initialize after initializing FlatRedBall:

float xSeed = 0;
float ySeed = 0;
float distanceBetweenNodes = 32;
int numberOfNodesX = 10;
int numberofNodesY = 10;

TileNodeNetwork tileNodeNetwork = new TileNodeNetwork(
    xSeed, 
    ySeed, 
    distanceBetweenNodes, 
    numberOfNodesX, 
    numberofNodesY, 
    DirectionalType.Four);

tileNodeNetwork.FillCompletely();

tileNodeNetwork.Visible = true;

Example - Creating a TileNodeNetwork from a TileMap in Code

The following code can be used to create a TileNodeNetwork using a loaded TMX file:

// Assuming WorldMap is a valid Tiled map

var tileNodeNetwork = new TileNodeNetwork(GridWidth / 2f,
    -WorldMap.Height + GridWidth / 2f,
    GridWidth,
    MathFunctions.RoundToInt(WorldMap.Width / WorldMap.WidthPerTile.Value),
    MathFunctions.RoundToInt(WorldMap.Height / WorldMap.HeightPerTile.Value)
    DirectionalType.Eight);

const string nameToLookFor = "PathTile";

foreach(var layer in WorldMap.MapLayers)
{
    var indexes = layer.NamedTileOrderedIndexes.ContainsKey(nameToLookFor) ? 
        layer.NamedTileOrderedIndexes[nameToLookFor] : null;

    if (indexes != null)
    {
        var count = indexes.Count;
        for (int i = count - 1; i > -1; i--)
        {
            float tileLeftX, tileBottomY;
            layer.GetBottomLeftWorldCoordinateForOrderedTile(indexes[i], out tileLeftX, out tileBottomY);
        
            // If we use the bottom-left position for adding a node network, floating point error may cause
            // the node to be positioned in one of four tiles that touch the corner. Shift the position up and
            // to the right to avoid this by GridWidth/2
            tileNodeNetwork.AddAndLinkTiledNodeWorld(tileLeftX + GridWidth/2.0f, tileBottomY + GridWidth/2.0f);
        }
    }
}

Note that the example above uses a name (PathTile) for simplicity, but you can also use properties. You simply have to convert the properties to a list of names:

...
var tileNamesForPath = WorldMap.TileProperties
                .Where(item => item.Value
                .Any(customProperty => customProperty.Name == "IsPath" && (string)customProperty.Value == "true"))
                .Select(item => item.Key)
                .ToArray();



foreach(var layer in WorldMap.MapLayers)
{
    foreach(var nameToLookFor in tileNamesForPath)
    {
        var indexes = layer.NamedTileOrderedIndexes.ContainsKey(nameToLookFor) ? 
            layer.NamedTileOrderedIndexes[nameToLookFor] : null;

        if (indexes != null)
        {
            ...
        }
    }
}

AddAndLinkTiledNode

Introduction

Code Example - Adding nodes manually

The following code adds a few nodes to a TileNodeNetwork using X,Y indexes.

void CustomInitialize()
{
    var left = -150;
    var bottom = -150;
    var gridSize = 32;
    var numberOfTilesWide = 30;
    var numberOfTilesTall = 30;

    var tileNodeNetwork = new TileNodeNetwork(left, bottom,
        gridSize, numberOfTilesWide, numberOfTilesTall, DirectionalType.Four);

    // add nodes at some positions at index X, Y
    // Note this is index and not world positions, 
    // so 0,0 will always be the bottom-left location
    // of the node network regardless of its actual world
    // position
    tileNodeNetwork.AddAndLinkTiledNode(0, 0);
    tileNodeNetwork.AddAndLinkTiledNode(1, 0);
    tileNodeNetwork.AddAndLinkTiledNode(2, 0);
    tileNodeNetwork.AddAndLinkTiledNode(3, 0);


    tileNodeNetwork.AddAndLinkTiledNode(2, 1);
    tileNodeNetwork.AddAndLinkTiledNode(3, 1);
    tileNodeNetwork.AddAndLinkTiledNode(4, 1);
    tileNodeNetwork.AddAndLinkTiledNode(5, 1);


    tileNodeNetwork.AddAndLinkTiledNode(2, 2);
    tileNodeNetwork.AddAndLinkTiledNode(2, 3);
    tileNodeNetwork.AddAndLinkTiledNode(2, 4);
    tileNodeNetwork.AddAndLinkTiledNode(2, 5);

    // So we can see the node network changes
    tileNodeNetwork.Visible = true;
}

Code Example - Adding Nodes with the Cursor

var cursor = GuiManager.Cursor;

if(cursor.PrimaryDown)
{
    TileNodeNetwork.WorldToIndex(cursor.WorldX, cursor.WorldY, out int xIndex, out int yIndex);

    var nodeAtPoint = TileNodeNetwork.TiledNodeAt(xIndex, yIndex);
    if(nodeAtPoint == null)
    {
        TileNodeNetwork.AddAndLinkTiledNode(xIndex, yIndex);
        TileNodeNetwork.UpdateShapes();
    }
}