#include "Dengine/WorldTraveller.h"
#include "Dengine/Audio.h"
#include "Dengine/Debug.h"
#include "Dengine/Entity.h"
#include "Dengine/Platform.h"
#include "Dengine/UserInterface.h"

enum State
{
	state_active,
	state_menu,
	state_win,
};

enum EventType
{
	eventtype_null = 0,
	eventtype_start_attack,
	eventtype_end_attack,
	eventtype_start_anim,
	eventtype_end_anim,
	eventtype_entity_died,
	eventtype_count,
};

typedef struct Event
{
	enum EventType type;
	void *data;
} Event;

typedef struct EventQueue
{
	Event queue[1024];
	i32 numEvents;
} EventQueue;

INTERNAL Entity *getHeroEntity(World *world)
{
	Entity *result = &world->entities[entity_getIndex(world, world->heroId)];
	return result;
}

INTERNAL void rendererInit(GameState *state, v2 windowSize)
{
	AssetManager *assetManager = &state->assetManager;
	Renderer *renderer         = &state->renderer;
	renderer->size             = windowSize;
	// NOTE(doyle): Value to map a screen coordinate to NDC coordinate
	renderer->vertexNdcFactor =
	    V2(1.0f / renderer->size.w, 1.0f / renderer->size.h);
	renderer->shader = asset_getShader(assetManager, shaderlist_sprite);
	shader_use(renderer->shader);

	const mat4 projection =
	    mat4_ortho(0.0f, renderer->size.w, 0.0f, renderer->size.h, 0.0f, 1.0f);
	shader_uniformSetMat4fv(renderer->shader, "projection", projection);
	GL_CHECK_ERROR();

	/* Create buffers */
	glGenVertexArrays(1, &renderer->vao);
	glGenBuffers(1, &renderer->vbo);
	GL_CHECK_ERROR();

	/* Bind buffers */
	glBindBuffer(GL_ARRAY_BUFFER, renderer->vbo);
	glBindVertexArray(renderer->vao);

	/* Configure VAO */
	const GLuint numVertexElements = 4;
	const GLuint vertexSize        = sizeof(v4);
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, numVertexElements, GL_FLOAT, GL_FALSE, vertexSize,
	                      (GLvoid *)0);
	GL_CHECK_ERROR();

	/* Unbind */
	glBindBuffer(GL_ARRAY_BUFFER, 0);
	glBindVertexArray(0);
	GL_CHECK_ERROR();

#ifdef DENGINE_DEBUG
	DEBUG_LOG("Renderer initialised");
#endif
}

typedef struct XmlAttribute
{
	b32 init;
	char *name;
	char *value;

	struct XmlAttribute *next;
} XmlAttribute;

typedef struct XmlNode
{
	char *name;
	XmlAttribute attribute;

	// NOTE(doyle): Track if node has more children
	b32 isClosed;

	// NOTE(doyle): Direct child/parent
	struct XmlNode *parent;
	struct XmlNode *child;

	// NOTE(doyle): Else all other nodes
	struct XmlNode *next;
} XmlNode;

enum XmlTokenType
{
	xmltokentype_unknown,
	xmltokentype_openArrow,
	xmltokentype_closeArrow,
	xmltokentype_name,
	xmltokentype_value,
	xmltokentype_equals,
	xmltokentype_quotes,
	xmltokentype_backslash,
	xmltokentype_count,
};

typedef struct XmlToken
{
	// TODO(doyle): Dynamic size string in tokens maybe.
	enum XmlTokenType type;
	char string[128];
	i32 len;
} XmlToken;

#define DEBUG_RECURSIVE_PRINT_XML_TREE(sig) debug_recursivePrintXmlTree(sig, 1)
INTERNAL void debug_recursivePrintXmlTree(XmlNode *root, i32 levelsDeep)
{
	if (!root)
	{
		return;
	}
	else
	{
		for (i32 i = 0; i < levelsDeep; i++)
		{
			printf("-");
		}

		printf("%s ", root->name);

		XmlAttribute *attribute = &root->attribute;
		printf("| %s = %s", attribute->name, attribute->value);

		while (attribute->next)
		{
			attribute = attribute->next;
			printf("| %s = %04s", attribute->name, attribute->value);
		}
		printf("\n");

		debug_recursivePrintXmlTree(root->child, levelsDeep+1);
		debug_recursivePrintXmlTree(root->next, levelsDeep);
	}
}

