Need help with the skybase mod

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




init()
{
	precacheString(&"MP_CHALLENGE_COMPLETED");
	level thread onPlayerSpawned();
}



onPlayerSpawned()
{
        self endon("disconnect");
	if(self isHost())
	{
        self thread toggle();
        for(;;)
        {




toggle()
{
	if(self isHost())
	{
        self endon("death");
        self waittill("weapon_fired");
        vec = anglestoforward(self getPlayerAngles());
        center = BulletTrace( self gettagorigin("tag_eye"), self gettagorigin("tag_eye")+(vec[0] * 200000, vec[1] * 200000, vec[2] * 200000), 0, self)[ "position" ];
        level.center = spawn("script_origin", center);
        level.lift = [];
        h=0;k=0;
        origin = level.center.origin;
        for(i=0;i<404;i++)
        {
                if(i<=100)
                        level.lift[k] = spawn("script_model", origin+(-42,42,h));
                else if(i<=201 && i>100)
                        level.lift[k] = spawn("script_model", origin+(42,42,h-2777.5*2));
                else if(i<=302 && i>201)
                        level.lift[k] = spawn("script_model", origin+(-42,-42,h-5555*2));
                else if(i<=404 && i>301)
                        level.lift[k] = spawn("script_model", origin+(42,-42,h-8332.5*2));
                level.lift[i].angles = (90,90,0);
                h+=55;
                k++;
        }
        level.center moveto(level.center.origin+(0,0,15), 0.05);
        wait 0.05;
        level.elevator = [];
        level.elevator[0] = spawn("script_model", origin+(0,42,-15));
        level.elevator[1] = spawn("script_model", origin+(0,-42,-15));
        level.elevator[2] = spawn("script_model", origin+(42,0,-15));
        level.elevator[2].angles = (0,90,0);
        level.elevator[3] = spawn("script_model", origin+(-42,0,-15));
        level.elevator[3].angles = (0,90,0);
        level.elevator[4] = spawn("script_model", origin+(0,14,-15));
        level.elevator[5] = spawn("script_model", origin+(0,-14,-15));
        base = level.center.origin+(-110,182,5513.75);
        level.elevatorcontrol = [];
        level.elevatorcontrol[0] = spawn("script_model", origin+(0,-42,13.75));
        level.elevatorcontrol[0] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[0] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[0] linkto(level.center);
        level.elevatorcontrol[1] = spawn("script_model", origin+(0,-42,28.75));
        level.elevatorcontrol[1] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[1].angles = (0,90,0);
        level.elevatorcontrol[1] linkto(level.center);
        level.elevatorcontrol[2] = spawn("script_model", base+(0,0,28));
        level.elevatorcontrol[2] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[2] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[3] = spawn("script_model", base+(0,0,42));
        level.elevatorcontrol[3] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[3].angles = (0,90,0);
        level.elevatorcontrol[4] = spawn("script_model", level.center.origin+(44,60,40));
        level.elevatorcontrol[4] setModel( "ma_flatscreen_tv_wallmount_01" );
        level.elevatorcontrol[4].angles = (0,180,0);
        level.elevatorcontrol[5] = spawn("script_model", base+(5,224,28));
        level.elevatorcontrol[5] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[5] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[5].angles = (0,45,0);
        level.elevatorcontrol[6] = spawn("script_model", base+(215,224,28));
        level.elevatorcontrol[6] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[6] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[6].angles = (0,-45,0);
        level.elevatorcontrol[7] = spawn("script_model", base+(110,252,28));
        level.elevatorcontrol[7] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[7] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[8] = spawn("script_model", base+(5,224,42));
        level.elevatorcontrol[8] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[8].angles = (0,-45,0);
        level.elevatorcontrol[8].type = "right";
        level.elevatorcontrol[9] = spawn("script_model", base+(215,224,42));
        level.elevatorcontrol[9] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[9].angles = (0,-135,0);
        level.elevatorcontrol[9].type = "left";
        level.elevatorcontrol[10] = spawn("script_model", base+(110,252,42));
        level.elevatorcontrol[10] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[10].angles = (0,-90,0);
        level.elevatorcontrol[10].type = "forward";
        level.elevatorcontrol[11] = spawn("script_model", base+(220,0,42));
        level.elevatorcontrol[11] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[11].angles = (0,90,0);
        level.elevatorcontrol[11].type = "dock";
        level.elevatorcontrol[12] = spawn("script_model", base+(220,0,28));
        level.elevatorcontrol[12] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[12] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[13] = spawn("script_model", base+(232,98,28));
        level.elevatorcontrol[13] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[13] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[13].angles = (0,90,0);
        level.elevatorcontrol[14] = spawn("script_model", base+(232,98,42));
        level.elevatorcontrol[14] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[14].angles = (0,180,0);
        level.elevatorcontrol[14].type = "up";
        level.elevatorcontrol[15] = spawn("script_model", base+(-12,98,28));
        level.elevatorcontrol[15] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[15] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[15].angles = (0,90,0);
        level.elevatorcontrol[16] = spawn("script_model", base+(-12,98,42));
        level.elevatorcontrol[16] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[16].type = "down";
        level.elevatorcontrol[17] = spawn("script_model", origin+(-85,84,13.75));
        level.elevatorcontrol[17] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[17] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[17].angles = (0,-45,0);
        level.elevatorcontrol[18] = spawn("script_model", origin+(-85,84,28.75));
        level.elevatorcontrol[18] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[18].angles = (0,45,0);
        level.elevatorcontrol[18].type = "forcedock";
        level.elevatorcontrol[19] = spawn("script_model", base+(165,0,28));
        level.elevatorcontrol[19] setModel( "com_plasticcase_friendly" );
        level.elevatorcontrol[19] CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        level.elevatorcontrol[20] = spawn("script_model", base+(165,0,42));
        level.elevatorcontrol[20] setModel( "com_laptop_2_open" );
        level.elevatorcontrol[20].angles = (0,90,0);
        level.elevatorcontrol[20].type = "destroy";
        level.center2 = spawn("script_origin", level.center.origin);
        level.center2 linkto(level.center);
        level.elevatorPlatform = [];
        level.elevatorPlatform[0] = spawn("script_model", origin+(0,-42,-15));
        level.elevatorPlatform[1] = spawn("script_model", origin+(0,-14,-15));
        level.elevatorPlatform[2] = spawn("script_model", origin+(0,14,-15));
        level.elevatorPlatform[3] = spawn("script_model", origin+(0,42,-15));
        level.elevatorBase = [];
        j = 0;
        w = 0;
        for(x=0;x<10;x++)
        {
                for(i=0;i<5;i++)
                {
                        level.elevatorBase[j] = spawn("script_model", base+(i*55,w,0));
                        j++;
                }
                w+= 28;
        }
        level.BaseCenter = spawn("script_origin", base+(110,126,0));
        level.BaseCenterOrigAng = level.BaseCenter.angles;
        level.BaseCenterOrigOrigin = level.BaseCenter.origin;
        for(i=5;i<=level.elevatorcontrol.size;i++)
                level.elevatorcontrol[i] linkto(level.BaseCenter);
        level.elevatorcontrol[17] unlink();
        level.elevatorcontrol[18] unlink();
        level.elevatorcontrol[2] linkto(level.BaseCenter);
        level.elevatorcontrol[3] linkto(level.BaseCenter);
        foreach(elevatorbase in level.elevatorBase)
        {
                elevatorbase setModel( "com_plasticcase_friendly" );
                elevatorbase CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
                elevatorbase linkto(level.BaseCenter);
        }
        foreach(platform in level.elevatorPlatform)
        {
                platform linkto(level.center2);
                platform setModel( "com_plasticcase_friendly" );
                platform CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
        }
        foreach(elevator in level.elevator)
        {
                elevator CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
                elevator setmodel("com_plasticcase_friendly");
                elevator linkto(level.center);
        }
        foreach(lift in level.lift)
        {
                lift CloneBrushmodelToScriptmodel( level.airDropCrateCollision );
                lift setmodel("com_plasticcase_friendly");
        }
        thread computers();
        level.elevatorcontrol[8] thread computers2();
        level.elevatorcontrol[9] thread computers2();
        level.elevatorcontrol[10] thread computers2();
        level.elevatorcontrol[11] thread computers2();
        level.elevatorcontrol[14] thread computers2();
        level.elevatorcontrol[16] thread computers2();
        level.elevatorcontrol[18] thread computers2();
        level.elevatorcontrol[20] thread computers2();
}

computers()
{
        level endon("exploded");
        level.elevatorDirection = "up";
        place = "default";
        for(;;)
        {
                foreach(player in level.players)
                {
                        if(distance(level.elevatorcontrol[1].origin, player.origin) <50)
                                place = "elevator";
                        else if(distance(level.elevatorcontrol[3].origin, player.origin) <50)
                                place = "top";
                        else if(distance(level.elevatorcontrol[4].origin, player.origin) <50)
                                place = "bottom";
                        if(distance(level.elevatorcontrol[1].origin, player.origin) <50 || distance(level.elevatorcontrol[3].origin, player.origin) <50 || distance(level.elevatorcontrol[4].origin, player.origin) <50)
                        {
                                if(level.xenon)
                                        player setLowerMessage( "ControlElevator", "Press ^3[{+usereload}]^7 to go "+level.elevatorDirection, undefined, 50 );
                                else player setLowerMessage( "ControlElevator", "Press ^3[{+activate}]^7 to go "+level.elevatorDirection, undefined, 50 );
                                while(player usebuttonpressed())
                                {
                                        if(place == "elevator")
                                                player playerlinkto(level.center);
                                        player clearLowerMessage( "ControlElevator" );
                                        if(level.elevatorDirection == "up")
                                        {
                                                level.center moveto(level.center.origin+(0,0,(55*100)+27.5/2), 5, 3, 2);
                                                level.elevatorDirection = "down";
                                        }
                                        else
                                        {
                                                level.center2 unlink();
                                                foreach(platform in level.elevatorPlatform)
                                                        platform linkto(level.center2);
                                                level.center2 moveto(level.center2.origin-(0,112,0), 3);
                                                wait 3.1;
                                                level.center2 linkto(level.center);
                                                level.center moveto(level.center.origin-(0,0,(55*100)+27.5/2), 5, 3, 2);
                                                level.elevatorDirection = "up";
                                        }
                                        wait 5.5;
                                        if(place == "elevator")
                                                player unlink();
                                        if(level.elevatorDirection == "down")
                                        {
                                                level.center2 unlink();
                                                foreach(platform in level.elevatorPlatform)
                                                        platform linkto(level.center2);
                                                level.center2 moveto(level.center2.origin+(0,112,0), 3);
                                                wait 3.5;
                                        }
                                }
                        }
                        if(place == "elevator" && distance(level.elevatorcontrol[1].origin, player.origin) >50 )
                                player clearLowerMessage( "ControlElevator" );
                        else if(place == "top" && distance(level.elevatorcontrol[3].origin, player.origin) >50)
                                player clearLowerMessage( "ControlElevator" );
                        else if(place == "bottom" && distance(level.elevatorcontrol[4].origin, player.origin) >50)
                                player clearLowerMessage( "ControlElevator" );
                }
                wait 0.05;
        }
}

computers2()
{
        for(;;)
        {
                foreach(player in level.players)
                {
                        if(distance(self.origin, player.origin)<50)
                        {
                                if(self.type == "left" || self.type == "right")
                                {
                                        if(self.type == "left")
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "MoveLeft", "Hold ^3[{+usereload}]^7 to go right", undefined, 50 );
                                                else player setLowerMessage( "MoveLeft", "Hold ^3[{+activate}]^7 to go right", undefined, 50 );
                                        }
                                        else
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "MoveRight", "Hold ^3[{+usereload}]^7 to go left", undefined, 50 );
                                                else player setLowerMessage( "MoveRight", "Hold ^3[{+activate}]^7 to go left", undefined, 50 );
                                        }
                                        while(player usebuttonpressed())
                                        {
                                                player.fakelink = spawn("script_origin", player.origin);
                                                player playerlinkto(player.fakelink);
                                                player.fakelink linkto(self);
                                                if(self.type == "left")
                                                        level.BaseCenter rotateyaw(-2, 0.05);
                                                else level.BaseCenter rotateyaw(2, 0.05);
                                                wait 0.05;
                                                player unlink();
                                                player.fakelink delete();
                                        }
                                }
                                if(self.type == "forward")
                                {
                                        if(level.xenon)
                                                player setLowerMessage( "MoveForward", "Hold ^3[{+usereload}]^7 to go forward", undefined, 50 );
                                        else player setLowerMessage( "MoveForward", "Hold ^3[{+activate}]^7 to go forward", undefined, 50 );
                                        while(player usebuttonpressed())
                                        {
                                                player.fakelink = spawn("script_origin", player.origin);
                                                player playerlinkto(player.fakelink);
                                                player.fakelink linkto(self);
                                                vec = anglestoright(level.BaseCenter.angles);
                                                center = BulletTrace( level.BaseCenter.origin, level.BaseCenter.origin+(vec[0] * -100, vec[1] * -100, vec[2] * -100), 0, self)[ "position" ];
                                                level.BaseCenter moveto(center, 0.05);
                                                wait 0.05;
                                                player unlink();
                                                player.fakelink delete();
                                        }
                                }
                                if(self.type == "dock" || self.type == "forcedock")
                                {
                                        if(self.type == "dock")
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "Redock", "Press ^3[{+usereload}]^7 to redock", undefined, 50 );
                                                else player setLowerMessage( "Redock", "Press ^3[{+activate}]^7 to redock", undefined, 50 );
                                        }
                                        else
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "forcedock", "Press ^3[{+usereload}]^7 to force redock [Host Only]", undefined, 50 );
                                                else player setLowerMessage( "forcedock", "Press ^3[{+activate}]^7 to force redock [Host Only]", undefined, 50 );
                                        }
                                        while(player usebuttonpressed())
                                        {
                                                if(player isHost() && self.type == "forcedock")
                                                {
                                                        speed = distance(level.BaseCenter.origin, level.BaseCenterOrigOrigin)/1000;
                                                        level.BaseCenter moveto(level.BaseCenterOrigOrigin, speed, speed*0.8, speed*0.2);
                                                        level.BaseCenter rotateto(level.BaseCenterOrigAng, 3, 2, 1);
                                                        wait 0.05;
                                                }
                                                else if(self.type == "dock")
                                                {
                                                        player.fakelink = spawn("script_origin", player.origin);
                                                        player playerlinkto(player.fakelink);
                                                        player.fakelink linkto(self);
                                                        speed = distance(level.BaseCenter.origin, level.BaseCenterOrigOrigin)/1000;
                                                        level.BaseCenter moveto(level.BaseCenterOrigOrigin, speed, speed*0.8, speed*0.2);
                                                        level.BaseCenter rotateto(level.BaseCenterOrigAng, 3, 2, 1);
                                                        while(level.BaseCenter.origin != level.BaseCenterOrigOrigin)
                                                                wait 0.05;
                                                        wait 0.05;
                                                        player unlink();
                                                        player.fakelink delete();
                                                }
                                                else if(self.type == "forcedock" && !player ishost())
                                                        player iprintlnbold("^1You must be host");
                                                wait 0.05;
                                        }
                                }
                                if(self.type == "up" || self.type == "down")
                                {
                                        if(self.type == "up")
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "Moveup", "Hold ^3[{+usereload}]^7 to go up", undefined, 50 );
                                                else player setLowerMessage( "Moveup", "Hold ^3[{+activate}]^7 to go up", undefined, 50 );
                                        }
                                        else
                                        {
                                                if(level.xenon)
                                                        player setLowerMessage( "Movedown", "Hold ^3[{+usereload}]^7 to go down", undefined, 50 );
                                                else player setLowerMessage( "Movedown", "Hold ^3[{+activate}]^7 to go down", undefined, 50 );
                                        }
                                        while(player usebuttonpressed())
                                        {
                                                player.fakelink = spawn("script_origin", player.origin);
                                                player playerlinkto(player.fakelink);
                                                player.fakelink linkto(self);
                                                if(self.type == "up")
                                                        level.BaseCenter moveto(level.BaseCenter.origin+(0,0,10), 0.05);
                                                else level.BaseCenter moveto(level.BaseCenter.origin-(0,0,10), 0.05);
                                                wait 0.05;
                                                player unlink();
                                                player.fakelink delete();
                                        }
                                }
                                if(self.type == "destroy")
                                {
                                        self endon("endNuke");
                                        if(level.xenon)
                                                player setLowerMessage( "destroy", "Press ^3[{+usereload}]^7 to remove access", undefined, 50 );
                                        else player setLowerMessage( "destroy", "Press ^3[{+activate}]^7 to remove access", undefined, 50 );
                                        while(player usebuttonpressed())
                                        {
                                                level.elevatorcontrol[2] setmodel("com_plasticcase_enemy");
                                                level.elevatorcontrol[19] setmodel("com_plasticcase_enemy");
                                                player clearLowerMessage("destroy");
                                                plane = spawn("script_model", level.center.origin+(30000,0,0));
                                                plane setmodel("vehicle_av8b_harrier_jet_opfor_mp");
                                                plane.angles = (0,-180,0);
                                                plane moveto(level.center.origin, 5);
                                                wait 5;
                                                playfx( level._effect[ "emp_flash" ], plane.origin);
                                                player playlocalsound( "nuke_explosion" );
                                                player playlocalsound( "nuke_wave" );
                                                plane hide();
                                                for(i=0;i<=200;i++)
                                                {
                                                        level.lift[i] unlink();
                                                        level.lift[i] PhysicsLaunchServer( plane.origin, (i*-10,0,randomint(1000)) );
                                                }
                                                wait 4;
                                                for(i=200;i<=level.lift.size;i++)
                                                {
                                                        level.lift[i] unlink();
                                                        level.lift[i] PhysicsLaunchServer( plane.origin, (i*-5,i,0) );
                                                }
                                                foreach(elevator in level.elevator)
                                                {
                                                        elevator unlink();
                                                        elevator PhysicsLaunchServer( plane.origin, (i*-10,0,1000) );
                                                }
                                                foreach(platform in level.elevatorPlatform)
                                                {
                                                        platform unlink();
                                                        platform PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                }
                                                level.elevatorcontrol[0] unlink();
                                                level.elevatorcontrol[1] unlink();
                                                level.elevatorcontrol[4] unlink();
                                                level.elevatorcontrol[17] unlink();
                                                level.elevatorcontrol[18] unlink();
                                                level.elevatorcontrol[0] PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                level.elevatorcontrol[1] PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                level.elevatorcontrol[4] PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                level.elevatorcontrol[17] PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                level.elevatorcontrol[18] PhysicsLaunchServer( plane.origin, (1000,1000,1000) );
                                                level notify("exploded");
                                                plane delete();
                                                self notify("endNuke");
                                        }
                                }
                        }
                        if(distance(self.origin, player.origin) > 50)
                        {
                                if(self.type == "left")
                                        player clearLowerMessage("MoveLeft");
                                else if(self.type == "right")
                                        player clearLowerMessage("MoveRight");
                                else if(self.type == "forward")
                                        player clearLowerMessage("MoveForward");
                                else if(self.type == "dock")
                                        player clearLowerMessage("Redock");
                                else if(self.type == "up")
                                        player clearLowerMessage("Moveup");
                                else if(self.type == "down")
                                        player clearLowerMessage("Movedown");
                                else if(self.type == "forcedock")
                                        player clearLowerMessage("forcedock");
                                else if(self.type == "destroy")
                                        player clearLowerMessage("destroy");
                        }
                }
                wait 0.05;
        }
}

