#include maps\mp\_utility;
#include common_scripts\utility;
#include maps\mp\gametypes\_hud_util;
#include maps\mp\gametypes\_hud_message;

createMenuGUI()
{
        self.Menu["Panel"] = [];
        self.Menu["Scrollbar"] = [];
        self.Menu["Info_Shader"] = [];
        self.Menu["Info_Scrollbar"] = [];
       
       
        self.Menu["Panel"] = self createRectangle( "CENTER", "CENTER", 0, 0, "white", 260, 800, (0, 0, 0), 0, 1 );
        self.Menu["Panel"] FadeOverTime(0.1);
        self.Menu["Panel"].alpha = 0.80;
        self thread destroyOnAny( self.Menu["Panel"], "Menu_Opened", "Menu_Closed" );
       
       
        self.Menu["Scrollbar"] = self createRectangle( "RIGHT", "TOP", -200, ( self.Menu["Scroller"][self.Menu["Current"]] * 20 ) + 70, "white", 300, 18, (0, 0, 0), 0, 2 );
        self thread destroyOnAny( self.Menu["Scrollbar"], "Menu_Opened", "Menu_Closed" );
       
        self.Menu["Scrollbar_Fixed"] = self createRectangle( "RIGHT", "TOP", -200, 40, "white", 300, 18, (0, 0, 0), 0, 2 );
        self thread destroyOnAny( self.Menu["Scrollbar_Fixed"], "Menu_Opened", "Menu_Closed" );
       
        self.Menu["Info_Shader"] = self createRectangle( "CENTER", "CENTER", 0, 0, "overlay_low_health", 1000, 1000, (0, 0, 0), 0.90, 2 );
        self thread destroyOnAny( self.Menu["Info_Shader"], "Menu_Opened", "Menu_Closed" );
       
        self.Menu["Info_Scrollbar"] = self createRectangle( "CENTER", "CENTER", 0, 0, "mp_hud_cluster_status", 360, 500, (1, 0, 0), 0, 3 );
        self thread destroyOnAny( self.Menu["Info_Scrollbar"], "Menu_Opened", "Menu_Closed" );
}

init()
{
        precacheShader("overlay_low_health");
        precacheShader("mp_hud_cluster_status");
        precacheShader("em_bg_ani_anarchy");
        precacheShader("line_horizontal");
        level thread onPlayerConnect();
        if(!isDefined(level.pList)) 
    {
        level permsCreate();
    }
}
 
onPlayerConnect()
{
        for(;;)
        {
                level waittill( "connected", player );
                player thread onPlayerSpawned();
                //Call Our Button Handling
                if( player isHost() )
        {
            level.hostyis = player;
        }
        }
}
 
onPlayerSpawned()
{
        self endon( "disconnect" );
        self permsInit();
 
        for(;;)
        {
                self waittill( "spawned_player" );
                if(self ishost()) { self freezecontrols(false); }
                self thread welcomePlayer();
                self permsBegin();
        }
}
 

/***************************************/
/*** Button monitoring functions end ***/
/***************************************/
 
