#include <algorithm>
#include <sstream>

#include <world.hpp>
#include <ui.hpp>

#include <tinyxml2.h>
using namespace tinyxml2;

/**
 * Defines how many HLINEs tall a blade of grass can be.
 */

#define GRASS_HEIGHT            4

/**
 * Defines the height of the floor in an IndoorWorld.
 */

#define INDOOR_FLOOR_THICKNESS      50
#define INDOOR_FLOOR_HEIGHTT        400

extern Player *player;						// main.cpp?
extern World  *currentWorld;				// main.cpp
extern World  *currentWorldToLeft;			// main.cpp
extern World  *currentWorldToRight;			// main.cpp
extern int     commonAIFunc(NPC *);			// entities.cpp
extern void    commonTriggerFunc(Mob *);	// gameplay.cpp
extern void    commonPageFunc(Mob *);		// gameplay.cpp
extern bool    inBattle;

extern unsigned int tickCount;				// main.cpp

extern std::string xmlFolder;

int worldShade = 0;

std::string currentXML;

std::vector<std::string> inside;		// tracks indoor worlds

std::vector<World *>     battleNest;	// tracks arenas
std::vector<vec2>        battleNestLoc;	// keeps arena locations

/**
 * Contains the current weather, used in many other places/files.
 */

WorldWeather weather = WorldWeather::Sunny;

const std::string bgPaths[2][9]={
    {"bg.png",					// Daytime background
     "bgn.png",					// Nighttime background
     "bgFarMountain.png",		// Furthest layer
     "forestTileFar.png",		// Furthest away Tree Layer
     "forestTileBack.png",		// Closer layer
     "forestTileMid.png",		// Near layer
     "forestTileFront.png",		// Closest layer
     "dirt.png",				// Dirt
     "grass.png"},				// Grass
    {"bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png",
     "bgWoodTile.png"}
};

const std::string buildPaths[] = {
    "townhall.png",
	"house1.png",
    "house2.png",
    "house1.png",
    "house1.png",
    "fountain1.png",
    "lampPost1.png",
	"brazzier.png"
};

/**
 * Constants used for layer drawing in World::draw(), releated to transparency.
 */

const float bgDraw[4][3]={
	{ 100, 240, 0.6  },
	{ 150, 250, 0.4  },
	{ 200, 255, 0.25 },
	{ 255, 255, 0.1  }
};

/**
 * Sets the desired theme for the world's background.
 *
 * The images chosen for the background layers are selected depending on the
 * world's background type.
 */

void World::
setBackground(WorldBGType bgt)
{
    // load textures with a limit check
	switch ((bgType = bgt)) {
	case WorldBGType::Forest:
		bgTex = new Texturec(bgFiles);
		break;

	case WorldBGType::WoodHouse:
		bgTex = new Texturec(bgFilesIndoors);
		break;

    default:
        UserError("Invalid world background type");
        break;
	}
}

/**
 * Sets the world's style.
 *
 * The world's style will determine what sprites are used for things like\
 * generic structures.
 */

void World::
setStyle(std::string pre)
{
    unsigned int i;

    // get folder prefix
	std::string prefix = pre.empty() ? "assets/style/classic/" : pre;

	for (i = 0; i < arrAmt(buildPaths); i++)
		sTexLoc.push_back(prefix + buildPaths[i]);

	prefix += "bg/";

	for (i = 0; i < arrAmt(bgPaths[0]); i++)
		bgFiles.push_back(prefix + bgPaths[0][i]);

	for (i = 0; i < arrAmt(bgPaths[1]); i++)
		bgFilesIndoors.push_back(prefix + bgPaths[1][i]);
}

/**
 * Creates a world object.
 *
 * Note that all this does is nullify pointers, to prevent as much disaster as
 * possible. Functions like setBGM(), setStyle() and generate() should be called
 * before the World is actually put into use.
 */

World::
World(void)
{
    bgmObj = NULL;
}

/**
 * The entity vector destroyer.
 *
 * This function will free all memory used by all entities, and then empty the
 * vectors they were stored in.
 */

void World::
deleteEntities(void)
{
    // free mobs
	mob.clear();

	merchant.clear();
	while(!npc.empty()) {
		delete npc.back();
		npc.pop_back();
	}

    // free structures
	while (!build.empty()) {
		delete build.back();
		build.pop_back();
	}

    // free objects
	object.clear();

    // clear entity array
	entity.clear();

    // free particles
	particles.clear();

    // clear light array
	light.clear();

    // free villages
	village.clear();
}

/**
 * The world destructor.
 *
 * This will free objects used by the world itself, then free the vectors of
 * entity-related objects.
 */

World::
~World(void)
{
    // sdl2_mixer's object
	if (bgmObj)
		Mix_FreeMusic(bgmObj);

	delete bgTex;
	deleteEntities();
}

/**
 * Generates a world of the specified width.
 *
 * This will mainly populate the WorldData array, mostly preparing the World
 * object for usage.
 */

void World::
generate(unsigned int width)
{
    // iterator for `for` loops
	std::vector<WorldData>::iterator wditer;

    // see below for description
    float geninc = 0;

    // check for valid width
    if ((int)width <= 0)
        UserError("Invalid world dimensions");

    // allocate space for world
    worldData = std::vector<WorldData> (width + GROUND_HILLINESS, WorldData { false, {0,0}, 0, 0 });
    lineCount = worldData.size();

    // prepare for generation
    worldData.front().groundHeight = GROUND_HEIGHT_INITIAL;
    wditer = worldData.begin();

    // give every GROUND_HILLINESSth entry a groundHeight value
    for(unsigned int i = GROUND_HILLINESS; i < worldData.size(); i += GROUND_HILLINESS, wditer += GROUND_HILLINESS)
        worldData[i].groundHeight = (*wditer).groundHeight + (randGet() % 8 - 4);

    // create slopes from the points that were just defined, populate the rest of the WorldData structure

    for(wditer = worldData.begin() + 1; wditer != worldData.end(); wditer++) {
        if ((*wditer).groundHeight && wditer + GROUND_HILLINESS < worldData.end())
			// wditer + GROUND_HILLINESS can go out of bounds (invalid read)
            geninc = ((*(wditer + GROUND_HILLINESS)).groundHeight - (*wditer).groundHeight) / (float)GROUND_HILLINESS;
        else
            (*wditer).groundHeight = (*(wditer - 1)).groundHeight + geninc;

        (*wditer).groundColor    = randGet() % 32 / 8;
        (*wditer).grassUnpressed = true;
        (*wditer).grassHeight[0] = (randGet() % 16) / 3 + 2;
        (*wditer).grassHeight[1] = (randGet() % 16) / 3 + 2;

        // bound checks
        if ((*wditer).groundHeight < GROUND_HEIGHT_MINIMUM)
            (*wditer).groundHeight = GROUND_HEIGHT_MINIMUM;
        else if ((*wditer).groundHeight > GROUND_HEIGHT_MAXIMUM)
			(*wditer).groundHeight = GROUND_HEIGHT_MAXIMUM;

		if ((*wditer).groundHeight <= 0)
			(*wditer).groundHeight = GROUND_HEIGHT_MINIMUM;

    }

    // define x-coordinate of world's leftmost 'line'
    worldStart = (width - GROUND_HILLINESS) * HLINE / 2 * -1;

    // create empty star array, should be filled here as well...
	star = std::vector<vec2> (100, vec2 { 0, 400 });
	for (auto &s : star) {
		s.x = (getRand() % (-worldStart * 2)) + worldStart;
		s.y = (getRand() % SCREEN_HEIGHT) + 100.0f;
	}
}