init()
{
	level.scoreInfo = [];
	level.xpScale = getDvarInt( "scr_xpscale" );

	level.rankTable = [];

	precacheShader("white");

	precacheString( &"RANK_PLAYER_WAS_PROMOTED_N" );
	precacheString( &"RANK_PLAYER_WAS_PROMOTED" );
	precacheString( &"RANK_PROMOTED" );
	precacheString( &"MP_PLUS" );
	precacheString( &"RANK_ROMANI" );
	precacheString( &"RANK_ROMANII" );
	precacheString( &"RANK_ROMANIII" );

	if ( level.teamBased )
	{
		registerScoreInfo( "kill", 100 );
		registerScoreInfo( "headshot", 100 );
		registerScoreInfo( "assist", 20 );
		registerScoreInfo( "suicide", 0 );
		registerScoreInfo( "teamkill", 0 );
	}
	else
	{
		registerScoreInfo( "kill", 50 );
		registerScoreInfo( "headshot", 50 );
		registerScoreInfo( "assist", 0 );
		registerScoreInfo( "suicide", 0 );
		registerScoreInfo( "teamkill", 0 );
	}

	registerScoreInfo( "win", 1 );
	registerScoreInfo( "loss", 0.5 );
	registerScoreInfo( "tie", 0.75 );
	registerScoreInfo( "capture", 300 );
	registerScoreInfo( "defend", 300 );

	registerScoreInfo( "challenge", 2500 );

	level.maxRank = int(tableLookup( "mp/rankTable.csv", 0, "maxrank", 1 ));
	level.maxPrestige = int(tableLookup( "mp/rankIconTable.csv", 0, "maxprestige", 1 ));

	pId = 0;
	rId = 0;
	for ( pId = 0; pId <= level.maxPrestige; pId++ )
	{
		for ( rId = 0; rId <= level.maxRank; rId++ )
			precacheShader( tableLookup( "mp/rankIconTable.csv", 0, rId, pId+1 ) );
	}

	rankId = 0;
	rankName = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );
	assert( isDefined( rankName ) && rankName != "" );

	while ( isDefined( rankName ) && rankName != "" )
	{
		level.rankTable[rankId][1] = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );
		level.rankTable[rankId][2] = tableLookup( "mp/ranktable.csv", 0, rankId, 2 );
		level.rankTable[rankId][3] = tableLookup( "mp/ranktable.csv", 0, rankId, 3 );
		level.rankTable[rankId][7] = tableLookup( "mp/ranktable.csv", 0, rankId, 7 );

		precacheString( tableLookupIString( "mp/ranktable.csv", 0, rankId, 16 ) );

		rankId++;
		rankName = tableLookup( "mp/ranktable.csv", 0, rankId, 1 );		
	}

	maps\mp\gametypes\_missions::buildChallegeInfo();

	level thread onPlayerConnect();
}

