libgamemaps

libgamemaps provides a standard interface to access different game levels regardless of their file format.

Structure

The main interface to the library is the getManager() function, which returns an instance of the Manager class. The Manager is used to query supported map formats, and for each supported file format it returns an instance of the MapType class.

The MapType class can be used to examine files and check what file format they are in, and if they are in the correct format, to open them. Successfully opening a map produces an instance of the Map class. The MapType class can also be used to create new maps from scratch, which will again return a Map instance.

The Map class is used to directly manipulate map files, changing the level as it appears in-game. The Map class itself is a base class, and is extended in the form of the Map2D class for editing maps from platform-style games. There are currently no plans to implement a Map3D class (e.g. for Build games) however should someone be dedicated enough the library can support this.

Examples

The libgamemaps distribution comes with example code in the form of the gamemap utility, which provides a simple command-line interface to the full functionality of the library.

For a small "hello world" example, try this:

#include <camoto/stream_file.hpp>
#include <camoto/gamemaps.hpp>
#include <iostream>

using namespace camoto;
using namespace camoto::gamemaps;

int main(void)
{
  // Get hold of the Manager class
  ManagerPtr manager = getManager();

  // Use the manager to look up a particular map format
  MapTypePtr mapType = manager->getMapTypeByCode("map-xargon");

  // Open a map file on disk
  stream::file_sptr file(new stream::file());
  file->open("board_01.xr1");

  // We cheat here - we should check and load any supplementary files, but
  // for the sake of keeping this example simple we know this format doesn't
  // need any supps.
  camoto::SuppData supps;

  // Use the map format handler to read in the file we opened as a map
  MapPtr map;
  try {
    map = mapType->open(file, supps);
  } catch (const stream::open_error& e) {
    std::cerr << "Error opening map: " << e.what() << std::endl;
    return 1;
  }

  // See if the map is a 2D grid-based one
  Map2DPtr map2d = boost::dynamic_pointer_cast<Map2D>(map);
  if (map2d) {

    // It is, print the number of layers
    std::cout << "This map has " << map2d->getLayerCount() << " layers."
      << std::endl;

  } else {
    std::cout << "This map was not a 2D map." << std::endl;
  }

  // No cleanup required because all the Ptr variables are shared pointers,
  // which get destroyed automatically when they go out of scope (if nobody
  // else is using them!)

  return 0;
}

When run, this program produces output similar to the following:

This map has 2 layers.

More information

Additional information including a mailing list is available from the Camoto homepage http://www.shikadi.net/camoto.