Restructured the way the world is loaded

The World class was removed and replaced by the RealizingSystem and RealizableComponent. The realizable entity is intended to be a singleton and to represent the world. The Map class was also removed and integrated into the MappableComponent.

These changes are to facilitate implementation of map objects without needing special intermediary objects (including the Map class). Now, map entities are created as soon as the world is created, and map object entities will be as well. They will simply be deactivated while the map is not active. Multiple players are now slightly better supported, which will be important in the future.

This will likely become inefficient as the world becomes bigger, and some sort of sector-loading process will have to be designed. This also reduces the usefulness of EntityManager's entity-searching capabilities (which are not the most efficiently implemented currently anyway), and will likely in the future require some added functionality to better search subsets of entities.

A lot of the components were also rewritten to use bare member variables instead of accessor methods, as they never had special functionality and just took up space. These components were also documented.

6 files changed, 350 insertions, 329 deletions

@@ -8,88 +8,86 @@
 class AnimatableComponent : public Component {
 public:
 
+  /**
+   * Constructor for initializing the animation set, because it is not default
+   * constructible.
+   */
   AnimatableComponent(
-    AnimationSet animationSet,
-    std::string animation) :
-      animationSet_(std::move(animationSet)),
-      animation_(std::move(animation))
+    AnimationSet animationSet) :
+      animationSet(std::move(animationSet))
   {
   }
 
-  inline size_t getFrame() const
-  {
-    return frame_;
-  }
-
-  inline void setFrame(size_t v)
-  {
-    frame_ = v;
-  }
-
-  inline size_t getCountdown() const
-  {
-    return countdown_;
-  }
-
-  inline void setCountdown(size_t v)
-  {
-    countdown_ = v;
-  }
-
-  inline const AnimationSet& getAnimationSet() const
-  {
-    return animationSet_;
-  }
-
+  /**
+   * The animation set that this entity will use -- an object describing the
+   * different animations that can be used to render the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  AnimationSet animationSet;
+
+  /**
+   * The name of the currently active animation.
+   *
+   * @managed_by AnimatingSystem
+   */
+  std::string animation;
+
+  /**
+   * For prototypes, the name of the original animation.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::string origAnimation;
+
+  /**
+   * Helper method for accessing the currently active animation.
+   */
   inline const Animation& getAnimation() const
   {
-    return animationSet_.getAnimation(animation_);
+    return animationSet.getAnimation(animation);
   }
 
-  inline void setAnimation(std::string animation)
-  {
-    animation_ = std::move(animation);
-  }
-
-  inline bool isFlickering() const
-  {
-    return flickering_;
-  }
-
-  inline void setFlickering(bool v)
-  {
-    flickering_ = v;
-  }
-
-  inline size_t getFlickerTimer() const
-  {
-    return flickerTimer_;
-  }
-
-  inline void setFlickerTimer(size_t v)
-  {
-    flickerTimer_ = v;
-  }
-
-  inline bool isFrozen() const
-  {
-    return frozen_;
-  }
-
-  inline void setFrozen(bool v)
-  {
-    frozen_ = v;
-  }
-
-private:
-
-  AnimationSet animationSet_;
-  std::string animation_;
-  size_t frame_ = 0;
-  size_t countdown_ = 0;
-  bool flickering_ = false;
-  size_t flickerTimer_ = 0;
-  bool frozen_ = false;
+  /**
+   * The frame of animation that is currently being rendered.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t frame = 0;
+
+  /**
+   * The amount of time (in game frames) before the animation is advanced.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t countdown = 0;
+
+  /**
+   * This option allows to give the sprite a "flickering" effect (as in, it is
+   * not rendered in some frames).
+   */
+  bool flickering = false;
+
+  /**
+   * Used for the flickering effect.
+   *
+   * @managed_by AnimatingSystem
+   */
+  size_t flickerTimer = 0;
+
+  /**
+   * If enabled, this will prevent the sprite's animation from progressing (but
+   * will not affect things such as placement on screen and flickering).
+   */
+  bool frozen = false;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the animating
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
 };
 
 #endif /* end of include guard: SPRITE_RENDERABLE_H_D3AACBBF */