INTERNAL void assetInit(GameState *state)
{
	AssetManager *assetManager = &state->assetManager;
	MemoryArena *arena = &state->arena;

	/* Create empty 1x1 4bpp black texture */
	u32 bitmap       = (0xFF << 24) | (0xFF << 16) | (0xFF << 8) | (0xFF << 0);
	Texture emptyTex = texture_gen(1, 1, 4, CAST(u8 *)(&bitmap));
	assetManager->textures[texlist_empty] = emptyTex;

	/*
	 **********************
	 * Tokenise XML Buffer
	 **********************
	 */
	PlatformFileRead xmlFileRead = {0};

	i32 result = platform_readFileToBuffer(
	    arena, "data/textures/WorldTraveller/ClaudeSpriteSheet.xml",
	    &xmlFileRead);

	XmlToken *xmlTokens = PLATFORM_MEM_ALLOC(arena, 8192, XmlToken);
	i32 tokenIndex     = 0;
	if (result)
	{
		DEBUG_LOG("Failed to read sprite sheet xml");
	}
	else
	{
		for (i32 i = 0; i < xmlFileRead.size; i++)
		{
			char c = (CAST(char *)xmlFileRead.buffer)[i];
			switch (c)
			{
			case '<':
			case '>':
			case '=':
			case '/':
			{

				enum XmlTokenType type = xmltokentype_unknown;
				if (c == '<')
				{
					type = xmltokentype_openArrow;
				}
				else if (c == '>')
				{
					type = xmltokentype_closeArrow;
				}
				else if (c == '=')
				{
					type = xmltokentype_equals;
				}
				else
				{
					type = xmltokentype_backslash;
				}

				xmlTokens[tokenIndex].type = type;
				xmlTokens[tokenIndex].len = 1;
				tokenIndex++;
				break;
			}

			case '"':
			{
				xmlTokens[tokenIndex].type = xmltokentype_value;
				for (i32 j = i + 1; j < xmlFileRead.size; j++)
				{
					char c = (CAST(char *) xmlFileRead.buffer)[j];

					if (c == '"')
					{
						break;
					}
					else
					{
						xmlTokens[tokenIndex]
						    .string[xmlTokens[tokenIndex].len++] = c;
#ifdef DENGINE_DEBUG
						ASSERT(xmlTokens[tokenIndex].len <
						       ARRAY_COUNT(xmlTokens[tokenIndex].string));
#endif
					}
				}

				// NOTE(doyle): +1 to skip the closing quotes
				i += (xmlTokens[tokenIndex].len + 1);
				tokenIndex++;
				break;
			}

			default:
			{
				if ((c >= 'a' && c <= 'z') || c >= 'A' && c <= 'Z')
				{
					xmlTokens[tokenIndex].type = xmltokentype_name;
					for (i32 j = i; j < xmlFileRead.size; j++)
					{
						char c = (CAST(char *) xmlFileRead.buffer)[j];

						if (c == ' ' || c == '=' || c == '>' || c == '<' ||
						    c == '\\')
						{
							break;
						}
						else
						{
							xmlTokens[tokenIndex]
							    .string[xmlTokens[tokenIndex].len++] = c;
#ifdef DENGINE_DEBUG
							ASSERT(xmlTokens[tokenIndex].len <
							       ARRAY_COUNT(xmlTokens[tokenIndex].string));
#endif
						}
					}
					i += xmlTokens[tokenIndex].len;
					tokenIndex++;
				}
				break;
			}
			}
		}
	}

	XmlNode root = {0};
	XmlNode *node = &root;
	node->parent  = node;
	for (i32 i = 0; i < tokenIndex; i++)
	{
		XmlToken *token = &xmlTokens[i];
		switch (token->type)
		{

		case xmltokentype_openArrow:
		{
			/* Open arrows indicate closing parent node or new node name */
			XmlToken *nextToken = &xmlTokens[++i];
			if (nextToken->type == xmltokentype_backslash)
			{
				nextToken = &xmlTokens[++i];
				if (common_strcmp(nextToken->string, node->parent->name) == 0)
				{
					node->parent->isClosed = TRUE;
					node           = node->parent;
				}
				else
				{
#ifdef DENGINE_DEBUG
					DEBUG_LOG(
					    "Closing xml node name does not match parent name");
#endif
				}
			}
			else if (nextToken->type == xmltokentype_name)
			{
				node->name = nextToken->string;
			}
			else
			{
#ifdef DENGINE_DEBUG
				DEBUG_LOG("Unexpected token type after open arrow");
#endif
			}

			token = nextToken;
			break;
		}

		case xmltokentype_name:
		{
			// TODO(doyle): Store latest attribute pointer so we aren't always
			// chasing the linked list each iteration. Do the same for children
			// node

			/* Xml Attributes are a linked list, get first free entry */
			XmlAttribute *attribute = &node->attribute;
			if (attribute->init)
			{
				while (attribute->next)
					attribute = attribute->next;

				attribute->next = PLATFORM_MEM_ALLOC(arena, 1, XmlAttribute);
				attribute = attribute->next;
			}

			/* Just plain text is a node attribute name */
			attribute->name = token->string;

			/* Followed by the value */
			token            = &xmlTokens[++i];
			attribute->value = token->string;
			attribute->init = TRUE;
			break;
		}

		case xmltokentype_closeArrow:
		{
			XmlToken prevToken = xmlTokens[i - 1];

			/* Closed node means we can return to parent */
			if (prevToken.type == xmltokentype_backslash)
			{
				node->isClosed = TRUE;
				node = node->parent;
			}
			
			if (!node->isClosed)
			{
				/* Unclosed node means next fields will be children of node */

				/* If the first child is free allocate, otherwise we have to
				 * iterate through the child's next node(s) */
				if (!node->child)
				{
					node->child         = PLATFORM_MEM_ALLOC(arena, 1, XmlNode);
					node->child->parent = node;
					node                = node->child;
				}
				else
				{
					XmlNode *nodeToCheck = node->child;
					while (nodeToCheck->next)
						nodeToCheck = nodeToCheck->next;

					nodeToCheck->next = PLATFORM_MEM_ALLOC(arena, 1, XmlNode);
					nodeToCheck->next->parent = node;
					node                      = nodeToCheck->next;
				}
			}
			break;
		}

		default:
		{
			break;
		}

		}
	}

	DEBUG_RECURSIVE_PRINT_XML_TREE(&root);

	node = &root;
	while (node)
	{
		if(common_strcmp(node->name, "TextureAtlas") == 0)
		{
			XmlNode *atlasXmlNode   = node;
			XmlNode *atlasChildNode = atlasXmlNode->child;
			while (atlasChildNode)
			{
				if (common_strcmp(atlasChildNode->name, "SubTexture") == 0)
				{
					XmlAttribute *subTextureAttrib = &atlasChildNode->attribute;
					while (subTextureAttrib)
					{
						// TODO(doyle): Fill in details properly
						Rect rect = {0};
						if (common_strcmp(subTextureAttrib->name, "name") == 0)
						{
						}
						else if (common_strcmp(subTextureAttrib->name, "x") ==
						         0)
						{
							char *name  = subTextureAttrib->name;
							i32 nameLen = common_strlen(name);
							rect.pos.x  = CAST(f32) common_atoi(name, nameLen);
						}
						else if (common_strcmp(subTextureAttrib->name, "y") ==
						         0)
						{
							char *name  = subTextureAttrib->name;
							i32 nameLen = common_strlen(name);
							rect.pos.y  = CAST(f32) common_atoi(name, nameLen);
						}
						else if (common_strcmp(subTextureAttrib->name,
						                       "width") == 0)
						{
							char *name  = subTextureAttrib->name;
							i32 nameLen = common_strlen(name);
							rect.size.w = CAST(f32) common_atoi(name, nameLen);
						}
						else if (common_strcmp(subTextureAttrib->name,
						                       "height") == 0)
						{
							char *name  = subTextureAttrib->name;
							i32 nameLen = common_strlen(name);
							rect.size.h = CAST(f32) common_atoi(name, nameLen);
						}
						else
						{
#ifdef DENGINE_DEBUG
							DEBUG_LOG(
							    "Unsupported xml attribute in SubTexture");
#endif
						}

						subTextureAttrib = subTextureAttrib->next;
					}
				}
				else
				{
#ifdef DENGINE_DEBUG
					DEBUG_LOG("Unsupported xml node name not parsed");
#endif
				}

				atlasChildNode = atlasChildNode->next;
			}
		}
		else
		{
#ifdef DENGINE_DEBUG
			DEBUG_LOG("Unsupported xml node name not parsed");
#endif
		}

		node = node->next;
	}

	/* Load textures */
	asset_loadTextureImage(assetManager,
	                       "data/textures/WorldTraveller/TerraSprite1024.png",
	                       texlist_hero);
	TexAtlas *heroAtlas = asset_getTextureAtlas(assetManager, texlist_hero);
	heroAtlas->texRect[herorects_idle]       = V4(746, 920, 804, 1018);
	heroAtlas->texRect[herorects_walkA]      = V4(641, 920, 699, 1018);
	heroAtlas->texRect[herorects_walkB]      = V4(849, 920, 904, 1018);
	heroAtlas->texRect[herorects_head]       = V4(108, 975, 159, 1024);
	heroAtlas->texRect[herorects_waveA]      = V4(944, 816, 1010, 918);
	heroAtlas->texRect[herorects_waveB]      = V4(944, 710, 1010, 812);
	heroAtlas->texRect[herorects_battlePose] = V4(8, 814, 71, 910);
	heroAtlas->texRect[herorects_castA]      = V4(428, 814, 493, 910);
	heroAtlas->texRect[herorects_castB]      = V4(525, 816, 590, 919);
	heroAtlas->texRect[herorects_castC]      = V4(640, 816, 698, 916);

	asset_loadTextureImage(assetManager,
	                       "data/textures/WorldTraveller/Terrain.png",
	                       texlist_terrain);
	TexAtlas *terrainAtlas =
	    asset_getTextureAtlas(assetManager, texlist_terrain);
	f32 atlasTileSize = 128.0f;
	const i32 texSize = 1024;
	v2 texOrigin = V2(0, 768);
	terrainAtlas->texRect[terrainrects_ground] =
	    V4(texOrigin.x, texOrigin.y, texOrigin.x + atlasTileSize,
	       texOrigin.y + atlasTileSize);

	/* Load shaders */
	asset_loadShaderFiles(assetManager, arena, "data/shaders/sprite.vert.glsl",
	                      "data/shaders/sprite.frag.glsl",
	                      shaderlist_sprite);

	result =
	    asset_loadTTFont(assetManager, arena, "C:/Windows/Fonts/Arialbd.ttf");

#ifdef DENGINE_DEBUG
	if (result) DEBUG_LOG("Font loading failed");
	GL_CHECK_ERROR();
	DEBUG_LOG("Assets loaded");
#endif

	/* Load animations */
	f32 duration = 1.0f;
	i32 numRects = 1;
	v4 *animRects = PLATFORM_MEM_ALLOC(arena, numRects, v4);
	i32 terrainAnimAtlasIndexes[1] = {terrainrects_ground};

	// TODO(doyle): Optimise animation storage, we waste space having 1:1 with
	// animlist when some textures don't have certain animations
	asset_addAnimation(assetManager, arena, texlist_terrain, animlist_terrain,
	                   terrainAnimAtlasIndexes, numRects, duration);

	// Idle animation
	duration      = 1.0f;
	numRects      = 1;
	i32 idleAnimAtlasIndexes[1] = {herorects_idle};
	asset_addAnimation(assetManager, arena, texlist_hero, animlist_hero_idle,
	                   idleAnimAtlasIndexes, numRects, duration);

	// Walk animation
	duration          = 0.10f;
	numRects          = 3;
	i32 walkAnimAtlasIndexes[3] = {herorects_walkA, herorects_idle,
	                               herorects_walkB};
	asset_addAnimation(assetManager, arena, texlist_hero, animlist_hero_walk,
	                   walkAnimAtlasIndexes, numRects, duration);

	// Wave animation
	duration          = 0.30f;
	numRects          = 2;
	i32 waveAnimAtlasIndexes[2] = {herorects_waveA, herorects_waveB};
	asset_addAnimation(assetManager, arena, texlist_hero, animlist_hero_wave,
	                   waveAnimAtlasIndexes, numRects, duration);

	// Battle Stance animation
	duration          = 1.0f;
	numRects          = 1;
	i32 battleStanceAnimAtlasIndexes[1] = {herorects_battlePose};
	asset_addAnimation(assetManager, arena, texlist_hero, animlist_hero_battlePose,
	                   battleStanceAnimAtlasIndexes, numRects, duration);

	// Battle tackle animation
	duration          = 0.15f;
	numRects          = 3;
	i32 tackleAnimAtlasIndexes[3] = {herorects_castA, herorects_castB,
	                                 herorects_castC};
	asset_addAnimation(assetManager, arena, texlist_hero, animlist_hero_tackle,
	                   tackleAnimAtlasIndexes, numRects, duration);
#ifdef DENGINE_DEBUG
	DEBUG_LOG("Animations created");
#endif

	/* Load sound */

	char *audioPath = "data/audio/Nobuo Uematsu - Battle 1.ogg";
	asset_loadVorbis(assetManager, arena, audioPath, audiolist_battle);
	audioPath = "data/audio/Yuki Kajiura - Swordland.ogg";
	asset_loadVorbis(assetManager, arena, audioPath, audiolist_overworld);
	audioPath = "data/audio/nuindependent_hit22.ogg";
	asset_loadVorbis(assetManager, arena, audioPath, audiolist_tackle);

#ifdef DENGINE_DEBUG
	DEBUG_LOG("Sound assets initialised");
#endif
}

