// Minecraft.cpp : Defines the entry point for the application.
//

#include "stdafx.h"

#include <assert.h>
#include <shellapi.h>
#include "GameConfig\Minecraft.spa.h"
#include "..\MinecraftServer.h"
#include "..\LocalPlayer.h"
#include "..\..\Minecraft.World\ItemInstance.h"
#include "..\..\Minecraft.World\MapItem.h"
#include "..\..\Minecraft.World\Recipes.h"
#include "..\..\Minecraft.World\Recipy.h"
#include "..\..\Minecraft.World\Language.h"
#include "..\..\Minecraft.World\StringHelpers.h"
#include "..\..\Minecraft.World\AABB.h"
#include "..\..\Minecraft.World\Vec3.h"
#include "..\..\Minecraft.World\Level.h"
#include "..\..\Minecraft.World\net.minecraft.world.level.tile.h"

#include "..\ClientConnection.h"
#include "..\User.h"
#include "..\..\Minecraft.World\Socket.h"
#include "..\..\Minecraft.World\ThreadName.h"
#include "..\..\Minecraft.Client\StatsCounter.h"
#include "..\ConnectScreen.h"
#include "..\..\Minecraft.Client\Tesselator.h"
#include "..\..\Minecraft.Client\Options.h"
#include "Sentient\SentientManager.h"
#include "..\..\Minecraft.World\IntCache.h"
#include "..\Textures.h"
#include "Resource.h"
#include "..\..\Minecraft.World\compression.h"
#include "..\..\Minecraft.World\OldChunkStorage.h"

#include "Windows64_Minecraft.h"
#include "Xbox/resource.h"
#include <vector>
#include "..\Common\UI\DirectTextEdit.h"
#include "..\Common\UI\UIControl_TextInput.h"
#include "..\Common\UI\UIScene.h"

BOOL g_bResolutionSetByCMD = FALSE;
HINSTANCE hMyInst;
LRESULT CALLBACK DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam);
WINDOWPLACEMENT g_wpPrev = { sizeof(g_wpPrev) };

char chGlobalText[256];
uint16_t ui16GlobalText[256];

#define FIFTY_ONE_MB (1000000*51) // Maximum TCR space required for a save is 52MB (checking for this on a selected device)

#define NUM_PROFILE_VALUES	5
#define NUM_PROFILE_SETTINGS 4
DWORD dwProfileSettingsA[NUM_PROFILE_VALUES]=
{
	0,0,0,0,0
};

//str1k3r - request dedicated GPU from AMD and NVIDIA drivers
extern "C"
{
	__declspec(dllexport) int AmdPowerXpressRequestHighPerformance = 1;
	__declspec(dllexport) unsigned long NvOptimusEnablement = 0x00000001;
}

BOOL g_bWidescreen = TRUE;

char g_Username[32];

BOOL g_isFullscreen = FALSE;

int g_iScreenWidth = 1280;
int g_iScreenHeight = 720;

int g_iWindowClientW = 1280;
int g_iWindowClientH = 720;

static bool s_bEscapeKeyPrev = false;
static bool s_bMenuMouseLPrev = false;
static bool s_bMenuMouseRPrev = false;
static int s_iWheelCarry = 0;

static void TickMenuNavKeys(int iPad, bool bMenuOpen)
{
	struct NavKey { int vk; int altVk; unsigned int action; bool repeat; bool prev; };
	static NavKey s_keys[] =
	{
		{ 'W', VK_UP, ACTION_MENU_UP, true, false },
		{ 'S', VK_DOWN, ACTION_MENU_DOWN, true, false },
		{ 'A', VK_LEFT, ACTION_MENU_LEFT, true, false },
		{ 'D', VK_RIGHT, ACTION_MENU_RIGHT, true, false },
		{ 'F', VK_RETURN, ACTION_MENU_OK, false, false },
		{ 'Q', 0, ACTION_MENU_LEFT_SCROLL, false, false },
		{ 'E', 0, ACTION_MENU_RIGHT_SCROLL, false, false },
	};
	bool bActive = bMenuOpen && !DirectTextEdit::IsActive();
	for (int i = 0; i < sizeof(s_keys) / sizeof(s_keys[0]); ++i)
	{
		NavKey &k = s_keys[i];
		bool down = InputManager.IsKeyDown(k.vk) || (k.altVk != 0 && InputManager.IsKeyDown(k.altVk));
		if (bActive)
		{
			unsigned int button = InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), k.action);
			if (k.repeat)
			{
				if (down)
					InputManager.MapTouchInput(iPad, button);
			}
			else if (down && !k.prev)
			{
				InputManager.MapTouchInput(iPad, button);
			}
		}
		k.prev = down;
	}
}
int g_iPendingHotbarScroll = 0;

static Windows64LaunchArgs ParseLaunchArgs()
{
	Windows64LaunchArgs args = {};
	args.resolution = 0;

	int argc = 0;
	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
	if (argv == nullptr)
		return args;

	if (argc > 1 && lstrlenW(argv[1]) == 1)
	{
		if (argv[1][0] >= L'1' && argv[1][0] <= L'6')
			args.resolution = argv[1][0] - L'0';
	}

	for (int i = 1; i < argc; ++i)
	{
		if (_wcsicmp(argv[i], L"-fullscreen") == 0)
		{
			args.fullscreen = true;
		}
		else if (_wcsicmp(argv[i], L"-no-vsync") == 0) //str1k3r - we all remember -femboysarecool right? also thank u neoapps for naming this arg
		{
			args.vsync = true;
		}
		else if (_wcsicmp(argv[i], L"-resolution") == 0)
		{
			if (i + 1 < argc && argv[i + 1][0] >= L'1' && argv[i + 1][0] <= L'6')
			{
				args.resolution = argv[++i][0] - L'0';
			}
		} 
		else if (_wcsicmp(argv[i], L"-name") == 0)
		{
			args.name = true;

			if (i + 1 < argc) 
			{
				app.CopyWideArgToAnsi(argv[i + 1], g_Username, sizeof(g_Username));
				app.SetFakeGamertag(g_Username);
			}
		}
	}

	LocalFree(argv);
	return args;
}