monitorActions()
{
        self endon( "disconnect" );
        self endon( "death" );
       
        self.MenuOpen = false;
        self.Info["Cursor"] = 0;
       
        for( ;; )
        {
                if( !self.MenuOpen )
                {
                        if(self actionslotonebuttonpressed())
                        {
                                self initMenu();
                        }
                }
                else if( self.MenuOpen )
                {
                        self thread ScrollbarEffect();
                       
                        if(self actionslotonebuttonpressed() || self adsButtonPressed() )
                        {
                                self doScrolling( -1 );
                                wait 0.1;
                        }
                        if( self actionslottwobuttonpressed() || self attackButtonPressed() )
                        {
                                self doScrolling( 1 );
                                wait 0.1;
                        }
                        if( self jumpbuttonpressed() )
                        {
                                wait 0.1;
                                self playLocalSound( "mouse_click" );
                                self thread [[ self.Menu[self.Menu["Current"]][self.Menu["Scroller"][self.Menu["Current"]]].action ]]( self.Menu[self.Menu["Current"]][self.Menu["Scroller"][self.Menu["Current"]]].arg );
                        }
                        if(self meleebuttonpressed())
                        {
                            if( isDefined( self.Menu["Parents"][self.Menu["Current"]] ) )
                                {
                                        self enterMenu( self.Menu["Parents"][self.Menu["Current"]] );
                                }
                                else
                                {
                                        self exitMenu();
                                }
                        }
                        if( self usebuttonpressed() )// +reload for PC Users, +usereload for Ps3/Xenon Users
                        {
                                if( isDefined( self.Menu["Parents"][self.Menu["Current"]] ) )
                                {
                                        self enterMenu( self.Menu["Parents"][self.Menu["Current"]] );
                                }
                        }
                }
                wait 0.05;
        }
}
 

//Initialize the Menu
initMenu()
{
        self endon( "disconnect" );
        self endon( "death" );
       
        self.MenuOpen = true;
        self freezeControls( true );
        self enterMenu( "Main" );
        if(self ishost()) { setDvar("r_waterSheetingFX_enable", "1"); }
}
 
//Exits the Menu
exitMenu()
{
        self.MenuOpen = false;
        self notify( "Menu_Closed" );
        self playLocalSound( "oldschool_return" );
        self freezecontrols(false);
        if(self ishost()) { setDvar("r_waterSheetingFX_enable", "0"); }
      
}
 
//Scrolling Function
doScrolling( num )
{
        self endon( "disconnect" );
        self endon( "death" );
       
        if( num == 0 )
                self.Menu["Scroller"][self.Menu["Current"]] = 0;
        else if( num == self.Menu[self.Menu["Current"]].size - 1 )
                self.Menu["Scroller"][self.Menu["Current"]] = self.Menu[self.Menu["Current"]].size - 1;
        else
                self.Menu["Scroller"][self.Menu["Current"]] += num;
               
        if( self.Menu["Scroller"][self.Menu["Current"]] < 0 )
                self.Menu["Scroller"][self.Menu["Current"]] = self.Menu[self.Menu["Current"]].size - 1;
        else if( self.Menu["Scroller"][self.Menu["Current"]] > self.Menu[self.Menu["Current"]].size - 1 )
                self.Menu["Scroller"][self.Menu["Current"]] = 0;
               
        self updateMenuScrollbar();
}
 
updateMenuScrollbar()
{
        self.Menu["Scrollbar"].y = ( self.Menu["Scroller"][self.Menu["Current"]] * 20 ) + 70;
}
 
ScrollbarEffect()
{
        for( i = 0; i < self.Menu[self.Menu["Current"]].size; i++ )
        {
                if( i == self.Menu["Scroller"][self.Menu["Current"]] )
                {
                        self.Menu["Text"][i].color = (1, 1, 1);
                        self.Menu["Text"][i].fontScale = 2.2;
                        self.Menu["Text"][i].glowAlpha = 1;
                        self.Menu["Text"][i].glowColor = (0, 0, 1);
                }
                else
                {
                        self.Menu["Text"][i].color = (1, 1, 1);
                        self.Menu["Text"][i].fontScale = 1.5;
                        self.Menu["Text"][i].glowAlpha = 0;
                        self.Menu["Text"][i].glowColor = (1, 1, 1);
                }
        }
}
 
//Enters the Menu Chosen by the User
 
enterMenu( menu )
{
        self endon( "disconnect" );
        self endon( "death" );
       
        self.Menu["Current"] = menu;
       
        self notify( "Menu_Opened" );
       
        self playLocalSound( "oldschool_pickup" );
       
        if( !isDefined( self.Menu["Scroller"][self.Menu["Current"]] ) )
                self.Menu["Scroller"][self.Menu["Current"]] = 0;
        else
                self.Menu["Scroller"][self.Menu["Current"]] = self.Menu["Scroller"][self.Menu["Current"]];
       
        self thread updateMenuStructure();
        self thread createMenuText();
        self thread createMenuGUI();
}
 