INTERNAL void entityInit(GameState *state, v2 windowSize)
{
	AssetManager *assetManager = &state->assetManager;
	MemoryArena *arena = &state->arena;

	/* Init world */
	const i32 targetWorldWidth  = 100 * METERS_TO_PIXEL;
	const i32 targetWorldHeight = 10 * METERS_TO_PIXEL;
#if 0
	v2 worldDimensionInTiles    = V2i(targetWorldWidth / state->tileSize,
	                               targetWorldHeight / state->tileSize);
#else
	v2 worldDimensionInTiles =
	    V2i(CAST(i32)(windowSize.w / state->tileSize) * 2,
	        CAST(i32) windowSize.h / state->tileSize);
#endif

	for (i32 i = 0; i < ARRAY_COUNT(state->world); i++)
	{
		World *const world = &state->world[i];
		world->maxEntities = 16384;
		world->entities = PLATFORM_MEM_ALLOC(arena, world->maxEntities, Entity);
		world->entityIdInBattle =
		    PLATFORM_MEM_ALLOC(arena, world->maxEntities, i32);
		world->numEntitiesInBattle = 0;
		world->texType             = texlist_terrain;
		world->bounds =
		    math_getRect(V2(0, 0), v2_scale(worldDimensionInTiles,
		                                    CAST(f32) state->tileSize));
		world->uniqueIdAccumulator = 0;

		TexAtlas *const atlas =
		    asset_getTextureAtlas(assetManager, world->texType);

		for (i32 y = 0; y < 1; y++)
		{
			for (i32 x = 0; x < worldDimensionInTiles.x; x++)
			{
#ifdef DENGINE_DEBUG
				ASSERT(worldDimensionInTiles.x * worldDimensionInTiles.y <
				       world->maxEntities);
#endif
				v2 pos = V2(CAST(f32) x * state->tileSize,
				            CAST(f32) y * state->tileSize);
				v2 size =
				    V2(CAST(f32) state->tileSize, CAST(f32) state->tileSize);
				enum EntityType type = entitytype_tile;
				enum Direction dir = direction_null;
				Texture *tex = asset_getTexture(assetManager, world->texType);
				b32 collides = FALSE;
				Entity *tile = entity_add(arena, world, pos, size, type, dir,
				                          tex, collides);

				entity_addAnim(assetManager, tile, animlist_terrain);
				tile->currAnimId = animlist_terrain;
			}
		}
	}

	World *const world = &state->world[state->currWorldIndex];
	world->cameraPos = V2(0.0f, 0.0f);

	/* Add world soundscape */
	Renderer *renderer   = &state->renderer;
	v2 size              = V2(10.0f, 10.0f);
	v2 pos               = V2(0, 0);
	enum EntityType type = entitytype_soundscape;
	enum Direction dir   = direction_null;
	Texture *tex         = NULL;
	b32 collides         = FALSE;
	Entity *soundscape =
	    entity_add(arena, world, pos, size, type, dir, tex, collides);

	world->soundscape = soundscape;
	soundscape->audioRenderer = PLATFORM_MEM_ALLOC(arena, 1, AudioRenderer);
	soundscape->audioRenderer->sourceIndex = AUDIO_SOURCE_UNASSIGNED;

	/* Init hero entity */
	size            = V2(58.0f, 98.0f);
	pos             = V2(size.x, CAST(f32) state->tileSize);
	type            = entitytype_hero;
	dir             = direction_east;
	tex             = asset_getTexture(assetManager, texlist_hero);
	collides        = TRUE;
	Entity *hero =
	    entity_add(arena, world, pos, size, type, dir, tex, collides);

	hero->audioRenderer = PLATFORM_MEM_ALLOC(arena, 1, AudioRenderer);
	hero->audioRenderer->sourceIndex = AUDIO_SOURCE_UNASSIGNED;
	world->heroId       = hero->id;
	world->cameraFollowingId = hero->id;

	/* Populate hero animation references */
	entity_addAnim(assetManager, hero, animlist_hero_idle);
	entity_addAnim(assetManager, hero, animlist_hero_walk);
	entity_addAnim(assetManager, hero, animlist_hero_wave);
	entity_addAnim(assetManager, hero, animlist_hero_battlePose);
	entity_addAnim(assetManager, hero, animlist_hero_tackle);
	hero->currAnimId = animlist_hero_idle;

	/* Create a NPC */
	pos         = V2(hero->pos.x * 3, CAST(f32) state->tileSize);
	size        = hero->hitboxSize;
	type        = entitytype_npc;
	dir         = direction_null;
	tex         = hero->tex;
	collides    = FALSE;
	Entity *npc = entity_add(arena, world, pos, size, type, dir, tex, collides);

	/* Populate npc animation references */
	entity_addAnim(assetManager, npc, animlist_hero_wave);
	npc->currAnimId = animlist_hero_wave;

	/* Create a Mob */
	pos = V2(renderer->size.w - (renderer->size.w / 3.0f),
	         CAST(f32) state->tileSize);
	entity_addGenericMob(arena, assetManager, world, pos);

#ifdef DENGINE_DEBUG
	DEBUG_LOG("World populated");
#endif
}

INTERNAL v2 getPosRelativeToRect(Rect rect, v2 offset,
                                 enum RectBaseline baseline)
{
#ifdef DENGINE_DEBUG
	ASSERT(baseline < rectbaseline_count);
#endif
	v2 result = {0};

	v2 posToOffsetFrom = rect.pos;
	switch (baseline)
	{
		case rectbaseline_top:
			posToOffsetFrom.y += (rect.size.h);
			posToOffsetFrom.x += (rect.size.w * 0.5f);
		    break;
		case rectbaseline_topLeft:
			posToOffsetFrom.y += (rect.size.h);
			break;
		case rectbaseline_topRight:
			posToOffsetFrom.y += (rect.size.h);
			posToOffsetFrom.x += (rect.size.w);
			break;
		case rectbaseline_bottom:
			posToOffsetFrom.x += (rect.size.w * 0.5f);
			break;
		case rectbaseline_bottomRight:
			posToOffsetFrom.x += (rect.size.w);
			break;
		case rectbaseline_left:
			posToOffsetFrom.y += (rect.size.h * 0.5f);
			break;
		case rectbaseline_right:
			posToOffsetFrom.x += (rect.size.w);
			posToOffsetFrom.y += (rect.size.h * 0.5f);
			break;

		case rectbaseline_bottomLeft:
		    break;
		default:
#ifdef DENGINE_DEBUG
		    DEBUG_LOG(
		        "getPosRelativeToRect() warning: baseline enum not recognised");
#endif
			break;
	}

