6 files changed, 82 insertions, 267 deletions

@@ -2,87 +2,16 @@
 #define AUTOMATABLE_H_3D519131
 
 #include "component.h"
-#include <vector>
-#include <random>
-#include "vector.h"
+#include <sol.hpp>
+#include <memory>
 
 class AutomatableComponent : public Component {
 public:
 
-  /**
-   * Helper class that defines an automatable action.
-   */
-  class Action {
-  public:
-
-    /**
-     * The horizontal and vertical speed, in pixels/sec, that the entity should
-     * move at.
-     */
-    vec2d speed;
-
-    /**
-     * The duration of the action in seconds.
-     */
-    double dur;
-  };
-
-  /**
-   * Helper type that defines a behavior that an entity can exhibit, which is a
-   * list of actions that are stepped through in sequence.
-   */
-  using Behavior = std::vector<Action>;
-
-  /**
-   * A group of behaviors that the entity can exhibit, which are picked at
-   * random at the start of automation and whenever a behavior completes.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::vector<Behavior> behaviors;
-
-  /**
-   * A random distribution over the above behaviors.
-   *
-   * @managed_by RealizingSystem
-   */
-  std::discrete_distribution<size_t> behaviorDist;
-
-  /**
-   * A flag indicating whether a behavior is currently executing.
-   *
-   * @managed_by AutomatingSystem
-   */
-  bool behaviorRunning = false;
-
-  /**
-   * A flag indicating whether an action is currently executing.
-   *
-   * @managed_by AutomatingSystem
-   */
-  bool actionRunning = false;
-
-  /**
-   * The index of the currently executing behavior, if there is one.
-   *
-   * @managed_by AutomatingSystem
-   */
-  size_t currentBehavior;
+  std::unique_ptr<sol::thread> runner;
+  std::unique_ptr<sol::coroutine> behavior;
 
-  /**
-   * The index of the currently executing action, if there is one.
-   *
-   * @managed_by AutomatingSystem
-   */
-  size_t currentAction;
-
-  /**
-   * The amount of time remaining, in seconds, of the currently executing
-   * action.
-   *
-   * @managed_by AutomatingSystem
-   */
-  double remaining;
+  sol::environment origBehavior;
 
   /**
    * If this flag is disabled, the entity will be ignored by the automating
@@ -4,6 +4,7 @@
 #include "component.h"
 #include <set>
 #include <map>
+#include <sol.hpp>
 #include "entity_manager.h"
 #include "vector.h"
 
@@ -69,6 +70,8 @@ public:
    * The entity ID of the currently active player.
    */
   id_type activePlayer;
+
+  sol::state scriptEngine;
 };
 
 #endif /* end of include guard: REALIZABLE_H_36D8D71E */
@@ -2,13 +2,24 @@
 #include "game.h"
 #include "components/automatable.h"
 #include "components/ponderable.h"
-#include "systems/pondering.h"
+#include "components/realizable.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,
-    PonderableComponent>();
+    AutomatableComponent>();
 
   for (id_type entity : entities)
   {
@@ -20,43 +31,7 @@ void AutomatingSystem::tick(double dt)
       continue;
     }
 
-    if (automatable.behaviorRunning &&
-        (automatable.remaining <= 0.0))
-    {
-      automatable.currentAction++;
-      automatable.actionRunning = false;
-
-      if (automatable.currentAction ==
-            automatable.behaviors[automatable.currentBehavior].size())
-      {
-        automatable.behaviorRunning = false;
-      }
-    }
-
-    if (!automatable.behaviorRunning)
-    {
-      automatable.currentBehavior = automatable.behaviorDist(game_.getRng());
-      automatable.currentAction = 0;
-      automatable.behaviorRunning = true;
-    }
-
-    AutomatableComponent::Action& curAction =
-      automatable.behaviors
-        [automatable.currentBehavior]
-          [automatable.currentAction];
-
-    if (!automatable.actionRunning)
-    {
-      automatable.remaining = curAction.dur;
-      automatable.actionRunning = true;
-    }
-
-    auto& ponderable = game_.getEntityManager().
-      getComponent<PonderableComponent>(entity);
-
-    ponderable.vel = curAction.speed;
-
-    automatable.remaining -= dt;
+    (*automatable.behavior)(dt);
   }
 }
 
