13 files changed, 346 insertions, 183 deletions

@@ -1,25 +0,0 @@
-#ifndef AUTOMATABLE_H_3D519131
-#define AUTOMATABLE_H_3D519131
-
-#include "component.h"
-#include <sol.hpp>
-#include <memory>
-
-class AutomatableComponent : public Component {
-public:
-
-  std::unique_ptr<sol::thread> runner;
-  std::unique_ptr<sol::coroutine> behavior;
-
-  sol::environment origBehavior;
-
-  /**
-   * If this flag is disabled, the entity will be ignored by the automating
-   * system.
-   *
-   * @managed_by RealizingSystem
-   */
-  bool active = false;
-};
-
-#endif /* end of include guard: AUTOMATABLE_H_3D519131 */
@@ -27,6 +27,9 @@ public:
   size_t checkpointMapId;
   vec2d checkpointPos;
 
+  bool checkpointMapObject = false;
+  size_t checkpointMapObjectIndex;
+
 };
 
 #endif /* end of include guard: PLAYABLE_H_DDC566C3 */
@@ -34,7 +34,8 @@ public:
     platform,
     adjacency,
     warp,
-    danger
+    danger,
+    event
   };
 
   /**
@@ -0,0 +1,22 @@
+#ifndef PROTOTYPABLE_H_817F2205
+#define PROTOTYPABLE_H_817F2205
+
+#include "component.h"
+#include "entity_manager.h"
+
+class PrototypableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  size_t mapObjectIndex;
+
+  std::string prototypeId;
+
+  bool hasBehavior = false;
+  bool runningBehavior = false;
+
+  id_type behaviorScript;
+};
+
+#endif /* end of include guard: PROTOTYPABLE_H_817F2205 */
@@ -4,7 +4,6 @@
 #include "component.h"
 #include <set>
 #include <map>
-#include <sol.hpp>
 #include "entity_manager.h"
 #include "vector.h"
 
@@ -70,8 +69,6 @@ public:
    * The entity ID of the currently active player.
    */
   id_type activePlayer;
-
-  sol::state scriptEngine;
 };
 
 #endif /* end of include guard: REALIZABLE_H_36D8D71E */
@@ -0,0 +1,15 @@
+#ifndef AUTOMATABLE_H_3D519131
+#define AUTOMATABLE_H_3D519131
+
+#include "component.h"
+#include <sol.hpp>
+#include <memory>
+
+class RunnableComponent : public Component {
+public:
+
+  std::unique_ptr<sol::thread> runner;
+  std::unique_ptr<sol::coroutine> callable;
+};
+
+#endif /* end of include guard: AUTOMATABLE_H_3D519131 */
@@ -12,7 +12,7 @@
 #include "systems/playing.h"
 #include "systems/scheduling.h"
 #include "systems/realizing.h"
-#include "systems/automating.h"
+#include "systems/scripting.h"
 #include "animation.h"
 #include "consts.h"
 
@@ -36,7 +36,7 @@ Game::Game(std::mt19937& rng) : rng_(rng)
   systemManager_.emplaceSystem<PlayingSystem>(*this);
   systemManager_.emplaceSystem<SchedulingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
-  systemManager_.emplaceSystem<AutomatingSystem>(*this);
+  systemManager_.emplaceSystem<ScriptingSystem>(*this);
   systemManager_.emplaceSystem<OrientingSystem>(*this);
   systemManager_.emplaceSystem<PonderingSystem>(*this);
   systemManager_.emplaceSystem<MappingSystem>(*this);
