21 files changed, 604 insertions, 0 deletions
diff --git a/include/components/aggro.hpp b/include/components/aggro.hpp
new file mode 100644
index 0000000..17d646c
--- /dev/null
+++ b/include/components/aggro.hpp
@@ -0,0 +1,25 @@
+#ifndef COMPONENTS_AGGRO_HPP_
+#define COMPONENTS_AGGRO_HPP_
+
+#include "base.hpp"
+
+/**
+ * Causes the entity to get mad at the player, charge and fight.
+ */
+struct Aggro : public Component {
+	Aggro(const std::string& a)
+		: arena(a) {}
+	Aggro(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	std::string arena;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		// TODO null check..?, imp given
+		arena = def->StrAttribute("arena");
+	}
+};
+
+#endif // COMPONENTS_AGGRO_HPP_
diff --git a/include/components/all.hpp b/include/components/all.hpp
index 2fb3c8d..dda8938 100644
--- a/include/components/all.hpp
+++ b/include/components/all.hpp
@@ -1,7 +1,26 @@
 #ifndef COMPONENTS_ALL_HPP_
 #define COMPONENTS_ALL_HPP_
 
+#include "aggro.hpp"
+#include "animate.hpp"
 #include "damage.hpp"
+#include "dialog.hpp"
+#include "direction.hpp"
 #include "drop.hpp"
+#include "grounded.hpp"
+#include "health.hpp"
+#include "hit.hpp"
+#include "hop.hpp"
+#include "itemdrop.hpp"
+#include "name.hpp"
+#include "physics.hpp"
+#include "player.hpp"
+#include "portal.hpp"
+#include "position.hpp"
+#include "solid.hpp"
+#include "sprite.hpp"
+#include "trigger.hpp"
+#include "visible.hpp"
+#include "wander.hpp"
 
 #endif // COMPONENTS_ALL_HPP_
