Restructured the way the world is loaded

The World class was removed and replaced by the RealizingSystem and RealizableComponent. The realizable entity is intended to be a singleton and to represent the world. The Map class was also removed and integrated into the MappableComponent.

These changes are to facilitate implementation of map objects without needing special intermediary objects (including the Map class). Now, map entities are created as soon as the world is created, and map object entities will be as well. They will simply be deactivated while the map is not active. Multiple players are now slightly better supported, which will be important in the future.

This will likely become inefficient as the world becomes bigger, and some sort of sector-loading process will have to be designed. This also reduces the usefulness of EntityManager's entity-searching capabilities (which are not the most efficiently implemented currently anyway), and will likely in the future require some added functionality to better search subsets of entities.

A lot of the components were also rewritten to use bare member variables instead of accessor methods, as they never had special functionality and just took up space. These components were also documented.

22 files changed, 1154 insertions, 1040 deletions

@@ -8,88 +8,86 @@
 class AnimatableComponent : public Component {
 public:
 
+  /**
+   * Constructor for initializing the animation set, because it is not default
+   * constructible.
+   */
   AnimatableComponent(
-    AnimationSet animationSet,
-    std::string animation) :
-      animationSet_(std::move(animationSet)),
-      animation_(std::move(animation))
+    AnimationSet animationSet) :
+      animationSet(std::move(animationSet))
   {
   }
 
-  inline size_t getFrame() const
-  {
-    return frame_;
-  }
-
-  inline void setFrame(size_t v)
-  {
-    frame_ = v;
-  }
-
-  inline size_t getCountdown() const
-  {
-    return countdown_;
-  }
-
-  inline void setCountdown(size_t v)
-  {
-    countdown_ = v;
-  }
-
-  inline const AnimationSet& getAnimationSet() const
-  {
-    return animationSet_;
-  }
-
+  /**
+   * The animation set that this entity will use -- an object describing the
+   * different animations that can be used to render the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  AnimationSet animationSet;
+
+  /**
+   * The name of the currently active animation.
+   *
+   * @managed_by AnimatingSystem
+   */
+  std::string animation;
+
+  /**
+   * For prototypes, the name of the original animation.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::string origAnimation;
+
+  /**
+   * Helper method for accessing the currently active animation.
+   */
   inline const Animation& getAnimation() const
   {
-    return animationSet_.getAnimation(animation_);
+    return animationSet.getAnimation(animation);
   }
 
-  inline void setAnimation(std::string animation)
-  {
-    animation_ = std::move(animation);
-  }
-
-  inline bool isFlickering() const
-  {
-    return flickering_;
-  }
-
-  inline void setFlickering(bool v)
-  {
-    flickering_ = v;
-  }
-
-  inline size_t getFlickerTimer() const
-  {
-    return flickerTimer_;
-  }
-
-  inline void setFlickerTimer(size_t v)
-  {
-    flickerTimer_ = v;
-  }
-
-  inline bool isFrozen() const
-  {
-    return frozen_;
-  }
-
-  inline void setFrozen(bool v)
-  {
-    frozen_ = v;
-  }
-
-private:
-
-  AnimationSet animationSet_;
-  std::string animation_;
-  size_t frame_ = 0;
-  size_t countdown_ = 0;
-  bool flickering_ = false;
-  size_t flickerTimer_ = 0;
-  bool frozen_ = false;
+  /**
+   * The frame of animation that is currently being rendered.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t frame = 0;
+
+  /**
+   * The amount of time (in game frames) before the animation is advanced.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t countdown = 0;
+
+  /**
+   * This option allows to give the sprite a "flickering" effect (as in, it is
+   * not rendered in some frames).
+   */
+  bool flickering = false;
+
+  /**
+   * Used for the flickering effect.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t flickerTimer = 0;
+
+  /**
+   * If enabled, this will prevent the sprite's animation from progressing (but
+   * will not affect things such as placement on screen and flickering).
+   */
+  bool frozen = false;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the animating
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
 };
 
 #endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */
@@ -2,14 +2,47 @@
 #define MAPPABLE_H_0B0316FB
 
 #include <map>
+#include <string>
+#include <vector>
+#include <list>
 #include "component.h"
 #include "renderer/texture.h"
 #include "collision.h"
-#include "map.h"
+#include "entity_manager.h"
 
 class MappableComponent : public Component {
 public:
 
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Helper type that stores information about map adjacency.
+   */
+  class Adjacent {
+  public:
+
+    enum class Type {
+      wall,
+      wrap,
+      warp,
+      reverse
+    };
+
+    Adjacent(
+      Type type = Type::wall,
+      size_t mapId = 0) :
+        type(type),
+        mapId(mapId)
+    {
+    }
+
+    Type type;
+    size_t mapId;
+  };
+
+  /**
+   * Helper type that stores information about collision boundaries.
+   */
   class Boundary {
   public:
 
@@ -20,121 +53,100 @@ public:
       double lower,
       double upper,
       Type type) :
-        axis_(axis),
-        lower_(lower),
-        upper_(upper),
-        type_(type)
-    {
-    }
-
-    inline double getAxis() const
-    {
-      return axis_;
-    }
-
-    inline double getLower() const
-    {
-      return lower_;
-    }
-
-    inline double getUpper() const
-    {
-      return upper_;
-    }
-
-    inline Type getType() const
+        axis(axis),
+        lower(lower),
+        upper(upper),
+        type(type)
     {
-      return type_;
     }
 
-  private:
-
-    double axis_;
-    double lower_;
-    double upper_;
-    Type type_;
+    double axis;
+    double lower;
+    double upper;
+    Type type;
   };
 
-  MappableComponent(
-    Texture tileset,
-    Texture font) :
-      tileset_(std::move(tileset)),
-      font_(std::move(font))
-  {
-  }
-
+  /**
+   * Helper types for efficient storage and lookup of collision boundaries.
+   */
   using asc_boundaries_type =
     std::multimap<
       double,
-      Boundary,
+      const Boundary,
       std::less<double>>;
 
   using desc_boundaries_type =
     std::multimap<
       double,
-      Boundary,
+      const Boundary,
       std::greater<double>>;
 
-  inline size_t getMapId() const
-  {
-    return mapId_;
-  }
-
-  inline void setMapId(size_t v)
-  {
-    mapId_ = v;
-  }
-
-  inline desc_boundaries_type& getLeftBoundaries()
-  {
-    return leftBoundaries_;
-  }
-
-  inline asc_boundaries_type& getRightBoundaries()
-  {
-    return rightBoundaries_;
-  }
-
-  inline desc_boundaries_type& getUpBoundaries()
-  {
-    return upBoundaries_;
-  }
-
-  inline asc_boundaries_type& getDownBoundaries()
-  {
-    return downBoundaries_;
-  }
-
-  inline const Texture& getTileset() const
-  {
-    return tileset_;
-  }
-
-  inline void setTileset(Texture v)
-  {
-    tileset_ = std::move(v);
-  }
-
-  inline const Texture& getFont() const
-  {
-    return font_;
-  }
-
-  inline void setFont(Texture v)
+  /**
+   * Constructor for initializing the tileset and font attributes, as they are
+   * not default constructible.
+   */
+  MappableComponent(
+    Texture tileset,
+    Texture font) :
+      tileset(std::move(tileset)),
+      font(std::move(font))
   {
-    font_ = std::move(v);
   }
 
-private:
-
-  size_t mapId_ = -1;
-
-  desc_boundaries_type leftBoundaries_;
-  asc_boundaries_type rightBoundaries_;
-  desc_boundaries_type upBoundaries_;
-  asc_boundaries_type downBoundaries_;
-  Texture tileset_;
-  Texture font_;
+  /**
+   * The ID of the map in the world definition that this entity represents.
+   *
+   * @managed_by RealizingSystem
+   */
+  size_t mapId;
+
+  /**
+   * The title of the map, which is displayed at the bottom of the screen.
+   */
+  std::string title;
+
+  /**
+   * The map data.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::vector<int> tiles;
+
+  /**
+   * These objects describe the behavior of the four edges of the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  Adjacent leftAdjacent;
+  Adjacent rightAdjacent;
+  Adjacent upAdjacent;
+  Adjacent downAdjacent;
+
+  /**
+   * Collision boundaries, for detecting when a ponderable entity is colliding
+   * with the environment.
+   *
+   * @managed_by MappingSystem
+   */
+  desc_boundaries_type leftBoundaries;
+  asc_boundaries_type rightBoundaries;
+  desc_boundaries_type upBoundaries;
+  asc_boundaries_type downBoundaries;
+
+  /**
+   * The list of entities representing the objects owned by the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::list<id_type> objects;
+
+  /**
+   * The tilesets for the map and the map name.
+   *
+   * TODO: These probably do not belong here.
+   */
+  Texture tileset;
+  Texture font;
 };
 
 #endif /* end of include guard: MAPPABLE_H_0B0316FB */