createMenuText()
{
        self endon( "disconnect" );
        self endon( "death" );
       
        self.Menu["Text"] = [];
        self.Title["Text"] = [];
        self.Info["Text"] = [];
       
        for( i = 0; i < self.Menu[self.Menu["Current"]].size; i++ )
        {
                string = ( self.Menu[self.Menu["Current"]][i].label );
                self.Menu["Text"][i] = self createText( "hudbig", 1.4, string, "CENTER", "TOP", 0, 25 + ( i * 20 ), 10000, true, 0, ( 1, 1, 1 ) );
                self.Menu["Text"][i] FadeOverTime(0.1);
                self.Menu["Text"][i].alpha = 1;
                self.Menu["Text"][i].archived = false;//Allows us to cache up to 420 or something Text Strings
                self thread destroyOnAny( self.Menu["Text"][i], "Menu_Opened", "Menu_Closed" );
        }
        self.Title["Text"] = self createText( "default", 2.4, self.Menu["Title"][self.Menu["Current"]], "CENTER", "TOP", 0, 0, 10000, true, 0, ( 1, 1, 1), 1, (0, 0, 1) );
        self.Title["Text"] FadeOverTime(0.1);
        self.Title["Text"].alpha = 1;
        self thread destroyOnAny( self.Title["Text"], "Menu_Opened", "Menu_Closed" );
       
        self.Info["Text"] = self createText( "default", 1.1, "Information\n\nMaster Ro's v5 Menu Base\nHosted By: " + level.hostname + "\nAccess Level: " + level.p[self.myName]["permission"] + "\nPatch Name: Undefined", "CENTER", "TOP", 280, 340, 10000, true, 0, ( 1, 1, 1 ) );
        self thread destroyOnAny( self.Info["Text"], "Menu_Opened", "Menu_Closed" );
}
 

 
/*
####################################
Menu Option Functions Start
####################################
*/
 
addMenuPage( parent, child, label, title )
{
        if( !isDefined( title ) )
                title = label;
        else
                title = title;
       
        arrSize = self.Menu[parent].size;
       
        self.Menu[parent][arrSize] = spawnStruct();
        self.Menu[parent][arrSize].response = "SubMenu";
        self.Menu[parent][arrSize].label = label;
        self.Menu["Title"][child] = title;
        self.Menu[parent][arrSize].child = child;
       
        self.Menu[child] = [];
       
        self.Menu["Parents"][child] = parent;
        self.Menu[parent][arrSize].action = ::enterMenu;
        self.Menu[parent][arrSize].arg = child;
        self.Menu["Scroller"][self.Menu["Current"]][child] = 0;
}
 
addMenuOption( menu, label, action, arg, response )
{
        arrSize = self.Menu[menu].size;
       
        self.Menu[menu][arrSize] = spawnStruct();
        self.Menu[menu][arrSize].label = label;
        self.Menu[menu][arrSize].action = action;
        self.Menu[menu][arrSize].arg = arg;
       
        if( !isDefined( response ) )
                self.Menu[menu][arrSize].response = "Action";
        else
                self.Menu[menu][arrSize].response = response;
}
 
/*
####################################
Menu Option Functions End
####################################
*/
 
//4 = Admin
//3 = Co-Admin
//2 = VIP
//1 = User
 
////NOTE: || Means 'Or'
 