diff --git a/include/components/animate.hpp b/include/components/animate.hpp
new file mode 100644
index 0000000..116ee3f
--- /dev/null
+++ b/include/components/animate.hpp
@@ -0,0 +1,64 @@
+#ifndef COMPONENTS_ANIMATE_HPP_
+#define COMPONENTS_ANIMATE_HPP_
+
+#include "base.hpp"
+
+#include <components/sprite.hpp>
+
+#include <vector>
+
+/**
+ * @struct Limb
+ * @brief Storage of frames for the limbs of a sprite.
+ * This will allow us to only update a certain limb. This was we can do mulitple animation types at once.
+ */
+struct Limb {
+	Limb(void) {} // TODO necessary?
+
+	// adds frame to the back of the frame stack
+	inline void addFrame(Frame fr) {
+		frame.push_back(fr);
+	}
+
+	void firstFrame(Frame& duckmyass);
+	void nextFrame(Frame& duckmyass, float dt); 
+
+	/**< How often we will change each frame. */
+	float updateRate;
+
+	/**< How much has been updated in the current frame. */
+	float updateCurrent = 0; 
+
+	/**< What the updateRate will base it's updates off of. ie: Movement, attacking, jumping. */
+	unsigned int updateType;
+
+	/**< The id of the limb we will be updating */
+	unsigned int limbID;
+	
+	/**< The current sprite being used for the limb. */
+	unsigned int index = 0;
+
+	/**< The multiple frames of each limb. */
+	std::vector<Frame> frame;
+};
+
+struct Animate : public Component {
+	// COMMENT
+	unsigned int index;
+	// COMMENT	
+	std::vector<Limb> limb;
+
+	Animate(void)
+		: index(0) {}
+	Animate(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	// COMMENT
+	void firstFrame(unsigned int updateType, Frame &sprite);
+	//TODO make updateType an enum
+	void updateAnimation(unsigned int updateType, Frame& sprite, float dt);
+	void fromXML(XMLElement* imp, XMLElement* def) final;
+};
+
+#endif // COMPONENTS_ANIMATE_HPP_
diff --git a/include/components/dialog.hpp b/include/components/dialog.hpp
new file mode 100644
index 0000000..8d26b92
--- /dev/null
+++ b/include/components/dialog.hpp
@@ -0,0 +1,31 @@
+#ifndef COMPONENTS_DIALOG_HPP_
+#define COMPONENTS_DIALOG_HPP_
+
+#include "base.hpp"
+
+#include <random.hpp>
+
+struct Dialog : public Component {
+	Dialog(int idx = 0)
+		: index(idx), rindex((idx == 9999) ? randGet() : idx), talking(false) {}
+	Dialog(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	int index;
+	int rindex;
+	bool talking;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)def;
+		bool hasDialog;
+		if (imp->QueryBoolAttribute("hasDialog", &hasDialog) != XML_NO_ERROR)
+			hasDialog = false;
+
+		index = hasDialog ? 0 : 9999;
+		rindex = (index == 9999) ? randGet() : index;
+		talking = false;
+	}
+};
+
+#endif // COMPONENTS_DIALOG_HPP_
diff --git a/include/components/direction.hpp b/include/components/direction.hpp
new file mode 100644
index 0000000..1229e49
--- /dev/null
+++ b/include/components/direction.hpp
@@ -0,0 +1,42 @@
+#ifndef COMPONENTS_DIRECTION_HPP_
+#define COMPONENTS_DIRECTION_HPP_
+
+#include "base.hpp"
+
+#include <vector2.hpp>
+
+/**
+ * @struct Direction
+ * @brief Store an entities velocity.
+ * This allows the entity to move throughout the world.
+ */
+struct Direction : public Component {
+	/**
+	 * Constructor that sets the velocity, if no position is passed, it defaults to (0,0).
+	 * @param x The velocity of the object on the x axis.
+	 * @param y The velocity of the object on the y axis.
+	 */
+	Direction(float x = 0.0f, float y = 0.0f): x(x), y(y), grounded(false) {}
+	Direction(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	float x; /**< Velocity the object is moving in the x direction, this is added to the position */
+	float y; /**< Velocity the object is moving in the y direction, this is added to the position */
+	bool grounded;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		vec2 c;
+		if (imp->Attribute("direction") != nullptr) {
+			c = imp->StrAttribute("direction");
+		} else if (def->Attribute("value") != nullptr) {
+			c = def->StrAttribute("value");
+		} else {
+			c = vec2(0, 0);
+		}
+
+		x = c.x, y = c.y, grounded = false;
+	}
+};
+
+#endif // COMPONENTS_DIRECTION_HPP_
diff --git a/include/components/flash.hpp b/include/components/flash.hpp
new file mode 100644
index 0000000..e53c41c
--- /dev/null
+++ b/include/components/flash.hpp
@@ -0,0 +1,15 @@
+#ifndef COMPONENTS_FLASH_HPP_
+#define COMPONENTS_FLASH_HPP_
+
+#include <color.hpp>
+
+struct Flash
+{
+	Flash(Color c, int _ms = 500)
+		: color(c), ms(_ms), totalMs(_ms) {}
+
+	Color color;
+	int ms, totalMs;
+};
+
+#endif // COMPONENTS_FLASH_HPP_
diff --git a/include/components/grounded.hpp b/include/components/grounded.hpp
new file mode 100644
index 0000000..017c118
--- /dev/null
+++ b/include/components/grounded.hpp
@@ -0,0 +1,27 @@
+#ifndef COMPONENTS_GROUNDED_HPP_
+#define COMPONENTS_GROUNDED_HPP_
+
+#include "base.hpp"
+
+/**
+ * @struct Grounded
+ * @brief Places an entity without physics on the ground.
+ * This is used so we don't have to update the physics of a non-moving object every loop.
+ */
+struct Grounded : public Component {
+	Grounded(bool g = false)
+		: grounded(g) {}
+	Grounded(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	bool grounded;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		(void)def;
+		grounded = false;
+	}
+};
+
+#endif // COMPONENTS_GROUNDED_HPP_
diff --git a/include/components/health.hpp b/include/components/health.hpp
new file mode 100644
index 0000000..eacaaa5
--- /dev/null
+++ b/include/components/health.hpp
@@ -0,0 +1,34 @@
+#ifndef COMPONENTS_HEALTH_HPP_
+#define COMPONENTS_HEALTH_HPP_
+
+#include "base.hpp"
+
+/**
+ * @struct Health
+ * @brief Gives and entity health and stuff.
+ */
+struct Health : public Component {
+	/**
+	 * Constructor that sets the variables, with 1 health as default.
+	 */
+	Health(int m = 1, int h = 0)
+		: health(h != 0 ? h : m), maxHealth(m) {}
+	Health(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	int health; /**< The current amount of health */
+	int maxHealth; /**< The maximum amount of health */
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		(void)def;
+		// TODO
+		if (def->QueryIntAttribute("value", &health) != XML_NO_ERROR)
+			health = 1;
+		maxHealth = health;
+	}
+};
+
+
+#endif // COMPONENTS_HEALTH_HPP_
diff --git a/include/components/hit.hpp b/include/components/hit.hpp
new file mode 100644
index 0000000..d2e80ca
--- /dev/null
+++ b/include/components/hit.hpp
@@ -0,0 +1,19 @@
+#ifndef COMPONENTS_HIT_HPP_
+#define COMPONENTS_HIT_HPP_
+
+#include "base.hpp"
+
+struct Hit : public Component {
+	Hit(int d, bool p = false)
+		: damage(d), pierce(p) {}
+
+	int damage;
+	bool pierce;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		(void)def;
+	}
+};
+
+#endif // COMPONENTS_HIT_HPP_
diff --git a/include/components/hop.hpp b/include/components/hop.hpp
new file mode 100644
index 0000000..f114265
--- /dev/null
+++ b/include/components/hop.hpp
@@ -0,0 +1,14 @@
+#ifndef COMPONENTS_HOP_HPP_
+#define COMPONENTS_HOP_HPP_
+
+/**
+ * Causes the entity to hop around.
+ */
+struct Hop {
+	Hop(float r = 0)
+		: hopRatio(r) {}
+
+	float hopRatio;
+};
+
+#endif // COMPONENTS_HOP_HPP
diff --git a/include/components/itemdrop.hpp b/include/components/itemdrop.hpp
new file mode 100644
index 0000000..681c0d6
--- /dev/null
+++ b/include/components/itemdrop.hpp
@@ -0,0 +1,13 @@
+#ifndef COMPONENTS_ITEMDROP_HPP_
+#define COMPONENTS_ITEMDROP_HPP_
+
+#include <inventory.hpp>
+
+struct ItemDrop {
+	ItemDrop(InventoryEntry& ie)
+		: item(ie) {}
+
+	InventoryEntry item;
+};
+
+#endif // COMPONENTS_ITEMDROP_HPP_
diff --git a/include/components/name.hpp b/include/components/name.hpp
new file mode 100644
index 0000000..423a484
--- /dev/null
+++ b/include/components/name.hpp
@@ -0,0 +1,24 @@
+#ifndef COMPONENTS_NAME_HPP_
+#define COMPONENTS_NAME_HPP_
+
+#include "base.hpp"
+
+#include <string>
+
+struct Name : public Component {
+	Name(std::string n = "")
+		: name(n) {}
+	Name(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	std::string name;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		auto n = imp->Attribute("name");
+
+		// TODO check def's nullness	
+		name = n != nullptr ? n : def->Attribute("value");
+	}
+};
+#endif // COMPONENTS_NAME_HPP_
diff --git a/include/components/physics.hpp b/include/components/physics.hpp
new file mode 100644
index 0000000..8e462a9
--- /dev/null
+++ b/include/components/physics.hpp
@@ -0,0 +1,31 @@
+#ifndef COMPONENTS_PHYSICS_HPP_
+#define COMPONENTS_PHYSICS_HPP_
+
+#include "base.hpp"
+
+/**
+ * @struct Physics
+ * @brief Allows and entity to react to gravity and frictions.
+ * When an entity inherits this component it will react with gravity and move with friction.
+ */
+struct Physics : public Component {
+	/**
+	 * Constructor that sets the gravity constant, if not specified it becomes 0.
+	 * @param g The non default gravity constant.
+	 */
+	Physics(float g = 0.2f): g(g) {}
+	Physics(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	float g; /**< The gravity constant, how fast the object falls */
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		if (imp->QueryFloatAttribute("gravity", &g) != XML_NO_ERROR) {
+			if (def->QueryFloatAttribute("value", &g) != XML_NO_ERROR)
+				g = 0.2f;
+		}
+	}
+};
+
+#endif // COMPONENTS_PHYSICS_HPP_
diff --git a/include/components/player.hpp b/include/components/player.hpp
new file mode 100644
index 0000000..afcaa90
--- /dev/null
+++ b/include/components/player.hpp
@@ -0,0 +1,6 @@
+#ifndef COMPONENTS_PLAYER_HPP_
+#define COMPONENTS_PLAYER_HPP_
+
+struct Player {};
+
+#endif // COMPONENTS_PLAYER_HPP_
diff --git a/include/components/portal.hpp b/include/components/portal.hpp
new file mode 100644
index 0000000..ca153e1
--- /dev/null
+++ b/include/components/portal.hpp
@@ -0,0 +1,23 @@
+#ifndef COMPONENTS_PORTAL_HPP_
+#define COMPONENTS_PORTAL_HPP_
+
+#include "base.hpp"
+
+#include <string>
+
+struct Portal : public Component {
+	Portal(std::string tf = "")
+		: toFile(tf) {}
+	Portal(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	std::string toFile;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)def;
+		toFile = imp->StrAttribute("inside");
+	}
+};
+
+#endif // COMPONENTS_PORTAL_HPP_
diff --git a/include/components/position.hpp b/include/components/position.hpp
new file mode 100644
index 0000000..f040bec
--- /dev/null
+++ b/include/components/position.hpp
@@ -0,0 +1,37 @@
+#ifndef COMPONENTS_POSITION_HPP_
+#define COMPONENTS_POSITION_HPP_
+
+#include "base.hpp"
+
+#include <vector2.hpp>
+
+/**
+ * @struct Position
+ * @brief Stores the position of an entity on the xy plane.
+ */
+struct Position : public Component {
+	/**
+	 * Constructor that sets the position of the object, if nothing is passed it will default to 0.
+	 * @param x The x position the object will be placed at.
+	 * @param y the y position the object will be placed at.
+	 */
+	Position(float x = 0.0f, float y = 0.0f): x(x), y(y) {}
+	Position(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	float x; /**< The x position in the world */
+	float y; /**< The y position in the world */
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		vec2 c;
+		if (imp->Attribute("position") != nullptr)
+			c = imp->StrAttribute("position");
+		else
+			c = def->StrAttribute("value");
+
+		x = c.x, y = c.y;
+	}
+};
+
+#endif // COMPONENTS_POSITION_HPP_
diff --git a/include/components/solid.hpp b/include/components/solid.hpp
new file mode 100644
index 0000000..35bfcf7
--- /dev/null
+++ b/include/components/solid.hpp
@@ -0,0 +1,45 @@
+#ifndef COMPONENTS_SOLID_HPP_
+#define COMPONENTS_SOLID_HPP_
+
+#include "base.hpp"
+
+#include <vector2.hpp>
+
+/**
+ * @struct Solid
+ * @brief Allows an entity to collide with other objects.
+ * When an entity has this component it can collide with the world and other objects.
+ */
+struct Solid : public Component {
+	/**
+	 * Constructor that sets the entities dimensions based on what is passed.
+	 * @param w The desired width of the entity.
+	 * @param h The desired height of the entity.
+	 */
+	Solid(float w = 0.0f, float h = 0.0f)
+		: width(w), height(h), offset(0), passable(true) {}
+	Solid(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	void Passable(bool v) { passable = v; }
+	bool Passable(void)   { return passable; }
+
+	float width; /**< The width of the entity in units */
+	float height; /**< The height of the entity in units */
+	vec2 offset; /**< This allows us to make the hitbox in any spot */
+	bool passable; /**< This determines whether or not one can pass by the entity */
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		vec2 c;
+		if (def->Attribute("value") != nullptr)
+			c = def->StrAttribute("value");
+		else
+			c = vec2(0, 0);
+
+		width = c.x, height = c.y, offset = 0, passable = true;
+	}
+};
+
+#endif // COMPONENTS_SOLID_HPP_
diff --git a/include/components/sprite.hpp b/include/components/sprite.hpp
new file mode 100644
index 0000000..35a13b8
--- /dev/null
+++ b/include/components/sprite.hpp
@@ -0,0 +1,64 @@
+#ifndef COMPONENTS_SPRITE_HPP_
+#define COMPONENTS_SPRITE_HPP_
+
+#include "base.hpp"
+
+#include <texture.hpp>
+#include <vector2.hpp>
+
+#include <vector>
+
+struct SpriteData {
+	SpriteData(void) = default;	
+	SpriteData(Texture t);
+	SpriteData(std::string path, vec2 off);
+	SpriteData(std::string path, vec2 off, vec2 si);
+
+	Texture tex;
+	vec2 size;
+	vec2 offset;
+	
+	vec2 offset_tex;
+	vec2 size_tex;
+
+	unsigned int limb;
+};
+
+using Frame = std::vector<std::pair<SpriteData, vec2>>;
+
+std::vector<Frame> developFrame(XMLElement*);
+
+/**
+ * @struct Sprite
+ * @brief If an entity is visible we want to be able to see it.
+ * Each entity is given a sprite, a sprite can consist of manu frames or pieces to make one.
+ */
+struct Sprite : public Component {
+	Sprite(bool left = false)
+	 	: faceLeft(left) {}
+	Sprite(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	inline Frame getSprite(void) {
+		return sprite;
+	}
+
+	int clearSprite(void);
+	int addSpriteSegment(SpriteData data, vec2 loc);
+	int changeSpriteSegment(SpriteData data, vec2 loc);
+	vec2 getSpriteSize(); 
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		auto frames = developFrame(def);
+		if (!frames.empty())
+			sprite = frames.at(0);
+	}
+
+	Frame sprite;
+	bool faceLeft;
+};
+
+
+#endif // COMPONENTS_SPRITE_HPP_
diff --git a/include/components/trigger.hpp b/include/components/trigger.hpp
new file mode 100644
index 0000000..c9a53f6
--- /dev/null
+++ b/include/components/trigger.hpp
@@ -0,0 +1,25 @@
+#ifndef COMPONENTS_TRIGGER_HPP_
+#define COMPONENTS_TRIGGER_HPP_
+
+#include "base.hpp"
+
+#include <string>
+
+struct Trigger : public Component {
+	Trigger(const std::string& t)
+		: text(t) {}
+	Trigger(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	std::string text;
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		(void)def;
+		text = "You got me!";
+	}
+};
+
+
+#endif // COMPONENTS_TRIGGER_HPP_
diff --git a/include/components/visible.hpp b/include/components/visible.hpp
new file mode 100644
index 0000000..4785fb0
--- /dev/null
+++ b/include/components/visible.hpp
@@ -0,0 +1,30 @@
+#ifndef COMPONENTS_VISIBLE_HPP_
+#define COMPONENTS_VISIBLE_HPP_
+
+#include "base.hpp"
+
+/**
+ * @struct Visible
+ * @brief If an entity is visible we want to be able to draw it.
+ */
+struct Visible : public Component {
+	/**
+	 * @brief Decide what layer to draw the entity on.
+	 * When stuff is drawn, it is drawn on a "layer". This layer gives more of a 3D effect to the world.
+	 * @param z The desired "layer" of the entity.
+	 */
+	Visible(float z = 0.0f): z(z) {}
+	Visible(XMLElement* imp, XMLElement* def) {
+		fromXML(imp, def);
+	}
+
+	float z; /**< The value along the z axis the entity will be drawn on */
+
+	void fromXML(XMLElement* imp, XMLElement* def) final {
+		(void)imp;
+		if (def->QueryFloatAttribute("value", &z) != XML_NO_ERROR)
+			z = 0;
+	}
+};
+
+#endif // COMPONENTS_VISIBLE_HPP_
diff --git a/include/components/wander.hpp b/include/components/wander.hpp
new file mode 100644
index 0000000..2001e89
--- /dev/null
+++ b/include/components/wander.hpp
@@ -0,0 +1,16 @@
+#ifndef COMPONENTS_WANDER_HPP_
+#define COMPONENTS_WANDER_HPP_
+
+/**
+ * Causes the entity to wander about.
+ */
+struct Wander {
+	Wander(float ix = 0, float r = 0)
+		: initialX(ix), range(r), countdown(0) {}
+
+	float initialX;
+	float range;
+	int countdown;
+};
+
+#endif // COMPONENTS_WANDER_HPP_