1 files changed, 257 insertions, 0 deletions

@@ -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));
+}