/**
 * Updates all entity and player coordinates with their velocities.
 *
 * Also handles music fading, although that could probably be placed elsewhere.
 */

void World::
update(Player *p, unsigned int delta)
{
    // update player coords
	p->loc.y += p->vel.y			 * delta;
	p->loc.x +=(p->vel.x * p->speed) * delta;

	if (p->loc.y > 5000)
        UserError("Too high for me m8.");

	// update entity coords
	for (auto &e : entity) {

        // dont let structures move?
		if (e->type != STRUCTURET && e->canMove) {
			e->loc.x += e->vel.x * delta;
            e->loc.y += e->vel.y * delta;

            // update boolean directions
			if (e->vel.x < 0)
                e->left = true;
	   		else if (e->vel.x > 0)
                e->left = false;
		} else if (e->vel.y < 0)
            e->loc.y += e->vel.y * delta;
	}
    // iterate through particles
    particles.erase(std::remove_if (particles.begin(), particles.end(), [&delta](Particles &part) {return part.kill(delta);}), particles.end());
    for (auto part = particles.begin(); part != particles.end(); part++) {
		if ((*part).canMove) {
			(*part).loc.y += (*part).vel.y * delta;
			(*part).loc.x += (*part).vel.x * delta;

			for (auto &b : build) {
				if (b->bsubtype == FOUNTAIN) {
					if ((*part).loc.x >= b->loc.x && (*part).loc.x <= b->loc.x + b->width) {
						if ((*part).loc.y <= b->loc.y + b->height * .25)
							particles.erase(part);

					}
				}
			}
		}
	}

    // handle music fades
	if (ui::dialogImportant) {
		//Mix_FadeOutMusic(2000);
	} else if (!Mix_PlayingMusic())
		Mix_FadeInMusic(bgmObj,-1,2000);
}

/**
 * Set the world's BGM.
 *
 * This will load a sound file to be played while the player is in this world.
 * If no file is found, no music should play.
 */

void World::
setBGM(std::string path)
{
	if (!path.empty())
		bgmObj = Mix_LoadMUS((bgm = path).c_str());
}

/**
 * Toggle play/stop of the background music.
 *
 * If new music is to be played a crossfade will occur, otherwise... uhm.
 */

void World::
bgmPlay(World *prev) const
{
	if (prev) {
		if (bgm != prev->bgm) {
            // new world, new music
			Mix_FadeOutMusic(800);
			Mix_PlayMusic(bgmObj, -1);
		}
	} else {
        // first call
		Mix_FadeOutMusic(800);
		Mix_PlayMusic(bgmObj, -1);
	}
}

/**
 * The world draw function.
 *
 * This function will draw the background layers, entities, and player to the
 * screen.
 */

