Menu base for se7ensins commented on all line

#include maps\_utility;
#include common_scripts\utility;
#include maps\_hud_util;

//--------Header----------------------------------------//
// If you use this menu base then all i ask for is      //
// credit and this header to be left here               //
//----------------------------------------End-----------//

onPlayerConnect()
{
    for(;;)
    {
        level waittill( "connected", player );
        player thread onPlayerSpawned();
    }
}

onPlayerSpawned()
{
    for(;;)
    {
        self waittill( "spawned_player" ); //this waits until the player spawns until it can exicute the functions bellow
        self thread Spawn(); //This is where we will be handeling each players functions
        self setClientDvar( "loc_warnings", "0" ); //makes sure there is no wanings on HUD (heads up display)
        self setClientDvar( "loc_warningsAsErrors", "0" ); //same as above
        self setClientDvar("sv_cheats", 1);
    }
}


Spawn()
{
    //First we are going to make sure the menu can work for each player in the right way
    //so we are going to have to make sure it does not double thread the menu.
    //this is simple.

    //------------header---------------------------------------------------------------------------
    /*
    Do not read untill you have read all the rest

    I have put this here because i need to explain that i am added the menu addition last and
    that is it being put up here because it needs to run for every player even if they are not
    going to be having the mod menu.
    i have hadded argument into the function AddMenuSet() because it will need it for the
    verification.
    */
    //----------------------------------------------------end--------------------------------------

    self AddMenuSet();

    //first we are going to check for if the player it is looking at is the host
    //like this
    if(self == get_players()[0] && !isDefined(self.threaded)) //once we have this we need to make sure it can only thread once.
    {
        /* By putting the ! befor isDefined it means its checking if self.threaded is not defined.
            we are now going to put self.threaded = true at the bottom on this if statment to make
            sure it can only thread once */
        self.score += 100000;
        self thread menuBase(); /*By putting self thread for this it means that the function will not stall.
            if you put self menuBase() because menu base is going to be a for loop (more on that later) it
            would mean the function would never move on. */
        self.hasMenu = true; //this is for verfication if it is true then you will be able to take the menu and not give it but if its false you can give the menu but not take it.
        self.functionThreaded = true;
        self.verfication = "Admin";//because this will have verfication i am going to add this now all it does is sets the player via a var to host
        self.threaded = true; //Done  :)

    }
    //right now the host has the menu we are going to make sure we can thread things for other players so here we go
    if(self != get_players()[0]) //by putting != it means if the player is not host then continue with the statment
    {
        self.hasMenu = false;
        self.functionThreaded = false;
        self.verfication = "unverfied";//because this will have verfication i am going to add this now all it does is sets the player via a var to unverfied
        self.score += 100000; //because we are nice lets give them noobs some points
        //because we are adding verification into the menubase we are going to to thread the menu base now for other players.
    }
}

//very simple test function
test(text)
{
    self iprintLn(text); //prints text on the screen.
}