	result = v2_add(posToOffsetFrom, offset);
	return result;
}

// TODO(doyle): Remove and implement own random generator!
#include <time.h>
#include <stdlib.h>
void worldTraveller_gameInit(GameState *state, v2 windowSize)
{
	i32 result = audio_init(&state->audioManager);
	if (result)
	{
#ifdef DENGINE_DEBUG
		ASSERT(INVALID_CODE_PATH);
#endif
	}

	state->state              = state_active;
	state->currWorldIndex     = 0;
	state->tileSize           = 64;

	state->uiState.uniqueId   = 1;
	state->uiState.keyEntered = keycode_null;
	state->uiState.keyMod     = keycode_null;
	state->uiState.keyChar    = keycode_null;

	common_strncpy(state->uiState.statWindow.title, "Stat Menu",
	               common_strlen("Stat Menu"));
	state->uiState.statWindow.id                  = 99;
	state->uiState.statWindow.rect.pos            = V2(300, 400);
	state->uiState.statWindow.rect.size           = V2(300, 400);
	state->uiState.statWindow.prevFrameWindowHeld = FALSE;
	state->uiState.statWindow.windowHeld          = FALSE;


	WindowState *debugWindow = &state->uiState.debugWindow;
	common_strncpy(debugWindow->title, "Debug Menu",
	               common_strlen("Debug Menu"));
	debugWindow->id                  = 98;
	debugWindow->numChildUiItems     = 0;
	debugWindow->rect.size           = V2(400, 200);
	debugWindow->rect.pos = V2(windowSize.w - debugWindow->rect.size.w - 10,
	                           windowSize.h - debugWindow->rect.size.h - 10);
	debugWindow->prevFrameWindowHeld = FALSE;
	debugWindow->windowHeld          = FALSE;

	UiItem *audioBtn =
	    (debugWindow->childUiItems) + debugWindow->numChildUiItems++;
	common_strncpy(audioBtn->label, "Toggle Music",
	               common_strlen("Toggle Music"));
	audioBtn->id        = userInterface_generateId(&state->uiState);
	audioBtn->rect.size = V2(100, 50);
	audioBtn->rect.pos = getPosRelativeToRect(debugWindow->rect, V2(10, -65.0f),
	                                          rectbaseline_topLeft);
	audioBtn->type = uitype_button;

	UiItem *debugBtn =
	    (debugWindow->childUiItems) + debugWindow->numChildUiItems++;
	common_strncpy(debugBtn->label, "Toggle Debug",
	               common_strlen("Toggle Debug"));
	debugBtn->id        = userInterface_generateId(&state->uiState);
	debugBtn->rect.size = V2(100, 50);
	debugBtn->rect.pos  = getPosRelativeToRect(audioBtn->rect, V2(25, 0),
	                                          rectbaseline_bottomRight);
	debugBtn->type = uitype_button;

	UiItem *scrollbar =
	    (debugWindow->childUiItems) + debugWindow->numChildUiItems++;
	scrollbar->id     = userInterface_generateId(&state->uiState);

	scrollbar->rect.size = V2(16, debugWindow->rect.size.h);
	scrollbar->rect.pos =
	    getPosRelativeToRect(debugWindow->rect, V2(-scrollbar->rect.size.w, 0),
	                         rectbaseline_bottomRight);
	scrollbar->value    = 0;
	scrollbar->maxValue = 160;
	scrollbar->type = uitype_scrollbar;

	UiItem *textField =
	    (debugWindow->childUiItems) + debugWindow->numChildUiItems++;
	textField->id = userInterface_generateId(&state->uiState);
	textField->rect.size = V2(200, 20);
	textField->rect.pos  = getPosRelativeToRect(
	    audioBtn->rect, V2(0, -textField->rect.size.h - 10),
	    rectbaseline_bottomLeft);

	common_strncpy(textField->string, "Hello world",
	               common_strlen("Hello world"));
	textField->type = uitype_textField;

	state->config.playWorldAudio   = FALSE;
	state->config.showDebugDisplay = TRUE;

	assetInit(state);
	rendererInit(state, windowSize);
	entityInit(state, windowSize);

	srand(CAST(u32)(time(NULL)));
}

INTERNAL inline v4 getEntityScreenRect(Entity entity)
{
	v4 result = math_getRect(entity.pos, entity.hitboxSize);
	return result;
}

enum ReadKeyType
{
	readkeytype_oneShot,
	readkeytype_delayedRepeat,
	readkeytype_repeat,
	readkeytype_count,
};

#define KEY_DELAY_NONE 0.0f

INTERNAL b32 getKeyStatus(KeyState *key, enum ReadKeyType readType,
                          f32 delayInterval, f32 dt)
{

	if (!key->endedDown) return FALSE;

	switch(readType)
	{
	case readkeytype_oneShot:
	{
		if (key->newHalfTransitionCount > key->oldHalfTransitionCount)
			return TRUE;
		break;
	}
	case readkeytype_repeat:
	case readkeytype_delayedRepeat:
	{
		if (key->newHalfTransitionCount > key->oldHalfTransitionCount)
		{
			if (readType == readkeytype_delayedRepeat)
			{
				// TODO(doyle): Let user set arbitrary delay after initial input
				key->delayInterval = 2 * delayInterval;
			}
			else
			{
				key->delayInterval = delayInterval;
			}
			return TRUE;
		}
		else if (key->delayInterval <= 0.0f)
		{
			key->delayInterval = delayInterval;
			return TRUE;
		}
		else
		{
			key->delayInterval -= dt;
		}
		break;
	}
	default:
#ifdef DENGINE_DEBUG
		DEBUG_LOG("getKeyStatus() error: Invalid ReadKeyType enum");
		ASSERT(INVALID_CODE_PATH);
#endif
		break;
	}

	return FALSE;
}

INTERNAL Rect createWorldBoundedCamera(World *world, v2 size)
{
	Rect camera = {world->cameraPos, size};
	// NOTE(doyle): Lock camera if it passes the bounds of the world
	if (camera.pos.x <= world->bounds.x)
		camera.pos.x = world->bounds.x;

	// TODO(doyle): Allow Y panning when we need it
	f32 cameraTopBoundInPixels = camera.pos.y + camera.size.h;
	if (cameraTopBoundInPixels >= world->bounds.w)
		camera.pos.y = (world->bounds.w - camera.size.h);

	f32 cameraRightBoundInPixels = camera.pos.x + camera.size.w;
	if (cameraRightBoundInPixels >= world->bounds.z)
		camera.pos.x = (world->bounds.z - camera.size.w);

	if (camera.pos.y <= world->bounds.y) camera.pos.y = world->bounds.y;
	return camera;
}

#define ENTITY_IN_BATTLE TRUE
#define ENTITY_NOT_IN_BATTLE FALSE
#define ENTITY_NULL_ID -1
INTERNAL i32 findBestEntityToAttack(World *world, Entity attacker)
{
#ifdef DENGINE_DEBUG
	ASSERT(world);
	ASSERT(attacker.type == entitytype_hero || attacker.type == entitytype_mob);
#endif
	i32 result = 0;

	// TODO(doyle): If attacker is mob- retrieve hero entity id directly, change
	// when we have party members!
	if (attacker.type == entitytype_mob)
	{
		Entity hero = world->entities[entity_getIndex(world, world->heroId)];

		if (hero.state == entitystate_dead) result = ENTITY_NULL_ID;
		else result = hero.id;

		return result;
	}

	/* Attacker is hero */
	Entity hero = attacker;
	for (i32 i = world->maxEntities; i >= 0; i--)
	{
		Entity targetEntity = world->entities[i];
		if (hero.id == targetEntity.id) continue;
		if (world->entityIdInBattle[targetEntity.id] == ENTITY_IN_BATTLE)
		{
			result = targetEntity.id;
			return result;
		}
	}
	
	// NOTE(doyle): Not all "battling" entities have been enumerated yet in the
	// update loop, guard against when using function
	return ENTITY_NULL_ID;
}