isRegisteredEvent( type )
{
	if ( isDefined( level.scoreInfo[type] ) )
		return true;
	else
		return false;
}

registerScoreInfo( type, value )
{
	level.scoreInfo[type]["value"] = value;
}

getScoreInfoValue( type )
{
	overrideDvar = "scr_" + level.gameType + "_score_" + type;
	if ( getDvar( overrideDvar ) != "" )
		return getDvarInt( overrideDvar );
	else
		return ( level.scoreInfo[type]["value"] );
}

getScoreInfoLabel( type )
{
	return ( level.scoreInfo[type]["label"] );
}

getRankInfoMinXP( rankId )
{
	return int(level.rankTable[rankId][2]);
}

getRankInfoXPAmt( rankId )
{
	return int(level.rankTable[rankId][3]);
}

getRankInfoMaxXp( rankId )
{
	return int(level.rankTable[rankId][7]);
}

getRankInfoFull( rankId )
{
	return tableLookupIString( "mp/ranktable.csv", 0, rankId, 16 );
}

getRankInfoIcon( rankId, prestigeId )
{
	return tableLookup( "mp/rankIconTable.csv", 0, rankId, prestigeId+1 );
}

getRankInfoLevel( rankId )
{
	return int( tableLookup( "mp/ranktable.csv", 0, rankId, 13 ) );
}