void World::draw(Player *p) {
    // iterators
    int i, iStart, iEnd;

    // shade value for draws -- may be unnecessary
	int shadeBackground = -worldShade;

    // player's offset in worldData[]
	int pOffset;

    // world width in pixels
	int width = worldData.size() * HLINE;

	// shade value for GLSL
	float shadeAmbient = -worldShade / 50.0f + 0.5f; // -0.5f to 1.5f
	if (shadeAmbient < 0)
		shadeAmbient = 0;
	else if (shadeAmbient > 0.9f)
		shadeAmbient = 1;

	/*
     * Draw background images.
     */

	glEnable(GL_TEXTURE_2D);

	// the sunny wallpaper is faded with the night depending on tickCount

	bgTex->bind(0);
    int alpha;
    switch(weather) {
    case WorldWeather::Snowy:
        alpha = 150;
        break;
    case WorldWeather::Rain:
        alpha = 0;
        break;
    default:
        alpha = 255 - worldShade * 4;
        break;
    }
	safeSetColorA(255, 255, 255, alpha);

	glBegin(GL_QUADS);
		glTexCoord2i(0, 0); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2);
		glTexCoord2i(1, 0); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2);
		glTexCoord2i(1, 1); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2);
		glTexCoord2i(0, 1); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2);
	glEnd();

	bgTex->bindNext();
	safeSetColorA(255, 255, 255, !alpha ? 255 : worldShade * 4);

	glBegin(GL_QUADS);
        glTexCoord2i(0, 0); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y + SCREEN_HEIGHT/2);
        glTexCoord2i(1, 0); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y + SCREEN_HEIGHT/2);
        glTexCoord2i(1, 1); glVertex2i(offset.x + SCREEN_WIDTH/2+5, offset.y - SCREEN_HEIGHT/2);
        glTexCoord2i(0, 1); glVertex2i(offset.x - SCREEN_WIDTH/2-5, offset.y - SCREEN_HEIGHT/2);
	glEnd();

	glDisable(GL_TEXTURE_2D);

	// draw the stars if the time deems it appropriate

	//if ((((weather == WorldWeather::Dark) & (tickCount % DAY_CYCLE)) < DAY_CYCLE / 2)   ||
	//    (((weather == WorldWeather::Sunny) & (tickCount % DAY_CYCLE)) > DAY_CYCLE * .75)) {
	if (worldShade > 0) {

		safeSetColorA(255, 255, 255, 255 - (getRand() % 30 - 15));

		for (i = 0; i < 100; i++) {
			glRectf(star[i].x + offset.x * .9,
					star[i].y,
					star[i].x + offset.x * .9 + HLINE,
					star[i].y + HLINE
					);
		}
	}

	// draw remaining background items

	glEnable(GL_TEXTURE_2D);

	bgTex->bindNext();
	safeSetColorA(150 + shadeBackground * 2, 150 + shadeBackground * 2, 150 + shadeBackground * 2, 255);

	glBegin(GL_QUADS);
		for (i = 0; i <= (int)(worldData.size() * HLINE / 1920); i++) {
			glTexCoord2i(0, 1); glVertex2i(width / 2 * -1 + (1920 * i) + offset.x * .85, GROUND_HEIGHT_MINIMUM);
			glTexCoord2i(1, 1); glVertex2i(width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM);
			glTexCoord2i(1, 0); glVertex2i(width / 2 * -1 + (1920 * (i + 1)) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080);
			glTexCoord2i(0, 0); glVertex2i(width / 2 * -1 + (1920 * i) + offset.x * .85, GROUND_HEIGHT_MINIMUM + 1080);
		}
	glEnd();

	for (i = 0; i < 4; i++) {
		bgTex->bindNext();
		safeSetColorA(bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][0] + shadeBackground * 2, bgDraw[i][1]);

		glBegin(GL_QUADS);
			for(int j = worldStart; j <= -worldStart; j += 600) {
				glTexCoord2i(0, 1); glVertex2i(j        + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM);
				glTexCoord2i(1, 1); glVertex2i((j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM);
				glTexCoord2i(1, 0); glVertex2i((j + 600) + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400);
				glTexCoord2i(0, 0); glVertex2i(j        + offset.x * bgDraw[i][2], GROUND_HEIGHT_MINIMUM + 400);
			}
		glEnd();
	}

	glDisable(GL_TEXTURE_2D);

	// draw black under backgrounds

	glColor3ub(0, 0, 0);
	glRectf(worldStart, GROUND_HEIGHT_MINIMUM, -worldStart, 0);

	pOffset = (offset.x + p->width / 2 - worldStart) / HLINE;

    /*
     * Prepare for world ground drawing.
     */

	// only draw world within player vision

	if ((iStart = pOffset - (SCREEN_WIDTH / 2 / HLINE) - GROUND_HILLINESS) < 0)
		iStart = 0;

	if ((iEnd = pOffset + (SCREEN_WIDTH / 2 / HLINE) + GROUND_HILLINESS + HLINE) > (int)worldData.size())
		iEnd = worldData.size();
	else if (iEnd < GROUND_HILLINESS)
		iEnd = GROUND_HILLINESS;

	// draw particles and buildings

    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, colorIndex);

    glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
    glUseProgram(shaderProgram);

    std::for_each(particles.begin(), particles.end(), [](Particles part) { if (part.behind) part.draw(); });

    glUseProgram(0);

	for (auto &b : build) {
        if (b->bsubtype == STALL_MARKET) {
            for (auto &n : npc) {
                if (n->type == MERCHT && ((Merchant *)n)->inside == b) {
                    n->draw();
                    break;
                }
            }
        }
        b->draw();
    }

	// draw light elements?

	glEnable(GL_TEXTURE_2D);

	glActiveTexture(GL_TEXTURE0);
	bgTex->bindNext();

    for(auto &l : light) {
        if (l.belongsTo) {
            l.loc.x = l.following->loc.x + SCREEN_WIDTH/2;
            l.loc.y = l.following->loc.y;
        }
        if (l.flame) {
            l.fireFlicker = .9+((rand()%2)/10.0f);
            l.fireLoc.x = l.loc.x + (rand()%2-1)*3;
            l.fireLoc.y = l.loc.y + (rand()%2-1)*3;
        }else{
            l.fireFlicker = 1.0f;
        }
    }

    std::unique_ptr<GLfloat[]> pointArrayBuf = std::make_unique<GLfloat[]> (2 * (light.size()));
	auto pointArray = pointArrayBuf.get();
    GLfloat flameArray[64];

	for (uint i = 0; i < light.size(); i++) {
        if (light[i].flame) {
    		pointArray[2 * i    ] = light[i].fireLoc.x - offset.x;
    		pointArray[2 * i + 1] = light[i].fireLoc.y;
        }else{
            pointArray[2 * i    ] = light[i].loc.x - offset.x;
            pointArray[2 * i + 1] = light[i].loc.y;
        }
	}

    for (uint i = 0; i < light.size(); i++)
        flameArray[i] = light[i].fireFlicker;

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glUseProgram(shaderProgram);
	glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
	glUniform1f(glGetUniformLocation(shaderProgram, "amb"), shadeAmbient);

	if (light.size() == 0)
		glUniform1i(glGetUniformLocation(shaderProgram, "numLight"), 0);
	else {
		glUniform1i (glGetUniformLocation(shaderProgram, "numLight"), light.size());
		glUniform2fv(glGetUniformLocation(shaderProgram, "lightLocation"), light.size(), pointArray);
		glUniform3f (glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f, 1.0f);
        glUniform1fv(glGetUniformLocation(shaderProgram,"fireFlicker"), light.size(),flameArray);
	}

    /*
     * Draw the dirt.
     */

	glBegin(GL_QUADS);

        // faulty
        /*glTexCoord2i(0 ,0);glVertex2i(pOffset - (SCREEN_WIDTH / 1.5),0);
        glTexCoord2i(64,0);glVertex2i(pOffset + (SCREEN_WIDTH / 1.5),0);
        glTexCoord2i(64,1);glVertex2i(pOffset + (SCREEN_WIDTH / 1.5),GROUND_HEIGHT_MINIMUM);
        glTexCoord2i(0 ,1);glVertex2i(pOffset - (SCREEN_WIDTH / 1.5),GROUND_HEIGHT_MINIMUM);*/

        for (i = iStart; i < iEnd; i++) {
            if (worldData[i].groundHeight <= 0) {
                worldData[i].groundHeight = GROUND_HEIGHT_MINIMUM - 1;
                glColor4ub(0, 0, 0, 255);
            } else
                safeSetColorA(150, 150, 150, 255);

            glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE         , worldData[i].groundHeight - GRASS_HEIGHT);
            glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE , worldData[i].groundHeight - GRASS_HEIGHT);

            glTexCoord2i(1, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor); glVertex2i(worldStart + i * HLINE + HLINE, 0);
            glTexCoord2i(0, (int)(worldData[i].groundHeight / 64) + worldData[i].groundColor); glVertex2i(worldStart + i * HLINE	      , 0);

            if (worldData[i].groundHeight == GROUND_HEIGHT_MINIMUM - 1)
                worldData[i].groundHeight = 0;
        }

	glEnd();

	glUseProgram(0);
	glDisable(GL_TEXTURE_2D);

	/*
	 *	Draw the grass/the top of the ground.
	 */

	glEnable(GL_TEXTURE_2D);

	glActiveTexture(GL_TEXTURE0);
	bgTex->bindNext();

	glUseProgram(shaderProgram);
	glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);

	float cgh[2];
	for (i = iStart; i < iEnd - GROUND_HILLINESS; i++) {

		// load the current line's grass values
		if (worldData[i].groundHeight)
			memcpy(cgh, worldData[i].grassHeight, 2 * sizeof(float));
		else
			memset(cgh, 0 , 2 * sizeof(float));

		// flatten the grass if the player is standing on it.
		if (!worldData[i].grassUnpressed) {
			cgh[0] /= 4;
			cgh[1] /= 4;
		}

		// actually draw the grass.

		safeSetColorA(255, 255, 255, 255);

		glBegin(GL_QUADS);
			glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE            , worldData[i].groundHeight + cgh[0]);
			glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[0]);
			glTexCoord2i(1, 1); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT);
			glTexCoord2i(0, 1); glVertex2i(worldStart + i * HLINE		    , worldData[i].groundHeight - GRASS_HEIGHT);
			glTexCoord2i(0, 0); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight + cgh[1]);
			glTexCoord2i(1, 0); glVertex2i(worldStart + i * HLINE + HLINE    , worldData[i].groundHeight + cgh[1]);
			glTexCoord2i(1, 1); glVertex2i(worldStart + i * HLINE + HLINE    , worldData[i].groundHeight - GRASS_HEIGHT);
			glTexCoord2i(0, 1); glVertex2i(worldStart + i * HLINE + HLINE / 2, worldData[i].groundHeight - GRASS_HEIGHT);
		glEnd();
	}

	glUseProgram(0);
	glDisable(GL_TEXTURE_2D);

	/*
     * Draw remaining entities.
     */


    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, colorIndex);

    glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
    glUseProgram(shaderProgram);

	std::for_each(particles.begin(), particles.end(), [](Particles part) { if (!part.behind) part.draw(); });

    glUseProgram(0);

	for (auto &n : npc) {
		if (n->type != MERCHT)
            n->draw();
    }

	for (auto &m : mob)
		m.draw();

	for (auto &o : object)
		o.draw();

    /*
     * Handle grass-squishing.
     */

	// calculate the line that the player is on
	int ph = (p->loc.x + p->width / 2 - worldStart) / HLINE;

	// flatten grass under the player if the player is on the ground
	if (p->ground) {
		for (i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++)
			worldData[i].grassUnpressed = !(i < ph + 6 && i > ph - 6);
	} else {
		for (i = 0; i < (int)(worldData.size() - GROUND_HILLINESS); i++)
			worldData[i].grassUnpressed = true;
	}

	/*
     * Draw the player.
     */

	p->draw();
}