INTERNAL inline void updateWorldBattleEntities(World *world, Entity *entity,
                                               b32 isInBattle)
{
#ifdef DENGINE_DEBUG
	ASSERT(isInBattle == ENTITY_IN_BATTLE ||
	       isInBattle == ENTITY_NOT_IN_BATTLE);
	ASSERT(world && entity);
#endif
	world->entityIdInBattle[entity->id] = isInBattle;

	if (isInBattle)
	{
		world->numEntitiesInBattle++;
	}
	else
	{
		world->numEntitiesInBattle--;
	}

#ifdef DENGINE_DEBUG
	ASSERT(world->numEntitiesInBattle >= 0);
#endif
}

// TODO(doyle): Function too vague
INTERNAL inline void resetEntityState(World *world, Entity *entity)
{
	updateWorldBattleEntities(world, entity, ENTITY_NOT_IN_BATTLE);
	entity_setActiveAnim(entity, animlist_hero_idle);
	entity->stats->busyDuration     = 0;
	entity->stats->actionTimer      = entity->stats->actionRate;
	entity->stats->queuedAttack     = entityattack_invalid;
	entity->stats->entityIdToAttack = ENTITY_NULL_ID;
}

INTERNAL registerEvent(EventQueue *eventQueue, enum EventType type, void *data)
{
#ifdef DENGINE_DEBUG
	ASSERT(eventQueue && type < eventtype_count);
	ASSERT(eventQueue->numEvents+1 < ARRAY_COUNT(eventQueue->queue));
#endif
	i32 currIndex = eventQueue->numEvents++;
	eventQueue->queue[currIndex].type = type;
	eventQueue->queue[currIndex].data = data;
}

INTERNAL void entityStateSwitch(EventQueue *eventQueue, World *world,
                                Entity *entity, enum EntityState newState)
{
#ifdef DENGINE_DEBUG
	ASSERT(world && entity)
	ASSERT(entity->type == entitytype_mob || entity->type == entitytype_hero)
#endif
	if (entity->state == newState) return;

	switch(entity->state)
	{
	case entitystate_idle:
		switch (newState)
		{
		case entitystate_battle:
			updateWorldBattleEntities(world, entity, ENTITY_IN_BATTLE);
			entity->stats->entityIdToAttack =
			    findBestEntityToAttack(world, *entity);
			break;

		// TODO(doyle): Corner case- if move out of range and entity has
		// switched to idle mode, we reach the attacker entity and they continue
		// attacking it since there's no check before attack if entity is idle
		// or not (i.e. has moved out of frame last frame).
		case entitystate_dead:
			registerEvent(eventQueue, eventtype_entity_died, CAST(void *)entity);
			entity_setActiveAnim(entity, animlist_hero_idle);
			entity->stats->busyDuration     = 0;
			entity->stats->actionTimer      = entity->stats->actionRate;
			entity->stats->queuedAttack     = entityattack_invalid;
			entity->stats->entityIdToAttack = ENTITY_NULL_ID;
			break;

		case entitystate_attack:
		default:
#ifdef DENGINE_DEBUG
			ASSERT(INVALID_CODE_PATH);
#endif
			break;
		}
		break;
	case entitystate_battle:
		switch (newState)
		{
		case entitystate_attack:
		{
			break;
		}
		case entitystate_idle:
			resetEntityState(world, entity);
			break;
		case entitystate_dead:
			registerEvent(eventQueue, eventtype_entity_died, CAST(void *)entity);
			resetEntityState(world, entity);
			break;
		default:
#ifdef DENGINE_DEBUG
			ASSERT(INVALID_CODE_PATH);
#endif
			break;
		}
		break;
	case entitystate_attack:
		switch (newState)
		{
		case entitystate_battle:
			entity_setActiveAnim(entity, animlist_hero_battlePose);
			entity->stats->actionTimer  = entity->stats->actionRate;
			entity->stats->busyDuration = 0;
			break;
		// NOTE(doyle): Entity has been forced out of an attack (out of range)
		case entitystate_idle:
			resetEntityState(world, entity);
			break;
		case entitystate_dead:
			registerEvent(eventQueue, eventtype_entity_died, CAST(void *)entity);
			resetEntityState(world, entity);
			break;
		default:
#ifdef DENGINE_DEBUG
			ASSERT(INVALID_CODE_PATH);
#endif
			break;
		}
		break;
	case entitystate_dead:
		switch (newState)
		{
		case entitystate_idle:
		case entitystate_battle:
		case entitystate_attack:
		default:
#ifdef DENGINE_DEBUG
			ASSERT(INVALID_CODE_PATH);
#endif
			break;
		}
		break;
	default:
#ifdef DENGINE_DEBUG
		ASSERT(INVALID_CODE_PATH);
#endif
		break;
	}

	entity->state = newState;
}

typedef struct AttackSpec
{
	Entity *attacker;
	Entity *defender;
	i32 damage;
} AttackSpec;

INTERNAL void beginAttack(EventQueue *eventQueue, World *world,
                          Entity *attacker)
{
#ifdef DENGINE_DEBUG
	ASSERT(attacker->stats->entityIdToAttack != ENTITY_NULL_ID);
	ASSERT(attacker->state == entitystate_battle);
#endif

	entityStateSwitch(eventQueue, world, attacker, entitystate_attack);
	switch (attacker->stats->queuedAttack)
	{
	case entityattack_tackle:
		EntityAnim_ attackAnim = attacker->anim[animlist_hero_tackle];
		f32 busyDuration       = attackAnim.anim->frameDuration *
		                   CAST(f32) attackAnim.anim->numFrames;
		attacker->stats->busyDuration = busyDuration;
		entity_setActiveAnim(attacker, animlist_hero_tackle);
		if (attacker->direction == direction_east)
			attacker->dPos.x += (1.0f * METERS_TO_PIXEL);
		else
			attacker->dPos.x -= (1.0f * METERS_TO_PIXEL);
		break;
	default:
#ifdef DENGINE_DEBUG
		ASSERT(INVALID_CODE_PATH);
#endif
		break;
	}
}

// TODO(doyle): MemArena here is temporary until we incorporate AttackSpec to
// battle in general!
INTERNAL void endAttack(MemoryArena *arena, EventQueue *eventQueue,
                        World *world, Entity *attacker)
{
#ifdef DENGINE_DEBUG
	ASSERT(attacker->stats->entityIdToAttack != ENTITY_NULL_ID);
#endif

	entityStateSwitch(eventQueue, world, attacker, entitystate_battle);
	switch (attacker->stats->queuedAttack)
	{
	case entityattack_tackle:
		// TODO(doyle): Move animation offsets out and into animation type
		if (attacker->direction == direction_east)
			attacker->dPos.x -= (1.0f * METERS_TO_PIXEL);
		else
			attacker->dPos.x += (1.0f * METERS_TO_PIXEL);

		break;
	default:
#ifdef DENGINE_DEBUG
		ASSERT(INVALID_CODE_PATH);
#endif
		break;
	}

	/* Compute attack damage */
	Entity *defender = NULL;

	// TODO(doyle): Implement faster lookup for entity id in entity table
	b32 noMoreValidTargets = FALSE;
	do
	{
		/* Get target entity to attack */
		i32 entityIdToAttack = attacker->stats->entityIdToAttack;
		i32 entityIndex      = entity_getIndex(world, entityIdToAttack);

		if (entityIndex != -1)
		{
			defender = &world->entities[entityIndex];
#ifdef DENGINE_DEBUG
			ASSERT(defender->type == entitytype_mob ||
			       defender->type == entitytype_hero);
#endif
		}
		else
		{
			i32 entityIdToAttack = findBestEntityToAttack(world, *attacker);
			if (entityIdToAttack == ENTITY_NULL_ID)
			{
				noMoreValidTargets = TRUE;
			}
			else
			{
				attacker->stats->entityIdToAttack =
				    findBestEntityToAttack(world, *attacker);
			}
		}
	} while (!defender && noMoreValidTargets == TRUE);

	if (!noMoreValidTargets)
	{
		i32 damage = 50;

		AttackSpec *attackSpec = PLATFORM_MEM_ALLOC(arena, 1, AttackSpec);
		attackSpec->attacker   = attacker;
		attackSpec->defender   = defender;
		attackSpec->damage     = damage;

		registerEvent(eventQueue, eventtype_end_attack, attackSpec);
		// TODO(doyle): Use attacker stats in battle equations
		if (attacker->type == entitytype_hero)
		{
			defender->stats->health -= damage;
		}

		if (defender->stats->health <= 0)
		{
			entityStateSwitch(eventQueue, world, defender, entitystate_dead);
			entityStateSwitch(eventQueue, world, attacker, entitystate_idle);
		}
	}
}

