aboutsummaryrefslogtreecommitdiffstats
path: root/src/inventory.cpp.bak
diff options
context:
space:
mode:
Diffstat (limited to 'src/inventory.cpp.bak')
-rw-r--r--src/inventory.cpp.bak747
1 files changed, 747 insertions, 0 deletions
diff --git a/src/inventory.cpp.bak b/src/inventory.cpp.bak
new file mode 100644
index 0000000..1b325c0
--- /dev/null
+++ b/src/inventory.cpp.bak
@@ -0,0 +1,747 @@
+#include <inventory.hpp>
+
+#include <numeric>
+
+#include <gametime.hpp>
+
+#include <render.hpp>
+
+#include <tinyxml2.h>
+using namespace tinyxml2;
+
+extern Player *player;
+extern GLuint invUI;
+static vec2 itemLoc;
+static const unsigned char numSlot = 7;
+Mix_Chunk* swordSwing;
+
+static std::vector<NewCurrency *> currencyMap;
+static std::vector<Item *> ItemMap;
+
+
+void itemDraw(Player *p, Item* d);
+
+bool strCaseCmp(std::string one, std::string two)
+{
+ for (auto &s : one) {
+ s = std::tolower(s);
+ }
+ for (auto &t : two) {
+ t = std::tolower(t);
+ }
+
+ if (one == two) return true;
+ return false;
+}
+
+void items(void)
+{
+ XMLDocument xml;
+ xml.LoadFile("config/items.xml");
+ XMLElement *exml = xml.FirstChildElement("item");
+ XMLElement *cxml = xml.FirstChildElement("currency");
+
+ while (cxml) {
+
+ // NEWEWEWEWEWEWEWEW
+ // TODO
+
+
+ cxml = cxml->NextSiblingElement();
+ }
+ while (exml) {
+
+ std::string name = exml->Attribute("type");
+ // if the type is blank
+ if (strCaseCmp(name, "blank")) {
+
+ ItemMap.push_back(new BaseItem());
+
+ // if the type is a sword
+ } else if (strCaseCmp(name, "sword")) {
+
+ Sword *tmpSword = new Sword();
+ tmpSword->setDamage(exml->FloatAttribute("damage"));
+ ItemMap.push_back(tmpSword->clone());
+ delete tmpSword;
+
+ // if the type is a bow
+ } else if (strCaseCmp(name, "bow")) {
+
+ Bow *tmpBow = new Bow();
+ tmpBow->setDamage(exml->FloatAttribute("damage"));
+ ItemMap.push_back(tmpBow->clone());
+ delete tmpBow;
+
+ // arrow
+ } else if (strCaseCmp(name, "arrow")) {
+
+ Arrow *tmpArrow = new Arrow();
+ tmpArrow->setDamage(exml->FloatAttribute("damage"));
+ ItemMap.push_back(tmpArrow->clone());
+ delete tmpArrow;
+
+ // uncooked / raw food
+ }else if (strCaseCmp(name, "raw food")) {
+
+ ItemMap.push_back(new RawFood());
+
+ // cooked food or natural food
+ } else if (strCaseCmp(name, "food") || strCaseCmp(name, "cooked food")) {
+
+ ItemMap.push_back(new Food());
+
+ // light
+ } else if (strCaseCmp(name, "light")) {
+
+ ItemMap.push_back(new ItemLight());
+
+ // if type was not specified make it a base item
+ } else {
+
+ ItemMap.push_back(new BaseItem());
+ }
+
+ // set how much of the item we can stack
+ if(exml->QueryUnsignedAttribute("maxStackSize", &ItemMap.back()->maxStackSize) != XML_NO_ERROR) {
+ ItemMap.back()->maxStackSize = 1;
+ }
+
+ // set all of the texture frames we can use
+ ItemMap.back()->tex = new Texturec(1, exml->Attribute("sprite"));
+
+ // get the width and height of the object based off of its sprite
+ dim2 tmpDim = Texture::imageDim(exml->Attribute("sprite"));
+ ItemMap.back()->dim.x = HLINES(tmpDim.x/2);
+ ItemMap.back()->dim.y = HLINES(tmpDim.y/2);
+
+ ItemMap.back()->name = exml->Attribute("name");
+
+ exml = exml->NextSiblingElement();
+ }
+}
+
+int Inventory::addItem(std::string name, uint count)
+{
+ for (uint i = 0; i < ItemMap.size(); i++) {
+ if (strCaseCmp(ItemMap[i]->name, name)) {
+ for (auto &it : Items) {
+ if (it.second && strCaseCmp(it.first->name, name)) {
+ if ((it.second + count) < it.first->maxStackSize) {
+ it.second += count;
+ return 0;
+ } else {
+ count -= (it.second + count) - it.first->maxStackSize;
+ it.second = it.first->maxStackSize;
+ }
+ }
+ }
+ uint tmpCount = count;
+ do {
+ if ((count) > ItemMap[i]->maxStackSize) {
+ count -= ItemMap[i]->maxStackSize;
+ tmpCount = ItemMap[i]->maxStackSize;
+ } else {
+ tmpCount = count;
+ count = 0;
+ }
+ Items[os] = std::make_pair(ItemMap[i]->clone(), tmpCount);
+ if (!Items[os+1].second) {
+ os++;
+ } else {
+ for (uint z = 0; z < Items.size(); z++) {
+ if (!Items[z].second) {
+ os = z;
+ }
+ }
+ }
+ } while (count > 0);
+ return 0;
+ }
+ }
+ return -1;
+}
+
+int Inventory::takeItem(std::string name, uint count)
+{
+
+ // returns
+ // 0 = good
+ // -1 = no such item exists
+ // -2 = if item doesnt exist in inventory
+ // postive items = number returned is how many more the item needs
+
+ std::string iden;
+
+ for (uint i = 0; i < ItemMap.size(); i++) {
+ if (ItemMap[i]->name == name) {
+ iden = name;
+ break;
+ }
+ }
+
+ if (iden.empty()) {
+ return -1;
+ }
+
+ for (auto &i : Items) {
+ if (i.second && i.first->name == iden) {
+ if (count > i.second) {
+ return (count - i.second);
+ } else {
+ i.second -= count;
+
+ }
+ return 0;
+ }
+ }
+
+ return -2;
+}
+
+int Inventory::hasItem(std::string name) {
+
+ for (auto &i : Items) {
+ if (i.first->name == name) {
+ return i.second;
+ }
+ }
+
+ return 0;
+}
+void initInventorySprites(void) {
+
+ items();
+
+ // keep
+ swordSwing = Mix_LoadWAV("assets/sounds/shortSwing.wav");
+ Mix_Volume(2,100);
+}
+
+void destroyInventory(void) {
+
+ // NEWEWEWEWEWEWEWEW
+ while (!ItemMap.empty()) {
+ delete ItemMap.back();
+ ItemMap.pop_back();
+ }
+
+ Mix_FreeChunk(swordSwing);
+}
+
+
+const char *getItemTexturePath(std::string name){
+ for (auto &i : ItemMap) {
+ if (i->name == name)
+ return i->tex->texLoc[0].c_str();
+ }
+ return NULL;
+}
+
+GLuint getItemTexture(std::string name) {
+ for (auto &i : ItemMap) {
+ if (i->name == name) {
+ return i->tex->image[0];
+ }
+ }
+ return 0;
+}
+
+float getItemWidth(std::string name) {
+ for (auto &i : ItemMap) {
+ if (i->name == name)
+ return i->dim.x;
+ }
+ return 0;
+}
+
+float getItemHeight(std::string name) {
+ for (auto &i : ItemMap) {
+ if (i->name == name)
+ return i->dim.y;
+ }
+ return 0;
+}
+
+Inventory::Inventory(unsigned int s) {
+ sel=0;
+ size=s;
+
+ Items.resize(size);
+ for (auto &i : Items) {
+ i = std::make_pair(nullptr, 0);
+ }
+}
+
+Inventory::~Inventory(void) {
+}
+
+void Inventory::setSelection(unsigned int s) {
+ sel=s;
+}
+
+void Inventory::setSelectionUp() {
+ if (!sel--)
+ sel++;
+}
+
+void Inventory::setSelectionDown() {
+ if (++sel >= numSlot)
+ sel = numSlot - 1;
+}
+
+void Inventory::draw(void) {
+ static std::vector<int>dfp(numSlot);
+ static std::vector<Ray>iray(numSlot);
+ static std::vector<vec2>curCoord(numSlot);
+ static int range = 200;
+
+ static std::vector<int>curdfp(4);
+ static std::vector<Ray>curRay(4);
+ static std::vector<vec2>curCurCoord(4);
+ static int curRange = 100;
+
+ static std::vector<int>massDfp(32);
+ static std::vector<vec2>massRay(32);
+ static std::vector<int>massOrder = {9,10,11,12,13,14,22,21,20,19,18,17,16,8,0,1,2,3,4,5,6,7,15,23,31,30,29,28,27,26,25,24};
+ static std::vector<int>massOrderClosing = {31,30,23,29,22,15,28,21,14,7,27,20,13,6,26,19,12,5,25,18,11,4,24,17,10,3,16,9,2,8,1,0};
+ static int massRange = 200;
+
+ static int itemWide = 45;
+ float angleB = (float)180/(float)numSlot;
+ float angle = float(angleB/2.0f);
+ unsigned int a = 0;
+ //static vec2 mouseStart = {0,0};
+
+ auto deltaTime = game::time::getDeltaTime();
+ auto SCREEN_WIDTH = game::SCREEN_WIDTH;
+ auto SCREEN_HEIGHT = game::SCREEN_HEIGHT;
+
+ for (auto &r : iray) {
+ r.start.x = player->loc.x + (player->width / 2);
+ r.start.y = player->loc.y + (player->height / 2);
+ curCoord[a++] = r.start;
+ } a = 0;
+
+ for (auto &cr : curRay) {
+ cr.start.x = (offset.x + SCREEN_WIDTH / 2);
+ cr.start.y = offset.y - (a * itemWide * 1.5f);
+ curCurCoord[a++] = cr.start;
+ } a = 0;
+
+ for (int r = 0; r < 4; r++) {
+ for (int c = 0; c < 8; c++) {
+ massRay[a ].x = ((offset.x - SCREEN_WIDTH / 2) + itemWide) + c * itemWide * 1.5f;
+ massRay[a++].y = ((offset.y + SCREEN_HEIGHT / 2) - itemWide * 1.5f) - r * itemWide * 1.5f;
+ }
+ } a = 0;
+
+ auto averagef = [](const std::vector<int> &v) {
+ auto sum = std::accumulate(std::begin(v), std::end(v), 0);
+ return sum / v.size();
+ };
+
+ ui::fontTransInv = std::clamp(255 * (averagef(dfp) / range), 0ul, 255ul);
+
+ if (invOpening) {
+ for (auto &d : dfp) {
+ if (!a || dfp[a - 1] > 50)
+ d += 4.0f * deltaTime;
+ if (d > range)
+ d = range;
+ a++;
+ } a = 0;
+
+ for (auto &cd : curdfp) {
+ if (!a || curdfp[a - 1] > 90)
+ cd += 3.0f * deltaTime;
+ if (cd > curRange)
+ cd = curRange;
+ a++;
+ } a = 0;
+
+ while (a < massOrder.size()) {
+ if (!a || massDfp[massOrder[a - 1]] > massRange * 0.75f)
+ massDfp[massOrder[a]] += 20.0f * deltaTime;
+ if (massDfp[massOrder[a]] > massRange)
+ massDfp[massOrder[a]] = massRange;
+ a++;
+ } a = 0;
+
+ if (numSlot > 0)
+ invOpen = true;
+ } else {
+ for (auto &d : dfp) {
+ if (d > 0)
+ d -= 4.5f * deltaTime;
+ }
+ for (auto &cd : curdfp) {
+ if (cd > 0)
+ cd -= 3.0f * deltaTime;
+ }
+
+ while (a < massRay.size()) {
+ if (!a || massDfp[massOrderClosing[a - 1]] <= 0)
+ massDfp[massOrderClosing[a]] -= 30.0f * deltaTime;
+ else if (massDfp[massOrderClosing[a - 1]] < 0)
+ massDfp[massOrderClosing[a - 1]] = 0;
+ a++;
+ } a = 0;
+
+ if (std::all_of(std::begin(massDfp), std::end(massDfp), [](auto d) { return d <= 0; })) {
+ invOpen = false;
+ for (auto &md : massDfp) {
+ if (md < 0)
+ md = 0;
+ }
+ }
+
+ }
+
+ /*
+ * a = 0
+ */
+
+ if (invOpen) {
+ Render::useShader(&Render::textShader);
+ for(auto &mr : massRay) {
+ float t = (((float)massDfp[a]/(float)massRange)*.5f);
+ glActiveTexture(GL_TEXTURE0);
+ Render::textShader.use();
+
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f,0.0f,0.0f, t >= 0? 255*t : 0)));
+ glUniform1i(Render::textShader.uniform[WU_texture], 0);
+
+ Render::drawRect(vec2(mr.x-(itemWide/2), mr.y-(itemWide/2)), vec2(mr.x-(itemWide/2)+itemWide, mr.y-(itemWide/2)+itemWide), -6.0);
+
+ glUseProgram(0);
+ if (!Items.empty() && a+numSlot < Items.size() && Items[a+numSlot].second) {
+ Render::textShader.use();
+ glBindTexture(GL_TEXTURE_2D, Items[a+numSlot].first->tex->image[0]);//itemtex[items[a+numSlot].id]);
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0f, 1.0f, 1.0f, ((float)massDfp[a]/(float)(massRange?massRange:1))*0.8f);
+
+ if (Items[a+numSlot].first->dim.y > Items[a+numSlot].first->dim.x) {
+ Render::drawRect(vec2(mr.x-((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y-(itemWide/2)),
+ vec2(mr.x+((itemWide/2)*((float)Items[a+numSlot].first->dim.x/(float)Items[a+numSlot].first->dim.y)), mr.y+(itemWide/2)), -6.1);
+ } else {
+ Render::drawRect(vec2(mr.x-(itemWide/2),mr.y-(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)),
+ vec2(mr.x-(itemWide/2),mr.y+(itemWide/2)*((float)Items[a+numSlot].first->dim.y/(float)Items[a+numSlot].first->dim.x)), -6.1);
+ }
+ ui::setFontColor(255,255,255,((float)massDfp[a]/(float)(massRange?massRange:1))*255);
+ ui::putText(mr.x-(itemWide/2)+(itemWide*.85),mr.y-(itemWide/2),"%d",Items[a+numSlot].second);
+ ui::setFontColor(255,255,255,255);
+ Render::textShader.unuse();
+ }
+ a++;
+ }a=0;
+
+ for(auto &cr : curRay) {
+ curCurCoord[a].x -= float((curdfp[a]) * cos(-1));
+ curCurCoord[a].y += float((curdfp[a]) * sin(0));
+ cr.end = curCurCoord[a];
+
+ float curTrans = (((float)curdfp[a]/(float)(curRange?curRange:1))*0.5f);
+
+ Render::textShader.use();
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f, 0.0f, 0.0f, curTrans >= 0 ? 255 * curTrans : 0)));
+ Render::drawRect(vec2(cr.end.x-(itemWide/2), cr.end.y-(itemWide/2)),
+ vec2(cr.end.x-(itemWide/2)+itemWide,cr.end.y-(itemWide/2)+itemWide), -6.0);
+ Render::textShader.unuse();
+ a++;
+ }a=0;
+
+ for(auto &r : iray) {
+ angle = 180 - (angleB * a) - angleB / 2.0f;
+ curCoord[a].x += float((dfp[a]) * cos(angle*PI/180));
+ curCoord[a].y += float((dfp[a]) * sin(angle*PI/180));
+ r.end = curCoord[a];
+
+ float t = ((float)dfp[a]/(float)(range?range:1))*0.5f;
+
+ Render::textShader.use();
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(0.0f, 0.0f, 0.0f, t >= 0 ? 255 * t : 0)));
+ Render::drawRect(vec2(r.end.x-(itemWide/2), r.end.y-(itemWide/2)),
+ vec2(r.end.x-(itemWide/2)+itemWide,r.end.y-(itemWide/2)+itemWide), -6.0);
+
+ if (!Items.empty() && a < numSlot && Items[a].second) {
+ glBindTexture(GL_TEXTURE_2D, Items[a].first->tex->image[0]);//itemtex[items[a].id]);
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0f, 1.0f, 1.0f, ((float)dfp[a]/(float)(range?range:1))*0.8f);
+ if (Items[a].first->dim.y > Items[a].first->dim.x) {
+ Render::drawRect(vec2(r.end.x-((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y-(itemWide/2)),
+ vec2(r.end.x+((itemWide/2)*((float)Items[a].first->dim.x/(float)Items[a].first->dim.y)), r.end.y+(itemWide/2)), -6.1);
+ } else {
+ Render::drawRect(vec2(r.end.x-(itemWide/2),r.end.y-(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)),
+ vec2(r.end.x+(itemWide/2),r.end.y+(itemWide/2)*((float)Items[a].first->dim.y/(float)Items[a].first->dim.x)), -6.1);
+ }
+ ui::setFontColor(255,255,255,((float)dfp[a]/(float)(range?range:1))*255);
+ ui::putStringCentered(r.end.x,r.end.y-(itemWide*.9),Items[a].first->name);//itemMap[items[a].id]->name);
+ ui::putText(r.end.x-(itemWide/2)+(itemWide*.85),r.end.y-(itemWide/2),"%d",Items[a].second);
+ ui::setFontColor(255,255,255,255);
+ }
+ Render::textShader.unuse();
+ if (sel == a) {
+ static float sc = 1;
+ static bool up;
+ up ? sc += .0025*deltaTime : sc -= .0025*deltaTime;
+ if (sc > 1.2) {
+ up = false;
+ sc = 1.2;
+ }
+ if (sc < 1.0) {
+ up = true;
+ sc = 1.0;
+ }
+ float t = ((float)dfp[a]/(float)(range?range:1));
+ Render::useShader(&Render::textShader);
+
+ Render::textShader.use();
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+
+ // bottom
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2), -6.2);
+
+ // top
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2), -6.2);
+
+ // left
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
+ Render::drawRect(vec2(r.end.x - (itemWide*sc)/2 - (itemWide*sc)*.09,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x - (itemWide*sc)/2 ,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
+
+ // right
+ glBindTexture(GL_TEXTURE_2D, Texture::genColor(Color(255, 255, 255, t >= 0 ? 255 * t : 0)));
+ Render::drawRect(vec2(r.end.x + (itemWide*sc)/2 ,r.end.y - (itemWide*sc)/2 - (itemWide*sc)*.09),
+ vec2(r.end.x + (itemWide*sc)/2 + (itemWide*sc)*.09,r.end.y + (itemWide*sc)/2 + (itemWide*sc)*.09), -6.2);
+
+ //glUseProgram(0);
+ }
+ a++;
+ }
+ } /*else if (invHover) {
+ static unsigned int highlight = 0;
+ static unsigned int thing = 0;
+
+ if (!mouseSel) {
+ // setup?
+ mouseStart.x = ui::mouse.x - offset.x;
+ highlight = sel;
+ thing = sel;
+ mouseSel = true;
+ } else {
+ if((ui::mouse.x - offset.x) >= mouseStart.x){
+ thing = (ui::mouse.x - offset.x - mouseStart.x)/80;
+ highlight=sel+thing;
+ if(highlight>numSlot-1)highlight=numSlot-1;
+ if(SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT)){
+ sel = highlight;
+ mouseSel=false;
+ invHover=false;
+ selected = true;
+ }
+ }
+ if ((ui::mouse.x - offset.x) < mouseStart.x) {
+ thing = (mouseStart.x - (ui::mouse.x - offset.x))/80;
+ if ((int)sel - (int)thing < 0)
+ highlight = 0;
+ else
+ highlight = sel - thing;
+ if(SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT)){
+ sel = highlight;
+ mouseSel=false;
+ invHover=false;
+ selected = true;
+ }
+ }
+ }
+
+ a = 0;
+ for (auto &r : iray) {
+ angle = 180 - (angleB * a) - angleB / 2.0f;
+ curCoord[a].x += float(range) * cos(angle*PI/180);
+ curCoord[a].y += float(range) * sin(angle*PI/180);
+ r.end = curCoord[a];
+
+ // square drawing
+ glColor4f(0.0f, 0.0f, 0.0f, a == highlight ? 0.5f : 0.1f);
+ glBegin(GL_QUADS);
+ glVertex2i(r.end.x-(itemWide/2), r.end.y-(itemWide/2));
+ glVertex2i(r.end.x+(itemWide/2), r.end.y-(itemWide/2));
+ glVertex2i(r.end.x+(itemWide/2), r.end.y+(itemWide/2));
+ glVertex2i(r.end.x-(itemWide/2), r.end.y+(itemWide/2));
+ glEnd();
+
+ if (a < items.size() && items[a].count) {
+ glEnable(GL_TEXTURE_2D);
+ glBindTexture(GL_TEXTURE_2D, itemtex[items[a].id]);
+ glColor4f(1.0f, 1.0f, 1.0f, a == highlight ? 0.8f : 0.2f);
+ glBegin(GL_QUADS);
+ if(itemMap[items[a].id]->height > itemMap[items[a].id]->width){
+ glTexCoord2i(0,1);glVertex2i(r.end.x-((itemWide/2)*((float)itemMap[items[a].id]->width/(float)itemMap[items[a].id]->height)),r.end.y-(itemWide/2));
+ glTexCoord2i(1,1);glVertex2i(r.end.x+((itemWide/2)*((float)itemMap[items[a].id]->width/(float)itemMap[items[a].id]->height)),r.end.y-(itemWide/2));
+ glTexCoord2i(1,0);glVertex2i(r.end.x+((itemWide/2)*((float)itemMap[items[a].id]->width/(float)itemMap[items[a].id]->height)),r.end.y+(itemWide/2));
+ glTexCoord2i(0,0);glVertex2i(r.end.x-((itemWide/2)*((float)itemMap[items[a].id]->width/(float)itemMap[items[a].id]->height)),r.end.y+(itemWide/2));
+ }else{
+ glTexCoord2i(0,1);glVertex2i(r.end.x-(itemWide/2),r.end.y-(itemWide/2)*((float)itemMap[items[a].id]->height/(float)itemMap[items[a].id]->width));
+ glTexCoord2i(1,1);glVertex2i(r.end.x+(itemWide/2),r.end.y-(itemWide/2)*((float)itemMap[items[a].id]->height/(float)itemMap[items[a].id]->width));
+ glTexCoord2i(1,0);glVertex2i(r.end.x+(itemWide/2),r.end.y+(itemWide/2)*((float)itemMap[items[a].id]->height/(float)itemMap[items[a].id]->width));
+ glTexCoord2i(0,0);glVertex2i(r.end.x-(itemWide/2),r.end.y+(itemWide/2)*((float)itemMap[items[a].id]->height/(float)itemMap[items[a].id]->width));
+ }
+ glEnd();
+ glDisable(GL_TEXTURE_2D);
+ }
+ a++;
+ }
+
+ if (highlight < items.size()) {
+ ui::putStringCentered(player->loc.x + player->width / 2,
+ player->loc.y + range * 0.75f,
+ itemMap[items[highlight].id]->name
+ );
+ }
+ }*/
+ /*if (!items.empty() && items.size() > sel && items[sel].count)
+ itemDraw(player,items[sel].id);*/
+ if (!Items.empty() && Items.size() > sel && Items[sel].second)
+ itemDraw(player, Items[sel].first);
+}
+
+void itemDraw(Player *p, Item *d) {
+
+ itemLoc.y = p->loc.y+(p->height/3);
+ itemLoc.x = p->left?p->loc.x-d->dim.x/2:p->loc.x+p->width-d->dim.x/2;
+
+ Render::worldShader.use();
+
+ if (p->left) {
+ // move to center of screen
+ glm::mat4 tro = glm::translate(glm::mat4(1.0f),
+ glm::vec3(itemLoc.x+d->dim.x/2, itemLoc.y, 0));
+ // rotate off center
+ glm::mat4 rot = glm::rotate(glm::mat4(1.0f),
+ static_cast<GLfloat>((d->rotation*3.14159)/180.0f),
+ glm::vec3(0.0f, 0.0f, 1.0f));
+ // move back to player
+ glm::mat4 trt = glm::translate(glm::mat4(1.0f),
+ glm::vec3(-itemLoc.x-d->dim.x/2, -itemLoc.y, 0));
+ // tell shader to translate the object using steps above
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
+ } else {
+ // move to center of screen
+ glm::mat4 tro = glm::translate(glm::mat4(1.0f),
+ glm::vec3(itemLoc.x+d->dim.x/2,itemLoc.y,0));
+ // rotate off center
+ glm::mat4 rot = glm::rotate(glm::mat4(1.0f),
+ static_cast<GLfloat>((d->rotation*3.14159)/180.0f),
+ glm::vec3(0.0f, 0.0f, 1.0f));
+ // move back to player
+ glm::mat4 trt = glm::translate(glm::mat4(1.0f),
+ glm::vec3(-itemLoc.x-d->dim.x/2,-itemLoc.y,0));
+ // tell shader to translate the object using steps above
+ glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(tro * rot * trt));
+ }
+
+ GLfloat itemTex[12] = {0.0, 0.0,
+ 1.0, 0.0,
+ 1.0, 1.0,
+
+ 1.0, 1.0,
+ 0.0, 1.0,
+ 0.0, 0.0};
+ if (!p->left) {
+ itemTex[0] = 1.0;
+ itemTex[2] = 0.0;
+ itemTex[4] = 0.0;
+ itemTex[6] = 0.0;
+ itemTex[8] = 1.0;
+ itemTex[10] = 1.0;
+ }
+
+ GLfloat itemCoords[] = {itemLoc.x, itemLoc.y, p->z,
+ itemLoc.x+d->dim.x, itemLoc.y, p->z,
+ itemLoc.x+d->dim.x, itemLoc.y+d->dim.y, p->z,
+
+ itemLoc.x+d->dim.x, itemLoc.y+d->dim.y, p->z,
+ itemLoc.x, itemLoc.y+d->dim.y, p->z,
+ itemLoc.x, itemLoc.y, p->z};
+
+ glBindTexture(GL_TEXTURE_2D,d->tex->image[0]);
+
+ Render::worldShader.enable();
+
+ glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, itemCoords);
+ glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, itemTex);
+ glDrawArrays(GL_TRIANGLES, 0, 6);
+
+ Render::worldShader.disable();
+ Render::worldShader.unuse();
+}
+
+/*
+ * This function is used to trigger the player's item's ability.
+ */
+int Inventory::useItem(void)
+{
+ return 0;
+}
+
+int Inventory::useCurrent()
+{
+ if (Items[sel].second)
+ return Items[sel].first->useItem();
+ return -1;
+}
+
+void Inventory::currentAddInteract(Entity* e)
+{
+ if (Items[sel].second)
+ Items[sel].first->addInteract(e);
+}
+
+void Inventory::currentAddInteract(std::vector<Entity*> e)
+{
+ if (Items[sel].second)
+ Items[sel].first->addInteract(e);
+}
+
+bool Inventory::detectCollision(vec2 one, vec2 two) {
+ (void)one;
+ (void)two;
+ return false;
+}
+
+const Item* Inventory::getCurrentItem(void)
+{
+ if (Items.size() > 0)
+ return Items[sel].first;
+ else
+ return nullptr;
+}
+
+void InventorySystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+ (void)en;
+ (void)ev;
+ (void)dt;
+}
+
+void InventorySystem::configure(entityx::EventManager &em)
+{
+ em.subscribe<MouseScrollEvent>(*this);
+}
+
+void InventorySystem::receive(const MouseScrollEvent &mse)
+{
+ static int mouseWheelUpCount = 0, mouseWheelDownCount = 0;
+
+ if ((mse.scrollDistance < 0) && ((++mouseWheelUpCount % 5) == 0) ) {
+ mouseWheelUpCount = 0;
+ player->inv->setSelectionUp();
+ } else if ( (++mouseWheelDownCount % 5) == 0 ) {
+ mouseWheelDownCount = 0;
+ player->inv->setSelectionDown();
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-05 16:05:12 +0000