1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
|
#ifndef INVENTORY_H
#define INVENTORY_H
#include <common.hpp>
#include <string.h>
#include <texture.hpp>
#define DEBUG
/**
* The base item class
* This stores the name, width, height, and texture(s)
*/
class Item {
public:
// 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;
/**
* 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 for blank items, we use this for items that do not have an ability
* Like Quest or Debug items
*/
class BaseItem : public Item {
public:
// since the items don't have a use, we don't make one for it
int useItem();
BaseItem* clone();
//~BaseItem(){}
};
/**
* 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;
//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();
};
/**
* 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<std::pair<Item*, uint>> Items;
bool invOpen = false; //is the inventory open
bool invOpening = false; //is the opening animation playing
bool invHover = false; //are we using the fancy hover inventory
bool selected = false; //used in hover inventory to show which item has been selected
bool mouseSel = false; //the location of the temperary selection for the hover inv
bool usingi = false; //bool used to tell if inventory owner is using selected item
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);
int useItem(void);
bool detectCollision(vec2,vec2);
void setSelection(unsigned int s);
void setSelectionUp();
void setSelectionDown();
void draw(void); // Draws a text list of items in this inventory (should only be called for the player for now)
};
void initInventorySprites(void);
void destroyInventory(void);
const char *getItemTexturePath(std::string name);
GLuint getItemTexture(std::string name);
float getItemWidth(std::string name);
float getItemHeight(std::string name);
#endif // INVENTORY_H
|
