14 files changed, 715 insertions, 160 deletions

@@ -0,0 +1,97 @@
+#include "collision.h"
+
+bool Collision::operator<(const Collision& other) const
+{
+  // Most important is the type of collision
+  if (type_ != other.type_)
+  {
+    return (static_cast<int>(type_) > static_cast<int>(other.type_));
+  }
+
+  // Next, categorize the collisions arbitrarily based on direction
+  if (dir_ != other.dir_)
+  {
+    return (static_cast<int>(dir_) < static_cast<int>(other.dir_));
+  }
+
+  // We want to process closer collisions first
+  if (axis_ != other.axis_)
+  {
+    switch (dir_)
+    {
+      case Direction::left:
+      case Direction::up:
+      {
+        return (axis_ < other.axis_);
+      }
+
+      case Direction::right:
+      case Direction::down:
+      {
+        return (axis_ > other.axis_);
+      }
+    }
+  }
+
+  // Order the remaining attributes arbitrarily
+  return std::tie(collider_, lower_, upper_) <
+    std::tie(other.collider_, other.lower_, other.upper_);
+}
+
+bool Collision::isColliding(
+  double x,
+  double y,
+  int w,
+  int h) const
+{
+  int right = x + w;
+  int bottom = y + h;
+
+  switch (dir_)
+  {
+    case Direction::left:
+    case Direction::right:
+    {
+      if (!((bottom > lower_) && (y < upper_)))
+      {
+        return false;
+      }
+
+      break;
+    }
+
+    case Direction::up:
+    case Direction::down:
+    {
+      if (!((right > lower_) && (x < upper_)))
+      {
+        return false;
+      }
+
+      break;
+    }
+  }
+
+  switch (dir_)
+  {
+    case Direction::left:
+    {
+      return (axis_ >= x);
+    }
+
+    case Direction::right:
+    {
+      return (axis_ <= right);
+    }
+
+    case Direction::up:
+    {
+      return (axis_ >= y);
+    }
+
+    case Direction::down:
+    {
+      return (axis_ <= bottom);
+    }
+  }
+}
@@ -0,0 +1,81 @@
+#ifndef COLLISION_H_53D84877
+#define COLLISION_H_53D84877
+
+#include "entity_manager.h"
+#include "direction.h"
+
+class Collision {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  // Types are defined in descending priority order
+  enum class Type {
+    wall,
+    platform,
+    adjacency,
+    warp,
+    danger
+  };
+
+  Collision(
+    id_type collider,
+    Direction dir,
+    Type type,
+    int axis,
+    double lower,
+    double upper) :
+      collider_(collider),
+      dir_(dir),
+      type_(type),
+      axis_(axis),
+      lower_(lower),
+      upper_(upper)
+  {
+  }
+
+  inline id_type getCollider() const
+  {
+    return collider_;
+  }
+
+  inline Direction getDirection() const
+  {
+    return dir_;
+  }
+
+  inline Type getType() const
+  {
+    return type_;
+  }
+
+  inline int getAxis() const
+  {
+    return axis_;
+  }
+
+  inline double getLower() const
+  {
+    return lower_;
+  }
+
+  inline double getUpper() const
+  {
+    return upper_;
+  }
+
+  bool operator<(const Collision& other) const;
+
+  bool isColliding(double x, double y, int w, int h) const;
+
+private:
+
+  id_type collider_;
+  Direction dir_;
+  Type type_;
+  int axis_;
+  double lower_;
+  double upper_;
+};
+
+#endif /* end of include guard: COLLISION_H_53D84877 */
@@ -4,6 +4,7 @@
 #include <map>
 #include "component.h"
 #include "renderer/texture.h"