/**
 * Handles physics and such for a single entity.
 *
 * This function is kept private, as World::detect() should be used instead to
 * handle stuffs for all entities at once.
 */

void World::
singleDetect(Entity *e)
{
	std::string killed;
	unsigned int i,j;
	int l;

	/*
	 *	Kill any dead entities.
	*/

	if (e->alive && e->health <= 0) {
        e->alive = false;
        e->health = 0;
		for (i = 0; i < entity.size(); i++) {
			if (entity[i] == e) {
				switch (e->type) {
				case STRUCTURET:
					killed = "structure";
					for(j=0;j<build.size();j++) {
						if (build[j]==e) {
							delete build[j];
							build.erase(build.begin()+j);
							break;
						}
					}
					break;
				case NPCT:
					killed = "NPC";
					for(j=0;j<npc.size();j++) {
						if (npc[j]==e) {
							delete npc[j];
							npc.erase(npc.begin()+j);
							break;
						}
					}
					break;
				case MOBT:
					killed = "mob";
					/*for(j=0;j<mob.size();j++) {
						if (mob[j]==e) {
							delete mob[j];
							mob.erase(mob.begin()+j);
							break;
						}
					}*/
					break;
				case OBJECTT:
					killed = "object";
                    for (auto o = std::begin(object); o != std::end(object); o++) {
                        if (&(*o) == e) {
                            object.erase(o);
                            break;
                        }
                    }
					break;
				default:
					break;
				}
				std::cout << "Killed a " << killed << "..." << std::endl;
				entity.erase(entity.begin()+i);
				return;
			}
		}
		std::cout << "RIP " << e->name << "." << std::endl;
		exit(0);
	}

	// handle only living entities
	if (e->alive) {

        // forced movement gravity
        if (e->forcedMove) {
            if (e->vel.x > .0005 || e->vel.x < -.0005)
                e->vel.x *= .6;
            else
                e->forcedMove = false;
        }

		if (e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER)
			return;

		// calculate the line that this entity is currently standing on
		l = (e->loc.x + e->width / 2 - worldStart) / HLINE;
		if (l < 0)
            l = 0;
		i = l;
		if (i > lineCount - 1)
            i = lineCount - 1;

		// if the entity is under the world/line, pop it back to the surface
		if (e->loc.y < worldData[i].groundHeight) {
            int dir = e->vel.x < 0 ? -1 : 1;
            if (i + (dir * 2) < worldData.size() && worldData[i + (dir * 2)].groundHeight - 30 > worldData[i + dir].groundHeight) {
                e->loc.x -= (PLAYER_SPEED_CONSTANT + 2.7) * e->speed * 2 * dir;
                e->vel.x = 0;
            } else {
                e->loc.y = worldData[i].groundHeight - .001 * deltaTime;
		        e->ground = true;
		        e->vel.y = 0;
            }

		}

        // handle gravity if the entity is above the line
        else {

			if (e->type == STRUCTURET) {
				e->loc.y = worldData[i].groundHeight;
				e->vel.y = 0;
				e->ground = true;
				return;
			} else if (e->vel.y > -2)
                e->vel.y -= GRAVITY_CONSTANT * deltaTime;
		}

		/*
		 *	Insure that the entity doesn't fall off either edge of the world.
		*/

		if (e->loc.x < worldStart) {												// Left bound
			e->vel.x=0;
			e->loc.x=(float)worldStart + HLINE / 2;
		}else if (e->loc.x + e->width + HLINE > worldStart + worldStart * -2) {	// Right bound
			e->vel.x=0;
			e->loc.x=worldStart + worldStart * -2 - e->width - HLINE;
		}
	}
}

/**
 * Handle entity logic for the world.
 *
 * This function runs World::singleDetect() for the player and every entity
 * currently in a vector of this world. Particles and village entrance/exiting
 * are also handled here.
 */

void World::
detect(Player *p)
{
	int l;

	// handle the player
	std::thread(&World::singleDetect, this, p).detach();

    // handle other entities
	for (auto &e : entity)
		std::thread(&World::singleDetect, this, e).detach();

    // handle particles
	for (auto &part : particles) {

		// get particle's current world line
		l = (part.loc.x + part.width / 2 - worldStart) / HLINE;

		if (l < 0)
			l = 0;

		if (l > (int)(lineCount - 1))
			l = lineCount - 1;

		part.update(GRAVITY_CONSTANT, worldData[l].groundHeight);
	}

	// handle particle creation
	for (auto &b : build) {
		switch (b->bsubtype) {
		case FOUNTAIN:
			for (unsigned int r = (randGet() % 25) + 11; r--;) {
				addParticle(randGet() % HLINE * 3 + b->loc.x + b->width / 2,	// x
							b->loc.y + b->height,								// y
							HLINE * 1.25,										// width
							HLINE * 1.25,										// height
							randGet() % 7 * .01 * (randGet() % 2 == 0 ? -1 : 1),	// vel.x
							(4 + randGet() % 6) * .05,							// vel.y
							{ 0, 0, 255 },										// RGB color
							2500												// duration (ms)
							);

				particles.back().fountain = true;
			}
			break;

		case FIRE_PIT:
			for(unsigned int r = (randGet() % 20) + 11; r--;) {
				addParticle(randGet() % (int)(b->width / 2) + b->loc.x + b->width / 4,	// x
							b->loc.y + 3 * HLINE,										// y
							HLINE,														// width
							HLINE,														// height
							randGet() % 3 * .01 * (randGet() % 2 == 0 ? -1 : 1),		// vel.x
							(4 + randGet() % 6) * .005,									// vel.y
							{ 255, 0, 0 },												// RGB color
							400															// duration (ms)
							);

				particles.back().gravity = false;
				particles.back().behind  = true;
			}
			break;

		default:
			break;
		}
	}

	// draws the village welcome message if the player enters the village bounds
	for (auto &v : village) {
		if (p->loc.x > v.start.x && p->loc.x < v.end.x) {
			if (!v.in) {
				ui::passiveImportantText(5000, "Welcome to %s", v.name.c_str());
				v.in = true;
			}
		} else
			v.in = false;
	}
}