@@ -1,106 +0,0 @@
-#include "automating.h"
-#include "game.h"
-#include "components/automatable.h"
-#include "components/ponderable.h"
-#include "components/realizable.h"
-#include "components/transformable.h"
-#include "systems/realizing.h"
-#include "vector.h"
-
-struct script_entity {
-  using id_type = EntityManager::id_type;
-
-  id_type id;
-
-  script_entity(id_type id) : id(id)
-  {
-  }
-};
-
-void AutomatingSystem::tick(double dt)
-{
-  auto entities = game_.getEntityManager().getEntitiesWithComponents<
-    AutomatableComponent>();
-
-  for (id_type entity : entities)
-  {
-    auto& automatable = game_.getEntityManager().
-      getComponent<AutomatableComponent>(entity);
-
-    if (!automatable.active)
-    {
-      continue;
-    }
-
-    auto result = (*automatable.behavior)(dt);
-    if (!result.valid())
-    {
-      sol::error e = result;
-      throw std::runtime_error(e.what());
-    }
-  }
-}
-
-void AutomatingSystem::initPrototype(id_type prototype)
-{
-  auto& automatable = game_.getEntityManager().
-    getComponent<AutomatableComponent>(prototype);
-
-  auto& realizable = game_.getEntityManager().
-    getComponent<RealizableComponent>(
-      game_.getSystemManager().getSystem<RealizingSystem>().getSingleton());
-  automatable.behavior.reset();
-  automatable.runner = std::unique_ptr<sol::thread>(new sol::thread(sol::thread::create(realizable.scriptEngine.lua_state())));
-  automatable.behavior = std::unique_ptr<sol::coroutine>(new sol::coroutine(automatable.runner->state()["run"]));
-
-  auto result = (*automatable.behavior)(script_entity(prototype));
-  if (!result.valid())
-  {
-    sol::error e = result;
-    throw std::runtime_error(e.what());
-  }
-}
-
-void AutomatingSystem::initScriptEngine(sol::state& scriptEngine)
-{
-  scriptEngine.open_libraries(sol::lib::base, sol::lib::coroutine);
-  scriptEngine.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; }));
-
-  scriptEngine.new_usertype<vec2i>(
-    "vec2i",
-    sol::constructors<vec2i(), vec2i(int, int)>(),
-    "x", [] (vec2i& v) -> int& { return v.x(); },
-    "y", [] (vec2i& v) -> int& { return v.y(); });
-
-  scriptEngine.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);
-      });
-
-  scriptEngine.new_usertype<TransformableComponent>(
-    "transformable",
-    "pos", &TransformableComponent::pos);
-
-  scriptEngine.new_usertype<PonderableComponent>(
-    "ponderable",
-    "vel", &PonderableComponent::vel,
-    "accel", &PonderableComponent::accel);
-}
@@ -1,22 +0,0 @@
-#ifndef AUTOMATING_H_E6E5D76E
-#define AUTOMATING_H_E6E5D76E
-
-#include "system.h"
-#include <sol.hpp>
-
-class AutomatingSystem : public System {
-public:
-
-  AutomatingSystem(Game& game) : System(game)
-  {
-  }
-
-  void tick(double dt);
-
-  void initPrototype(id_type prototype);
-
-  void initScriptEngine(sol::state& scriptEngine);
-
-};
-
-#endif /* end of include guard: AUTOMATING_H_E6E5D76E */
@@ -11,6 +11,7 @@
 #include "systems/orienting.h"
 #include "systems/playing.h"
 #include "systems/realizing.h"
+#include "systems/scripting.h"
 #include "consts.h"
 
 void PonderingSystem::tick(double dt)
@@ -857,6 +858,18 @@ void PonderingSystem::processCollision(
       break;
     }
 
+    case PonderableComponent::Collision::event:
+    {
+      if (game_.getEntityManager().
+        hasComponent<PlayableComponent>(entity))
+      {
+        game_.getSystemManager().getSystem<ScriptingSystem>().
+          onTouch(collider, entity);
+      }
+
+      break;
+    }
+
     default:
     {
       // Not yet implemented.
@@ -12,11 +12,11 @@
 #include "components/playable.h"
 #include "components/ponderable.h"
 #include "components/transformable.h"
-#include "components/automatable.h"
+#include "components/prototypable.h"
 #include "systems/mapping.h"
 #include "systems/animating.h"
 #include "systems/pondering.h"
-#include "systems/automating.h"
+#include "systems/scripting.h"
 
 inline xmlChar* getProp(xmlNodePtr node, const char* attr)
 {
@@ -40,9 +40,6 @@ EntityManager::id_type RealizingSystem::initSingleton(
   auto& realizable = game_.getEntityManager().
     emplaceComponent<RealizableComponent>(world);
 
-  game_.getSystemManager().getSystem<AutomatingSystem>().
-    initScriptEngine(realizable.scriptEngine);
-
   realizable.worldFile = worldFile;
   realizable.prototypeFile = prototypeFile;
 
@@ -216,14 +213,28 @@ EntityManager::id_type RealizingSystem::initSingleton(
           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);
-
+            prototypable.hasBehavior = true;
+          } else if (prototypeId == "checkpoint")
+          {
+            auto& ponderable = game_.getEntityManager().
+              getComponent<PonderableComponent>(mapObject);
 
-            realizable.scriptEngine.script_file(
-              "res/platform.lua");//,
+            ponderable.colliderType = PonderableComponent::Collision::event;
           }
 
           mappable.objects.push_back(mapObject);
@@ -319,7 +330,6 @@ void RealizingSystem::loadMap(id_type mapEntity)
 
   auto& animating = game_.getSystemManager().getSystem<AnimatingSystem>();
   auto& pondering = game_.getSystemManager().getSystem<PonderingSystem>();
-  auto& automating = game_.getSystemManager().getSystem<AutomatingSystem>();
 
   std::set<id_type> players =
     game_.getEntityManager().getEntitiesWithComponents<
@@ -380,11 +390,6 @@ void RealizingSystem::loadMap(id_type mapEntity)
       pondering.initPrototype(prototype);
     }
 
-    if (game_.getEntityManager().hasComponent<AutomatableComponent>(prototype))
-    {
-      automating.initPrototype(prototype);
-    }
-
     enterActiveMap(prototype);
   }
 
