7 files changed, 376 insertions, 3 deletions

@@ -0,0 +1,96 @@
+#ifndef AUTOMATABLE_H_3D519131
+#define AUTOMATABLE_H_3D519131
+
+#include "component.h"
+#include <vector>
+#include <random>
+
+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.
+     */
+    double speedX;
+    double speedY;
+
+    /**
+     * 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;
+
+  /**
+   * 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;
+
+  /**
+   * 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 */
@@ -12,6 +12,7 @@
 #include "systems/playing.h"
 #include "systems/scheduling.h"
 #include "systems/realizing.h"
+#include "systems/automating.h"
 #include "animation.h"
 #include "consts.h"
 
@@ -29,12 +30,13 @@ void key_callback(GLFWwindow* window, int key, int, int action, int)
   game.systemManager_.input(key, action);
 }
 
-Game::Game()
+Game::Game(std::mt19937& rng) : rng_(rng)
 {
   systemManager_.emplaceSystem<RealizingSystem>(*this);
   systemManager_.emplaceSystem<PlayingSystem>(*this);
   systemManager_.emplaceSystem<SchedulingSystem>(*this);
   systemManager_.emplaceSystem<ControllingSystem>(*this);
+  systemManager_.emplaceSystem<AutomatingSystem>(*this);
   systemManager_.emplaceSystem<OrientingSystem>(*this);
   systemManager_.emplaceSystem<PonderingSystem>(*this);
   systemManager_.emplaceSystem<MappingSystem>(*this);
@@ -1,6 +1,7 @@
 #ifndef GAME_H_1014DDC9
 #define GAME_H_1014DDC9
 
+#include <random>
 #include "entity_manager.h"
 #include "system_manager.h"
 #include "renderer/renderer.h"
@@ -8,10 +9,15 @@
 class Game {
 public:
 
-  Game();
+  Game(std::mt19937& rng);
 
   void execute();
 
+  inline std::mt19937& getRng()
+  {
+    return rng_;
+  }
+
   inline Renderer& getRenderer()
   {
     return renderer_;
@@ -36,6 +42,7 @@ public:
 
 private:
 
+  std::mt19937 rng_;
   Renderer renderer_;
   EntityManager entityManager_;
   SystemManager systemManager_;
@@ -1,11 +1,15 @@
+#include <random>
 #include "muxer.h"
 #include "game.h"
 
 int main()
 {
+  std::random_device randomDevice;
+  std::mt19937 rng(randomDevice());
+
   initMuxer();
 
-  Game game;
+  Game game(rng);
   game.execute();
 
   destroyMuxer();
@@ -0,0 +1,71 @@
+#include "automating.h"
+#include "game.h"
+#include "components/automatable.h"
+#include "components/ponderable.h"
+#include "systems/pondering.h"
+
+void AutomatingSystem::tick(double dt)
+{
+  auto entities = game_.getEntityManager().getEntitiesWithComponents<
+    AutomatableComponent,
+    PonderableComponent>();
+
+  for (id_type entity : entities)
+  {
+    auto& automatable = game_.getEntityManager().
+      getComponent<AutomatableComponent>(entity);
+
+    if (!automatable.active)
+    {
+      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.velX = curAction.speedX;
+    ponderable.velY = curAction.speedY;
+
+    automatable.remaining -= dt;
+  }
+}
+
+void AutomatingSystem::initPrototype(id_type prototype)
+{
+  auto& automatable = game_.getEntityManager().
+    getComponent<AutomatableComponent>(prototype);
+
+  automatable.behaviorRunning = false;
+  automatable.actionRunning = false;
+}
@@ -0,0 +1,19 @@
+#ifndef AUTOMATING_H_E6E5D76E
+#define AUTOMATING_H_E6E5D76E
+
+#include "system.h"
+
+class AutomatingSystem : public System {
+public:
+
+  AutomatingSystem(Game& game) : System(game)
+  {
+  }
+
+  void tick(double dt);
+
+  void initPrototype(id_type prototype);
+
+};
+
+#endif /* end of include guard: AUTOMATING_H_E6E5D76E */
@@ -12,9 +12,11 @@
 #include "components/playable.h"
 #include "components/ponderable.h"
 #include "components/transformable.h"
+#include "components/automatable.h"
 #include "systems/mapping.h"
 #include "systems/animating.h"
 #include "systems/pondering.h"
+#include "systems/automating.h"
 
 inline xmlChar* getProp(xmlNodePtr node, const char* attr)
 {
@@ -27,6 +29,92 @@ 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.speedX = -speed;
+      action.speedY = 0;
+    } else if (direction == "right")
+    {
+      action.speedX = speed;
+      action.speedY = 0;
+    } else if (direction == "up")
+    {
+      action.speedX = 0;
+      action.speedY = -speed;
+    } else if (direction == "down")
+    {
+      action.speedX = 0;
+      action.speedY = 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(
@@ -211,6 +299,70 @@ 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 (!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;
+            }
+          }
+
+          // 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));
+            }
+          }
+
           mappable.objects.push_back(mapObject);
         } else if (!xmlStrcmp(
           mapNode->name,
@@ -304,6 +456,7 @@ 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<
@@ -366,6 +519,11 @@ void RealizingSystem::loadMap(id_type mapEntity)
       pondering.initPrototype(prototype);
     }
 
+    if (game_.getEntityManager().hasComponent<AutomatableComponent>(prototype))
+    {
+      automating.initPrototype(prototype);
+    }
+
     enterActiveMap(prototype);
   }
 
@@ -399,6 +557,14 @@ void RealizingSystem::enterActiveMap(id_type entity)
 
     ponderable.active = true;
   }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    auto& automatable = game_.getEntityManager().
+      getComponent<AutomatableComponent>(entity);
+
+    automatable.active = true;
+  }
 }
 
 void RealizingSystem::leaveActiveMap(id_type entity)
@@ -418,4 +584,12 @@ void RealizingSystem::leaveActiveMap(id_type entity)
 
     ponderable.active = false;
   }
+
+  if (game_.getEntityManager().hasComponent<AutomatableComponent>(entity))
+  {
+    auto& automatable = game_.getEntityManager().
+      getComponent<AutomatableComponent>(entity);
+
+    automatable.active = false;
+  }
 }