This project is read-only.
Support GameFX with a paypal donation

Project Description
The Game Development Framework (GameFX) is simply a set of libraries to be used as the foundation for any simple 2D tile-based game. It can be used to build games such as PacMan, Snake, Tetris, and even Chess.

GameFX will handle tile-based maps, graphics, and pathfinding AI.

Click Here if you wish to review a complete tutorial were we will go through step-by-step the development of this project. We will start with the idea, after that we will go through the process of designing the program, thinking through all of the important details that all programmers must think about. Finally we will hammer out all of the necessary code to make it work.

Building and reusing a framework greatly simplifies the task of actually developing the game. You don't have to think about all of the tedium of mapping, graphics, and AI because it has been separated and encapsulated.

It is like building a box with buttons, knobs, and switches. We are going build a box that has all of the mechanisms inside that deal with the logic of handling maps, drawing map graphics, and finding paths. On the outside of that box we will have the hypothetical buttons, switches, and knobs to manipulate the maps, pathfinder, and graphics engine. Doing it that way makes it much simpler and easier to use. If we didn't do it, we would be tinkering around inside of it for every game that we build.

Using the code
GameFX will handle tile-based maps, graphics, and pathfinding, so we can divide GameFX into those three main categories.

Let's start with tile-mapping. The highest-level functioning unit of tile-mapping is of course the TileMap. The basic unit of a TileMap is a Tile which uses Coordinates.

Good, we have broken down the first category (tile-mapping) into three functional components that can be put together to preform the functions of tile-mapping.

* Tile (the basic unit of a tile map)
* TileMap (a 2D map of Tiles that can be operated on)
* Coordinate (a simple data type that represents X,Y values on a TileMap)

Here we have the Graphics Engine.

* GraphicsEngine (the mechanism that graphically renders a TileMap)

We can break down the pathfinding category into these three components.

* Node (an interesting mechanism used in finding a path from one coordinate to another)
* NodeHeap (a sorted storage mechanism that is key to the A* pathfinding algorithm)
* SimplePathFinder (the mechanism that finds the path from one coordinate to another on a TileMap)

Here is the simplest working example of GameFX. The code simply creates a 10x10 map of Tiles of type Byte. 0 represents the floor, 1 represents the path, and 2 represents a wall. The Graphics Engine will draw the map to Form1, all changes to the map will be rendered in real-time. There is a wall in the middle of the map. The Pathfinder will find the path from the upper left corner to the bottom right corner.

using HenizeSoftware.GameFX.PathFinding;
using HenizeSoftware.GameFX.TileMap;

namespace WindowsFormsApplication1
  public partial class Form1 : Form
    TileMap<byte> myMap;
    GraphicsEngine<byte> gfx;
    SimplePathFinder<byte> path;
    public Form1()

    private void button1_Click(object sender, EventArgs e)
      myMap = new TileMap<byte>(10, 10);
      gfx = new GraphicsEngine<byte>(myMap, this.CreateGraphics(), 10, 10, RenderMode.OnChanged);
      path = new SimplePathFinder<byte>(myMap);

      path.ResistanceDictionary.Add(2, 255);
      path.Start = new Coordinate(0, 0);
      path.End = new Coordinate(9, 9);

      gfx.ColorDictionary.Add(0, Color.Black);
      gfx.ColorDictionary.Add(1, Color.Pink);
      gfx.ColorDictionary.Add(2, Color.White);


      for (ushort i = 8; i > 0; i--) //draw wall down the middle
        myMap[4, i].Value = 2;

    private void Form1_Paint(object sender, PaintEventArgs e)
      if(gfx != null)

    private void button2_Click(object sender, EventArgs e)
      foreach (Coordinate c in path.GetFullPath())
        myMap[c].Value = 1;

Points of interest
There may be some minor bugs in the code that I have not yet discovered. However I have developed a test program allows you to create maps of any size, and drop as many snakes as your computer can handle onto the map. The snakes run around on the map in competition for food. You can draw on the map while it's running. It also allows you to use bitmapped graphics if you choose to draw them. The speed can also be adjusted.

First you must click New Map before you can do anything. You also cannot remove the last snake.

The code is pretty self explanatory, however I will go over the core of the sample program, the part that makes it all tick.

     //Each snake has its own pathfinder. For each snake on the map, find the path to the food and increment the snake toward it.
    private void timer_Tick(object sender, EventArgs e)
      //Go through all of the snakes that are currently on the map
      for (int i = 0; i < snakeList.Count; i++)
        //If the snake being processed has eaten the food then find a new place to drop food, and then tell all the other snakes
        //the new location of the food.
        if (snakeList[i].HeadCoordinate == pathFinderList[i].End)
          //Drop new food on clear area of map
          while (true)
            food = new Coordinate((ushort)rnd.Next(0, map.Width - 1), (ushort)rnd.Next(0, map.Height - 1));
            if (map[food].Value == SLThTile.Floor) break;

          //Tell the other snakes the new location of the food.
          foreach(SimplePathFinder<SLThTile> p in pathFinderList)
            p.End = food;
          map[food].Value = SLThTile.Food;

          if (btnAutoGrow.Checked == true)

        Coordinate next = new Coordinate(); //default 0,0 incase Snake is trapped.

        //Try to find the path to the food.
          next = pathFinderList[i].GetNextMove();
        catch (PathNotFoundException)
          snakeList[i].Reverse(); //if no path found then make the snake reverse.

        //Figure out the general direction the snake needs to go.
        if (next.X == snakeList[i].HeadCoordinate.X && next.Y < snakeList[i].HeadCoordinate.Y)
          snakeList[i].Direction = SnakeDirection.Up;
        else if (next.X == snakeList[i].HeadCoordinate.X && next.Y > snakeList[i].HeadCoordinate.Y)
          snakeList[i].Direction = SnakeDirection.Down;
        else if (next.X > snakeList[i].HeadCoordinate.X && next.Y == snakeList[i].HeadCoordinate.Y)
          snakeList[i].Direction = SnakeDirection.Right;
        else if (next.X < snakeList[i].HeadCoordinate.X && next.Y == snakeList[i].HeadCoordinate.Y)
          snakeList[i].Direction = SnakeDirection.Left;


        pathFinderList[i].Start = snakeList[i].HeadCoordinate;


The capabilities of GameFX far exceed the example shown here. Bitmapped graphics, and many configurations are available by simply initiating and configuring properties. Don't be afraid to check it out, might be useful for one of your projects.

If you would like a more detailed article Click Here

Here is a class diagram for GameFX.

Cannot resolve image macro, invalid image name or id.

Support GameFX with a paypal donation

Last edited May 25, 2010 at 11:57 PM by jhenize, version 4