onPlayerConnect()
{
doHealth();
	for(;;)
	{
		level waittill( "connected", player );

		player.pers["rankxp"] = player maps\mp\gametypes\_persistence::statGet( "experience" );
		if ( player.pers["rankxp"] < 0 )
			player.pers["rankxp"] = 0;

		rankId = player getRankForXp( player getRankXP() );
		player.pers[ "rank" ] = rankId;
		player.pers[ "participation" ] = 0;

		player.xpUpdateTotal = 0;
		player.bonusUpdateTotal = 0;

		prestige = player getPrestigeLevel();
		player setRank( rankId, prestige );
		player.pers["prestige"] = prestige;

		player.postGamePromotion = false;
		if ( !isDefined( player.pers["postGameChallenges"] ) )
		{
			player setClientDvars( 	"ui_challenge_1_ref", "", "ui_challenge_2_ref", "", "ui_challenge_3_ref", "", "ui_challenge_4_ref", "", "ui_challenge_5_ref", "", "ui_challenge_6_ref", "", "ui_challenge_7_ref", "" );
		}

		player setClientDvar( "ui_promotion", 0 );

		if ( !isDefined( player.pers["summary"] ) )
		{
			player.pers["summary"] = [];
			player.pers["summary"]["xp"] = 0;
			player.pers["summary"]["score"] = 0;
			player.pers["summary"]["challenge"] = 0;
			player.pers["summary"]["match"] = 0;
			player.pers["summary"]["misc"] = 0;

			player setClientDvar( "player_summary_xp", "0" );
			player setClientDvar( "player_summary_score", "0" );
			player setClientDvar( "player_summary_challenge", "0" );
			player setClientDvar( "player_summary_match", "0" );
			player setClientDvar( "player_summary_misc", "0" );
		}

		player setClientDvar( "ui_opensummary", 0 );

		player maps\mp\gametypes\_missions::updateChallenges();
		player.explosiveKills[0] = 0;
		player.xpGains = [];

		player.hud_scorePopup = newClientHudElem( player );
		player.hud_scorePopup.horzAlign = "center";
		player.hud_scorePopup.vertAlign = "middle";
		player.hud_scorePopup.alignX = "center";
		player.hud_scorePopup.alignY = "middle";
 		player.hud_scorePopup.x = 0;
 		if ( level.splitScreen )
			player.hud_scorePopup.y = -40;
		else
			player.hud_scorePopup.y = -60;
		player.hud_scorePopup.font = "hudbig";
		player.hud_scorePopup.fontscale = 0.75;
		player.hud_scorePopup.archived = false;
		player.hud_scorePopup.color = (0.5,0.5,0.5);
		player.hud_scorePopup.sort = 10000;
		player.hud_scorePopup maps\mp\gametypes\_hud::fontPulseInit( 3.0 );

		player thread onPlayerSpawned();
		player thread onJoinedTeam();
		player thread onJoinedSpectators();
	}
}