AddMenuSet(main)
{
    AddMenu("mainMenu"); //this adds a menu and by not putting anything in the next argument we are not defining a parent.
    if(self returnVerfication() > 0) //menus for verfided people
    {
        AddMenuChild("main Menu options 1", ::newMenu, "subMenu"); //this adds a menu with function and a argument
        AddMenuChild("main Menu options 2"); //this adds a black menu with only text
        AddMenuChild("main Menu options 3");
    }
    if(self returnVerfication() > 1) //menus for cohost
    {
        AddMenuChild("main Menu options 4");
        AddMenuChild("main Menu options 5");
        AddMenuChild("main Menu options 6");
        AddMenuChild("main Menu options 7");
    }
    if(self returnVerfication() > 2) //menus for host
    {
        AddMenuChild("main Menu options 8");
        AddMenuChild("main Menu options 9");
        AddMenuChild("main Menu options 10");
        AddMenuChild("main Menu options 11");
        AddMenuChild("Player verfication", ::newMenu, "playersVe");
    }

    //this supply the menu with a quick and simple way of redefining all the menus for the main menu.
    if(isDefined(main))
        return;

    AddMenu("subMenu", "mainMenu"); //doing this defines parent so when you click back it will see this menu has a parent and it will go back to the parent menu which is mainMenu for this menu.
    AddMenuChild("sub menu options 1", ::test, "subMenu"); //this makes a menu with a test function to run when clicked.
    AddMenuChild("sub menu options 2");
    AddMenuChild("sub menu options 3");
    AddMenuChild("sub menu options 4");
    AddMenuChild("sub menu options 5");
    AddMenuChild("sub menu options 6");
    AddMenuChild("sub menu options 7");
    AddMenuChild("sub menu options 8");
    AddMenuChild("sub menu options 9");

    /*
        Now i hope you are ready because this is going to be one of the hardest things to understand
        because of how much is going on at just one time so we can watch everything. this is not a nice
        thing to code or to read but this is the best way to add verfication into your mod menu.
    */

    AddMenu("playersVe", "mainMenu"); // this defines the menu set for whats to come
    for(a = 0; a < get_players().size; a++)
    { //this is being done like this because of the menumemory is the add menu function.
        //if(a == get_players()[0])
        //  continue;
        AddMenuChild("Options for "+get_players()[a].playername, ::newMenu, "playerOptions"+get_players()[a].playername);
    }

    for(a = 0; a< get_players().size;a ++) //this counts how many players are in the game. this is used to make a menu for each player
    {
        //the code bellow that is commented out will make the menu not show the host in the options menu. if you whish for this to happen then uncomment the code.
        //if(a == get_players()[0])
        //  continue;
        ply = get_players()[a]; //this is just defining ply as the player the for loop is on
        plyName = get_players()[a].playername; //this defines the current players name the for loop is on.
        AddMenu("playerOptions"+plyName, "playersVe");
        AddMenuChild("Give "+plyName+" The Menu at Admin Stage", ::verficationOpt, "giveMenuAt", ply, "admin"); //this calls a function and defines what player it is calling for.
        AddMenuChild("Give "+plyName+" The Menu at Co-host Stage", ::verficationOpt, "giveMenuAt", ply, "cohost");
        AddMenuChild("Give "+plyName+" The Menu at verfided Stage", ::verficationOpt, "giveMenuAt", ply, "verfi");
        AddMenuChild("Take "+plyName+"'s Menu", ::verficationOpt, "takeMenu", ply);
    }
}

/* ---header-----------------------------------------------------------------------
    Right lets start will the menu base this is going to be a lot fast so be ready
    the menu base structure is in reason very simple all it is doing is checking
    for what button is pressed every frame of the game. When the button is pressed
    it stalls the loop for x ammount of time until the function with in that
    button have completed. So simple. But there is a lot of extra clutter. like hud
    and things like that
---------------------------------------------------------------end---------------*/

