Merge branch 'master' of https://github.com/tcsullivan/gamedev

3 files changed, 161 insertions, 25 deletions

diff --git a/include/inventory.hpp b/include/inventory.hpp
index ce887c3..a41d4d4 100644
--- a/include/inventory.hpp
+++ b/include/inventory.hpp
@@ -8,50 +8,173 @@
 
 #define DEBUG
 
-class Item{
+/**
+ *	The base item class
+ *	This stores the name, width, height, and texture(s)
+ */
+class Item {
 public:
-	std::string name, type;
-	std::string texloc;
+	// what we want to call each item
+	std::string name;
+
+	// how many pixel tall and white each thing is
+	dim2 dim;
+
+	// the total amount of this item each slot can have
+	uint maxStackSize;
 
+	// the array of textures for each frame of animation
 	Texturec *tex;
 
-	float width;
-	float height;
-	int   maxStackSize;
-	float attribValue;
+	// how much the item is rotated in the hand
+	float rotation = 0.0f;
+
+	/**
+	 *	The function we use to call the child classes ability
+	 * 	Note: Since this function is abstract, we HAVE to create one for each
+	 *	child class/type of item.
+	 */
+	virtual int useItem()=0;
+
+	virtual Item* clone()=0;
 
+	// destructor
+	virtual ~Item();
+	// return the first texture for the item
+	GLuint rtex();
+
+	// return the nth texture for the item
+	GLuint rtex(int n);
 };
 
-class Currency{
+/**
+ *	Class for blank items, we use this for items that do not have an ability
+ *	Like Quest or Debug items
+ */
+class BaseItem : public Item {
 public:
-	std::string name;
+	// since the items don't have a use, we don't make one for it
+	int useItem();
 
-	float width;
-	float height;
+	BaseItem* clone();
 
-	std::string texloc;
-	Texturec *tex;
+	//~BaseItem(){}
+};
 
-	float value;
+/**
+ *	Sword class. This is for swords, y'know. Pretty basic stuff
+ */
+class Sword : public Item {
+//	can't touch this
+private:
+	/**
+	 *	How much damage our sword will do
+	 *	notice that it's private to avoid a change
+	 */
+	float damage;
 
-	GLuint rtex()
-	{
-		return tex->image[0];
-	}
+//can touch this
+public:
+	/**
+	 *	Lets us return the amount of damage the sword has
+	 *	TODO takes into account enchants and/or buffs/nerfs
+	 */
+	//TODO move
+	float getDamage();
+
+	/**
+	 *	handles the swinging of the sword
+	 */
+	//TODO move
+	int useItem();
+
+	Sword* clone();
 };
 
-struct item_t {
-	uint count;
-	uint id;
-} __attribute__((packed));
+/**
+ *	Bow class. We use this for shooting bow and arrows
+ */
+class Bow : public Item {
+private:
+	// same as sword
+	float damage;
+public:
+	// returns the amount of damage, see sword
+	float getDamage();
 
+	// handles shooting and arrow curving
+	int useItem();
+
+	Bow* clone();
+};
+
+/**
+ *	Raw food class, this will be used for uncooked meats...
+ *	TODO Eating this may cause health loss, salmonela, mad cow diese
+ */
+class RawFood : public Item {
+private:
+	// the amount of the health the food heals
+	float health;
+
+public:
+	// since the health is private, we get how much it is here
+	float getHealth();
+
+	// TODO chance to hurt
+	virtual int useItem();
+
+	RawFood* clone();
+};
+
+/**
+ *	Cooked/Naturale food class
+ *	When this food is consumed, higher stats are gained than Raw Food and
+ *	there is no chance of damage/de-buffs
+ */
+class Food : public RawFood {
+private:
+public:
+
+	// consume food in hand, no chance for de-buff;
+	int useItem();
+
+	Food* clone();
+};
+
+/**
+ *	Currency class. Well, it's used for currency
+ */
+class NewCurrency : public Item {
+private:
+	// how much the coin is "worth" so to say
+	int value;
+public:
+	// get the value of the coin
+	int getValue();
+
+	// TODO maybe play a jingling noise
+	// probably won't have a use
+	int useItem();
+
+	NewCurrency(){}
+	~NewCurrency(){}
+};
+
+/***********************************************************************************
+ *							OLD STUFF THAT NEEDS TO BURN				   		   *
+ **********************************************************************************/
+
+/***********************************************************************************
+ *						OLD STUFF THAT NEEDS TO GET UPDATED				   		   *
+ **********************************************************************************/
 class Inventory {
 private:
 	unsigned int size; //how many slots our inventory has
 	unsigned int sel; //what item is currently selected
 	int os = 0;
 public:
-	std::vector<item_t> items;
+	std::vector<std::pair<Item*, uint>> Items;
 
 	bool invOpen = false; //is the inventory open
 	bool invOpening = false; //is the opening animation playing
@@ -63,6 +186,8 @@ public:
 	Inventory(unsigned int s);	// Creates an inventory of size 's'
 	~Inventory(void);			// Free's allocated memory
 
+	int useCurrent();
+
 	int addItem(std::string name,uint count);
 	int takeItem(std::string name,uint count);
 	int hasItem(std::string name);
diff --git a/include/quest.hpp b/include/quest.hpp
index 311aade..2db65a2 100644
--- a/include/quest.hpp
+++ b/include/quest.hpp
@@ -22,8 +22,8 @@
 typedef struct {

 	std::string title;

 	std::string desc;

-	struct item_t reward;

-	std::vector<std::pair<std::string,int>> need;

+	std::pair<std::string, uint> reward;

+	std::vector<std::pair<std::string, int>> need;

 } Quest;

 

 /**

diff --git a/include/texture.hpp b/include/texture.hpp
index 0611ded..99d2d84 100644
--- a/include/texture.hpp
+++ b/include/texture.hpp
@@ -61,6 +61,17 @@ public:
 	std::vector<GLuint> image;
 
 	/**
+	 * Contains the dimensions of each texture in the vector
+	 */
+	 //TODO
+	//std::vector<vec2> imageDim;
+
+	/**
+	 * Stores the location of all the images
+	 */
+	std::vector<std::string> texLoc;
+
+	/**
 	 * Populates the image array from a list of strings, with each string as a
 	 * separate argument.
 	 */