void DefineActions(void)
{
	// The app needs to define the actions required, and the possible mappings for these

	// Split into Menu actions, and in-game actions

	if(InputManager.IsSelectBackSwapped())
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_A,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_B,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OK,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_A);
	}
	else
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_A,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_B,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OK,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_B);
	}
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_X,							_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_Y,							_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_UP,							_360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_DOWN,						_360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT,						_360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT,						_360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEUP,						_360_JOY_BUTTON_LT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAGEDOWN,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_RIGHT_SCROLL,				_360_JOY_BUTTON_RB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_LEFT_SCROLL,					_360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_PAUSEMENU,					_360_JOY_BUTTON_START);

	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_STICK_PRESS,					_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_PRESS,			_360_JOY_BUTTON_RTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_DOWN,			_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_LEFT,			_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,ACTION_MENU_OTHER_STICK_RIGHT,			_360_JOY_BUTTON_RSTICK_RIGHT);

	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_JUMP,					_360_JOY_BUTTON_A);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_FORWARD,				_360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_BACKWARD,				_360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT,					_360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT,					_360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_LEFT,				_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_RIGHT,				_360_JOY_BUTTON_RSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LOOK_DOWN,				_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_USE,					_360_JOY_BUTTON_LT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_ACTION,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RIGHT_SCROLL,			_360_JOY_BUTTON_RB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_LEFT_SCROLL,			_360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_INVENTORY,				_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_PAUSEMENU,				_360_JOY_BUTTON_START);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DROP,					_360_JOY_BUTTON_B);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_SNEAK_TOGGLE,			_360_JOY_BUTTON_RTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_CRAFTING,				_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_GAME_INFO,				_360_JOY_BUTTON_BACK);

	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_LEFT,				_360_JOY_BUTTON_DPAD_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_RIGHT,				_360_JOY_BUTTON_DPAD_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_UP,				_360_JOY_BUTTON_DPAD_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_0,MINECRAFT_ACTION_DPAD_DOWN,				_360_JOY_BUTTON_DPAD_DOWN);

	if(InputManager.IsSelectBackSwapped())
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_A,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_B,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OK,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_A);
	}
	else
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_A,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_B,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OK,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_B);
	}
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_X,							_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_Y,							_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_UP,							_360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_DOWN,						_360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT,						_360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT,						_360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEUP,						_360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAGEDOWN,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_RIGHT_SCROLL,				_360_JOY_BUTTON_RB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_LEFT_SCROLL,					_360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_PAUSEMENU,					_360_JOY_BUTTON_START);

	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_STICK_PRESS,					_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_PRESS,			_360_JOY_BUTTON_RTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_DOWN,			_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_LEFT,			_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,ACTION_MENU_OTHER_STICK_RIGHT,			_360_JOY_BUTTON_RSTICK_RIGHT);

	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_JUMP,					_360_JOY_BUTTON_RB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_FORWARD,				_360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_BACKWARD,				_360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT,					_360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT,					_360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_LEFT,				_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_RIGHT,				_360_JOY_BUTTON_RSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LOOK_DOWN,				_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_USE,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_ACTION,					_360_JOY_BUTTON_LT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RIGHT_SCROLL,			_360_JOY_BUTTON_DPAD_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_LEFT_SCROLL,			_360_JOY_BUTTON_DPAD_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_INVENTORY,				_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_PAUSEMENU,				_360_JOY_BUTTON_START);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DROP,					_360_JOY_BUTTON_B);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_SNEAK_TOGGLE,			_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_CRAFTING,				_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_360_JOY_BUTTON_RTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_GAME_INFO,				_360_JOY_BUTTON_BACK);
	
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_LEFT,				_360_JOY_BUTTON_DPAD_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_RIGHT,				_360_JOY_BUTTON_DPAD_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_UP,				_360_JOY_BUTTON_DPAD_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_1,MINECRAFT_ACTION_DPAD_DOWN,				_360_JOY_BUTTON_DPAD_DOWN);	

	if(InputManager.IsSelectBackSwapped())
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_A,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_B,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OK,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_A);
	}
	else
	{
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_A,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_B,							_360_JOY_BUTTON_B);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OK,							_360_JOY_BUTTON_A);
		InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_CANCEL,						_360_JOY_BUTTON_B);
	}
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_X,							_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_Y,							_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_UP,							_360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_DOWN,						_360_JOY_BUTTON_DPAD_DOWN | _360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT,						_360_JOY_BUTTON_DPAD_LEFT | _360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT,						_360_JOY_BUTTON_DPAD_RIGHT | _360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEUP,						_360_JOY_BUTTON_DPAD_UP | _360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAGEDOWN,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_RIGHT_SCROLL,				_360_JOY_BUTTON_RB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_LEFT_SCROLL,					_360_JOY_BUTTON_LB);

	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_JUMP,					_360_JOY_BUTTON_LT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_FORWARD,				_360_JOY_BUTTON_LSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_BACKWARD,				_360_JOY_BUTTON_LSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT,					_360_JOY_BUTTON_LSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT,					_360_JOY_BUTTON_LSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_LEFT,				_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_RIGHT,				_360_JOY_BUTTON_RSTICK_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LOOK_DOWN,				_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_USE,					_360_JOY_BUTTON_RT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_ACTION,					_360_JOY_BUTTON_A);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RIGHT_SCROLL,			_360_JOY_BUTTON_DPAD_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_LEFT_SCROLL,			_360_JOY_BUTTON_DPAD_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_INVENTORY,				_360_JOY_BUTTON_Y);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_PAUSEMENU,				_360_JOY_BUTTON_START);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DROP,					_360_JOY_BUTTON_B);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_SNEAK_TOGGLE,			_360_JOY_BUTTON_LB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_CRAFTING,				_360_JOY_BUTTON_X);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_RENDER_THIRD_PERSON,	_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_GAME_INFO,				_360_JOY_BUTTON_BACK);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_PAUSEMENU,					_360_JOY_BUTTON_START);

	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_STICK_PRESS,					_360_JOY_BUTTON_LTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_PRESS,			_360_JOY_BUTTON_RTHUMB);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_UP,				_360_JOY_BUTTON_RSTICK_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_DOWN,			_360_JOY_BUTTON_RSTICK_DOWN);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_LEFT,			_360_JOY_BUTTON_RSTICK_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,ACTION_MENU_OTHER_STICK_RIGHT,			_360_JOY_BUTTON_RSTICK_RIGHT);
	
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_LEFT,				_360_JOY_BUTTON_DPAD_LEFT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_RIGHT,				_360_JOY_BUTTON_DPAD_RIGHT);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_UP,				_360_JOY_BUTTON_DPAD_UP);
	InputManager.SetGameJoypadMaps(MAP_STYLE_2,MINECRAFT_ACTION_DPAD_DOWN,				_360_JOY_BUTTON_DPAD_DOWN);	
}

void MemSect(int sect)
{
	//str1k3r - i feel like something should go here, i just dont know what
}

HINSTANCE               g_hInst = NULL;
HWND                    g_hWnd = NULL;
D3D_DRIVER_TYPE         g_driverType = D3D_DRIVER_TYPE_NULL;
D3D_FEATURE_LEVEL       g_featureLevel = D3D_FEATURE_LEVEL_11_0;
ID3D11Device*           g_pd3dDevice = NULL;
ID3D11DeviceContext*    g_pImmediateContext = NULL;
IDXGISwapChain*         g_pSwapChain = NULL;
ID3D11RenderTargetView* g_pRenderTargetView = NULL;
ID3D11DepthStencilView* g_pDepthStencilView = NULL;
ID3D11Texture2D*		g_pDepthStencilBuffer = NULL;

