<item name="Crude Arrow" type="Arrow" damage="1" maxStackSize="99" sprite="assets/items/arrow_crude.png"/>
<!-- UTILITIES -->
-<item name="Rusty Lantern" type="Light" radius="150" color="255|255|255" sprite="assets/items/rusty_lantern.png"/>
+<!--<item name="Rusty Lantern" type="Light" radius="150" color="255|255|255" sprite="assets/items/rusty_lantern.png"/>-->
<item name="Mossy Torch" type="Light" fire="true" radius="150" color="245|220|200" sprite="assets/items/basic_torch.png"/>
#include <components.hpp>
#include <events.hpp>
-struct Item {
- GLuint icon;
+struct InventoryEntry {
+ GLuint icon;
+ std::string name;
+ std::string type;
+
+ int count;
+ int max;
+ vec2 loc;
};
-using InventoryEntry = std::pair<Item, unsigned int>;
-
class InventorySystem : public entityx::System<InventorySystem>, public entityx::Receiver<InventorySystem> {
private:
entityx::Entity currentItemEntity;
std::vector<InventoryEntry> items;
- unsigned int maxItemCount;
public:
- InventorySystem(unsigned int mic = 1)
- : maxItemCount(mic) {}
+ InventorySystem(int size = 4) {
+ items.resize(size);
+ loadItems();
+ }
void configure(entityx::EventManager &ev);
- void loadIcons(void);
+ void loadItems(void);
void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
void receive(const KeyDownEvent &kde);
+ void render(void);
};
#endif // INVENTORY_HPP_
#include <entityx/entityx.h>
enum class ParticleType : char {
- Drop,
- Confetti,
- SmallBlast,
- SmallPoof
+ Drop = 1,
+ Confetti = 2,
+ SmallBlast = 4,
+ SmallPoof = 8
};
struct Particle {
- vec2 location;
+ int timeLeft;
vec2 velocity;
+ vec2 location;
ParticleType type;
- int timeLeft;
vec2 color; // assets/colorIndex.png
Particle(vec2 p, ParticleType t, int tl, vec2 c)
- : location(p), type(t), timeLeft(tl), color(c) {}
-};// __attribute__ ((packed));
+ : timeLeft(tl), location(p), type(t), color(c) {}
+};
class ParticleSystem : public entityx::System<ParticleSystem> {
private:
newPartDelay = 0;
partSystem.add(vec2(offset.x - game::SCREEN_WIDTH + randGet() % game::SCREEN_WIDTH * 2,
offset.y + game::SCREEN_HEIGHT / 2 + 50),
- ParticleType::Confetti, 6000, 0);
+ ParticleType::Confetti, 10000, 0);
}
break;
default:
systems.add<WindowSystem>();
systems.add<RenderSystem>();
systems.add<InputSystem>();
- //systems.add<InventorySystem>();
+ systems.add<InventorySystem>();
systems.add<WorldSystem>();
systems.add<PlayerSystem>();
systems.add<QuestSystem>();
#include <common.hpp>
#include <events.hpp>
-//#include <texture.hpp>
-//#include <render.hpp>
+#include <texture.hpp>
+#include <render.hpp>
-constexpr const char* iconTexturePath = "config/invIcons.txt";
+#include <deque>
-static std::vector<Texture> iconTextures;
+#include <tinyxml2.h>
+using namespace tinyxml2;
+
+constexpr const char* itemsPath = "config/items.xml";
+
+
+struct Item {
+ std::string name;
+ std::string type;
+ int value;
+ int stackSize;
+ Texture sprite;
+
+ Item(void)
+ : value(0), stackSize(1) {}
+
+ Item(XMLElement *e) {
+ name = e->StrAttribute("name");
+ type = e->StrAttribute("type");
+
+ value = 0;
+ e->QueryIntAttribute("value", &value);
+ stackSize = 1;
+ e->QueryIntAttribute("maxStackSize", &stackSize);
+
+ sprite = Texture(e->StrAttribute("sprite"));
+ }
+};
+
+static std::deque<Item> itemList;
void InventorySystem::configure(entityx::EventManager &ev)
{
ev.subscribe<KeyDownEvent>(*this);
}
-void InventorySystem::loadIcons(void) {
- iconTextures.clear();
- auto icons = readFileA(iconTexturePath);
- for (const auto& s : icons)
- iconTextures.push_back(s);
+void InventorySystem::loadItems(void) {
+ XMLDocument doc;
+ doc.LoadFile(itemsPath);
+
+ auto item = doc.FirstChildElement("item");
+ if (item == nullptr)
+ UserError("No items found");
+
+ do {
+ itemList.emplace_back(item);
+ item = item->NextSiblingElement("item");
+ } while (item != nullptr);
}
void InventorySystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
(void)en;
(void)ev;
(void)dt;
+}
- // TODO TODO TODO TODO until we do something
- return;
+void InventorySystem::render(void)
+{
+ Render::textShader.use();
+ Render::textShader.enable();
+ Colors::black.use();
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1, 1, 1, .8);
- //vec2 start = vec2(offset.x, 100);// - game::SCREEN_WIDTH / 2 + 20, game::SCREEN_HEIGHT - 40);
+ // calculate positions
+ items.front().loc = vec2(offset.x - 35 * items.size(), offset.y - game::SCREEN_HEIGHT / 2);
+ for (unsigned int i = 1; i < items.size(); i++)
+ items[i].loc = vec2(items[i - 1].loc.x + 70, items[i - 1].loc.y);
- //std::cout << start.x << ' ' << start.y << std::endl;
+ // draw items
+ for (const auto& i : items) {
+ glVertexAttribPointer(Render::textShader.tex, 2, GL_FLOAT, GL_FALSE, 0, Colors::texCoord);
+ vec2 end = i.loc + 64;
+ GLfloat coords[18] = {
+ i.loc.x, i.loc.y, -9, end.x, i.loc.y, -9, end.x, end.y, -9,
+ end.x, end.y, -9, i.loc.x, end.y, -9, i.loc.x, i.loc.y, -9
+ };
+ glVertexAttribPointer(Render::textShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
+ glDrawArrays(GL_TRIANGLES, 0, 6);
+ }
- /*Render::textShader.use();
- glActiveTexture(GL_TEXTURE0);
- Colors::black.use();
- Render::useShader(&Render::textShader);
- Render::drawRect(start, start + 20, -9.9f);
- Render::textShader.unuse();*/
+ glUniform4f(Render::textShader.uniform[WU_tex_color], 1, 1, 1, 1);
+ Render::textShader.disable();
+ Render::textShader.unuse();
}
void InventorySystem::receive(const KeyDownEvent &kde)
auto& p = parts[i];
// update timers
- p.timeLeft -= dt;
+ if (p.timeLeft > 0)
+ p.timeLeft -= dt;
+ else
+ continue;
// update movement
+ auto& vel = p.velocity;
switch (p.type) {
case ParticleType::Drop:
- if (p.velocity.y > -.6)
- p.velocity.y -= 0.001f;
+ if (vel.y > -.6)
+ vel.y -= 0.001f;
break;
case ParticleType::Confetti:
- if (p.velocity.x > -0.01 && p.velocity.x < 0.01) {
- p.velocity.x = randGet() % 12 / 30.0f - 0.2f;
+ if (vel.x > -0.01 && vel.x < 0.01) {
+ vel.x = randGet() % 12 / 30.0f - 0.2f;
+ vel.y = -0.15f;
} else {
- p.velocity.x += (p.velocity.x > 0) ? -0.002f : 0.002f;
+ vel.x += (vel.x > 0) ? -0.002f : 0.002f;
}
- p.velocity.y = -0.15f;
- p.timeLeft = 1000;
break;
case ParticleType::SmallBlast:
- if (p.velocity.x == 0) {
+ if (vel.x == 0) {
int degree = randGet() % 100;
- p.velocity.x = cos(degree) / 4.0f;
- p.velocity.y = sin(degree) / 4.0f;
+ vel.x = cos(degree) / 4.0f;
+ vel.y = sin(degree) / 4.0f;
} else {
- p.velocity.x += (p.velocity.x > 0) ? -0.001f : 0.001f;
- p.velocity.y += (p.velocity.y > 0) ? -0.001f : 0.001f;
- if ((p.velocity.x > -0.01 && p.velocity.x < 0.01) &&
- (p.velocity.y > -0.01 && p.velocity.y < 0.01)) {
+ vel.x += (vel.x > 0) ? -0.001f : 0.001f;
+ vel.y += (vel.y > 0) ? -0.001f : 0.001f;
+ if ((vel.x > -0.01 && vel.x < 0.01) &&
+ (vel.y > -0.01 && vel.y < 0.01)) {
p.timeLeft = 0;
}
}
-
break;
case ParticleType::SmallPoof:
- if (p.velocity.x == 0) {
- p.velocity.y = 0.1f;
- p.velocity.x = randGet() % 10 / 20.0f - 0.25f;
+ if (vel.x == 0) {
+ vel.y = 0.1f;
+ vel.x = randGet() % 10 / 20.0f - 0.25f;
} else {
- p.velocity.x += (p.velocity.x > 0) ? -0.001f : 0.001f;
- p.velocity.y -= 0.0015f;
+ vel.x += (vel.x > 0) ? -0.001f : 0.001f;
+ vel.y -= 0.0015f;
}
break;
}
// really update movement
- p.location.x += p.velocity.x * dt;
- p.location.y += p.velocity.y * dt;
+ p.location.x += vel.x * dt;
+ p.location.y += vel.y * dt;
// world collision
auto height = worldSystem.isAboveGround(p.location);
} // namespace render
-#include <ui.hpp>
-#include <window.hpp>
-#include <world.hpp>
#include <engine.hpp>
+#include <gametime.hpp>
+#include <inventory.hpp>
#include <particle.hpp>
#include <player.hpp>
+#include <ui.hpp>
+#include <window.hpp>
+#include <world.hpp>
+
#include <entityx/entityx.h>
-#include <gametime.hpp>
void preRender(void)
{
game::engine.getSystem<RenderSystem>()->render();
+ game::engine.getSystem<InventorySystem>()->render();
+
// draw the debug overlay if desired
if (ui::debug) {
auto pos = game::engine.getSystem<PlayerSystem>()->getPosition();
"brazzier.png"
};
-// alpha-related values used for world drawing? nobody knows...
-static const float bgDraw[4][3]={
- { 100, 240, 0.6 },
- { 150, 250, 0.4 },
- { 200, 255, 0.25 },
- { 255, 255, 0.1 }
-};
-
/* ----------------------------------------------------------------------------
** Functions section
** --------------------------------------------------------------------------*/
Render::worldShader.unuse();
// draw the remaining layers
+ static const float alphas[4] = {
+ 0.6, 0.4, 0.25, 0.1
+ };
for (int i = 0; i < 4; i++) {
bgTex++;
- auto xcoord = offset.x * bgDraw[i][2];
+ auto xcoord = offset.x * alphas[i];
bg_items.clear();
bg_tex.clear();
projects / clyne / gamedev.git / commitdiff