removed all old entity stuff

1 files changed, 1352 insertions, 0 deletions

diff --git a/src/entities.cpp.bak b/src/entities.cpp.bak
new file mode 100644
index 0000000..e005df5
--- /dev/null
+++ b/src/entities.cpp.bak
@@ -0,0 +1,1352 @@
+#include <entities.hpp>
+
+#include <istream>
+#include <sstream>
+#include <fstream>
+
+#include <ui.hpp>
+#include <world.hpp>
+#include <gametime.hpp>
+#include <brice.hpp>
+
+#include <render.hpp>
+#include <engine.hpp>
+
+///NEW
+#include <components.hpp>
+#include <entityx/entityx.h>
+///OLD
+
+extern std::istream *names;
+
+extern Player *player;			// main.cpp
+extern World *currentWorld;		// main.cpp
+extern unsigned int loops;		// main.cpp
+
+extern std::string xmlFolder;
+extern XMLDocument currentXMLDoc;
+
+// a dynamic array of pointers to the NPC's that are being assigned the preloads
+std::vector<NPC *> aipreload;
+
+// the size of the player's inventory
+const unsigned int PLAYER_INV_SIZE = 43;
+// the size of an NPC's inventory
+const unsigned int NPC_INV_SIZE = 3;
+
+static std::vector<std::string> randomDialog (readFileA("assets/dialog_en-us"));
+
+
+void PlayerSystem::update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt)
+{
+	(void)en;
+	(void)ev;
+	(void)dt;
+
+	if (!m_MoveLeft && !m_MoveRight)
+		(*m_Player)->vel.x = 0;
+}
+
+void PlayerSystem::configure(entityx::EventManager &ev)
+{
+	ev.subscribe<KeyDownEvent>(*this);
+	ev.subscribe<KeyUpEvent>(*this);
+}
+
+extern World  *currentWorldToLeft;
+extern World  *currentWorldToRight;
+extern bool gameRunning;
+extern bool inBattle;
+
+void PlayerSystem::receive(const KeyUpEvent &kue)
+{
+	auto p = *m_Player;
+	auto kc = kue.keycode;
+
+	if (kc == SDLK_ESCAPE) {
+		ui::menu::toggle();
+		p->save();
+	} else if (kc == getControl(1)) {
+		m_MoveLeft = false;
+	} else if (kc == getControl(2)) {
+		m_MoveRight = false;
+	} else if (kc == getControl(3) || kc == getControl(4)) {
+		player->speed = 1;
+	} else if (kc == getControl(5)) {
+		if (p->inv->invHover) {
+			p->inv->invHover = false;
+		} else {
+			if (!p->inv->selected)
+				p->inv->invOpening ^= true;
+			else
+				p->inv->selected = false;
+
+			p->inv->mouseSel = false;
+		}
+
+		// disable action ui
+		ui::action::disable();
+	}
+}
+
+void PlayerSystem::receive(const KeyDownEvent &kde)
+{
+	auto p = *m_Player;
+	auto kc = kde.keycode;
+
+	auto worldSwitch = [&](const WorldSwitchInfo& wsi){
+		player->canMove = false;
+		ui::toggleBlackFast();
+		ui::waitForCover();
+		game::events.emit<BGMToggleEvent>(wsi.first->bgm, wsi.first);
+		std::tie(currentWorld, player->loc) = wsi; // using p causes segfault
+		game::engine.getSystem<WorldSystem>()->setWorld(currentWorld);
+		ui::toggleBlackFast();
+		ui::waitForUncover();
+		player->canMove = true; // using p causes segfault
+	};
+
+	if ((kc == SDLK_SPACE) && (game::canJump & p->ground)) {
+		p->loc.y += HLINES(2);
+		p->vel.y = .4;
+		p->ground = false;
+	}
+
+	if (!ui::dialogBoxExists || ui::dialogPassive) {
+		if (kc == getControl(0)) {
+			if (inBattle) {
+				std::thread([&](void){
+					auto thing = dynamic_cast<Arena *>(currentWorld)->exitArena(p);
+					if (thing.first != currentWorld)
+						worldSwitch(thing);
+				}).detach();
+			} else if (!ui::fadeIntensity) {
+				std::thread([&](void){
+					auto thing = currentWorld->goInsideStructure(p);
+					if (thing.first != currentWorld)
+						worldSwitch(thing);
+				}).detach();
+			}
+		} else if (kc == getControl(1)) {
+			if (!ui::fadeEnable) {
+				p->vel.x = -PLAYER_SPEED_CONSTANT;
+				if (std::stoi(game::getValue("Slow")) == 1)
+					p->vel.x /= 2.0f;
+				p->left = m_MoveLeft = true;
+				p->right = m_MoveRight = false;
+				if (currentWorldToLeft) {
+					std::thread([&](void){
+						auto thing = currentWorld->goWorldLeft(p);
+						if (thing.first != currentWorld)
+							worldSwitch(thing);
+					}).detach();
+				}
+			}
+		} else if (kc == getControl(2)) {
+			if (!ui::fadeEnable) {
+				p->vel.x = PLAYER_SPEED_CONSTANT;
+				if (std::stoi(game::getValue("Slow")) == 1)
+					p->vel.x /= 2.0f;
+				p->right = m_MoveRight = true;
+				p->left = m_MoveLeft = false;
+				if (currentWorldToRight) {
+					std::thread([&](void){
+						auto thing = currentWorld->goWorldRight(p);
+						if (thing.first != currentWorld)
+							worldSwitch(thing);
+					}).detach();
+				}
+			}
+		} else if (kc == getControl(3)) {
+			if (game::canSprint)
+				p->speed = 2.0f;
+		} else if (kc == getControl(4)) {
+			p->speed = .5;
+		} else if (kc == getControl(5)) {
+			/*static int heyOhLetsGo = 0;
+
+			//edown = true;
+
+			// start hover counter?
+			if (!heyOhLetsGo) {
+				heyOhLetsGo = game::time::getTickCount();
+				p->inv->mouseSel = false;
+			}
+
+			// run hover thing
+			if (game::time::getTickCount() - heyOhLetsGo >= 2 && !(p->inv->invOpen) && !(p->inv->selected)) {
+				p->inv->invHover = true;
+
+				// enable action ui
+				ui::action::enable();
+			}*/
+		}
+	} else if (kc == SDLK_DELETE) {
+		game::endGame();
+	} else if (kc == SDLK_t) {
+		game::time::tick(50);
+	}
+}
+
+
+void getRandomName(Entity *e)
+{
+	auto names = readFileA("assets/names_en-us");
+	auto name = names[randGet() % names.size()];
+
+	// gender is a binary construct
+	e->gender = (name[0] == 'm') ? MALE : FEMALE;
+
+	e->name = &name[1];
+}
+
+Entity::Entity(void)
+{
+	vel = 0;
+	width = 0;
+	height = 0;
+	health = 0;
+	maxHealth = 0;
+	outnabout = 0;
+	targetx = 0.9112001f;
+
+	type = UNKNOWNT;
+
+	// set flags
+	alive      = true;
+	right      = true;
+	left       = false;
+	near       = false;
+	canMove    = true;
+	ground     = false;
+	forcedMove = false;
+	z = 0.0f;
+
+	// clear counters
+	ticksToUse = 0;
+	hitCooldown = 0;
+
+	hitDuration = maxHitDuration = 0;
+
+	inv = nullptr;
+}
+
+// spawns the entity you pass to it based off of coords and global entity settings
+void Entity::spawn(float x, float y)
+{
+	loc.x = x;
+	loc.y = y;
+
+	if (health == 0 && maxHealth == 0)
+		health = maxHealth = 1;
+
+	// generate a name
+	if (type == MOBT)
+		name = "mob";
+	else
+		getRandomName(this);
+
+	setCooldown(0);
+}
+
+void Entity::takeHit(unsigned int _health, unsigned int cooldown)
+{
+	if (hitCooldown <= 1) {
+		// modify variables
+		health = fmax(health - _health, 0);
+		forcedMove = true;
+		hitCooldown = cooldown;
+
+		hitDuration = maxHitDuration = 350.0f;
+
+		// pushback
+		vel.x = player->left ? -0.5f : 0.5f;
+		vel.y = 0.2f;
+	}
+}
+
+unsigned int Entity::coolDown()
+{
+	return hitCooldown;
+}
+
+void Entity::setCooldown(unsigned int c)
+{
+	hitCooldown = c;
+}
+
+void Entity::handleHits(void)
+{
+	hitCooldown = fmax(static_cast<int>(hitCooldown - game::time::getDeltaTime()), 0);
+	hitDuration = fmax(hitDuration - game::time::getDeltaTime(), 0);
+
+	if (!forcedMove)
+		return;
+
+	// reduce knockback
+	if ((vel.x > 0.0005f) || (vel.x < -0.0005f))
+		vel.x *= 0.6f;
+	else
+		forcedMove = false;
+}
+
+void Entity::die(void)
+{
+	alive = false;
+	health = 0;
+
+	/*if (xmle) {
+		xmle->SetAttribute("alive", false);
+		currentXMLDoc.SaveFile(currentXML.c_str(), false);
+	}*/
+}
+
+bool Entity::isAlive(void) const
+{
+	return alive;
+}
+
+bool Entity::isHit(void) const
+{
+	return forcedMove;
+}
+
+void Entity::moveTo(float dest_x)
+{
+	targetx = dest_x;
+}
+
+Player::Player() : Entity()
+{
+	width = HLINES(10);
+	height = HLINES(16);
+
+	type = PLAYERT; //set type to player
+	subtype = 0;
+	health = maxHealth = 100;
+	speed = 1;
+	canMove = true;
+
+	tex = TextureIterator({"assets/player/playerk.png",
+						   "assets/player/playerk1.png",
+						   "assets/player/playerk2.png",
+						   "assets/player/playerk3.png",
+						   "assets/player/playerk4.png",
+						   "assets/player/playerk5.png",
+						   "assets/player/playerk6.png",
+						   "assets/player/playerk7.png",
+						   "assets/player/playerk8.png"
+					       });
+
+	inv = new Inventory(PLAYER_INV_SIZE);
+	dim2 tmpDim = Texture::imageDim(tex.getTexturePath(0));
+	width = HLINES(tmpDim.x/2);
+	height = HLINES(tmpDim.y/2);
+
+	z = -2.0;
+}
+
+Player::~Player()
+{
+	delete inv;
+	delete &tex;
+}
+
+void Player::createFromXML(XMLElement *e, World *w=nullptr)
+{
+	(void)e;
+	(void)w;
+}
+
+void Player::saveToXML(void)
+{}
+
+NPC::NPC() : Entity()
+{
+	width = HLINES(10);
+	height = HLINES(16);
+
+	type	= NPCT; //sets type to npc
+	subtype = 0;
+
+	health = maxHealth = 100;
+
+	maxHealth = health = 100;
+	canMove = true;
+
+	tex = TextureIterator({"assets/NPC.png"});
+	inv = new Inventory(NPC_INV_SIZE);
+
+	randDialog = randGet() % randomDialog.size();
+	dialogIndex = 0;
+	dialogCount = 0;
+
+	dim2 tmpDim = Texture::imageDim(tex.getTexturePath(0));
+	width = HLINES(tmpDim.x/2);
+	height = HLINES(tmpDim.y/2);
+}
+
+NPC::~NPC()
+{
+	delete inv;
+}
+
+void NPC::createFromXML(XMLElement *e, World *w=nullptr)
+{
+	std::string npcname;
+	bool dialog;
+	unsigned int flooor;
+
+	xmle = e;
+	(void)w;
+
+    // spawn at coordinates if desired
+	E_LOAD_COORDS(100);
+
+    // name override
+	if (!(npcname = e->StrAttribute("name")).empty())
+		name = npcname;
+
+    // dialog enabling
+	dialog = false;
+	if (e->QueryBoolAttribute("hasDialog", &dialog) == XML_NO_ERROR && dialog)
+		addAIFunc(false);
+	else
+        dialogIndex = 9999;
+
+    // custom health value
+	E_LOAD_HEALTH;
+
+	// movemenet
+	if (e->QueryBoolAttribute("canMove", &dialog) == XML_NO_ERROR)
+		canMove = dialog;
+
+	// dialog index
+	if (e->QueryUnsignedAttribute("dindex", &flooor) == XML_NO_ERROR)
+		dialogIndex = flooor;
+}
+
+void NPC::saveToXML(void)
+{
+	E_SAVE_HEALTH;
+	E_SAVE_COORDS;
+	xmle->SetAttribute("dindex", dialogIndex);
+}
+
+Merchant::Merchant() : NPC()
+{
+	width = HLINES(10);
+	height = HLINES(16);
+
+	type	= MERCHT; //sets type to merchant
+	subtype = 0;
+
+	health = maxHealth = 100;
+
+	canMove = true;
+
+	trade.reserve(100);
+	currTrade = 0;
+
+	inside = nullptr;
+
+	//tex = new Texturec(1,"assets/NPC.png");
+	//inv = new Inventory(NPC_INV_SIZE);
+	//inv = new Inventory(1);
+
+	//randDialog = rand() % RAND_DIALOG_COUNT - 1;
+	dialogIndex = 0;
+
+	dim2 tmpDim = Texture::imageDim(tex.getTexturePath(0));
+	width = HLINES(tmpDim.x/2);
+	height = HLINES(tmpDim.y/2);
+}
+
+Merchant::~Merchant()
+{
+}
+
+void Merchant::saveToXML(void){}
+
+Structures::Structures() : Entity()
+{
+	type = STRUCTURET;
+	canMove = false;
+	health = maxHealth = 1;
+}
+
+Structures::~Structures()
+{
+}
+
+extern std::string currentXMLRaw;
+
+void Structures::createFromXML(XMLElement *e, World *w)
+{
+	float spawnx;
+
+	if (e->QueryBoolAttribute("alive", &alive) == XML_NO_ERROR && !alive) {
+		//die();
+		return;
+	}
+
+	inWorld = w;
+	inside = e->StrAttribute("inside");
+
+	// edge
+	if (!inside.empty()) {
+		insideWorld = loadWorldFromXMLNoTakeover(inside);
+	}
+
+	textureLoc = e->StrAttribute("texture");
+
+	insideTex = Texture::loadTexture(e->StrAttribute("insideTexture"));
+
+	spawn(static_cast<BUILD_SUB>(e->UnsignedAttribute("type")),
+	      e->QueryFloatAttribute("spawnx", &spawnx) == XML_NO_ERROR ? spawnx : (randGet() % w->getTheWidth() / 2.0f),
+	      100);
+
+	xmle = e;
+}
+
+void Structures::saveToXML(void)
+{
+	xmle->SetAttribute("alive", alive);
+}
+
+Object::Object()
+{
+	type = OBJECTT;
+}
+
+Object::Object(std::string in, std::string pd)
+{
+	iname = in;
+
+	pickupDialog = pd;
+	questObject = !pd.empty();
+
+	type = OBJECTT;
+	width  = getItemWidth(in);
+	height = getItemHeight(in);
+
+	tex = TextureIterator({getItemTexturePath(in)});
+}
+
+Object::~Object()
+{
+}
+
+void Object::createFromXML(XMLElement *e, World *w=nullptr)
+{
+	(void)e;
+	(void)w;
+}
+
+void Object::saveToXML(void)
+{}
+
+void Object::reloadTexture(void)
+{
+	tex = TextureIterator({getItemTexturePath(iname)});
+	width  = getItemWidth(iname);
+	height = getItemHeight(iname);
+}
+
+bool Entity::isNear(const Entity *e) {
+	return (e != nullptr) ? (pow(e->loc.x - loc.x, 2) + pow(e->loc.y - loc.y, 2) <= pow(HLINES(40), 2)) : false;
+}
+
+void NPC::drawThingy(void) const
+{
+	if (dialogCount) {
+		const auto w = width / 3;
+		GLfloat tex_coord[] = {
+			0, 0, 1, 0, 1, 1,
+			1, 1, 0, 1, 0, 0
+		};
+		const GLfloat c[4] = {
+			loc.x + w, loc.y + height, loc.x + w * 2, loc.y + height + w
+		};
+		GLfloat coords[] = {
+			c[0], c[1], z, c[2], c[1], z, c[2], c[3], z,
+			c[2], c[3], z, c[0], c[3], z, c[0], c[1], z
+		};
+
+		// TODO use texture made for this
+		static GLuint thingyColor = Texture::genColor(Color(236, 238, 15));
+
+		Render::worldShader.use();
+		Render::worldShader.enable();
+
+		glBindTexture(GL_TEXTURE_2D, thingyColor);
+
+		glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
+		glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex_coord);
+		glDrawArrays(GL_TRIANGLES, 0, 6);
+
+		Render::worldShader.disable();
+		Render::worldShader.unuse();
+	}
+}
+
+void Entity::draw(void)
+{
+	GLfloat tex_coord[] = {0.0, 0.0,
+						   1.0, 0.0,
+						   1.0, 1.0,
+
+						   1.0, 1.0,
+						   0.0, 1.0,
+						   0.0, 0.0};
+
+	GLfloat tex_coordL[] = {1.0, 0.0,
+						   	0.0, 0.0,
+						   	0.0, 1.0,
+
+						   	0.0, 1.0,
+						   	1.0, 1.0,
+						   	1.0, 0.0};
+
+	GLfloat coords[] = {loc.x, loc.y, z,
+						loc.x + width, loc.y, z,
+						loc.x + width, loc.y + height, z,
+
+						loc.x + width, loc.y + height, z,
+						loc.x, loc.y + height, z,
+						loc.x, loc.y, z};
+
+
+	glActiveTexture(GL_TEXTURE0);
+
+	if (!alive)
+		return;
+
+	if (type == NPCT) {
+		NPCp(this)->drawThingy();
+
+		if (gender == MALE)
+			glColor3ub(255, 255, 255);
+		else if (gender == FEMALE)
+			glColor3ub(255, 105, 180);
+	} else if (type == MOBT) {
+		if (Mobp(this)->rider != nullptr) {
+			Mobp(this)->rider->loc.x = loc.x + width * 0.25f;
+	        Mobp(this)->rider->loc.y = loc.y + height - HLINES(5);
+	        Mobp(this)->rider->vel.y = .12;
+			Mobp(this)->rider->z     = z + 0.01;
+	    }
+	}
+	switch(type) {
+	case PLAYERT:
+		static int texState = 0;
+		if (speed && !(game::time::getTickCount() % ((2.0f/speed) < 1 ? 1 : (int)((float)2.0f/(float)speed)))) {
+			if (++texState == 9)
+				texState = 1;
+			glActiveTexture(GL_TEXTURE0);
+			tex(texState);
+		}
+		if (!ground) {
+			glActiveTexture(GL_TEXTURE0);
+			tex(0);
+		} else if (vel.x) {
+			glActiveTexture(GL_TEXTURE0);
+			tex(texState);
+		} else {
+			glActiveTexture(GL_TEXTURE0);
+			tex(0);
+		}
+		break;
+	case MOBT:
+		if (!Mobp(this)->bindTex())
+			goto NOPE;
+		break;
+	case STRUCTURET:
+		/* fall through */
+	default:
+		glActiveTexture(GL_TEXTURE0);
+		tex(0);
+		break;
+	}
+
+	Render::worldShader.use();
+	// make the entity hit flash red
+	if (maxHitDuration-hitDuration) {
+		float flashAmt = 1-(hitDuration/maxHitDuration);
+		glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, flashAmt, flashAmt, 1.0);
+	}
+
+	glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+	Render::worldShader.enable();
+
+	glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coords);
+	if (left)
+		glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coordL);
+	else
+		glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0 ,tex_coord);
+	glDrawArrays(GL_TRIANGLES, 0, 6);
+
+	glUniform4f(Render::worldShader.uniform[WU_tex_color], 1.0, 1.0, 1.0, 1.0);
+NOPE:
+if (near && type != MOBT)
+	ui::putStringCentered(loc.x+width/2,loc.y-ui::fontSize-game::HLINE/2,name);
+if (health != maxHealth) {
+
+	static GLuint frontH = Texture::genColor(Color(255,0,0));
+	static GLuint backH =  Texture::genColor(Color(150,0,0));
+	glUniform1i(Render::worldShader.uniform[WU_texture], 0);
+
+	GLfloat coord_back[] = {
+		loc.x, 			loc.y + height, 			      z + 0.1f,
+		loc.x + width,	loc.y + height, 			      z + 0.1f,
+		loc.x + width, 	loc.y + height + game::HLINE * 2, z + 0.1f,
+
+		loc.x + width, 	loc.y + height + game::HLINE * 2, z + 0.1f,
+		loc.x, 			loc.y + height + game::HLINE * 2, z + 0.1f,
+		loc.x, 			loc.y + height, 			      z + 0.1f,
+	};
+
+	GLfloat coord_front[] = {
+		loc.x, 			                    loc.y + height,                   z,
+		loc.x + health / maxHealth * width, loc.y + height,                   z,
+		loc.x + health / maxHealth * width, loc.y + height + game::HLINE * 2, z,
+
+		loc.x + health / maxHealth * width, loc.y + height + game::HLINE * 2, z,
+		loc.x,                              loc.y + height + game::HLINE * 2, z,
+		loc.x,                              loc.y + height,                   z,
+	};
+
+	glBindTexture(GL_TEXTURE_2D, backH);
+	GLfloat tex[] = { 0.0, 0.0,
+					  1.0, 0.0,
+					  1.0, 1.0,
+
+					  1.0, 1.0,
+					  0.0, 1.0,
+					  0.0, 0.0,
+	};
+	glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coord_back);
+	glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+	glDrawArrays(GL_TRIANGLES, 0, 6);
+
+	glBindTexture(GL_TEXTURE_2D, frontH);
+	glVertexAttribPointer(Render::worldShader.coord, 3, GL_FLOAT, GL_FALSE, 0, coord_front);
+	glVertexAttribPointer(Render::worldShader.tex, 2, GL_FLOAT, GL_FALSE, 0, tex);
+	glDrawArrays(GL_TRIANGLES, 0, 6);
+}
+
+Render::worldShader.disable();
+Render::worldShader.unuse();
+}
+
+/**
+ * Handles NPC movement, usually just random walking.
+ */
+
+void NPC::
+wander(int timeRun)
+{
+	static int direction;
+
+	if (forcedMove)
+		return;
+
+	if (hitCooldown)
+		hitCooldown--;
+
+	if (targetx != 0.9112001f) {
+		if (loc.x > targetx + HLINES(5))
+			vel.x = HLINES(-0.018);
+		else if (loc.x < targetx - HLINES(5))
+			vel.x = HLINES(0.018);
+		else {
+			targetx = 0.9112001f;
+			vel.x = 0;
+		}
+	} else if (ticksToUse == 0) {
+		ticksToUse = timeRun;
+
+		vel.x = HLINES(0.008);
+		direction = (randGet() % 3 - 1);
+
+		if (direction == 0)
+			ticksToUse *= 2;
+
+		vel.x *= direction;
+	}
+
+	if (vel.x < 0)
+		currentWorld->goWorldLeft(this);
+
+	ticksToUse--;
+}
+
+void NPC::addAIFunc(bool preload)
+{
+	if (preload)
+		aipreload.push_back(this);
+	else
+		++dialogCount;
+}
+
+extern int commonAIFunc(NPC *speaker);
+
+void NPC::interact() { //have the npc's interact back to the player
+	std::thread([this]{
+		std::vector<XMLElement *> dopt;
+		XMLDocument *xml;
+		XMLElement *exml,*oxml;
+
+		static unsigned int oldidx = 9999;
+		const char *ptr;
+		std::string nname;
+		unsigned int idx;
+		bool stop;
+		float tgt = 0.12345678f;
+		bool pmove = true, advance = false;
+
+		loc.y += 5;
+
+		// freeze the npc, face the player
+		canMove = false;
+		left    = (player->loc.x < loc.x);
+		right   = !left;
+
+		// if there's actual scripted stuff to do, do it
+		if (dialogCount && dialogIndex != 9999) {
+			// load the XML file and find the dialog tags
+			if (outnabout == 0) {
+				xml = &currentXMLDoc;
+			} else if (outnabout < 0) {
+				xml = new XMLDocument();
+				xml->LoadFile((xmlFolder + currentWorld->getToLeft()).c_str());
+			} else {
+				xml = new XMLDocument();
+				xml->LoadFile((xmlFolder + currentWorld->getToRight()).c_str());
+			}
+
+COMMONAIFUNC:
+			idx = 0;
+			stop = false;
+			exml = xml->FirstChildElement("Dialog");
+
+			// search for the dialog block associated with this npc
+			while (exml->StrAttribute("name") != name)
+				exml = exml->NextSiblingElement();
+
+			// search for the desired text block
+			exml = exml->FirstChildElement();
+			do {
+				if (std::string("text") == exml->Name() && exml->UnsignedAttribute("id") == (unsigned)dialogIndex)
+					break;
+			} while ((exml = exml->NextSiblingElement()));
+
+			// handle quest tags
+			if ((oxml = exml->FirstChildElement("quest"))) {
+				std::string qname;
+
+				// iterate through all quest tags
+				do {
+					// assign quest
+					if (!(qname = oxml->StrAttribute("assign")).empty())
+						player->qh.assign(qname, oxml->StrAttribute("desc"), (oxml->GetText() == nullptr) ? "" : oxml->GetText());
+
+					// check / finish quest
+					else if (!(qname = oxml->StrAttribute("check")).empty()) {
+						if (player->qh.hasQuest(qname) && player->qh.finish(qname)) {
+							// QuestHandler::finish() did all the work..
+							break;
+						} else {
+							// run error dialog
+							oldidx = dialogIndex;
+							dialogIndex = oxml->UnsignedAttribute("fail");
+							goto COMMONAIFUNC;
+						}
+					}
+				} while((oxml = oxml->NextSiblingElement("quest")));
+			}
+
+			// handle give tags
+			if ((oxml = exml->FirstChildElement("give"))) {
+				do player->inv->addItem(oxml->Attribute("id"), oxml->UnsignedAttribute("count"));
+				while ((oxml = oxml->NextSiblingElement("give")));
+			}
+
+			// handle take tags
+			if ((oxml = exml->FirstChildElement("take"))) {
+				do player->inv->takeItem(oxml->Attribute("id"), oxml->UnsignedAttribute("count"));
+				while ((oxml = oxml->NextSiblingElement()));
+			}
+
+			// handle movement directs
+			if ((oxml = exml->FirstChildElement("gotox"))) {
+				moveTo((tgt = std::stoi(oxml->GetText())));
+				if (oxml->QueryBoolAttribute("playerMove", &pmove) != XML_NO_ERROR)
+					pmove = true;
+				if (oxml->QueryBoolAttribute("advance", &advance) != XML_NO_ERROR)
+					advance = false;
+			}
+
+			// handle attribute setting
+			if ((oxml = exml->FirstChildElement("set"))) {
+				do game::setValue(oxml->StrAttribute("id"), oxml->StrAttribute("value"));
+				while ((oxml = oxml->NextSiblingElement()));
+				game::briceUpdate();
+			}
+
+			// asdlfkj
+
+			auto txml = exml->FirstChildElement("content");
+			if (txml == nullptr)
+				goto OTHERSTUFF;
+
+			ptr = txml->GetText() - 1;
+			while (*++ptr && isspace(*ptr));
+
+			// handle dialog options
+			if ((oxml = exml->FirstChildElement("option"))) {
+				std::string optstr;
+
+				// convert option strings to a colon-separated format
+				do {
+					// append the next option
+					optstr.append(std::string(":") + oxml->Attribute("text"));
+
+					// save the associated XMLElement
+					dopt.push_back(oxml);
+				} while ((oxml = oxml->NextSiblingElement()));
+
+				// run the dialog stuff
+				ui::dialogBox(name, optstr, false, ptr);
+				ui::waitForDialog();
+
+				if (ui::dialogOptChosen)
+					exml = dopt[ui::dialogOptChosen - 1];
+
+				dopt.clear();
+			}
+
+			// optionless dialog
+			else {
+				ui::dialogBox(name, "", false, ptr);
+				ui::waitForDialog();
+			}
+
+OTHERSTUFF:
+
+			// trigger other npcs if desired
+			if (!(nname = exml->StrAttribute("call")).empty()) {
+				NPC *n = dynamic_cast<NPC *>(*std::find_if(std::begin(currentWorld->entity), std::end(currentWorld->entity), [nname](Entity *e) {
+					return (e->type == NPCT && e->name == nname);
+				}));
+
+				if (exml->QueryUnsignedAttribute("callid", &idx) == XML_NO_ERROR) {
+					n->dialogIndex = idx;
+					n->addAIFunc(false);
+				}
+			}
+
+			if (tgt != 0.12345678f) {
+				stop = canMove;
+				canMove = true;
+				while (targetx != 0.9112001f) {
+					if (!pmove)
+						player->speed = 0;
+				}
+				if (!pmove) {
+					pmove = true;
+					player->speed = 1;
+				}
+				canMove = stop;
+			}
+
+			// handle potential following dialogs
+			if ((idx = exml->UnsignedAttribute("nextid"))) {
+				dialogIndex = idx;
+
+				// stop talking
+				if (exml->QueryBoolAttribute("stop", &stop) == XML_NO_ERROR && stop) {
+					dialogIndex = 9999;
+					dialogCount--;
+				}
+
+				// pause, allow player to click npc to continue
+				else if (exml->QueryBoolAttribute("pause", &stop) == XML_NO_ERROR && stop) {
+					//return 1;
+				}
+
+				// instantly continue
+				else {
+					goto COMMONAIFUNC;
+				}
+			}
+
+			// advance if desired
+			else if (advance) {
+				goto COMMONAIFUNC;
+			}
+
+			// stop talking
+			else {
+				// error text?
+				if (oldidx != 9999) {
+					dialogIndex = oldidx;
+					oldidx = 9999;
+				} else {
+					dialogIndex = 9999;
+					dialogCount--;
+				}
+			}
+		} else {
+			ui::dialogBox(name, "", false, randomDialog[randDialog]);
+		}
+
+		ui::waitForDialog();
+		canMove = true;
+	}).detach();
+}
+
+void Merchant::wander(int timeRun) {
+	static int direction;
+
+	if (forcedMove)
+		return;
+
+	if (ticksToUse == 0) {
+		ticksToUse = timeRun;
+
+		vel.x = HLINES(0.008);
+		direction = (randGet() % 3 - 1);
+
+		if (direction == 0)
+			ticksToUse *= 2;
+
+		vel.x *= direction;
+	}
+
+	if (vel.x < 0)
+		currentWorld->goWorldLeft(this);
+	if (inside != nullptr) {
+		loc.y = inside->loc.y + HLINES(2);
+		vel.y = GRAVITY_CONSTANT * 5;
+		if (loc.x <= inside->loc.x + HLINES(5))
+			loc.x = inside->loc.x + HLINES(5);
+		else if (loc.x + width >= inside->loc.x + inside->width - HLINES(5))
+			loc.x = inside->loc.x + inside->width - width - HLINES(5);
+	}
+	ticksToUse--;
+}
+
+void Merchant::interact() {
+	std::thread([this]{
+		ui::merchantBox(name.c_str(), trade[currTrade], ":Accept:Good-Bye", false, toSay->c_str());
+		ui::waitForDialog();
+
+		// handle normal dialog options
+		switch (ui::dialogOptChosen) {
+		// Accept
+		case 1:
+			if (!(player->inv->takeItem(trade[currTrade].item[1], trade[currTrade].quantity[1]))) {
+				player->inv->addItem(trade[currTrade].item[0],trade[currTrade].quantity[0]);
+				toSay = &text[1];
+				interact();
+			} else {
+				toSay = &text[2];
+				interact();
+			}
+			break;
+
+		// Good-bye
+		case 2:
+			break;
+
+		default:
+			break;
+		}
+
+		// handle merchant-specific dialog options
+		switch (ui::merchOptChosen) {
+		// left arrow
+		case 1:
+			if (currTrade)
+				currTrade--;
+			ui::dontTypeOut();
+			interact(); // TODO should we nest like this?
+			break;
+
+		// right arrow
+		case 2:
+			if (currTrade < trade.size() - 1)
+				currTrade++;
+			ui::dontTypeOut();
+			interact();
+			break;
+
+		default:
+			break;
+		toSay = &text[0];
+		}
+	}).detach();
+}
+
+void Object::interact(void) {
+	std::thread([this]{
+		if(questObject && alive){
+			ui::dialogBox(player->name, ":Yes:No", false, pickupDialog);
+			ui::waitForDialog();
+			if (ui::dialogOptChosen == 1) {
+				player->inv->addItem(iname, 1);
+				alive = false;
+			}
+		}else{
+			alive = false;
+			player->inv->addItem(iname, 1);
+		}
+	}).detach();
+}
+
+bool Entity::isInside(vec2 coord) const {
+	return coord.x >= loc.x &&
+	   	   coord.x <= loc.x + width &&
+	   	   coord.y >= loc.y	&&
+	       coord.y <= loc.y + height;
+}
+
+/*
+ *	This spawns the structures
+ *
+ * Structures::spawn		This allows us to spawn buildings and large amounts of entities with it.
+ *							Passed are the type and x and y coordinates. These set the x and y coords
+ *							of the structure being spawned, the type pass just determines what rules to follow
+ *							when spawing the structure and entities. In theory this function can also spawn
+ *							void spawn points for large amounts of entities. This would allow for the spawn
+ *							point to have non-normal traits so it could be invisible or invincible...
+*/
+
+unsigned int Structures::spawn(BUILD_SUB sub, float x, float y) {
+	loc.x = x;
+	loc.y = y;
+	type = STRUCTURET;
+
+	alive = true;
+	canMove = false;
+
+	bsubtype = sub;
+	dim2 dim;
+
+	z = 1.0;
+	/*
+	 *	tempN is the amount of entities that will be spawned in the village. Currently the village
+	 *	will spawn bewteen 2 and 7 villagers for the starting hut.
+	*/
+
+	//unsigned int tempN = (randGet() % 5 + 2);
+
+	if (textureLoc.empty())
+		textureLoc = inWorld->getSTextureLocation(sub);
+
+	switch(sub) {
+		case STALL_MARKET:
+			tex = TextureIterator({ textureLoc });
+			dim = Texture::imageDim(textureLoc);
+			width = HLINES(dim.x/2);
+			height = HLINES(dim.y/2);
+			break;
+		default:
+			tex = TextureIterator({ textureLoc });
+			dim = Texture::imageDim(textureLoc);
+			width = HLINES(dim.x/2);
+			height = HLINES(dim.y/2);
+			inv = NULL;
+			break;
+	}
+
+	return 0;
+}
+
+/*Particles::Particles(const Structures *&s, vec2 vell, Color c, float d, )
+{
+
+}*/
+
+Particles::Particles(float x, float y, float w, float h, float vx, float vy, Color c, float d)
+{
+	loc = vec2 {x, y};
+	vel = vec2 {vx, vy};
+	width = w;
+	height = h;
+	color = c;
+	duration = d;
+	gravity = true;
+	fountain = false;
+	behind = false;
+	bounce = false;
+	index = Texture::getIndex(c);
+	zOffset = ((rand()%20)-10)/1000.0f;
+	stu = nullptr;
+}
+
+void Particles::draw(GLfloat*& p) const
+{
+	vec2 tc = vec2(0.25f * index.x, 0.125f * (8.0f - index.y));
+
+	float z = (behind ? 2.0f : 0.9f) + zOffset;
+
+	// lower left
+    *(p++) = loc.x;
+    *(p++) = loc.y;
+    *(p++) = z;
+
+	*(p++) = tc.x;
+	*(p++) = tc.y;
+
+	// lower right
+    *(p++) = loc.x + width;
+    *(p++) = loc.y;
+    *(p++) = z;
+
+	*(p++) = tc.x;
+	*(p++) = tc.y;
+
+	// upper right
+    *(p++) = loc.x + width;
+    *(p++) = loc.y + height;
+    *(p++) = z;
+
+	*(p++) = tc.x;
+	*(p++) = tc.y;
+
+	// upper right
+    *(p++) = loc.x + width;
+    *(p++) = loc.y + height;
+    *(p++) = z;
+
+	*(p++) = tc.x;
+	*(p++) = tc.y;
+
+	// upper left
+    *(p++) = loc.x;
+    *(p++) = loc.y + height;
+    *(p++) = z;
+
+	*(p++) = tc.x;
+    *(p++) = tc.y;
+
+	// lower left
+    *(p++) = loc.x;
+    *(p++) = loc.y;
+    *(p++) = z;
+
+    *(p++) = tc.x;
+    *(p++) = tc.y;
+}
+
+void Particles::update(float _gravity, float ground_y)
+{
+	auto delta = game::time::getDeltaTime();
+
+	// handle ground collision
+	if (loc.y < ground_y) {
+		loc.y = ground_y;
+
+		// handle bounce
+		if (bounce) {
+			vel.y *= -0.2f;
+			vel.x /= 4.0f;
+		} else {
+			vel = 0.0f;
+			canMove = false;
+		}
+	}
+
+	// handle gravity
+	else if (gravity && vel.y > -1.0f) {
+		vel.y -= _gravity * delta;
+	}
+
+	// handle lifetime
+	duration -= delta;
+}
+
+bool Particles::timeUp(void)
+{
+	return !(duration > 0);
+}
+
+void Player::save(void) {
+	std::string data;
+	std::ofstream out (xmlFolder + ".main.dat", std::ios::out | std::ios::binary);
+	std::cout<<"Saving player data..."<<std::endl;
+	data.append(std::to_string((int)loc.x) + "\n");
+	data.append(std::to_string((int)loc.y) + "\n");
+	data.append(std::to_string((int)health) + "\n");
+	data.append(std::to_string((int)maxHealth) + "\n");
+	data.append(std::to_string((int)game::time::getTickCount()) + "\n");
+
+	data.append("qwer\n");
+	data.append(std::to_string((int)inv->Items.size()) + "\n");
+	for(auto &i : inv->Items) {
+		if(i.second)
+			data.append(std::to_string(uint(i.second)) + "\n" + i.first->name + "\n");
+	}
+	data.append("qwer\n");
+
+	data.append(std::string(currentXML.data() + 4) + "\n");
+
+	data.append("dOnE\0");
+	out.write(data.data(),data.size());
+	out.close();
+}
+
+void Player::sspawn(float x,float y) {
+	unsigned int i;
+	int count;
+	std::ifstream in (xmlFolder + ".main.dat", std::ios::in | std::ios::binary);
+	spawn(x,y);
+
+	if (in.good()) {
+		std::istringstream data;
+		std::string ddata;
+		std::streampos len;
+
+		in.seekg(0,std::ios::end);
+		len = in.tellg();
+		in.seekg(0,std::ios::beg);
+
+		std::vector<char> buf (len,'\0');
+		in.read(buf.data(),buf.size());
+
+		data.rdbuf()->pubsetbuf(buf.data(),buf.size());
+
+		std::getline(data,ddata);
+		loc.x = std::stoi(ddata);
+		std::getline(data,ddata);
+		loc.y = std::stoi(ddata);
+		std::getline(data,ddata);
+		health = std::stoi(ddata);
+		std::getline(data,ddata);
+		maxHealth = std::stoi(ddata);
+		std::getline(data,ddata);
+		game::time::tick(std::stoi(ddata));
+
+		std::getline(data,ddata);
+		std::getline(data,ddata);
+
+		for (i = std::stoi(ddata);i;i--) {
+			std::getline(data,ddata);
+			if (ddata == "qwer")
+				break;
+			count = std::stoi(ddata);
+
+			std::getline(data,ddata);
+			if (ddata == "qwer")
+				break;
+			inv->addItem(ddata, (uint)count);
+		}
+
+		std::getline(data,ddata);
+		currentWorld = loadWorldFromXMLNoSave(ddata);
+
+		in.close();
+	}
+}