//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND	- process the application menu
//  WM_PAINT	- Paint the main window
//  WM_DESTROY	- post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
	case WM_SETCURSOR:
		if (LOWORD(lParam) == HTCLIENT || LOWORD(lParam) == HTCAPTION)
		{
			SetCursor((HCURSOR)GetClassLongPtr(hWnd, GCLP_HCURSOR));
			return TRUE;
		}
		break;
	case WM_ENTERMENULOOP:
    case WM_ENTERSIZEMOVE:
        SetTimer(hWnd, 1, USER_TIMER_MINIMUM, NULL);
        break;
	case WM_EXITMENULOOP:
	case WM_EXITSIZEMOVE:
    	KillTimer(hWnd, 1);
    	break;
	case WM_ERASEBKGND:
		return 1;
	case WM_TIMER:
    	if (wParam == 1)
    	{
			// Tick UI
        	ui.tick();
        	ui.render();
			RenderManager.Present();
        	ui.CheckMenuDisplayed();

			// Tick Managers
			app.UpdateTime();
			InputManager.Tick();
			StorageManager.Tick();
			RenderManager.Tick();

			// Tick Music
			Minecraft *pMinecraft=Minecraft::GetInstance();
			pMinecraft->soundEngine->tick(NULL, 0.0f);
			pMinecraft->soundEngine->playMusicTick();
    	}
    	break;

	case WM_KEYDOWN:
	case WM_SYSKEYDOWN:
		if (!(lParam & 0x40000000))
		{
			InputManager.OnKeyDown((int)wParam);
		}
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_KEYUP:
	case WM_SYSKEYUP:
		InputManager.OnKeyUp((int)wParam);
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_CHAR:
		InputManager.OnChar((wchar_t)wParam);
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_INPUT:
		{
			UINT dwSize = 0;
			GetRawInputData((HRAWINPUT)lParam, RID_INPUT, nullptr, &dwSize, sizeof(RAWINPUTHEADER));
			if (dwSize > 0 && dwSize <= 256)
			{
				BYTE rawBuffer[256];
				if (GetRawInputData((HRAWINPUT)lParam, RID_INPUT, rawBuffer, &dwSize, sizeof(RAWINPUTHEADER)) == dwSize)
				{
					const RAWINPUT* raw = (RAWINPUT*)rawBuffer;
					if (raw->header.dwType == RIM_TYPEMOUSE)
					{
						InputManager.OnRawMouseDelta(raw->data.mouse.lLastX, raw->data.mouse.lLastY);
					}
				}
			}
		}
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_SIZE:
		g_iWindowClientW = LOWORD(lParam);
		g_iWindowClientH = HIWORD(lParam);
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_MOUSEMOVE:
		InputManager.OnMouseMove(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_LBUTTONDOWN:
		InputManager.OnLButtonDown(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_LBUTTONUP:
		InputManager.OnLButtonUp(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_RBUTTONDOWN:
		InputManager.OnRButtonDown(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_RBUTTONUP:
		InputManager.OnRButtonUp(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_MBUTTONDOWN:
		InputManager.OnMButtonDown(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_MBUTTONUP:
		InputManager.OnMButtonUp(LOWORD(lParam), HIWORD(lParam));
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_MOUSEWHEEL:
		{
			POINT pt = { (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam) };
			ScreenToClient(hWnd, &pt);
			InputManager.OnMouseWheel((short)HIWORD(wParam), pt.x, pt.y);
		}
		return DefWindowProc(hWnd, message, wParam, lParam);

	case WM_KILLFOCUS:
		InputManager.SetWindowFocused(false);
		if (InputManager.IsMouseCaptured())
			InputManager.SetMouseCaptured(false);
		break;

	case WM_SETFOCUS:
		InputManager.SetWindowFocused(true);
		break;

	case WM_CLOSE:
		app.ExitGame();
		break;
	case WM_DESTROY:
		PostQuitMessage(0);
		break;
	default:
		return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return DefWindowProc(hWnd, message, wParam, lParam);
}

//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
	WNDCLASSEX wcex;

	wcex.cbSize = sizeof(WNDCLASSEX);

	wcex.style			= CS_HREDRAW | CS_VREDRAW;
	wcex.lpfnWndProc	= WndProc;
	wcex.cbClsExtra		= 0;
	wcex.cbWndExtra		= 0;
	wcex.hInstance		= hInstance;
	wcex.hIcon			= LoadIcon(hInstance, "Minecraft");
	wcex.hCursor		= (HCURSOR)LoadImage(hInstance, MAKEINTRESOURCE(IDC_POINTER), IMAGE_CURSOR, 0, 0, LR_SHARED);
	wcex.hbrBackground	= (HBRUSH)(COLOR_WINDOW+1);
	wcex.lpszMenuName	= "Minecraft";
	wcex.lpszClassName	= "MinecraftClass";
	wcex.hIconSm		= LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MINECRAFTWINDOWS64));

	return RegisterClassEx(&wcex);
}

//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
	g_hInst = hInstance; // Store instance handle in our global variable

	RECT wr = {0, 0, g_iScreenWidth, g_iScreenHeight};    // set the size, but not the position
	AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);    // adjust the size

	g_hWnd = CreateWindow(	"MinecraftClass",
		"Minecraft",
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT,
		0,
		wr.right - wr.left,    // width of the window
		wr.bottom - wr.top,    // height of the window
		NULL,
		NULL,
		hInstance,
		NULL);

	if (!g_hWnd)
	{
		return FALSE;
	}

	ShowWindow(g_hWnd, (nCmdShow != SW_HIDE) ? SW_SHOWMAXIMIZED : nCmdShow);
	UpdateWindow(g_hWnd);

	RECT rcClient;
	if (GetClientRect(g_hWnd, &rcClient))
	{
		g_iWindowClientW = rcClient.right - rcClient.left;
		g_iWindowClientH = rcClient.bottom - rcClient.top;
	}

	return TRUE;
}

// 4J Stu - These functions are referenced from the Windows Input library
void ClearGlobalText()
{
	// clear the global text
	memset(chGlobalText,0,256);
	memset(ui16GlobalText,0,512);
}

uint16_t *GetGlobalText()
{
	//copy the ch text to ui16
	char * pchBuffer=(char *)ui16GlobalText;
		for(int i=0;i<256;i++)
		{
			pchBuffer[i*2]=chGlobalText[i];
		}
	return ui16GlobalText;
}
void SeedEditBox()
{
	DialogBox(hMyInst, MAKEINTRESOURCE(IDD_SEED),
		g_hWnd, reinterpret_cast<DLGPROC>(DlgProc));
}


//---------------------------------------------------------------------------
LRESULT CALLBACK DlgProc(HWND hWndDlg, UINT Msg, WPARAM wParam, LPARAM lParam)
{
	switch(Msg)
	{
	case WM_INITDIALOG:
		return TRUE;

	case WM_COMMAND:
		switch(wParam)
		{
		case IDOK:
			// Set the text
			GetDlgItemText(hWndDlg,IDC_EDIT,chGlobalText,256);
			EndDialog(hWndDlg, 0);
			return TRUE;
		}
		break;
	}

	return FALSE;
}

