18 files changed, 2819 insertions, 0 deletions

@@ -0,0 +1,103 @@
+#include "animating.h"
+#include "game.h"
+#include "components/animatable.h"
+#include "components/transformable.h"
+
+void AnimatingSystem::tick(double)
+{
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<AnimatableComponent>();
+
+  for (id_type entity : spriteEntities)
+  {
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    if (sprite.active)
+    {
+      if (!sprite.frozen)
+      {
+        sprite.countdown++;
+      }
+
+      const Animation& anim = sprite.getAnimation();
+      if (sprite.countdown >= anim.getDelay())
+      {
+        sprite.frame++;
+        sprite.countdown = 0;
+
+        if (sprite.frame >= anim.getFirstFrame() + anim.getNumFrames())
+        {
+          sprite.frame = anim.getFirstFrame();
+        }
+      }
+
+      if (sprite.flickering)
+      {
+        sprite.flickerTimer = (sprite.flickerTimer + 1) % 6;
+      }
+    }
+  }
+}
+
+void AnimatingSystem::render(Texture& texture)
+{
+  std::set<id_type> spriteEntities =
+    game_.getEntityManager().getEntitiesWithComponents<
+      AnimatableComponent,
+      TransformableComponent>();
+
+  for (id_type entity : spriteEntities)
+  {
+    auto& sprite = game_.getEntityManager().
+      getComponent<AnimatableComponent>(entity);
+
+    if (sprite.active)
+    {
+      auto& transform = game_.getEntityManager().
+        getComponent<TransformableComponent>(entity);
+
+      double alpha = 1.0;
+      if (sprite.flickering && (sprite.flickerTimer < 3))
+      {
+        alpha = 0.0;
+      }
+
+      Rectangle dstrect {
+        static_cast<int>(transform.pos.x()),
+        static_cast<int>(transform.pos.y()),
+        transform.size.w(),
+        transform.size.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.animation = std::move(animation);
+  sprite.frame = sprite.getAnimation().getFirstFrame();
+}
@@ -0,0 +1,25 @@
+#ifndef ANIMATING_H_5BBF0094
+#define ANIMATING_H_5BBF0094
+
+#include "system.h"
+#include <string>
+#include "renderer/texture.h"
+
+class AnimatingSystem : public System {
+public:
+
+  AnimatingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void render(Texture& texture);
+
+  void initPrototype(id_type entity);
+
+  void startAnimation(id_type entity, std::string animation);
+
+};
+
+#endif /* end of include guard: ANIMATING_H_5BBF0094 */
@@ -0,0 +1,136 @@
+#include "controlling.h"
+#include "game.h"
+#include "components/controllable.h"
+#include "components/orientable.h"
+#include "systems/orienting.h"
+
+void ControllingSystem::tick(double)
+{
+  while (!actions_.empty())
+  {
+    int key = actions_.front().first;
+    int action = actions_.front().second;
+
+    auto entities = game_.getEntityManager().getEntitiesWithComponents<
+      ControllableComponent,
+      OrientableComponent>();
+
+    for (auto entity : entities)
+    {
+      auto& controllable = game_.getEntityManager().
+        getComponent<ControllableComponent>(entity);
+
+      auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
+      if (action == GLFW_PRESS)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(true);
+
+          if (!controllable.isFrozen())
+          {
+            orienting.moveLeft(entity);
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(true);
+
+          if (!controllable.isFrozen())
+          {
+            orienting.moveRight(entity);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.jump(entity);
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.drop(entity);
+          }
+        }
+      } else if (action == GLFW_RELEASE)
+      {
+        if (key == controllable.getLeftKey())
+        {
+          controllable.setHoldingLeft(false);
+
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingRight())
+            {
+              orienting.moveRight(entity);
+            } else {
+              orienting.stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getRightKey())
+        {
+          controllable.setHoldingRight(false);
+
+          if (!controllable.isFrozen())
+          {
+            if (controllable.isHoldingLeft())
+            {
+              orienting.moveLeft(entity);
+            } else {
+              orienting.stopWalking(entity);
+            }
+          }
+        } else if (key == controllable.getDropKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.stopDropping(entity);
+          }
+        } else if (key == controllable.getJumpKey())
+        {
+          if (!controllable.isFrozen())
+          {
+            orienting.stopJumping(entity);
+          }
+        }
+      }
+    }
+
+    actions_.pop();
+  }
+}
+
+void ControllingSystem::input(int key, int action)
+{
+  actions_.push(std::make_pair(key, action));
+}
+
+void ControllingSystem::freeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  controllable.setFrozen(true);
+}
+
+void ControllingSystem::unfreeze(id_type entity)
+{
+  auto& controllable = game_.getEntityManager().
+    getComponent<ControllableComponent>(entity);
+
+  if (controllable.isFrozen())
+  {
+    controllable.setFrozen(false);
+
+    auto& orienting = game_.getSystemManager().getSystem<OrientingSystem>();
+
+    if (controllable.isHoldingLeft())
+    {
+      orienting.moveLeft(entity);
+    } else if (controllable.isHoldingRight())
+    {
+      orienting.moveRight(entity);
+    }
+  }
+}
@@ -0,0 +1,27 @@
+#ifndef CONTROLLING_H_80B1BB8D
+#define CONTROLLING_H_80B1BB8D
+
+#include "system.h"
+#include <queue>
+
+class ControllingSystem : public System {
+public:
+
+  ControllingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void input(int key, int action);
+
+  void freeze(id_type entity);
+
+  void unfreeze(id_type entity);
+
+private:
+
+  std::queue<std::pair<int,int>> actions_;
+};
+
+#endif /* end of include guard: CONTROLLING_H_80B1BB8D */
@@ -0,0 +1,187 @@
+#include "mapping.h"
+#include "components/mappable.h"
+#include "systems/realizing.h"
+#include "game.h"
+#include "consts.h"
+
+template <typename Storage>
+inline void addBoundary(
+  Storage& boundaries,
+  int axis,
+  int lower,
+  int upper,
+  MappableComponent::Boundary::Type type)
+{
+  boundaries.emplace(std::piecewise_construct,
+    std::tie(axis),
+    std::tie(axis, lower, upper, type));
+}
+
+void MappingSystem::render(Texture& texture)
+{
+  id_type map =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
+
+  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 = mappable.tiles[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.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::generateBoundaries(id_type mapEntity)
+{
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  addBoundary(
+    mappable.leftBoundaries,
+    -WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.rightBoundaries,
+    GAME_WIDTH + WALL_GAP,
+    0,
+    MAP_HEIGHT * TILE_HEIGHT,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.upBoundaries,
+    -WALL_GAP,
+    0,
+    GAME_WIDTH,
+    MappableComponent::Boundary::Type::adjacency);
+
+  addBoundary(
+    mappable.downBoundaries,
+    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;
+    size_t y = i / MAP_WIDTH;
+    int tile = mappable.tiles[i];
+
+    if ((tile >= 5) && (tile <= 7))
+    {
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x + 1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::platform);
+    } else if ((tile > 0) && (tile < 28))
+    {
+      addBoundary(
+        mappable.rightBoundaries,
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.leftBoundaries,
+        (x+1) * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::wall);
+
+      addBoundary(
+        mappable.upBoundaries,
+        (y+1) * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::wall);
+    } else if (tile == 42)
+    {
+      addBoundary(
+        mappable.rightBoundaries,
+        x * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.leftBoundaries,
+        (x+1) * TILE_WIDTH,
+        y * TILE_HEIGHT,
+        (y+1) * TILE_HEIGHT,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.downBoundaries,
+        y * TILE_HEIGHT + 1,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::danger);
+
+      addBoundary(
+        mappable.upBoundaries,
+        (y+1) * TILE_HEIGHT,
+        x * TILE_WIDTH,
+        (x+1) * TILE_WIDTH,
+        MappableComponent::Boundary::Type::danger);
+    }
+  }
+}
@@ -0,0 +1,19 @@
+#ifndef MAPPING_H_33FC2294
+#define MAPPING_H_33FC2294
+
+#include "system.h"
+
+class MappingSystem : public System {
+public:
+
+  MappingSystem(Game& game) : System(game)
+  {
+  }
+
+  void render(Texture& texture);
+
+  void generateBoundaries(id_type mapEntity);
+
+};
+
+#endif /* end of include guard: MAPPING_H_33FC2294 */
@@ -0,0 +1,230 @@
+#include "orienting.h"
+#include "game.h"
+#include "components/orientable.h"
+#include "components/ponderable.h"
+#include "systems/animating.h"
+#include "consts.h"
+#include "muxer.h"
+
+void OrientingSystem::tick(double)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    OrientableComponent,
+    PonderableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    switch (orientable.getWalkState())
+    {
+      case OrientableComponent::WalkState::still:
+      {
+        ponderable.vel.x() = 0.0;
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::left:
+      {
+        ponderable.vel.x() = -WALK_SPEED;
+
+        break;
+      }
+
+      case OrientableComponent::WalkState::right:
+      {
+        ponderable.vel.x() = WALK_SPEED;
+
+        break;
+      }
+    }
+
+    if (orientable.isJumping() && (ponderable.vel.y() > 0))
+    {
+      orientable.setJumping(false);
+    }
+  }
+}
+
+void OrientingSystem::moveLeft(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(false);
+  orientable.setWalkState(OrientableComponent::WalkState::left);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.grounded)
+  {
+    animating.startAnimation(entity, "walkingLeft");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::moveRight(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setFacingRight(true);
+  orientable.setWalkState(OrientableComponent::WalkState::right);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  if (ponderable.grounded)
+  {
+    animating.startAnimation(entity, "walkingRight");
+  } else {
+    animating.startAnimation(entity, "stillRight");
+  }
+}
+
+void OrientingSystem::stopWalking(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  orientable.setWalkState(OrientableComponent::WalkState::still);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::jump(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.grounded)
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    orientable.setJumping(true);
+
+    playSound("res/Randomize87.wav", 0.25);
+
+    ponderable.vel.y() = JUMP_VELOCITY;
+    ponderable.accel.y() = JUMP_GRAVITY;
+
+    auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+    if (orientable.isFacingRight())
+    {
+      animating.startAnimation(entity, "stillRight");
+    } else {
+      animating.startAnimation(entity, "stillLeft");
+    }
+  }
+}
+
+void OrientingSystem::stopJumping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.isJumping())
+  {
+    orientable.setJumping(false);
+
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    ponderable.accel.y() = NORMAL_GRAVITY;
+  }
+}
+
+void OrientingSystem::land(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  switch (orientable.getWalkState())
+  {
+    case OrientableComponent::WalkState::still:
+    {
+      if (orientable.isFacingRight())
+      {
+        animating.startAnimation(entity, "stillRight");
+      } else {
+        animating.startAnimation(entity, "stillLeft");
+      }
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::left:
+    {
+      animating.startAnimation(entity, "walkingLeft");
+
+      break;
+    }
+
+    case OrientableComponent::WalkState::right:
+    {
+      animating.startAnimation(entity, "walkingRight");
+
+      break;
+    }
+  }
+}
+
+void OrientingSystem::startFalling(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+
+  if (orientable.isFacingRight())
+  {
+    animating.startAnimation(entity, "stillRight");
+  } else {
+    animating.startAnimation(entity, "stillLeft");
+  }
+}
+
+void OrientingSystem::drop(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.grounded
+    && (orientable.getDropState() == OrientableComponent::DropState::none))
+  {
+    orientable.setDropState(OrientableComponent::DropState::ready);
+  }
+}
+
+void OrientingSystem::stopDropping(id_type entity)
+{
+  auto& orientable = game_.getEntityManager().
+    getComponent<OrientableComponent>(entity);
+
+  if (orientable.getDropState() == OrientableComponent::DropState::ready)
+  {
+    orientable.setDropState(OrientableComponent::DropState::none);
+  }
+}
@@ -0,0 +1,35 @@
+#ifndef ORIENTING_H_099F0C23
+#define ORIENTING_H_099F0C23
+
+#include "system.h"
+
+class OrientingSystem : public System {
+public:
+
+  OrientingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void moveLeft(id_type entity);
+
+  void moveRight(id_type entity);
+
+  void stopWalking(id_type entity);
+
+  void jump(id_type entity);
+
+  void stopJumping(id_type entity);
+
+  void land(id_type entity);
+
+  void startFalling(id_type entity);
+
+  void drop(id_type entity);
+
+  void stopDropping(id_type entity);
+
+};
+
+#endif /* end of include guard: ORIENTING_H_099F0C23 */
@@ -0,0 +1,144 @@
+#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 "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::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));
+
+  game_.getSystemManager().getSystem<AnimatingSystem>().startAnimation(
+    player,
+    "stillLeft");
+
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  auto& transformable = game_.getEntityManager().
+    emplaceComponent<TransformableComponent>(player);
+
+  transformable.pos = realizing.getStartingPos();
+  transformable.size.w() = 10;
+  transformable.size.h() = 12;
+
+  game_.getSystemManager().getSystem<PonderingSystem>().initializeBody(
+    player,
+    PonderableComponent::Type::freefalling);
+
+  game_.getEntityManager().emplaceComponent<ControllableComponent>(player);
+  game_.getEntityManager().emplaceComponent<OrientableComponent>(player);
+
+  auto& playable = game_.getEntityManager().
+    emplaceComponent<PlayableComponent>(player);
+
+  playable.mapId = realizing.getActiveMap();
+  playable.checkpointMapId = realizing.getStartingMapId();
+  playable.checkpointPos = realizing.getStartingPos();
+
+  realizing.enterActiveMap(player);
+
+  realizing.setActivePlayer(player);
+}
+
+void PlayingSystem::changeMap(
+  id_type player,
+  size_t mapId,
+  vec2d warpPos)
+{
+  auto& playable = game_.getEntityManager().
+    getComponent<PlayableComponent>(player);
+
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(player);
+
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+  auto& realizing = game_.getSystemManager().getSystem<RealizingSystem>();
+
+  id_type newMapEntity = realizing.getEntityByMapId(mapId);
+
+  if (playable.mapId != newMapEntity)
+  {
+    if (playable.mapId == realizing.getActiveMap())
+    {
+      realizing.leaveActiveMap(player);
+    } else if (newMapEntity == realizing.getActiveMap())
+    {
+      realizing.enterActiveMap(player);
+    }
+
+    playable.mapId = newMapEntity;
+  }
+
+  pondering.unferry(player);
+
+  transformable.pos = warpPos;
+
+  if (realizing.getActivePlayer() == player)
+  {
+    realizing.loadMap(newMapEntity);
+  }
+}
+
+void PlayingSystem::die(id_type player)
+{
+  playSound("res/Hit_Hurt5.wav", 0.25);
+
+  auto& animatable = game_.getEntityManager().
+    getComponent<AnimatableComponent>(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.checkpointPos);
+
+    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);
+  });
+}
@@ -0,0 +1,25 @@
+#ifndef PLAYING_H_70A54F7D
+#define PLAYING_H_70A54F7D
+
+#include "system.h"
+#include "vector.h"
+
+class PlayingSystem : public System {
+public:
+
+  PlayingSystem(Game& game) : System(game)
+  {
+  }
+
+  void initPlayer();
+
+  void changeMap(
+    id_type player,
+    size_t mapId,
+    vec2d warpPos);
+
+  void die(id_type player);
+
+};
+
+#endif /* end of include guard: PLAYING_H_70A54F7D */
@@ -0,0 +1,916 @@
+#include "pondering.h"
+#include <queue>
+#include <algorithm>
+#include "game.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/orientable.h"
+#include "components/mappable.h"
+#include "components/playable.h"
+#include "systems/orienting.h"
+#include "systems/playing.h"
+#include "systems/realizing.h"
+#include "systems/scripting.h"
+#include "consts.h"
+
+void PonderingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& ponderable = game_.getEntityManager().
+      getComponent<PonderableComponent>(entity);
+
+    // We will recursively process ferried bodies after their ferries have been
+    // processed, so hold off on processing ferried bodies at the top level.
+    if (ponderable.ferried)
+    {
+      continue;
+    }
+
+    tickBody(entity, dt);
+  }
+}
+
+void PonderingSystem::initializeBody(
+  id_type entity,
+  PonderableComponent::Type type)
+{
+  auto& ponderable = game_.getEntityManager().
+    emplaceComponent<PonderableComponent>(entity, type);
+
+  if (type == PonderableComponent::Type::freefalling)
+  {
+    ponderable.accel.y() = NORMAL_GRAVITY;
+  }
+}
+
+void PonderingSystem::initPrototype(id_type prototype)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(prototype);
+
+  ponderable.vel.x() = 0.0;
+  ponderable.vel.y() = 0.0;
+  ponderable.accel.x() = 0.0;
+  ponderable.accel.y() = 0.0;
+  ponderable.grounded = false;
+  ponderable.frozen = false;
+  ponderable.collidable = true;
+  ponderable.ferried = false;
+  ponderable.passengers.clear();
+}
+
+void PonderingSystem::unferry(id_type entity)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (ponderable.ferried)
+  {
+    ponderable.ferried = false;
+
+    auto& ferryPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(ponderable.ferry);
+
+    ferryPonder.passengers.erase(entity);
+  }
+}
+
+void PonderingSystem::tickBody(
+  id_type entity,
+  double dt)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  if (!ponderable.active)
+  {
+    return;
+  }
+
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  // Accelerate
+  if (!ponderable.frozen)
+  {
+    ponderable.vel += ponderable.accel * dt;
+
+    if ((ponderable.type == PonderableComponent::Type::freefalling)
+      && (ponderable.vel.y() > TERMINAL_VELOCITY))
+    {
+      ponderable.vel.y() = TERMINAL_VELOCITY;
+    }
+  }
+
+  // Move
+  vec2d newPos = transformable.pos;
+
+  if (!ponderable.frozen)
+  {
+    newPos += ponderable.vel * dt;
+  }
+
+  CollisionResult result = moveBody(entity, newPos);
+
+  // Perform cleanup for orientable entites
+  bool groundedChanged = (ponderable.grounded != result.grounded);
+  ponderable.grounded = result.grounded;
+
+  if (game_.getEntityManager().hasComponent<OrientableComponent>(entity))
+  {
+    auto& orientable = game_.getEntityManager().
+      getComponent<OrientableComponent>(entity);
+
+    // Handle changes in groundedness
+    if (groundedChanged)
+    {
+      if (ponderable.grounded)
+      {
+        game_.getSystemManager().getSystem<OrientingSystem>().land(entity);
+      } else {
+        game_.getSystemManager().
+          getSystem<OrientingSystem>().startFalling(entity);
+      }
+    }
+
+    // Complete dropping, if necessary
+    if (orientable.getDropState() == OrientableComponent::DropState::active)
+    {
+      orientable.setDropState(OrientableComponent::DropState::none);
+    }
+  }
+
+  // Ferry or unferry as necessary
+  if ((ponderable.type == PonderableComponent::Type::freefalling) &&
+      groundedChanged)
+  {
+    if (ponderable.grounded &&
+        game_.getEntityManager().
+          hasComponent<PonderableComponent>(result.groundEntity))
+    {
+      // The body is now being ferried
+      auto& ferryPonder = game_.getEntityManager().
+        getComponent<PonderableComponent>(result.groundEntity);
+
+      ponderable.ferried = true;
+      ponderable.ferry = result.groundEntity;
+      ponderable.ferrySide = Direction::up;
+
+      ferryPonder.passengers.insert(entity);
+    } else if (ponderable.ferried)
+    {
+      // The body is no longer being ferried
+      unferry(entity);
+    }
+  }
+
+  // Handle ferry passengers
+  std::set<id_type> passengers = ponderable.passengers;
+
+  for (id_type passenger : passengers)
+  {
+    tickBody(passenger, dt);
+  }
+}
+
+PonderingSystem::CollisionResult PonderingSystem::moveBody(
+  id_type entity,
+  vec2d newPos)
+{
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  CollisionResult result;
+
+  if (ponderable.collidable)
+  {
+    result = detectCollisions(entity, newPos);
+  } else {
+    result.pos = newPos;
+  }
+
+  if (!ponderable.frozen)
+  {
+    auto& transformable = game_.getEntityManager().
+      getComponent<TransformableComponent>(entity);
+
+    vec2d delta = result.pos - transformable.pos;
+
+    // Move.
+    transformable.pos = result.pos;
+
+    // Stop if the entity hit a wall.
+    if (result.blockedHoriz)
+    {
+      ponderable.vel.x() = 0.0;
+    }
+
+    if (result.blockedVert)
+    {
+      ponderable.vel.y() = 0.0;
+    }
+
+    // Move ferry passengers by the appropriate amount.
+    auto passengers = ponderable.passengers;
+
+    for (id_type passenger : passengers)
+    {
+      auto& passTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(passenger);
+
+      moveBody(passenger, passTrans.pos + delta);
+    }
+
+    // Move to an adjacent map, if necessary
+    if (result.adjacentlyWarping)
+    {
+      vec2d warpPos = result.pos;
+
+      switch (result.adjWarpDir)
+      {
+        case Direction::left:
+        {
+          warpPos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
+
+          break;
+        }
+
+        case Direction::right:
+        {
+          warpPos.x() = -WALL_GAP;
+
+          break;
+        }
+
+        case Direction::up:
+        {
+          warpPos.y() = MAP_HEIGHT * TILE_HEIGHT - transformable.size.h();
+
+          break;
+        }
+
+        case Direction::down:
+        {
+          warpPos.y() = -WALL_GAP;
+
+          break;
+        }
+      }
+
+      game_.getSystemManager().getSystem<PlayingSystem>().
+        changeMap(
+          entity,
+          result.adjWarpMapId,
+          warpPos);
+    }
+  }
+
+  return result;
+}
+
+namespace CollisionParams {
+
+  template <typename HorizVert>
+  class Desc : public HorizVert {
+  public:
+
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis >= entityAxis);
+    }
+
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis > entityAxis);
+    }
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisLower(pos);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisUpper(pos, size);
+    }
+
+    inline static bool Closer(double left, double right)
+    {
+      return right < left;
+    }
+  };
+
+  template <typename HorizVert>
+  class Asc : public HorizVert {
+  public:
+
+    inline static bool AtLeastInAxisSweep(
+      double boundaryAxis,
+      double entityAxis)
+    {
+      return (boundaryAxis <= entityAxis);
+    }
+
+    inline static bool IsPastAxis(
+      double colliderAxis,
+      double entityAxis)
+    {
+      return (colliderAxis < entityAxis);
+    }
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisUpper(pos, size);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return HorizVert::AxisLower(pos);
+    }
+
+    inline static bool Closer(double left, double right)
+    {
+      return left < right;
+    }
+  };
+
+  template <size_t Axis, size_t NonAxis>
+  class HorizVert {
+  public:
+
+    inline static double AxisLower(const vec2d& pos)
+    {
+      return pos.coords[Axis];
+    }
+
+    inline static double AxisUpper(const vec2d& pos, const vec2i& size)
+    {
+      return pos.coords[Axis] + size.coords[Axis];
+    }
+
+    inline static double NonAxisLower(const vec2d& pos)
+    {
+      return pos.coords[NonAxis];
+    }
+
+    inline static double NonAxisUpper(const vec2d& pos, const vec2i& size)
+    {
+      return pos.coords[NonAxis] + size.coords[NonAxis];
+    }
+
+  };
+
+  using Horizontal = HorizVert<0, 1>;
+  using Vertical = HorizVert<1, 0>;
+
+  template <Direction dir, typename AscDesc>
+  class DetectCollisions : public AscDesc {
+  public:
+
+    static const Direction Dir = dir;
+
+    inline static double EntityAxis(const vec2d& pos, const vec2i& size)
+    {
+      return AscDesc::EntityAxis(pos, size);
+    }
+
+    inline static double ObjectAxis(const vec2d& pos, const vec2i& size)
+    {
+      return AscDesc::ObjectAxis(pos, size);
+    }
+
+    inline static double EntityAxis(const TransformableComponent& transformable)
+    {
+      return AscDesc::EntityAxis(transformable.pos, transformable.size);
+    }
+
+    inline static double ObjectAxis(const TransformableComponent& transformable)
+    {
+      return AscDesc::ObjectAxis(transformable.pos, transformable.size);
+    }
+  };
+
+  class Left : public DetectCollisions<Direction::left, Desc<Horizontal>> {
+  public:
+
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.leftBoundaries;
+    }
+  };
+
+  class Right : public DetectCollisions<Direction::right, Asc<Horizontal>> {
+  public:
+
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.rightBoundaries;
+    }
+  };
+
+  class Up : public DetectCollisions<Direction::up, Desc<Vertical>> {
+  public:
+
+    inline static const MappableComponent::desc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.upBoundaries;
+    }
+  };
+
+  class Down : public DetectCollisions<Direction::down, Asc<Vertical>> {
+  public:
+
+    inline static const MappableComponent::asc_boundaries_type& MapBoundaries(
+      const MappableComponent& mappable)
+    {
+      return mappable.downBoundaries;
+    }
+  };
+};
+
+PonderingSystem::CollisionResult PonderingSystem::detectCollisions(
+  id_type entity,
+  vec2d newPos)
+{
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  CollisionResult result;
+  result.pos.x() = newPos.x();
+  result.pos.y() = transformable.pos.y();
+
+  // Find horizontal collisions.
+  if (result.pos.x() < transformable.pos.x())
+  {
+    detectCollisionsInDirection<CollisionParams::Left>(entity, result);
+  } else if (result.pos.x() > transformable.pos.x())
+  {
+    detectCollisionsInDirection<CollisionParams::Right>(entity, result);
+  }
+
+  // Find vertical collisions
+  if (!result.stopProcessing)
+  {
+    result.pos.y() = newPos.y();
+    result.touchedWall = false;
+
+    if (result.pos.y() < transformable.pos.y())
+    {
+      detectCollisionsInDirection<CollisionParams::Up>(entity, result);
+    } else if (result.pos.y() > transformable.pos.y())
+    {
+      detectCollisionsInDirection<CollisionParams::Down>(entity, result);
+    }
+  }
+
+  return result;
+}
+
+template <typename Param>
+void PonderingSystem::detectCollisionsInDirection(
+  id_type entity,
+  CollisionResult& result)
+{
+  // Get map data.
+  id_type mapEntity =
+    game_.getSystemManager().getSystem<RealizingSystem>().getActiveMap();
+
+  auto& mappable = game_.getEntityManager().
+    getComponent<MappableComponent>(mapEntity);
+
+  // Get old location.
+  auto& transform = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  auto& ponderable = game_.getEntityManager().
+    getComponent<PonderableComponent>(entity);
+
+  bool boundaryCollision = false;
+
+  auto boundaries = Param::MapBoundaries(mappable);
+  auto it = boundaries.lower_bound(Param::EntityAxis(transform));
+
+  // Find the axis distance of the closest environmental boundary.
+  for (;
+      (it != std::end(boundaries)) &&
+        Param::AtLeastInAxisSweep(
+          it->first,
+          Param::EntityAxis(result.pos, transform.size));
+      it++)
+  {
+    // Check that the boundary is in range for the other axis.
+    if ((Param::NonAxisUpper(result.pos, transform.size) > it->second.lower) &&
+        (Param::NonAxisLower(result.pos) < it->second.upper))
+    {
+      // We have a collision!
+      boundaryCollision = true;
+
+      break;
+    }
+  }
+
+  // Find the results of pretending to move the entity's passengers, if there
+  // are any.
+  vec2d delta = result.pos - transform.pos;
+  std::map<id_type, CollisionResult> passResults;
+
+  for (id_type passenger : ponderable.passengers)
+  {
+    auto& passPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(passenger);
+
+    if (passPonder.ferrySide == Param::Dir)
+    {
+      auto& passTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(passenger);
+
+      passResults[passenger] =
+        detectCollisions(passenger, passTrans.pos + delta);
+    }
+  }
+
+  // Find a list of potential colliders, sorted so that the closest is
+  // first.
+  std::vector<id_type> colliders;
+
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    PonderableComponent,
+    TransformableComponent>();
+
+  for (id_type collider : entities)
+  {
+    // Can't collide with self.
+    if (collider == entity)
+    {
+      continue;
+    }
+
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
+
+    // Only check objects that are active and collidable.
+    if (!colliderPonder.active || !colliderPonder.collidable)
+    {
+      continue;
+    }
+
+    // If the collider is a passenger of the entity, pretend that it has already
+    // moved.
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
+
+    vec2d colliderPos = colliderTrans.pos;
+    vec2i colliderSize = colliderTrans.size;
+
+    if (passResults.count(collider))
+    {
+      colliderPos = passResults[collider].pos;
+    }
+
+    // Check if the entity would move into the potential collider,
+    if (Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(result.pos, transform.size)) &&
+        // that it wasn't already colliding,
+        !Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(transform)) &&
+        // that the position on the non-axis is in range,
+        (Param::NonAxisUpper(colliderPos, colliderSize) >
+          Param::NonAxisLower(result.pos)) &&
+        (Param::NonAxisLower(colliderPos) <
+          Param::NonAxisUpper(result.pos, transform.size)) &&
+        // and that the collider is not farther away than the environmental
+        // boundary.
+        (!boundaryCollision ||
+          Param::AtLeastInAxisSweep(
+            Param::ObjectAxis(colliderPos, colliderSize),
+            it->first)))
+    {
+      colliders.push_back(collider);
+    }
+  }
+
+  // Sort the potential colliders such that the closest to the axis of movement
+  // is first. When sorting, treat passengers of the entity as having already
+  // moved.
+  std::sort(
+    std::begin(colliders),
+    std::end(colliders),
+    [&] (id_type left, id_type right) {
+      auto& leftTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(left);
+
+      vec2d leftPos = leftTrans.pos;
+
+      if (passResults.count(left))
+      {
+        leftPos = passResults[left].pos;
+      }
+
+      auto& rightTrans = game_.getEntityManager().
+        getComponent<TransformableComponent>(right);
+
+      vec2d rightPos = rightTrans.pos;
+
+      if (passResults.count(right))
+      {
+        rightPos = passResults[right].pos;
+      }
+
+      return Param::Closer(
+        Param::ObjectAxis(leftPos, leftTrans.size),
+        Param::ObjectAxis(rightPos, rightTrans.size));
+    });
+
+  for (id_type collider : colliders)
+  {
+    auto& colliderTrans = game_.getEntityManager().
+      getComponent<TransformableComponent>(collider);
+
+    // If the collider is a passenger of the entity, pretend that it has already
+    // moved.
+    vec2d colliderPos = colliderTrans.pos;
+    vec2i colliderSize = colliderTrans.size;
+
+    if (passResults.count(collider))
+    {
+      colliderPos = passResults[collider].pos;
+    }
+
+    // Check if the entity would still move into the potential collider.
+    if (!Param::IsPastAxis(
+          Param::ObjectAxis(colliderPos, colliderSize),
+          Param::EntityAxis(result.pos, transform.size)))
+    {
+      break;
+    }
+
+    // TODO: Check if the entity is moving into one of its passengers.
+    auto& colliderPonder = game_.getEntityManager().
+      getComponent<PonderableComponent>(collider);
+
+    processCollision(
+      entity,
+      collider,
+      Param::Dir,
+      colliderPonder.colliderType,
+      Param::ObjectAxis(colliderPos, colliderSize),
+      Param::NonAxisLower(colliderPos),
+      Param::NonAxisUpper(colliderPos, colliderSize),
+      result);
+
+    if (result.stopProcessing)
+    {
+      break;
+    }
+  }
+
+  // If movement hasn't been stopped by an intermediary object, and
+  // collision checking hasn't been stopped, process the environmental
+  // boundaries closest to the entity.
+  if (!result.stopProcessing && !result.touchedWall && boundaryCollision)
+  {
+    double boundaryAxis = it->first;
+
+    for (;
+        (it != std::end(boundaries)) &&
+          (it->first == boundaryAxis);
+        it++)
+    {
+      if ((Param::NonAxisLower(result.pos) < it->second.upper) &&
+          (Param::NonAxisUpper(result.pos, transform.size) > it->second.lower))
+      {
+        processCollision(
+          entity,
+          mapEntity,
+          Param::Dir,
+          it->second.type,
+          it->first,
+          it->second.lower,
+          it->second.upper,
+          result);
+
+        if (result.stopProcessing)
+        {
+          break;
+        }
+      }
+    }
+  }
+}
+
+void PonderingSystem::processCollision(
+  id_type entity,
+  id_type collider,
+  Direction dir,
+  PonderableComponent::Collision type,
+  double axis,
+  double lower,
+  double upper,
+  CollisionResult& result)
+{
+  auto& transformable = game_.getEntityManager().
+    getComponent<TransformableComponent>(entity);
+
+  switch (type)
+  {
+    case PonderableComponent::Collision::wall:
+    {
+      result.touchedWall = true;
+
+      break;
+    }
+
+    case PonderableComponent::Collision::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 {
+          result.touchedWall = true;
+        }
+      } else {
+        result.touchedWall = true;
+      }
+
+      break;
+    }
+
+    case PonderableComponent::Collision::adjacency:
+    {
+      auto& mappable = game_.getEntityManager().
+        getComponent<MappableComponent>(collider);
+
+      auto& adj = [&] () -> const MappableComponent::Adjacent& {
+          switch (dir)
+          {
+            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.type)
+      {
+        case MappableComponent::Adjacent::Type::wall:
+        {
+          result.touchedWall = true;
+
+          break;
+        }
+
+        case MappableComponent::Adjacent::Type::wrap:
+        {
+          switch (dir)
+          {
+            case Direction::left:
+            {
+              result.pos.x() = GAME_WIDTH + WALL_GAP - transformable.size.w();
+
+              break;
+            }
+
+            case Direction::right:
+            {
+              result.pos.x() = -WALL_GAP;
+
+              break;
+            }
+
+            case Direction::up:
+            {
+              result.pos.y() =
+                MAP_HEIGHT * TILE_HEIGHT + WALL_GAP - transformable.pos.h();
+
+              break;
+            }
+
+            case Direction::down:
+            {
+              result.pos.y() = -WALL_GAP;
+
+              break;
+            }
+          }
+        }
+
+        case MappableComponent::Adjacent::Type::warp:
+        {
+          if (game_.getEntityManager().
+            hasComponent<PlayableComponent>(entity))
+          {
+            result.adjacentlyWarping = true;
+            result.adjWarpDir = dir;
+            result.adjWarpMapId = adj.mapId;
+          }
+
+          break;
+        }
+
+        case MappableComponent::Adjacent::Type::reverse:
+        {
+          // TODO: not yet implemented.
+
+          break;
+        }
+      }
+
+      break;
+    }
+
+    case PonderableComponent::Collision::danger:
+    {
+      if (game_.getEntityManager().
+        hasComponent<PlayableComponent>(entity))
+      {
+        game_.getSystemManager().getSystem<PlayingSystem>().die(entity);
+
+        result.adjacentlyWarping = false;
+      }
+
+      result.stopProcessing = true;
+
+      break;
+    }
+
+    case PonderableComponent::Collision::event:
+    {
+      if (game_.getEntityManager().
+        hasComponent<PlayableComponent>(entity))
+      {
+        game_.getSystemManager().getSystem<ScriptingSystem>().
+          onTouch(collider, entity);
+      }
+
+      break;
+    }
+
+    default:
+    {
+      // Not yet implemented.
+
+      break;
+    }
+  }
+
+  if (!result.stopProcessing && result.touchedWall)
+  {
+    switch (dir)
+    {
+      case Direction::left:
+      {
+        result.pos.x() = axis;
+        result.blockedHoriz = true;
+
+        break;
+      }
+
+      case Direction::right:
+      {
+        result.pos.x() = axis - transformable.size.w();
+        result.blockedHoriz = true;
+
+        break;
+      }
+
+      case Direction::up:
+      {
+        result.pos.y() = axis;
+        result.blockedVert = true;
+
+        break;
+      }
+
+      case Direction::down:
+      {
+        result.pos.y() = axis - transformable.size.h();
+        result.blockedVert = true;
+        result.groundEntity = collider;
+        result.grounded = true;
+
+        break;
+      }
+    }
+  }
+}
@@ -0,0 +1,81 @@
+#ifndef PONDERING_H_F2530E0E
+#define PONDERING_H_F2530E0E
+
+#include "system.h"
+#include "components/ponderable.h"
+#include "direction.h"
+#include "vector.h"
+
+class PonderingSystem : public System {
+public:
+
+  PonderingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void initializeBody(id_type entity, PonderableComponent::Type type);
+
+  /**
+   * Initializes a ponderable map object from its prototype data.
+   *
+   * @requires entity is ponderable
+   * @requires entity is a map object
+   */
+  void initPrototype(id_type prototype);
+
+  /**
+   * Unferries an entity if it is a passenger of another entity. Use before
+   * moving a ponderable entity outside the PonderingSystem.
+   *
+   * @requires entity is ponderable
+   */
+  void unferry(id_type entity);
+
+private:
+
+  struct CollisionResult
+  {
+    vec2d pos;
+    bool stopProcessing = false;
+    bool touchedWall = false;
+    bool blockedHoriz = false;
+    bool blockedVert = false;
+    bool adjacentlyWarping = false;
+    Direction adjWarpDir;
+    size_t adjWarpMapId;
+    bool grounded = false;
+    id_type groundEntity;
+  };
+
+  void tickBody(
+    id_type entity,
+    double dt);
+
+  CollisionResult moveBody(
+    id_type entity,
+    vec2d newPos);
+
+  CollisionResult detectCollisions(
+    id_type entity,
+    vec2d newPos);
+
+  template <typename Param>
+  void detectCollisionsInDirection(
+    id_type entity,
+    CollisionResult& result);
+
+  void processCollision(
+    id_type entity,
+    id_type collider,
+    Direction dir,
+    PonderableComponent::Collision type,
+    double axis,
+    double lower,
+    double upper,
+    CollisionResult& result);
+
+};
+
+#endif /* end of include guard: PONDERING_H_F2530E0E */
@@ -0,0 +1,438 @@
+#include "realizing.h"
+#include <stdexcept>
+#include <libxml/parser.h>
+#include <cstring>
+#include <map>
+#include "game.h"
+#include "consts.h"
+#include "animation.h"
+#include "components/mappable.h"
+#include "components/animatable.h"
+#include "components/playable.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/prototypable.h"
+#include "components/automatable.h"
+#include "systems/mapping.h"
+#include "systems/animating.h"
+#include "systems/pondering.h"
+#include "systems/scripting.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 constructor throws an exception.
+RealizingSystem::RealizingSystem(
+  Game& game,
+  std::string worldFile,
+  std::string prototypeFile) :
+    System(game),
+    worldFile_(std::move(worldFile)),
+    prototypeFile_(std::move(prototypeFile))
+{
+  auto& mapping = game_.getSystemManager().getSystem<MappingSystem>();
+
+  xmlChar* key = nullptr;
+
+  // Create a mapping between prototype names and the XML trees defining them.
+  xmlDocPtr protoXml = xmlParseFile(prototypeFile_.c_str());
+  if (protoXml == nullptr)
+  {
+    throw std::invalid_argument("Cannot find prototypes file");
+  }
+
+  xmlNodePtr protoTop = xmlDocGetRootElement(protoXml);
+  if (protoTop == nullptr)
+  {
+    throw std::invalid_argument("Error parsing prototypes file");
+  }
+
+  if (xmlStrcmp(protoTop->name, reinterpret_cast<const xmlChar*>("entities")))
+  {
+    throw std::invalid_argument("Error parsing prototypes file");
+  }
+
+  std::map<std::string, xmlNodePtr> prototypes;
+
+  for (xmlNodePtr node = protoTop->xmlChildrenNode;
+       node != nullptr;
+       node = node->next)
+  {
+    if (!xmlStrcmp(node->name, reinterpret_cast<const xmlChar*>("entity")))
+    {
+      key = getProp(node, "id");
+      std::string prototypeId = reinterpret_cast<char*>(key);
+      xmlFree(key);
+
+      prototypes[prototypeId] = node;
+    }
+  }
+
+  // Create entities from the world definition.
+  xmlDocPtr doc = xmlParseFile(worldFile_.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");
+  }
+
+  key = getProp(top, "startx");
+  startingPos_.x() = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "starty");
+  startingPos_.y() = atoi(reinterpret_cast<char*>(key));
+  xmlFree(key);
+
+  key = getProp(top, "startmap");
+  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*>("entity")))
+        {
+          id_type mapObject = game_.getEntityManager().emplaceEntity();
+
+          key = getProp(mapNode, "type");
+          std::string prototypeId = reinterpret_cast<char*>(key);
+          xmlFree(key);
+
+          xmlNodePtr prototypeNode = prototypes[prototypeId];
+
+          // Set the coordinates from the object definition.
+          auto& transformable = game_.getEntityManager().
+            emplaceComponent<TransformableComponent>(mapObject);
+
+          key = getProp(mapNode, "x");
+          transformable.origPos.x() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(mapNode, "y");
+          transformable.origPos.y() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          // Set the sprite and size using the prototype definition.
+          key = getProp(prototypeNode, "sprite");
+          std::string spritePath = reinterpret_cast<char*>(key);
+          xmlFree(key);
+
+          key = getProp(prototypeNode, "width");
+          transformable.origSize.w() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          key = getProp(prototypeNode, "height");
+          transformable.origSize.h() = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          AnimationSet objectAnim(
+            spritePath.c_str(),
+            transformable.origSize.w(),
+            transformable.origSize.h(),
+            1);
+
+          objectAnim.emplaceAnimation("static", 0, 1, 1);
+
+          auto& animatable = game_.getEntityManager().
+            emplaceComponent<AnimatableComponent>(
+              mapObject,
+              std::move(objectAnim));
+
+          animatable.origAnimation = "static";
+
+          // Create a physics body.
+          game_.getSystemManager().getSystem<PonderingSystem>().
+            initializeBody(mapObject, PonderableComponent::Type::vacuumed);
+
+
+
+
+
+          auto& prototypable = game_.getEntityManager().
+            emplaceComponent<PrototypableComponent>(mapObject);
+
+          prototypable.prototypeId = prototypeId;
+
+          key = getProp(mapNode, "index");
+          prototypable.mapObjectIndex = atoi(reinterpret_cast<char*>(key));
+          xmlFree(key);
+
+          if (prototypeId == "movplat")
+          {
+            auto& automatable = game_.getEntityManager().
+              emplaceComponent<AutomatableComponent>(mapObject);
+
+            automatable.table = prototypeId;
+          } else if (prototypeId == "checkpoint")
+          {
+            auto& ponderable = game_.getEntityManager().
+              getComponent<PonderableComponent>(mapObject);
+
+            ponderable.colliderType = PonderableComponent::Collision::event;
+          }
+
+          mappable.objects.push_back(mapObject);
+        } 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);
+
+      entityByMapId_[mappable.mapId] = map;
+    }
+  }
+
+  xmlFreeDoc(doc);
+  xmlFreeDoc(protoXml);
+
+  activateMap(entityByMapId_[startingMapId_]);
+}
+
+void RealizingSystem::loadMap(id_type mapEntity)
+{
+  deactivateMap();
+  activateMap(mapEntity);
+}
+
+void RealizingSystem::deactivateMap()
+{
+  id_type oldMap = 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.
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
+
+  for (id_type player : players)
+  {
+    auto& playable = game_.getEntityManager().
+      getComponent<PlayableComponent>(player);
+
+    if (playable.mapId == oldMap)
+    {
+      leaveActiveMap(player);
+    }
+  }
+}
+
+void RealizingSystem::activateMap(id_type mapEntity)
+{
+  auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
+  auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
+
+  std::set<id_type> players =
+    game_.getEntityManager().getEntitiesWithComponents<
+      PlayableComponent>();
+
+  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.pos = transformable.origPos;
+      transformable.size = transformable.origSize;
+    }
+
+    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;
+  }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    game_.getSystemManager().getSystem<ScriptingSystem>().startBehavior(entity);
+  }
+}
+
+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;
+  }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    game_.getSystemManager().getSystem<ScriptingSystem>().stopBehavior(entity);
+  }
+}
@@ -0,0 +1,86 @@
+#ifndef REALIZING_H_6853748C
+#define REALIZING_H_6853748C
+
+#include <string>
+#include <map>
+#include "system.h"
+#include "vector.h"
+
+class RealizingSystem : public System {
+public:
+
+  /**
+   * Constructs the realizing system.
+   *
+   * Note that this must be constructed after the following system:
+   * - Mapping
+   * - Animating
+   * - Pondering
+   * - Scripting
+   */
+  RealizingSystem(
+    Game& game,
+    std::string worldFile,
+    std::string prototypeFile);
+
+  id_type getActiveMap() const
+  {
+    return activeMap_;
+  }
+
+  int getStartingMapId() const
+  {
+    return startingMapId_;
+  }
+
+  vec2i getStartingPos() const
+  {
+    return startingPos_;
+  }
+
+  id_type getEntityByMapId(size_t mapId) const
+  {
+    return entityByMapId_.at(mapId);
+  }
+
+  id_type getActivePlayer() const
+  {
+    return activePlayer_;
+  }
+
+  void setActivePlayer(id_type entity)
+  {
+    activePlayer_ = entity;
+  }
+
+  /**
+   * 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);
+
+private:
+
+  void deactivateMap();
+
+  void activateMap(id_type mapEntity);
+
+  std::string worldFile_;
+  std::string prototypeFile_;
+  int startingMapId_;
+  vec2i startingPos_;
+  std::map<size_t, id_type> entityByMapId_;
+  id_type activeMap_;
+  id_type activePlayer_;
+};
+
+#endif /* end of include guard: REALIZING_H_6853748C */
@@ -0,0 +1,54 @@
+#include "scheduling.h"
+#include "game.h"
+#include "components/schedulable.h"
+#include "util.h"
+
+void SchedulingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    SchedulableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& schedulable = game_.getEntityManager().
+      getComponent<SchedulableComponent>(entity);
+
+    for (auto& action : schedulable.actions)
+    {
+      std::get<0>(action) -= dt;
+
+      if (std::get<0>(action) < 0)
+      {
+        std::get<1>(action)(entity);
+      }
+    }
+
+    erase_if(schedulable.actions,
+      [] (const SchedulableComponent::Action& action) {
+        return (std::get<0>(action) < 0);
+      });
+
+    if (schedulable.actions.empty())
+    {
+      game_.getEntityManager().removeComponent<SchedulableComponent>(entity);
+    }
+  }
+}
+
+void SchedulingSystem::schedule(
+  id_type entity,
+  double length,
+  std::function<void(id_type)> action)
+{
+  if (!game_.getEntityManager().hasComponent<SchedulableComponent>(entity))
+  {
+    game_.getEntityManager().emplaceComponent<SchedulableComponent>(entity);
+  }
+
+  auto& schedulable = game_.getEntityManager().
+    getComponent<SchedulableComponent>(entity);
+
+  schedulable.actions.emplace_back(
+    length,
+    std::move(action));
+}
@@ -0,0 +1,22 @@
+#ifndef SCHEDULING_H_7B02E3E3
+#define SCHEDULING_H_7B02E3E3
+
+#include "system.h"
+
+class SchedulingSystem : public System {
+public:
+
+  SchedulingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void schedule(
+    id_type entity,
+    double length,
+    std::function<void(id_type)> action);
+
+};
+
+#endif /* end of include guard: SCHEDULING_H_7B02E3E3 */
@@ -0,0 +1,257 @@
+#include "scripting.h"
+#include "game.h"
+#include "components/runnable.h"
+#include "components/ponderable.h"
+#include "components/transformable.h"
+#include "components/playable.h"
+#include "components/mappable.h"
+#include "components/prototypable.h"
+#include "components/automatable.h"
+#include "systems/realizing.h"
+#include "vector.h"
+#include "muxer.h"
+
+struct script_entity {
+  using id_type = EntityManager::id_type;
+
+  id_type id;
+
+  script_entity(id_type id) : id(id)
+  {
+  }
+};
+
+ScriptingSystem::ScriptingSystem(Game& game) : System(game)
+{
+  id_type entity = game_.getEntityManager().emplaceEntity();
+
+  engine_.open_libraries(sol::lib::base, sol::lib::coroutine);
+
+  engine_.new_usertype<vec2d>(
+    "vec2d",
+    sol::constructors<vec2d(), vec2d(double, double)>(),
+    "x", sol::property(
+      [] (vec2d& v) -> double { return v.x(); },
+      [] (vec2d& v, double x) { v.x() = x; }),
+    "y", sol::property(
+      [] (vec2d& v) -> double { return v.y(); },
+      [] (vec2d& v, double y) { v.y() = y; }));
+
+  engine_.new_usertype<vec2i>(
+    "vec2i",
+    sol::constructors<vec2i(), vec2i(int, int)>(),
+    "x", [] (vec2i& v) -> int& { return v.x(); },
+    "y", [] (vec2i& v) -> int& { return v.y(); });
+
+  engine_.new_usertype<script_entity>(
+    "entity",
+    sol::constructors<script_entity(id_type)>(),
+    "id", &script_entity::id,
+    "transformable",
+      [&] (script_entity& entity) -> TransformableComponent& {
+        return game_.getEntityManager().
+          getComponent<TransformableComponent>(entity.id);
+      },
+    "ponderable",
+      [&] (script_entity& entity) -> PonderableComponent& {
+        return game_.getEntityManager().
+          getComponent<PonderableComponent>(entity.id);
+      },
+    "mappable",
+      [&] (script_entity& entity) -> MappableComponent& {
+        return game_.getEntityManager().
+          getComponent<MappableComponent>(entity.id);
+      },
+    "playable",
+      [&] (script_entity& entity) -> PlayableComponent& {
+        return game_.getEntityManager().
+          getComponent<PlayableComponent>(entity.id);
+      },
+    "prototypable",
+      [&] (script_entity& entity) -> PrototypableComponent& {
+        return game_.getEntityManager().
+          getComponent<PrototypableComponent>(entity.id);
+      });
+
+  engine_.new_usertype<TransformableComponent>(
+    "transformable",
+    "pos", &TransformableComponent::pos);
+
+  engine_.new_usertype<PonderableComponent>(
+    "ponderable",
+    "vel", &PonderableComponent::vel,
+    "accel", &PonderableComponent::accel);
+
+  engine_.new_usertype<MappableComponent>(
+    "mappable",
+    "mapId", &MappableComponent::mapId);
+
+  engine_.new_usertype<PlayableComponent>(
+    "playable",
+    "checkpointPos", &PlayableComponent::checkpointPos,
+    "checkpointMapId", &PlayableComponent::checkpointMapId,
+    "checkpointMapObject", &PlayableComponent::checkpointMapObject,
+    "checkpointMapObjectIndex", &PlayableComponent::checkpointMapObjectIndex);
+
+  engine_.new_usertype<PrototypableComponent>(
+    "prototypable",
+    "mapObjectIndex", &PrototypableComponent::mapObjectIndex,
+    "prototypeId", &PrototypableComponent::prototypeId);
+
+  engine_.new_usertype<RealizingSystem>(
+    "realizing",
+    "activeMap", sol::property(&RealizingSystem::getActiveMap));
+
+  engine_.set_function(
+    "realizing",
+    [&] () -> RealizingSystem& {
+      return game_.getSystemManager().getSystem<RealizingSystem>();
+    });
+
+  engine_.set_function("playSound", playSound);
+
+  engine_.script_file("scripts/common.lua");
+  engine_.script_file("scripts/movplat.lua");
+  engine_.script_file("scripts/checkpoint.lua");
+}
+
+void ScriptingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    RunnableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& runnable = game_.getEntityManager().
+      getComponent<RunnableComponent>(entity);
+
+    if (*runnable.callable)
+    {
+      auto result = (*runnable.callable)(dt);
+      if (!result.valid())
+      {
+        sol::error e = result;
+        throw std::runtime_error(e.what());
+      }
+    }
+
+    if (!*runnable.callable)
+    {
+      killScript(entity);
+    }
+  }
+}
+
+void ScriptingSystem::killScript(id_type entity)
+{
+  auto& runnable = game_.getEntityManager().
+    getComponent<RunnableComponent>(entity);
+
+  if (runnable.behavior)
+  {
+    auto& automatable = game_.getEntityManager().
+      getComponent<AutomatableComponent>(runnable.actor);
+
+    automatable.running = false;
+  }
+
+  game_.getEntityManager().deleteEntity(entity);
+}
+
+template <typename... Args>
+sol::optional<EntityManager::id_type> ScriptingSystem::runScript(
+  std::string table,
+  std::string event,
+  id_type entity,
+  Args&&... args)
+{
+  id_type script = game_.getEntityManager().emplaceEntity();
+
+  auto& runnable = game_.getEntityManager().
+    emplaceComponent<RunnableComponent>(script);
+
+  runnable.runner =
+    std::unique_ptr<sol::thread>(
+      new sol::thread(
+        sol::thread::create(
+          engine_.lua_state())));
+
+  runnable.callable =
+    std::unique_ptr<sol::coroutine>(
+      new sol::coroutine(
+        runnable.runner->state().
+          traverse_get<sol::function>(
+            table,
+            event)));
+
+  if (!*runnable.callable)
+  {
+    throw std::runtime_error("Error running script");
+  }
+
+  auto result = (*runnable.callable)(
+    script_entity(entity),
+    std::forward<Args>(args)...);
+
+  if (!result.valid())
+  {
+    sol::error e = result;
+    throw std::runtime_error(e.what());
+  }
+
+  if (*runnable.callable)
+  {
+    return { script };
+  } else {
+    killScript(script);
+
+    return {};
+  }
+}
+
+void ScriptingSystem::startBehavior(id_type entity)
+{
+  auto& automatable = game_.getEntityManager().
+    getComponent<AutomatableComponent>(entity);
+
+  sol::optional<id_type> script =
+    runScript(
+      automatable.table,
+      "Behavior",
+      entity);
+
+  if (script)
+  {
+    automatable.script = *script;
+    automatable.running = true;
+
+    auto& runnable = game_.getEntityManager().
+      getComponent<RunnableComponent>(automatable.script);
+
+    runnable.behavior = true;
+    runnable.actor = entity;
+  }
+}
+
+void ScriptingSystem::stopBehavior(id_type entity)
+{
+  auto& automatable = game_.getEntityManager().
+    getComponent<AutomatableComponent>(entity);
+
+  if (automatable.running)
+  {
+    killScript(automatable.script);
+  }
+}
+
+void ScriptingSystem::onTouch(id_type entity, id_type player)
+{
+  auto& prototypable = game_.getEntityManager().
+    getComponent<PrototypableComponent>(entity);
+
+  runScript(
+    prototypable.prototypeId,
+    "OnTouch",
+    entity,
+    script_entity(player));
+}
@@ -0,0 +1,34 @@
+#ifndef AUTOMATING_H_E6E5D76E
+#define AUTOMATING_H_E6E5D76E
+
+#include "system.h"
+#include <sol.hpp>
+
+class ScriptingSystem : public System {
+public:
+
+  ScriptingSystem(Game& game);
+
+  void tick(double dt);
+
+  void killScript(id_type entity);
+
+  void startBehavior(id_type entity);
+
+  void stopBehavior(id_type entity);
+
+  void onTouch(id_type entity, id_type player);
+
+private:
+
+  template <typename... Args>
+  sol::optional<id_type> runScript(
+    std::string table,
+    std::string event,
+    id_type entity,
+    Args&&... args);
+
+  sol::state engine_;
+};
+
+#endif /* end of include guard: AUTOMATING_H_E6E5D76E */