@@ -65,6 +40,46 @@ void AutomatingSystem::initPrototype(id_type prototype)
   auto& automatable = game_.getEntityManager().
     getComponent<AutomatableComponent>(prototype);
 
-  automatable.behaviorRunning = false;
-  automatable.actionRunning = false;
+  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"]));
+  (*automatable.behavior)(script_entity(prototype));
+}
+
+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,
+    "ponderable",
+      [&] (script_entity& entity) -> PonderableComponent& {
+        return game_.getEntityManager().
+          getComponent<PonderableComponent>(entity.id);
+      });
+
+  scriptEngine.new_usertype<PonderableComponent>(
+    "ponderable",
+    "vel", &PonderableComponent::vel,
+    "accel", &PonderableComponent::accel);
 }
@@ -2,6 +2,7 @@
 #define AUTOMATING_H_E6E5D76E
 
 #include "system.h"
+#include <sol.hpp>
 
 class AutomatingSystem : public System {
 public:
@@ -14,6 +15,8 @@ public:
 
   void initPrototype(id_type prototype);
 
+  void initScriptEngine(sol::state& scriptEngine);
+
 };
 
 #endif /* end of include guard: AUTOMATING_H_E6E5D76E */
@@ -29,92 +29,6 @@ inline xmlChar* getProp(xmlNodePtr node, const char* attr)
   return key;
 }
 