namespace DirectTextEdit
{
	static UIControl_TextInput *s_ctrl = NULL;
	static UIControl *s_parent = NULL;
	static bool s_mousePrev = false;
	static LineNavCallback s_navCb = NULL;
	static LPVOID s_navParam = NULL;
	static CommitCallback s_callback = NULL;
	static LPVOID s_param = NULL;
	static wstring s_text;
	static wstring s_initial;
	static size_t s_caret = 0;
	static bool s_selAll = false;
	static unsigned int s_maxChars = 0;
	static int s_keyMode = 0;
	static vector<pair<wstring, size_t> > s_undo;
	static wstring s_clipboard;
	static bool s_keyPrev[256] = { false };
	static int s_repKey = 0;
	static int s_repDelay = 0;

	static bool s_commitReady = false;
	static wstring s_commitText;

	enum { UNDO_CAP = 64, REPEAT_DELAY_FRAMES = 24, REPEAT_RATE_FRAMES = 2 };

	static void PushUndo()
	{
		if (s_undo.size() >= UNDO_CAP)
			s_undo.erase(s_undo.begin());
		s_undo.push_back(make_pair(s_text, s_caret));
	}

	static bool CharAllowed(wchar_t ch)
	{
		if (ch < 0x20 || ch == 0x7F)
			return false;
		if (s_keyMode == C_4JInput::EKeyboardMode_Numeric)
			return (ch >= L'0' && ch <= L'9') || ch == L'-' || ch == L'+';
		return true;
	}

	static void PushToFlash()
	{
		if (!s_ctrl)
			return;
		s_ctrl->setLabel(s_text.c_str());
		s_ctrl->SyncCaret((int)s_caret, (int)s_text.length());
	}

	static void InsertText(const wstring &ins)
	{
		if (ins.empty() || !s_ctrl)
			return;
		wstring filtered;
		for (size_t i = 0; i < ins.length(); ++i)
			if (CharAllowed(ins[i]))
				filtered += ins[i];
		if (filtered.empty())
			return;
		PushUndo();
		if (s_selAll)
		{
			s_text.clear();
			s_caret = 0;
			s_selAll = false;
		}
		if (s_text.length() + filtered.length() > s_maxChars)
			filtered.erase(s_maxChars > s_text.length() ? s_maxChars - s_text.length() : 0);
		s_text.insert(s_caret, filtered);
		s_caret += filtered.length();
		PushToFlash();
	}

	static void ActBackspace()
	{
		if (!s_ctrl)
			return;
		if (s_selAll)
		{
			s_selAll = false;
			if (s_text.empty())
				return;
			PushUndo();
			s_text.clear();
			s_caret = 0;
			PushToFlash();
			return;
		}
		if (s_caret == 0)
			return;
		PushUndo();
		s_text.erase(s_caret - 1, 1);
		--s_caret;
		PushToFlash();
	}

	static void ActDelete()
	{
		if (!s_ctrl)
			return;
		if (s_selAll)
		{
			s_selAll = false;
			if (s_text.empty())
				return;
			PushUndo();
			s_text.clear();
			s_caret = 0;
			PushToFlash();
			return;
		}
		if (s_caret >= s_text.length())
			return;
		PushUndo();
		s_text.erase(s_caret, 1);
		PushToFlash();
	}

	static void ActLeft()
	{
		if (!s_ctrl || s_caret == 0)
		{
			s_selAll = false;
			return;
		}
		s_selAll = false;
		--s_caret;
		PushToFlash();
	}

	static void ActRight()
	{
		if (!s_ctrl)
			return;
		s_selAll = false;
		if (s_caret < s_text.length())
		{
			++s_caret;
			PushToFlash();
		}
	}

	static void ActHome()
	{
		if (!s_ctrl)
			return;
		s_selAll = false;
		if (s_caret != 0)
		{
			s_caret = 0;
			PushToFlash();
		}
	}

	static void ActEnd()
	{
		if (!s_ctrl)
			return;
		s_selAll = false;
		if (s_caret != s_text.length())
		{
			s_caret = s_text.length();
			PushToFlash();
		}
	}

	static void CopyToClipboard(const wstring &s)
	{
		s_clipboard = s;
		InputManager.SetClipboardText(s.c_str());
	}

	static bool ClipboardText(wstring &out)
	{
		wchar_t buf[512];
		int n = InputManager.GetClipboardText(buf, 512);
		if (n > 0)
		{
			out.assign(buf, n);
			return true;
		}
		if (!s_clipboard.empty())
		{
			out = s_clipboard;
			return true;
		}
		return false;
	}

	static bool FreshPress(int vk)
	{
		return vk >= 0 && vk < 256 && InputManager.IsKeyDown(vk) && !s_keyPrev[vk];
	}

	static void PollRepeatKey(int vk, void (*action)())
	{
		bool down = InputManager.IsKeyDown(vk);
		if (down && !s_keyPrev[vk])
		{
			action();
			s_repKey = vk;
			s_repDelay = REPEAT_DELAY_FRAMES;
		}
		else if (down && s_repKey == vk)
		{
			if (--s_repDelay <= 0)
			{
				action();
				s_repDelay = REPEAT_RATE_FRAMES;
			}
		}
		else if (!down && s_repKey == vk)
		{
			s_repKey = 0;
		}
	}

	static bool ClickOutsideBox()
	{
		if (!s_ctrl)
			return false;
		UIScene *scene = s_ctrl->getParentScene();
		if (!scene)
			return false;
		float movieW = (float)scene->getMovieWidth();
		float movieH = (float)scene->getMovieHeight();
		float fx = (float)InputManager.GetMouseX();
		float fy = (float)InputManager.GetMouseY();
		if (movieW > 0.0f && movieH > 0.0f && g_iWindowClientW > 0 && g_iWindowClientH > 0)
		{
			fx = fx * (movieW / (float)g_iWindowClientW);
			fy = fy * (movieH / (float)g_iWindowClientH);
		}
		float ox = 0.0f, oy = 0.0f;
		if (s_parent)
		{
			s_parent->UpdateControl();
			ox = (float)s_parent->getXPos();
			oy = (float)s_parent->getYPos();
		}
		s_ctrl->UpdateControl();
		float w = (float)s_ctrl->getWidth();
		float h = (float)s_ctrl->getHeight();
		if (w < 4.0f || h < 4.0f)
			return false;
		float x = ox + (float)s_ctrl->getXPos();
		float y = oy + (float)s_ctrl->getYPos();
		return fx < x || fx >= x + w || fy < y || fy >= y + h;
	}

	void Begin(UIControl_TextInput *ctrl, UIControl *parent,
		const wchar_t *initialText,
		unsigned int maxChars, int keyboardMode,
		CommitCallback callback, LPVOID param)
	{
		if (!ctrl)
			return;
		if (s_ctrl == ctrl)
			return;
		if (s_ctrl)
			Finish(true);
		s_ctrl = ctrl;
		s_parent = parent;
		s_mousePrev = InputManager.IsMouseLDown();
		s_callback = callback;
		s_param = param;
		s_text = initialText ? initialText : L"";
		s_initial = s_text;
		s_caret = s_text.length();
		s_selAll = false;
		s_maxChars = maxChars;
		s_keyMode = keyboardMode;
		s_undo.clear();
		memset(s_keyPrev, 0, sizeof(s_keyPrev));
		s_repKey = 0;
		ctrl->setFocus(true);
		PushToFlash();
	}

	bool IsActive()
	{
		return s_ctrl != NULL;
	}

