#include maps\mp\gametypes\_globallogic;
#include maps\mp\gametypes\_hud;
#include maps\mp\gametypes\_hud_util;
#include maps\mp\_utility;
#include common_scripts\utility;

init()
{
    precacheShader("menu_mp_killstreak_select");
    precacheShader("menu_mp_contract_expired");
    precacheShader("emblem_bg_att_select_fire");
    precacheShader("hud_gl_select");
    precacheShader("map_mortar_selector");
    precacheShader("hud_obit_death_crush");

    precacheShader("ui_scrollbar_arrow_right");
    precacheShader("ui_scrollbar_arrow_left");
    level thread onPlayerConnect();
}

onPlayerConnect()
{
    for(;;)
    {
        level waittill( "connecting", player );

        // define variables used later on
        player.isInMenu = false;
        player.currentMenu = "main";
        player.textDrawn = false;
        player.shadersDrawn = false;

        player thread onPlayerSpawned();
    }
}

onPlayerSpawned()
{

    isFirstSpawn = true;

    self waittill("spawned_player");

        // only runs once when the player spawns for the first time
    if(isFirstSpawn)
    {
        initOverFlowFix();

        thread runController(); // should only ever be called once
        buildMenu();
        self freezeControls(false); // testing only

        isFirstSpawn = false;
    }
    self iprintln("Press [{+actionslot 2}] To Open Menu");

    for(;;)
    {
		self waittill("spawned_player");
		self iprintln("Press [{+actionslot 2}] To Open Menu");
		wait 0.05;
	}
}

/*
 * Text Table Structure:
 *
 * id = id of text element
 * element = text element
 * stringId = id of string text element uses
 *
 **************************************************
 *
 * String Table Structure:
 *
 * id = id of string
 * string = string value
 *
 */

initOverFlowFix()
{
    // tables
    self.stringTable = [];
    self.stringTableEntryCount = 0;
    self.textTable = [];
    self.textTableEntryCount = 0;

    if(isDefined(level.anchorText) == false)
    {
        level.anchorText = createServerFontString("default",1.5);
        level.anchorText setText("anchor");
        level.anchorText.alpha = 0;

        level.stringCount = 0;
        level thread monitorOverflow();
    }
}

// strings cache serverside -- all string entries are shared by every player
monitorOverflow()
{
    for(;;)
    {
        if(level.stringCount >= 60)
        {
            level.anchorText clearAllTextAfterHudElem();
            level.stringCount = 0;

            foreach(player in level.players)
            {
                player purgeTextTable();
                player purgeStringTable();
                player recreateText();
            }
        }

        wait 0.05;
    }
}

setSafeText(player, text)
{
    stringId = player getStringId(text);

    // if the string doesn't exist add it and get its id
    if(stringId == -1)
    {
        player addStringTableEntry(text);
        stringId = player getStringId(text);
    }

    // update the entry for this text element
    player editTextTableEntry(self.textTableIndex, stringId);

    self setText(text);
}

recreateText()
{
    foreach(entry in self.textTable)
        entry.element setSafeText(self, lookUpStringById(entry.stringId));
}

addStringTableEntry(string)
{
    // create new entry
    entry = spawnStruct();
    entry.id = self.stringTableEntryCount;
    entry.string = string;

    self.stringTable[self.stringTable.size] = entry; // add new entry
    self.stringTableEntryCount++;
    level.stringCount++;
}

lookUpStringById(id)
{
    string = "";

    foreach(entry in self.stringTable)
    {
        if(entry.id == id)
        {
            string = entry.string;
            break;
        }
    }

    return string;
}

getStringId(string)
{
    id = -1;

    foreach(entry in self.stringTable)
    {
        if(entry.string == string)
        {
            id = entry.id;
            break;
        }
    }

    return id;
}

getStringTableEntry(id)
{
    stringTableEntry = -1;

    foreach(entry in self.stringTable)
    {
        if(entry.id == id)
        {
            stringTableEntry = entry;
            break;
        }
    }

    return stringTableEntry;
}

purgeStringTable()
{
    stringTable = [];

    // store all used strings
    foreach(entry in self.textTable)
        stringTable[stringTable.size] = getStringTableEntry(entry.stringId);

    self.stringTable = stringTable; // empty array
}

purgeTextTable()
{
    textTable = [];

    foreach(entry in self.textTable)
    {
        if(entry.id != -1)
            textTable[textTable.size] = entry;
    }

    self.textTable = textTable;
}