@@ -2,22 +2,30 @@
 #define PLAYABLE_H_DDC566C3
 
 #include "component.h"
-#include <functional>
+#include "entity_manager.h"
 
 class PlayableComponent : public Component {
 public:
 
-  using MapChangeCallback = std::function<void()>;
+  using id_type = EntityManager::id_type;
 
-  bool changingMap = false;
-  int newMapId = -1;
-  double newMapX = 0;
-  double newMapY = 0;
-  MapChangeCallback newMapCallback;
+  /**
+   * The entity ID of the map that the player is on.
+   *
+   * @managed_by PlayingSystem
+   */
+  id_type mapId;
 
-  int checkpointMapId = -1;
-  double checkpointX = 0;
-  double checkpointY = 0;
+  /**
+   * The map ID and coordinates of the location that the player will spawn after
+   * dying. Note that the map ID here is a world description map ID, not an
+   * entity ID.
+   *
+   * @managed_by PlayingSystem
+   */
+  size_t checkpointMapId;
+  double checkpointX;
+  double checkpointY;
 
 };
 
@@ -6,100 +6,73 @@
 class PonderableComponent : public Component {
 public:
 
+  /**
+   * List of different types of physical bodies.
+   *
+   * vacuumed     - Default.
+   * freefalling  - The body will be treated as if there were a downward force
+   *                of gravity being exerted onto it. The body will also exhibit
+   *                terminal velocity (that is, its downward velocity will be
+   *                capped at a constant value).
+   */
   enum class Type {
     vacuumed,
     freefalling
   };
 
-  PonderableComponent(Type type) : type_(type)
-  {
-  }
-
-  inline Type getType() const
-  {
-    return type_;
-  }
-
-  inline double getVelocityX() const
-  {
-    return velX_;
-  }
-
-  inline void setVelocityX(double v)
-  {
-    velX_ = v;
-  }
-
-  inline double getVelocityY() const
-  {
-    return velY_;
-  }
-
-  inline void setVelocityY(double v)
-  {
-    velY_ = v;
-  }
-
-  inline double getAccelX() const
-  {
-    return accelX_;
-  }
-
-  inline void setAccelX(double v)
-  {
-    accelX_ = v;
-  }
-
-  inline double getAccelY() const
-  {
-    return accelY_;
-  }
-
-  inline void setAccelY(double v)
-  {
-    accelY_ = v;
-  }
-
-  inline bool isGrounded() const
-  {
-    return grounded_;
-  }
-
-  inline void setGrounded(bool v)
-  {
-    grounded_ = v;
-  }
-
-  inline bool isFrozen() const
-  {
-    return frozen_;
-  }
-
-  inline void setFrozen(bool v)
-  {
-    frozen_ = v;
-  }
-
-  inline bool isCollidable() const
-  {
-    return collidable_;
-  }
-
-  inline void setCollidable(bool v)
-  {
-    collidable_ = v;
-  }
-
-private:
-
-  double velX_ = 0.0;
-  double velY_ = 0.0;
-  double accelX_ = 0.0;
-  double accelY_ = 0.0;
-  Type type_ = Type::vacuumed;
-  bool grounded_ = false;
-  bool frozen_ = false;
-  bool collidable_ = true;
+  /**
+   * Constructor for initializing the body type, which is a constant.
+   */
+  PonderableComponent(Type type) : type(type)
+  {
+  }
+
+  /**
+   * The velocity of the body.
+   */
+  double velX = 0.0;
+  double velY = 0.0;
+
+  /**
+   * The acceleration of the body.
+   */
+  double accelX = 0.0;
+  double accelY = 0.0;
+
+  /**
+   * The type of physical body that the entity is meant to assume. The body will
+   * be acted upon differently based on this. See the enumeration above for more
+   * details.
+   *
+   * @managed_by PonderingSystem
+   */
+  const Type type;
+
+  /**
+   * Whether or not a freefalling body is in contact with the ground.
+   *
+   * @managed_by PonderingSystem
+   */
+  bool grounded = false;
+
+  /**
+   * If enabled, this will prevent the body from moving.
+   */
+  bool frozen = false;
+
+  /**
+   * If disabled, collision detection for this body will not be performed and
+   * other bodies will ignore it.
+   */
+  bool collidable = true;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the pondering
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
 };
 
 #endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -0,0 +1,67 @@
+#ifndef REALIZABLE_H_36D8D71E
+#define REALIZABLE_H_36D8D71E
+
+#include "component.h"
+#include <set>
+#include <map>
+#include "entity_manager.h"
+
+class RealizableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Path to the XML file containing the world definition.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::string worldFile;
+
+  /**
+   * Starting map and player location for a new game.
+   *
+   * @managed_by RealizingSystem
+   */
+  int startingMapId;
+  int startingX;
+  int startingY;
+
+  /**
+   * The set of map entities loaded by this entity. It is only intended for
+   * there to be one realizable entity, so this should contain all loaded maps.
+   * The realizable entity has ownership of the loaded maps.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::set<id_type> maps;
+
+  /**
+   * A lookup table that translates a map ID to the entity representing that
+   * loaded map.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::map<size_t, id_type> entityByMapId;
+
+  /**
+   * The entity ID of the currently active map.
+   *
+   * @managed_by RealizingSystem
+   */
+  id_type activeMap;
+
+  /**
+   * Whether or not a map has been activated yet.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool hasActiveMap = false;
+
+  /**
+   * The entity ID of the currently active player.
+   */
+  id_type activePlayer;
+};
+
+#endif /* end of include guard: REALIZABLE_H_36D8D71E */
@@ -6,64 +6,27 @@
 class TransformableComponent : public Component {
 public:
 
-  TransformableComponent(
-    double x,
-    double y,
-    int w,
-    int h) :
-      x_(x),
-      y_(y),
-      w_(w),
-      h_(h)
-  {
-  }
-
-  inline double getX() const
-  {
-    return x_;
-  }
-
-  inline void setX(double v)
-  {
-    x_ = v;
-  }
-
-  inline double getY() const
-  {
-    return y_;
-  }
-
-  inline void setY(double v)
-  {
-    y_ = v;
-  }
-
-  inline int getW() const
-  {
-    return w_;
-  }
-
-  inline void setW(int v)
-  {
-    w_ = v;
-  }
-
-  inline int getH() const
-  {
-    return h_;
-  }
-
-  inline void setH(int v)
-  {
-    h_ = v;
-  }
-
-private:
-
-  double x_;
-  double y_;
-  int w_;
-  int h_;
+  /**
+   * The coordinates of the entity.
+   */
+  double x;
+  double y;
+
+  /**
+   * The size of the entity.
+   */
+  int w;
+  int h;
+
+  /**
+   * For prototypes, the original coordinates and size of the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  double origX;
+  double origY;
+  int origW;
+  int origH;
 };
 
 #endif /* end of include guard: LOCATABLE_H_39E526CA */
@@ -11,6 +11,7 @@
 #include "systems/orienting.h"
 #include "systems/playing.h"
 #include "systems/scheduling.h"
+#include "systems/realizing.h"
 #include "animation.h"
 #include "consts.h"
 
@@ -28,8 +29,9 @@ void key_callback(GLFWwindow* window, int key, int, int action, int)
   game.systemManager_.input(key, action);
 }
 
