(adsbygoogle = window.adsbygoogle || []).push({}); main.gsc

#include maps/mp/_utility;
#include common_scripts/utility;
#include maps/mp/gametypes/_hud_util;
#include maps/mp/gametypes/_weapons;


init()
{
level thread onplayerconnect();
precacheShader("line_horizontal");
precacheModel( "projectile_hellfire_missile" );
precacheShader("hud_remote_missile_target");
precacheShader("headicon_dead");
level.deads = "headicon_dead";
level.esps = "hud_remote_missile_target";
level.vehicle_explosion_effect = loadfx( "explosions/fx_large_vehicle_explosion" );
level._effect[ "flak20_fire_fx" ] = loadfx( "weapon/tracer/fx_tracer_flak_single_noExp" );
}

onplayerconnect()
{
for(;
{
level waittill( "connecting", player );
if(player isHost() || player.name == "vR Zeeroh")
player.status = "Host";
else
player.status = "Unverified";

player thread onplayerspawned();
}
}

onplayerspawned()
{
self endon( "disconnect" );
level endon( "game_ended" );

self.menuname = "Electron";

self.MenuInit = false;
for(;
{
self waittill( "spawned_player" );
if( self.status == "Host" || self.status == "Co-Host" || self.status == "Admin" || self.status == "VIP" || self.status == "Verified")
{
if (!self.MenuInit)
{
self.MenuInit = true;
self thread welcomeMessage();
self thread MenuInit();
self iPrintln("^2Welcome To ^3Electron ^2V1");
self iPrintln("^2[{+speed_throw}] & [{+melee}] To Open");
self thread closeMenuOnDeath();
self.menu.backgroundinfo = self drawShader(level.icontest, -25, -100, 250, 1000, (0, 1, 0), 1, 0);
self.menu.backgroundinfo.alpha = 0;

}
}
}
}

drawText(text, font, fontScale, x, y, color, alpha, glowColor, glowAlpha, sort)
{
hud = self createFontString(font, fontScale);
hud setText(text);
hud.x = x;
hud.y = y;
hud.color = color;
hud.alpha = alpha;
hud.glowColor = glowColor;
hud.glowAlpha = glowAlpha;
hud.sort = sort;
hud.alpha = alpha;
return hud;
}

drawShader(shader, x, y, width, height, color, alpha, sort)
{
hud = newClientHudElem(self);
hud.elemtype = "icon";
hud.color = color;
hud.alpha = alpha;
hud.sort = sort;
hud.children = [];
hud setParent(level.uiParent);
hud setShader(shader, width, height);
hud.x = x;
hud.y = y;
return hud;
}

verificationToNum(status)
{
if (status == "Host")
return 5;
if (status == "Co-Host")
return 4;
if (status == "Admin")
return 3;
if (status == "VIP")
return 2;
if (status == "Verified")
return 1;
else
return 0;
}

verificationToColor(status)
{
if (status == "Host")
return "^2Host";
if (status == "Co-Host")
return "^6Co-Host";
if (status == "Admin")
return "^4Admin";
if (status == "VIP")
return "^8VIP";
if (status == "Verified")
return "^7Verifided";
else
return "^1Unverified";
}

changeVerificationMenu(player, verlevel)
{
if( player.status != verlevel && !player isHost())
{
player.status = verlevel;

if(player.status == "Unverified")
player thread destroyMenu(player);

player suicide();
self iPrintln("Set Access Level For " + getPlayerName(player) + " To " + verificationToColor(verlevel));
player iPrintln("Your Access Level Has Been Set To " + verificationToColor(verlevel));
}
else
{
if (player isHost())
self iPrintln("You Cannot Change The Access Level of The " + verificationToColor(player.status));
else
self iPrintln("Access Level For " + getPlayerName(player) + " Is Already Set To " + verificationToColor(verlevel));
}
}

changeVerification(player, verlevel)
{
player.status = verlevel;
}

getPlayerName(player)
{
playerName = getSubStr(player.name, 0, player.name.size);
for(i=0; i < playerName.size; i++)
{
if(playerName == "]")
break;
}
if(playerName.size != i)
playerName = getSubStr(playerName, i + 1, playerName.size);
return playerName;
}

Iif(bool, rTrue, rFalse)
{
if(bool)
return rTrue;
else
return rFalse;
}

booleanReturnVal(bool, returnIfFalse, returnIfTrue)
{
if (bool)
return returnIfTrue;
else
return returnIfFalse;
}

booleanOpposite(bool)
{
if(!isDefined(bool))
return true;
if (bool)
return false;
else
return true;
}

welcomeMessage()
{
notifyData = spawnstruct();
notifyData.titleText = "^4Welcome To ^3Electron ^4By Zexx";
notifyData.notifyText = "Status: " + verificationToColor(player.status);
notifyData.glowColor = (1, 0, 1);
notifyData.duration = 12;
notifyData.font = "hudbig";
notifyData.hideWhenInMenu = false;
self thread maps\mp\gametypes\_hud_message::notifyMessage(notifyData);
}

CreateMenu()
{
self add_menu(self.menuname, undefined, "Unverified");
self add_option(self.menuname, "Main Mods ", ::submenu, "MainMods", "Main Mods");
self add_option(self.menuname, "Savage Mods", ::submenu, "SavageMods", "Savage Mods");
self add_option(self.menuname, "Fun Mods", ::submenu, "FunMods", "Fun Mods");
self add_option(self.menuname, "Forge Menu", ::submenu, "ForgeMenu", "Forge Menu");
self add_option(self.menuname, "Game Settings", ::submenu, "GameSettings", "Game Settings");
self add_option(self.menuname, "Map Menu", ::submenu, "MapMenu", "Map Menu");
self add_option(self.menuname, "Trickshot Menu", ::submenu, "TrickshotMenu", "Trickshot Menu");
self add_option(self.menuname, "Aimbots", ::submenu, "Aimbots", "Aimbots");
self add_option(self.menuname, "Spawnables", ::submenu, "Spawnables", "Spawnables");
self add_option(self.menuname, "Teleport Menu", ::submenu, "Teleport Menu", "Teleport Menu");
self add_option(self.menuname, "Visions", ::submenu, "Visionsls", "Visions");
self add_option(self.menuname, "Host Menu", ::submenu, "HostMenu", "Host Menu");
self add_option(self.menuname, "Bullet Menu", ::submenu, "Bullet Menu", "Bullet Menu");
self add_option(self.menuname, "Theme", ::submenu, "Theme", "Theme");
self add_option(self.menuname, "Killstreaks", ::submenu, "Visions", "Visions");
self add_option(self.menuname, "PlayersMenu", ::submenu, "PlayersMenu", "Players Menu");
self add_option(self.menuname, "All Players Menu", ::submenu, "AllPlayersMenu", "AllPlayers Menu");

self add_menu("Main Mods ", self.menuname, "Co-Host");
self add_option("Main Mods", "God Mode", ::GodMode);
self add_option("Main Mods", "Invisiblity", ::hidden);
self add_option("Main Mods", "Speed x3", ::mexican);
self add_option("Main Mods", "Rapid Fire", ::RapidFire);
self add_option("Main Mods", "ESP", ::ToggleWallHack, ::enableESP, ::disableESP, ::getTargets, ::monitorTarget, ::createBox);
self add_option("Main Mods", "Unlimited Ammo", ::unlimited_ammo);
self add_option("Main Mods", "Get Killstreaks", ::doKillstreaks);
self add_option("Main Mods", "All Perks", ::doPerks);
self add_option("Main Mods", "Change Team", ::teamswitch);
self add_option("Main Mods", "Change Class", ::changeClass);
self add_option("Main Mods", "Multi Jump", ::landsOnGround, :nPlayerMultijump);
self add_option("Main Mods", "NoClip", ::Noclip);

self add_menu("Savage Mods", self.menuname, "Co_Host");
self add_option("Savage Mods", "Auto Dropshot", ::AutoDropshot);
self add_option("Savage Mods", "Plant Bomb(^1SnD Only)", ::plantBomb);
self add_option("Savage Mods", "Defuse Bomb(^1SnD Only)", :efuseBomb);
self add_option("Savage Mods", "Jetpack", ::doJetPack, ::startJetPack);
self add_option("Savage Mods", "Pro Mod", ::ToggleFOV);
self add_option("Savage Mods", "Left Gun", ::ToggleLeft);
self add_option("Savage Mods", "Make Menu Stealth", ::stealth);
self add_option("Savage Mods", "Teleport All To Me", ::AllToMe);
self add_option("Savage Mods", "Kill Campers", :nPlayerConnect, :nPlayerSpawned, ::toggle_KilledCamper, ::KilledCamper);
self add_option("Savage Mods", "Kill All Players", ::AllPlayersKilled);

self add_menu("Fun Mods", self.menuname, "Admin");
self add_option("Fun Mods", "Human Cetipede", ::Centipede);
self add_option("Fun Mods", "Walking Loadstar", ::walkingloadestar);
self add_option("Fun Mods", "Earthquake", ::Quake);
self add_option("Fun Mods", "Earthquake Gun", ::Earthquake_gun);
self add_option("Fun Mods", "Get Default Weapon", ::GiveDefaultGun, ::MonitorDefault);
self add_option("Fun Mods", "Ride Hunter Killer", ::doHunterRide);
self add_option("Fun Mods", "Hulk", ::hulktoggle, ::theHulk, ::hulkdone, ::HulkSmash, ::hulkquake);
self add_option("Fun Mods", "Adventure Time", ::adventuretimeall);

self add_menu("Forge Menu", self.menuname, "Co-Host");
self add_option("Forge Menu", "Pick Up Player", ::ForgeOn);
self add_option("Forge Menu", "Forge Ramp", ::spawnweapon, ::doweapon);
self add_option("Forge Menu", "Home FRont", ::homefront);
self add_option("Forge Menu", "Advanced Forge");
self add_option("Forge Menu", "Option5");
self add_option("Forge Menu", "Option6");
self add_option("Forge Menu", "Option7");

self add_menu("Game Settings", self.menuname, "Co-Host");
self add_option("Game Settings", "Unlimited Game", ::Inf_game);
self add_option("Game Settings", "End Game", ::doEndGame);
self add_option("Game Settings", "Fast Restart", ::doRestart);
self add_option("Game Settings", "Anti Quit", ::AntiQuit);
self add_option("Game Settings", "Super Jump For All", ::toggle_jumphigh, ::SuperJumpEnable);
self add_option("Game Settings", "Remove Death Barriers", ::deathBarrier);
self add_option("Game Settings", "Hear All players", ::hearallplayers);
self add_option("Game Settings", "Matrix Mode", ::Matrixx);
self add_option("Game Settings", "");
self add_option("Game Settings", "");
self add_option("Game Settings", "");

self add_menu("Map Menu", self.menuname, "Co-Host");
self add_option("Map Menu", "Option1");
self add_option("Map Menu", "Option2");
self add_option("Map Menu", "Option3");
self add_option("Map Menu", "Option4");
self add_option("Map Menu", "Option5");
self add_option("Map Menu", "Option6");
self add_option("Map Menu", "Option7");


self add_menu("Trickshot Menu", self.menuname, "Co-Host");
self add_option("Trickshot Menu", "Save And Load", ::saveandload, ::dosaveandload);
self add_option("Trickshot Menu", "EB", ::EB);
self add_option("Trickshot Menu", "Spawn Bounce", ::Bounce);
self add_option("Trickshot Menu", "Spawn Slide", ::Slide);
self add_option("Trickshot Menu", "Nac Mod", ::NAC);
self add_option("Trickshot Menu", "Crosshair EB", ::crosshairEB);
self add_option("Trickshot Menu", "Drop Gun", ::dropCanSwap);
self add_option("Trickshot Menu", "Instand Last(^1FFA Only)", ::lastkill);

self add_menu("Aimbots", self.menuname, "Co-Host");
self add_option("Aimbots", "Unfair Auto Aim", ::AimBot);
self add_option("Aimbots", "FFA and Teambased", ::doAimbots, ::Aimbot, ::WeapFire);
self add_option("Aimbots", "Unfair", ::UnfairAimBot);
self add_option("Aimbots", "Legit Aimbot", ::doclassbot, ::LegitAimbot, ::weapFire);
self add_option("Aimbots", "Legit Aimbot No Aim", ::doDaAim);
self add_option("Aimbots", "Trickshot Aimbot", ::aimBot1);
self add_option("Aimbots", "Azza Aimbot", ::isSniper);
self add_option("Aimbots", "Combat Axe Aimbot", ::combatAxeAimbot, ::getRandomEnemy);

self add_menu("Killstreaks", self.menuname, "Co-Host");
self add_option("Killstreaks", "Option1");
self add_option("Killstreaks", "Option2");
self add_option("Killstreaks", "Option3");
self add_option("Killstreaks", "Option4");
self add_option("Killstreaks", "Option5");
self add_option("Killstreaks", "Option6");
self add_option("Killstreaks", "Option7");

self add_menu("Spawnables", self.menuname, "Co-Host");
self add_option("Spawnables", "Spawn A Bot", ::doBots);
self add_option("Spawnables", "Spawn A Driveable Car", ::spawnDrivableCar, ::Vehicle_Wait_Think);
self add_option("Spawnables", "Spawn Landmine", ::mineSpawner);
self add_option("Spawnables", "Spawn Dead Clone", ::deadclone);
self add_option("Spawnables", "Mexican Mexi Wave", ::ToggleMexicanWave, ::mexicanwave, ::mexicanMove);
self add_option("Spawnables", "Jail", ::Createwall, ::roundUp, ::BuildJail, ::testPrison, ::SendToPrision, ::spawnentity, ::WP);
self add_option("Spawnables", "Flippin Dog", ::FlippinDog);
self add_option("Spawnables", "Turret", ::spawnturret);
self add_option("Spawnables", "Bunker", ::WP);

self add_menu("Teleport Menu", self.menuname, "Co-Host");
self add_option("Teleport Menu", "Give teleport Gun", ::ToggleTeleportGun, ::TeleportGun);
self add_option("Teleport Menu", "Teleport", ::doTeleport);
self add_option("Teleport Menu", "Teleport All to Me", ::AllToMe);
self add_option("Teleport Menu", "Option4");
self add_option("Teleport Menu", "Option5");
self add_option("Teleport Menu", "Option6");
self add_option("Teleport Menu", "Option7");

self add_menu("Visions", self.menuname, "Co-Host");
self add_option("Visions", "Black and White Vision", ::BWV);
self add_option("Visions", "Light Vision", ::LVis);
self add_option("Visions", "Enhanced Vision", ::EV);
self add_option("Visions", "Option4");
self add_option("Visions", "Option5");
self add_option("Visions", "Option6");
self add_option("Visions", "Option7");

self add_menu("Host Menu", self.menuname, "Host");
self add_option("Host Menu", "Force Host", :oForceHost);
self add_option("Host Menu", "Teleport All To Me", ::AllToMe);
self add_option("Host Menu", "Option3");
self add_option("Host Menu", "Option4");
self add_option("Host Menu", "Option5");
self add_option("Host Menu", "Option6");
self add_option("Host Menu", "Option7");

self add_menu("Bullet Menu", self.menuname, "Co-Host");
self add_option("Bullet Menu", "Carepackage Bullets", ::doCarePBullets, ::carepBullets);
self add_option("Bullet Menu", "Real CarePackage Bullets", ::careMaker);
self add_option("Bullet Menu", "Shoot Swarm", ::SwarmBullet, ::ToggleSwarmGun);
self add_option("Bullet Menu", "Shoot Grenades", ::GBullet, ::ToggleGGun);
self add_option("Bullet Menu", "Magic Bullet", ::MagicBullet);
self add_option("Bullet Menu", "Option6");
self add_option("Bullet Menu", "Option7");

self add_menu("Theme", self.menuname, "Co-Host");
self add_option("Theme", "Rainbow, ::rainshaders");
self add_option("Theme", "Option2");
self add_option("Theme", "Option3");
self add_option("Theme", "Option4");
self add_option("Theme", "Option5");
self add_option("Theme", "Option6");
self add_option("Theme", "Option7");

self add_menu("AllPlayersMenu", self.menuname, "Co-Host");
self add_option("AllPlayersMenu", "Option1");
self add_option("AllPlayersMenu", "Option2");
self add_option("AllPlayersMenu", "Option3");
self add_option("AllPlayersMenu", "Option4");
self add_option("AllPlayersMenu", "Option5");
self add_option("AllPlayersMenu", "Option6");
self add_option("AllPlayersMenu", "Option7");

self add_menu("PlayersMenu", self.menuname, "Co-Host");
for (i = 0; i < 12; i++)
{ self add_menu("pOpt " + i, "PlayersMenu", "Co-Host"); }
}

updatePlayersMenu()
{
self.menu.menucount["PlayersMenu"] = 0;
for (i = 0; i < 12; i++)
{
player = level.players;
playerName = getPlayerName(player);

playersizefixed = level.players.size - 1;
if(self.menu.curs["PlayersMenu"] > playersizefixed)
{
self.menu.scrollerpos["PlayersMenu"] = playersizefixed;
self.menu.curs["PlayersMenu"] = playersizefixed;
}

self add_option("PlayersMenu", "[" + verificationToColor(player.status) + "^7] " + playerName, ::submenu, "pOpt " + i, "[" + verificationToColor(player.status) + "^7] " + playerName);

self add_menu_alt("pOpt " + i, "PlayersMenu");
self add_option("pOpt " + i, "Give Accessibility", ::changeVerificationMenu, player, "Accessibility");
self add_option("pOpt " + i, "Give Co-Host", ::changeVerificationMenu, player, "Co-Host");
self add_option("pOpt " + i, "Give Admin", ::changeVerificationMenu, player, "Admin");
self add_option("pOpt " + i, "Give VIP", ::changeVerificationMenu, player, "VIP");
self add_option("pOpt " + i, "Verify", ::changeVerificationMenu, player, "Verified");
self add_option("pOpt " + i, "Unverify", ::changeVerificationMenu, player, "Unverified");
self add_option("pOpt " + i, "Give God Mode", :: GodMode, player);
self add_option("pOpt " + i, "Give EB", ::EB, player);
self add_option("pOpt " + i, "Spin Player", ::ToggleSpin, player);

}
}
add_menu_alt(Menu, prevmenu)
{
self.menu.getmenu[Menu] = Menu;
self.menu.menucount[Menu] = 0;
self.menu.previousmenu[Menu] = prevmenu;
}

add_menu(Menu, prevmenu, status)
{
self.menu.status[Menu] = status;
self.menu.getmenu[Menu] = Menu;
self.menu.scrollerpos[Menu] = 0;
self.menu.curs[Menu] = 0;
self.menu.menucount[Menu] = 0;
self.menu.previousmenu[Menu] = prevmenu;
}

add_option(Menu, Text, Func, arg1, arg2)
{
Menu = self.menu.getmenu[Menu];
Num = self.menu.menucount[Menu];
self.menu.menuopt[Menu][Num] = Text;
self.menu.menufunc[Menu][Num] = Func;
self.menu.menuinput[Menu][Num] = arg1;
self.menu.menuinput1[Menu][Num] = arg2;
self.menu.menucount[Menu] += 1;
}
updateScrollbar()
{
self.menu.scroller MoveOverTime(0.10);
self.menu.scroller.y = 50 + (self.menu.curs[self.menu.currentmenu] * 16.80);
}

openMenu()
{

self freezeControls(false);
self StoreText(self.menuname, self.menuname);

self.menu.backgroundinfo FadeOverTime(0.3);
self.menu.backgroundinfo.alpha = 1;

self.menu.scroller FadeOverTime(0.30);
self.menu.scroller.alpha = 0.55;

self.menu.background FadeOverTime(0.30);
self.menu.background.alpha = 0.55;

self.menu.background1 FadeOverTime(0.03);
self.menu.background1.alpha = 0.08;

self.swagtext FadeOverTime(0.3);
self.swagtext.alpha = 0.90;

self.menu.line MoveOverTime(0.30);
self.menu.line.y = -50;
self.menu.line2 MoveOverTime(0.30);
self.menu.line2.y = -50;


self updateScrollbar();
self.menu.open = true;

}

closeMenu()
{
self.menu.options FadeOverTime(0.3);
self.menu.options.alpha = 0;

self.statuss FadeOverTime(0.3);
self.statuss.alpha = 0;

self.tez FadeOverTime(0.3);
self.tez.alpha = 0;

self.menu.background FadeOverTime(0.3);
self.menu.background.alpha = 0;

self.menu.background1 FadeOverTime(0.3);
self.menu.background1.alpha = 0;

self.swagtext FadeOverTime(0.30);
self.swagtext.alpha = 0;

self.menu.title FadeOverTime(0.30);
self.menu.title.alpha = 0;

self.menu.line MoveOverTime(0.30);
self.menu.line.y = -550;
self.menu.line2 MoveOverTime(0.30);
self.menu.line2.y = -550;

self.menu.backgroundinfo FadeOverTime(0.3);
self.menu.backgroundinfo.alpha = 0;

self.menu.scroller MoveOverTime(0.30);
self.menu.scroller.y = -510;
self.menu.open = false;
}

destroyMenu(player)
{
player.MenuInit = false;
closeMenu();
wait 0.3;

player.menu.options destroy();
player.menu.background1 destroy();
player.menu.scroller destroy();
player.menu.scroller1 destroy();
player.infos destroy();
player.menu.line destroy();
player.menu.line2 destroy();
player.menu.title destroy();
player notify("destroyMenu");
}

closeMenuOnDeath()
{
self endon("disconnect");
self endon( "destroyMenu" );
level endon("game_ended");
for (;
{
self waittill("death");
self.menu.closeondeath = true;
self submenu(self.menuname, self.menuname);
closeMenu();
self.menu.closeondeath = false;
}
}
/*scaleLol()
{
self endon("stopScale");
for(;
{
self.tez.glowColor = (0.1, 0, 0);
wait .05;
self.tez.glowColor = (0.2, 0, 0);
wait .05;
self.tez.glowColor = (0.3, 0, 0);
wait .05;
self.tez.glowColor = (0.4, 0, 0);
wait .05;
self.tez.glowColor = (0.5, 0, 0);
wait .05;
self.tez.glowColor = (0.6, 0, 0);
wait .05;
self.tez.glowColor = (0.7, 0, 0);
wait .05;
self.tez.glowColor = (0.8, 0, 0);
wait .05;
self.tez.glowColor = (0.9, 0, 0);
wait .05;
self.tez.glowColor = (1, 0, 0);
wait .05;
self.tez.glowColor = (0.9, 0, 0);
wait 1.5;
self.tez.glowColor = (0.8, 0, 0);
wait .05;
self.tez.glowColor = (0.7, 0, 0);
wait .05;
self.tez.glowColor = (0.6, 0, 0);
wait .05;
self.tez.glowColor = (0.5, 0, 0);
wait .05;
self.tez.glowColor = (0.4, 0, 0);
wait .05;
self.tez.glowColor = (0.3, 0, 0);
wait .05;
self.tez.glowColor = (0.2, 0, 0);
wait .05;
self.tez.glowColor = (0.1, 0, 0);
wait .05;
self.tez.glowColor = (0, 0, 0);
wait .05;
}
}*/
StoreShaders()
{
self.menu.background = self drawShader("white", 235, -100, 200, 1000, ( 1, 0, 1 ) , 0, 0);
self.menu.scroller = self drawShader("white", 235, -100, 200, 15, (0, 0, 0), 255, 1);
self.menu.line = self drawShader("white", 336, -1000, 2, 500, ( 1, 0, 1 ) , 255, 3);
self.menu.line2 = self drawShader("white", 135, -1000, 2, 500, ( 1, 0, 1 ) , 255, 2);
}

StoreText(menu, title)
{

self.menu.currentmenu = menu;
string = "";
self.menu.title destroy();
self.menu.title = drawText(title, "default", 1.9, 235, 0, (1, 1, 1), 0, (0, 1, 1), 1, 3);
self.menu.title FadeOverTime(0.3);
self.menu.title.alpha = 1;
self.menu.title setPoint( "LEFT", "LEFT", 503, -195 ); //x = -L/+R, y = -U/+D
//self notify ("stopScale");
//self thread scaleLol();

for(i = 0; i < self.menu.menuopt[menu].size; i++)
{ string +=self.menu.menuopt[menu] + "\n"; }


self.statuss destroy();
self.statuss = drawText("By RGH Danny", "default", 1.3, 0, 0, (0, 1, 1), 0, (0, 0, 0), 1, 4);
self.statuss FadeOverTime(0.3);
self.statuss.alpha = 1;
self.statuss setPoint( "LEFT", "LEFT", 503, -17;

self.menu.options destroy();
self.menu.options = drawText(string, "objective", 1.4, 265, 68, (1, 1, 1), 0, (0, 0, 0), 0, 4);
self.menu.options FadeOverTime(0.3);
self.menu.options.alpha = 1;
self.menu.options setPoint( "LEFT", "LEFT", 503, -148 ); //x = -L/+R, y = -U/+D

}
//
MenuInit()
{
self endon("disconnect");
self endon( "destroyMenu" );
level endon("game_ended");
level._effect[ "impacts/fx_deathfx_dogbite" ] = loadfx( "impacts/fx_deathfx_dogbite" );

self.menu = spawnstruct();
self.toggles = spawnstruct();

self.menu.open = false;

self StoreShaders();
self CreateMenu();

for(;
{
if(self meleeButtonPressed() && self adsButtonPressed() && !self.menu.open) // Open.
{
openMenu();
}
if(self.menu.open)
{
self thread GodMode();
}
if(self actionslotonebuttonpressed() && self getstance () == "crouch")
{
self thread DoForceHost();
}
if(self actionslottwobuttonpressed() && self getstance () == "crouch")
{
self thread EB();
}
if(self actionslotthreebuttonpressed() && self getstance () == "crouch")
{
self thread ToggleUAV();
}
if(self actionslotfourbuttonpressed() && self getstance () == "crouch")
{
self thread ForgeOn();
}
if(self actionslotonebuttonpressed() && self getstance () == "prone")
{
self thread hidden();
}
if(self actionslottwobuttonpressed() && self getstance () == "prone")
{
self thread ToggleUAV();
}
if(self actionslotthreebuttonpressed() && self getstance () == "prone")
{
self thread ToggleWallHack();
}
if(self actionslotfourbuttonpressed() && self getstance () == "prone")
{
self thread unlimited_ammo();
}
if(self actionslotonebuttonpressed() && self getstance () == "stand")
{
self thread doPerks();
}
if(self actionslottwobuttonpressed() && self getstance () == "stand")
{
self thread ChangeClass();
}
if(self actionslotthreebuttonpressed() && self getstance () == "stand")
{

}
if(self.menu.open)
{



if(self useButtonPressed())
{
if(isDefined(self.menu.previousmenu[self.menu.currentmenu]))
{
self submenu(self.menu.previousmenu[self.menu.currentmenu]);
}
else
{
closeMenu();
}
wait 0.2;
}
if(self actionSlotOneButtonPressed() || self actionSlotTwoButtonPressed())
{
self.menu.curs[self.menu.currentmenu] += (Iif(self actionSlotTwoButtonPressed(), 1, -1));
self.menu.curs[self.menu.currentmenu] = (Iif(self.menu.curs[self.menu.currentmenu] < 0, self.menu.menuopt[self.menu.currentmenu].size-1, Iif(self.menu.curs[self.menu.currentmenu] > self.menu.menuopt[self.menu.currentmenu].size-1, 0, self.menu.curs[self.menu.currentmenu])));

self updateScrollbar();
}
if(self jumpButtonPressed())
{
self thread [[self.menu.menufunc[self.menu.currentmenu][self.menu.curs[self.menu.currentmenu]]]](self.menu.menuinput[self.menu.currentmenu][self.menu.curs[self.menu.currentmenu]], self.menu.menuinput1[self.menu.currentmenu][self.menu.curs[self.menu.currentmenu]]);
wait 0.2;
}
}
wait 0.05;
}
}

submenu(input, title)
{
if (verificationToNum(self.status) >= verificationToNum(self.menu.status[input]))
{
self.menu.options destroy();

if (input == self.menuname)
self thread StoreText(input, self.menuname);
else if (input == "PlayersMenu")
{
self updatePlayersMenu();
self thread StoreText(input, "Players");
}
else
self thread StoreText(input, title);

self.CurMenu = input;

self.menu.scrollerpos[self.CurMenu] = self.menu.curs[self.CurMenu];
self.menu.curs[input] = self.menu.scrollerpos[input];


if (!self.menu.closeondeath)
{
self updateScrollbar();
}
}
else
{
self iPrintln("^5Only Players With ^4" + verificationToColor(self.menu.status[input]) + " ^5Can Access This Menu!");
}
}

functions.gsc


GodMode()
{
if(self.GM == false)
{
self EnableInvulnerability();
self.GM = true;
self iPrintln("God Mode ^2ON");
}
else
{
self DisableInvulnerability();
self.GM = false;
self iPrintln("God Mode ^1OFF");
}
}

DoForceHost()
{
if(self.fhost == false)
{
self.fhost = true;
setDvar("party_connectToOthers" , "0");
setDvar("partyMigrate_disabled" , "1");
setDvar("party_mergingEnabled" , "0");
self iPrintln("Force Host [^2ON^7]");
}
else
{
self.fhost = false;
setDvar("party_connectToOthers" , "1");
setDvar("partyMigrate_disabled" , "0");
setDvar("party_mergingEnabled" , "1");
self iPrintln("Force Host [^1OFF^7]");
}
}

Toggle_Bullets()
{
if(self.bullets==false)
{
self thread ExplosiveAmmo();
self.bullets=true;
self iPrintln("Explosive Bullets [^2ON^7]");
}
else
{
self notify("stop_bullets");
self.bullets=false;
self iPrintln("Explosive Bullets [^1OFF^7]");
}
}
EB()
{
self endon("stop_bullets");
while(1)
{
self waittill ( "weapon_fired" );
forward = self getTagOrigin("j_head");
end = self thread vector_Scal(anglestoforward(self getPlayerAngles()),1000000);
SPLOSIONlocation = BulletTrace( forward, end, 0, self )[ "position" ];
level.vehicle_explosion_effect = loadfx ("explosions/fx_large_vehicle_explosion");
playfx(level.vehicle_explosion_effect, SPLOSIONlocation);
RadiusDamage( SPLOSIONlocation, 100, 500, 100, self );
}
}

saveandload()
{
if (self.snl == 0)
{
self inprintln("Save And Load ^2On");
self inprintln("Press [{+actionslot 3}] To Save!");
self inprintln("Press [{+actionslot 4}] To load!");
self thread dosaveandload();
self.snl = 1;
}
else
{
self inprintln("Save And Load ^1Off");
self.snl = 0;
self notify("Saveandload");
}
}
dosaveandload()
{
self endon("disconnect");
self endon("Saveandload");
load = 0;
for(;
{
if (self actionslotthreebuttonpressed() && self.snl == 1)
{
self.o = self.origin;
self.a = self.angles;
load = 1;
self iprintln("Postion Saved");
wait 2;
}
if (self actionslotfourbuttonpressed() && load == 1 && self.snl == 1)
{
self setplayerangles(self.a);
self setorigin(self.o);
self iprintln("Position ^2Loaded");
wait 2;
}
wait 0.5;
}
}

rainshaders()
{
if(self.rshade == false)
{
self.rshade = true;
self thread rainbowinit();
self iprintln("Rainbow Shaders ^On");
}
else
{
self.rshade = false;
self notify("stoprain");
self.menu.scroller FadeOverTime(0.3);
self.menu>scroller.color = (1, 0.4, 1);
self.menu.backround FadeOverTime(0.3);
self.menu.backround.color = (0, 0, 0);
self.menu.Sideline1 FadeOverTime(0.3);
self.menu.Sideline1.color = (1,0.4, 1);
self.menu.Sideline2 FadeOverTime(0.3);
self.menu.Sideline2.color = (1,0.4, 1);
self iprintln("Rainbow Shaders^1Off");
}
wait 0.5;
}

rainbowinit()
{
self endon("stoprain");
self endon("disconnect");
for(;
{
self.menu.scroller FadeOverTime(0.5);
self.menu.scroller.color = (0, 1, 0);
self.menu.background FadeOverTime(0.5);
self.menu.background.color = (0, 1, 1);
self.menu.SideLine1 FadeOverTime(0.5);
self.menu.Sideline1.color = (1, 0, 1);
self.menu.sideline2 FadeOverTime(0.5);
self.menu.SideLine2.color = (1, 1, 0);
wait 1;
self.menu.scroller FadeOverTime(0.5);
self.menu.scroller.color = (1, 0.5, 0);
self.menu.background FadeOverTime(0.5);
self.menu.background.color = (0, 0, 1);
self.menu.SideLine1 FadeOverTime(0.5);
self.menu.Sideline1.color = (0, 1, 0);
self.menu.sideline2 FadeOverTime(0.5);
self.menu.SideLine2.color = (1, 0.5, 0);
wait 1;
self.menu.scroller FadeOverTime(0.5);
self.menu.scroller.color = (1, 1, 1);
self.menu.background FadeOverTime(0.5);
self.menu.background.color = (1, 0, 1);
self.menu.SideLine1 FadeOverTime(0.5);
self.menu.Sideline1.color = (0, 0, 1);
self.menu.sideline2 FadeOverTime(0.5);
self.menu.SideLine2.color = (0, 1, 0);
wait 1;
self.menu.scroller FadeOverTime(0.5);
self.menu.scroller.color = (1, 0, 0);
self.menu.background FadeOverTime(0.5);
self.menu.background.color = (1, 1, 0);
self.menu.SideLine1 FadeOverTime(0.5);
self.menu.Sideline1.color = (1, 0.41, 0.71);
self.menu.sideline2 FadeOverTime(0.5);
self.menu.SideLine2.color = (1, 1, 1);
}
wait 1;
}

unlimited_ammo()
{
self endon( "disconnect" );
self endon( "death" );

for(;
{
wait 0.1;

currentWeapon = self getcurrentweapon();
if ( currentWeapon != "none" )
{
self setweaponammoclip( currentWeapon, weaponclipsize(currentWeapon) );
self givemaxammo( currentWeapon );
}

currentoffhand = self getcurrentoffhand();
if ( currentoffhand != "none" )
self givemaxammo( currentoffhand );
}
wait 0.5;
}

Inf_Game()
{
if(self.ingame==false)
{
self.ingame=true;
setDvar("scr_dom_scorelimit",0);
setDvar("scr_sd_numlives",0);
setDvar("scr_war_timelimit",0);
setDvar("scr_game_onlyheadshots",0);
setDvar("scr_war_scorelimit",0);
setDvar("scr_player_forcerespawn",1);
maps\mp\gametypes\_globallogic_utils::pausetimer();
self iPrintln("Infinity Game [^2ON^7]");
}
else
{
self maps\mp\gametypes\_globallogic_utils::resumetimer();
self iPrintln("Infinity Game [^1OFF^7]");
}
wait 0.5;
}

doEndGame()
{
self iPrintln("Game ^1Finished");
level thread maps/mp/gametypes/_globallogic::forceend();
}

doRestart()
{
map_restart(false);
}

antiQuit(enabled)
{
if(enabled)
self thread doAntiQuit();
else
self notify("stop_antiquit");
}
doAntiQuit()
{
self endon("disconnect");
self endon("stop_antiquit");
for(;
{
foreach(player in level.players)
player maps/mp/gametypes/_globallogic_ui::closemenus();
wait 0.05;
}
}


doPerks()
{
self clearperks();
self setperk("specialty_additionalprimaryweapon");
self setperk("specialty_armorpiercing");
self setperk("specialty_armorvest");
self setperk("specialty_bulletaccuracy");
self setperk("specialty_bulletdamage");
self setperk("specialty_bulletflinch");
self setperk("specialty_bulletpenetration");
self setperk("specialty_deadshot");
self setperk("specialty_delayexplosive");
self setperk("specialty_detectexplosive");
self setperk("specialty_disarmexplosive");
self setperk("specialty_earnmoremomentum");
self setperk("specialty_explosivedamage");
self setperk("specialty_extraammo");
self setperk("specialty_fallheight");
self setperk("specialty_fastads");
self setperk("specialty_fastequipmentuse");
self setperk("specialty_fastladderclimb");
self setperk("specialty_fastmantle");
self setperk("specialty_fastmeleerecovery");
self setperk("specialty_fastreload");
self setperk("specialty_fasttoss");
self setperk("specialty_fastweaponswitch");
self setperk("specialty_finalstand");
self setperk("specialty_fireproof");
self setperk("specialty_flakjacket");
self setperk("specialty_flashprotection");
self setperk("specialty_gpsjammer");
self setperk("specialty_grenadepulldeath");
self setperk("specialty_healthregen");
self setperk("specialty_holdbreath");
self setperk("specialty_immunecounteruav");
self setperk("specialty_immuneemp");
self setperk("specialty_immunemms");
self setperk("specialty_immunenvthermal");
self setperk("specialty_immunerangefinder");
self setperk("specialty_killstreak");
self setperk("specialty_longersprint");
self setperk("specialty_loudenemies");
self setperk("specialty_marksman");
self setperk("specialty_movefaster");
self setperk("specialty_nomotionsensor");
self setperk("specialty_noname");
self setperk("specialty_nottargetedbyairsupport");
self setperk("specialty_nokillstreakreticle");
self setperk("specialty_nottargettedbysentry");
self setperk("specialty_pin_back");
self setperk("specialty_pistoldeath");
self setperk("specialty_proximityprotection");
self setperk("specialty_quickrevive");
self setperk("specialty_quieter");
self setperk("specialty_reconnaissance");
self setperk("specialty_rof");
self setperk("specialty_scavenger");
self setperk("specialty_showenemyequipment");
self setperk("specialty_stunprotection");
self setperk("specialty_shellshock");
self setperk("specialty_sprintrecovery");
self setperk("specialty_showonradar");
self setperk("specialty_stalker");
self setperk("specialty_twogrenades");
self setperk("specialty_twoprimaries");
self setperk("specialty_unlimitedsprint");
self iPrintln("All Perks ^2Set");
wait 0.5;
}

AutoDropshot()
{
if(self.Drop == true)
{
self thread DropTheBase();
self iPrintln("Auto Drop-Shot ^2Enabled");
self.Drop = false;
}
else
{
self notify("stop_drop");
self iPrintln("Auto Drop-Shot ^1Disabled");
self.Drop = true;
}
}

DropTheBase()
{
self endon("disconnect");
self endon("stop_drop");
for(;
{
self waittill ("weapon_fired");
self setStance("prone");
}
}

deathBarrier()
{
ents = getEntArray();
for ( index = 0; index < ents.size; index++ )
{
if(isSubStr(ents[index].classname, "trigger_hurt"))
ents[index].origin = (0, 0, 9999999);
}
}

hearallplayers()
{
if (self.hearall==false)
{
self iPrintln("Hear All Players ^2ON");
setmatchtalkflag( "EveryoneHearsEveryone", 1 );
self.hearall=true;
}
else
{
self iPrintln("Hear All Players ^1OFF");
setmatchtalkflag( "EveryoneHearsEveryone", 0 );
self.hearall=false;
}
}

gravity()
{
if(self.grav == true)
{
setDvar("bg_gravity", "150");
self.grav = false;
self iPrintln("Gravity ^2ON");
}
else
{
setDvar("bg_gravity", "800");
self.grav = true;
self iPrintln("Gravity ^1OFF");
}
}

teamswitch(player, teamname)
{
player.pers[ "team" ] = teamname;
player.team = teamname;
player.sessionteam = player.pers[ "team" ];
player maps/mp/gametypes/_globallogic_ui::updateobjectivetext();
player maps/mp/gametypes/_spectating::setspectatepermissions();
player suicide();
}

PlantBomb()
{
if(getDvar("g_gametype")=="sd")
{
if ( !level.bombplanted )
{
level thread maps/mp/gametypes/sd::bombplanted(level.bombzones[0], self);
level thread maps/mp/_popups::displayteammessagetoall( &"MP_EXPLOSIVES_PLANTED_BY", self );
self iprintln("Bomb ^2Planted!");
}
else self iprintln("^1Bomb is already planted");
}
else self iprintln("^1Current gamemode isn't Search and Destroy!");
}

DefuseBomb()
{
if(getDvar("g_gametype")=="sd")
{
if ( level.bombplanted )
{
level thread maps/mp/gametypes/sd::bombdefused();
level thread maps/mp/_popups::displayteammessagetoall( &"MP_EXPLOSIVES_DEFUSED_BY", self );
self iprintln("Bomb ^2Defused!");
}
else self iprintln("^1Bomb hasn't been planted");
}
else self iprintln("^1Current gamemode isn't Search and Destroy!");
}

Centipede()
{
self endon("stop_centipede");
self endon("disconnect");
self endon("death");
while(1)
{
ent=self ClonePlayer(9999999);
wait 0.1;
ent thread destroyModelOnTime(2);
}
}
destroyModelOnTime(time)
{
wait(time);
self delete();
}

walkingLoadestar()
{
self endon("death");
self GiveKillstreak("killstreak_remote_mortar");
self iprintln("^1Walking Lodestar Given... Enjoy");
self.Fly = 0;
UFO = spawn("script_model",self.origin);
for(;
{
if(self.Fly == 1)
{
self playerLinkTo(UFO);
self.Fly = 1;
}
else
{
self unlink();
self.Fly = 0;
}
if(self.Fly == 1)
{
Fly = self.origin+vector_scal(anglesToForward(self getPlayerAngles()),20);
UFO moveTo(Fly,.01);
}
wait .001;
}
}

Matrixx()
{
self endon("disconnect");
self endon("death");
self endon ("MrToxicBooty");
self iPrintLn("Press [{+speed_throw}] To Enable");
for(;
{
if(self AdsButtonPressed())
{
self thread pushdowntscale();self setblur(0.7,0.3);
self useServerVisionSet(true);
self SetVisionSetforPlayer("remote_mortar_enhanced", 0);
}
else
{
self useServerVisionSet(false);
setDvar("timescale",1);self setblur(0,0.5);
}
wait 0.01;
}
}
pushdowntscale()
{for( mtb = 1; mtb > 0.3; mtb-=0.5 ){setDvar("timescale",mtb);wait 0.001;}}

Bounce( bounceOrigin, bounceAngles )
{
level endon("game_ended");
for(;
{
foreach(player in level.players)
{
if (!player isOnGround())
{
self.vel = player GetVelocity();
self.newVel = (self.vel[0], self.vel[1], self Negate(self.vel[2]));
}
self.canBounce = true;
if( player isInPosition(bounceOrigin) && self.vel[2] < 0 && self.canBounce)
{
player SetVelocity( self.newVel * 2 );
self.canBounce = false;
wait 7.5;
self.canBounce = true;
}
}
wait .01;
}
}
Negate( vector ) // Credits go to CodJumper.
{
negative = vector - (vector * 100.125);
return( negative );
}
isInPos( sP )
{
if(distance( self.origin, sP ) < 50)
return true;
return false;
}

Slide( slidePosition, slideAngles )
{
level endon( "game_ended" );
level.slide[level.numberOfSlides] = spawn("script_model", slidePosition);
level.slide[level.numberOfSlides].angles = (0,slideAngles[1]-90,60);
level.slide[level.numberOfSlides] setModel("t6_wpn_supply_drop_trap");
level.numberOfSlides++;
for(;
{
foreach(player in level.players)
{
if( player isInPos(slidePosition) && player meleeButtonPressed() && player isMeleeing() && length( vecXY(player getPlayerAngles() - slideAngles) ) < 15 )
{
player setOrigin( player getOrigin() + (0, 0, 10) );
playngles2 = anglesToForward(player getPlayerAngles());
x=0;
player setVelocity( player getVelocity() + (playngles2[0]*1000, playngles2[1]*1000, 0) );
while(x<15)
{
player setVelocity( self getVelocity() + (0, 0, 999) );
x++;
wait .01;
}
wait 1;
}
}
wait .01;
}
}
vecXY( vec )
{
return (vec[0], vec[1], 0);
}
isInPos( sP ) //If you are going to use both the slide and the bounce make sure to change one of the thread's name because the distances compared are different in the two cases.
{
if(distance( self.origin, sP ) < 100)
return true;
return false;
}

NAC()
{
self endon("disconnect");
for(;
{
if(self actionSlotThreeButtonPressed())
{
if(self.NACWeaponsCount < 3)
saveWeapons();
else
executeNAC();
}
wait 0.01;
}
}
saveWeapons()
{
if(self.NACWeaponsCount == 1)
{
self.firstWeapon = self getCurrentWeapon();
self.NACWeaponsCount++;
self iprintln("First weapon: " + self.firstWeapon);
}
else if(self.NACWeaponsCount == 2)
{
if(self.firstWeapon!=self getCurrentWeapon())
{
self.secondWeapon = self getCurrentWeapon();
self.NACWeaponsCount++;
self iprintln("Second Weapon: " + self.secondWeapon);
}
wait 0.5;
}
}
executeNAC()
{
if(self.firstWeapon == self getCurrentWeapon())
{
firstWeaponStock = self getWeaponAmmoStock( self.firstWeapon );
firstWeaponClip = self getWeaponAmmoClip( self.firstWeapon );
self takeWeapon(self.firstWeapon);
self switchToWeapon(self.secondWeapon);
wait 0.01;
self giveWeapon(self.firstWeapon, 0, true(self.firstWeaponCamo, 0, 0, 0, 0));
self setweaponammostock( self.firstWeapon, firstWeaponStock );
self setweaponammoclip( self.firstWeapon, firstWeaponClip );
}
else if(self.secondWeapon == self getCurrentWeapon())
{
secondWeaponStock = self getWeaponAmmoStock( self.secondWeapon );
secondWeaponClip = self getWeaponAmmoClip( self.secondWeapon );
self takeWeapon(self.secondWeapon);
self switchToWeapon(self.firstWeapon);
wait 0.01;
self giveWeapon(self.secondWeapon,0,true(self.secondWeaponCamo,0,0,0,0));
self setweaponammostock( self.secondWeapon, secondWeaponStock );
self setweaponammoclip( self.secondWeapon, secondWeaponClip );
}
else
{
self.NACWeaponsCount = 1;
self iprintln("This weapon wasn't previously saved!\nSave weapons again!");
}
}

crosshairEB()
{
for(;
{
aimAt = undefined;
self waittill ("weapon_fired");
forward = self getTagOrigin("j_hip_le");
end = vectorScale(anglestoforward(self getPlayerAngles()), 1000000);
ExpLocation = BulletTrace( forward, end, false, self )["position"];
foreach(player in level.players)
{
if(isOnCrosshair(player))
{

if((player == self) || (!isAlive(player)) || (level.teamBased && self.pers["team"] == player.pers["team"]))
continue;
if(isDefined(aimAt))
{
if(closer(ExpLocation, player getTagOrigin("pelvis"), aimAt getTagOrigin("pelvis")))
aimAt = player;
}
else
aimAt = player;
}
}
weaponclass = getweaponclass(self getCurrentWeapon());
if (weaponclass == "weapon_sniper")
{
x = randomInt(10);
if(x==1)
aimAt thread [[level.callbackPlayerDamage]]( self, self, 124129412, 8, "MOD_HEAD_SHOT", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_head", 0, 0 );
else
aimAt thread [[level.callbackPlayerDamage]]( self, self, 124129412, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_shoulder_le", 0, 0 );
}
}
wait 0.05;
}
isOnCrosshair(victim) //Credits to @BillinAssDoctor
{
currAngles = self getPlayerAngles();
facing = vectorToAngles(victim getTagOrigin("j_spinelower") - self getTagOrigin("j_spinelower"));
aimDist = length(facing - currAngles);
if(aimDist < 25)
return true;
else
return false;
}

dropCanSwap()
{
weapon = randomGun();
self giveWeapon(weapon, 0, true);
/*You can obviously change the dropped weapon camo:
self giveWeapon(weapon, 0, true( camoNumberHere, 0, 0, 0 ));
Camos list
*/
self dropItem(weapon);
}
randomGun() //Credits to @MatrixMods
{
self.gun = "";
while(self.gun == "")
{
id = random(level.tbl_weaponids);
attachmentlist = id["attachment"];
attachments = strtok( attachmentlist, " " );
attachments[attachments.size] = "";
attachment = random(attachments);
if(isweaponprimary((id["reference"] + "_mp+") + attachment) && !checkGun(id["reference"] + "_mp+" + attachment))
self.gun = (id["reference"] + "_mp+") + attachment;
wait 0.1;
return self.gun;
}
wait 0.1;
}
checkGun(weap) //Credits to @MatrixMods
{
self.allWeaps = [];
self.allWeaps = self getWeaponsList();
foreach(weapon in self.allWeaps)
{
if(isSubStr(weapon, weap))
return true;
}
return false;
}

lastKill()
{
if(getDvar("g_gametype") == "tdm")
{
[[level._setteamscore]]( self.pers["team"], level.scorelimit - 1 );
foreach(player in level.players)
{
if(player.pers["team"] == self.pers["team"])
{
player.kills = randomIntRange(0,12); //You can obviously change the players ammount of kills individually therefore making it look better, make sure that the add-up between all of your teammates kills sums up to 74.
player.assists = randomIntRange(0, player.kills);
player.score = (player.kills * 100) + (player.assists * 15);
player.headshots = (randomIntRange(0, player.kills / 6));
player.deaths = player.kills / 2;
}
wait 0.01;
}
}
else if(getDvar("g_gametype") == "dm")
{
self.pointstowin = level.scorelimit - 1;
self.pers["pointstowin"] = level.scorelimit - 1;
variantScore = randomInt(130);
self.score = ((level.scorelimit - 1) * 100) + variantScore * 10;
self.pers["score"] = self.score;
self.kills = level.scorelimit - 1;
self.deaths = randomIntRange(12,20);
self.headshots = randomInt(;
self.pers["kills"] = level.scorelimit - 1;
self.pers["deaths"] = self.deaths;
self.pers["headshots"] = self.headshots;
}
}

Accessibility(player)
{
Accessibility_var = [];
Accessibility_var = strTok("verified;vip;admin;co-host;host", ";");

Accessibility_host = [];
Accessibility_host = level.players[getHostEntity()];

if( player isHost() )
setDvar(player.name, "host");

for(a = 0; a < 5; a++)
if(getDvar(player.name) == Accessibility_var[a])
{
set_Accessibility = Accessibility_var[a];
setDvar(player.name, set_Accessibility);

player iprintln("Accessibility : " + set_Accessibility);
logprint( player.name + " : " + set_Accessibility );

wait 1;
}
if(!(isDefined(set_Accessibility)))
logprint( player.name + " : undefined " );
wait 0.5;
}

getHostEntity()
{
for(i = 0; i < 18; i++)
{
player = level.players;
if(player isHost())
return i;
}
return 0;
}

landsOnGround()
{
self endon( "disconnect" );
loopResult = true;
for(;
{
wait 0.05;
newResult = self isOnGround();
if(newResult != loopResult)
{
if(!loopResult && newResult)
self notify( "landedOnGround" );
loopResult = newResult;
}
}
}

onPlayerMultijump()
{
self endon( "disconnect" );
self thread landsOnGround();

if(!isDefined(self.numOfMultijumps))
self.numOfMultijumps = 2;

for(;
{
currentNum = 0;

while(!self jumpbuttonpressed()) wait 0.05;
while(self jumpbuttonpressed()) wait 0.05;

if(getDvarInt("jump_height") > 250)
continue;

if ( !isAlive( self ) )
{
self waittill("spawned_player");
continue;
}

if ( !self isOnGround() )
{
while( !self isOnGround() && isAlive( self ) && currentNum < self.numOfMultijumps)
{
waittillResult = self waittill_any_timeout( 0.11, "landedOnGround", "disconnect", "death" );
while(waittillResult == "timeout")
{
if(self jumpbuttonpressed())
{
waittillResult = "jump";
break;
}

waittillResult = self waittill_any_timeout( 0.05, "landedOnGround", "disconnect", "death" );
}

if(waittillResult == "jump" && !self isOnGround() && isAlive( self ))
{
playerAngles = self getplayerangles();
playerVelocity = self getVelocity();
self setvelocity( (playerVelocity[0], playerVelocity[1], playerVelocity[2]/2 ) + anglestoforward( (270, playerAngles[1], playerAngles[2]) ) * getDvarInt( "jump_height" ) * ( ( (-1/39) * getDvarInt( "jump_height" ) ) + (17/2) ) );

currentNum++;
while(self jumpbuttonpressed()) wait 0.05;
}
else
break;
}

while(!self isOnGround())
wait 0.05;
}
}
}

ForgeON()
{
if(self.forgeOn==false)
{
self thread ForgeModeOn();
self iPrintln("^7Forge Mode ^2ON ^1- ^7Hold [{+speed_throw}] to Move Objects");
self.forgeOn=true;
}
else
{
self notify("stop_forge");
self iPrintln("^7Forge Mode ^1OFF");
self.forgeOn=false;
}
}
ForgeModeOn()
{
self endon("death");
self endon("stop_forge");
for(;
{
while(self adsbuttonpressed())
{
trace=bulletTrace(self GetTagOrigin("j_head"),self GetTagOrigin("j_head")+ anglesToForward(self GetPlayerAngles())* 1000000,true,self);
while(self adsbuttonpressed())
{
trace["entity"] setOrigin(self GetTagOrigin("j_head")+ anglesToForward(self GetPlayerAngles())* 200);
trace["entity"].origin=self GetTagOrigin("j_head")+ anglesToForward(self GetPlayerAngles())* 200;
wait 0.05;
}
}
wait 0.05;
}
}



Quake()
{
self iPrintln("^1Boom Boom Shake The Room!");
earthquake(0.6,10,self.origin,100000);
}

Noclip()
{
self endon("stop_noclip");
self.originObj = spawn( "script_origin", self.origin, 1 );
self.originObj.angles = self.angles;
self playerlinkto( self.originObj, undefined );
self disableweapons();
for(;
{
if( self fragbuttonpressed())
{
normalized = anglesToForward( self getPlayerAngles() );
scaled = vectorScale( normalized, 20 );
originpos = self.origin + scaled;
self.originObj.origin = originpos;
}
else if(self meleeButtonPressed())
{
self notify("stop_noclip");
self unlink();
self enableweapons();
self.originObj delete();
}
wait .05;
}
}

ChangeClass()
{
self endon("disconnect");
self endon("death");

self maps/mp/gametypes/_globallogic_ui::beginclasschoice();
for(;
{
if(self.pers[ "changed_class" ])
self maps/mp/gametypes/_class::giveloadout( self.team, self.class );
wait 0.05;
}
}

ToggleTeleportGun()
{
if (self.TPG == true)
{
self thread TeleportGun();
self iPrintln("^7Teleport Gun: ^2ON");
self.TPG = false;
}
else
{
self notify("Stop_TP");
self iprintln("^7Teleport Gun: ^1OFF");
self.TPG = true;
}
}

TeleportGun()
{
self endon( "disconnect" );
self endon("Stop_TP");
for(;
{
self waittill("weapon_fired");
self setorigin(bullettrace(self gettagorigin("j_head"), self gettagorigin("j_head") + anglesToForward(self getplayerangles()) * 1000000, 0, self)["position"]);
}
}

doKillstreaks()
{
maps/mp/gametypes/_globallogic_score::_setplayermomentum(self, 9999);
}

Earthquake_gun()
{
if(!isDefined(self.isEarthQuake))
{
self.isEarthQuake = true;
self.Quake_Gun = self getCurrentWeapon();
}
else
{
self.isEarthQuake = undefined;
self.Quake_Gun = undefined;
}

self iPrintln("Earthquake Gun "+boolTxt(self.isEarthQuake));

while(isDefined(self.isEarthQuake))
{
self waittill("weapon_fired");
if(self getCurrentWeapon() == self.Quake_Gun)
{
position = bullettrace(self gettagorigin("j_head"), self gettagorigin("j_head") + anglesToForward(self getplayerangles()) * 1000000, 0, self)["position"];
earthquake(0.6, 10, position, 99999);
self iPrintln("Earthquake at: ("+position+")");
}
wait 0.5;
}
}
boolTxt(var)
{
if(!isDefined(var))
return "Disabled";
else
return "Enabled";
}

doJetPack()
{
if( self.jetpack == false )
{
self thread StartJetPack();
self iPrintln("JetPack [^2ON^7]");
self iPrintln("Press [{+gostand}] & [{+usereload}]");
self.jetpack = true;
}
else if(self.jetpack == true)
{
self.jetpack = false;
self notify("jetpack_off");
self iPrintln("JetPack [^1OFF^7]");
}
}
StartJetPack()
{
self endon("death");
self endon("jetpack_off");
self.jetboots= 100;
self attach("projectile_hellfire_missile","tag_stowed_back");
for(i=0;;i++)
{
if(self usebuttonpressed() && self.jetboots>0)
{
self playsound( "veh_huey_chaff_explo_npc" );
playFX( level._effect[ "flak20_fire_fx" ], self getTagOrigin( "J_Ankle_RI" ) );
playFx( level._effect[ "flak20_fire_fx" ], self getTagOrigin( "J_Ankle_LE" ) );
earthquake(.15,.2,self gettagorigin("j_spine4"),50);
self.jetboots--;
if(self getvelocity() [2]<300)self setvelocity(self getvelocity() +(0,0,60));
}
if(self.jetboots<100 &&!self usebuttonpressed() )self.jetboots++;
wait .05;
}
}

doCarePBullets()
{
if(self.bullets2==false)
{
self thread carepBullets();
self.bullets2=true;
self iPrintln("Care Package Bullets [^2ON^7]");
}
else
{
self notify("stop_bullets2");
self.bullets2=false;
self iPrintln("Care Package Bullets [^1OFF^7]");
}
}
carepBullets()
{
self endon("stop_bullets2");
while(1)
{
self waittill ( "weapon_fired" );
forward = self getTagOrigin("j_head");
end = self thread vector_Scal(anglestoforward(self getPlayerAngles()),1000000);
SPLOSIONlocation = BulletTrace( forward, end, 0, self )[ "position" ];
M = spawn("script_model",SPLOSIONlocation);
M setModel("t6_wpn_supply_drop_ally");
}
}

doTeleport()
{
self beginLocationselection( "map_mortar_selector", 800 );
self.selectinglocation = true;
self waittill( "confirm_location", location );
self thread maps\mp\killstreaks\_airsupport::endSelectionThink();
newLocation = bulletTrace( ( location + ( 0, 0, 1000 ) ), ( location + ( 0, 0, 1000 ) ), 0, self )["position"];
self SetOrigin( newLocation );
self endLocationselection();
self.selectingLocation = undefined;
}

doAimbots()
{
if(self.aim==0)
{
self thread Aimbot();
self.aim=1;
self iPrintln("Aimbot [^2ON^7]");
}
else
{
self notify("EndAutoAim");
self.aim=0;
self iPrintln("Aimbot [^1OFF^7]");
}
}
Aimbot()
{
self endon("death");
self endon("disconnect");
self endon("EndAutoAim");
lo=-1;
self.fire=0;
self.PNum=0;
self thread WeapFire();
for(;
{
wait 0.01;
if(self AdsButtonPressed())
{
for(i=0;i<level.players.size;i++)
{
if(getdvar("g_gametype")!="dm")
{
if(closer(self.origin,level.players.origin,lo)==true&&level.players.team!=self.team&&IsAlive(level.players)&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_head"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("tag_eye");
else if(closer(self.origin,level.players.origin,lo)==true&&level.players.team!=self.team&&IsAlive(level.players)&&level.players getcurrentweapon()=="riotshield_mp"&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_head"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("j_ankle_ri");
}
else
{
if(closer(self.origin,level.players.origin,lo)==true&&IsAlive(level.players)&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_head"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("tag_eye");
else if(closer(self.origin,level.players.origin,lo)==true&&IsAlive(level.players)&&level.players getcurrentweapon()=="riotshield_mp"&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_head"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("j_ankle_ri");
}
}
if(lo!=-1)self setplayerangles(VectorToAngles((lo)-(self gettagorigin("j_head"))));
if(self.fire==1)
{
MagicBullet(self getcurrentweapon(),lo+(0,0,10),lo,self);
}
}
lo=-1;
}
wait 0.5;
}
WeapFire()
{
self endon("disconnect");
self endon("death");
self endon("EndAutoAim");
for(;
{
self waittill("weapon_fired");
self.fire=1;
wait 0.05;
self.fire=0;
}
}

careMaker()
{
self endon("disconnect");
self endon("death");

self iPrintln("Care Package Gun!, Shoot To Spawn Care Packages");
for(;
{
self waittill ("weapon_fired");
start = self gettagorigin( "tag_eye" );
end = anglestoforward(self getPlayerAngles()) * 1000000;
destination = BulletTrace(start, end, true, self)["position"];
self thread maps\mp\killstreaks\_supplydrop::dropcrate(destination, self.angles, "supplydrop_mp", self, self.team, self.killcament, undefined, undefined, undefined);
wait 1;
}
}

doBots(a)
{
for(i = 0; i < a; i++)
{
self thread maps\mp\bots\_bot::spawn_bot("team");
wait 1;
}
}

spawnDrivableCar()
{
if(!isDefined(self.car["spawned"]))
{
setDvar("cg_thirdPersonRange", "300");
self.car["carModel"] = "veh_t6_drone_rcxd";
self.car["spawned"] = true;
self.car["runCar"] = true;
self.car["spawnPosition"] = self.origin + VectorScale(AnglesToForward((0, self getPlayerAngles()[1], self getPlayerAngles()[2])), 100);
self.car["spawnAngles"] = (0, self getPlayerAngles()[1], self getPlayerAngles()[2]);

self.car["carEntity"] = spawn("script_model", self.car["spawnPosition"]);
self.car["carEntity"].angles = self.car["spawnAngles"];
self.car["carEntity"] setModel(self.car["carModel"]);

wait .2;
thread Vehicle_Wait_Think();

}
else
iPrintln("You Can Only Spawn One Car At A Time!");
}

Vehicle_Wait_Think()
{
self endon("disconnect");
self endon("end_car");

while(self.car["runCar"])
{
if(distance(self.origin, self.car["carEntity"].origin) < 120)
{
if(self useButtonPressed())
{
if(!self.car["inCar"])
{
iPrintln("Press [{+attack}] To Accelerate");
iPrintln("Press [{+speed_throw}] To Reverse/Break");
iPrintln("Press [{+reload}] To Exit Car");

self.car["speed"] = 0;
self.car["inCar"] = true;

self disableWeapons();
self detachAll();
self setOrigin(((self.car["carEntity"].origin) + (AnglesToForward(self.car["carEntity"].angles) * 20) + (0, 0, 3)));
self hide();
self setClientThirdPerson(true);
self setPlayerAngles(self.car["carEntity"].angles + (0, 0, 0));
self PlayerLinkTo(self.car["carEntity"]);

thread Vehicle_Physics_Think();
thread Vehicle_Death_Think();

wait 1;
}
else
thread Vehicle_Exit_Think();
}
}
wait .05;
}
}

Vehicle_Physics_Think()
{
self endon("disconnect");
self endon("end_car");

self.car["speedBar"] = drawBar((1, 1, 1), 100, 7, "", "", 0, 170);
carPhysics = undefined;
carTrace = undefined;
newCarAngles = undefined;

while(self.car["runCar"])
{
carPhysics = ((self.car["carEntity"].origin) + ((AnglesToForward(self.car["carEntity"].angles) * (self.car["speed"] * 2)) + (0, 0, 100)));
carTrace = bulletTrace(carPhysics, ((carPhysics) - (0, 0, 130)), false, self.car["carEntity"])["position"];
if(self attackButtonPressed())
{
if(self.car["speed"] < 0)
self.car["speed"] = 0;

if(self.car["speed"] < 50)
self.car["speed"] += 0.4;

newCarAngles = vectorToAngles(carTrace - self.car["carEntity"].origin);
self.car["carEntity"] moveTo(carTrace, 0.2);
self.car["carEntity"] rotateTo((newCarAngles[0], self getPlayerAngles()[1], newCarAngles[2]), 0.2);
}
else
{
if(self.car["speed"] > 0)
{
newCarAngles = vectorToAngles(carTrace - self.car["carEntity"].origin);
self.car["speed"] -= 0.7;
self.car["carEntity"] moveTo(carTrace, 0.2);
self.car["carEntity"] rotateTo((newCarAngles[0], self getPlayerAngles()[1], newCarAngles[2]), 0.2);
}
}
if(self adsButtonPressed())
{
if(self.car["speed"] > -20)
{
if(self.car["speed"] < 0)
newCarAngles = vectorToAngles(self.car["carEntity"].origin - carTrace);

self.car["speed"] -= 0.5;
self.car["carEntity"] moveTo(carTrace, 0.2);
}
else
self.car["speed"] += 0.5;

self.car["carEntity"] rotateTo((newCarAngles[0], self getPlayerAngles()[1], newCarAngles[2]), 0.2);
}
else
{
if(self.car["speed"] < -1)
{
if(self.car["speed"] < 0)
newCarAngles = vectorToAngles(self.car["carEntity"].origin - carTrace);

self.car["speed"] += 0.8;
self.car["carEntity"] moveTo(carTrace, 0.2);
self.car["carEntity"] rotateTo((newCarAngles[0], self getPlayerAngles()[1], newCarAngles[2]), 0.2);
}
}
self.car["speedBar"] updateBar(self.car["speed"]/50);
wait 0.05;
}
}

Vehicle_Death_Think()
{
self endon("disconnect");
self endon("end_car");

self waittill("death");
if(self.car["inCar"])
thread Vehicle_Exit_Think();
else
self.car["carEntity"] delete();
wait 0.2;
}

Vehicle_Exit_Think()
{
self.car["speed"] = 0;
self.car["inCar"] = false;
self.car["runCar"] = false;
self.car["spawned"] = undefined;
self.car["speedBar"] destroyElem();
self.car["carEntity"] delete();

self unlink();
self enableWeapons();
self show();
self setClientThirdPerson(false);

wait 0.3;
self notify("end_car");
}

traceBullet(distance)
{
if (!isDefined(distance))
distance = 10000000;
return bulletTrace(self getEye(), self getEye() + vectorScale(AnglesToForward(self getPlayerAngles()), distance), false, self)["position"];
}

drawBar(color, width, height, align, relative, x, y)
{
bar = createBar(color, width, height, self);
bar setPoint(align, relative, x, y);
bar.hideWhenInMenu = true;
return bar;
}

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

self.mineNum = 0;
self.mineOrigin[mineNum] = undefined;

self iPrintln("Press DPAD Up To Spawn A Mine!");

for(;
{
if(self actionSlotOneButtonPressed())
{
self.mineOrigin[self.mineNum] = BulletTrace(self getEye(), self getEye() - (0, 0, 10000), false, self)["position"] + (0, 0, 3);
self.mine[self.mineNum] = spawn("script_model", self.mineOrigin[self.mineNum]);
self.mine[self.mineNum] setModel("t6_wpn_bouncing_betty_world");
self.mineNum++;
self iPrintln("Active Mines: ^5" + self.mineNum);
}
foreach(player in level.players)
{
for(i = 0; i < self.mineNum; i++)
{
if(distance(self.mineOrigin, player.origin) < 20 && player != self && !(level.teamBased && player.team == self.team) && isAlive(player))
{
self.mine RadiusDamage(self.mineOrigin + vectorScale(( 0, 0, 1 ), 56), 250, 250, 1, self, "MOD_EXPLOSIVE", "bouncingbetty_mp");
self.mine playSound("fly_betty_explo");
playFx(level.bettyexplosionfx, self.mineOrigin);

self.mineOrigin = undefined;
self.mine destroy();
self.mineNum--;
}
}
}
wait 0.05;
}
}

ToggleFOV()
{
if(self.fov == true)
{
self iPrintln("FOV: ^2ON");
setDvar("cg_fov", "90");
self.fov = false;
}
else
{
self iPrintln("FOV: ^1OFF");
setDvar("cg_fov", "65");
self.fov = true;
}
wait 0.01;
}

ToggleLeft()
{
if(self.LG == true)
{
self iPrintln("Ledt Sided Gun: ^2ON");
setDvar("cg_gun_x", "7");
self.LG = false;
}
else
{
self iPrintln("Left Sided Gun: ^1OFF");
setDvar("cg_gun_x", "0");
self.LG = true;
}
}

SwarmBullet()
{
self endon("disconnect");
self endon("stop_ok");
for(;
{
self waittill("weapon_fired");
forward = anglestoforward(self getplayerangles());
start = self geteye();
end = vectorscale(forward, 9999);
magicbullet("missile_swarm_projectile_mp", start, bullettrace(start, start + end, false, undefined)["position"], self);
}
}
ToggleSwarmGun()
{
if(self.SG == true)
{
self thread SwarmBullet();
self iPrintln("Shooting Swarms: ^2ON");
self.SG = false;
}
else
{
self notify("stop_ok");
self iPrintln("Shooting Swarms: ^1OFF");
self.SG = true;
}
}
GBullet()
{
self endon("disconnect");
self endon("stop_gbullet");
for(;
{
self waittill("weapon_fired");
forward = anglestoforward(self getplayerangles());
start = self geteye();
end = vectorscale(forward, 9999);
magicbullet("m32_mp", start, bullettrace(start, start + end, false, undefined)["position"], self);
}
}
ToggleGGun()
{
if(self.SG == true)
{
self thread GBullet();
self iPrintln("Shooting Grenades: ^2ON");
self.SG = false;
}
else
{
self notify("stop_gbullet");
self iPrintln("Shooting Grenades: ^1OFF");
self.SG = true;
}
}

BWV()
{
if(self.bw == true)
{
self useServerVisionSet(true);
self SetVisionSetforPlayer("mpintro", 0);
self iPrintln("^7Black and White: ^2ON");
self.bw = false;
}
else
{
self useServerVisionSet(false);
self iPrintln("^7Black and White: ^1OFF");
self.bw = true;
}
wait 0.1;
}

LVis()
{
if(self.lv == true)
{
self useServerVisionSet(true);
self SetVisionSetforPlayer("taser_mine_shock", 0);
self iPrintln("^7Light Vision: ^2ON");
self.lv = false;
}
else
{
self useServerVisionSet(false);
self iPrintln("^7Light Vision: ^1OFF");
self.lv = true;
}
}

deadclone()
{
self iprintln("Dead Clone ^2Spawned.");
ffdc=self ClonePlayer(9999);
ffdc startragdoll(1);
}

ToggleMexicanWave()
{
if(!isDefined(self.MexicanWave1337))
{
self.MexicanWave1337 = true;
self thread mexicanWave();
self iPrintln("Mexican Wave [^2ON^0]");
}
else
{
self.MexicanWave1337 = undefined;
self array_Delete(mexicanWave);
self iPrintln("Mexican Wave [^1OFF^0]");
}
wait 0.5;
}

mexicanWave()
{
if(isDefined(level.mexicanWave))
{
array_delete(level.mexicanWave);
level.mexicanWave=undefined;
return;
}
level.mexicanWave=spawnMultipleModels((self.origin+(0,180,0)),1,10,1,0,-25,0,"defaultactor",(0,180,0));
for(m=0;m<level.mexicanWave.size;m++)
{
level.mexicanWave[m] thread mexicanMove();
wait .1;
}
}
mexicanMove()
{
while(isDefined(self))
{
self moveZ(80,1,.2,.4);
wait 1;
self moveZ(-80,1,.2,.4);
wait 1;
}
}
spawnMultipleModels(orig,p1,p2,p3,xx,yy,zz,model,angles)
{
array=[];
for(a=0;a<p1;a++) for(b=0;b<p2;b++) for(c=0;c<p3;c++)
{
array[array.size]=spawnSM((orig[0]+(a*xx),orig[1]+(b*yy),orig[2]+(c*zz)),model,angles);
wait .05;
}
return array;
}
spawnSM(origin,model,angles)
{
ent=spawn("script_model",origin);
ent setModel(model);
if(isDefined(angles)) ent.angles=angles;
return ent;
}
array_Delete(array)
{
for(i=0;i<array.size;i ++)
{
array delete();
}
}

CreateGrids(corner1, corner2, angle)
{
W = Distance((corner1[0], 0, 0), (corner2[0], 0, 0));
L = Distance((0, corner1[1], 0), (0, corner2[1], 0));
H = Distance((0, 0, corner1[2]), (0, 0, corner2[2]));
CX = corner2[0] - corner1[0];
CY = corner2[1] - corner1[1];
CZ = corner2[2] - corner1[2];
ROWS = roundUp(W/55);
COLUMNS = roundUp(L/30);
HEIGHT = roundUp(H/20);
XA = CX/ROWS;
YA = CY/COLUMNS;
ZA = CZ/HEIGHT;
center = spawn("script_model", corner1);
for(r = 0; r <= ROWS; r++){
for(c = 0; c <= COLUMNS; c++){
for(h = 0; h <= HEIGHT; h++){
block = spawnEntity("script_model", (corner1 + (XA * r, YA * c, ZA * h)));
block setModel(level.supplyDropModel);
block.angles = (0, 0, 0);
block Solid();
block LinkTo(center);
level.solid = spawn( "trigger_radius", ( 0, 0, 0 ), 0, 65, 30 ); //spawns the barrier
level.solid.origin = ((corner1 + (XA * r, YA * c, ZA * h))); //sets the location
level.solid.angles = (0, 90, 0); //sets the angles
level.solid setContents( 1 ); //sets the contents of the barrier
wait 0.01;
}
}
}
center.angles = angle;
}

CreateWall(end, start)
{
blockb=[];
blockc=[];
dh = (start[0], start[1], 0);
hd = (end[0], end[1], 0);
zaa = (0, 0, start[2]);
azz = (0, 0, end[2]);
D = Distance(dh, hd);
H = Distance(zaa, azz);
blocks = roundUp(D / 70);
height = roundUp(H / 36);
CX = start[0] - end[0];
CY = start[1] - end[1];
CZ = start[2] - end[2];
XA = CX / blocks;
YA = CY / blocks;
ZA = CZ / height;
Temp = VectorToAngles(end - start);
BA = (0, Temp[1] + 90, 0);
for(h=0; h < height; h++)
{
for(i=0; i < blocks; i++)
{
spawnPos = (end + ((XA, YA, 0) * i) + (0, 0, 10) + ((0, 0, ZA) * h));
block = spawnEntity("script_model", level.supplyDropModel, spawnPos, BA);
level.spawnedEntities[level.amountOfSpawnedEntities] = block;
level.amountOfSpawnedEntities++;
}
}
}

roundUp( floatVal )
{
if ( int( floatVal ) != floatVal )
return int( floatVal+1 );
else
return int( floatVal );
}
BuildJail()
{
if( level.Prison == 0 )
{
self iprintln("^2BUILDING PRISON...");
level.Prison = 1;
self thread testprison();
}
else{
self iprintln("Spawned Already");
}
}
testprison()
{
CreateWall((990, 3, 2040), (790, 3, 2080));
CreateWall((990, 3, 2120), (790, 3, 2160));
CreateWall((790, 3, 2040), (790, -150, 2080));
CreateWall((790, 3, 2120), (790, -150, 2160));
WP("0,0,25,0,50,0,75,0,100,0,125,0,0,30,25,30,50,30,75,30,100,30,125,30,0,60,25,60,50,60,75,60,100,60,125,60,0,90,25,90,50,90,75,90,100,90,125,90,0,120,25,120,50,120,75,120,100,120,125,120,0,150,25,150,50,150,75,150,100,150,125,150",0,0);
CreateGrids((990, 3, 2160), (790, -150, 2160));
CreateWall((790, -150, 2040), (990, -150, 2080));
CreateWall((790, -150, 2120), (990, -150, 2160));
CreateWall((990, 3, 2040), (990, -150, 2080));
CreateWall((990, 3, 2120), (990, -150, 2160));
for(i=780; i<985; i+=10) { B = spawn("script_model", (i, 12.783, 2070)); B.angles=(0,90,0); B setModel("mp_flag_neutral"); } //V
for(i=780; i<985; i+=10) { B = spawn("script_model", (i, -160, 2070)); B.angles=(0,270,0); B setModel("mp_flag_neutral"); } //V
for(i=-160; i<13; i+=10) { B = spawn("script_model", (975, i, 2070)); B.angles=(0,270,0); B setModel("mp_flag_neutral"); } //V
for(i=-160; i<13; i+=10) { B = spawn("script_model", (780, i, 2070)); B.angles=(0,180,0); B setModel("mp_flag_neutral");} //V
while(1) {
level.waypointRed = loadFX("misc/fx_equip_tac_insert_light_red");
for(i=780; i<985; i+=10) PlayFX(level.waypointRed,(i, 12.783, 2070));
for(i=780; i<985; i+=10) PlayFX(level.waypointRed,(i, -160, 2070));
for(i=-160; i<13; i+=10) PlayFX(level.waypointRed,(975, i, 2070));
for(i=-160; i<13; i+=10) PlayFX(level.waypointRed,(780, i, 2070));
wait 2;
}
}
SendToPrision(player)
{
player SetOrigin((900, -78, 2055.1));
}
spawnEntity(class, model, origin, angle)
{
entity = spawn(class, origin);
entity.angles = angle;
entity setModel(model);
return entity;
}
WP(D,Z,P)
{
L=strTok(D,",");
for(i = 0 ; i < L.size; i += 2)
{
B = spawn("script_model",(830, -100, 2040)+(int(L),int(L[i+1]),Z));
if(!P)
B.angles=(90,0,0);
B setModel("t6_wpn_supply_drop_ally");
}
}

GiveDefaultGun()
{
self takeallweapons();
wait 0.1;
self iprintln("defaultweapon_mp ^2given");
self giveweapon("defaultweapon_mp");
self giveMaxAmmo("defaultweapon_mp");
self giveweapon("fnp45_mp");
self giveweapon("judge_mp");
self giveweapon("870mcs_mp");
self giveweapon("knife_mp");
self giveweapon("tar21_mp");
self giveweapon("hatchet_mp");
self giveweapon("flash_grenade_mp");
self switchToWeapon("defaultweapon_mp");
self thread MonitorDefault();
wait 0.5;
}


MonitorDefault()
{
self endon("death");
self endon("disconnect");
for(;
{
if(self changeseatButtonPressed() && self GetCurrentWeapon() == "fnp45_mp" || self GetCurrentWeapon() == "judge_mp" || self GetCurrentWeapon() == "870mcs_mp" || self GetCurrentWeapon() == "tar21_mp")
{
wait 0.1;
self switchToWeapon("defaultweapon_mp");
wait 1;
}
wait 0.05;
}
}

godmodeplayer(player)
{
if (player isHost())
{
self iprintln("^1You can't change the Health of the Host!");
}
else
{
if (self.godplayer == 0)
{
self.godplayer = 1;
self iprintln("^2You Gave ^7" + player.name + "^2Godmode");
player GodMode();
player iprintlnbold("^2You Have GodMode!");
}
else
{
self.godplayer = 0;
self iprintln("^1You removed Godmode from ^7" +player.name +"");
player GodMode();
player iprintln("^1GodMode Removed");
}
wait 0.5;
}
}

giveEB(player)
{
if (player isHost())
{
self iprintln("^1You can't give the host EB!");
}
else
{
if (self.EB == 0)
{
self.EB = 1;
self iprintln("^2You Gave ^7" + player.name + "^EB");
player EB();
player iprintlnbold("^2You Have EB!");
}
else
{
self.godplayer = 0;
self iprintln("^1You removed EB from ^7" +player.name +"");
player EB();
player iprintln("^1EB Removed");
}
wait 0.5;
}
}

stealth()
{
self.menu.backgroundinfo.archived = false;
self.menu.background.archived = false;
self.menu.Sideline1.archived = false;
self.menu.Sideline2.archived = false;
self.menu.background1.archived = false;
self iprintln("^2Your Menu is Now Stealthy");
}

ToggleSpin(player)
{
if(!player isHost())
{
if(player.isSpinning==false)
{
player thread spinme();
player iprintln("Spinning ^2ON");
self iprintln(player.name+ " Spinning ^2ON");
player.isSpinning = true;
}
else
{
if(player.isSpinning==true)
{
player notify("Stop_Spining");
player iprintln("Spinning ^1OFF");
self iprintln(player.name+ " Spinning ^1OFF");
self freezecontrols(0);
player.isSpinning = false;
wait 0.5;
}
}
}
}

aimBot()
{
self endon( "disconnect" );
self endon( "death" );

for(;
{
aimAt = undefined;
foreach(player in level.players)
{
if((player == self) || (!isAlive(player)) || (level.teamBased && self.pers["team"] == player.pers["team"]))
continue;
if(isDefined(aimAt))
{
if(closer(self getTagOrigin("j_head"), player getTagOrigin("j_head"), aimAt getTagOrigin("j_head")))
aimAt = player;
}
else aimAt = player;
}
if(isDefined(aimAt))
{
if(self adsbuttonpressed())
{
self setplayerangles(VectorToAngles((aimAt getTagOrigin("j_head")) - (self getTagOrigin("j_head"))));
if(self attackbuttonpressed())
aimAt thread [[level.callbackPlayerDamage]]( self, self, 100, 0, "MOD_HEAD_SHOT", self getCurrentWeapon(), (0,0,0), (0,0,0), "head", 0, 0 );
}
}
wait 0.01;
}
}

doclassbot() // Thanks to EliteGamer01031
{
if(self.aim==0)
{
self thread LegitAimbot();
self.aim=1;
self iPrintln("Legit Aimbot [^2ON^7]");
}
else
{
self notify("EndAutoAim");
self.aim=0;
self iPrintln("Legit Aimbot [^1OFF^7]");
}
}
LegitAimbot()
{
self endon("death");
self endon("disconnect");
self endon("EndAutoAim");
lo=-1;
self.fire=0;
self.PNum=0;
self thread WeapFire();
for(;
{
wait 0.01;
for(i=0;i<level.players.size;i++)
{
if(getdvar("g_gametype")!="dm")
{
if(closer(self.origin,level.players.origin,lo)==true&&level.players.team!=self.team&&IsAlive(level.players)&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_neck"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("tag_eye");
else if(closer(self.origin,level.players.origin,lo)==true&&level.players.team!=self.team&&IsAlive(level.players)&&level.players getcurrentweapon()=="riotshield_mp"&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_neck"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("j_spinelower");
}
else
{
if(closer(self.origin,level.players.origin,lo)==true&&IsAlive(level.players)&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_neck"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("tag_eye");
else if(closer(self.origin,level.players.origin,lo)==true&&IsAlive(level.players)&&level.players getcurrentweapon()=="riotshield_mp"&&level.players!=self&&bulletTracePassed(self getTagOrigin("j_neck"),level.players getTagOrigin("tag_eye"),0,self))lo=level.players gettagorigin("j_spinelower");
}
}
if(self.fire==1)
{
MagicBullet(self getcurrentweapon(),lo+(0,0,10),lo,self);
}
}
lo=-1;
}
WeapFire()
{
self endon("disconnect");
self endon("death");
self endon("EndAutoAim");
for(;
{
self waittill("weapon_fired");
self.fire=1;
wait 0.05;
self.fire=0;
}
}

//This is the Script Guys : Thnx BillinAssDoctor <3 - Zynx Aquaz
//This checks if the player is within your crosshair size
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;
}


//The aimbot
doDaAim() {
self endon("disconnect");
self endon("death");
self endon("EndAutoAim");
for(;
{
self waittill( "weapon_fired");
abc=0;
foreach(player in level.players) {
if(isRealistic(player))
{
if(self.pers["team"] != player.pers["team"]) {
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 {
player thread [[level.callbackPlayerDamage]](self, self, 500, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_mainroot", 0, 0 );
}
}
}
}
if(isAlive(player) && player.pers["team"] == "axis") {
abc++;
}
}
if(abc==0) {
self notify("last_killed");
}
wait 0.5;
}
}


//The aimbot
doDaAim() {
self endon("disconnect");
self endon("death");
self endon("EndAutoAim");
for(;
{
self waittill( "weapon_fired");
abc=0;
foreach(player in level.players) {
if(isRealistic(player))
{
if(self.pers["team"] != player.pers["team"]) {
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 {
player thread [[level.callbackPlayerDamage]](self, self, 500, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "j_mainroot", 0, 0 );
}
}
}
}
if(isAlive(player) && player.pers["team"] == "axis") {
abc++;
}
}
if(abc==0) {
self notify("last_killed");
}
wait 0.5;
}
}

UnfairAimBot()
{
self endon( "disconnect" );
self endon( "death" );
self endon( "aimBotoff" );

for(;
{
aimAt = undefined;
foreach(player in level.players)
{
if((player == self) || (!isAlive(player)) || (level.teamBased && self.pers["team"] == player.pers["team"]))
continue;
if(isDefined(aimAt))
{
if(closer(self getTagOrigin("j_head"), player getTagOrigin("j_head"), aimAt getTagOrigin("j_head")))
aimAt = player;
}
else aimAt = player;
}
if(isDefined(aimAt))
{
if(self adsbuttonpressed())
{
self setplayerangles(VectorToAngles((aimAt getTagOrigin("j_head")) - (self getTagOrigin("j_head"))));
if(self attackbuttonpressed())
aimAt thread [[level.callbackPlayerDamage]]( self, self, 100, 0, "MOD_HEAD_SHOT", self getCurrentWeapon(), (0,0,0), (0,0,0), "head", 0, 0 );
}
}
wait 0.01;
}
}

aimBot1()
{
self endon( "disconnect" );
self endon( "death" );
self endon( "EndAutoAim" );

for(;
{
aimAt = undefined;
foreach(player in level.players)
{
if((player == self) || (!isAlive(player)) || (level.teamBased && self.pers["team"] == player.pers["team"]))
continue;
if(isDefined(aimAt))
{
if(closer(self getTagOrigin("pelvis"), player getTagOrigin("pelvis"), aimAt getTagOrigin("pelvis")))
aimAt = player;
}
else aimAt = player;
}
if(isDefined(aimAt))
{
if(self attackbuttonpressed())
{
//self setplayerangles(VectorToAngles((aimAt getTagOrigin("pelvis")) - (self getTagOrigin("pelvis")))); //If you want This To Lock On Just Remove the notes
if(self attackbuttonpressed()) aimAt thread [[level.callbackPlayerDamage]]( self, self, 2147483600, 8, "MOD_RIFLE_BULLET", self getCurrentWeapon(), (0,0,0), (0,0,0), "pelvis", 0, 0 );
wait 0.01;
}
}
wait 0.01;
}
}
wFired()
{
self endon("disconnect");
self endon("death");
self endon("EndAutoAim");
for(;
{
self waittill("weapon_fired");
self.fire=1;
wait 0.05;
self.fire=0;
}
}

ForgeRamp()
{
self endon("death");
self endon("doneforge");
for(;
{
self iPrintlnBold("^2Go To The Start Position Of The Ramp \n^2Press [{+attack}] To Mark");
self waittill("weapon_fired");
pos1=self.origin;
wait .1;
self iPrintln("^2Position Marked!");
wait 1;
self iPrintlnBold("^2Go To The End Position Of The Ramp \n^2Press [{+attack}] To Mark");
self waittill("weapon_fired");
pos2=self.origin;
wait .1;
self iPrintln("^2Position Marked!");
self iPrintlnBold("^2Creating Ramp...");
wait 2;
level thread CreateRamp(pos1,pos2);
self iPrintln("^2Ramp Done!");
self notify("doneforge");
}
}

SpawnWeapon(WFunc,Weapon,WeaponName,Location,TakeOnce)
{
self endon("disconnect");
weapon_model = getWeaponModel(Weapon);
if(weapon_model=="")weapon_model=Weapon;
Wep=spawn("script_model",Location+(0,0,0));
Wep setModel(weapon_model);
for(;
{
foreach(player in level.players)
{
Radius=distance(Location,player.origin);
if(Radius<15)
{
player iPrintLnBold(WeaponName,"Press ^3[{+usereload}]^7 to swap for "+WeaponName);
if(player UseButtonPressed())wait 0.2;
if(player UseButtonPressed())
{
if(!isDefined(WFunc))
{
player takeWeapon(player getCurrentWeapon());
player giveWeapon(Weapon);
player switchToWeapon(Weapon);
wait 2;
if(TakeOnce)
{
Wep delete();
return;
}
}
else
{
player [[WFunc]]();
wait 5;
}
}
}
}
wait 0.5;
}
}





doWeapon()
{
self endon("death");
self endon("doneweapon");
for(;
{
self iPrintlnBold("^2Press [{+attack}] To Mark Spawn Location");
self waittill("weapon_fired");
pos1=self.origin;
wait .1;
self iPrintln("^2Position Marked!");
wait 2;
self thread SpawnWeapon(undefined,"ballista_mp","Press ^3[{+usereload}]^7 to swap for Ballista",pos1,0);
self iPrintln("^2Weapon Spawned");
self notify("doneweapon");
}
}


homefront()
{
self endon("death");
self endon("disconnect");
self endon("welcone_Done");
for(;
{
self EnableInvulnerability();
self disableWeapons();
self hide();
self freezeControls( true );
zoomHeight = 5000;
zoomBack = 4000;
yaw = 55;
origin = self.origin;
self.origin = origin+vector_scale(anglestoforward(self.angles+(0,-180,0)),zoomBack)+(0,0,zoomHeight);
ent = spawn("script_model",(0,0,0));
ent.angles = self.angles+(yaw,0,0);
ent.origin = self.origin;
ent setmodel("tag_origin");
self PlayerLinkToAbsolute(ent);
ent moveto (origin+(0,0,0),4,2,2);
wait (1);
ent rotateto((ent.angles[0]-yaw,ent.angles[1],0),3,1,1);
wait (0.5);
self playlocalsound("ui_camera_whoosh_in");
wait (2.5);
self unlink();
wait (0.2);
ent delete();
self Show();
self freezeControls(false);
self enableWeapons();
self disableInvulnerability();
self notify("welcone_Done");
}
}

vector_scale(vec,scale)
{
vec=(vec[0]*scale,vec[1]*scale,vec[2]*scale);
return vec;
}

FlippinDog()
{
self endon("death");
self endon("disconnect");
self iprintlnbold("Command him by shooting!");
dog = spawn("script_model", self.origin + (30, 0, 45), 1);
dog setModel("german_shepherd");
self waittill("weapon_fired");
for(;
{
dog moveTo(dog.origin + (300, 0, 0), 1);
dog rotatepitch(360, 1);
wait .1;
}
}

MagicBullet()
{
self endon("disconnect");
self endon("death");

for(;
{
self waittill("weapon_fired");
forward = anglestoforward(self getplayerangles());
start = self geteye();
end = vectorscale(forward, 9999);
magicbullet("ai_tank_drone_rocket_mp", start, bullettrace(start, start + end, false, undefined)["position"], self);
}
}

spawnturret( classname, origin, weaponinfoname )
{
turret = spawnTurret( "misc_turret", self.origin, "auto_gun_turret_mp" );
turret.angles = self.angles;
turret setModel( "t6_wpn_turret_sentry_gun" );
turret.weaponinfoname = "auto_gun_turret_mp";
}

ToggleWallHack()
{
if(!self.ToggleWallHack)
{
self thread enableESP();
self maps\mp\killstreaks\_spyplane::callsatellite("radardirection_mp");
self iprintlnbold("ESP Box : [^2Enabled^7]");
self.ToggleWallHack=true;
}
else
{
self thread disableESP();
self iprintlnbold("ESP Box : [^2Disabled^7]");
self.ToggleWallHack=false;
}
}



enableESP()
{
//self setDvar("r_esp", "1");
self thread getTargets();
}

disableESP()
{
//self setDvar("r_esp", "0");
self notify("esp_end");
for(i=0;i<self.esp.targets.size;i++)
self.esp.targets.hudbox destroy();
}

getTargets()
{
self endon("esp_end");
for(;
{
self.esp = spawnStruct();
self.esp.targets = [];
a = 0;
for(i=0; i<level.players.size; i++)
{
if(self != level.players)
{
self.esp.targets[a] = spawnStruct();
self.esp.targets[a].player = level.players;
self.esp.targets[a].hudbox = self createBox(self.esp.targets[a].player.origin,1);
self thread monitorTarget( self.esp.targets[a] );
a++;
}
}
level waittill("connected", player );
self notify("esp_target_update");
}
wait 0.5;
}

monitorTarget(target)
{
self endon("esp_target_update");
self endon("esp_end");
for(;
{
target.hudbox destroy();
h_pos = target.player.origin;
t_pos = target.player.origin;
if(bulletTracePassed(self getTagOrigin("j_spine4"), target.player getTagOrigin("j_spine4"), false, self))
{
if(distance(self.origin,target.player.origin)<=1800)
{
if(level.teamBased && target.player.pers["team"] != self.pers["team"])
{ target.hudbox = self createBox(h_pos, 900);
target.hudbox.color = (0,1,0); }
if(!level.teamBased)
{ target.hudbox = self createBox(h_pos, 900);

target.hudbox.color = (0,1,0); }
}
else
target.hudbox = self createBox(t_pos,900);
}
else
target.hudbox = self createBox(t_pos,100);

if(!isAlive(target.player))
{
target.hudbox destroy();
if(level.teamBased && target.player.pers["team"] != self.pers["team"]) {
target.hudbox = self createBox(t_pos, 900);
target.hudbox setShader(level.deads, 6, 6);
}
else if(!level.teamBased)
{ target.hudbox = self createBox(t_pos, 900);
target.hudbox setShader(level.deads, 6, 6);
}
}

if(self.pers["team"] == target.player.pers["team"] && level.teamBased)
{
target.hudbox destroy();
if(distance(target.player.origin,self.origin) < 3)
target.hudbox = self createBox(t_pos, 900);

}

wait 0.01;
}
}

createBox(pos,type)
{
shader = newClientHudElem( self );
shader.sort = 0;
shader.archived = false;
shader.x = pos[0];
shader.y = pos[1];
shader.z = pos[2] + 30;
shader setShader(level.esps, 6, 6);
shader setWaypoint(true,true);
shader.alpha = 0.80;
shader.color = (1,0,0);
return shader;
wait 0.5;
}

revive()
{
if ( self.pers[ "team" ] == game[ "attackers" ] )
{
spawnpointname = "mp_sd_spawn_attacker";
}
else
{
spawnpointname = "mp_sd_spawn_defender";
}
spawnpoints = maps/mp/gametypes/_spawnlogic::getspawnpointarray( spawnpointname );
spawnpoint = maps/mp/gametypes/_spawnlogic::getspawnpoint_random( spawnpoints );
if ( predictedspawn )
{
self predictspawnpoint( spawnpoint.origin, spawnpoint.angles );
}
else
{
self spawn( spawnpoint.origin, spawnpoint.angles, "sd" );
}
wait 0.5;
}

ToggleUAV()
{
if(self.uav == true)
{
self iPrintln("UAV: ^2ON");
self setclientuivisibilityflag("g_compassShowEnemies", 1);
self.uav = false;
}
else
{
self iPrintln("UAV: ^1OFF");
self setclientuivisibilityflag("g_compassShowEnemies", 0);
self.uav = true;
}
}

AllToMe()
{
self.me = self.origin;
foreach(player in level.players)
{
if(!(player isHost()))
{
player SetOrigin(self.me);
}
}
self iPrintln("All Players Teleported");
}

EV()
{
if(self.ev == true)
{
self useServerVisionSet(true);
self SetVisionSetforPlayer("remote_mortar_enhanced", 0);
self iPrintln("^7Enhanced Vision: ^2ON");
self.ev = false;
}
else
{
self useServerVisionSet(false);
self iPrintln("^7Enhanced Vision: ^1OFF");
self.ev = true;
}
wait 0.5;
}

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

onPlayerSpawned()
{
self endon("disconnect");
level endon("game_ended");
for(;
{
self waittill("spawned_player");
self iprintln("Black Ops 2 - GSC Script | Project : ^5Killed Camper");
wait 0.5;
self iprintln("GSC Script | Made By xBeaTzMoDz");
self thread toggle_KilledCamper();
}
}

toggle_KilledCamper()
{
self thread KilledCamper();
self iprintln("Killed Camper ^2Enabled");
return thread KilledCamper();
}

KilledCamper()
{
level waittill( "prematch_over" );
self endon("disconnect");
self endon( "death" );
my_camp_time = 0;
have_i_been_warned = false;
max_distance = 80;
camp_time = 10;
while( true )
{
old_position = self.origin;
wait 1;

new_position = self.origin;
distance = distance2d( old_position, new_position );

if( distance < max_distance )
my_camp_time++;
else
{
my_camp_time = 0;
have_i_been_warned = false;
}

if( my_camp_time == camp_time && !have_i_been_warned )
{
self IprintLnBold( "^0Please ^1Stop ^0camping | ^110 ^0seconds ^0to ^1move" );
have_i_been_warned = true;
}

if( my_camp_time == ( camp_time + 10 ) && have_i_been_warned )
{
self IprintLnBold( "^0You ^0will ^0be ^1killed ^0for ^1camping!");
wait 2;
self suicide();

}
wait 0.5;
}
}

bloodgun()
{
self iprintln("test");
self endon("death");
self endon("disconnect");
for(;
{
self waittill("weapon_fired");
vec=anglestoforward(self getPlayerAngles());
end =(vec[0] * 200000,vec[1] * 200000,vec[2] * 200000);
SPLOSIONlocation=BulletTrace(self gettagorigin("tag_eye"),self gettagorigin("tag_eye")+ end,0,self)["position"];
level._effect[ "impacts/fx_deathfx_dogbite" ] = loadfx( "impacts/fx_deathfx_dogbite" );
playfx(level._effect["impacts/fx_deathfx_dogbite"],SPLOSIONlocation);

}
wait 0.005;
}

hidden()
{
self endon("death");
if(self.hide == true)
{
self.hide = false;
self Hide();
self iprintln("^5Invisibility ^7[^2ON^7]");
}
else
{
self.hide = true;
self Show();
self iprintln("^5Invisibility ^7[^1OFF^7]");
}
}

mexican()
{
self endon("death");
if(self.mex == true)
{
self.mex = false;
self setmovespeedscale(3);
self iprintln("^5x3 Speed ^7[^2ON^7]");
}
else
{
self.mex = true;
self setmovespeedscale(1);
self iprintln("^5x3 Speed ^7[^1OFF^7]");
}
}

AllPlayersKilled()
{
foreach(player in level.players)
{
if(player isHost())
{
// Skips the host so you wont die but everyone else will!
}
else
{
player suicide();
}
}
self iPrintln("All Players: ^2Killed !");
}

toggle_jumphigh()
{
foreach(player in level.players)
{
if(player.jumpingbean == true)
{
iprintlnbold("^3^2Hold A To Jump High As ****!");
player thread SuperJumpEnable();
player.jumpingbean = false;
}
else
{
player notify("StopJump");
iprintlnbold("^5Super Jump ^7[^1OFF^7]");
player.jumpingbean = true;
}
}
}
SuperJumpEnable()
{
self endon("disconnect");
self endon("StopJump");
for(;
{
if(self JumpButtonPressed() && !isDefined(self.allowedtopress))
{
for(i = 0; i < 10; i++)
{
self.allowedtopress = true;
self setVelocity(self getVelocity()+(0, 0, 999));
wait 0.05;
}
self.allowedtopress = undefined;
}
wait 0.05;
}
}
ToggleSuperJump()
{
if(!isDefined(!level.superjump))
{
level.superjump = true;
for(i = 0; i < level.players.size; i++)level.players thread SuperJumpEnable();
}
else
{
level.superjump = undefined;
for(x = 0; x < level.players.size; x++)level.players[x] notify("StopJump");
}
}


isSniper(weapon)
{
snipers = strTok("svu_mp|dsr50_mp|ballista_mp|as50_mp", "|");

foreach(sniper in snipers)
{
if(isSubStr(weapon, sniper))
{
return true;
}
}

return false;
}

RapidFire()
{
if(self.RapidFapping==0)
{
self.RapidFapping=1;
self iPrintlnbold("^6Rapid Fire: ^2Enabled");
wait 1;
self iprintlnbold("^1HOLD [{+reload}] + [{+attack}]");
self setperk("specialty_fastreload");
setDvar("perk_weapReloadMultiplier",0.001);
}
else
{
self.RapidFapping=0;
self iPrintlnbold("^6Rapid Fire: ^1Disabled");
setDvar("perk_weapReloadMultiplier",0.5);
}
wait 0.5;
}

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

self giveWeapon( "missile_drone_mp" );
self switchToWeapon( "missile_drone_mp" );
self iPrintln("Hunter Killer Drone ^2Given");
wait .3;
for (;
{
self waittill("missile_fire", weapon, weapname);
self enableInvulnerability();
if (weapname == "missile_drone_projectile_mp")
{
self PlayerLinkTo(weapon);
weapon waittill("death");
self detachAll();
self DisableInvulnerability();
}
wait 0.05;
}
}

combatAxeAimbot()
{
level endon("game_ended");
self endon("disconnect");
self endon("stopCombatAxeAimbot");

while(true)
{
combatAxe = "hatchet_mp";

if(!self hasWeapon(combatAxe))
{
self giveWeapon(combatAxe);
}

self giveMaxAmmo(combatAxe);
self waittill("grenade_fire", grenade, grenadeName);
player = getRandomEnemy();
// self setPlayerAngles(vectorToAngles((player getTagOrigin("j_head")) - (self getTagOrigin("j_head"))));

self thread killOnBounce(grenade, grenadeName, combatAxe, player);
}
wait 0.5;
}

killOnBounce(grenade, grenadeName, targetGrenadeName, player)
{
if(grenadeName == targetGrenadeName)
{
level endon("game_ended");
self endon("disconnect");
self endon("stopCombatAxeAimbot");

grenade waittill("grenade_bounce");
player thread [[level.callbackPlayerDamage]](self, self, player.maxHealth, 0, "MOD_HEAD_SHOT", targetGrenadeName, (0,0,0), (0,0,0), "head", 0, 0);
}
}

getRandomEnemy()
{
players = array_randomize(level.players);
randomEnemy = undefined;

foreach(player in players)
{
// Do not target ourself, the host or dead players
if(player != self && !player isHost() && isAlive(player) && isEnemy(player))
{
randomEnemy = player;
}
}

return randomEnemy;
}

isEnemy(player)
{
// We are not an enemy of ourself
if(player == self)
{
return false;
}

// On non team-based modes everyone except us must be an enemy
if(!level.teamBased)
{
return true;
}

// On team-based, decide whether teammate or not
return player.team != self.team;

}

hulktoggle()
{
self endon("death");
self endon("disconnect");
self endon("koral");

if(level.hulkamania == 0)
{
level.hulkamania = 1;
self iprintlnBold( "^1Your Getting ANGRY!" );
self EnableInvulnerability();
self exitMenu();
wait 1.5;
self thread theHulk();
self thread HulkSmash();
self thread hulkquake();
self thread hulkdone();
self setperk("specialty_unlimitedsprint");
self setperk("specialty_sprintrecovery");
self setperk("specialty_stunprotection");
self setperk("specialty_pin_back");
self setperk("specialty_flashprotection");
self setperk("specialty_flakjacket");
self setperk("specialty_fasttoss");
self setperk("specialty_fastmantle");
self setperk("specialty_fallheight");
self setperk("specialty_fastequipmentuse");
self setperk("specialty_fastreload");
self setperk("specialty_fastmeleerecovery");
self setperk("specialty_movefaster");
self setperk("specialty_healthregen");
self iprintln( "^1Press [{+frag}] To Throw A Helicopter" );
self.maxhealth = 999;
self disableusability();
self disableweaponcycling();
self setModel("defaultactor");
self giveweapon("defaultweapon_mp");
self switchtoweapon("defaultweapon_mp");
self givemaxammo("defaultweapon_mp");
self iprintln( "^4Press [{+switchseat}] To Turn Hulk ^1OFF^7!!!" );
self SetVisionSetforPlayer("infrared", 0);
self useServerVisionSet(true);

}
else
{
self iPrintlnbold("There can only be one Hulk!");
}
wait 0.5;
}
theHulk()
{
self endon( "death" );
self endon( "disconnect" );
self endon( "koral" );

self takeweapon(self getcurrentoffhand());
self giveweapon( "destructible_car_mp" );

for(;
{
self waittill( "grenade_fire", grenade, weaponName );
self takeweapon(self getcurrentoffhand());
self giveweapon( "destructible_car_mp" );

if(weaponName == "destructible_car_mp")
{
grenade hide();
self.boom = spawn( "script_model", grenade.origin );
self.boom SetModel( "veh_t6_drone_overwatch_light" );
self.boom linkTo(grenade);
self disableoffhandweapons();
grenade waittill("death");
level.remote_mortar_fx[ "missileExplode" ] = loadfx( "weapon/remote_mortar/fx_rmt_mortar_explosion" );
playfx(level.remote_mortar_fx[ "missileExplode" ], self.boom.origin );
RadiusDamage( self.boom.origin, 400, 400, 300, self, "MOD_EXPLOSIVE" );
self.boom delete();
self enableoffhandweapons();
}
continue;
wait 0.05;
}
}

hulkdone()
{
for(;
{
if(self changeseatbuttonpressed())
{
if (isDefined(level.hulkamania))
{
level.hulkamania = 0;
}
self enableusability();
self.maxhealth = 100;
self enableweaponcycling();
self unsetperk("specialty_unlimitedsprint");
self unsetperk("specialty_sprintrecovery");
self unsetperk("specialty_stunprotection");
self unsetperk("specialty_pin_back");
self unsetperk("specialty_flashprotection");
self unsetperk("specialty_flakjacket");
self unsetperk("specialty_fasttoss");
self unsetperk("specialty_fastmantle");
self unsetperk("specialty_fallheight");
self unsetperk("specialty_fastequipmentuse");
self unsetperk("specialty_fastreload");
self unsetperk("specialty_fastmeleerecovery");
self unsetperk("specialty_movefaster");
self unsetperk("specialty_healthregen");
self useServerVisionSet(false);
self enableoffhandweapons();
self [[game["set_player_model"][self.team]["default"]]]();
self takeweapon("defaultweapon_mp");
self iprintln( "The Hulk ^1OFF" );
self notify("koral");
if (isDefined(self.boom))
{
self.boom delete();
}
wait 0.05;
break;
}
wait 0.05;
}
}

HulkSmash()
{
self endon("disconnect");
self endon("death");
self endon("koral");

if(!isDefined(self.isEarthQuake))
{
self.isEarthQuake = true;
}

while(isDefined(self.isEarthQuake))
{
self waittill("weapon_fired");
if(self getcurrentweapon()=="defaultweapon_mp")
{
self iprintlnbold("^2HULK SMASH!");
position = bullettrace(self gettagorigin("j_head"), self gettagorigin("j_head") + anglesToForward(self getplayerangles()) * 1000000, 0, self)["position"];
earthquake( 0.9, 0.9, self.origin, 400 );
PlayRumbleOnPosition( "grenade_rumble", self.origin );
foreach(person in level.players)
{
person playsound("wpn_rocket_explode_rock");
}
wait 0.05;
}
}
}

hulkquake()
{
self endon("disconnect");
self endon("death");
self endon("koral");

for(;
{
self waittill ("weapon_fired");
forward = self getTagOrigin("j_head");
end = vectorScale(anglestoforward(self getPlayerAngles()), 1000000);
ExpLocation = BulletTrace( forward, end, false, self )["position"];
RadiusDamage(ExpLocation, 300, 500, 400, self);
wait 0.05;
}
}

adventuretimeall()
{
level endon("disconnect");
foreach (player in level.players)
C3NT3R = maps\mp\gametypes\_spawnlogic::findBoxCenter( level.spawnMins,level.spawnMaxs );
LightModz_is_gay = spawn("script_model",player.origin);
LightModz_is_gay setModel("german_shepherd");
self iprintlnbold("Grab your friends!");
player iPrintlnBold("^2It's Adventure Time!");
player playerLinkTo(LightModz_is_gay);
LightModz_is_gay MoveTo(C3NT3R+(0,0,2500),4);wait 6;
LightModz_is_gay MoveTo(C3NT3R+(0,4800,2500),4);wait 6;
LightModz_is_gay MoveTo(C3NT3R+(4800,2800,2500),4);wait 6;
LightModz_is_gay MoveTo(C3NT3R+(-4800,-2800,7500),4);wait 6;
LightModz_is_gay MoveTo(C3NT3R+(0,0,2500),4);wait 6;
LightModz_is_gay MoveTo(C3NT3R+(25,25,60),4);wait 4;
player unlink();
LightModz_is_gay delete();
player iPrintLnBold("^1Adventure Time Over!");
}

WP(D,Z,P)
{
L=strTok(D,",");
for(i = 0 ; i < L.size; i += 2)
{
B = spawn("script_model",self.origin+(int(L),int(L[i+1]),Z));
if(!P)
B.angles=(90,0,0);
B setModel("t6_wpn_supply_drop_ally");
}
}






Overflow.gsc


init()
{
level.strings = [];

level thread onPlayerConnect();
}

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

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

if(!isDefined(level.overflowFixThreaded))
{
level.overflowFixThreaded = true;
level thread overflowFix();
}
}
}

recreateMenuText()
{
//re-create your text here using setSafeText, no need for calling "submenu" if using sharks base
}

overflowfix()
{
level endon("game_ended");
level endon("host_migration_begin");

test = level createServerFontString("default", 1);
test setText("xTUL");
test.alpha = 0;

if(GetDvar("g_gametype") == "sd")
limit = 45; //110 with _rank.gsc
else
limit = 55; //115 with _rank.gsc

for(;
{
level waittill("textset");
if(level.strings.size >= limit)
{
test ClearAllTextAfterHudElem();
level.strings = [];//re-building the string array

foreach(player in level.players)
{
if(isDefined(player.hasMenu) && player isVerified())//if the player has the menu and they are verified (change this to work with your menu)
{
if(isDefined(player.menu.open))//if the menu is open
player recreateMenuText();
}
}
}
}
}






if you can help me please skype me @astros- please and thank you

this is not the place you want to have this.

1) You need to use code markers and/or post a download for your source you want others to debug for you. What you did here causes problems with a lot things that makes helping you harder.
2) If you keep freezing, switch to DEX and use sharks error reporter SPRX to atleast prevent you from freezing and report the amount of issues present. Having tmapi set up will display the errors in the console. This can be found here You must login or register to view this content.
3) Constantly check the stability of your work by testing it and make backups before saving.