addTextTableEntry(element, stringId)
{
    entry = spawnStruct();
    entry.id = self.textTableEntryCount;
    entry.element = element;
    entry.stringId = stringId;

    element.textTableIndex = entry.id;

    self.textTable[self.textTable.size] = entry;
    self.textTableEntryCount++;
}

editTextTableEntry(id, stringId)
{
    foreach(entry in self.textTable)
    {
        if(entry.id == id)
        {
            entry.stringId = stringId;
            break;
        }
    }
}

deleteTextTableEntry(id)
{
    foreach(entry in self.textTable)
    {
        if(entry.id == id)
        {
            entry.id = -1;
            entry.stringId = -1;
        }
    }
}

clear(player)
{
    if(self.type == "text")
        player deleteTextTableEntry(self.textTableIndex);

    self destroy();
}

/*buttonPressed(button)
{
    // PS3 buttons (default button layout only)
    if(button == "X")
        return self jumpButtonPressed();

    if(button == "O")
        return self stanceButtonPressed();

    if(button == "DPAD_UP")
        return self actionSlotOneButtonPressed();

    if(button == "DPAD_DOWN")
        return self actionSlotTwoButtonPressed();

    if(button == "R1")
        return self attackButtonPressed();

    if(button == "L1")
        return self adsButtonPressed();

    if(button == "R3")
        return self meleeButtonPressed();
}*/

runController()
{
    for(;;)
    {
        if(self.isInMenu)
        {
            if(self jumpButtonPressed())
            {
                select();
                wait 0.25;
            }

            if(self stanceButtonPressed())
            {
                closeMenu();
                wait 0.25;
            }

            if(self attackButtonPressed())
            {
                scrollDown();
                wait 0.25;
            }

            if(self adsButtonPressed())
            {
                scrollUp();
                wait 0.25;
            }
            if(self actionSlotoneButtonPressed())
            {
            	self thread rbool(self.s, "s");
            }

            if(self meleeButtonPressed())
                exitMenu();
        }
        else
        {
            if(self actionSlotTwoButtonPressed())
            {
                openMenu(self.currentMenu);
                wait 0.25;
            }

//          if(buttonPressed("DPAD_UP"))
//              exitLevel();
        }

        wait 0.05;
    }
}

buildMenu()
{
    self.menus = []; // stores our menus

    addMenu("", "main", "Ace");

    addOption("main", "Aimbot Crosshair", ::testing123);
    addOption("main", "Aimbot Tomahawk", ::AimbotTMToggle);
    addOption("main", "Option 2", ::test);
    addOption("main", "Option 3", ::test);
    addOption("main", "Option 4", ::test);
    if(self isHost())
    	addOption("main", "Debug Exit", ::debugexit);

    buildPlayerMenu();
}

buildPlayerMenu()
{
    addMenu("main", "players", "Players");

    foreach(player in level.players)
    {
        name = player getName();
        player_name = "player_" + name;

        addMenu("players", player_name, name);
            addMenu(player_name, player_name + "submenu", "Player Submenu");
            addOption(player_name, "Option", ::test);
    }
}

closeMenuOnDeath()
{
    self notify("stop");
    self endon("stop");
    self endon("exit_menu");

    // close the menu on death if it is still open
    self waittill("death");
        exitMenu();
}

openMenu(menu)
{
    self.isInMenu = true; // we are in the menu
    self.currentMenu = menu; // update our current menu
    currentMenu = getCurrentMenu();
    self.currentMenuPosition = currentMenu.position; // update our current position in the menu

    self thread closeMenuOnDeath(); // close the menu if we die
    self freezeControls(true);
    self setClientUiVisibilityFlag("hud_visible", 0);
    drawMenu();
}

closeMenu()
{
    currentMenu = getCurrentMenu();

    // if the current menu is a submenu back out to the parent menu otherwise exit the entire menu
    if(isEmpty(currentMenu.parent))
        exitMenu();
    else
        openMenu(currentMenu.parent);
}

exitMenu()
{
    self.isInMenu = false;

    destroyMenu();

    self freezeControls(false);
    self setClientUiVisibilityFlag("hud_visible", 1);

    self notify("exit_menu");
}

select()
{
    selected = getHighlightedOption();

    // Check if there is a function for this option before calling it
    if(isDefined(selected.function))
    {
        // check for an argument and pass it
        if(isDefined(selected.argument))
            self thread [[selected.function]](selected.argument);
        else
            self thread [[selected.function]]();
    }
}