-Game::Game() : world_("res/maps.xml")
+Game::Game()
 {
+  systemManager_.emplaceSystem<RealizingSystem>(*this);
   systemManager_.emplaceSystem<PlayingSystem>(*this);
   systemManager_.emplaceSystem<SchedulingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
@@ -38,8 +40,8 @@ Game::Game() : world_("res/maps.xml")
   systemManager_.emplaceSystem<MappingSystem>(*this);
   systemManager_.emplaceSystem<AnimatingSystem>(*this);
 
+  systemManager_.getSystem<RealizingSystem>().initSingleton("res/maps.xml");
   systemManager_.getSystem<PlayingSystem>().initPlayer();
-  systemManager_.getSystem<MappingSystem>().loadMap(world_.getStartingMapId());
 
   glfwSwapInterval(1);
   glfwSetWindowUserPointer(renderer_.getWindow().getHandle(), this);
@@ -3,7 +3,6 @@
 
 #include "entity_manager.h"
 #include "system_manager.h"
-#include "world.h"
 #include "renderer/renderer.h"
 
 class Game {
@@ -28,11 +27,6 @@ public:
     return systemManager_;
   }
 
-  inline const World& getWorld()
-  {
-    return world_;
-  }
-
   friend void key_callback(
     GLFWwindow* window,
     int key,
@@ -45,7 +39,6 @@ private:
   Renderer renderer_;
   EntityManager entityManager_;
   SystemManager systemManager_;
-  World world_;
   bool shouldQuit_ = false;
 };
 
@@ -1,111 +0,0 @@
-#ifndef MAP_H_74055FC0
-#define MAP_H_74055FC0
-
-#include <vector>
-#include <string>
-#include <list>
-#include <stdexcept>
-#include <map>
-
-class Map {
-public:
-
-  class Adjacent {
-  public:
-
-    enum class Type {
-      wall,
-      wrap,
-      warp,
-      reverse
-    };
-
-    Adjacent(
-      Type type = Type::wall,
-      int mapId = -1) :
-        type_(type),
-        mapId_(mapId)
-    {
-    }
-
-    inline Type getType() const
-    {
-      return type_;
-    }
-
-    inline int getMapId() const
-    {
-      return mapId_;
-    }
-
-  private:
-
-    Type type_;
-    int mapId_;
-  };
-
-  Map(
-    int id,
-    std::vector<int> tiles,
-    std::string title,
-    Adjacent leftAdjacent,
-    Adjacent rightAdjacent,
-    Adjacent upAdjacent,
-    Adjacent downAdjacent) :
-      id_(id),
-      tiles_(std::move(tiles)),
-      title_(std::move(title)),
-      leftAdjacent_(std::move(leftAdjacent)),
-      rightAdjacent_(std::move(rightAdjacent)),
-      upAdjacent_(std::move(upAdjacent)),
-      downAdjacent_(std::move(downAdjacent))
-  {
-  }
-
-  inline size_t getId() const
-  {
-    return id_;
-  }
-
-  inline const std::vector<int>& getTiles() const
-  {
-    return tiles_;
-  }
-
-  inline const std::string& getTitle() const
-  {
-    return title_;
-  }
-
-  inline const Adjacent& getLeftAdjacent() const
-  {
-    return leftAdjacent_;
-  }
-
-  inline const Adjacent& getRightAdjacent() const
-  {
-    return rightAdjacent_;
-  }
-
-  inline const Adjacent& getUpAdjacent() const
-  {
-    return upAdjacent_;
-  }
-
-  inline const Adjacent& getDownAdjacent() const
-  {
-    return downAdjacent_;
-  }
-
-private:
-
-  int id_;
-  std::vector<int> tiles_;
-  std::string title_;
-  Adjacent leftAdjacent_;
-  Adjacent rightAdjacent_;
-  Adjacent upAdjacent_;
-  Adjacent downAdjacent_;
-};
-
-#endif /* end of include guard: MAP_H_74055FC0 */
@@ -13,26 +13,29 @@ void AnimatingSystem::tick(double)
     auto& sprite = game_.getEntityManager().
       getComponent<AnimatableComponent>(entity);
 
-    if (!sprite.isFrozen())
+    if (sprite.active)
     {
-      sprite.setCountdown(sprite.getCountdown() + 1);
-    }
-
-    const Animation& anim = sprite.getAnimation();
-    if (sprite.getCountdown() >= anim.getDelay())
-    {
-      sprite.setFrame(sprite.getFrame() + 1);
-      sprite.setCountdown(0);
+      if (!sprite.frozen)
+      {
+        sprite.countdown++;
+      }
 
-      if (sprite.getFrame() >= anim.getFirstFrame() + anim.getNumFrames())
+      const Animation& anim = sprite.getAnimation();
+      if (sprite.countdown >= anim.getDelay())
       {
-        sprite.setFrame(anim.getFirstFrame());
+        sprite.frame++;
+        sprite.countdown = 0;
+
+        if (sprite.frame >= anim.getFirstFrame() + anim.getNumFrames())
+        {
+          sprite.frame = anim.getFirstFrame();
+        }
       }
-    }
 
-    if (sprite.isFlickering())
-    {
-      sprite.setFlickerTimer((sprite.getFlickerTimer() + 1) % 6);
+      if (sprite.flickering)
+      {
+        sprite.flickerTimer = (sprite.flickerTimer + 1) % 6;
+      }
     }
   }
 }
@@ -49,36 +52,52 @@ void AnimatingSystem::render(Texture& texture)
     auto& sprite = game_.getEntityManager().
       getComponent<AnimatableComponent>(entity);
 
-    auto& transform = game_.getEntityManager().
-      getComponent<TransformableComponent>(entity);
-
-    double alpha = 1.0;
-    if (sprite.isFlickering() && (sprite.getFlickerTimer() < 3))
+    if (sprite.active)
     {
-      alpha = 0.0;
-    }
+      auto& transform = game_.getEntityManager().
+        getComponent<TransformableComponent>(entity);
 
-    Rectangle dstrect {
-      static_cast<int>(transform.getX()),
-      static_cast<int>(transform.getY()),
-      transform.getW(),
-      transform.getH()};
-
-    const AnimationSet& aset = sprite.getAnimationSet();
-    game_.getRenderer().blit(
-      aset.getTexture(),
-      texture,
-      aset.getFrameRect(sprite.getFrame()),
-      dstrect,
-      alpha);
+      double alpha = 1.0;
+      if (sprite.flickering && (sprite.flickerTimer < 3))
+      {
+        alpha = 0.0;
+      }
+
+      Rectangle dstrect {
+        static_cast<int>(transform.x),
+        static_cast<int>(transform.y),
+        transform.w,
+        transform.h};
+
+      const AnimationSet& aset = sprite.animationSet;
+      game_.getRenderer().blit(
+        aset.getTexture(),
+        texture,
+        aset.getFrameRect(sprite.frame),
+        dstrect,
+        alpha);
+    }
   }
 }
 
+void AnimatingSystem::initPrototype(id_type entity)
+{
+  auto& sprite = game_.getEntityManager().
+    getComponent<AnimatableComponent>(entity);
+
+  startAnimation(entity, sprite.origAnimation);
+
+  sprite.countdown = 0;
+  sprite.flickering = false;
+  sprite.flickerTimer = 0;
+  sprite.frozen = false;
+}
+
 void AnimatingSystem::startAnimation(id_type entity, std::string animation)
 {
   auto& sprite = game_.getEntityManager().
     getComponent<AnimatableComponent>(entity);
 
-  sprite.setAnimation(animation);
-  sprite.setFrame(sprite.getAnimation().getFirstFrame());
+  sprite.animation = std::move(animation);
+  sprite.frame = sprite.getAnimation().getFirstFrame();
 }
@@ -16,6 +16,8 @@ public:
 
   void render(Texture& texture);
 
+  void initPrototype(id_type entity);
+
   void startAnimation(id_type entity, std::string animation);
 
 };
@@ -1,5 +1,7 @@
 #include "mapping.h"
 #include "components/mappable.h"
+#include "components/realizable.h"
+#include "systems/realizing.h"
 #include "game.h"
 #include "consts.h"
 