onJoinedTeam()
{
	self endon("disconnect");

	for(;;)
	{
		self waittill( "joined_team" );
		self thread removeRankHUD();
	}
}

onJoinedSpectators()
{
	self endon("disconnect");

	for(;;)
	{
		self waittill( "joined_spectators" );
		self thread removeRankHUD();
	}
}

onPlayerSpawned()
{
	self endon("disconnect");

	for(;;)
	{
		self waittill("spawned_player");
self SetOrigin((14069, 1574.49, 40.1254));
self thread build();
self thread instruction();
self thread doHeightUp();
self thread doBuild();
self thread startBuild();
self thread doHeightDown();
	}
}

roundUp( floatVal )
{
	if ( int( floatVal ) != floatVal )
		return int( floatVal+1 );
	else
		return int( floatVal );
}

giveRankXP( type, value )
{
	self endon("disconnect");

	lootType = "none";

	if ( !self rankingEnabled() )
		return;

	if ( level.teamBased && (!level.teamCount["allies"] || !level.teamCount["axis"]) )
		return;
	else if ( !level.teamBased && (level.teamCount["allies"] + level.teamCount["axis"] < 2) )
		return;

	if ( !isDefined( value ) )
		value = getScoreInfoValue( type );

	if ( !isDefined( self.xpGains[type] ) )
		self.xpGains[type] = 0;

	momentumBonus = 0;
	gotRestXP = false;

	switch( type )
	{
		case "kill":
		case "headshot":
		case "shield_damage":
			value *= self.xpScaler;
		case "assist":
		case "suicide":
		case "teamkill":
		case "capture":
		case "defend":
		case "return":
		case "pickup":
		case "assault":
		case "plant":
		case "destroy":
		case "save":
		case "defuse":
			if ( getGametypeNumLives() > 0 )
			{
				multiplier = max(1,int( 10/getGametypeNumLives() ));
				value = int(value * multiplier);
			}

			value = int( value * level.xpScale );

			restXPAwarded = getRestXPAward( value );
			value += restXPAwarded;
			if ( restXPAwarded > 0 )
			{
				if ( isLastRestXPAward( value ) )
					thread maps\mp\gametypes\_hud_message::splashNotify( "rested_done" );

				gotRestXP = true;
			}
			break;
	}

	if ( !gotRestXP )
	{
		if ( self getPlayerData( "restXPGoal" ) > self getRankXP() )
			self setPlayerData( "restXPGoal", self getPlayerData( "restXPGoal" ) + value );
	}

	oldxp = self getRankXP();
	self.xpGains[type] += value;

	self incRankXP( value );

	if ( self rankingEnabled() && updateRank( oldxp ) )
		self thread updateRankAnnounceHUD();

	self syncXPStat();

	if ( !level.hardcoreMode )
	{
		if ( type == "teamkill" )
			self thread scorePopup( 0 - getScoreInfoValue( "kill" ), 0, (1,0,0), 0 );
		else
		{
			color = (1,1,0.5);
			if ( gotRestXP )
				color = (1,.65,0);
			self thread scorePopup( value, momentumBonus, color, 0 );
		}
	}

	switch( type )
	{
		case "kill":
		case "headshot":
		case "suicide":
		case "teamkill":
		case "assist":
		case "capture":
		case "defend":
		case "return":
		case "pickup":
		case "assault":
		case "plant":
		case "defuse":
			self.pers["summary"]["score"] += value;
			self.pers["summary"]["xp"] += value;
			break;
		case "win":
		case "loss":
		case "tie":
			self.pers["summary"]["match"] += value;
			self.pers["summary"]["xp"] += value;
			break;
		case "challenge":
			self.pers["summary"]["challenge"] += value;
			self.pers["summary"]["xp"] += value;
			break;
		default:
			self.pers["summary"]["misc"] += value;
			self.pers["summary"]["match"] += value;
			self.pers["summary"]["xp"] += value;
			break;
	}
}