+#include "collision.h"
 #include "map.h"
 
 class MappableComponent : public Component {
@@ -12,14 +13,7 @@ public:
   class Boundary {
   public:
 
-    enum class Type {
-      wall,
-      wrap,
-      teleport,
-      reverse,
-      platform,
-      danger
-    };
+    using Type = Collision::Type;
 
     Boundary(
       double axis,
@@ -0,0 +1,15 @@
+#ifndef PLAYABLE_H_DDC566C3
+#define PLAYABLE_H_DDC566C3
+
+#include "component.h"
+
+class PlayableComponent : public Component {
+public:
+
+  bool changingMap = false;
+  int newMapId = -1;
+  double newMapX = 0;
+  double newMapY = 0;
+};
+
+#endif /* end of include guard: PLAYABLE_H_DDC566C3 */
@@ -7,7 +7,7 @@ const int GAME_WIDTH = 320;
 const int GAME_HEIGHT = 200;
 const int MAP_WIDTH = GAME_WIDTH/TILE_WIDTH;
 const int MAP_HEIGHT = GAME_HEIGHT/TILE_HEIGHT - 1;
-const int WALL_GAP = 6;
+const int WALL_GAP = 5;
 const int TILESET_COLS = 8;
 const int FONT_COLS = 16;
 
@@ -26,6 +26,7 @@ private:
 
   database_type entities;
   std::vector<bool> slotAvailable;
+  std::set<id_type> allEntities;
   std::map<std::set<std::type_index>, std::set<id_type>> cachedComponents;
 
   id_type nextEntityID = 0;
@@ -59,12 +60,14 @@ public:
       // If the database is saturated, add a new element for the new entity.
       entities.emplace_back();
       slotAvailable.push_back(false);
+      allEntities.insert(nextEntityID);
 
       return nextEntityID++;
     } else {
       // If there is an available slot in the database, use it.
       id_type id = nextEntityID++;
       slotAvailable[id] = false;
+      allEntities.insert(id);
 
       // Fast forward the next available slot pointer to an available slot.
       while ((nextEntityID < entities.size()) && !slotAvailable[nextEntityID])
@@ -89,6 +92,8 @@ public:
       cache.second.erase(entity);
     }
 
+    allEntities.erase(entity);
+
     // Destroy the data
     entities[entity].components.clear();
 
@@ -202,6 +207,11 @@ public:
 
     return getEntitiesWithComponentsHelper<R...>(componentTypes);
   }
+
+  const std::set<id_type>& getEntities() const
+  {
+    return allEntities;
+  }
 };
 
 template <>
@@ -9,6 +9,7 @@
 #include "systems/animating.h"
 #include "systems/mapping.h"
 #include "systems/orienting.h"
+#include "systems/playing.h"
 #include "animation.h"
 #include "consts.h"
 
@@ -28,36 +29,14 @@ void key_callback(GLFWwindow* window, int key, int, int action, int)
 
 Game::Game() : world_("res/maps.xml")
 {
+  systemManager_.emplaceSystem<PlayingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
   systemManager_.emplaceSystem<OrientingSystem>(*this);
   systemManager_.emplaceSystem<PonderingSystem>(*this);
   systemManager_.emplaceSystem<MappingSystem>(*this);
   systemManager_.emplaceSystem<AnimatingSystem>(*this);
 
-  int player = entityManager_.emplaceEntity();
-
-  AnimationSet playerGraphics {"res/Starla.png", 10, 12, 6};
-  playerGraphics.emplaceAnimation("stillLeft", 3, 1, 1);
-  playerGraphics.emplaceAnimation("stillRight", 0, 1, 1);
-  playerGraphics.emplaceAnimation("walkingLeft", 4, 2, 10);
-  playerGraphics.emplaceAnimation("walkingRight", 1, 2, 10);
-
-  entityManager_.emplaceComponent<AnimatableComponent>(
-    player,
-    std::move(playerGraphics),
-    "stillLeft");
-
-  entityManager_.emplaceComponent<TransformableComponent>(
-    player,
-    203, 44, 10, 12);
-
-  systemManager_.getSystem<PonderingSystem>().initializeBody(
-    player,
-    PonderableComponent::Type::freefalling);
-
-  entityManager_.emplaceComponent<ControllableComponent>(player);
-  entityManager_.emplaceComponent<OrientableComponent>(player);
-
+  systemManager_.getSystem<PlayingSystem>().initPlayer();
   systemManager_.getSystem<MappingSystem>().loadMap(world_.getStartingMapId());
 
   glfwSwapInterval(1);
@@ -10,13 +10,55 @@
 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) :
+    std::string title,
+    Adjacent leftAdjacent,
+    Adjacent rightAdjacent,
+    Adjacent upAdjacent,
+    Adjacent downAdjacent) :
       id_(id),
       tiles_(std::move(tiles)),
