component reorginization; entity flashes

4 files changed, 420 insertions, 0 deletions

diff --git a/src/systems/dialog.cpp b/src/systems/dialog.cpp
new file mode 100644
index 0000000..0be0acb
--- /dev/null
+++ b/src/systems/dialog.cpp
@@ -0,0 +1,161 @@
+#include <systems/dialog.hpp>
+
+#include <components/position.hpp>
+#include <components/solid.hpp>
+#include <components/dialog.hpp>
+#include <components/flash.hpp>
+#include <components/name.hpp>
+#include <components/direction.hpp>
+
+#include <brice.hpp>
+#include <engine.hpp>
+#include <fileio.hpp>
+#include <quest.hpp>
+#include <thread.hpp>
+#include <ui.hpp>
+#include <world.hpp>
+
+#include <string>
+#include <vector>
+
+static std::vector<std::string> randomDialog (readFileA("assets/dialog_en-us"));
+
+void DialogSystem::configure(entityx::EventManager &ev)
+{
+	ev.subscribe<MouseClickEvent>(*this);
+}
+
+void DialogSystem::receive(const MouseClickEvent &mce)
+{
+	game::entities.each<Position, Solid, Dialog, Name>(
+		[&](entityx::Entity e, Position &pos, Solid &dim, Dialog &d, Name &name) {
+			static std::atomic_bool dialogRun;
+			(void)e;
+			(void)d;
+
+			if (((mce.position.x > pos.x) & (mce.position.x < pos.x + dim.width)) &&
+			    ((mce.position.y > pos.y) & (mce.position.y < pos.y + dim.height))) {
+
+			if (e.has_component<Flash>())
+				e.remove<Flash>();
+			e.assign<Flash>(Color(0, 255, 255));
+
+			if (!dialogRun.load()) {
+				// copy entity, windows destroys the original after thread detach
+				std::thread([e, &pos, &dim, &d, &name] {
+					std::string questAssignedText;
+					int newIndex;
+
+					auto exml = WorldSystem::getXML()->FirstChildElement("Dialog");
+					dialogRun.store(true);
+
+					if (e.has_component<Direction>())
+						d.talking = true;
+
+					if (d.index == 9999) {
+						UISystem::dialogBox(name.name, /*"", false,*/ randomDialog[d.rindex % randomDialog.size()]);
+						UISystem::waitForDialog();
+					} else if (exml != nullptr) {
+						while (exml->StrAttribute("name") != name.name)
+							exml = exml->NextSiblingElement();
+
+						exml = exml->FirstChildElement("text");
+						while (exml->IntAttribute("id") != d.index)
+							exml = exml->NextSiblingElement();
+
+						auto oxml = exml->FirstChildElement("set");
+						if (oxml != nullptr) {
+							do game::setValue(oxml->StrAttribute("id"), oxml->StrAttribute("value"));
+							while ((oxml = oxml->NextSiblingElement()));
+							game::briceUpdate();
+						}
+
+						auto ixml = exml->FirstChildElement("give");
+						if (ixml != nullptr) {
+							do {
+								InventorySystem::add(ixml->StrAttribute("name"), ixml->IntAttribute("count"));
+								ixml = ixml->NextSiblingElement();
+							} while (ixml != nullptr);
+						}
+
+						auto qxml = exml->FirstChildElement("quest");
+						if (qxml != nullptr) {
+							const char *qname;
+
+							do {
+								// assign quest
+								qname = qxml->Attribute("assign");
+								if (qname != nullptr) {
+									questAssignedText = qname;
+									auto req = qxml->GetText();
+									QuestSystem::assign(qname, qxml->StrAttribute("desc"), req ? req : "");
+								}
+
+								// check / finish quest
+								else {
+									qname = qxml->Attribute("check");
+									if (qname != nullptr) {
+										if (qname != nullptr && QuestSystem::finish(qname) == 0) {
+											d.index = 9999;
+										} else {
+											UISystem::dialogBox(name.name, /*"", false,*/ "Finish my quest u nug");
+											UISystem::waitForDialog();
+											return;
+										}
+									//	oldidx = d.index;
+									//	d.index = qxml->UnsignedAttribute("fail");
+									//	goto COMMONAIFUNC;
+									}
+								}
+							} while((qxml = qxml->NextSiblingElement()));
+						}
+
+						auto xxml = exml->FirstChildElement("option");
+						std::string options;
+						std::vector<int> optionNexts;
+						if (xxml != nullptr) {
+							do {
+								UISystem::dialogAddOption(xxml->StrAttribute("name"));
+
+								options += '\"' + xxml->StrAttribute("name");
+								optionNexts.emplace_back(xxml->IntAttribute("value"));
+								xxml = xxml->NextSiblingElement();
+							} while (xxml != nullptr);
+						}
+
+						auto cxml = exml->FirstChildElement("content");
+						const char *content;
+						if (cxml == nullptr) {
+							content = randomDialog[d.rindex % randomDialog.size()].c_str();
+						} else {
+							content = cxml->GetText() - 1;
+							while (*++content && isspace(*content));
+						}
+
+						UISystem::dialogBox(name.name, /*options, false,*/ content);
+						UISystem::waitForDialog();
+						UISystem::waitForDialog();
+
+						if (!questAssignedText.empty())
+							UISystem::dialogImportant("Quest assigned:\n\"" + questAssignedText + "\"");
+							//passiveImportantText(5000, ("Quest assigned:\n\"" + questAssignedText + "\"").c_str());
+
+						if (exml->QueryIntAttribute("nextid", &newIndex) == XML_NO_ERROR)
+							d.index = newIndex;
+					}
+
+					d.talking = false;
+					dialogRun.store(false);
+				}).detach();
+			}
+		}
+	});
+}
+
+void DialogSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+	(void)en;
+	(void)ev;
+	(void)dt;
+}
+
diff --git a/src/systems/movement.cpp b/src/systems/movement.cpp
new file mode 100644
index 0000000..00baa40
--- /dev/null
+++ b/src/systems/movement.cpp
@@ -0,0 +1,98 @@
+#include <systems/movement.hpp>
+
+#include <components/position.hpp>
+#include <components/direction.hpp>
+#include <components/solid.hpp>
+#include <components/animate.hpp>
+#include <components/sprite.hpp>
+#include <components/aggro.hpp>
+#include <components/dialog.hpp>
+
+#include <thread>
+
+#include <attack.hpp>
+#include <events.hpp>
+#include <player.hpp>
+#include <ui.hpp>
+
+void MovementSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+	//bool fight = false;
+	entityx::Entity toFight;
+
+	(void)ev;
+	en.each<Position, Direction>([&](entityx::Entity entity, Position &position, Direction &direction) {
+		position.x += HLINES(direction.x) * dt;
+		position.y += HLINES(direction.y) * dt;
+
+		if (entity.has_component<Animate>() && entity.has_component<Sprite>()) {
+			auto animate = entity.component<Animate>();
+			auto sprite =  entity.component<Sprite>();
+		
+			if (direction.x)	
+				animate->updateAnimation(1, sprite->sprite, dt);
+			else
+				animate->firstFrame(1, sprite->sprite);
+		}
+		if (entity.has_component<Dialog>() && entity.component<Dialog>()->talking) {
+			direction.x = 0;
+		} else {
+			if (entity.has_component<Sprite>()) {
+				auto& fl = entity.component<Sprite>()->faceLeft;
+				if (direction.x != 0)
+					fl = (direction.x < 0);
+			}
+
+			auto ppos = PlayerSystem::getPosition();
+			if (ppos.x > position.x && ppos.x < position.x + entity.component<Solid>()->width) {
+				if (entity.has_component<Aggro>()) {
+					auto dim = entity.component<Solid>();
+					ev.emit<AttackEvent>(vec2(position.x + dim->width, position.y + dim->height),
+						AttackType::ShortSlash, false);
+					/*auto& h = entity.component<Health>()->health;
+					if (h > 0) {
+						fight = true;
+						toFight = entity;
+						h = 0;
+					}*/
+				} else if (entity.has_component<Trigger>()) {
+					static bool triggering = false;
+					if (!triggering) {
+						triggering = true;
+						std::thread([&](entityx::Entity e) {
+							UISystem::fadeToggle();
+							UISystem::waitForCover();
+							UISystem::dialogImportant(e.component<Trigger>()->text);
+							UISystem::waitForDialog();
+							UISystem::fadeToggle();
+							e.destroy();
+							triggering = false;
+						}, entity).detach();
+					}
+					return;
+				}
+			}
+
+			// make the entity wander
+			// TODO initialX and range?
+			if (entity.has_component<Wander>()) {
+				auto& countdown = entity.component<Wander>()->countdown;
+
+				if (countdown > 0) {
+					countdown--;
+				} else {
+					countdown = 5000 + randGet() % 10 * 100;
+					direction.x = (randGet() % 3 - 1) * 0.004f;
+				}
+			}
+		}
+	});
+
+//	if (fight) {
+//		UISystem::fadeToggleFast();
+//		UISystem::waitForCover();
+		//game::engine.getSystem<WorldSystem>()->fight(toFight);
+//		UISystem::fadeToggleFast();
+//	}
+}
+
diff --git a/src/systems/physics.cpp b/src/systems/physics.cpp
new file mode 100644
index 0000000..4cee110
--- /dev/null
+++ b/src/systems/physics.cpp
@@ -0,0 +1,15 @@
+#include <systems/physics.hpp>
+
+#include <components/direction.hpp>
+#include <components/physics.hpp>
+
+void PhysicsSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+	(void)ev;
+	en.each<Direction, Physics>([dt](entityx::Entity entity, Direction &direction, Physics &physics) {
+		(void)entity;
+		// TODO GET GRAVITY FROM WORLD
+		direction.y += physics.g * dt;
+	});
+}
+
diff --git a/src/systems/render.cpp b/src/systems/render.cpp
new file mode 100644
index 0000000..ce79522
--- /dev/null
+++ b/src/systems/render.cpp
@@ -0,0 +1,146 @@
+#include <systems/render.hpp>
+
+#include <components/visible.hpp>
+#include <components/sprite.hpp>
+#include <components/position.hpp>
+#include <components/solid.hpp>
+#include <components/flash.hpp>
+
+#include <thread>
+#include <chrono>
+using namespace std::literals::chrono_literals;
+
+#include <glm.hpp>
+#include <render.hpp>
+#include <engine.hpp>
+#include <font.hpp>
+#include <ui.hpp>
+
+std::string RenderSystem::loadTexString;
+Texture     RenderSystem::loadTexResult;
+
+Texture RenderSystem::loadTexture(const std::string& file)
+{
+	loadTexString = file;
+	loadTexResult = Texture();
+	while (loadTexResult.isEmpty())
+		std::this_thread::sleep_for(1ms);
+	auto t = loadTexResult;
+	loadTexResult = Texture();
+	return t;
+}
+
+void RenderSystem::render(void)
+{	
+	if (!loadTexString.empty()) {
+		loadTexResult = Texture(loadTexString, false);
+		loadTexString.clear();
+	}
+
+	if (!loadTexResult.isEmpty())
+		return;
+
+	Render::worldShader.use();
+	Render::worldShader.enable();
+
+	game::entities.each<Visible, Sprite, Position>([](entityx::Entity entity, Visible &visible, Sprite &sprite, Position &pos) {
+		// Verticies and shit
+		float its = 0;
+		
+		float sz;
+		if (entity.has_component<Solid>())
+			sz = entity.component<Solid>()->width;
+		else 
+			sz = sprite.getSpriteSize().x;
+
+		if (sprite.faceLeft) {
+			glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(-1.0f,1.0f,1.0f));
+			glm::mat4 translate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f - sz - pos.x * 2.0f, 0.0f, 0.0f));
+
+			glm::mat4 mov = scale * translate;
+			glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(mov));
+		}
+
+		for (auto &S : sprite.sprite) {
+			auto sp = S.first;
+			auto size = sp.size * game::HLINE;
+			vec2 drawOffset (HLINES(S.second.x), HLINES(S.second.y));
+			vec2 loc (pos.x + drawOffset.x, pos.y + drawOffset.y);
+
+			GLfloat verts[] = {
+				loc.x,          loc.y,          visible.z + its, sp.offset_tex.x,                 sp.offset_tex.y,
+				loc.x + size.x,	loc.y,          visible.z + its, sp.offset_tex.x + sp.size_tex.x, sp.offset_tex.y,
+				loc.x + size.x, loc.y + size.y, visible.z + its, sp.offset_tex.x + sp.size_tex.x, sp.offset_tex.y + sp.size_tex.y,
+				loc.x,          loc.y,          visible.z + its, sp.offset_tex.x,                 sp.offset_tex.y,
+				loc.x + size.x, loc.y + size.y, visible.z + its, sp.offset_tex.x + sp.size_tex.x, sp.offset_tex.y + sp.size_tex.y,
+				loc.x,          loc.y + size.y, visible.z + its, sp.offset_tex.x,                 sp.offset_tex.y + sp.size_tex.y
+			};
+
+			sp.tex.use();
+
+			glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+
+			glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), verts);
+			glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), verts + 3);
+			glDrawArrays(GL_TRIANGLES, 0, 6);
+
+			if (entity.has_component<Flash>()) {
+				auto& f = *entity.component<Flash>();
+				if (f.ms > 0) {
+					verts[2] = verts[7] = verts[12] = verts[17] = verts[22] = verts[27] = visible.z + its - 0.001f;
+					float alpha = static_cast<float>(f.ms) / static_cast<float>(f.totalMs);
+					glUniform4f(Render::worldShader.uniform[WU_tex_color], f.color.red, f.color.green, f.color.blue, alpha);
+					glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), verts);
+					glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), verts + 3);
+					glDrawArrays(GL_TRIANGLES, 0, 6);
+					glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+				}
+			}
+
+			its-=.01;
+		}
+		glUniformMatrix4fv(Render::worldShader.uniform[WU_transform], 1, GL_FALSE, glm::value_ptr(glm::mat4(1.0f)));
+
+		if (entity.has_component<Health>()) {
+			float width = entity.component<Solid>()->width;
+			auto& health = *entity.component<Health>();
+			width *= health.health / static_cast<float>(health.maxHealth);
+
+			GLfloat health_coord[] = {
+				pos.x, pos.y, -9, 0, 0,
+				pos.x + width, pos.y, -9, 0, 0,
+				pos.x + width, pos.y - 5, -9, 0, 0,
+				pos.x + width, pos.y - 5, -9, 0, 0,
+				pos.x, pos.y - 5, -9, 0, 0,
+				pos.x, pos.y, -9, 0, 0,
+			};
+
+			Colors::red.use();
+			glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), health_coord);
+			glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), health_coord + 3);
+			glDrawArrays(GL_TRIANGLES, 0, 6);
+		}
+	});
+
+	Render::worldShader.disable();
+	Render::worldShader.unuse();
+
+	game::entities.each<Visible, Position, Solid, Name>([](entityx::Entity e, Visible &v, Position &pos, Solid& dim, Name &name) {
+		(void)e;
+		(void)v;
+		FontSystem::setFontZ(-5.0f);
+		UISystem::putStringCentered(vec2(pos.x + dim.width / 2, pos.y - FontSystem::getSize() - HLINES(0.5)), name.name);
+	});
+}
+
+void RenderSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+	(void)ev;
+	(void)dt;
+
+	en.each<Flash>([](entityx::Entity e, Flash& flash) {
+		if (--flash.ms <= 0) // TODO delta time?
+			e.remove<Flash>();
+	});
+}
+