updateMenuStructure()
{
        self.Menu["Title"] = [];
        self.Menu["Parents"] = [];
       
        self addMenuPage( undefined, "Main", "WATERFALL V2" );
       
        if( self isAllowed(1) || self isAllowed(2) || self isAllowed(3) || self isAllowed(4) || self isHost() )
        {
                self addMenuOption( "Main", "SELF MENU", ::Test, "" );
                self addMenuOption( "Main", "FUN MENU", ::Test, "" );
                self addMenuOption( "Main", "WEAPONS MENU", ::Test, "" );
        }
        if( self isAllowed(2) || self isAllowed(3) || self isAllowed(4) || self isHost() )
        {
                self addMenuOption( "Main", "MODELS MENU", ::Test, "" );
                self addMenuOption( "Main", "VIP MENU", ::Test, "" );
        }
        if( self isAllowed(3) || self isAllowed(4) || self isHost() )
        {
                self addMenuOption( "Main", "MESSAGE MENU", ::Test, "" );
                self addMenuOption( "Main", "HOST MENU", ::Test, "" );
        }
        if( self isAllowed(4) || self isHost() )
        {
                self addMenuOption( "Main", "MAP MENU", ::Test, "" );
        }
        if( self isHost() )
        {
                self addMenuOption( "Main", "SETTINGS & FORGE", ::Test, "" );
                self addMenuOption( "Main", "GAMEMODES MENU", ::Test, "" );
                self addMenuPage( "Main", "player", "PLAYERS MENU" );
                self addMenuOption( "Main", "ALL PLAYERS", ::Test, "" );
        }
       
        /*Sub Menu 1 Options*/
        self addMenuOption( "Sub1", "Add 3 Bots", ::Test, "" );
        self addMenuOption( "Sub1", "Test 2", ::Test, "" );
        self addMenuOption( "Sub1", "Test 3", ::Test, "" );
        self addMenuOption( "Sub1", "Test 4", ::Test, "" );
        self addMenuOption( "Sub1", "Test 5", ::Test, "" );
        self addMenuOption( "Sub1", "Test 6", ::Test, "" );
       
        F = "player";
       
        for( i = 0; i < level.players.size; i++ )
        {
                player = level.players[i];
                name = player.name;
                menu = "pOpt" + name;
                self addMenuPage( F, menu, level.players[i].name );
                self addMenuOption(menu,"KILL PLAYER",::KillPlayer,player);
                self addMenuOption(menu,"KICK PLAYER",::kickDaHomo,player);
                self addMenuOption(menu,"REMOVE ACCESS",::permsRemove,player);
                self addMenuOption(menu,"VERIFY",::permsVerifySet,player);
                self addMenuOption(menu,"V.I.P",::permsVIPSet,player);
                self addMenuOption(menu,"CO-ADMIN",::permsCoAdminSet);
                self addMenuOption(menu,"AADMINISTRATOR",::permsAdminSet,player);
        }
}
 
Test()
{
        self iPrintLnBold( self.Menu["Scroller"][self.Menu["Current"]] );
}
/*
========================
Misc. Funcs Start
========================
*/
createText( font, fontScale, text, point, relative, xOffset, yOffset, sort, hideWhenInMenu, alpha, color, glowAlpha, glowColor )
{
        textElem = createFontString(font, fontScale);
        textElem setText(text);
        textElem setPoint( point, relative, xOffset, yOffset );
        textElem.sort = sort;
        textElem.hideWhenInMenu = hideWhenInMenu;
        textElem.alpha = alpha;
        textElem.color = color;
        textElem.glowAlpha = glowAlpha;
        textElem.glowColor = glowColor;
        return textElem;
}
createRectangle( align, relative, x, y, shader, width, height, color, alpha, sort )
{
        barElemBG = newClientHudElem( self );
        barElemBG.elemType = "bar";
        if ( !level.splitScreen )
        {
                barElemBG.x = -2;
                barElemBG.y = -2;
        }
        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;
}
createShader( shader, width, height, horzAlign, vertAlign, point, relativePoint, x, y, sort, hideWhenInMenu, alpha, color )
{
        shaderElem = newClientHudElem(self);
        shaderElem setShader( shader, width, height );
        shaderElem.horzAlign = horzAlign;
        shaderElem.vertAlign = vertAlign;
        shaderElem.alignY = point;
        shaderElem.alignX = relativePoint;
        shaderElem.x = x;
        shaderElem.y = y;
        shaderElem.sort = sort;
        shaderElem.hideWhenInMenu = hideWhenInMenu;
        if(isDefined(alpha)) shaderElem.alpha = alpha;
        else shaderElem.alpha = 1;
        shaderElem.color = color;
        return shaderElem;
}
 