-      title_(std::move(title))
+      title_(std::move(title)),
+      leftAdjacent_(std::move(leftAdjacent)),
+      rightAdjacent_(std::move(rightAdjacent)),
+      upAdjacent_(std::move(upAdjacent)),
+      downAdjacent_(std::move(downAdjacent))
   {
   }
 
@@ -35,11 +77,35 @@ public:
     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 */
@@ -93,6 +93,34 @@ void MappingSystem::loadMap(size_t mapId)
 
   const Map& map = game_.getWorld().getMap(mappable.getMapId());
 
+  addBoundary(
+    mappable.getLeftBoundaries(),
+    -WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.getRightBoundaries(),
+    GAME_WIDTH + WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.getUpBoundaries(),
+    -WALL_GAP,
+    0,
+    GAME_WIDTH,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.getDownBoundaries(),
+    MAP_HEIGHT * TILE_HEIGHT + WALL_GAP,
+    0,
+    GAME_WIDTH,
+    MappableComponent::Boundary::Type::adjacency);
+
   for (size_t i = 0; i < MAP_WIDTH * MAP_HEIGHT; i++)
   {
     size_t x = i % MAP_WIDTH;
@@ -0,0 +1,98 @@
+#include "playing.h"
+#include "game.h"
+#include "components/transformable.h"
+#include "components/animatable.h"
+#include "components/playable.h"
+#include "components/controllable.h"
+#include "components/orientable.h"
+#include "systems/mapping.h"
+#include "systems/pondering.h"
+#include "animation.h"
+
+void PlayingSystem::tick(double)
+{
+  // Check if we need to change the map
+  auto players = game_.getEntityManager().getEntitiesWithComponents<
+    PlayableComponent>();
+
+  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;
+
+      break;
+    }
+  }
+}
+
+void PlayingSystem::initPlayer()
+{
+  id_type player = game_.getEntityManager().emplaceEntity();
+
+  AnimationSet playerGraphics {"res/Starla.png", 10, 12, 6};
+  playerGraphics.emplaceAnimation("stillLeft", 3, 1, 1);
+  playerGraphics.emplaceAnimation("stillRight", 0, 1, 1);
+  playerGraphics.emplaceAnimation("walkingLeft", 4, 2, 10);
+  playerGraphics.emplaceAnimation("walkingRight", 1, 2, 10);
+
+  game_.getEntityManager().emplaceComponent<AnimatableComponent>(
+    player,
+    std::move(playerGraphics),
+    "stillLeft");
+
+  game_.getEntityManager().emplaceComponent<TransformableComponent>(
+    player,
+    203, 44, 10, 12);
+
+  game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
+    player,
+    PonderableComponent::Type::freefalling);
+
+  game_.getEntityManager().emplaceComponent<ControllableComponent>(player);
+  game_.getEntityManager().emplaceComponent<OrientableComponent>(player);
+  game_.getEntityManager().emplaceComponent<PlayableComponent>(player);
+}
+
+void PlayingSystem::changeMap(
+  size_t mapId,
+  double x,
+  double y)
+{
+  auto players = game_.getEntityManager().getEntitiesWithComponents<
+    PlayableComponent>();
+
+  for (id_type player : players)
+  {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    playable.changingMap = true;
+    playable.newMapId = mapId;
+    playable.newMapX = x;
+    playable.newMapY = y;
+  }
+}
@@ -0,0 +1,21 @@
+#ifndef PLAYING_H_70A54F7D
+#define PLAYING_H_70A54F7D
+
+#include "system.h"
+
+class PlayingSystem : public System {
+public:
+
+  PlayingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void initPlayer();
+
+  void changeMap(size_t mapId, double x, double y);
+
+};
+
+#endif /* end of include guard: PLAYING_H_70A54F7D */
@@ -1,11 +1,14 @@
 #include "pondering.h"
+#include <queue>
 #include "game.h"
 #include "components/ponderable.h"
 #include "components/transformable.h"
 #include "components/orientable.h"
 #include "components/mappable.h"
 #include "systems/orienting.h"
+#include "systems/playing.h"
 #include "consts.h"