@@ -2,14 +2,47 @@
 #define MAPPABLE_H_0B0316FB
 
 #include <map>
+#include <string>
+#include <vector>
+#include <list>
 #include "component.h"
 #include "renderer/texture.h"
 #include "collision.h"
-#include "map.h"
+#include "entity_manager.h"
 
 class MappableComponent : public Component {
 public:
 
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Helper type that stores information about map adjacency.
+   */
+  class Adjacent {
+  public:
+
+    enum class Type {
+      wall,
+      wrap,
+      warp,
+      reverse
+    };
+
+    Adjacent(
+      Type type = Type::wall,
+      size_t mapId = 0) :
+        type(type),
+        mapId(mapId)
+    {
+    }
+
+    Type type;
+    size_t mapId;
+  };
+
+  /**
+   * Helper type that stores information about collision boundaries.
+   */
   class Boundary {
   public:
 
@@ -20,121 +53,100 @@ public:
       double lower,
       double upper,
       Type type) :
-        axis_(axis),
-        lower_(lower),
-        upper_(upper),
-        type_(type)
-    {
-    }
-
-    inline double getAxis() const
-    {
-      return axis_;
-    }
-
-    inline double getLower() const
-    {
-      return lower_;
-    }
-
-    inline double getUpper() const
-    {
-      return upper_;
-    }
-
-    inline Type getType() const
+        axis(axis),
+        lower(lower),
+        upper(upper),
+        type(type)
     {
-      return type_;
     }
 
-  private:
-
-    double axis_;
-    double lower_;
-    double upper_;
-    Type type_;
+    double axis;
+    double lower;
+    double upper;
+    Type type;
   };
 
-  MappableComponent(
-    Texture tileset,
-    Texture font) :
-      tileset_(std::move(tileset)),
-      font_(std::move(font))
-  {
-  }
-
+  /**
+   * Helper types for efficient storage and lookup of collision boundaries.
+   */
   using asc_boundaries_type =
     std::multimap<
       double,
-      Boundary,
+      const Boundary,
       std::less<double>>;
 
   using desc_boundaries_type =
     std::multimap<
       double,
-      Boundary,
+      const Boundary,
       std::greater<double>>;
 
-  inline size_t getMapId() const
-  {
-    return mapId_;
-  }
-
-  inline void setMapId(size_t v)
-  {
-    mapId_ = v;
-  }
-
-  inline desc_boundaries_type& getLeftBoundaries()
-  {
-    return leftBoundaries_;
-  }
-
-  inline asc_boundaries_type& getRightBoundaries()
-  {
-    return rightBoundaries_;
-  }
-
-  inline desc_boundaries_type& getUpBoundaries()
-  {
-    return upBoundaries_;
-  }
-
-  inline asc_boundaries_type& getDownBoundaries()
-  {
-    return downBoundaries_;
-  }
-
-  inline const Texture& getTileset() const
-  {
-    return tileset_;
-  }
-
-  inline void setTileset(Texture v)
-  {
-    tileset_ = std::move(v);
-  }
-
-  inline const Texture& getFont() const
-  {
-    return font_;
-  }
-
-  inline void setFont(Texture v)
+  /**
+   * Constructor for initializing the tileset and font attributes, as they are
+   * not default constructible.
+   */
+  MappableComponent(
+    Texture tileset,
+    Texture font) :
+      tileset(std::move(tileset)),
+      font(std::move(font))
   {
-    font_ = std::move(v);
   }
 