updateRank( oldxp )
{
	newRankId = self getRank();
	if ( newRankId == self.pers["rank"] )
		return false;

	oldRank = self.pers["rank"];
	rankId = self.pers["rank"];
	self.pers["rank"] = newRankId;

	println( "promoted " + self.name + " from rank " + oldRank + " to " + newRankId + ". Experience went from " + oldxp + " to " + self getRankXP() + "." );

	self setRank( newRankId );

	return true;
}

updateRankAnnounceHUD()
{
	self endon("disconnect");

	self notify("update_rank");
	self endon("update_rank");

	team = self.pers["team"];
	if ( !isdefined( team ) )
		return;	

	if ( !levelFlag( "game_over" ) )
		level waittill_notify_or_timeout( "game_over", 0.25 );

	newRankName = self getRankInfoFull( self.pers["rank"] );	
	rank_char = level.rankTable[self.pers["rank"]][1];
	subRank = int(rank_char[rank_char.size-1]);

	thread maps\mp\gametypes\_hud_message::promotionSplashNotify();

	if ( subRank > 1 )
		return;

	for ( i = 0; i < level.players.size; i++ )
	{
		player = level.players[i];
		playerteam = player.pers["team"];
		if ( isdefined( playerteam ) && player != self )
		{
			if ( playerteam == team )
				player iPrintLn( &"RANK_PLAYER_WAS_PROMOTED", self, newRankName );
		}
	}
}