	void SetLineNav(LineNavCallback callback, LPVOID param)
	{
		if (!s_ctrl)
			return;
		s_navCb = callback;
		s_navParam = param;
	}

	static void DoLineNav(int vk, int dir)
	{
		LineNavCallback cb = s_navCb;
		LPVOID p = s_navParam;
		Finish(true);
		if (cb)
			cb(p, dir);
		s_keyPrev[vk] = true;
		s_repKey = vk;
		s_repDelay = REPEAT_DELAY_FRAMES;
	}

	static void PollNavKey(int vk, int dir)
	{
		if (!s_navCb)
			return;
		bool down = InputManager.IsKeyDown(vk);
		if (down && !s_keyPrev[vk])
		{
			DoLineNav(vk, dir);
		}
		else if (down && s_repKey == vk)
		{
			if (--s_repDelay <= 0)
			{
				DoLineNav(vk, dir);
				s_repDelay = REPEAT_RATE_FRAMES;
			}
		}
		else if (!down && s_repKey == vk)
		{
			s_repKey = 0;
		}
	}

	void Tick()
	{
		if (!s_ctrl)
			return;

		s_ctrl->RefreshFocus();

		{
			UIScene *pinScene = s_ctrl->getParentScene();
			if (pinScene && s_ctrl->getId() >= 0)
				pinScene->SetFocusToElement(s_ctrl->getId(), true);
		}

		bool mouseDown = InputManager.IsMouseLDown();
		if (mouseDown && !s_mousePrev)
		{
			if (ClickOutsideBox())
			{
				Finish(true);
				s_mousePrev = mouseDown;
				for (int v = 0; v < 256; ++v)
					s_keyPrev[v] = InputManager.IsKeyDown(v);
				return;
			}
		}
		s_mousePrev = mouseDown;

		bool ctrlDown = InputManager.IsKeyDown(VK_CONTROL) && !InputManager.IsKeyDown(VK_MENU);
		if (ctrlDown)
		{
			if (FreshPress('A'))
			{
				s_selAll = !s_text.empty();
			}
			else if (FreshPress('C'))
			{
				CopyToClipboard(s_text);
			}
			else if (FreshPress('X'))
			{
				CopyToClipboard(s_text);
				if (!s_text.empty())
				{
					PushUndo();
					s_text.clear();
					s_caret = 0;
					s_selAll = false;
					PushToFlash();
				}
			}
			else if (FreshPress('V'))
			{
				wstring pasted;
				if (ClipboardText(pasted))
					InsertText(pasted);
			}
			else if (FreshPress('Z'))
			{
				if (!s_undo.empty())
				{
					s_text = s_undo.back().first;
					s_caret = s_undo.back().second;
					if (s_caret > s_text.length())
						s_caret = s_text.length();
					s_undo.pop_back();
					s_selAll = false;
					PushToFlash();
				}
			}
		}

		if (FreshPress(VK_RETURN))
		{
			if (s_navCb)
			{
				LineNavCallback cb = s_navCb;
				LPVOID p = s_navParam;
				Finish(true);
				cb(p, +1);
			}
			else
			{
				Finish(true);
			}
		}
		else if (FreshPress(VK_ESCAPE))
		{
			Finish(false);
		}
		else if (s_ctrl)
		{
			int n = InputManager.GetCharCount();
			if (n > 0)
			{
				wstring ins;
				for (int i = 0; i < n; ++i)
					ins += InputManager.GetChar(i);
				InsertText(ins);
			}
			PollRepeatKey(VK_BACK, ActBackspace);
			PollRepeatKey(VK_DELETE, ActDelete);
			PollRepeatKey(VK_LEFT, ActLeft);
			PollRepeatKey(VK_RIGHT, ActRight);
			PollRepeatKey(VK_HOME, ActHome);
			PollRepeatKey(VK_END, ActEnd);
			PollNavKey(VK_UP, -1);
			PollNavKey(VK_DOWN, +1);
		}

		for (int v = 0; v < 256; ++v)
			s_keyPrev[v] = InputManager.IsKeyDown(v);
	}

	void Finish(bool accepted)
	{
		if (!s_ctrl)
			return;
		UIControl_TextInput *ctrl = s_ctrl;
		s_ctrl = NULL;
		if (!accepted)
		{
			s_text = s_initial;
			s_caret = 0;
			ctrl->setLabel(s_text.c_str());
		}
		ctrl->setFocus(false);
		if (s_callback)
		{
			s_commitReady = true;
			s_commitText = accepted ? s_text : L"";
			CommitCallback cb = s_callback;
			LPVOID p = s_param;
			s_callback = NULL;
			s_param = NULL;
			cb(p, accepted);
			s_commitReady = false;
		}
		s_undo.clear();
		s_selAll = false;
		s_repKey = 0;
		s_navCb = NULL;
		s_navParam = NULL;
	}

	bool TakeText(uint16_t *outText, unsigned int outCapacity)
	{
		if (!s_commitReady || !outText || outCapacity == 0)
			return false;
		unsigned int n = (unsigned int)s_commitText.length();
		if (n >= outCapacity)
			n = outCapacity - 1;
		for (unsigned int i = 0; i < n; ++i)
			outText[i] = (uint16_t)s_commitText[i];
		outText[n] = 0;
		return true;
	}
};