+#include "collision.h"
 
 void PonderingSystem::tick(double dt)
 {
@@ -42,6 +45,9 @@ void PonderingSystem::tick(double dt)
     bool oldGrounded = ponderable.isGrounded();
     ponderable.setGrounded(false);
 
+    std::priority_queue<Collision> collisions;
+
+    // Find collisions
     for (id_type mapEntity : maps)
     {
       auto& mappable = game_.getEntityManager().
@@ -57,13 +63,13 @@ void PonderingSystem::tick(double dt)
             && (oldY < it->second.getUpper()))
           {
             // We have a collision!
-            processCollision(
-              entity,
+            collisions.emplace(
+              mapEntity,
               Direction::left,
-              newX,
-              newY,
+              it->second.getType(),
               it->first,
-              it->second.getType());
+              it->second.getLower(),
+              it->second.getUpper());
           }
         }
       } else if (newX > oldX)
@@ -77,13 +83,13 @@ void PonderingSystem::tick(double dt)
             && (oldY < it->second.getUpper()))
           {
             // We have a collision!
-            processCollision(
-              entity,
+            collisions.emplace(
+              mapEntity,
               Direction::right,
-              newX,
-              newY,
+              it->second.getType(),
               it->first,
-              it->second.getType());
+              it->second.getLower(),
+              it->second.getUpper());
           }
         }
       }
@@ -98,13 +104,13 @@ void PonderingSystem::tick(double dt)
             && (oldX < it->second.getUpper()))
           {
             // We have a collision!
-            processCollision(
-              entity,
+            collisions.emplace(
+              mapEntity,
               Direction::up,
-              newX,
-              newY,
+              it->second.getType(),
               it->first,
-              it->second.getType());
+              it->second.getLower(),
+              it->second.getUpper());
           }
         }
       } else if (newY > oldY)
@@ -118,13 +124,221 @@ void PonderingSystem::tick(double dt)
             && (oldX < it->second.getUpper()))
           {
             // We have a collision!
-            processCollision(
-              entity,
+            collisions.emplace(
+              mapEntity,
               Direction::down,
-              newX,
-              newY,
+              it->second.getType(),
               it->first,
-              it->second.getType());
+              it->second.getLower(),
+              it->second.getUpper());
+          }
+        }
+      }
+    }
+
+    // Process collisions in order of priority
+    while (!collisions.empty())
+    {
+      Collision collision = collisions.top();
+      collisions.pop();
+
+      // Make sure that they are still colliding
+      if (!collision.isColliding(
+        newX,
+        newY,
+        transformable.getW(),
+        transformable.getH()))
+      {
+        continue;
+      }
+
+      bool touchedWall = false;
+      bool stopProcessing = false;
+
+      switch (collision.getType())
+      {
+        case Collision::Type::wall:
+        {
+          touchedWall = true;
+
+          break;
+        }
+
+        case Collision::Type::platform:
+        {
+          if (game_.getEntityManager().
+            hasComponent<OrientableComponent>(entity))
+          {
+            auto& orientable = game_.getEntityManager().
+              getComponent<OrientableComponent>(entity);
+
+            if (orientable.getDropState() !=
+              OrientableComponent::DropState::none)
+            {
+              orientable.setDropState(OrientableComponent::DropState::active);
+            } else {
+              touchedWall = true;
+            }
+          } else {
+            touchedWall = true;
+          }
+
+          break;
+        }
+
+        case Collision::Type::adjacency:
+        {
+          auto& mappable = game_.getEntityManager().
+            getComponent<MappableComponent>(collision.getCollider());
+          const Map& map = game_.getWorld().getMap(mappable.getMapId());
+          auto& adj = [&] () -> const Map::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();
+              }
+            }();
+
+          switch (adj.getType())
+          {
+            case Map::Adjacent::Type::wall:
+            {
+              touchedWall = true;
+
+              break;
+            }
+
+            case Map::Adjacent::Type::wrap:
+            {
+              switch (collision.getDirection())
+              {
+                case Direction::left:
+                {
+                  newX = GAME_WIDTH + WALL_GAP - transformable.getW();
+
+                  break;
+                }
+
+                case Direction::right:
+                {
+                  newX = -WALL_GAP;
+
+                  break;
+                }
+
+                case Direction::up:
+                {
+                  newY = MAP_HEIGHT * TILE_HEIGHT + WALL_GAP -
+                    transformable.getH();
+
+                  break;
+                }
+
+                case Direction::down:
+                {
+                  newY = -WALL_GAP;
+
+                  break;
+                }
+              }
+            }
+
+            case Map::Adjacent::Type::warp:
+            {
+              double warpX = newX;
+              double warpY = newY;
+
+              switch (collision.getDirection())
+              {
+                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;
+                }
+              }
+
+              game_.getSystemManager().getSystem<PlayingSystem>().
+                changeMap(adj.getMapId(), warpX, warpY);
+
+              stopProcessing = true;
+
+              break;
+            }
+          }
+        }
+
+        default:
+        {
+          // Not yet implemented.
+
+          break;
+        }
+      }
+
+      if (stopProcessing)
+      {
+        break;
+      }
+
+      if (touchedWall)
+      {
+        switch (collision.getDirection())
+        {
+          case Direction::left:
+          {
+            newX = collision.getAxis();
+            ponderable.setVelocityX(0.0);
+
+            break;
+          }
+
+          case Direction::right:
+          {
+            newX = collision.getAxis() - transformable.getW();
+            ponderable.setVelocityX(0.0);
+
+            break;
+          }
+
+          case Direction::up:
+          {
+            newY = collision.getAxis();
+            ponderable.setVelocityY(0.0);
+
+            break;
+          }
+
+          case Direction::down:
+          {
+            newY = collision.getAxis() - transformable.getH();
+            ponderable.setVelocityY(0.0);
+            ponderable.setGrounded(true);
+
+            break;
           }
         }
       }