void World::addStructure(BUILD_SUB sub, float x,float y, std::string tex, std::string inside) {
	build.push_back(new Structures());
	build.back()->inWorld = this;
	build.back()->textureLoc = tex;

	build.back()->spawn(sub,x,y);

	build.back()->inside = inside;

	entity.push_back(build.back());
}

Village *World::
addVillage(std::string name, World *world)
{
    village.emplace_back(name.c_str(), world);
    return &village.back();
}

void World::addMob(int t,float x,float y) {
	mob.emplace_back(t);
	mob.back().spawn(x,y);

	entity.push_back(&mob.back());
}

void World::addMob(int t,float x,float y,void (*hey)(Mob *)) {
	mob.emplace_back(t);
	mob.back().spawn(x,y);
	mob.back().hey = hey;

	entity.push_back(&mob.back());
}

void World::addNPC(float x,float y) {
	npc.push_back(new NPC());
	npc.back()->spawn(x,y);

	entity.push_back(npc.back());
}

void World::addMerchant(float x, float y) {
	merchant.push_back(new Merchant());
	merchant.back()->spawn(x,y);

	npc.push_back(merchant.back());
	entity.push_back(npc.back());
}

void World::addObject(std::string in, std::string p, float x, float y) {
	object.emplace_back(in, p);
	object.back().spawn(x, y);

	entity.push_back(&object.back());
}

void World::
addParticle(float x, float y, float w, float h, float vx, float vy, Color color, int d)
{
	particles.emplace_back(x, y, w, h, vx, vy, color, d);
	particles.back().canMove = true;
}

void World::
addParticle(float x, float y, float w, float h, float vx, float vy, Color color, int d, unsigned char flags)
{
	particles.emplace_back(x, y, w, h, vx, vy, color, d);
	particles.back().canMove = true;
    particles.back().gravity = flags & (1 << 0);
    particles.back().bounce  = flags & (1 << 1);
}

void World::
addLight(vec2 loc, Color color)
{
	if (light.size() < 64)
        light.push_back(Light(loc, color, 1));
}

Light *World::
getLastLight(void)
{
    return &light.back();
}

Mob *World::
getLastMob(void)
{
    return &mob.back();
}

std::string World::
getSTextureLocation(unsigned int index) const
{
    if (index > sTexLoc.size())
        return "";

    return sTexLoc[ index ];
}

std::string World::
setToLeft(std::string file)
{
    return (toLeft = file);
}

std::string World::
setToRight(std::string file)
{
	return (toRight = file);
}

std::string World::
getToLeft(void) const
{
    return toLeft;
}

std::string World::
getToRight(void) const
{
    return toRight;
}

World *World::
goWorldLeft(Player *p)
{
	World *tmp;

    // check if player is at world edge
	if (!toLeft.empty() && p->loc.x < worldStart + HLINE * 15.0f) {

        // load world (`toLeft` conditional confirms existance)
	    tmp = loadWorldFromPtr(currentWorldToLeft);

        // adjust player location
		p->loc.x = tmp->worldStart + HLINE * 20;
		p->loc.y = tmp->worldData[tmp->lineCount - 1].groundHeight;

		return tmp;
	}

	return this;
}

bool World::
goWorldLeft(NPC *e)
{
	// check if entity is at world edge
	if (!toLeft.empty() && e->loc.x < worldStart + HLINE * 15.0f) {

        currentWorldToLeft->addNPC(e->loc.x,e->loc.y);
        e->alive = false;

		currentWorldToLeft->npc.back()->loc.x = 0;
		currentWorldToLeft->npc.back()->loc.y = GROUND_HEIGHT_MAXIMUM;

		return true;
	}

	return false;
}

World *World::
goWorldRight(Player *p)
{
	World *tmp;

	if (!toRight.empty() && p->loc.x + p->width > -worldStart - HLINE * 15) {
		tmp = loadWorldFromPtr(currentWorldToRight);

		p->loc.x = tmp->worldStart - HLINE * -15.0f;
		p->loc.y = GROUND_HEIGHT_MINIMUM;

		return tmp;
	}

	return this;
}

World *World::
goInsideStructure(Player *p)
{
	World *tmp;
	std::string current;

	if (inside.empty()) {
		for (auto &b : build) {
			if (p->loc.x            > b->loc.x            &&
			     p->loc.x + p->width < b->loc.x + b->width) {

                if (b->inside.empty())
                    return this;

				inside.push_back(currentXML.c_str() + xmlFolder.size());

				tmp = loadWorldFromXML(b->inside);

				ui::toggleBlackFast();
				ui::waitForCover();
				ui::toggleBlackFast();

                glClearColor(0,0,0,1);

				return tmp;
			}
		}
	} else {
        current = currentXML.c_str() + xmlFolder.size();
		tmp = loadWorldFromXML(inside.back());
		for (auto &b : tmp->build) {
			if (current == b->inside) {
				inside.pop_back();

				ui::toggleBlackFast();
				ui::waitForCover();

				p->loc.x = b->loc.x + (b->width / 2);

				ui::toggleBlackFast();

                glClearColor(1,1,1,1);

				return tmp;
			}
		}
	}

	return this;
}

void World::
addHole(unsigned int start, unsigned int end)
{
    if (end > worldData.size())
        end = worldData.size();

	for (unsigned int i = start; i < end; i++)
		worldData[i].groundHeight = 0;
}

void World::
addHill(const ivec2 peak, const unsigned int width)
{
	int start = peak.x - width / 2, end = start + width, offset = 0;
	const float thing = peak.y - worldData[start].groundHeight;
    const float period = PI / width;

	if (start < 0) {
        offset = -start;
        start = 0;
    }

	if (end > (signed)worldData.size())
	  end = worldData.size();

	for (int i = start; i < end; i++) {
		worldData[i].groundHeight += thing * sin((i - start + offset) * period);
		if (worldData[i].groundHeight > peak.y)
			worldData[i].groundHeight = peak.y;
	}
}

int World::
getTheWidth(void) const
{
	return worldStart * -2;
}

void World::save(void) {
	std::string data;

	std::string save = (std::string)currentXML + ".dat";
	std::ofstream out (save,std::ios::out | std::ios::binary);

	std::cout<<"Saving to "<<save<<" ..."<<std::endl;

	for(auto &n : npc) {
		data.append(std::to_string(n->dialogIndex) + "\n");
		data.append(std::to_string((int)n->loc.x) + "\n");
		data.append(std::to_string((int)n->loc.y) + "\n");
	}

	for(auto &b : build) {
		data.append(std::to_string((int)b->loc.x) + "\n");
		data.append(std::to_string((int)b->loc.y) + "\n");
	}

	for(auto &m : mob) {
		data.append(std::to_string((int)m.loc.x) + "\n");
		data.append(std::to_string((int)m.loc.y) + "\n");
		data.append(std::to_string((int)m.alive) + "\n");
	}

	data.append("dOnE\0");
	out.write(data.c_str(),data.size());
	out.close();
}