-private:
-
-  size_t mapId_ = -1;
-
-  desc_boundaries_type leftBoundaries_;
-  asc_boundaries_type rightBoundaries_;
-  desc_boundaries_type upBoundaries_;
-  asc_boundaries_type downBoundaries_;
-  Texture tileset_;
-  Texture font_;
+  /**
+   * The ID of the map in the world definition that this entity represents.
+   *
+   * @managed_by RealizingSystem
+   */
+  size_t mapId;
+
+  /**
+   * The title of the map, which is displayed at the bottom of the screen.
+   */
+  std::string title;
+
+  /**
+   * The map data.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::vector<int> tiles;
+
+  /**
+   * These objects describe the behavior of the four edges of the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  Adjacent leftAdjacent;
+  Adjacent rightAdjacent;
+  Adjacent upAdjacent;
+  Adjacent downAdjacent;
+
+  /**
+   * Collision boundaries, for detecting when a ponderable entity is colliding
+   * with the environment.
+   *
+   * @managed_by MappingSystem
+   */
+  desc_boundaries_type leftBoundaries;
+  asc_boundaries_type rightBoundaries;
+  desc_boundaries_type upBoundaries;
+  asc_boundaries_type downBoundaries;
+
+  /**
+   * The list of entities representing the objects owned by the map.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::list<id_type> objects;
+
+  /**
+   * The tilesets for the map and the map name.
+   *
+   * TODO: These probably do not belong here.
+   */
+  Texture tileset;
+  Texture font;
 };
 
 #endif /* end of include guard: MAPPABLE_H_0B0316FB */
@@ -2,22 +2,30 @@
 #define PLAYABLE_H_DDC566C3
 
 #include "component.h"
-#include <functional>
+#include "entity_manager.h"
 
 class PlayableComponent : public Component {
 public:
 
-  using MapChangeCallback = std::function<void()>;
+  using id_type = EntityManager::id_type;
 
-  bool changingMap = false;
-  int newMapId = -1;
-  double newMapX = 0;
-  double newMapY = 0;
-  MapChangeCallback newMapCallback;
+  /**
+   * The entity ID of the map that the player is on.
+   *
+   * @managed_by PlayingSystem
+   */
+  id_type mapId;
 
-  int checkpointMapId = -1;
-  double checkpointX = 0;
-  double checkpointY = 0;
+  /**
+   * The map ID and coordinates of the location that the player will spawn after
+   * dying. Note that the map ID here is a world description map ID, not an
+   * entity ID.
+   *
+   * @managed_by PlayingSystem
+   */
+  size_t checkpointMapId;
+  double checkpointX;
+  double checkpointY;
 
 };
 