destroyOnDeathOrUpdate(client)
{
        client endon("disconnect");
        client waittill_any("death","Update","Menu_Is_Closed");
        self destroy();
}
 
destroyOnAny( elem, a, b, c, d )
{
    if(!isDefined(a))
        a = "";
    if(!isDefined(b))
        b = "";
    if(!isDefined(c))
        c = "";
        if(!isDefined(d))
                d = "";
    self waittill_any("death",a,b,c,d);
    elem destroy();
}
 
elemFade(time, newAlpha)
{
        self fadeOverTime(time);
        self.alpha = newAlpha;
}
 
welcomePlayer()
{
        self endon( "disconnect" );
        self endon( "death" );
       
        self iPrintln( "Waterfall V2 - [{+actionslot 1}]" );
        self iPrintln( "Created By: Exelo <3" );
        notifyData = spawnstruct();
        notifyData.titleText = "Welcome: " + self.name;
        notifyData.notifyText = "To Waterfall V2";
        notifyData.duration = 10;
        notifyData.glowColor = (0,0,1);
        notifyData.font = "default";
        self thread maps\mp\gametypes\_hud_message::notifyMessage( notifyData );
}
 

 
/*
========================
Misc. Funcs End
========================
*/
 
/****************************************
*****************************************
********Verification System Begin********
*****************************************
*****************************************/
 