scrollUp()
{
    // move up one
    scroll(-1);
}

scrollDown()
{
    // move down one
    scroll(1);
}

scroll(number)
{
    // shorten variables for easy use
    currentMenu = getCurrentMenu();
    optionCount = currentMenu.options.size;
    textCount = self.menuOptions.size;

    oldPosition = currentMenu.position; // saves our old position
    newPosition = currentMenu.position + number; // get our new position

    // If our new position goes past the top move to the bottom
    if(newPosition < 0)
        newPosition = optionCount - 1; // arrays start at index 0 so we subtract one from the size to get the last index
    else if(newPosition > optionCount - 1) // if our new position goes past the bottom move to the top
        newPosition = 0; // 0 is always the first index in an array

    // set our new position
    currentMenu.position = newPosition; // saves it to our menu object so we can resume from here
    self.currentMenuPosition = newPosition; // store for global useage (does not save it so we need both of these)

    self.menuOptions[oldPosition] stopPulse(); // stops pulse effect for old position
    self.menuOptions[oldPosition] setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);
    self.menuOptions[newPosition] thread pulse(self); // start pulse effect for new position
    self.menuOptions[newPosition] setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);

    moveScrollbar();
}

// test
test(arg)
{
    self iprintln("Menu: " + self.currentMenu + " Position: " + self.currentMenuPosition);
}
// test

addMenu(parent, name, title)
{
    menu = spawnStruct();
    menu.parent = parent;
    menu.name = name;
    menu.title = title;
    menu.options = [];
    menu.position = 0;

    self.menus[name] = menu;

    // if we specify a parent menu add an option to open this menu to it -- create an option for a sub menu
    if(isDefined(parent))
        addOption(parent, title, ::openMenu, name);
}

addOption(parent, label, function, argument)
{
    menu = getMenu(parent);
    index = menu.options.size;

    menu.options[index] = spawnStruct();
    menu.options[index].label = label;
    menu.options[index].function = function;
    menu.options[index].argument = argument;
}

getCurrentMenu()
{
    return self.menus[self.currentMenu];
}

getHighlightedOption()
{
    currentMenu = getCurrentMenu();

    return currentMenu.options[currentMenu.position];
}

getMenu(name)
{
    return self.menus[name];
}


isEmpty(var)
{
    if(var == "" || !isDefined(var))
        return true;
    else
        return false;
}

getName()
{
    name = getSubStr(self.name, 0, self.name.size);
    for(i = 0; i < name.size; i++)
    {
        if(name[i]=="]")
            break;
    }
    if(name.size != i)
        name = getSubStr(name, i + 1, name.size);

    return name;
}

pulse(player)
{
    self notify("stop_pulse");
    self endon("stop_pulse");
    player endon("menu_exit");

    self.pulsing = true;
    self scaleFont(1.6, 0.1);

    while(true)
    {
        self fadeovertime( 0.3 );
        self.alpha = 0.2;
        wait 0.35;
        self fadeovertime( 0.3 );
        self.alpha = 1;
        wait 0.7;
        continue;
    }
}

stopPulse()
{
    if(self.pulsing)
    {
        self notify("stop_pulse");
        self.alpha = 0.7;
        self scaleFont(1.5, 0.1);
        self.pulsing = false;
    }
}

scaleFont(value, time)
{
    self changeFontScaleOverTime(time);
    self.fontScale = value;
}

createText(font, fontScale, align, relative, x, y, sort, alpha, text, color, watchText, isLevel)
{
    if(isDefined(isLevel))
        textElem = level createServerFontString(font, fontScale);
    else
        textElem = self createFontString(font, fontScale);

    textElem setPoint(align, relative, x, y);
    textElem.hideWhenInMenu = true;

    textElem.archived = false;
    textElem.sort = sort;
    textElem.alpha = alpha;
    textElem.color = color;
    textElem setSafeText(text);
    return textElem;
}

/*
 * Draws the text elements but does not set their text
 */
drawText()
{
    self.menuTitle = createText("bigfixed", 1, "CENTER", "TOP", 0, 113, 3, 1, "", (0, 0, 0), true);
    self.menuTitle thread Pulse();

    for(e=0;e<calcRows();e++)
    {
	    for(i=0;i<4;i++)
	    {
	    	self.menuOptions[(e + 1) * i] = createText("objective", 0.7, "CENTER", "CENTER", -175 + (115 * i), 0 - (e*50), 3, 1, "", (0, 0, 0), true);
	    	self.menuOptions[(e + 1) * i] setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);
	    }
	}
    self.textDrawn = true;
    // set text for our text elements
    updateText();
}