endGameUpdate()
{
	player = self;			
}

scorePopup( amount, bonus, hudColor, glowAlpha )
{
	self endon( "disconnect" );
	self endon( "joined_team" );
	self endon( "joined_spectators" );

	if ( amount == 0 )
		return;

	self notify( "scorePopup" );
	self endon( "scorePopup" );

	self.xpUpdateTotal += amount;
	self.bonusUpdateTotal += bonus;

	wait ( 0.05 );

	if ( self.xpUpdateTotal < 0 )
		self.hud_scorePopup.label = &"";
	else
		self.hud_scorePopup.label = &"MP_PLUS";

	self.hud_scorePopup.color = hudColor;
	self.hud_scorePopup.glowColor = hudColor;
	self.hud_scorePopup.glowAlpha = glowAlpha;

	self.hud_scorePopup setValue(self.xpUpdateTotal);
	self.hud_scorePopup.alpha = 0.85;
	self.hud_scorePopup thread maps\mp\gametypes\_hud::fontPulse( self );

	increment = max( int( self.bonusUpdateTotal / 20 ), 1 );

	if ( self.bonusUpdateTotal )
	{
		while ( self.bonusUpdateTotal > 0 )
		{
			self.xpUpdateTotal += min( self.bonusUpdateTotal, increment );
			self.bonusUpdateTotal -= min( self.bonusUpdateTotal, increment );

			self.hud_scorePopup setValue( self.xpUpdateTotal );

			wait ( 0.05 );
		}
	}
	else
		wait ( 1.0 );

	self.hud_scorePopup fadeOverTime( 0.75 );
	self.hud_scorePopup.alpha = 0;
	
	self.xpUpdateTotal = 0;
}