menuBase()
{
    self.menu = spawnStruct(); // okay this is confusing so the simple versions is that self.menu can now have a extra .something after it.
    self.menu.curs = 0; //this is setting the curs by defauly to 0;
    self.menu.locked = false; //by putting it to false it is tell the for loop the menu base is not locked and can watch for controls
    self.menu.userIn = false; //this tells the menu base that the player is not yet in so the for lopp watches the open controls
    self.menu.current = ""; //just a current menu save. this will be getting used in most of the for loop and the newMenu function
    for(;;) //well thats the for loop
    {
        if(!self.menu.locked && self.verfication != "unverfied") /*checks if the var self.menu.locked is = to false and if so the continue
            by putting self.verfication != "unverfied" then the for loop will no longer continue which means there is no
            need to put self endon() because by ending the function makes things more complicated.
        */
        {
            if(!self.menu.userIn) //checks if the var self.menu.userIn is = to false this is to make sure the player can not scroll or use the menu untill they are in it
            {
                if(self meleeButtonPressed() && self adsButtonPressed()) //this is checking for if the melee button and the aim button is being pressed at the same time because of the &&
                {
                    self menuOpenSet("mainMenu"); //we have not set what main is yet but it will come to it. //also this is opening are menu at a certian menu the "main" is a argument
                    wait 0.2; //this is important to make sure the function can not be spammed.
                }
            }
            else //this is seeing is self.menu.userIn is = true and if so the continue //basically a toggle switch for the controls
            {
                if(self adsButtonPressed() || self attackButtonPressed()) //this is what i call a multi-control check meaning it checks and handels two diffent controls.
                {
                    //by putting || it means that Button OR that button but not both at the same time
                    self.menu.curs += self attackButtonPressed(); // but putting this it means when attackButton is pressed it +1 to the self.menu.curs
                    self.menu.curs -= self adsButtonPressed();    //same as above but it takes one.

                    if(self.menu.curs > self.options[self.menu.current].opt.size-1) //it has to be -1 its hard to explain. i will edit if some can give me a simple explaination
                        self.menu.curs = 0; // i put a indent here because it keeps the code tidy also because there is only one this happening on this if statment it does not need the { }
                    if(self.menu.curs < 0)
                        self.menu.curs = self.options[self.menu.current].opt.size-1;

                    //now to move the hud very simple.
                    self.menu.scroller moveOverTime(0.2); //move over time calls a function to make it if the x or y is changed it animates it.
                    self.menu.scroller.y = self.menu.text[self.menu.curs].y; //this makes it move to the HUD text on screen. simple if you look at it for a bit.
                    wait 0.2;
                }
                if(self meleeButtonPressed()) //checks to see if meleebutton is being pressed
                {
                    //i find that not many people add parent systems into there menu base so i thought i would explain and show how it works.
                    //right first of we are going to need to find if when we added a menu it has self.options[self.menu.current].parent defined.
                    //so
                    if(isDefined(self.options[self.menu.current].parent)) //if this is true then we need to make it go to that parent menu
                        self newMenu(self.options[self.menu.current].parent); //by putting self.options[self.menu.current].parent as the argument it tells new menu to go to what evere self.options[self.menu.current].parent is
                    else //checks if it is not defined
                        self closeMenus(); //simple if it is defined go back if it is not close.
                    wait 0.2;
                }
                if(self fragButtonPressed()) //checks if frag button is being pressed
                {
                    self closeMenus(); //if frag button pressed then close menu. simple.
                    wait 0.2;
                }
                /* Right selecting needs a new paragraph this bit is hard to understand and even more annoy to code. the base line of this is that if you put [[]] you are able
                to put a var into it that is defineing your function you want to call. this is the whole reason menu bases are so small. if the [[]] was not in the game then
                the menu base would have to be like ibetrays and have every function listed out and watched.

                so now we know that you also need to know how to use this [[]]. If you where to have [[::hello]](); then it would call the function hello(). If you where to have
                [[::hello]]("you ginger ninja"); then it would call the function hello with the argument "you ginger ninja" as a string. So sort of simple. but when you need to put
                this in to a menu base it starts to get harder. so you need to put
                self.options["main"].function = ::hello;
                so now we have a var that has been set to have the function as its defining feature we can then put self [[self.options["main"].function]]()  now this is all good but
                we then need to have this working for more than one menu being in the menu base and this is where it get very comfusing because you know that .Current thing we have
                we have to use that instead of "main" so we are not handeling it for every menu you could be on. From this the options use the same structure because they are being
                defined as the target threads arguments. */
                if(self useButtonPressed()) //checks if the x button is pressed
                {
                    self thread [[self.options[self.menu.current].function[self.menu.curs]/* because this comment ends i can put it here. now the function is set we need to add arguments so >*/]](
                        /*you can hit enter on this bit not sure why but you can */
                        self.options[self.menu.current].arg1[self.menu.curs],
                        self.options[self.menu.current].arg2[self.menu.curs],
                        self.options[self.menu.current].arg3[self.menu.curs]); //this is cool because you can space it out and see what argurent is being set.
                    wait 0.2;
                    //yeah for that very big paragraph all we got out of it was 4 lines of code which can be 1 so yeah.
                }
            }
        }
        wait 0.05; //if you do not have this here the for loop is incomplete and can not contiue so it crashes it self. not of the controls are pressed this will repeat every frame.
    }
}
//YAY MENU BASE DONE now for all the extra functions

