Started integrating Lua as a scripting engine

Currently moving platforms are able to have their movement controlled by a script rather than by XML, which is probably a better implementation and scales better to other things. The scripts, instead of using the components as state, use the stack as state. In this way, they pretend to be multithreaded. For instance, the moving platform calls moveRight and then moveLeft. Both of those functions internally make calls that say to wait until the next tick. When the AutomatingSystem ticks, it continues execution of all scripts (sequentially, of course) until they ask for the next tick again. This is implemented using coroutines.

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;