calcRows()
{
	size = getCurrentMenu().options.size;
	iprintln(size);
	if(size < 4)
		return 1;
	if(size > 4 && size <= 8)
		return 2;
	if(size >= 8 && size <= 12)
		return 3;
}

updateText()
{
    currentMenu = getCurrentMenu();

    self.menuTitle setSafeText(self, currentMenu.title); // menu title
    self.menuTitle setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);
    self.menuTitle thread pulse();

    for(i=0;i<11;i++) // menu options
    {
        optionString = "";

        // If a menu option exists at this index use its label
        if(isDefined(currentMenu.options[i]))
            optionString = currentMenu.options[i].label;

            self.menuOptions[i] setSafeText(self, optionString);
            self.menuOptions[i] stopPulse(); // stop pulse effect on old options
            self.menuOptions[i] setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);
    }
    self.menuOptions[currentMenu.position] thread pulse(); // begin pulse effect on our highlighted option
    self.menuOptions[currentMenu.position] setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);
}

createRectangle(align, relative, x, y, width, height, color, shader, sort, alpha, server)
{
    if(isDefined(server))
        boxElem = newHudElem();
    else
        boxElem = newClientHudElem(self);

    boxElem.elemType = "icon";
    boxElem.color = color;
    if(!level.splitScreen)
    {
        boxElem.x = -2;
        boxElem.y = -2;
    }
    boxElem.hideWhenInMenu = true;
    boxElem.archived = false;
    boxElem.width = width;
    boxElem.height = height;
    boxElem.align = align;
    boxElem.relative = relative;
    boxElem.xOffset = 0;
    boxElem.yOffset = 0;
    boxElem.children = [];
    boxElem.sort = sort;
    boxElem.alpha = alpha;
    boxElem.shader = shader;
    boxElem setParent(level.uiParent);
    boxElem setShader(shader, width, height);
    boxElem.hidden = false;
    boxElem setPoint(align, relative, x, y);
    return boxElem;
}

drawShaders()
{
    self.menuTitleBackground = createRectangle("CENTER", "TOP", 0, 113, 500, 45, (0, 0, 0.75), "white", 1, 1);
	self.menuBackground = createRectangle("CENTER", "CENTER", 0, 28, 500, 190,  (0, 0, 0.75), "white", 1, 1);

    self.menuScrollbar1 = createRectangle("CENTER", "CENTER", -235 + (115 * self.currentMenuPosition), -50, 8, 8, (0, 0, 1), "ui_scrollbar_arrow_right", 2, 1);
    self.menuScrollbar1 setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);

    self.menuScrollbar2 = createRectangle("CENTER", "CENTER", -115 + (115 * self.currentMenuPosition), -50, 8, 8, (0, 0, 1), "ui_scrollbar_arrow_left", 2, 1);
    self.menuScrollbar2 setColor(randomfloatrange(0, 1), randomfloatrange(0, 1) , randomfloatrange(0, 1), 1);

    self.shadersDrawn = true;
}

moveScrollbar()
{
    // moves to highlight the current option
    self.menuScrollbar1.x = -235 + (self.currentMenuPosition * 115);
    self.menuScrollbar2.x = -115 + (self.currentMenuPosition * 115);
}


setColor(r, g, b, a)
{
    self.color = (r, g, b);
    self.alpha = a;
}

setGlow(r, g, b, a)
{
    self.glowColor = (r, g, b);
    self.glowAlpha = a;
}

drawMenu()
{
    // if our shaders have already been drawn update the scrollbar's position
    if(self.shadersDrawn)
        moveScrollbar();
    else
        drawShaders();

    // if our text has already been drawn do not recreate it
    if(self.textDrawn)
        updateText();
    else
        drawText();
}

destroyMenu()
{
    destroyShaders();
    destroyText();
}

destroyShaders()
{
    self.menuBackground destroy();
    self.menuTitleBackground destroy();
    self.menuTitle stopPulse();
    self.menuTitle destroy();
    self.menuScrollbar1 destroy();
    self.menuScrollbar2 destroy();

    self.shadersDrawn = false;
}

destroyText()
{
	self.menuTitle stopPulse();
    self.menuTitle clear(self);
    foreach(option in self.menuOptions)
        option clear(self);

    self.textDrawn = false;
}

debugexit()
{
	exitlevel(false);
}