//--------------------------------------------------------------------------------------
// Create Direct3D device and swap chain
//--------------------------------------------------------------------------------------
HRESULT InitDevice()
{
	HRESULT hr = S_OK;

	//str1k3r - use screen size instead of window size & detect if its widescreen or not
	if (!g_bResolutionSetByCMD)
	{
		HMONITOR hMonitor = MonitorFromWindow(g_hWnd, MONITOR_DEFAULTTONEAREST);
		MONITORINFO monitorInfo = { sizeof(MONITORINFO) };
		if (GetMonitorInfo(hMonitor, &monitorInfo))
		{
			g_iScreenWidth = monitorInfo.rcMonitor.right - monitorInfo.rcMonitor.left;
			g_iScreenHeight = monitorInfo.rcMonitor.bottom - monitorInfo.rcMonitor.top;
		}
		else
		{
			g_iScreenWidth = GetSystemMetrics(SM_CXSCREEN);
			g_iScreenHeight = GetSystemMetrics(SM_CYSCREEN);
		}
	}
	
	//str1k3r - stop hardcoding size and just use the screens actual size
	UINT width = g_iScreenWidth;
	UINT height = g_iScreenHeight;

	UINT createDeviceFlags = 0;
#ifdef _DEBUG
	app.DebugPrintf("Screen Width: %d, Screen Height: %d\n", width, height);
	createDeviceFlags |= D3D11_CREATE_DEVICE_DEBUG;
#endif

	D3D_DRIVER_TYPE driverTypes[] =
	{
		D3D_DRIVER_TYPE_HARDWARE,
		D3D_DRIVER_TYPE_WARP,
#ifdef _DEBUG //str1k3r - using this can actually SLOW stuff down, as its ran on the CPU instead of the GPU also only intended for debugging
		D3D_DRIVER_TYPE_REFERENCE,
#endif
	};
	UINT numDriverTypes = ARRAYSIZE( driverTypes );

	D3D_FEATURE_LEVEL featureLevels[] =
	{
		D3D_FEATURE_LEVEL_11_1,
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0,
	};
	UINT numFeatureLevels = ARRAYSIZE( featureLevels );

	DXGI_SWAP_CHAIN_DESC sd;
	ZeroMemory( &sd, sizeof( sd ) );
	sd.BufferCount = 2;
	sd.BufferDesc.Width = width;
	sd.BufferDesc.Height = height;
	sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	sd.BufferDesc.RefreshRate.Numerator = 0;
	sd.BufferDesc.RefreshRate.Denominator = 0;
	sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	sd.OutputWindow = g_hWnd;
	sd.SampleDesc.Count = 1;
	sd.SampleDesc.Quality = 0;
	sd.Windowed = TRUE;

	for( UINT driverTypeIndex = 0; driverTypeIndex < numDriverTypes; driverTypeIndex++ )
	{
		g_driverType = driverTypes[driverTypeIndex];

		hr = D3D11CreateDeviceAndSwapChain( NULL, g_driverType, NULL, createDeviceFlags, featureLevels, numFeatureLevels,
			D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );

		if (hr == E_INVALIDARG && numFeatureLevels > 1 && featureLevels[0] == D3D_FEATURE_LEVEL_11_1)
		{
			hr = D3D11CreateDeviceAndSwapChain( NULL, g_driverType, NULL, createDeviceFlags, &featureLevels[1], numFeatureLevels - 1,
				D3D11_SDK_VERSION, &sd, &g_pSwapChain, &g_pd3dDevice, &g_featureLevel, &g_pImmediateContext );
		}

		if( SUCCEEDED( hr ) )
			break;
	}
	if( FAILED( hr ) )
		return hr;

	// Create a render target view
	ID3D11Texture2D* pBackBuffer = NULL;
	hr = g_pSwapChain->GetBuffer( 0, __uuidof( ID3D11Texture2D ), ( LPVOID* )&pBackBuffer );
	if( FAILED( hr ) )
		return hr;

	// Create a depth stencil buffer
	D3D11_TEXTURE2D_DESC descDepth;

	descDepth.Width = width;
	descDepth.Height = height;
	descDepth.MipLevels = 1;
	descDepth.ArraySize = 1;
	descDepth.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
	descDepth.SampleDesc.Count = 1;
	descDepth.SampleDesc.Quality = 0;
	descDepth.Usage = D3D11_USAGE_DEFAULT;
	descDepth.BindFlags = D3D11_BIND_DEPTH_STENCIL;
	descDepth.CPUAccessFlags = 0;
	descDepth.MiscFlags = 0;
	hr = g_pd3dDevice->CreateTexture2D(&descDepth, NULL, &g_pDepthStencilBuffer);

	D3D11_DEPTH_STENCIL_VIEW_DESC descDSView;
	ZeroMemory(&descDSView, sizeof(descDSView));
	descDSView.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
	descDSView.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
	descDSView.Texture2D.MipSlice = 0;

	hr = g_pd3dDevice->CreateDepthStencilView(g_pDepthStencilBuffer, &descDSView, &g_pDepthStencilView);

	hr = g_pd3dDevice->CreateRenderTargetView( pBackBuffer, NULL, &g_pRenderTargetView );
	pBackBuffer->Release();
	if( FAILED( hr ) )
		return hr;

	g_pImmediateContext->OMSetRenderTargets( 1, &g_pRenderTargetView, g_pDepthStencilView );

	// Setup the viewport
	D3D11_VIEWPORT vp;
	vp.Width = (FLOAT)width;
	vp.Height = (FLOAT)height;
	vp.MinDepth = 0.0f;
	vp.MaxDepth = 1.0f;
	vp.TopLeftX = 0;
	vp.TopLeftY = 0;
	g_pImmediateContext->RSSetViewports( 1, &vp );

	//RenderManager.Initialise(g_pd3dDevice, g_pSwapChain); //str1k3r - this was getting ran twice, keeping this commented out just incase

	return S_OK;
}

//--------------------------------------------------------------------------------------
// Render the frame
//--------------------------------------------------------------------------------------
void Render()
{
	// Just clear the backbuffer
	float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f }; //red,green,blue,alpha

	g_pImmediateContext->ClearRenderTargetView( g_pRenderTargetView, ClearColor );
	g_pSwapChain->Present( 0, 0 );
}