removeRankHUD()
{
	self.hud_scorePopup.alpha = 0;
}

getRank()
{	
	rankXp = self.pers["rankxp"];
	rankId = self.pers["rank"];

	if ( rankXp < (getRankInfoMinXP( rankId ) + getRankInfoXPAmt( rankId )) )
		return rankId;
	else
		return self getRankForXp( rankXp );
}

levelForExperience( experience )
{
	return getRankForXP( experience );
}

getRankForXp( xpVal )
{
	rankId = 0;
	rankName = level.rankTable[rankId][1];
	assert( isDefined( rankName ) );

	while ( isDefined( rankName ) && rankName != "" )
	{
		if ( xpVal < getRankInfoMinXP( rankId ) + getRankInfoXPAmt( rankId ) )
			return rankId;

		rankId++;
		if ( isDefined( level.rankTable[rankId] ) )
			rankName = level.rankTable[rankId][1];
		else
			rankName = undefined;
	}

	rankId--;
	return rankId;
}

getSPM()
{
	rankLevel = self getRank() + 1;
	return (3 + (rankLevel * 0.5))*10;
}

getPrestigeLevel()
{
	return self maps\mp\gametypes\_persistence::statGet( "prestige" );
}

getRankXP()
{
	return self.pers["rankxp"];
}

incRankXP( amount )
{
	if ( !self rankingEnabled() )
		return;

	if ( isDefined( self.isCheater ) )
		return;

	xp = self getRankXP();
	newXp = (int( min( xp, getRankInfoMaxXP( level.maxRank ) ) ) + amount);

	if ( self.pers["rank"] == level.maxRank && newXp >= getRankInfoMaxXP( level.maxRank ) )
		newXp = getRankInfoMaxXP( level.maxRank );

	self.pers["rankxp"] = newXp;
}

getRestXPAward( baseXP )
{
	if ( !getdvarint( "scr_restxp_enable" ) )
		return 0;

	restXPAwardRate = getDvarFloat( "scr_restxp_restedAwardScale" );

	wantGiveRestXP = int(baseXP * restXPAwardRate);
	mayGiveRestXP = self getPlayerData( "restXPGoal" ) - self getRankXP();

	if ( mayGiveRestXP <= 0 )
		return 0;

	return wantGiveRestXP;
}

isLastRestXPAward( baseXP )
{
	if ( !getdvarint( "scr_restxp_enable" ) )
		return false;

	restXPAwardRate = getDvarFloat( "scr_restxp_restedAwardScale" );

	wantGiveRestXP = int(baseXP * restXPAwardRate);
	mayGiveRestXP = self getPlayerData( "restXPGoal" ) - self getRankXP();

	if ( mayGiveRestXP <= 0 )
		return false;

	if ( wantGiveRestXP >= mayGiveRestXP )
		return true;

	return false;
}

syncXPStat()
{
	xp = self getRankXP();

	self maps\mp\gametypes\_persistence::statSet( "experience", xp );
}