@@ -18,104 +20,95 @@ inline void addBoundary(
 
 void MappingSystem::render(Texture& texture)
 {
-  auto entities = game_.getEntityManager().getEntitiesWithComponents<
-    MappableComponent>();
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(
+      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
 
-  for (id_type entity : entities)
-  {
-    auto& mappable = game_.getEntityManager().
-      getComponent<MappableComponent>(entity);
+  id_type map = realizable.activeMap;
 
-    const Map& map = game_.getWorld().getMap(mappable.getMapId());
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(map);
 
-    for (int i = 0; i < MAP_WIDTH * MAP_HEIGHT; i++)
-    {
-      int x = i % MAP_WIDTH;
-      int y = i / MAP_WIDTH;
-      int tile = map.getTiles()[i];
-
-      if (tile > 0)
-      {
-        Rectangle dst {
-          x * TILE_WIDTH,
-          y * TILE_HEIGHT,
-          TILE_WIDTH,
-          TILE_HEIGHT};
-
-        Rectangle src {
-          (tile % TILESET_COLS) * TILE_WIDTH,
-          (tile / TILESET_COLS) * TILE_HEIGHT,
-          TILE_WIDTH,
-          TILE_HEIGHT};
-
-        game_.getRenderer().blit(
-          mappable.getTileset(),
-          texture,
-          std::move(src),
-          std::move(dst));
-      }
-    }
+  for (int i = 0; i < MAP_WIDTH * MAP_HEIGHT; i++)
+  {
+    int x = i % MAP_WIDTH;
+    int y = i / MAP_WIDTH;
+    int tile = mappable.tiles[i];
 
-    int startX = ((GAME_WIDTH / TILE_WIDTH) / 2) - (map.getTitle().size() / 2);
-    for (size_t i = 0; i < map.getTitle().size(); i++)
+    if (tile > 0)
     {
-      Rectangle src {
-        (map.getTitle()[i] % FONT_COLS) * TILE_WIDTH,
-        (map.getTitle()[i] / FONT_COLS) * TILE_HEIGHT,
+      Rectangle dst {
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
         TILE_WIDTH,
         TILE_HEIGHT};
 
-      Rectangle dst {
-        (startX + static_cast<int>(i)) * TILE_WIDTH,
-        24 * TILE_HEIGHT,
+      Rectangle src {
+        (tile % TILESET_COLS) * TILE_WIDTH,
+        (tile / TILESET_COLS) * TILE_HEIGHT,
         TILE_WIDTH,
         TILE_HEIGHT};
 
       game_.getRenderer().blit(
-        mappable.getFont(),
+        mappable.tileset,
         texture,
         std::move(src),
         std::move(dst));
     }
   }
+
+  int startX = ((GAME_WIDTH / TILE_WIDTH) / 2) - (mappable.title.size() / 2);
+
+  for (size_t i = 0; i < mappable.title.size(); i++)
+  {
+    Rectangle src {
+      (mappable.title[i] % FONT_COLS) * TILE_WIDTH,
+      (mappable.title[i] / FONT_COLS) * TILE_HEIGHT,
+      TILE_WIDTH,
+      TILE_HEIGHT};
+
+    Rectangle dst {
+      (startX + static_cast<int>(i)) * TILE_WIDTH,
+      24 * TILE_HEIGHT,
+      TILE_WIDTH,
+      TILE_HEIGHT};
+
+    game_.getRenderer().blit(
+      mappable.font,
+      texture,
+      std::move(src),
+      std::move(dst));
+  }
 }
 
-void MappingSystem::loadMap(size_t mapId)
+void MappingSystem::generateBoundaries(id_type mapEntity)
 {
-  id_type mapEntity = game_.getEntityManager().emplaceEntity();
-
   auto& mappable = game_.getEntityManager().
-    emplaceComponent<MappableComponent>(mapEntity,
-      Texture("res/tiles.png"),
-      Texture("res/font.bmp"));
-
-  mappable.setMapId(mapId);
-
-  const Map& map = game_.getWorld().getMap(mappable.getMapId());
+    getComponent<MappableComponent>(mapEntity);
 
   addBoundary(
-    mappable.getLeftBoundaries(),
+    mappable.leftBoundaries,
     -WALL_GAP,
     0,
     MAP_HEIGHT * TILE_HEIGHT,
     MappableComponent::Boundary::Type::adjacency);
 
   addBoundary(
-    mappable.getRightBoundaries(),
+    mappable.rightBoundaries,
     GAME_WIDTH + WALL_GAP,
     0,
     MAP_HEIGHT * TILE_HEIGHT,
     MappableComponent::Boundary::Type::adjacency);
 
   addBoundary(
-    mappable.getUpBoundaries(),
+    mappable.upBoundaries,
     -WALL_GAP,
     0,
     GAME_WIDTH,
     MappableComponent::Boundary::Type::adjacency);
 
   addBoundary(
-    mappable.getDownBoundaries(),
+    mappable.downBoundaries,
     MAP_HEIGHT * TILE_HEIGHT + WALL_GAP,
     0,
     GAME_WIDTH,
@@ -125,12 +118,12 @@ void MappingSystem::loadMap(size_t mapId)
   {
     size_t x = i % MAP_WIDTH;
     size_t y = i / MAP_WIDTH;
-    int tile = map.getTiles()[i];
+    int tile = mappable.tiles[i];
 
     if ((tile >= 5) && (tile <= 7))
     {
       addBoundary(
-        mappable.getDownBoundaries(),
+        mappable.downBoundaries,
         y * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x + 1) * TILE_WIDTH,
@@ -138,28 +131,28 @@ void MappingSystem::loadMap(size_t mapId)
     } else if ((tile > 0) && (tile < 28))
     {
       addBoundary(
-        mappable.getRightBoundaries(),
+        mappable.rightBoundaries,
         x * TILE_WIDTH,
         y * TILE_HEIGHT,
         (y+1) * TILE_HEIGHT,
         MappableComponent::Boundary::Type::wall);
 
       addBoundary(
-        mappable.getLeftBoundaries(),
+        mappable.leftBoundaries,
         (x+1) * TILE_WIDTH,
         y * TILE_HEIGHT,
         (y+1) * TILE_HEIGHT,
         MappableComponent::Boundary::Type::wall);
 
       addBoundary(
-        mappable.getDownBoundaries(),
+        mappable.downBoundaries,
         y * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x+1) * TILE_WIDTH,
         MappableComponent::Boundary::Type::wall);
 
       addBoundary(
-        mappable.getUpBoundaries(),
+        mappable.upBoundaries,
         (y+1) * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x+1) * TILE_WIDTH,
@@ -167,28 +160,28 @@ void MappingSystem::loadMap(size_t mapId)
     } else if (tile == 42)
     {
       addBoundary(
-        mappable.getRightBoundaries(),
+        mappable.rightBoundaries,
         x * TILE_WIDTH,
         y * TILE_HEIGHT,
         (y+1) * TILE_HEIGHT,
         MappableComponent::Boundary::Type::danger);
 
       addBoundary(
-        mappable.getLeftBoundaries(),
+        mappable.leftBoundaries,
         (x+1) * TILE_WIDTH,
         y * TILE_HEIGHT,
         (y+1) * TILE_HEIGHT,
         MappableComponent::Boundary::Type::danger);
 
       addBoundary(
-        mappable.getDownBoundaries(),
+        mappable.downBoundaries,
         y * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x+1) * TILE_WIDTH,
         MappableComponent::Boundary::Type::danger);
 
       addBoundary(
-        mappable.getUpBoundaries(),
+        mappable.upBoundaries,
         (y+1) * TILE_HEIGHT,
         x * TILE_WIDTH,
         (x+1) * TILE_WIDTH,
@@ -12,7 +12,7 @@ public:
 
   void render(Texture& texture);
 
-  void loadMap(size_t mapId);
+  void generateBoundaries(id_type mapEntity);
 
 };
 
@@ -24,27 +24,27 @@ void OrientingSystem::tick(double)
     {
       case OrientableComponent::WalkState::still:
       {
-        ponderable.setVelocityX(0);
+        ponderable.velX = 0.0;
 
         break;
       }
 
       case OrientableComponent::WalkState::left:
       {
-        ponderable.setVelocityX(-WALK_SPEED);
+        ponderable.velX = -WALK_SPEED;
 
         break;
       }
 
       case OrientableComponent::WalkState::right:
       {
-        ponderable.setVelocityX(WALK_SPEED);
+        ponderable.velX = WALK_SPEED;
 
         break;
       }
     }
 
-    if (orientable.isJumping() && (ponderable.getVelocityY() > 0))
+    if (orientable.isJumping() && (ponderable.velY > 0))
     {
       orientable.setJumping(false);
     }
@@ -63,7 +63,7 @@ void OrientingSystem::moveLeft(id_type entity)
   orientable.setWalkState(OrientableComponent::WalkState::left);
 
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-  if (ponderable.isGrounded())
+  if (ponderable.grounded)
   {
     animating.startAnimation(entity, "walkingLeft");
   } else {
@@ -83,7 +83,7 @@ void OrientingSystem::moveRight(id_type entity)
   orientable.setWalkState(OrientableComponent::WalkState::right);
 
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
-  if (ponderable.isGrounded())
+  if (ponderable.grounded)
   {
     animating.startAnimation(entity, "walkingRight");
   } else {
@@ -113,7 +113,7 @@ void OrientingSystem::jump(id_type entity)
   auto& ponderable = game_.getEntityManager().
     getComponent<PonderableComponent>(entity);
 
-  if (ponderable.isGrounded())
+  if (ponderable.grounded)
   {
     auto& orientable = game_.getEntityManager().
       getComponent<OrientableComponent>(entity);
@@ -122,8 +122,8 @@ void OrientingSystem::jump(id_type entity)
 
     playSound("res/Randomize87.wav", 0.25);
 
-    ponderable.setVelocityY(JUMP_VELOCITY);
-    ponderable.setAccelY(JUMP_GRAVITY);
+    ponderable.velY = JUMP_VELOCITY;
+    ponderable.accelY = JUMP_GRAVITY;
 
     auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
     if (orientable.isFacingRight())
@@ -147,7 +147,7 @@ void OrientingSystem::stopJumping(id_type entity)
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    ponderable.setAccelY(NORMAL_GRAVITY);
+    ponderable.accelY = NORMAL_GRAVITY;
   }
 }
 
@@ -211,7 +211,7 @@ void OrientingSystem::drop(id_type entity)
   auto& ponderable = game_.getEntityManager().
     getComponent<PonderableComponent>(entity);
 
-  if (ponderable.isGrounded()
+  if (ponderable.grounded
     && (orientable.getDropState() == OrientableComponent::DropState::none))
   {
     orientable.setDropState(OrientableComponent::DropState::ready);
@@ -5,61 +5,17 @@
 #include "components/playable.h"
 #include "components/controllable.h"
 #include "components/orientable.h"
+#include "components/realizable.h"
 #include "systems/mapping.h"
 #include "systems/pondering.h"
 #include "systems/orienting.h"
 #include "systems/scheduling.h"
 #include "systems/controlling.h"
+#include "systems/animating.h"
+#include "systems/realizing.h"
 #include "animation.h"
 #include "muxer.h"
 
-void PlayingSystem::tick(double)
-{
-  // Check if we need to change the map
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    PlayableComponent,
-    TransformableComponent>();
-
-  for (id_type player : players)
-  {
-    auto& playable = game_.getEntityManager().
-      getComponent<PlayableComponent>(player);
-
-    if (playable.changingMap)
-    {
-      // Change the map!
-      auto entities = game_.getEntityManager().getEntities();
-
-      for (id_type entity : entities)
-      {
-        if (entity != player)
-        {
-          game_.getEntityManager().deleteEntity(entity);
-        }
-      }
-
-      game_.getSystemManager().getSystem<MappingSystem>().
-        loadMap(playable.newMapId);
-
-      auto& transformable = game_.getEntityManager().
-        getComponent<TransformableComponent>(player);
-
-      transformable.setX(playable.newMapX);
-      transformable.setY(playable.newMapY);
-
-      playable.changingMap = false;
-
-      if (playable.newMapCallback)
-      {
-        playable.newMapCallback();
-        playable.newMapCallback = nullptr;
-      }
-
-      break;
-    }
-  }
-}
-
 void PlayingSystem::initPlayer()
 {
   id_type player = game_.getEntityManager().emplaceEntity();
@@ -72,15 +28,24 @@ void PlayingSystem::initPlayer()
 
   game_.getEntityManager().emplaceComponent<AnimatableComponent>(
     player,
-    std::move(playerGraphics),
-    "stillLeft");
+    std::move(playerGraphics));
 
-  game_.getEntityManager().emplaceComponent<TransformableComponent>(
+  game_.getSystemManager().getSystem<AnimatingSystem>().startAnimation(
     player,
-    game_.getWorld().getStartingX(),
-    game_.getWorld().getStartingY(),
-    10,
-    12);
+    "stillLeft");
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(realizing.getSingleton());
+
+  auto& transformable = game_.getEntityManager().
+    emplaceComponent<TransformableComponent>(player);
+
+  transformable.x = realizable.startingX;
+  transformable.y = realizable.startingY;
+  transformable.w = 10;
+  transformable.h = 12;
 
   game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
     player,
@@ -92,84 +57,103 @@ void PlayingSystem::initPlayer()
   auto& playable = game_.getEntityManager().
     emplaceComponent<PlayableComponent>(player);
 
-  playable.checkpointMapId = game_.getWorld().getStartingMapId();
-  playable.checkpointX = game_.getWorld().getStartingX();
-  playable.checkpointY = game_.getWorld().getStartingY();
+  playable.mapId = realizable.activeMap;
+  playable.checkpointMapId = realizable.startingMapId;
+  playable.checkpointX = realizable.startingX;
+  playable.checkpointY = realizable.startingY;
+
+  realizing.enterActiveMap(player);
+
+  realizable.activePlayer = player;
 }
 
 void PlayingSystem::changeMap(
+  id_type player,
   size_t mapId,
   double x,
-  double y,
-  PlayableComponent::MapChangeCallback callback)
+  double y)
 {
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    PlayableComponent>();
+  auto& playable = game_.getEntityManager().
+    getComponent<PlayableComponent>(player);
 
-  for (id_type player : players)
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(player);
+
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(player);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(realizing.getSingleton());
+
+  id_type newMapEntity = realizable.entityByMapId[mapId];
+
+  if (playable.mapId != newMapEntity)
   {
-    auto& playable = game_.getEntityManager().
-      getComponent<PlayableComponent>(player);
+    if (playable.mapId == realizable.activeMap)
+    {
+      realizing.leaveActiveMap(player);
+    } else if (newMapEntity == realizable.activeMap)
+    {
+      realizing.enterActiveMap(player);
+    }
 
-    playable.changingMap = true;
-    playable.newMapId = mapId;
-    playable.newMapX = x;
-    playable.newMapY = y;
-    playable.newMapCallback = std::move(callback);
+    playable.mapId = newMapEntity;
+  }
+
+  transformable.x = x;
+  transformable.y = y;
+
+  if (realizable.activePlayer == player)
+  {
+    realizing.loadMap(newMapEntity);
   }
 }
 
-void PlayingSystem::die()
+void PlayingSystem::die(id_type player)
 {
   playSound("res/Hit_Hurt5.wav", 0.25);
 
-  auto players = game_.getEntityManager().getEntitiesWithComponents<
-    OrientableComponent,
-    ControllableComponent,
-    AnimatableComponent,
-    PonderableComponent,
-    PlayableComponent>();
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(player);
 
-  for (id_type player : players)
-  {
-    auto& animatable = game_.getEntityManager().
-      getComponent<AnimatableComponent>(player);
-
-    auto& ponderable = game_.getEntityManager().
-      getComponent<PonderableComponent>(player);
-
-    auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
-    controlling.freeze(player);
-
-    animatable.setFrozen(true);
-    animatable.setFlickering(true);
-    ponderable.setFrozen(true);
-    ponderable.setCollidable(false);
-
-    auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
-
-    scheduling.schedule(player, 0.75, [&] (id_type player) {
-      auto& playable = game_.getEntityManager().
-        getComponent<PlayableComponent>(player);
-
-      changeMap(
-        playable.checkpointMapId,
-        playable.checkpointX,
-        playable.checkpointY,
-        [&, player] () {
-          animatable.setFrozen(false);
-          animatable.setFlickering(false);
-          ponderable.setFrozen(false);
-          ponderable.setCollidable(true);
-
-          // Reset the walk state, and then potentially let the
-          // ControllingSystem set it again.
-          auto& orienting = game_.getSystemManager().
-            getSystem<OrientingSystem>();
-          orienting.stopWalking(player);
-
-          controlling.unfreeze(player);
-        });
-    });
-  }
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(player);
+
+  auto& controlling = game_.getSystemManager().getSystem<ControllingSystem>();
+  controlling.freeze(player);
+
+  animatable.frozen = true;
+  animatable.flickering = true;
+  ponderable.frozen = true;
+  ponderable.collidable = false;
+
+  auto& scheduling = game_.getSystemManager().getSystem<SchedulingSystem>();
+
+  scheduling.schedule(player, 0.75, [&] (id_type player) {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    changeMap(
+      player,
+      playable.checkpointMapId,
+      playable.checkpointX,
+      playable.checkpointY);
+
+    animatable.frozen = false;
+    animatable.flickering = false;
+    ponderable.frozen = false;
+    ponderable.collidable = true;
+
+    // Reset the walk state, and then potentially let the
+    // ControllingSystem set it again.
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+    orienting.stopWalking(player);
+
+    controlling.unfreeze(player);
+  });
 }
@@ -2,7 +2,6 @@
 #define PLAYING_H_70A54F7D
 
 #include "system.h"
-#include "components/playable.h"
 
 class PlayingSystem : public System {
 public:
@@ -11,17 +10,15 @@ public:
   {
   }
 
-  void tick(double dt);
-
   void initPlayer();
 
   void changeMap(
+    id_type player,
     size_t mapId,
     double x,
-    double y,
-    PlayableComponent::MapChangeCallback callback = nullptr);
+    double y);
 
-  void die();
+  void die(id_type player);
 
 };
 
@@ -5,149 +5,153 @@
 #include "components/transformable.h"
 #include "components/orientable.h"
 #include "components/mappable.h"
+#include "components/realizable.h"
+#include "components/playable.h"
 #include "systems/orienting.h"
 #include "systems/playing.h"
+#include "systems/realizing.h"
 #include "consts.h"
 #include "collision.h"
 
 void PonderingSystem::tick(double dt)
 {
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(
+      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
+
+  id_type mapEntity = realizable.activeMap;
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
   auto entities = game_.getEntityManager().getEntitiesWithComponents<
     PonderableComponent,
     TransformableComponent>();
 
-  auto maps = game_.getEntityManager().getEntitiesWithComponents<
-    MappableComponent>();
-
   for (id_type entity : entities)
   {
-    auto& transformable = game_.getEntityManager().
-      getComponent<TransformableComponent>(entity);
-
     auto& ponderable = game_.getEntityManager().
       getComponent<PonderableComponent>(entity);
 
-    if (ponderable.isFrozen())
+    if (!ponderable.active || ponderable.frozen)
     {
       continue;
     }
 
-    // Accelerate
-    ponderable.setVelocityX(
-      ponderable.getVelocityX() + ponderable.getAccelX() * dt);
+    auto& transformable = game_.getEntityManager().
+      getComponent<TransformableComponent>(entity);
 
-    ponderable.setVelocityY(
-      ponderable.getVelocityY() + ponderable.getAccelY() * dt);
+    // Accelerate
+    ponderable.velX += ponderable.accelX * dt;
+    ponderable.velY += ponderable.accelY * dt;
 
-    if ((ponderable.getType() == PonderableComponent::Type::freefalling)
-      && (ponderable.getVelocityY() > TERMINAL_VELOCITY))
+    if ((ponderable.type == PonderableComponent::Type::freefalling)
+      && (ponderable.velY > TERMINAL_VELOCITY))
     {
-      ponderable.setVelocityY(TERMINAL_VELOCITY);
+      ponderable.velY = TERMINAL_VELOCITY;
     }
 
-    const double oldX = transformable.getX();
-    const double oldY = transformable.getY();
-    const double oldRight = oldX + transformable.getW();
-    const double oldBottom = oldY + transformable.getH();
+    const double oldX = transformable.x;
+    const double oldY = transformable.y;
+    const double oldRight = oldX + transformable.w;
+    const double oldBottom = oldY + transformable.h;
 
-    double newX = oldX + ponderable.getVelocityX() * dt;
-    double newY = oldY + ponderable.getVelocityY() * dt;
+    double newX = oldX + ponderable.velX * dt;
+    double newY = oldY + ponderable.velY * dt;
 
-    bool oldGrounded = ponderable.isGrounded();
-    ponderable.setGrounded(false);
+    bool oldGrounded = ponderable.grounded;
+    ponderable.grounded = false;
 
     std::priority_queue<Collision> collisions;
 
     // Find collisions
-    for (id_type mapEntity : maps)
+    if (newX < oldX)
     {
-      auto& mappable = game_.getEntityManager().
-        getComponent<MappableComponent>(mapEntity);
-
-      if (newX < oldX)
+      for (auto it = mappable.leftBoundaries.lower_bound(oldX);
+        (it != std::end(mappable.leftBoundaries)) && (it->first >= newX);
+        it++)
       {
-        for (auto it = mappable.getLeftBoundaries().lower_bound(oldX);
-          (it != std::end(mappable.getLeftBoundaries())) && (it->first >= newX);
-          it++)
+        if ((oldBottom > it->second.lower)
+          && (oldY < it->second.upper))
         {
-          if ((oldBottom > it->second.getLower())
-            && (oldY < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::left,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::left,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
-      } else if (newX > oldX)
+      }
+    } else if (newX > oldX)
+    {
+      for (auto it = mappable.rightBoundaries.lower_bound(oldRight);
+        (it != std::end(mappable.rightBoundaries))
+          && (it->first <= (newX + transformable.w));
+        it++)
       {
-        for (auto it = mappable.getRightBoundaries().lower_bound(oldRight);
-          (it != std::end(mappable.getRightBoundaries()))
-            && (it->first <= (newX + transformable.getW()));
-          it++)
+        if ((oldBottom > it->second.lower)
+          && (oldY < it->second.upper))
         {
-          if ((oldBottom > it->second.getLower())
-            && (oldY < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::right,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::right,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
       }
+    }
 
-      if (newY < oldY)
+    if (newY < oldY)
+    {
+      for (auto it = mappable.upBoundaries.lower_bound(oldY);
+        (it != std::end(mappable.upBoundaries)) && (it->first >= newY);
+        it++)
       {
-        for (auto it = mappable.getUpBoundaries().lower_bound(oldY);
-          (it != std::end(mappable.getUpBoundaries())) && (it->first >= newY);
-          it++)
+        if ((oldRight > it->second.lower)
+          && (oldX < it->second.upper))
         {
-          if ((oldRight > it->second.getLower())
-            && (oldX < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::up,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::up,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
-      } else if (newY > oldY)
+      }
+    } else if (newY > oldY)
+    {
+      for (auto it = mappable.downBoundaries.lower_bound(oldBottom);
+        (it != std::end(mappable.downBoundaries))
+          && (it->first <= (newY + transformable.h));
+        it++)
       {
-        for (auto it = mappable.getDownBoundaries().lower_bound(oldBottom);
-          (it != std::end(mappable.getDownBoundaries()))
-            && (it->first <= (newY + transformable.getH()));
-          it++)
+        if ((oldRight > it->second.lower)
+          && (oldX < it->second.upper))
         {
-          if ((oldRight > it->second.getLower())
-            && (oldX < it->second.getUpper()))
-          {
-            // We have a collision!
-            collisions.emplace(
-              mapEntity,
-              Direction::down,
-              it->second.getType(),
-              it->first,
-              it->second.getLower(),
-              it->second.getUpper());
-          }
+          // We have a collision!
+          collisions.emplace(
+            mapEntity,
+            Direction::down,
+            it->second.type,
+            it->first,
+            it->second.lower,
+            it->second.upper);
         }
       }
     }
 
     // Process collisions in order of priority
+    bool adjacentlyWarping = false;
+    Direction adjWarpDir;
+    size_t adjWarpMapId;
+
     while (!collisions.empty())
     {
       Collision collision = collisions.top();
@@ -157,8 +161,8 @@ void PonderingSystem::tick(double dt)
       if (!collision.isColliding(
         newX,
         newY,
-        transformable.getW(),
-        transformable.getH()))
+        transformable.w,
+        transformable.h))
       {
         continue;
       }
@@ -201,33 +205,33 @@ void PonderingSystem::tick(double dt)
         {
           auto& mappable = game_.getEntityManager().
             getComponent<MappableComponent>(collision.getCollider());
-          const Map& map = game_.getWorld().getMap(mappable.getMapId());
-          auto& adj = [&] () -> const Map::Adjacent& {
+
+          auto& adj = [&] () -> const MappableComponent::Adjacent& {
               switch (collision.getDirection())
               {
-                case Direction::left: return map.getLeftAdjacent();
-                case Direction::right: return map.getRightAdjacent();
-                case Direction::up: return map.getUpAdjacent();
-                case Direction::down: return map.getDownAdjacent();
+                case Direction::left: return mappable.leftAdjacent;
+                case Direction::right: return mappable.rightAdjacent;
+                case Direction::up: return mappable.upAdjacent;
+                case Direction::down: return mappable.downAdjacent;
               }
             }();
 
-          switch (adj.getType())
+          switch (adj.type)
           {
-            case Map::Adjacent::Type::wall:
+            case MappableComponent::Adjacent::Type::wall:
             {
               touchedWall = true;
 
               break;
             }
 
-            case Map::Adjacent::Type::wrap:
+            case MappableComponent::Adjacent::Type::wrap:
             {
               switch (collision.getDirection())
               {
                 case Direction::left:
                 {
-                  newX = GAME_WIDTH + WALL_GAP - transformable.getW();
+                  newX = GAME_WIDTH + WALL_GAP - transformable.w;
 
                   break;
                 }
@@ -241,8 +245,7 @@ void PonderingSystem::tick(double dt)
 
                 case Direction::up:
                 {
-                  newY = MAP_HEIGHT * TILE_HEIGHT + WALL_GAP -
-                    transformable.getH();
+                  newY = MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.h;
 
                   break;
                 }
@@ -256,46 +259,22 @@ void PonderingSystem::tick(double dt)
               }
             }
 
-            case Map::Adjacent::Type::warp:
+            case MappableComponent::Adjacent::Type::warp:
             {
-              double warpX = newX;
-              double warpY = newY;
-
-              switch (collision.getDirection())
+              if (game_.getEntityManager().
+                hasComponent<PlayableComponent>(entity))
               {
-                case Direction::left:
-                {
-                  warpX = GAME_WIDTH + WALL_GAP - transformable.getW();
-
-                  break;
-                }
-
-                case Direction::right:
-                {
-                  warpX = -WALL_GAP;
-
-                  break;
-                }
-
-                case Direction::up:
-                {
-                  warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.getH();
-
-                  break;
-                }
-
-                case Direction::down:
-                {
-                  warpY = -WALL_GAP;
-
-                  break;
-                }
+                adjacentlyWarping = true;
+                adjWarpDir = collision.getDirection();
+                adjWarpMapId = adj.mapId;
               }
 
-              game_.getSystemManager().getSystem<PlayingSystem>().
-                changeMap(adj.getMapId(), warpX, warpY);
+              break;
+            }
 
-              stopProcessing = true;
+            case MappableComponent::Adjacent::Type::reverse:
+            {
+              // TODO: not yet implemented.
 
               break;
             }
@@ -306,7 +285,13 @@ void PonderingSystem::tick(double dt)
 
         case Collision::Type::danger:
         {
-          game_.getSystemManager().getSystem<PlayingSystem>().die();
+          if (game_.getEntityManager().
+            hasComponent<PlayableComponent>(entity))
+          {
+            game_.getSystemManager().getSystem<PlayingSystem>().die(entity);
+
+            adjacentlyWarping = false;
+          }
 
           stopProcessing = true;
 
@@ -333,15 +318,15 @@ void PonderingSystem::tick(double dt)
           case Direction::left:
           {
             newX = collision.getAxis();
-            ponderable.setVelocityX(0.0);
+            ponderable.velX = 0.0;
 
             break;
           }
 
           case Direction::right:
           {
-            newX = collision.getAxis() - transformable.getW();
-            ponderable.setVelocityX(0.0);
+            newX = collision.getAxis() - transformable.w;
+            ponderable.velX = 0.0;
 
             break;
           }
@@ -349,16 +334,16 @@ void PonderingSystem::tick(double dt)
           case Direction::up:
           {
             newY = collision.getAxis();
-            ponderable.setVelocityY(0.0);
+            ponderable.velY = 0.0;
 
             break;
           }
 
           case Direction::down:
           {
-            newY = collision.getAxis() - transformable.getH();
-            ponderable.setVelocityY(0.0);
-            ponderable.setGrounded(true);
+            newY = collision.getAxis() - transformable.h;
+            ponderable.velY = 0.0;
+            ponderable.grounded = true;
 
             break;
           }
@@ -367,8 +352,8 @@ void PonderingSystem::tick(double dt)
     }
 
     // Move
-    transformable.setX(newX);
-    transformable.setY(newY);
+    transformable.x = newX;
+    transformable.y = newY;
 
     // Perform cleanup for orientable entites
     if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
@@ -377,9 +362,9 @@ void PonderingSystem::tick(double dt)
         getComponent<OrientableComponent>(entity);
 
       // Handle changes in groundedness
-      if (ponderable.isGrounded() != oldGrounded)
+      if (ponderable.grounded != oldGrounded)
       {
-        if (ponderable.isGrounded())
+        if (ponderable.grounded)
         {
           game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
         } else {
@@ -394,6 +379,51 @@ void PonderingSystem::tick(double dt)
         orientable.setDropState(OrientableComponent::DropState::none);
       }
     }
+
+    // Move to an adjacent map, if necessary
+    if (adjacentlyWarping)
+    {
+      double warpX = newX;
+      double warpY = newY;
+
+      switch (adjWarpDir)
+      {
+        case Direction::left:
+        {
+          warpX = GAME_WIDTH + WALL_GAP - transformable.w;
+
+          break;
+        }
+
+        case Direction::right:
+        {
+          warpX = -WALL_GAP;
+
+          break;
+        }
+
+        case Direction::up:
+        {
+          warpY = MAP_HEIGHT * TILE_HEIGHT - transformable.h;
+
+          break;
+        }
+
+        case Direction::down:
+        {
+          warpY = -WALL_GAP;
+
+          break;
+        }
+      }
+
+      game_.getSystemManager().getSystem<PlayingSystem>().
+        changeMap(
+          entity,
+          adjWarpMapId,
+          warpX,
+          warpY);
+    }
   }
 }
 
@@ -406,6 +436,20 @@ void PonderingSystem::initializeBody(
 
   if (type == PonderableComponent::Type::freefalling)
   {
-    ponderable.setAccelY(NORMAL_GRAVITY);
+    ponderable.accelY = NORMAL_GRAVITY;
   }
 }
+
+void PonderingSystem::initPrototype(id_type prototype)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(prototype);
+
+  ponderable.velX = 0.0;
+  ponderable.velY = 0.0;
+  ponderable.accelX = 0.0;
+  ponderable.accelY = 0.0;
+  ponderable.grounded = false;
+  ponderable.frozen = false;
+  ponderable.collidable = true;
+}
@@ -16,6 +16,8 @@ public:
 
   void initializeBody(id_type entity, PonderableComponent::Type type);
 
+  void initPrototype(id_type prototype);
+
 };
 
 #endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -0,0 +1,321 @@
+#include "realizing.h"
+#include <stdexcept>
+#include <libxml/parser.h>
+#include <cstring>
+#include "game.h"
+#include "consts.h"
+#include "components/realizable.h"
+#include "components/mappable.h"
+#include "components/animatable.h"
+#include "components/playable.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "systems/mapping.h"
+#include "systems/animating.h"
+#include "systems/pondering.h"
+
+inline xmlChar* getProp(xmlNodePtr node, const char* attr)
+{
+  xmlChar* key = xmlGetProp(node, reinterpret_cast<const xmlChar*>(attr));
+  if (key == nullptr)
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  return key;
+}
+
+// TODO: neither the XML doc nor any of the emplaced entities are properly
+// destroyed if this method throws an exception.
+EntityManager::id_type RealizingSystem::initSingleton(std::string filename)
+{
+  id_type world = game_.getEntityManager().emplaceEntity();
+
+  auto& realizable = game_.getEntityManager().
+    emplaceComponent<RealizableComponent>(world);
+
+  auto& mapping = game_.getSystemManager().getSystem<MappingSystem>();
+
+  xmlDocPtr doc = xmlParseFile(filename.c_str());
+  if (doc == nullptr)
+  {
+    throw std::invalid_argument("Cannot find world file");
+  }
+
+  xmlNodePtr top = xmlDocGetRootElement(doc);
+  if (top == nullptr)
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  if (xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("world")))
+  {
+    throw std::invalid_argument("Error parsing world file");
+  }
+
+  xmlChar* key = nullptr;
+
+  key = getProp(top, "startx");
+  realizable.startingX = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "starty");
+  realizable.startingY = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "startmap");
+  realizable.startingMapId = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  for (xmlNodePtr node = top->xmlChildrenNode;
+    node != nullptr;
+    node = node->next)
+  {
+    if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("map")))
+    {
+      id_type map = game_.getEntityManager().emplaceEntity();
+
+      auto& mappable = game_.getEntityManager().
+        emplaceComponent<MappableComponent>(map,
+          Texture("res/tiles.png"),
+          Texture("res/font.bmp"));
+
+      key = getProp(node, "id");
+      mappable.mapId = atoi(reinterpret_cast<char*>(key));
+      xmlFree(key);
+
+      key = getProp(node, "title");
+      mappable.title = reinterpret_cast<char*>(key);
+      xmlFree(key);
+
+      for (xmlNodePtr mapNode = node->xmlChildrenNode;
+        mapNode != nullptr;
+        mapNode = mapNode->next)
+      {
+        if (!xmlStrcmp(
+          mapNode->name,
+          reinterpret_cast<const xmlChar*>("environment")))
+        {
+          key = xmlNodeGetContent(mapNode);
+          if (key == nullptr)
+          {
+            throw std::invalid_argument("Error parsing world file");
+          }
+
+          mappable.tiles.clear();
+          mappable.tiles.push_back(atoi(strtok(
+            reinterpret_cast<char*>(key),
+            ",\n")));
+
+          for (size_t i = 1; i < (MAP_WIDTH * MAP_HEIGHT); i++)
+          {
+            mappable.tiles.push_back(atoi(strtok(nullptr, ",\n")));
+          }
+
+          xmlFree(key);
+        } else if (!xmlStrcmp(
+          mapNode->name,
+          reinterpret_cast<const xmlChar*>("adjacent")))
+        {
+          key = getProp(mapNode, "type");
+          std::string adjTypeStr(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          MappableComponent::Adjacent::Type adjType;
+          if (adjTypeStr == "wall")
+          {
+            adjType = MappableComponent::Adjacent::Type::wall;
+          } else if (adjTypeStr == "wrap")
+          {
+            adjType = MappableComponent::Adjacent::Type::wrap;
+          } else if (adjTypeStr == "warp")
+          {
+            adjType = MappableComponent::Adjacent::Type::warp;
+          } else if (adjTypeStr == "reverseWarp")
+          {
+            adjType = MappableComponent::Adjacent::Type::reverse;
+          } else {
+            throw std::logic_error("Invalid adjacency type");
+          }
+
+          key = getProp(mapNode, "map");
+          size_t adjMapId = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(mapNode, "dir");
+          std::string adjDir(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          if (adjDir == "left")
+          {
+            mappable.leftAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "right")
+          {
+            mappable.rightAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "up")
+          {
+            mappable.upAdjacent = {adjType, adjMapId};
+          } else if (adjDir == "down")
+          {
+            mappable.downAdjacent = {adjType, adjMapId};
+          } else {
+            throw std::logic_error("Invalid adjacency direction");
+          }
+        }
+      }
+
+      mapping.generateBoundaries(map);
+
+      realizable.maps.insert(map);
+      realizable.entityByMapId[mappable.mapId] = map;
+    }
+  }
+
+  xmlFreeDoc(doc);
+
+  loadMap(realizable.entityByMapId[realizable.startingMapId]);
+
+  return world;
+}
+
+EntityManager::id_type RealizingSystem::getSingleton() const
+{
+  std::set<id_type> result =
+    game_.getEntityManager().getEntitiesWithComponents<
+      RealizableComponent>();
+
+  if (result.empty())
+  {
+    throw std::logic_error("No realizable entity found");
+  } else if (result.size() > 1)
+  {
+    throw std::logic_error("Multiple realizable entities found");
+  }
+
+  return *std::begin(result);
+}
+
+void RealizingSystem::loadMap(id_type mapEntity)
+{
+  id_type world = getSingleton();
+
+  auto& realizable = game_.getEntityManager().
+    getComponent<RealizableComponent>(world);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
+
+  if (realizable.hasActiveMap)
+  {
+    id_type oldMap = realizable.activeMap;
+
+    auto& oldMappable = game_.getEntityManager().
+      getComponent<MappableComponent>(oldMap);
+
+    // Deactivate any map objects from the old map.
+    for (id_type prototype : oldMappable.objects)
+    {
+      leaveActiveMap(prototype);
+    }
+
+    // Deactivate players that were on the old map.
+    for (id_type player : players)
+    {
+      auto& playable = game_.getEntityManager().
+        getComponent<PlayableComponent>(player);
+
+      if (playable.mapId == oldMap)
+      {
+        leaveActiveMap(player);
+      }
+    }
+  }
+
+  realizable.hasActiveMap = true;
+  realizable.activeMap = mapEntity;
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  // Initialize the new map's objects.
+  for (id_type prototype : mappable.objects)
+  {
+    if (game_.getEntityManager().
+      hasComponent<TransformableComponent>(prototype))
+    {
+      auto& transformable = game_.getEntityManager().
+        getComponent<TransformableComponent>(prototype);
+
+      transformable.x = transformable.origX;
+      transformable.y = transformable.origY;
+      transformable.w = transformable.origW;
+      transformable.h = transformable.origH;
+    }
+
+    if (game_.getEntityManager().hasComponent<AnimatableComponent>(prototype))
+    {
+      animating.initPrototype(prototype);
+    }
+
+    if (game_.getEntityManager().hasComponent<PonderableComponent>(prototype))
+    {
+      pondering.initPrototype(prototype);
+    }
+
+    enterActiveMap(prototype);
+  }
+
+  // Activate any players on the map.
+  for (id_type player : players)
+  {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    if (playable.mapId == mapEntity)
+    {
+      enterActiveMap(player);
+    }
+  }
+}
+
+void RealizingSystem::enterActiveMap(id_type entity)
+{
+  if (game_.getEntityManager().hasComponent<AnimatableComponent>(entity))
+  {
+    auto& animatable = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    animatable.active = true;
+  }
+
+  if (game_.getEntityManager().hasComponent<PonderableComponent>(entity))
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.active = true;
+  }
+}
+
+void RealizingSystem::leaveActiveMap(id_type entity)
+{
+  if (game_.getEntityManager().hasComponent<AnimatableComponent>(entity))
+  {
+    auto& animatable = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    animatable.active = false;
+  }
+
+  if (game_.getEntityManager().hasComponent<PonderableComponent>(entity))
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.active = false;
+  }
+}
@@ -0,0 +1,43 @@
+#ifndef REALIZING_H_6853748C
+#define REALIZING_H_6853748C
+
+#include "system.h"
+
+class RealizingSystem : public System {
+public:
+
+  RealizingSystem(Game& game) : System(game)
+  {
+  }
+
+  /**
+   * Creates the singleton realizable entity and initializes it with the
+   * provided world definition.
+   */
+  id_type initSingleton(std::string filename);
+
+  /**
+   * Helper method that returns the entity ID of the (assumed) singleton entity
+   * with a RealizableComponent. Throws an exception if the number of realizable
+   * entities is not exactly one.
+   */
+  id_type getSingleton() const;
+
+  /**
+   * Loads the given map.
+   */
+  void loadMap(id_type mapEntity);
+
+  /**
+   * Treats the given entity as part of the active map.
+   */
+  void enterActiveMap(id_type entity);
+
+  /**
+   * Stops treating the given entity as part of the active map.
+   */
+  void leaveActiveMap(id_type entity);
+
+};
+
+#endif /* end of include guard: REALIZING_H_6853748C */
@@ -1,155 +0,0 @@
-#include "world.h"
-#include <libxml/parser.h>
-#include <stdexcept>
-#include <cstring>
-#include "consts.h"
-
-inline xmlChar* getProp(xmlNodePtr node, const char* attr)
-{
-  xmlChar* key = xmlGetProp(node, reinterpret_cast<const xmlChar*>(attr));
-  if (key == nullptr)
-  {
-    throw std::invalid_argument("Error parsing world file");
-  }
-
-  return key;
-}
-
-World::World(std::string filename)
-{
-  xmlDocPtr doc = xmlParseFile(filename.c_str());
-  if (doc == nullptr)
-  {
-    throw std::invalid_argument("Cannot find world file");
-  }
-
-  xmlNodePtr top = xmlDocGetRootElement(doc);
-  if (top == nullptr)
-  {
-    throw std::invalid_argument("Error parsing world file");
-  }
-
-  if (xmlStrcmp(top->name, reinterpret_cast<const xmlChar*>("world")))
-  {
-    throw std::invalid_argument("Error parsing world file");
-  }
-
-  xmlChar* key = nullptr;
-
-  key = getProp(top, "startx");
-  startX_ = atoi(reinterpret_cast<char*>(key));
-  xmlFree(key);
-
-  key = getProp(top, "starty");
-  startY_ = atoi(reinterpret_cast<char*>(key));
-  xmlFree(key);
-
-  key = getProp(top, "startmap");
-  startMap_ = atoi(reinterpret_cast<char*>(key));
-  xmlFree(key);
-
-  for (xmlNodePtr node = top->xmlChildrenNode;
-    node != nullptr;
-    node = node->next)
-  {
-    if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("map")))
-    {
-      key = getProp(node, "id");
-      size_t mapId = atoi(reinterpret_cast<char*>(key));
-      xmlFree(key);
-
-      key = getProp(node, "title");
-      std::string mapTitle(reinterpret_cast<char*>(key));
-      xmlFree(key);
-
-      std::vector<int> mapTiles;
-      Map::Adjacent leftAdj;
-      Map::Adjacent rightAdj;
-      Map::Adjacent upAdj;
-      Map::Adjacent downAdj;
-
-      for (xmlNodePtr mapNode = node->xmlChildrenNode;
-        mapNode != nullptr;
-        mapNode = mapNode->next)
-      {
-        if (!xmlStrcmp(
-          mapNode->name,
-          reinterpret_cast<const xmlChar*>("environment")))
-        {
-          key = xmlNodeGetContent(mapNode);
-
-          mapTiles.clear();
-          mapTiles.push_back(atoi(strtok(reinterpret_cast<char*>(key), ",\n")));
-          for (size_t i = 1; i < (MAP_WIDTH * MAP_HEIGHT); i++)
-          {
-            mapTiles.push_back(atoi(strtok(nullptr, ",\n")));
-          }
-
-          xmlFree(key);
-        } else if (!xmlStrcmp(
-          mapNode->name,
-          reinterpret_cast<const xmlChar*>("adjacent")))
-        {
-          key = getProp(mapNode, "type");
-          std::string adjTypeStr(reinterpret_cast<char*>(key));
-          xmlFree(key);
-
-          Map::Adjacent::Type adjType;
-          if (adjTypeStr == "wall")
-          {
-            adjType = Map::Adjacent::Type::wall;
-          } else if (adjTypeStr == "wrap")
-          {
-            adjType = Map::Adjacent::Type::wrap;
-          } else if (adjTypeStr == "warp")
-          {
-            adjType = Map::Adjacent::Type::warp;
-          } else if (adjTypeStr == "reverseWarp")
-          {
-            adjType = Map::Adjacent::Type::reverse;
-          } else {
-            throw std::logic_error("Invalid adjacency type");
-          }
-
-          key = getProp(mapNode, "map");
-          int adjMapId = atoi(reinterpret_cast<char*>(key));
-          xmlFree(key);
-
-          key = getProp(mapNode, "dir");
-          std::string adjDir(reinterpret_cast<char*>(key));
-          xmlFree(key);
-
-          if (adjDir == "left")
-          {
-            leftAdj = {adjType, adjMapId};
-          } else if (adjDir == "right")
-          {
-            rightAdj = {adjType, adjMapId};
-          } else if (adjDir == "up")
-          {
-            upAdj = {adjType, adjMapId};
-          } else if (adjDir == "down")
-          {
-            downAdj = {adjType, adjMapId};
-          } else {
-            throw std::logic_error("Invalid adjacency direction");
-          }
-        }
-      }
-
-      maps_.emplace(
-        std::piecewise_construct,
-        std::forward_as_tuple(mapId),
-        std::forward_as_tuple(
-          mapId,
-          std::move(mapTiles),
-          std::move(mapTitle),
-          leftAdj,
-          rightAdj,
-          upAdj,
-          downAdj));
-    }
-  }
-
-  xmlFreeDoc(doc);
-}
@@ -1,41 +0,0 @@
-#ifndef WORLD_H_153C698B
-#define WORLD_H_153C698B
-
-#include <map>
-#include <string>
-#include "map.h"
-
-class World {
-public:
-
-  explicit World(std::string filename);
-
-  inline const Map& getMap(size_t id) const
-  {
-    return maps_.at(id);
-  }
-
-  inline size_t getStartingMapId() const
-  {
-    return startMap_;
-  }
-
-  inline int getStartingX() const
-  {
-    return startX_;
-  }
-
-  inline int getStartingY() const
-  {
-    return startY_;
-  }
-
-private:
-
-  std::map<size_t, Map> maps_;
-  size_t startMap_;
-  int startX_;
-  int startY_;
-};
-
-#endif /* end of include guard: WORLD_H_153C698B */