@@ -173,96 +387,3 @@ void PonderingSystem::initializeBody(
     ponderable.setAccelY(NORMAL_GRAVITY);
   }
 }
-
-void PonderingSystem::processCollision(
-  id_type entity,
-  Direction dir,
-  double& newX,
-  double& newY,
-  int axis,
-  MappableComponent::Boundary::Type type)
-{
-  auto& ponderable = game_.getEntityManager().
-    getComponent<PonderableComponent>(entity);
-
-  auto& transformable = game_.getEntityManager().
-    getComponent<TransformableComponent>(entity);
-
-  bool touchedGround = false;
-
-  switch (type)
-  {
-    case MappableComponent::Boundary::Type::wall:
-    {
-      switch (dir)
-      {
-        case Direction::left:
-        {
-          newX = axis;
-          ponderable.setVelocityX(0.0);
-
-          break;
-        }
-
-        case Direction::right:
-        {
-          newX = axis - transformable.getW();
-          ponderable.setVelocityX(0.0);
-
-          break;
-        }
-
-        case Direction::up:
-        {
-          newY = axis;
-          ponderable.setVelocityY(0.0);
-
-          break;
-        }
-
-        case Direction::down:
-        {
-          touchedGround = true;
-
-          break;
-        }
-      }
-
-      break;
-    }
-
-    case MappableComponent::Boundary::Type::platform:
-    {
-      if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
-      {
-        auto& orientable = game_.getEntityManager().
-          getComponent<OrientableComponent>(entity);
-
-        if (orientable.getDropState() != OrientableComponent::DropState::none)
-        {
-          orientable.setDropState(OrientableComponent::DropState::active);
-        } else {
-          touchedGround = true;
-        }
-      } else {
-        touchedGround = true;
-      }
-
-      break;
-    }
-
-    default:
-    {
-      // Not yet implemented.
-
-      break;
-    }
-  }
-
-  if (touchedGround)
-  {
-    newY = axis - transformable.getH();
-    ponderable.setVelocityY(0.0);
-    ponderable.setGrounded(true);
-  }
-}
@@ -2,7 +2,6 @@
 #define PONDERING_H_F2530E0E
 
 #include "system.h"
-#include "components/mappable.h"
 #include "components/ponderable.h"
 #include "direction.h"
 
@@ -17,16 +16,6 @@ public:
 
   void initializeBody(id_type entity, PonderableComponent::Type type);
 
-private:
-
-  void processCollision(
-    id_type entity,
-    Direction dir,
-    double& newX,
-    double& newY,
-    int axis,
-    MappableComponent::Boundary::Type type);
-
 };
 
 #endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -63,6 +63,10 @@ World::World(std::string filename)
       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;
@@ -82,6 +86,54 @@ World::World(std::string filename)
           }
 
           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");
+          }
         }
       }
 
@@ -91,7 +143,11 @@ World::World(std::string filename)
         std::forward_as_tuple(
           mapId,
           std::move(mapTiles),
-          std::move(mapTitle)));
+          std::move(mapTitle),
+          leftAdj,
+          rightAdj,
+          upAdj,
+          downAdj));
     }
   }