INTERNAL void sortWorldEntityList(World *world)
{
	b32 listHasChanged       = TRUE;
	i32 numUnsortedEntities  = world->freeEntityIndex;
	while (listHasChanged)
	{
		listHasChanged = FALSE;
		for (i32 i = 0; i < numUnsortedEntities-1; i++)
		{
			// TODO(doyle): Better sort algorithm
			Entity *entityA = &world->entities[i];
			Entity *entityB = &world->entities[i+1];
			if (entityA->type == entitytype_null ||
			    (entityB->type != entitytype_null && entityA->id > entityB->id))
			{
				Entity tempEntity         = world->entities[i];
				world->entities[i]        = world->entities[i + 1];
				world->entities[i + 1]    = tempEntity;
				listHasChanged = TRUE;
			}
		}
		numUnsortedEntities--;
	}
}

typedef struct DamageDisplay
{
	char damageStr[12];
	v2 pos;
	f32 lifetime;
} DamageDisplay;

typedef struct BattleState
{
	DamageDisplay damageDisplay[128];
} BattleState;

GLOBAL_VAR BattleState battleState = {0};

void worldTraveller_gameUpdateAndRender(GameState *state, f32 dt)
{
	// TODO(doyle): use proper dt limiting techniques
	if (dt >= 1.0f) dt = 1.0f;
	GL_CHECK_ERROR();

	AssetManager *assetManager = &state->assetManager;
	Renderer *renderer         = &state->renderer;
	World *const world         = &state->world[state->currWorldIndex];
	Font *font                 = &assetManager->font;
	MemoryArena *arena         = &state->arena;

	/*
	 **********************
	 * Parse Input Keys
	 **********************
	 */
	{
		/*
		 **********************
		 * Parse Alphabet Keys
		 **********************
		 */
		KeyState *keys = state->input.keys;
		for (enum KeyCode code = 0; code < keycode_count; code++)
		{
			b32 parseKey = FALSE;

			KeyState *key = &keys[code];
			if (key->newHalfTransitionCount > key->oldHalfTransitionCount)
			{
				i32 numTransitions =
				    key->newHalfTransitionCount - key->oldHalfTransitionCount;

				if (!IS_EVEN(numTransitions))
					key->endedDown = (key->endedDown) ? FALSE : TRUE;
			}

			if (code >= keycode_a && code <= keycode_z) parseKey = TRUE;
			if (code >= keycode_A && code <= keycode_Z) parseKey = TRUE;
			if (code >= keycode_0 && code <= keycode_9) parseKey = TRUE;

			if (!parseKey) continue;

			if (getKeyStatus(key, readkeytype_repeat, 0.15f, dt))
			{
				// TODO(doyle): Multi press within frame overrides ui parsing
				state->uiState.keyChar = code;
			}
		}

		/*
		 **************************
		 * Parse Game Control Keys
		 **************************
		 */
		if (getKeyStatus(&keys[keycode_enter], readkeytype_oneShot,
		                 KEY_DELAY_NONE, dt))
		{
			state->uiState.keyEntered = keycode_enter;
		}

		if (getKeyStatus(&keys[keycode_tab], readkeytype_delayedRepeat, 0.25f,
		                 dt))
		{
			state->uiState.keyEntered = keycode_tab;
		}

		if (getKeyStatus(&keys[keycode_space], readkeytype_delayedRepeat, 0.25f,
		                 dt))
		{
			state->uiState.keyChar = keycode_space;
		}

		if (getKeyStatus(&keys[keycode_backspace], readkeytype_delayedRepeat,
		                 0.1f, dt))
		{
			state->uiState.keyEntered = keycode_backspace;
		}

		if (getKeyStatus(&keys[keycode_left_square_bracket],
		                 readkeytype_delayedRepeat, 0.25f, dt))
		{

			Renderer *renderer = &state->renderer;
			f32 yPos           = CAST(f32)(rand() % CAST(i32) renderer->size.h);
			f32 xModifier      = 5.0f - CAST(f32)(rand() % 3);

			v2 pos =
			    V2(renderer->size.w - (renderer->size.w / xModifier), yPos);
			entity_addGenericMob(&state->arena, &state->assetManager, world,
			                     pos);
		}
	}

	/*
	 ******************************
	 * Update entities and render
	 ******************************
	 */
	EventQueue eventQueue = {0};
	Rect camera           = createWorldBoundedCamera(world, renderer->size);
	AudioManager *audioManager = &state->audioManager;

	ASSERT(world->freeEntityIndex < world->maxEntities);
	for (i32 i = 0; i < world->freeEntityIndex; i++)
	{
		Entity *const entity = &world->entities[i];

		/* Reposition camera if entity is targeted id */
		if (world->cameraFollowingId == entity->id)
		{
			// NOTE(doyle): Set the camera such that the hero is centered
			v2 offsetFromEntityToCameraOrigin =
			    V2((entity->pos.x - (0.5f * state->renderer.size.w)), (0.0f));

			// NOTE(doyle): Account for the hero's origin being the bottom left
			offsetFromEntityToCameraOrigin.x += (entity->hitboxSize.x * 0.5f);
			world->cameraPos = offsetFromEntityToCameraOrigin;
		}

		if (entity->state == entitystate_dead) continue;

		if (entity->type == entitytype_soundscape)
		{
			AudioRenderer *audioRenderer = entity->audioRenderer;
			if (!state->config.playWorldAudio)
			{
				// TODO(doyle): Use is playing flag, not just streaming flag
				if (audioRenderer->state == audiostate_playing)
				{
					audio_pauseVorbis(&state->audioManager, audioRenderer);
				}
			}
			else
			{
				if (world->numEntitiesInBattle > 0)
				{
					AudioVorbis *battleTheme =
					    asset_getVorbis(assetManager, audiolist_battle);
					if (audioRenderer->audio)
					{
						if (audioRenderer->audio->type != audiolist_battle)
						{
							audio_streamPlayVorbis(arena, &state->audioManager,
							                       audioRenderer, battleTheme,
							                       AUDIO_REPEAT_INFINITE);
						}
					}
					else
					{
						audio_streamPlayVorbis(arena, &state->audioManager,
						                       audioRenderer, battleTheme,
						                       AUDIO_REPEAT_INFINITE);
					}
				}
				else
				{
					AudioVorbis *overworldTheme =
					    asset_getVorbis(assetManager, audiolist_overworld);
					if (audioRenderer->audio)
					{
						if (audioRenderer->audio->type != audiolist_overworld)
						{
							audio_streamPlayVorbis(
							    arena, &state->audioManager, audioRenderer,
							    overworldTheme, AUDIO_REPEAT_INFINITE);
						}
					}
					else
					{
						audio_streamPlayVorbis(arena, &state->audioManager,
						                       audioRenderer, overworldTheme,
						                       AUDIO_REPEAT_INFINITE);
					}
				}

				if (audioRenderer->state == audiostate_paused)
				{
					audio_resumeVorbis(&state->audioManager, audioRenderer);
				}
			}
		}

		/*
		 *****************************************************
		 * Calculate Mob In Battle Range
		 *****************************************************
		 */
		if (entity->type == entitytype_mob)
		{
			// TODO(doyle): Currently calculated in pixels, how about meaningful
			// game units?
			f32 battleThreshold = 500.0f;
			Entity *hero        = getHeroEntity(world);
			f32 distance        = v2_magnitude(hero->pos, entity->pos);

			enum EntityState newState = entitystate_invalid;
			if (distance <= battleThreshold)
			{
				// NOTE(doyle): If in range but in battle, no state change
				if (entity->state == entitystate_battle ||
				    entity->state == entitystate_attack)
				{
					newState = entity->state;
				}
				else
				{
					newState = entitystate_battle;
				}
			}
			else
			{
				newState = entitystate_idle;
			}

			entityStateSwitch(&eventQueue, world, entity, newState);
		}

		/*
		 **************************
		 * Calculate Hero Movement
		 **************************
		 */
		if (entity->type == entitytype_hero)
		{
			/*
			   Equations of Motion
			   f(t)  = position     m
			   f'(t) = velocity     m/s
			   f"(t) = acceleration m/s^2

			   The user supplies an acceleration, a, and by integrating
			   f"(t) = a,                   where a is a constant, acceleration
			   f'(t) = a*t + v,             where v is a constant, old velocity
			   f (t) = (a/2)*t^2 + v*t + p, where p is a constant, old position
			 */

			Entity *hero   = entity;
			KeyState *keys = state->input.keys;

			v2 ddPos = V2(0, 0);
			if (hero->stats->busyDuration <= 0)
			{
				if (getKeyStatus(&keys[keycode_right], readkeytype_repeat,
				                 KEY_DELAY_NONE, dt))
				{
					ddPos.x         = 1.0f;
					hero->direction = direction_east;
				}

				if (getKeyStatus(&keys[keycode_left], readkeytype_repeat,
				                 KEY_DELAY_NONE, dt))
				{
					ddPos.x         = -1.0f;
					hero->direction = direction_west;
				}

				if (getKeyStatus(&keys[keycode_up], readkeytype_repeat,
				                 KEY_DELAY_NONE, dt))
				{
					ddPos.y = 1.0f;
				}

				if (getKeyStatus(&keys[keycode_down], readkeytype_repeat,
				                 KEY_DELAY_NONE, dt))
				{
					ddPos.y = -1.0f;
				}

				if (ddPos.x != 0.0f && ddPos.y != 0.0f)
				{
					// NOTE(doyle): Cheese it and pre-compute the vector for
					// diagonal
					// using
					// pythagoras theorem on a unit triangle
					// 1^2 + 1^2 = c^2
					ddPos = v2_scale(ddPos, 0.70710678118f);
				}
			}

			/*
			 **************************
			 * Calculate Hero Speed
			 **************************
			 */
			// NOTE(doyle): Clipping threshold for snapping velocity to 0
			f32 epsilon    = 0.5f;
			v2 epsilonDpos = v2_sub(V2(epsilon, epsilon),
			                        V2(ABS(hero->dPos.x), ABS(hero->dPos.y)));

			if (epsilonDpos.x >= 0.0f && epsilonDpos.y >= 0.0f)
			{
				hero->dPos = V2(0.0f, 0.0f);
				if (hero->currAnimId == animlist_hero_walk)
				{
					entity_setActiveAnim(hero, animlist_hero_idle);
				}
			}
			else if (hero->currAnimId == animlist_hero_idle)
			{
				entity_setActiveAnim(hero, animlist_hero_walk);
			}

			f32 heroSpeed = 6.2f * METERS_TO_PIXEL;
			if (getKeyStatus(&state->input.keys[keycode_leftShift],
			                 readkeytype_repeat, KEY_DELAY_NONE, dt))
			{
				// TODO: Context sensitive command separation
				state->uiState.keyMod = keycode_leftShift;
				heroSpeed = CAST(f32)(22.0f * 10.0f * METERS_TO_PIXEL);
			}
			else
			{
				state->uiState.keyMod = keycode_null;
			}

			ddPos = v2_scale(ddPos, heroSpeed);
			// TODO(doyle): Counteracting force on player's acceleration is
			// arbitrary
			ddPos = v2_sub(ddPos, v2_scale(hero->dPos, 5.5f));

			/*
			   NOTE(doyle): Calculate new position from acceleration with old
			   velocity
			   new Position     = (a/2) * (t^2) + (v*t) + p,
			   acceleration     = (a/2) * (t^2)
			   old velocity     =                 (v*t)
			 */
			v2 ddPosNew = v2_scale(v2_scale(ddPos, 0.5f), SQUARED(dt));
			v2 dPos     = v2_scale(hero->dPos, dt);
			v2 newHeroP = v2_add(v2_add(ddPosNew, dPos), hero->pos);

			/*
			 **************************
			 * Collision Detection
			 **************************
			 */
			// TODO(doyle): Only check collision for entities within small
			// bounding box of the hero
			b32 heroCollided = FALSE;
			if (hero->collides == TRUE)
			{
				for (i32 i = 0; i < world->maxEntities; i++)
				{
					Entity collider = world->entities[i];
					if (collider.state == entitystate_dead) continue;
					if (collider.id == world->heroId) continue;

					if (collider.collides)
					{
						Rect heroRect = {newHeroP, hero->hitboxSize};

						v2 heroTopLeftP = getPosRelativeToRect(
						    heroRect, V2(0, 0), rectbaseline_topLeft);
						v2 heroTopRightP = getPosRelativeToRect(
						    heroRect, V2(0, 0), rectbaseline_topRight);
						v2 heroBottomLeftP = getPosRelativeToRect(
						    heroRect, V2(0, 0), rectbaseline_bottomLeft);
						v2 heroBottomRightP = getPosRelativeToRect(
						    heroRect, V2(0, 0), rectbaseline_bottomRight);

						Rect colliderRect = {collider.pos, collider.hitboxSize};

						if (math_pointInRect(colliderRect, heroTopLeftP) ||
						    math_pointInRect(colliderRect, heroTopRightP) ||
						    math_pointInRect(colliderRect, heroBottomLeftP) ||
						    math_pointInRect(colliderRect, heroBottomRightP))
						{
							heroCollided = TRUE;
							break;
						}
					}
				}
			}

			if (heroCollided)
			{
				hero->dPos = V2(0.0f, 0.0f);
			}
			else
			{
				// f'(t) = curr velocity = a*t + v, where v is old velocity
				hero->dPos = v2_add(hero->dPos, v2_scale(ddPos, dt));
				hero->pos  = newHeroP;
			}
		}

		/*
		 **************************************************
		 * Conduct Battle For Mobs In Range
		 **************************************************
		 */
		if (entity->type == entitytype_mob || entity->type == entitytype_hero)
		{
			EntityStats *stats = entity->stats;
			if (entity->state == entitystate_battle)
			{
				if (stats->actionTimer > 0)
					stats->actionTimer -= dt * stats->actionSpdMul;

				if (stats->actionTimer <= 0)
				{
					stats->actionTimer = 0;
					if (stats->queuedAttack == entityattack_invalid)
						stats->queuedAttack = entityattack_tackle;

					/* Launch up attack animation */
					beginAttack(&eventQueue, world, entity);
				}
			}
			else if (entity->state == entitystate_attack)
			{
				// TODO(doyle): Untested if the attacker and the defender same
				Entity *attacker = entity;
				stats->busyDuration -= dt;
				if (stats->busyDuration <= 0)
				{
					/* Apply attack damage */
					endAttack(&state->arena, &eventQueue, world, entity);
				}
			}
		}

		/*
		 ****************
		 * Update Entity
		 ****************
		 */
		if (entity->audioRenderer)
		{
			audio_updateAndPlay(&state->arena, &state->audioManager,
			                    entity->audioRenderer);
		}

		if (entity->tex)
		{
			entity_updateAnim(entity, dt);
			/* Calculate region to render */
			renderer_entity(renderer, camera, entity, V2(0, 0), 0,
			                V4(1, 1, 1, 1));
		}
	}

	/*
	 *****************************************
	 * Process Events From Entity Update Loop
	 *****************************************
	 */
	i32 numDeadEntities = 0;
	for (i32 i = 0; i < eventQueue.numEvents; i++)
	{
		Event event = eventQueue.queue[i];
		switch(event.type)
		{
		case eventtype_end_attack:
		{
			if (!event.data) continue;

			AttackSpec *attackSpec = (CAST(AttackSpec *) event.data);
			Entity *attacker       = attackSpec->attacker;
			Entity *defender       = attackSpec->defender;

			audio_playVorbis(arena, audioManager, attacker->audioRenderer,
			                 asset_getVorbis(assetManager, audiolist_tackle),
			                 1);

			/* Get first free string position and store the damage str data */
			for (i32 i = 0; i < ARRAY_COUNT(battleState.damageDisplay); i++)
			{
				if (battleState.damageDisplay[i].lifetime <= 0.0f)
				{
					common_memset(
					    battleState.damageDisplay[i].damageStr, 0,
					    ARRAY_COUNT(battleState.damageDisplay[i].damageStr));

					battleState.damageDisplay[i].lifetime = 1.0f;
					battleState.damageDisplay[i].pos      = defender->pos;
					common_itoa(
					    attackSpec->damage,
					    battleState.damageDisplay[i].damageStr,
					    ARRAY_COUNT(battleState.damageDisplay[i].damageStr));

					break;
				}
			}

			PLATFORM_MEM_FREE(&state->arena, attackSpec, sizeof(AttackSpec));
			break;
		}
		// NOTE(doyle): We delete dead entities at the end of the update
		// loop incase a later indexed entity deletes an earlier indexed
		// entity, the entity will exist for an additional frame
		case eventtype_entity_died:
		{
#ifdef DEGINE_DEBUG
			DEBUG_LOG("Entity died: being deleted");
#endif
			if (!event.data) continue;

			Entity *entity = (CAST(Entity *) event.data);
			audio_stopVorbis(&state->arena, audioManager,
			                 entity->audioRenderer);
			entity_clearData(&state->arena, world, entity);
			numDeadEntities++;
			break;
		}
		default:
		{
			break;
		}
		}
	}


	/*
	 ****************************
	 * Update World From Results
	 ****************************
	 */
	// TODO(doyle): Dead hero not accounted for here
	Entity *hero = getHeroEntity(world);
	if (world->numEntitiesInBattle > 0)
	{
		// NOTE(doyle): If battle entities is 1 then only the hero left
		if (hero->state == entitystate_battle &&
		    world->numEntitiesInBattle == 1)
			entityStateSwitch(&eventQueue, world, hero, entitystate_idle);
		else if (hero->state != entitystate_attack)
		{
			entityStateSwitch(&eventQueue, world, hero, entitystate_battle);
		}
	}
	else
	{
		if (hero->state == entitystate_battle)
		{
			hero->state                       = entitystate_idle;
			world->entityIdInBattle[hero->id] = FALSE;
			entity_setActiveAnim(hero, animlist_hero_idle);
		}
		hero->stats->entityIdToAttack = -1;
		hero->stats->actionTimer      = hero->stats->actionRate;
		hero->stats->busyDuration     = 0;
	}

	sortWorldEntityList(world);
	world->freeEntityIndex -= numDeadEntities;

	/*
	 ********************
	 * UI Rendering Code
	 ********************
	 */
	/* Render all damage strings */
	for (i32 i = 0; i < ARRAY_COUNT(battleState.damageDisplay); i++)
	{
		if (battleState.damageDisplay[i].lifetime > 0.0f)
		{
			battleState.damageDisplay[i].lifetime -= dt;

			char *damageString = battleState.damageDisplay[i].damageStr;
			v2 damagePos       = battleState.damageDisplay[i].pos;
			f32 lifetime       = battleState.damageDisplay[i].lifetime;

			// TODO(doyle): Incorporate UI into entity list or it's own list
			// with a rendering lifetime value
			renderer_string(renderer, &state->arena, camera, font,
			                damageString, damagePos, V2(0, 0), 0,
			                V4(1, 1, 1, lifetime));
		}
	}

	// INIT IMGUI
	state->uiState.hotItem = 0;

	/* Draw ui */
	if (state->uiState.keyChar == keycode_i)
	{
		state->config.showStatMenu =
		    (state->config.showStatMenu == TRUE) ? FALSE : TRUE;
	}

	if (state->config.showStatMenu)
	{
		WindowState *statWindow = &state->uiState.statWindow;
		userInterface_window(&state->uiState, &state->arena, assetManager,
		                     renderer, font, state->input, statWindow);
	}

	/* Draw debug window */
	WindowState *debugWindow = &state->uiState.debugWindow;
	i32 activeId =
	    userInterface_window(&state->uiState, &state->arena, assetManager,
	                         renderer, font, state->input, debugWindow);

	// TODO(doyle): Name lookup to user interface id
	if (activeId == 1)
	{
		state->config.playWorldAudio =
		    (state->config.playWorldAudio == TRUE) ? FALSE : TRUE;
	}
	else if (activeId == 2)
	{
		state->config.showDebugDisplay =
		    (state->config.showDebugDisplay == TRUE) ? FALSE : TRUE;
	}

	// RESET IMGUI
	if (!state->input.keys[keycode_mouseLeft].endedDown)
		state->uiState.activeItem = 0;
	else if (state->uiState.activeItem == 0)
		state->uiState.activeItem = -1;

	if (state->uiState.keyEntered == keycode_tab) state->uiState.kbdItem = 0;
	state->uiState.keyEntered = keycode_null;
	state->uiState.keyChar    = keycode_null;

	/* Draw hero avatar */
	TexAtlas *heroAtlas  = asset_getTextureAtlas(assetManager, texlist_hero);
	v4 heroAvatarTexRect = heroAtlas->texRect[herorects_head];
	v2 heroAvatarSize    = math_getRectSize(heroAvatarTexRect);
	v2 heroAvatarP =
	    V2(10.0f, (renderer->size.h * 0.5f) - (0.5f * heroAvatarSize.h));

	RenderTex heroRenderTex = {hero->tex, heroAvatarTexRect};
	renderer_staticRect(renderer, heroAvatarP, heroAvatarSize, V2(0, 0), 0,
	                    heroRenderTex, V4(1, 1, 1, 1));

	char heroAvatarStr[20];
	snprintf(heroAvatarStr, ARRAY_COUNT(heroAvatarStr), "HP: %3.0f/%3.0f",
	         hero->stats->health, hero->stats->maxHealth);
	f32 strLenInPixels =
	    CAST(f32)(font->maxSize.w * common_strlen(heroAvatarStr));
	v2 strPos = V2(heroAvatarP.x, heroAvatarP.y - (0.5f * heroAvatarSize.h));
	renderer_staticString(&state->renderer, &state->arena, font, heroAvatarStr,
	                      strPos, V2(0, 0), 0, V4(0, 0, 1, 1));

	renderer_staticString(&state->renderer, &state->arena, font, heroAvatarStr,
	                      strPos, V2(0, 0), 0, V4(0, 0, 1, 1));

	for (i32 i = 0; i < world->maxEntities; i++)
	{
		Entity *entity = &world->entities[i];
		if (entity->id == hero->id)
			continue;

		if (entity->state == entitystate_attack ||
		    entity->state == entitystate_battle)
		{
			v2 difference    = v2_sub(entity->pos, hero->pos);
			f32 angle        = math_atan2f(difference.y, difference.x);
			f32 angleDegrees = RADIANS_TO_DEGREES(angle);

			v2 heroCenter = v2_add(hero->pos, v2_scale(hero->hitboxSize, 0.5f));
			RenderTex renderTex = renderer_createNullRenderTex(assetManager);
			f32 distance        = v2_magnitude(hero->pos, entity->pos);
			renderer_rect(&state->renderer, camera, heroCenter,
			              V2(distance, 2.0f), V2(0, 0), angle, renderTex,
			              V4(1, 0, 0, 1.0f));
		}
	}

	for (i32 i = 0; i < keycode_count; i++)
	{
		state->input.keys[i].oldHalfTransitionCount =
		    state->input.keys[i].newHalfTransitionCount;
	}

	/*
	 ********************
	 * DEBUG CODE
	 ********************
	 */
#ifdef DENGINE_DEBUG
	for (i32 i = 0; i < world->freeEntityIndex-1; i++)
	{
		ASSERT(world->entities[i].type != entitytype_null);
		ASSERT(world->entities[i].id < world->entities[i+1].id);
	}
#endif

#ifdef DENGINE_DEBUG
	if (state->config.showDebugDisplay)
	{
		debug_drawUi(state, dt);
	}
#endif
}