//--------------------------------------------------------------------------------------
// Toggle borderless fullscreen
// Credits to the smartCMD repo for this
// This is the proper way to do this therefore we just took it
//--------------------------------------------------------------------------------------
void ToggleFullscreen()
{
	const DWORD dwStyle = GetWindowLong(g_hWnd, GWL_STYLE);
	if (!g_isFullscreen)
	{
		MONITORINFO mi = { sizeof(mi) };
		if (GetWindowPlacement(g_hWnd, &g_wpPrev) &&
			GetMonitorInfo(MonitorFromWindow(g_hWnd, MONITOR_DEFAULTTOPRIMARY), &mi))
		{
			SetWindowLong(g_hWnd, GWL_STYLE, dwStyle & ~WS_OVERLAPPEDWINDOW);
			SetWindowPos(g_hWnd, HWND_TOP,
				mi.rcMonitor.left, mi.rcMonitor.top,
				mi.rcMonitor.right - mi.rcMonitor.left,
				mi.rcMonitor.bottom - mi.rcMonitor.top,
				SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
		}
	}
	else
	{
		SetWindowLong(g_hWnd, GWL_STYLE, dwStyle | WS_OVERLAPPEDWINDOW);
		SetWindowPlacement(g_hWnd, &g_wpPrev);
		SetWindowPos(g_hWnd, nullptr, 0, 0, 0, 0,
			SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER | SWP_NOOWNERZORDER | SWP_FRAMECHANGED);
	}
	g_isFullscreen = !g_isFullscreen;
}


//--------------------------------------------------------------------------------------
// Clean up the objects we've created
//--------------------------------------------------------------------------------------
void CleanupDevice()
{
	if( g_pImmediateContext ) g_pImmediateContext->ClearState();

	if( g_pRenderTargetView ) g_pRenderTargetView->Release();
	if( g_pSwapChain ) g_pSwapChain->Release();
	if( g_pImmediateContext ) g_pImmediateContext->Release();
	if( g_pd3dDevice ) g_pd3dDevice->Release();
}

int APIENTRY _tWinMain(_In_ HINSTANCE hInstance,
					   _In_opt_ HINSTANCE hPrevInstance,
					   _In_ LPTSTR    lpCmdLine,
					   _In_ int       nCmdShow)
{
	UNREFERENCED_PARAMETER(hPrevInstance);
	UNREFERENCED_PARAMETER(lpCmdLine);

	//str1k3r - tell windows that we are aware of high DPI displays
	SetProcessDPIAware();

	Windows64LaunchArgs launchArgs = ParseLaunchArgs();

	if(launchArgs.resolution != 0)
	{
		if(launchArgs.resolution == 1)
		{
			// 2160p
			g_iScreenWidth = 3840;
			g_iScreenHeight = 2160;
			g_bResolutionSetByCMD = TRUE;
		}
		else if(launchArgs.resolution == 2)
		{
			// 1440p
			g_iScreenWidth = 2560;
			g_iScreenHeight = 1440;
			g_bResolutionSetByCMD = TRUE;
		}
		else if (launchArgs.resolution == 3)
		{
			// 1080p
			g_iScreenWidth = 1920;
			g_iScreenHeight = 1080;
			g_bResolutionSetByCMD = TRUE;
		}
		else if(launchArgs.resolution == 4)
		{
			// 720p
			g_iScreenWidth = 1280;
			g_iScreenHeight = 720;
			g_bResolutionSetByCMD = TRUE;
		}
		else if(launchArgs.resolution == 5)
		{
			// 480p
			g_iScreenWidth = 640;
			g_iScreenHeight = 480;
			g_bResolutionSetByCMD = TRUE;
		}
		else if(launchArgs.resolution == 6)
		{
			// Vita Native, 544p
			g_iScreenWidth = 960;
			g_iScreenHeight = 544;
			g_bResolutionSetByCMD = TRUE;
		}
	}

	// Initialize global strings
	MyRegisterClass(hInstance);

	// Perform application initialization:
	if (!InitInstance (hInstance, nCmdShow))
	{
		return FALSE;
	}

	hMyInst=hInstance;

	if( FAILED( InitDevice() ) )
	{
		CleanupDevice();
		return 0;
	}

	if(launchArgs.fullscreen)
	{
		ToggleFullscreen();
	}

	static bool bTrialTimerDisplayed=true;

	app.loadMediaArchive();

	RenderManager.Initialise(g_pd3dDevice, g_pSwapChain);

	//str1k3r - set the resolution that we have at time of launch
	RenderManager.setResolution(g_iScreenWidth, g_iScreenHeight);
	
	app.loadStringTable();
	ui.init(g_pd3dDevice,g_pImmediateContext,g_pRenderTargetView,g_pDepthStencilView,g_iScreenWidth,g_iScreenHeight);

	////////////////
	// Initialise //
	////////////////

	// Set the number of possible joypad layouts that the user can switch between, and the number of actions
	InputManager.Initialise(1,3,MINECRAFT_ACTION_MAX, ACTION_MAX_MENU);

	// Set the default joypad action mappings for Minecraft
	DefineActions();
	InputManager.SetJoypadMapVal(0,0);
	InputManager.SetKeyRepeatRate(0.3f,0.2f);

	//str1k3r - load username.txt if we havent ran the -name arg
	if(!launchArgs.name) ProfileManager.LoadGamertag();

	// Initialise the profile manager with the game Title ID, Offer ID, a profile version number, and the number of profile values and settings
	ProfileManager.Initialise(TITLEID_MINECRAFT,
		app.m_dwOfferID,
		PROFILE_VERSION_12,
		NUM_PROFILE_VALUES,
		NUM_PROFILE_SETTINGS,
		dwProfileSettingsA,
		app.GAME_DEFINED_PROFILE_DATA_BYTES*XUSER_MAX_COUNT,
		&app.uiGameDefinedDataChangedBitmask
	);

	// initialise the storage manager with a default save display name, a Minimum save size, and a callback for displaying the saving message
	StorageManager.Init(0,app.GetString(IDS_DEFAULT_SAVENAME),"savegame.dat",FIFTY_ONE_MB,&CConsoleMinecraftApp::DisplaySavingMessage,(LPVOID)&app,"");

	// Set a callback for the default player options to be set - when there is no profile data for the player
	ProfileManager.SetDefaultOptionsCallback(&CConsoleMinecraftApp::DefaultOptionsCallback,(LPVOID)&app);

	// QNet needs to be setup after profile manager, as we do not want its Notify listener to handle
	// XN_SYS_SIGNINCHANGED notifications. This does mean that we need to have a callback in the
	// ProfileManager for XN_LIVE_INVITE_ACCEPTED for QNet.
	g_NetworkManager.Initialise();

	// debug switch to trial version
	ProfileManager.SetDebugFullOverride(true);

	// Initialise TLS for tesselator, for this main thread
	Tesselator::CreateNewThreadStorage(1024*1024);
	// Initialise TLS for AABB and Vec3 pools, for this main thread
	AABB::CreateNewThreadStorage();
	Vec3::CreateNewThreadStorage();
	IntCache::CreateNewThreadStorage();
	Compression::CreateNewThreadStorage();
	OldChunkStorage::CreateNewThreadStorage();
	Level::enableLightingCache();
	Tile::CreateNewThreadStorage();

	Minecraft::main();
	Minecraft *pMinecraft=Minecraft::GetInstance();

	app.InitGameSettings();

	app.InitialiseTips();

#ifdef _TEMPORARY_CREATE_GAME
	app.TemporaryCreateGameStart();

	Sleep(10000);
#endif

	MSG msg = {0};
	while( WM_QUIT != msg.message )
	{
		while( PeekMessage( &msg, NULL, 0, 0, PM_REMOVE ) )
		{
			if (msg.message == WM_QUIT) break;
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		if (msg.message == WM_QUIT) break;
		RenderManager.StartFrame();

		app.UpdateTime();

		if (app.GetGameStarted())
		{
			int iPad = ProfileManager.GetPrimaryPad();
		TickMenuNavKeys(iPad, ui.GetMenuDisplayed(iPad) || pMinecraft->screen != NULL);
		if (ui.GetMenuDisplayed(iPad) || pMinecraft->screen != NULL)
		{
			if (InputManager.IsKeyDown(VK_ESCAPE) && !s_bEscapeKeyPrev && !DirectTextEdit::IsActive())
			{
				InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_CANCEL));
			}

				bool bMouseL = InputManager.IsMouseLDown();
				bool bMouseR = InputManager.IsMouseRDown();
			if (bMouseL && !s_bMenuMouseLPrev)
			{
				if (InputManager.IsKeyDown(VK_SHIFT))
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_Y));
				else if (!ui.IsCraftingMenuDisplayed(iPad))
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_A));
			}
				if (bMouseR && !s_bMenuMouseRPrev)
				{
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_X));
				}
				s_bMenuMouseLPrev = bMouseL;
				s_bMenuMouseRPrev = bMouseR;

				int iWheelMenu = InputManager.GetMouseWheelDelta();
				if (iWheelMenu > 0)
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_OTHER_STICK_UP));
				else if (iWheelMenu < 0)
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_OTHER_STICK_DOWN));
				s_iWheelCarry = 0;
				g_iPendingHotbarScroll = 0;
			}
			else
			{
			if (InputManager.IsMouseLDown()) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_ACTION));
			if (InputManager.IsMouseRDown()) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_USE));
			if (!DirectTextEdit::IsActive())
			{
				if (InputManager.IsKeyDown('Q')) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_DROP));
				if (InputManager.IsKeyDown(VK_SHIFT)) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_SNEAK_TOGGLE));
				if (InputManager.IsKeyDown('E')) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_INVENTORY));
				if (InputManager.IsKeyDown('F')) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_RENDER_THIRD_PERSON));
				if (InputManager.IsKeyDown(VK_ESCAPE)) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_PAUSEMENU));
				if (InputManager.IsKeyDown('R')) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_CRAFTING));
				if (InputManager.IsKeyDown(VK_TAB)) InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), MINECRAFT_ACTION_GAME_INFO));
			}
				s_iWheelCarry += InputManager.GetMouseWheelDelta();
				int iNewNotches = s_iWheelCarry / 120;
				if (iNewNotches != 0)
				{
					s_iWheelCarry -= iNewNotches * 120;
					g_iPendingHotbarScroll += iNewNotches;
					if (g_iPendingHotbarScroll > 12) g_iPendingHotbarScroll = 12;
					else if (g_iPendingHotbarScroll < -12) g_iPendingHotbarScroll = -12;
				}
			}
			s_bEscapeKeyPrev = InputManager.IsKeyDown(VK_ESCAPE);
		}
		else
		{
			int iPad = ProfileManager.GetPrimaryPad();
		TickMenuNavKeys(iPad, ui.GetMenuDisplayed(iPad) ? true : false);
		if (ui.GetMenuDisplayed(iPad))
		{
			if (InputManager.IsKeyDown(VK_ESCAPE) && !s_bEscapeKeyPrev && !DirectTextEdit::IsActive())
			{
				InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_CANCEL));
			}

			bool bMouseL = InputManager.IsMouseLDown();
			bool bMouseR = InputManager.IsMouseRDown();
		if (bMouseL && !s_bMenuMouseLPrev)
		{
			if (!ui.IsSkinSelectMenuDisplayed(iPad))
				InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_OK));
		}
			s_bMenuMouseLPrev = bMouseL;
			s_bMenuMouseRPrev = bMouseR;

				int iWheelMenu = InputManager.GetMouseWheelDelta();
				if (iWheelMenu > 0)
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_OTHER_STICK_UP));
				else if (iWheelMenu < 0)
					InputManager.MapTouchInput(iPad, InputManager.GetGameJoypadMaps(InputManager.GetJoypadMapVal(iPad), ACTION_MENU_OTHER_STICK_DOWN));
			}
			s_bEscapeKeyPrev = InputManager.IsKeyDown(VK_ESCAPE);
		}

		{
			int iPad = ProfileManager.GetPrimaryPad();
			bool bPointerMenu = ui.IsContainerMenuDisplayed(iPad) && !ui.IsCraftingMenuDisplayed(iPad);
			if (bPointerMenu && !InputManager.IsMouseCaptured())
			{
				while (ShowCursor(FALSE) >= 0) {}
			}
			else if (!InputManager.IsMouseCaptured())
			{
				while (ShowCursor(TRUE) < 0) {}
			}
		}

		DirectTextEdit::Tick();

		PIXBeginNamedEvent(0,"Input manager tick mouse");
		InputManager.TickKBM();
		PIXEndNamedEvent();

		PIXBeginNamedEvent(0,"Input manager tick");
		if (GetFocus())
		{
			InputManager.Tick();
		}
		PIXEndNamedEvent();
		/*PIXBeginNamedEvent(0,"Profile manager tick");
		ProfileManager.Tick();
		PIXEndNamedEvent();*/
		PIXBeginNamedEvent(0,"Storage manager tick");
		StorageManager.Tick();
		PIXEndNamedEvent();
		PIXBeginNamedEvent(0,"Render manager tick");
		RenderManager.Tick();
		PIXEndNamedEvent();

		PIXBeginNamedEvent(0,"Network manager do work #1");
		//		g_NetworkManager.DoWork();
		PIXEndNamedEvent();

		// LeaderboardManager::Instance()->Tick();
		// Render game graphics.
		if(app.GetGameStarted())
		{
			pMinecraft->run_middle();
			app.SetAppPaused( g_NetworkManager.IsLocalGame() && g_NetworkManager.GetPlayerCount() == 1 && ui.IsPauseMenuDisplayed(ProfileManager.GetPrimaryPad()) );
		}
		else
		{
			MemSect(28);
			pMinecraft->soundEngine->tick(NULL, 0.0f);
			MemSect(0);
			pMinecraft->textures->tick(true,false);
			IntCache::Reset();
			if( app.GetReallyChangingSessionType() )
			{
				pMinecraft->tickAllConnections();		// Added to stop timing out when we are waiting after converting to an offline game
			}
		}

		pMinecraft->soundEngine->playMusicTick();

		ui.tick();
		ui.render();

		//str1k3r - update resolution
		ui.updateResolution(g_iScreenWidth, g_iScreenHeight);

		// Present the frame.
		RenderManager.Present();

		ui.CheckMenuDisplayed();

		// Any threading type things to deal with from the xui side?
		app.HandleUIActions();

		isF11Pressed = (GetAsyncKeyState(VK_F11) & 0x8000) != 0;

		if(isF11Pressed && !wasF11Pressed && GetFocus())
		{
			ToggleFullscreen();
		}
		else if(isF11Pressed && !wasF11Pressed && GetFocus())
		{
			ToggleFullscreen();
		}

		wasF11Pressed = isF11Pressed;

		if(app.GetGameStarted())
		{
			if(ui.IsPauseMenuDisplayed(ProfileManager.GetPrimaryPad()))
			{
				if(launchArgs.vsync) RenderManager.SetVSync(true);
			}
			else
			{
				if(launchArgs.vsync) RenderManager.SetVSync(false);
			}
		}
		if(launchArgs.vsync && !app.GetGameStarted()) RenderManager.SetVSync(true);

		// 4J-PB - Update the trial timer display if we are in the trial version
		if(!ProfileManager.IsFullVersion())
		{
			// display the trial timer
			if(app.GetGameStarted())
			{
				// 4J-PB - if the game is paused, add the elapsed time to the trial timer count so it doesn't tick down
				if(app.IsAppPaused())
				{
					app.UpdateTrialPausedTimer();
				}
				ui.UpdateTrialTimer(ProfileManager.GetPrimaryPad());
			}
		}
		else
		{
			// need to turn off the trial timer if it was on , and we've unlocked the full version
			if(bTrialTimerDisplayed)
			{
				ui.ShowTrialTimer(false);
				bTrialTimerDisplayed=false;
			}
		}

		// Fix for #7318 - Title crashes after short soak in the leaderboards menu
		// A memory leak was caused because the icon renderer kept creating new Vec3's because the pool wasn't reset
		Vec3::resetPool();
	}

	//str1k3r - shutdown server & network manager
	MinecraftServer::HaltServer();
	g_NetworkManager.Terminate();

	//str1k3r - unregister the minecraft window class
	UnregisterClass("MinecraftClass", g_hInst);

	//str1k3r - shutdown Iggy
	ui.shutdown();
	IggyShutdown();

	//str1k3r - shutdown mss :3
	AIL_shutdown();

	//str1k3r - cleanup DirectX stuff
	CleanupDevice();

	//str1k3r - pass exitcode to OS, removed app.ExitGame() as that made it always exit with 0
	return (int)msg.wParam;
}