@@ -6,100 +6,73 @@
 class PonderableComponent : public Component {
 public:
 
+  /**
+   * List of different types of physical bodies.
+   *
+   * vacuumed     - Default.
+   * freefalling  - The body will be treated as if there were a downward force
+   *                of gravity being exerted onto it. The body will also exhibit
+   *                terminal velocity (that is, its downward velocity will be
+   *                capped at a constant value).
+   */
   enum class Type {
     vacuumed,
     freefalling
   };
 
-  PonderableComponent(Type type) : type_(type)
-  {
-  }
-
-  inline Type getType() const
-  {
-    return type_;
-  }
-
-  inline double getVelocityX() const
-  {
-    return velX_;
-  }
-
-  inline void setVelocityX(double v)
-  {
-    velX_ = v;
-  }
-
-  inline double getVelocityY() const
-  {
-    return velY_;
-  }
-
-  inline void setVelocityY(double v)
-  {
-    velY_ = v;
-  }
-
-  inline double getAccelX() const
-  {
-    return accelX_;
-  }
-
-  inline void setAccelX(double v)
-  {
-    accelX_ = v;
-  }
-
-  inline double getAccelY() const
-  {
-    return accelY_;
-  }
-
-  inline void setAccelY(double v)
-  {
-    accelY_ = v;
-  }
-
-  inline bool isGrounded() const
-  {
-    return grounded_;
-  }
-
-  inline void setGrounded(bool v)
-  {
-    grounded_ = v;
-  }
-
-  inline bool isFrozen() const
-  {
-    return frozen_;
-  }
-
-  inline void setFrozen(bool v)
-  {
-    frozen_ = v;
-  }
-
-  inline bool isCollidable() const
-  {
-    return collidable_;
-  }
-
-  inline void setCollidable(bool v)
-  {
-    collidable_ = v;
-  }
-
-private:
-
-  double velX_ = 0.0;
-  double velY_ = 0.0;
-  double accelX_ = 0.0;
-  double accelY_ = 0.0;
-  Type type_ = Type::vacuumed;
-  bool grounded_ = false;
-  bool frozen_ = false;
-  bool collidable_ = true;
+  /**
+   * Constructor for initializing the body type, which is a constant.
+   */
+  PonderableComponent(Type type) : type(type)
+  {
+  }
+
+  /**
+   * The velocity of the body.
+   */
+  double velX = 0.0;
+  double velY = 0.0;
+
+  /**
+   * The acceleration of the body.
+   */
+  double accelX = 0.0;
+  double accelY = 0.0;
+
+  /**
+   * The type of physical body that the entity is meant to assume. The body will
+   * be acted upon differently based on this. See the enumeration above for more
+   * details.
+   *
+   * @managed_by PonderingSystem
+   */
+  const Type type;
+
+  /**
+   * Whether or not a freefalling body is in contact with the ground.
+   *
+   * @managed_by PonderingSystem
+   */
+  bool grounded = false;
+
+  /**
+   * If enabled, this will prevent the body from moving.
+   */
+  bool frozen = false;
+
+  /**
+   * If disabled, collision detection for this body will not be performed and
+   * other bodies will ignore it.
+   */
+  bool collidable = true;
+
+  /**
+   * If this flag is disabled, the entity will be ignored by the pondering
+   * system.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool active = false;
 };
 
 #endif /* end of include guard: TANGIBLE_H_746DB3EE */
@@ -0,0 +1,67 @@
+#ifndef REALIZABLE_H_36D8D71E
+#define REALIZABLE_H_36D8D71E
+
+#include "component.h"
+#include <set>
+#include <map>
+#include "entity_manager.h"
+
+class RealizableComponent : public Component {
+public:
+
+  using id_type = EntityManager::id_type;
+
+  /**
+   * Path to the XML file containing the world definition.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::string worldFile;
+
+  /**
+   * Starting map and player location for a new game.
+   *
+   * @managed_by RealizingSystem
+   */
+  int startingMapId;
+  int startingX;
+  int startingY;
+
+  /**
+   * The set of map entities loaded by this entity. It is only intended for
+   * there to be one realizable entity, so this should contain all loaded maps.
+   * The realizable entity has ownership of the loaded maps.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::set<id_type> maps;
+
+  /**
+   * A lookup table that translates a map ID to the entity representing that
+   * loaded map.
+   *
+   * @managed_by RealizingSystem
+   */
+  std::map<size_t, id_type> entityByMapId;
+
+  /**
+   * The entity ID of the currently active map.
+   *
+   * @managed_by RealizingSystem
+   */
+  id_type activeMap;
+
+  /**
+   * Whether or not a map has been activated yet.
+   *
+   * @managed_by RealizingSystem
+   */
+  bool hasActiveMap = false;
+
+  /**
+   * The entity ID of the currently active player.
+   */
+  id_type activePlayer;
+};
+
+#endif /* end of include guard: REALIZABLE_H_36D8D71E */
@@ -6,64 +6,27 @@
 class TransformableComponent : public Component {
 public:
 
-  TransformableComponent(
-    double x,
-    double y,
-    int w,
-    int h) :
-      x_(x),
-      y_(y),
-      w_(w),
-      h_(h)
-  {
-  }
-
-  inline double getX() const
-  {
-    return x_;
-  }
-
-  inline void setX(double v)
-  {
-    x_ = v;
-  }
-
-  inline double getY() const
-  {
-    return y_;
-  }
-
-  inline void setY(double v)
-  {
-    y_ = v;
-  }
-
-  inline int getW() const
-  {
-    return w_;
-  }
-
-  inline void setW(int v)
-  {
-    w_ = v;
-  }
-
-  inline int getH() const
-  {
-    return h_;
-  }
-
-  inline void setH(int v)
-  {
-    h_ = v;
-  }
-
-private:
-
-  double x_;
-  double y_;
-  int w_;
-  int h_;
+  /**
+   * The coordinates of the entity.
+   */
+  double x;
+  double y;
+
+  /**
+   * The size of the entity.
+   */
+  int w;
+  int h;
+
+  /**
+   * For prototypes, the original coordinates and size of the entity.
+   *
+   * @managed_by RealizingSystem
+   */
+  double origX;
+  double origY;
+  int origW;
+  int origH;
 };
 
 #endif /* end of include guard: LOCATABLE_H_39E526CA */