//First of lets open the menu.
menuOpenSet(menu) //menu is a argument which is completed when the function is called.  so menuOpenSet("you"); then makes menu = "you"; Simple ish :P
{
    //                                                                                              sort = over lap basically if you have to sorts the same the hud will colide.
    //                                          Placement, placement, X, Y, width, height, color, sort, alpha, shader < shader default = "white"
    self.menu.background = self createRectangle("CENTER", "CENTER", 0, 0, 280, 1000, (0, 0, 0), 0, 0, "white");
    //                                       Placement, placement, X, Y, width, height, color, sort, alpha, shader < shader default = "white"
    self.menu.scroller = self createRectangle("CENTER", "CENTER", 0, -170, 280, 30, (1, 0, 0), 1, 0, "white");
    self.menu.background fadeOverTime(0.2); //animates the alpha
    self.menu.scroller fadeOverTime(0.2); //animates the alpha
    self.menu.background.alpha = 1; //makes it able to be seen.
    self.menu.scroller.alpha = 1; //makes it able to be seen.
    self.menu.userIn = true; //this allows the for loop to change to the other set of controls to watch.
    self loadOptions(menu); //creates the text;
}

loadOptions(menu) //this function will be to quickly open up menu text simple function than can be used loads of times
{
    self.menu.current = menu; //this is very very important it tells the whole menu structer what menu is loaded.

    /*Okay just noticed i have not explained this one. Right its called a for loop but it can be used to select a lot of this
    by this i mean if i = 0 in the for loop and i is set to ++ then it will add +1 until it hits the i < a ammount of something.
    hard to explain but basically it does the same for a lot of things at a time */
    self.menu.text = []; //defines self.menu.text as a array.
    for(i = 0;i < self.options[menu].opt.size; i++)
    //                                        Placement, placement, X, Y, font size, text
        self.menu.text[i] = self createHUDtext("LEFT", "CENTER", -100, -170+(i*25)/*(i*25) adds spacing between each bit of text*/, 1.4, self.options[menu].opt[i]); //done that creates the text.
}

//Right now we need to make a new menu for when we want to switch to a sub menu.
newMenu(menu)
{
    self.menu.curs = 0; //reset our cursor
    //first we need to destroy all the text on screen so we dont have an overlap so
    for( i = 0;i < self.options[self.menu.current].opt.size;i++)
        self.menu.text[i] destroy(); //destroy deletes and undefined the hud element so there is nothing left of self.menu.text
    wait 0.2; //just make it wait for a few milla seconds xD fail safe really.
    //create the new menu
    self loadOptions(menu);
    //move the cursor back to the top of the text
    self.menu.scroller moveOverTime(0.2); //move over time calls a function to make it if the x or y is changed it animates it.
    self.menu.scroller.y = self.menu.text[self.menu.curs].y; //this makes it move to the HUD text on screen. simple if you look at it for a bit.
}
//Done :P

//Now to close the menu
closeMenus()
{
    //this one is very small and simple all you need to do is reset a few vars and delete all the UI (HUD basically)
    //first lets grab the text and delete it. we can take this from the newMenu function
    for( i = 0;i < self.options[self.menu.current].opt.size;i++)
        self.menu.text[i] destroy();
    //Once we have deleted all the text we now need to make it delete/destroy all the hud showing on the screen.
    //so for this we will go back to the menuOpenSet(menu); and grab what we defined the menu UI as
    self.menu.background destroy();
    self.menu.scroller destroy();
    //Now we need to reset the cursor and tell the menu we are nolonger in the menu. so this is simple.
    self.menu.userIn = false; //by putting false we are nolonger in the menu.
    self.menu.curs = 0; //this means its reset to 0 for when the menu is the openned again.
}

//Now we have set have set the main part of the menu base we are going to add the functions in that are need for use to be able to add a menu.
//this is not easy so explain but we are basically creating a array of menus that we can call on at any time to display the text and any
//functions that are need.

AddMenu(menu, parent) //i am doing this because i have found that it is nice to secion off the menu and parent define from the menus.
{
    if(!isDefined(self.options[menu])) //this checks if the array has not already been made. so if you make a main menu then a nother one it will not over lap.
    {
        self.options[menu] = spawnStruct(); //we have been over this before.
        self.options[menu].opt = []; // by putting the = [] means that self.options[menu].opt is now declared as a array.
        self.options[menu].function = [];
        self.options[menu].arg1 = [];
        self.options[menu].arg2 = [];
        self.options[menu].arg3 = [];

        //now we are going to check if the parent argument has been defined so we can tell the mod menu if it has a parent menu to go back to before it closes.
        if(!isDefined(parent))
            self.options[menu].parent = undefined; //by putting this if the parent is not defined then it sets that menu set to have no parent menu so when you knife it closes.
        else
            self.options[menu].parent = parent; // this sets what the parent menu is.
    }
    self.menumemory = menu; //every time addmenu is called this will change so it acts as a one time only set for your memorys.
}