-void parseAI(
-  xmlNodePtr node,
-  std::vector<AutomatableComponent::Action>& behavior,
-  const std::map<std::string, int>& items)
-{
-  xmlChar* key = nullptr;
-
-  if (!xmlStrcmp(
-    node->name,
-    reinterpret_cast<const xmlChar*>("switch")))
-  {
-    key = getProp(node, "item");
-    std::string switchItem = reinterpret_cast<char*>(key);
-    xmlFree(key);
-
-    for (xmlNodePtr switchNode = node->xmlChildrenNode;
-         switchNode != nullptr;
-         switchNode = switchNode->next)
-    {
-      if (!xmlStrcmp(
-        switchNode->name,
-        reinterpret_cast<const xmlChar*>("case")))
-      {
-        key = getProp(switchNode, "value");
-        int caseValue = atoi(reinterpret_cast<char*>(key));
-        xmlFree(key);
-
-        if (items.at(switchItem) == caseValue)
-        {
-          for (xmlNodePtr caseNode = switchNode->xmlChildrenNode;
-               caseNode != nullptr;
-               caseNode = caseNode->next)
-          {
-            parseAI(
-              caseNode,
-              behavior,
-              items);
-          }
-        }
-      }
-    }
-  } else if (!xmlStrcmp(
-    node->name,
-    reinterpret_cast<const xmlChar*>("move")))
-  {
-    key = getProp(node, "direction");
-    std::string direction = reinterpret_cast<char*>(key);
-    xmlFree(key);
-
-    key = getProp(node, "length-var");
-    std::string lengthVar = reinterpret_cast<char*>(key);
-    xmlFree(key);
-
-    key = getProp(node, "speed-var");
-    std::string speedVar = reinterpret_cast<char*>(key);
-    xmlFree(key);
-
-    double length = items.at(lengthVar);
-    double speed = items.at(speedVar);
-
-    AutomatableComponent::Action action;
-
-    if (direction == "left")
-    {
-      action.speed.x() = -speed;
-      action.speed.y() = 0;
-    } else if (direction == "right")
-    {
-      action.speed.x() = speed;
-      action.speed.y() = 0;
-    } else if (direction == "up")
-    {
-      action.speed.x() = 0;
-      action.speed.y() = -speed;
-    } else if (direction == "down")
-    {
-      action.speed.x() = 0;
-      action.speed.y() = speed;
-    }
-
-    action.dur = length / speed;
-
-    behavior.push_back(std::move(action));
-  }
-}
-
 // TODO: neither the XML doc nor any of the emplaced entities are properly
 // destroyed if this method throws an exception.
 EntityManager::id_type RealizingSystem::initSingleton(
@@ -126,6 +40,9 @@ 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;
 
@@ -299,68 +216,14 @@ EntityManager::id_type RealizingSystem::initSingleton(
           game_.getSystemManager().getSystem<PonderingSystem>().
             initializeBody(mapObject, PonderableComponent::Type::vacuumed);
 
-          // Look for any object configuration.
-          std::map<std::string, int> items;
-
-          for (xmlNodePtr objectNode = mapNode->xmlChildrenNode;
-            objectNode != nullptr;
-            objectNode = objectNode->next)
+          if (prototypeId == "movplat")
           {
-            if (!xmlStrcmp(
-              objectNode->name,
-              reinterpret_cast<const xmlChar*>("item")))
-            {
-              key = getProp(objectNode, "id");
-              std::string itemName = reinterpret_cast<char*>(key);
-              xmlFree(key);
-
-              key = xmlNodeGetContent(objectNode);
-              int itemVal = atoi(reinterpret_cast<char*>(key));
-              xmlFree(key);
-
-              items[itemName] = itemVal;
-            }
-          }
+            auto& automatable = game_.getEntityManager().
+              emplaceComponent<AutomatableComponent>(mapObject);
 
-          // Add any AI behaviors.
-          std::vector<double> behaviorWeights;
 
-          for (xmlNodePtr protoSubNode = prototypeNode->xmlChildrenNode;
-            protoSubNode != nullptr;
-            protoSubNode = protoSubNode->next)
-          {
-            if (!xmlStrcmp(
-              protoSubNode->name,
-              reinterpret_cast<const xmlChar*>("ai")))
-            {
-              if (!game_.getEntityManager().
-                hasComponent<AutomatableComponent>(mapObject))
-              {
-                game_.getEntityManager().
-                  emplaceComponent<AutomatableComponent>(mapObject);
-              }
-
-              auto& automatable = game_.getEntityManager().
-                getComponent<AutomatableComponent>(mapObject);
-
-              key = getProp(protoSubNode, "chance");
-              behaviorWeights.push_back(atof(reinterpret_cast<char*>(key)));
-              xmlFree(key);
-
-              std::vector<AutomatableComponent::Action> behavior;
-
-              for (xmlNodePtr aiNode = protoSubNode->xmlChildrenNode;
-                aiNode != nullptr;
-                aiNode = aiNode->next)
-              {
-                parseAI(
-                  aiNode,
-                  behavior,
-                  items);
-              }
-
-              automatable.behaviors.push_back(std::move(behavior));
-            }
+            realizable.scriptEngine.script_file(
+              "res/platform.lua");//,
           }
 
           mappable.objects.push_back(mapObject);
@@ -7,9 +7,11 @@ public:
 
   T coords[2];
 
-  vec2() = default;
+  vec2() : coords{0, 0}
+  {
+  }
 
-  vec2(double x, double y) : coords{x, y}
+  vec2(T x, T y) : coords{x, y}
   {
   }
 
@@ -90,12 +92,12 @@ public:
     return vec2(-x(), -y());
   }
 
-  vec2 operator*(double s) const
+  vec2 operator*(T s) const
   {
     return vec2(x() * s, y() * s);
   }
 
-  vec2& operator*=(double s)
+  vec2& operator*=(T s)
   {
     x() *= s;
     y() *= s;