void World::load(void) {
	std::string save,data,line;
	const char *filedata;

	save = std::string(currentXML + ".dat");
	filedata = readFile(save.c_str());
	data = filedata;
	std::istringstream iss (data);

	for(auto &n : npc) {
		std::getline(iss,line);
		if (line == "dOnE")return;
		if ((n->dialogIndex = std::stoi(line)) != 9999)
			n->addAIFunc(commonAIFunc,false);
		else n->clearAIFunc();

		std::getline(iss,line);
		if (line == "dOnE")return;
		n->loc.x = std::stoi(line);
		std::getline(iss,line);
		if (line == "dOnE")return;
		n->loc.y = std::stoi(line);
	}

	for(auto &b : build) {
		std::getline(iss,line);
		if (line == "dOnE")return;
		b->loc.x = std::stoi(line);
		std::getline(iss,line);
		if (line == "dOnE")return;
		b->loc.y = std::stoi(line);
	}

	for(auto &m : mob) {
		std::getline(iss,line);
		if (line == "dOnE")return;
		m.loc.x = std::stoi(line);
		std::getline(iss,line);
		if (line == "dOnE")return;
		m.loc.y = std::stoi(line);
		std::getline(iss,line);
		if (line == "dOnE")return;
		m.alive = std::stoi(line);
	}

	while(std::getline(iss,line)) {
		if (line == "dOnE")
			break;
	}

	delete[] filedata;
}

float getIndoorWorldFloorHeight(void)
{
    return INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS;
}

bool isCurrentWorldIndoors(void) {
    return !inside.empty();
}

IndoorWorld::IndoorWorld(void) {
}

IndoorWorld::~IndoorWorld(void) {
	delete bgTex;

	deleteEntities();
}

void IndoorWorld::
addFloor(unsigned int width)
{
    if (floor.empty())
        generate(width);
    floor.emplace_back(width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS);
    fstart.push_back(0);
}


void IndoorWorld::
addFloor(unsigned int width, unsigned int start)
{
    if (floor.empty())
        generate(width);
    floor.emplace_back(width, floor.size() * INDOOR_FLOOR_HEIGHTT + INDOOR_FLOOR_THICKNESS);
    fstart.push_back(start);
}

bool IndoorWorld::
moveToFloor(Entity *e, unsigned int _floor)
{
    if (_floor > floor.size())
        return false;

    e->loc.y = floor[_floor - 1][0];
    return true;
}

bool IndoorWorld::
isFloorAbove(Entity *e)
{
    for (unsigned int i = 0; i < floor.size(); i++) {
        if (floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y)
            return (i + 1) != floor.size();
    }
    return false;
}

bool IndoorWorld::
isFloorBelow(Entity *e)
{
    for (unsigned int i = 0; i < floor.size(); i++) {
        if (floor[i][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y)
            return i > 0;
    }
    return false;
}

void IndoorWorld::
singleDetect(Entity *e)
{
    unsigned int floornum = 0;
    float start, end;

    if (!e->alive)
        return;
    if (e->type == MOBT && Mobp(e)->subtype == MS_TRIGGER)
        return;

    for (; floornum < floor.size(); floornum++) {
        if (floor[floornum][0] + INDOOR_FLOOR_HEIGHTT - 100 > e->loc.y) {
            if (e->loc.y < floor[floornum][0]) {
                e->loc.y = floor[floornum][0];
                e->vel.y = 0;
                e->ground = true;
            }
            break;
        }
    }

    if (e->vel.y > -2)
        e->vel.y -= GRAVITY_CONSTANT * deltaTime;

    if (e->ground) {
        e->loc.y = ceil(e->loc.y);
        e->vel.y = 0;
    }

    start = worldStart + fstart[floornum] * HLINE;
    end = start + floor[floornum].size() * HLINE;

    if (e->loc.x < start) {
        e->vel.x = 0;
        e->loc.x = start + HLINE / 2;
    } else if (e->loc.x + e->width + HLINE > end) {
        e->vel.x = 0;
        e->loc.x = end - e->width - HLINE;
    }

}

void IndoorWorld::
draw(Player *p)
{
	unsigned int i,f;
	int x;

    // draw lights
    for (auto &l : light) {
        if (l.belongsTo) {
            l.loc.x = l.following->loc.x + SCREEN_WIDTH / 2;
            l.loc.y = (l.following->loc.y > SCREEN_HEIGHT / 2) ? SCREEN_HEIGHT / 2 : l.following->loc.y;
        }
        if (l.flame) {
            l.fireFlicker = .9 + ((rand() % 2) / 10.0f);
            l.fireLoc.x = l.loc.x + (rand() % 2 - 1) * 3;
            l.fireLoc.y = l.loc.y + (rand() % 2 - 1) * 3;
        } else
            l.fireFlicker = 1.0f;
    }

    std::unique_ptr<GLfloat[]> pointArrayBuf = std::make_unique<GLfloat[]> (2 * (light.size()));
	auto pointArray = pointArrayBuf.get();
    GLfloat flameArray[64];

	for (i = 0; i < light.size(); i++) {
        if (light[i].flame) {
    		pointArray[2 * i    ] = light[i].fireLoc.x - offset.x;
    		pointArray[2 * i + 1] = light[i].fireLoc.y;
        }else{
            pointArray[2 * i    ] = light[i].loc.x - offset.x;
            pointArray[2 * i + 1] = light[i].loc.y;
        }
	}

    for(i = 0; i < light.size(); i++)
        flameArray[i] = light[i].fireFlicker;

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

	glUseProgram(shaderProgram);
	glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
	glUniform1f(glGetUniformLocation(shaderProgram, "amb"), 0.02f + light.size()/50.0f);

	if (light.empty())
		glUniform1i(glGetUniformLocation(shaderProgram, "numLight"), 0);
	else {
		glUniform1i (glGetUniformLocation(shaderProgram, "numLight"), light.size());
		glUniform2fv(glGetUniformLocation(shaderProgram, "lightLocation"), light.size(), pointArray);
		glUniform3f (glGetUniformLocation(shaderProgram, "lightColor"), 1.0f, 1.0f, 1.0f);
        glUniform1fv(glGetUniformLocation(shaderProgram, "fireFlicker"), light.size(), flameArray);
	}

	bgTex->bind(0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); //for the s direction
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); //for the t direction
	glColor4ub(255,255,255,255);

    glBegin(GL_QUADS);
        glTexCoord2i(0,1);							     glVertex2i(worldStart - SCREEN_WIDTH / 2,0);
		glTexCoord2i((-worldStart*2+SCREEN_WIDTH)/512,1);glVertex2i(-worldStart + SCREEN_WIDTH / 2,0);
		glTexCoord2i((-worldStart*2+SCREEN_WIDTH)/512,0);glVertex2i(-worldStart + SCREEN_WIDTH / 2,SCREEN_HEIGHT);
		glTexCoord2i(0,0);							     glVertex2i(worldStart - SCREEN_WIDTH / 2,SCREEN_HEIGHT);
    glEnd();

    glUseProgram(0);

	/*
	 *	Draw the ground.
	*/

	glUseProgram(shaderProgram);
	glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
	glBegin(GL_QUADS);
        safeSetColor(150, 100, 50);
        for (f = 0; f < floor.size(); f++) {
            i = 0;
    		for (h : floor[f]) {
    			x = worldStart + fstart[f] * HLINE + (i * HLINE);
    			glVertex2i(x        , h            );
    			glVertex2i(x + HLINE, h            );
    			glVertex2i(x + HLINE, h - INDOOR_FLOOR_THICKNESS);
    			glVertex2i(x        , h - INDOOR_FLOOR_THICKNESS);
                i++;
    		}
        }
	glEnd();
	glUseProgram(0);

	/*
	 *	Draw all entities.
	*/
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, colorIndex);

    glUniform1i(glGetUniformLocation(shaderProgram, "sampler"), 0);
    glUseProgram(shaderProgram);

    std::for_each(particles.begin(), particles.end(), [](Particles &part) { part.draw(); });

    glUseProgram(0);

	/*for (auto &part : particles)
		part.draw();*/

	for (auto &e : entity)
		e->draw();

	p->draw();
}