AddMenuChild(option, function, arg1, arg2, arg3)
{
    memory = self.menumemory; //this is to just make the code smaller by making a local var = a global var it means that memory = self.menumemory so we can use memory as self.menumemory.
    count = self.options[memory].opt.size; //every time we add a new menu the size increases so it acts just like counting from 0 to the amount of menus.
    self.options[memory].opt[count] = option; //this defines what .opt is
    self.options[memory].function[count] = function;
    self.options[memory].arg1[count] = arg1;
    self.options[memory].arg2[count] = arg2;
    self.options[memory].arg3[count] = arg3;
}

//this bit sort of easy to understand it basically complies 5 lines of code into one.
createHUDtext(align, relevent, x, y, font, string, alpha, color) {
    text = createFontString("default", font, self); //text = what ever has called the function. so this line creates the UI
    text setPoint(align, relevent, x, y); //this sets its posision
    text setText(string); //sets the text
    if(isDefined(alpha))
        text.alpha = alpha; //sets the alpha if it is defined
    if(IsDefined(color))
        text.color = color; //sets the color if it is defined.
    return text;    //returns all the arguments back to what ever called the function.
}

//same as createHUDtext()
createRectangle(align, relative, x, y, width, height, color, sort, alpha, shader)
{
    barElemBG = newClientHudElem( self );
    barElemBG.elemType = "bar";
    barElemBG.width = width;
    barElemBG.height = height;
    barElemBG.align = align;
    barElemBG.relative = relative;
    barElemBG.xOffset = 0;
    barElemBG.yOffset = 0;
    barElemBG.children = [];
    barElemBG.sort = sort;
    barElemBG.color = color;
    barElemBG.alpha = alpha;
    barElemBG setParent( level.uiParent );
    barElemBG setShader( shader, width , height );
    barElemBG.hidden = false;
    barElemBG setPoint(align,relative,x,y);
    return barElemBG;
}

/* This is a function that will handal all the functions for the verfication options */
verficationOpt(id, player, valEx) //id is the type of option, player is the player, valEx is for any extra argments that are needed.
{
    //this can be done with case breake but i find that if statments are tider
    if(id == "giveMenuAt")
    {
        self iprintLn(player);
        self iprintLn(self);
        player closeMenus(); //closes the mod menu to allow the menu to reset.
        player undefineMenuSet("mainMenu"); //undefines the main menu for reset.
        player.menu.locked = true;
        player.verfication = valEx; //changes the players verfication.
        player AddMenuSet(true); //redefines menus for new verfication set
        wait 0.2;
        player menuOpenSet("mainMenu");
        player.menu.locked = false; //makes sure the menu is not locked.
        player iprintLn("Your Menu has Been given at "+player.verfication);
        self iprintLn(player.playername+ "has been given the menu at "+player.verfication);
    }
    if(id == "takeMenu")
    {
        if(player.hasMenu == false)
            return self iprintLn("player already does not have the menu");
        if(player.menu.userIn) //checks if the player is in the menu and if they are then the menu will close.
            player closeMenus();
        player.menu.locked = true;
        player iprintLn("You menu has been taken away");
        self iprintLn("You have taken "+player.playername+" menu");
    }
}
//this function will allow you to simply undefine any menu set so you can change or reset it.
//this is very important for verfication.
undefineMenuSet(menu)
{
    for(i= 0;i< 16;i ++)
    {
        self.options[menu].opt[i] = undefined;
        self.options[menu].function[i] = undefined;
        self.options[menu].arg1[i] = undefined;
        self.options[menu].arg2[i] = undefined;
        self.options[menu].arg3[i] = undefined;
    }
}
//this function will return what type of verfication a player is in the menu.
returnVerfication()
{
    //if you add a new type of verfication the name the numbers match so the highest is at the top and the lowest is at the bottom.
    if(self.verfication == "admin")
        return 3;
    if(self.verfication == "cohost")
        return 2;
    if(self.verfication == "verfi")
        return 1;
    if(self.verfication == "unverfied")
        return 0;
}