@@ -419,12 +424,19 @@ void RealizingSystem::enterActiveMap(id_type entity)
     ponderable.active = true;
   }
 
-  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  if (game_.getEntityManager().hasComponent<PrototypableComponent>(entity))
   {
-    auto& automatable = game_.getEntityManager().
-      getComponent<AutomatableComponent>(entity);
+    auto& prototypable = game_.getEntityManager().
+      getComponent<PrototypableComponent>(entity);
+
+    if (prototypable.hasBehavior)
+    {
+      auto& scripting = game_.getSystemManager().getSystem<ScriptingSystem>();
 
-    automatable.active = true;
+      prototypable.hasBehavior = true;
+      prototypable.runningBehavior = true;
+      prototypable.behaviorScript = scripting.runBehaviorScript(entity);
+    }
   }
 }
 
@@ -446,11 +458,17 @@ void RealizingSystem::leaveActiveMap(id_type entity)
     ponderable.active = false;
   }
 
-  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  if (game_.getEntityManager().hasComponent<PrototypableComponent>(entity))
   {
-    auto& automatable = game_.getEntityManager().
-      getComponent<AutomatableComponent>(entity);
+    auto& prototypable = game_.getEntityManager().
+      getComponent<PrototypableComponent>(entity);
 
-    automatable.active = false;
+    if (prototypable.runningBehavior)
+    {
+      auto& scripting = game_.getSystemManager().getSystem<ScriptingSystem>();
+      scripting.killScript(prototypable.behaviorScript);
+
+      prototypable.runningBehavior = false;
+    }
   }
 }
@@ -0,0 +1,219 @@
+#include "scripting.h"
+#include "game.h"
+#include "components/runnable.h"
+#include "components/ponderable.h"
+#include "components/realizable.h"
+#include "components/transformable.h"
+#include "components/playable.h"
+#include "components/mappable.h"
+#include "components/prototypable.h"
+#include "systems/realizing.h"
+#include "vector.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);
+      },
+    "realizable",
+      [&] (script_entity& entity) -> RealizableComponent& {
+        return game_.getEntityManager().
+          getComponent<RealizableComponent>(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<RealizableComponent>(
+    "realizable",
+    "activeMap", &RealizableComponent::activeMap);
+
+  engine.new_usertype<PrototypableComponent>(
+    "prototypable",
+    "mapObjectIndex", &PrototypableComponent::mapObjectIndex,
+    "prototypeId", &PrototypableComponent::prototypeId);
+
+  engine.new_usertype<RealizingSystem>(
+    "realizing",
+    "singleton",
+      [&] (RealizingSystem& realizing) -> script_entity {
+        return realizing.getSingleton();
+      });
+
+  engine.set_function(
+    "realizing",
+    [&] () {
+      return game_.getSystemManager().getSystem<RealizingSystem>();
+    });
+
+  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)
+    {
+      game_.getEntityManager().deleteEntity(entity);
+    }
+  }
+}
+
+void ScriptingSystem::killScript(id_type entity)
+{
+  if (game_.getEntityManager().hasComponent<RunnableComponent>(entity))
+  {
+    game_.getEntityManager().deleteEntity(entity);
+  }
+}
+
+template <typename... Args>
+EntityManager::id_type ScriptingSystem::runScript(
+  std::string event,
+  id_type entity,
+  Args&&... args)
+{
+  auto& prototypable = game_.getEntityManager().
+    getComponent<PrototypableComponent>(entity);
+
+  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>(
+            prototypable.prototypeId,
+            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());
+  }
+
+  return script;
+}
+
+EntityManager::id_type ScriptingSystem::runBehaviorScript(id_type entity)
+{
+  return runScript("Behavior", entity);
+}
+
+void ScriptingSystem::onTouch(id_type entity, id_type player)
+{
+  runScript(
+    "OnTouch",
+    entity,
+    script_entity(player));
+}
@@ -0,0 +1,28 @@
+#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);
+
+  id_type runBehaviorScript(id_type entity);
+
+  void onTouch(id_type entity, id_type player);
+
+private:
+
+  template <typename... Args>
+  id_type runScript(std::string event, id_type entity, Args&&... args);
+
+  sol::state engine;
+};
+
+#endif /* end of include guard: AUTOMATING_H_E6E5D76E */