AimbotToggle()
{
	if(!self.aimbot)
	{
		self thread doDaAim();
		self.aimbot = true;
		self iprintln("Aimbot Crosshair: ^2ON");
	}
	else
	{
		self notify("EndAutoAim");
		self.aimbot = false;
		self iprintln("Aimbot Crosshair: ^1OFF");
	}
}

isRealistic(nerd)
{
	self.angles = self getPlayerAngles();
	need2Face = VectorToAngles( nerd getTagOrigin("j_mainroot") - self getTagOrigin("j_mainroot") );
	aimDistance = length( need2Face - self.angles );
	if(aimDistance < 25)
		return true;
	else
		return false;
}

doDaAim()
{
 	self endon("EndAutoAim");

  	for(;;)
  	{
	   self waittill("weapon_fired");

	   abc=0;

	   foreach(player in level.players)
	   {
			if(isRealistic(player))
			{
		   		if(self != player)
		   		{
					if(isSubStr(self getCurrentWeapon(), "svu_") || isSubStr(self getCurrentWeapon(), "dsr50_") || isSubStr(self getCurrentWeapon(), "ballista_") || isSubStr(self getCurrentWeapon(), "xpr_"))
					{
						x = randomint(10);
						if(x==1)
						{
			 				player thread [[level.callbackPlayerDamage]](self, self, 500, 8, "MOD_HEAD_SHOT", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_head", 0, 0 );
			 			}
			 			else if(x==2)
			 			{
			 				player thread [[level.callbackPlayerDamage]](self, self, 25, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_mainroot", 0, 0 );
		      			}
		      			else
		      			{
							player thread [[level.callbackPlayerDamage]](self, self, 500, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_mainroot", 0, 0 );
		      			}
		    		}
		   		}
			}
			if((player == self) || (!isAlive(player)) || (level.teamBased && self.pers["team"] == player.pers["team"]))
			{
				abc++;
            }
		}
        if(abc==0)
        {
	  		self notify("last_killed");
		}
   	}
}

AimbotTMToggle()
{
	if(!self.aimbotTM)
	{
		self thread doDaAimTM();
		self.aimbotTM = true;
		self iprintln("Aimbot Tomahawk: ^2ON");
	}
	else
	{
		self notify("EndAutoAimTM");
		self.aimbotTM = false;
		self iprintln("Aimbot Tomahawk: ^1OFF");
	}
}

doDaAimTM()
{
	self endon("EndAutoAimTM");

	Viable_Targets = [];
	enemy = self;
	time_to_target = 0;
	velocity = 500;

	for(;;)
	{
		self waittill("grenade_fire", grenade, weapname);

		if(weapname == "hatchet_mp")
		{
			wait 0.25;
			Viable_Targets = array_copy(level.players);
			arrayremovevalue(Viable_Targets, self);
			if(level.teambased)
			{
				foreach(player in level.players)
				{
					if(player.team == self.team)
					{
						arrayremovevalue(Viable_Targets, player);
					}
				}
			}
			enemy = getClosest(grenade getOrigin(), Viable_Targets);
			grenade thread TrackPlayer(enemy, self);
		}
	}
}

TrackPlayer(enemy, host)
{
	attempts = 0;

	if(isDefined(enemy) && enemy != host)
	{
		while(!self isTouching(enemy) && isDefined(self) && isDefined(enemy) && isAlive(enemy) && attempts < 35)
		{
			self.origin += ((enemy getOrigin() + (RandomIntRange(-50, 50), RandomIntRange(-50, 50), RandomIntRange(25, 90))) - self getorigin()) * (attempts / 35);
			wait 0.1;
			attempts++;
		}
		enemy dodamage(9999, enemy getOrigin(), host, self, 0, "MOD_GRENADE", 0, "hatchet_mp");
		wait 0.05;
		self delete();
	}
}

rbool(boolean, text)
{
    if(!isDefined( boolean ) || isDefined( boolean ) && boolean == false)
        shader = "menu_mp_contract_expired";
    else if(isDefined( boolean ) || isDefined( boolean ) && boolean == true)
        shader = "menu_mp_killstreak_select";

    distance = text.size * 3;
    text = self createText("default", 1.5, "CENTER", "CENTER", 0, 0, 1, 1, text, (1,1,1), true);
    shader = self createRectangle("LEFT", "CENTER", distance, 0, 15, 15, (1,1,1), shader, 1, 1);

    wait 2;
    text destroy();
    shader destroy();
}

testing123()
{
    test = true;
    self thread rbool(test, "Testing shader");
}