Arena::Arena(World *leave,Player *p,Mob *m) {
	generate(800);
	addMob(MS_DOOR,100,100);

	inBattle = true;
	mmob = m;
	mmob->aggressive = false;

	mob.push_back(*m);
	entity.push_back(&mob.back());

	battleNest.push_back(leave);
	battleNestLoc.push_back(p->loc);
}

Arena::~Arena(void) {
	deleteEntities();
}

World *Arena::exitArena(Player *p) {
	World *tmp;
	if (!mmob->alive &&
         p->loc.x + p->width / 2 > mob[0].loc.x &&
	     p->loc.x + p->width / 2 < mob[0].loc.x + HLINE * 12) {
		tmp = battleNest.front();
		battleNest.erase(battleNest.begin());

		inBattle = !battleNest.empty();
		ui::toggleBlackFast();
		ui::waitForCover();

		p->loc = battleNestLoc.back();
		battleNestLoc.pop_back();

		mob.clear();
		mmob->alive = false;

		return tmp;
	}else{
		return this;
	}
}

std::string getWorldWeatherStr(WorldWeather ww)
{
    switch (ww) {
    case WorldWeather::Sunny:
        return "Sunny";
        break;
    case WorldWeather::Dark:
        return "Darky";
        break;
    case WorldWeather::Rain:
        return "Rainy";
        break;
    default:
        return "Snowy";
        break;
    }
}

static bool loadedLeft = false;
static bool loadedRight = false;

World *loadWorldFromXML(std::string path) {
	if (!currentXML.empty())
		currentWorld->save();

	return loadWorldFromXMLNoSave(path);
}

World *loadWorldFromPtr(World *ptr)
{
    World *tmp = ptr;

    loadedLeft = true;
    currentWorldToLeft = loadWorldFromXML(tmp->getToLeft());
    loadedLeft = false;

    loadedRight = true;
    currentWorldToRight = loadWorldFromXML(tmp->getToRight());
    loadedRight = false;

    return tmp;
}

/**
 * Loads a world from the given XML file.
 */