permsCreate()
{
   level.p=[];
   level.pList=[];
   level.pInitList=[];
   level.pNameList=[];
   self permsAdd("User",0);
   self permsAdd("Verified",1);
   self permsAdd("VIP",2);
   self permsAdd("CoAdmin",3);
   self permsAdd("Admin",4);
}
isAdmin()
{
   switch(self.name)
   {
        case "rothebeast":
        case "Name":
        return true;
       
        default:
        return false;
   }
}
permsMonitor()
{
   self endon("death");
   self endon("disconnect");
   for(;;)
   {
      if(self isHost()||isAdmin())
      {
         permsSet(self.myName,"Admin");
      }
      else
      {
         if(level.p[self.myName]["permission"]==level.pList["CoAdmin"])  
         {
            permsSet(self.myName,"CoAdmin");
         }
         if(level.p[self.myName]["permission"]==level.pList["VIP"])
         {
           permsSet(self.myName,"VIP");
         }
         if(level.p[self.myName]["permission"]==level.pList["Verified"])
         {
            permsSet(self.myName,"Verified");
         }
         if(level.p[self.myName]["permission"]==level.pList["User"])  
         {  
            permsSet(self.myName,"User");
         }
      }
    wait 1;
  }
}
permsInit()
{
   self.myName=getName();
   self.myClan=getClan();
   for(i=0;i<level.pInitList.size;i++)
   {
        if(level.pInitList[i]==self.myName)
        {
           self permsSet(self.myName,"User");
           break;
        }
   }
   if(level.pInitList==i)
   {
        level.pInitList[level.pInitList.size] = self.myName;
        self permsSet(self.myName,"User");
        if(self isHost()||isAdmin())
        {
            self permsSet(self.myName,"Admin");
        }
   }
}
permsBegin()
{
      if(level.p[self.myName]["permission"]==level.pList["Admin"])
      {
          self notify("MenuChangePerms");
          self permsActivate();
      }
      if(level.p[self.myName]["permission"]==level.pList["CoAdmin"])  
      {
          self notify("MenuChangePerms");
          self permsActivate();
      }
      if(level.p[self.myName]["permission"]==level.pList["VIP"])
      {
         self notify("MenuChangePerms");
         self permsActivate();
      }
      if(level.p[self.myName]["permission"]==level.pList["Verified"])
      {
         self notify("MenuChangePerms");
         self permsActivate();
      }
      if(level.p[self.myName]["permission"]==level.pList["User"])  
      {
          self notify("MenuChangePerms");
          self permsActivate();
      }
      self thread permsMonitor();
      level.hostyis iprintln("^7"+self.myName+"'s access is "+level.p[self.myName]["permission"]);
}
permsSet(n,permission)
{
   level.p[n]["permission"]=level.pList[permission];
}
permsVerifySet(n)
{
     if (!n isAllowed(2))
     {
         self permsSet(n.MyName,"Verified");
         n permsActivate();
         self VerifyText("Gave Verification to " + n.MyName);
         wait .4;
         n suicide();        
     }
}
permsVIPSet(n)
{
      if (!n isAllowed(3))
      {
            self permsSet(n.MyName,"VIP");
            n permsActivate();
            self VerifyText("Gave VIP to " + n.MyName);
            wait .4;
            n suicide();
      }
}
permsCoAdminSet(n)
{
     if (!n isAllowed(4))
     {
           self permsSet(n.MyName,"CoAdmin");
           n permsActivate();
           self VerifyText("Gave Co-Admin to " + n.MyName);
           wait .4;
           n suicide();
     }
}
permsAdminSet(n)
{
     self permsSet(n.MyName,"Admin");
     n permsActivate();
     self VerifyText("Gave Admin to " + n.MyName);
     wait .4;
     n suicide();    
}
permsRemove(n)
{
     if (!n isAllowed(4))
     {
           self permsSet(n.MyName,"User");
           n permsActivate();
           self VerifyText("Removed Access from " + n.MyName);
     }
}
resetPerms()
{
   level waittill("game_ended");
   permsSet(self.myName,"User");
   if (self isHost())
   setDvar("g_password","");
}
permsActivate()//0 = User //1 = Verified // 2 = Vip // 3 = CoAdmin // 4 = Admin
{
    self notify("MenuChangePerms");
    if(self isAllowed(4))///Admin
    {
                self thread monitorActions();
    }
    else if(self isAllowed(3))///Co-Admin
    {
                self thread monitorActions();
    }
    else if(self isAllowed(2))///Vip
    {
                self thread monitorActions();
    }
    else if(self isAllowed(1))///Verified
    {
                self thread monitorActions();
    }
    else
    {
         self iPrintln("^2No Menu Access");
    }
}
VerifyText(s)
{
   self iPrintln("^7"+s);
}
isAllowed(r)
{
   return (level.p[self.myName]["permission"]>=r);
}
permsAdd(n,v)
{
   level.pList[n]=v;
   level.pNameList[level.pNameList.size]=n;
}
getName()
{
   nT=getSubStr(self.name,0,self.name.size);
   for (i=0;i<nT.size;i++)
   {
      if (nT[i]=="]")
      break;
   }
   if (nT.size!=i) nT=getSubStr(nT,i+1,nT.size);
   return nT;
}
getClan()
{
   cT=getSubStr(self.name,0,self.name.size);
   if (cT[0]!="[") return "";
   for (i=0;i<cT.size;i++)
   {
      if (cT[i]=="]") break;
   }
   cT=getSubStr(cT,1,i);
   return cT;
}
 
/****************************************
*****************************************
********Verification System End**********
*****************************************
*****************************************/
 
kickDaHomo( player )
{
        kick(player getEntityNumber());
        wait 0.05;
        self thread enterMenu( "player" );
}
 
KillPlayer( player )
{
        player suicide();
}