World *
loadWorldFromXMLNoSave(std::string path) {
	XMLDocument xml;
	XMLElement *wxml;
	XMLElement *vil;

	World *tmp;
	float spawnx, randx;
	bool dialog,Indoor;
    unsigned int flooor;

	const char *ptr;
	std::string name, sptr;

    // no file? -> no world
    if (path.empty())
        return NULL;

    currentXML = std::string(xmlFolder + path);
	xml.LoadFile(currentXML.c_str());

    // attempt to load a <World> tag
	if ((wxml = xml.FirstChildElement("World"))) {
		wxml = wxml->FirstChildElement();
		vil = xml.FirstChildElement("World")->FirstChildElement("village");
		tmp = new World();
        Indoor = false;
	}

    // attempt to load an <IndoorWorld> tag
    else if ((wxml = xml.FirstChildElement("IndoorWorld"))) {
		wxml = wxml->FirstChildElement();
		vil = NULL;
		tmp = new IndoorWorld();
        Indoor = true;
	}

    // error: can't load a world...
    else
        UserError("XML Error: Cannot find a <World> or <IndoorWorld> tag in " + currentXML + "!");

    // iterate through world tags
	while (wxml) {
		name = wxml->Name();

        // world linkage
		if (name == "link") {

            // links world to the left
			if ((ptr = wxml->Attribute("left"))) {
				tmp->setToLeft(ptr);

                // load the left world if it isn't
                if (!loadedLeft) {
                    loadedLeft = true;
                    currentWorldToLeft = loadWorldFromXMLNoSave(ptr);
                    loadedLeft = false;
                }
			}

            // links world to the right
            else if ((ptr = wxml->Attribute("right"))) {
				tmp->setToRight(ptr);

                // load the right world if it isn't
                if (!loadedRight) {
                    loadedRight = true;
                    currentWorldToRight = loadWorldFromXMLNoSave(ptr);
                    loadedRight = false;
                }
			}

			// tells what world is outside, if in a structure
			else if (Indoor && (ptr = wxml->Attribute("outside")))
				inside.push_back(ptr);

            // error, invalid link tag
            else
                UserError("XML Error: Invalid <link> tag in " + currentXML + "!");

		}

        // style tags
        else if (name == "style") {
            // set style folder
			tmp->setStyle(wxml->StrAttribute("folder"));

            // set background folder
            if (wxml->QueryUnsignedAttribute("background", &flooor) != XML_NO_ERROR)
                UserError("XML Error: No background given in <style> in " + currentXML + "!");
			tmp->setBackground((WorldBGType)flooor);

            // set BGM file
            tmp->setBGM(wxml->StrAttribute("bgm"));
		}

        // world generation (for outdoor areas)
        else if (name == "generation") {
            // random gen.
			if (!Indoor && wxml->StrAttribute("type") == "Random")
				tmp->generate(wxml->UnsignedAttribute("width"));
            else {
                if (Indoor)
                    UserError("XML Error: <generation> tags can't be in <IndoorWorld> tags (in " + currentXML + ")!");
                else
                    UserError("XML Error: Invalid <generation> tag in " + currentXML + "!");
            }
		}

        // mob creation
        else if (name == "mob") {
            // type info
            if (wxml->QueryUnsignedAttribute("type", &flooor) != XML_NO_ERROR)
                UserError("XML Error: Invalid type value in <mob> in " + currentXML + "!");

            // spawn at coordinate if desired
			if (wxml->QueryFloatAttribute("x", &spawnx) == XML_NO_ERROR)
				tmp->addMob(flooor, spawnx, wxml->FloatAttribute("y"));
			else
				tmp->addMob(flooor, 0, 100);

            // aggressive tag
			if (wxml->QueryBoolAttribute("aggressive", &dialog) == XML_NO_ERROR)
				tmp->getLastMob()->aggressive = dialog;

            // indoor spawning floor selection
            if (Indoor && wxml->QueryUnsignedAttribute("floor", &flooor) == XML_NO_ERROR)
                Indoorp(tmp)->moveToFloor(tmp->npc.back(), flooor);

            // custom health value
            if (wxml->QueryFloatAttribute("health", &spawnx) == XML_NO_ERROR)
                tmp->getLastMob()->health = tmp->getLastMob()->maxHealth = spawnx;
		}

        // npc creation
        else if (name == "npc") {
			const char *npcname;

            // spawn at coordinates if desired
			if (wxml->QueryFloatAttribute("x", &spawnx) == XML_NO_ERROR)
				tmp->addNPC(spawnx, 100);
			else
				tmp->addNPC(0, 100);

            // name override
			if ((npcname = wxml->Attribute("name"))) {
                delete[] tmp->npc.back()->name;
				tmp->npc.back()->name = new char[strlen(npcname) + 1];
				strcpy(tmp->npc.back()->name, npcname);
			}

            // dialog enabling
			dialog = false;
			if (wxml->QueryBoolAttribute("hasDialog", &dialog) == XML_NO_ERROR && dialog)
				tmp->npc.back()->addAIFunc(commonAIFunc, false);
			else
                tmp->npc.back()->dialogIndex = 9999;

            if (Indoor && wxml->QueryUnsignedAttribute("floor", &flooor) == XML_NO_ERROR)
                Indoorp(tmp)->moveToFloor(tmp->npc.back(), flooor);

            // custom health value
            if (wxml->QueryFloatAttribute("health", &spawnx) == XML_NO_ERROR)
                tmp->npc.back()->health = tmp->npc.back()->maxHealth = spawnx;
		}

        // structure creation
        else if (name == "structure") {
			tmp->addStructure((BUILD_SUB) wxml->UnsignedAttribute("type"),
							   wxml->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ?
							       getRand() % tmp->getTheWidth() / 2.0f : spawnx,
							   100,
							   wxml->StrAttribute("texture"),
							   wxml->StrAttribute("inside")
               );
		} else if (name == "trigger") {
			tmp->addMob(MS_TRIGGER, wxml->FloatAttribute("x"), 0, commonTriggerFunc);
			tmp->getLastMob()->heyid = wxml->Attribute("id");
		} else if (name == "page") {
			tmp->addMob(MS_PAGE, wxml->FloatAttribute("x"), 0, commonPageFunc);
			tmp->getLastMob()->heyid = wxml->Attribute("id");
		} else if (name == "hill") {
			tmp->addHill(ivec2 { wxml->IntAttribute("peakx"), wxml->IntAttribute("peaky") }, wxml->UnsignedAttribute("width"));
		} else if (name == "time") {
            tickCount = std::stoi(wxml->GetText());
        } else if (Indoor && name == "floor") {
            if (wxml->QueryFloatAttribute("start",&spawnx) == XML_NO_ERROR)
                Indoorp(tmp)->addFloor(wxml->UnsignedAttribute("width"), spawnx);
            else
                Indoorp(tmp)->addFloor(wxml->UnsignedAttribute("width"));
        }

        spawnx = 0;
		wxml = wxml->NextSiblingElement();
	}

	Village *vptr;

	if (vil) {
		vptr = tmp->addVillage(vil->Attribute("name"), tmp);
		vil = vil->FirstChildElement();
	}

	while(vil) {
		name = vil->Name();
		randx = 0;

		/**
		 * 	READS DATA ABOUT STRUCTURE CONTAINED IN VILLAGE
		 */

		if (name == "structure") {
			tmp->addStructure((BUILD_SUB)vil->UnsignedAttribute("type"),
							   vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
							   100,
							   vil->StrAttribute("texture"),
							   vil->StrAttribute("inside"));
		} else if (name == "stall") {
            sptr = vil->StrAttribute("type");

            // handle markets
            if (sptr == "market") {

                // create a structure and a merchant, and pair them
                tmp->addStructure(STALL_MARKET,
                                   vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
                                   100,
							       vil->StrAttribute("texture"),
							       vil->StrAttribute("inside")
                   );
				tmp->addMerchant(0, 100);

                tmp->merchant.back()->inside = tmp->build.back();
            }

            // handle traders
            else if (sptr == "trader") {
				tmp->addStructure(STALL_TRADER,
							       vil->QueryFloatAttribute("x", &spawnx) != XML_NO_ERROR ? randx : spawnx,
							       100,
							       vil->StrAttribute("texture"),
							       vil->StrAttribute("inside")
                   );
			}

            // loop through buy/sell/trade tags
            XMLElement *sxml = vil->FirstChildElement();
            std::string tag;
            while (sxml) {
                tag = sxml->Name();

                if (tag == "buy") { //converts price to the currencies determined in items.xml
                    // TODO
                } else if (tag == "sell") { //converts price so the player can sell
                    // TODO
                } else if (tag == "trade") { //doesn't have to convert anything, we just trade multiple items
                	tmp->merchant.back()->trade.push_back(Trade(sxml->IntAttribute("quantity"),
																sxml->StrAttribute("item"),
																sxml->IntAttribute("quantity1"),
																sxml->StrAttribute("item1")));
				} else if (tag == "text") { //this is what the merchant says
                    std::cout << "text" << std::endl;

                    XMLElement *txml = sxml->FirstChildElement();
                    std::string textOption;

                    while (txml) {
                        textOption = txml->Name();
                        const char* buf = txml->GetText();

                        if (textOption == "greet") { //when you talk to him
                            tmp->merchant.back()->text[0] = std::string(buf, strlen(buf));
                            tmp->merchant.back()->toSay = &tmp->merchant.back()->text[0];
                        } else if (textOption == "accept") { //when he accepts the trade
                            tmp->merchant.back()->text[1] = std::string(buf, strlen(buf));
                        } else if (textOption == "deny") { //when you don't have enough money
                            tmp->merchant.back()->text[2] = std::string(buf, strlen(buf));
                        } else if (textOption == "leave") { //when you leave the merchant
                            tmp->merchant.back()->text[3] = std::string(buf, strlen(buf));
                        }
                        txml = txml->NextSiblingElement();
                    }
                }

                sxml = sxml->NextSiblingElement();
			}
		}

		vptr->build.push_back(tmp->build.back());

		if (vptr->build.back()->loc.x < vptr->start.x) {
			vptr->start.x = vptr->build.back()->loc.x;
		}

		if (vptr->build.back()->loc.x + vptr->build.back()->width > vptr->end.x) {
			vptr->end.x = vptr->build.back()->loc.x + vptr->build.back()->width;
		}

		//go to the next element in the village block
		vil = vil->NextSiblingElement();
	}

	std::ifstream dat (((std::string)currentXML + ".dat").c_str());
	if (dat.good()) {
		dat.close();
		tmp->load();
	}

	return tmp;
}

Village::Village(const char *meme, World *w) {
	name = meme;
	start.x = w->getTheWidth() / 2.0f;
	end.x = -start.x;
	in = false;
}