#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_utility;
#include maps\_soviet\soviet_backend;
#include maps\_soviet\soviet_dev;

// Script inits all required scripts for all gamemodes
init()
{
	flag_wait( "all_players_connected" );

	dev();
	dev_create_playback("soviet");
	dev_create_playback("ctf");
	dev_create_playback("hotzone");
	dev_create_playback("bots");
	dev_create_playback("weapons");
	dev_create_playback("perks");

	dev_add_playback("soviet", "Soviet mod initalized");

	setDvar( "soviet_gamemode", "deathmatch" );
	setDvar( "soviet_dif", "normal" );


	if(!isdefined(level.soviet))	
		level.soviet = [];

	level.soviet["mod_version"] = 1.3;

	dev_add_playback("soviet", "Using soviet mod version " + level.soviet["mod_version"] + ".");

	threadedTasks = [];
	threadedTasks[0] = ::hide_ctf;
	threadedTasks[1] = maps\_soviet\soviet_weapons::init_weapon_affects;
 
	do_threaded_tasks(threadedTasks);

	players_connect_opening();

	script_wait_message(15, "Use the console to select your gamemode by typing soviet_gamemode <gamemode>", "Locking current gamemode in ", "Current gamemode locked in!");


	level.soviet["gamemode"] = getdvar("soviet_gamemode");
	level.soviet["max_ai"] = 8;

 
	if(!is_valid_gamemode())
	{
		iprintln("Gamemode not valid! Changing gamemode to deathmatch!");
 
		dev_add_playback("soviet", "Gamemode dvar not valid. The gamemode has been set to deathmatch.");
		level.soviet["gamemode"] = "deathmatch";
	}

	mod_version_Check();

	mod_dif();

	mod_init();
}
mod_init()
{

	if(level.soviet["gamemode"] == "deathmatch")
	{
		[[level.deathmatch_settings]]();
		level.soviet["cType"] = " kills";
		level.soviet["gamemode_text"] = "Kills: ";
		thread deathmatch_init();
	}
	else if(level.soviet["gamemode"] == "ctf")
	{
		[[level.ctf_settings]]();
		level.soviet["cType"] = " captures";
		level.soviet["gamemode_text"] = "Captures: ";
		thread ctf_init();
	}
	else if(level.soviet["gamemode"] == "hotzone")
	{
		[[level.hotzone_settings]]();
		level.soviet["cType"] = " hotzones";
		level.soviet["gamemode_text"] = "Hotzone: ";
		thread hotzone_init();
	}
	else if(level.soviet["gamemode"] == "quake_deathmatch")
	{
		[[level.quake_deathmatch_settings]]();
		level.soviet["cType"] = " score";
		level.soviet["gamemode_text"] = "Score: ";
		thread quake_deathmatch_init();
	}
	else if(level.soviet["gamemode"] == "null")
		return;
	else
	{
		assertMsg("Gamemode " + level.soviet["gamemode"] + " is not valid!");
		return;
	}

	level.gamemode = level.soviet["gamemode"];
	level.cType = level.soviet["cType"];

	[[level.common_settings]]();
	thread common_init();
	thread gamemode_hud();
}
mod_dif()
{
	dif = getDvar("soviet_dif");

	if(dif == "easy")
		level.soviet["max_ai"] = 4;
	else if(dif == "hard")
		level.soviet["max_ai"] = 12;
	else if(dif == "extreme")
		level.soviet["max_ai"] = 16;
	else
		level.soviet["max_ai"] = 8;

 
}

common_init()
{
	players = get_players();
	for(i=0;i<players.size;i++)
	{
		players[i].score = 0;
		players[i].kills = 0;
	}
 
	maps\_soviet\soviet_perks::init();
	maps\_soviet\soviet_weapons::init();
}
deathmatch_init()
{	
	maps\_soviet\soviet_bots::init();

	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
			players[i].score = players[i].kills;	
		wait(.75);
	}
 
}
ctf_init()
{
	maps\_soviet\soviet_ctf::init();
	maps\_soviet\soviet_bots::init();
}
hotzone_init()
{
	maps\_soviet\soviet_hotzone::init();
	maps\_soviet\soviet_bots::init();
}
quake_deathmatch_init()
{
	maps\_soviet\soviet_bots::init("spawner", maps\_soviet\soviet_bots::quake_deathmatch);

	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
			players[i].score = players[i].kills;	
		wait(.75);
	}
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_utility;
#include maps\_soviet\soviet_dev;

// This script is for functions that are used once in other scripts. Placing this stuff here will just make other scripts shorter and clutter free.
mod_integrity_check()
{
	if(!isdefined(level.cost[level.soviet["gamemode"]]))
		assertmsg("No weapon cost for gamemode: " + level.soviet["gamemode"]);
	if(!isdefined(level.delay[level.soviet["gamemode"]]))
		assertmsg("No spawner delays for gamemode: " + level.soviet["gamemode"]);
	if(!isdefined(level.shader))
		assertmsg("shader array not defined!");
}
is_valid_gamemode()
{
	if(!isdefined(level.compatibility) || !isArray(level.compatibility))
		return false;

	if(level.soviet["gamemode"] == "null")
		return true;

	return search_array(level.compatibility, level.soviet["gamemode"]);
}
mod_Version_Check()
{
	if(!isDefined(level.soviet["map_mod_version"]))
		return;

	if(level.soviet["mod_version"] < level.soviet["map_mod_version"])
		iprintln("[Warning] This map requires a newer version of the Soviet Mod.");
}
hide_ctf()
{
	home_flag = getent("home_flag","targetname");	
	enemy_flags = getentarray("enemy_flag", "targetname");

	if(!isdefined(home_flag) || !isdefined(enemy_flags))
		return;

	home_flag hide();
 
	for(i=0;i<enemy_flags.size;i++)
		enemy_flags[i] hide();
}
players_connect_opening()
{
	flag_wait( "all_players_connected" ); 
	players = get_players();
	for( i = 0; i < players.size; i++ )
	{
		players[i] allowstand(true);
		players[i] allowcrouch(true);
		players[i] allowprone(true);
		players[i] setstance("stand");
		players[i] SetClientDvar( "hud_showStance", "0" ); 
		players[i] SetClientDvar( "compass", "0"); 
		players[i] SetClientDvar( "ammoCounterHide", "1" );
		players[i] setClientDvar( "miniscoreboardhide", "0" );
	}
	level thread coop_player_spawn_placement();
}

coop_player_spawn_placement()
{
	structs = getstructarray( "initial_spawn_points", "targetname" ); 

	//chrisp - adding support for overriding the default spawning method

	players = get_players(); 

	for( i = 0; i < players.size; i++ )
	{
		players[i] setorigin( structs[i].origin );  
		players[i].spectator_respawn = structs[i];
	}
}
gamemode_hud()
{
	hud = create_simple_hud();
	hud.alignX = "left"; 
	hud.alignY = "bottom";
	hud.horzAlign = "left"; 
	hud.vertAlign = "bottom";
	hud.alpha = 1;
	hud.x = 20; 
	Hud.y = -35; 
	hud.font = "big"; 
	hud.fontscale = 2.0; 
	hud.color = ( 1, 1, 0.5 ); 

	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
		{
			hud SetText(level.soviet["gamemode_text"] + players[i].score ); 
		}	
		wait(.5);
	}
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_utility;
#include maps\_soviet\soviet_dev;

init(spawners, func, forcemove)
{
	if(isdefined(spawners))
		level.spawner["valid_spawners"] = getentarray(spawners,"targetname");
	else
		level.spawner["valid_spawners"] = getentarray("spawner","targetname");

	if(!isdefined(level.spawner["valid_spawners"]))
		assertmsg("No spawners!");

	for(i=0;i<level.spawner["valid_spawners"].size;i++)
		if(!isdefined(level.spawner["valid_spawners"][i].script_noteworthy))
			assertmsg("Spawner at origin: " + level.spawner["valid_spawners"][i].origin + " doesn't have a script_noteworthy!");

	if(isdefined(func))
		thread [[func]]();	
	else
		thread loop_spawn();

	if(!isdefined(forcemove) || forcemove)
		thread ai_move();
}
loop_spawn()
{
	while(1)
	{
		ai = getaiarray("axis");
		if(ai.size < level.soviet["max_ai"])
		{
			a = randomint(level.spawner["valid_spawners"].size);
			waitTime = level.delay[level.soviet["gamemode"]][level.spawner["valid_spawners"][a].script_noteworthy];	
 
			guy = level.spawner["valid_spawners"][a] dospawn();
 
			if(isDefined(guy))
				guy.dropweapon = false;
 

			dev_add_playback("bots", "Spawned AI at origin: " + level.spawner["valid_spawners"][a].origin + " with wait time: " + waitTime);
			wait(waitTime);
		}
		else if(ai.size > level.soviet["max_ai"])
			assertmsg("Over max AI limit!");
		wait(1);
	}	
}
quake_deathmatch()
{
	players = get_players();
 
	for(i=0;i<players.size;i++)
	{
		players[i] setMoveSpeedScale( 1.6 ); 
		players[i] allowCrouch(false);
		players[i] allowProne(false);
		players[i] allowSprint(false);
		players[i] allowAds(false);
	}
	thread loop_spawn();
}				
ai_move()
{
	while(1)
	{
 
		ai = getaiarray("axis");
		players = get_players();

		if(isdefined(ai))
		{
			for(i=0;i<players.size;i++)
			{
				for(k=0;k<ai.size;k++)
				{
					ai[k].closest_player = get_Closest_player(ai[k].origin);
					nodes = GetAllNodes();
					goal_node = getClosest(ai[k].closest_player.origin, nodes ); 
					ai[k] SetGoalNode( goal_node );
				}
			}
		}
		wait(.25);
	}
}

//////////////////////////////////////////////
//
//	Script Playback System
//	Version: 1.2
//	Tracks in-game scripted events
//	ONLY FOR DEVELOPER MODE
//
//	Scripted by BlueSoviet
//	
//////////////////////////////////////////////


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

dev()
{
/#
	level.playback = [];
	SetDvar( "dev_playback", "" );
	thread dev_dvar_playback();
#/
}
dev_dvar_playback()
{
	while(1)
	{
		cmd = getdvar("dev_playback");
		if(isdefined(level.playback[cmd]))
			dev_print_playback(cmd);
		SetDvar("dev_playback", "");
		wait(.1);
	}
}
 
dev_create_playback(script)
{
/#
	// *** BEGIN MAIN PLAYBACK VAR ***
	level.playback[script] = [];
	level.playback[script][0] = "***DEV SCRIPT PLAYBACK INIT***";
	level.playback[script][1] = "DEV SCRIPT: " + script;
	level.num[script] = level.playback[script].size;
	// *** END MAIN PLAYBACK VAR ***
#/
}
dev_add_playback(script, playback)
{
/#
	if(!isdefined(level.playback[script]) || !isdefined(level.num[script]))
		assertmsg("UNDEFINED PLAYBACK SCRIPT");	
	level.playback[script][level.num[script]] = playback;
	level.num[script]++;		
#/
}
dev_print_playback(script, alert)
{
/#
	if(!isdefined(level.playback[script]))
		assertmsg("UNDEFINED PLAYBACK SCRIPT");	

	println("Script Playback Size: " + level.playback[script].size);
	for(i=0;i<level.playback[script].size;i++)
	{
		if(isdefined(alert) && isstring(alert))
			println(alert + " Playback " + i + ": " + level.playback[script][i]);	
		else
			println("Playback " + i + ": " + level.playback[script][i]);
	}
#/
}
dev_assert(desc, file, line, script)
{
/#
	dev_add_playback(script, "SCRIPT FAIL! Desc: " + desc + " File: " + file + " Line: " + line);
	assertmsg("SCRIPT FAIL! Desc: " + desc + " File: " + file + " Line: " + line);
#/
}
 

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_dev;

init()
{
	level.flags = [];
	level.flags["home"] = getent("home_flag","targetname");	
	level.flags["enemy"] = getentarray("enemy_flag", "targetname");

	if(!isdefined(level.flags["home"]) || !isdefined(level.flags["enemy"]))
		assertmsg("No home or enemy flags!");

	level.flags["home"] show();

	players = get_players();
	for(i=0;i<players.size;i++)
	{
		players[i].has_flag = false;
		dev_add_playback("ctf", ".has_flag set to false for: " + players[i].playername);
	}
	thread flags_init();
}
flags_init()
{		
	level.sa = true;
 
	home_trig = spawn("trigger_radius", level.flags["home"].origin,0,32,32);
	home_trig thread home_init();
	flag_hide();

	dev_add_playback("ctf", "Home flag set at origin: " + home_trig.origin + ". All enemy flags have been hidden.");

	while(1)
	{
		if(level.sa)
		{
			dev_add_playback("ctf", "initializing new flag");
			change_flag();
			wait(1);
			level.flags["current_flag"] enemy_init();
			level.sa = false;
		}
		wait(1);
	}
}
change_flag()
{
	a_flag = randomint(level.flags["enemy"].size);
	level.flags["current_flag"] = level.flags["enemy"][a_flag];
	level.flags["current_trig"] = spawn("trigger_radius", level.flags["current_flag"].origin, 0, 32, 32);
	level.flags["current_trig"] show();
}		
flag_hide()
{
	for(i=0;i<level.flags["enemy"].size;i++)
	{
		dev_add_playback("ctf", "Hiding flag at origin: " + level.flags["enemy"][i].origin);
		level.flags["enemy"][i] hide();
	}
}
 
home_init()
{
	level.flags["home_trig"] = spawn("trigger_radius", level.flags["home"].origin,0,32,32);
	dev_add_playback("ctf", "Spawned trigger radius for home flag.");
	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
		{
			if(players[i].has_flag == true && players[i] istouching(self))
			{
				dev_add_playback("ctf", "Player: " + players[i].playername + " captured flag!");
				players[i].has_flag = false;
				level.fh = false;
				players[i].score++;
				players[i] iprintln("Flag captured!");
				dev_add_playback("ctf", "Level.sa set to true!");
				level.sa = true;

			}
		}
	wait(.1);
	}
}
enemy_init()
{
	self endon("flag_taken");
	self show();
//	org = spawn("script_model", self.origin);
//	org setModel("tag_origin");
//	org moveTo(org groundPos(org.origin), .005);
//	playFxOnTag(level.fx["pickupAvailableEffect"], org, "tag_origin");
//	org.angles = org.angles + (0,180,0);
//	iprintln("tag: " + org getTagAngles("tag_origin") + " Flag: " + self.angles);
	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
		{
			if(players[i].has_flag == false && players[i] istouching(self))
			{
				dev_add_playback("ctf", "Player: " + players[i].playername + " has a flag!");
				self hide();
				players[i].has_flag = true;
				players[i] iprintln("Flag taken!");
				dev_add_playback("ctf", "Deleting current_trig and ending script execution for current flag!");
				// org delete();
				self notify("flag_taken");
				self delete();
			}
		}
		wait(.01);
	}
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_dev;

init()
{
	flag_wait( "all_players_connected" );

	level.hotzones = getentarray("hotzone", "targetname");
	if(!isdefined(level.hotzones))
	{
		dev_assert("No hotzones!", "Soviet_hotzone", 12, "hotzone");
		return;
	}
	else if(!isdefined(level.shader["obj_capture"]) || !isdefined(level.shader["obj_capture"]))
	{
		dev_assert("A hotzone shader is not defined!", "Soviet_hotzone", 17, "hotzone");
		return;
	}
	else if(!isdefined(level.cost["hotzone"]["hotzone_count"]))
	{
		dev_assert("Hotzone count cost not defined!", "Soviet_hotzone", 22, "hotzone");
	}
 
	thread hotzone_init();
}
hotzone_init()
{
	level.hotzone_spawn = true;
	while(1)
	{
		if(level.hotzone_spawn)
		{
			dev_add_playback("hotzone", "initializing new hotzone");
			dynamic_change_hotzone();
			level.c_hotzone hotzone_think();
			level.hotzone_spawn = false;
		}
		wait(1);
	}
}
dynamic_change_hotzone()
{
	a_hotzone = randomint(level.hotzones.size);
	level.c_hotzone = level.hotzones[a_hotzone];
}
hotzone_think()
{
	self endon("count_done");
	if(!isdefined(self.radius) || !isdefined(self.height))
	{
		self.radius = 256;
		self.height = 128;
	}
	count = 0;
	hud = newHudElem(); 
	hud.hideWhenInMenu = true;
	hud SetTargetEnt(self);
	hud setshader(level.shader["obj_capture"]);
	hud SetWayPoint( true, level.shader["obj_capture"]); 
	while(1)
	{
		players = get_players();
		for(i=0;i<players.size;i++)
		{
			if(players[i] istouching(self))
			{
				count++;
				hud setshader(level.shader["obj_defend"]); 
				hud SetTargetEnt(self); 
				if(count == level.cost["hotzone"]["hotzone_count"])
				{
					hud destroy();
					players[i].score++;
					level.hotzone_spawn = true;
					self notify("count_done");			
				}
			}
			else
			{
				hud setshader(level.shader["obj_capture"]);
				hud SetTargetEnt(self); 
			}
 
		}
		wait(1);
	}
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_utility;
#include maps\_soviet\soviet_dev;


init()
{
	if(!isDefined(level.perks))
		level.perks = [];

	level.perks["trigger_use_array"] = getEntArray("perk_trig","targetname");


	if(!isdefined(level.perks["trigger_use_array"]))
		return;

	array_thread(level.perks["trigger_use_array"], ::perk_init );
	array_thread(level.perks["trigger_use_array"], ::effects_init );
}
perk_init()
{
	if(!isdefined(self.script_noteworthy))
		assertmsg("No script_noteworthy for perk trigger at " + self.origin);

	self.cost = level.cost[level.soviet["gamemode"]][self.script_noteworthy];

	if(!isdefined(self.cost))
		assertmsg("Undefined cost for perk: " + self.script_noteworthy + " at origin: " + self.origin);

	string = level.string[level.soviet["gamemode"]][self.script_noteworthy];

	if(!isdefined(string))
		assertmsg("Undefined string for perk: " + self.script_noteworthy + " at origin: " + self.origin);
 
	self sethintstring(string);
	self SetCursorHint( "HINT_NOICON" );
 
	while(1)
	{
		who = undefined;
		self waittill("trigger", who);

		if(who.score >= self.cost && !who hasperk(self.script_noteworthy) && isPlayer(who) && who usebuttonpressed())
			who give_perk(self.script_noteworthy);
		wait(.001);
	}
}
give_perk(perk)
{
	self setperk(perk);
	if(perk == "specialty_fastreload")
		self SetClientDvar("perk_weapReloadMultiplier", .75);		
	else if(perk == "specialty_rof")
		self SetClientDvar("perk_weapratemultiplier", .94);
	self perk_hud_create(perk);
	self perk_think(perk);
}
perk_hud_create( perk )
{
	if ( !IsDefined( self.perk_hud ) )
		self.perk_hud = [];

	shader = level.shader[perk];

	hud = create_simple_hud( self );
	hud.foreground = true; 
	hud.sort = 1; 
	hud.hidewheninmenu = false; 
	hud.alignX = "left"; 
	hud.alignY = "bottom";
	hud.horzAlign = "left"; 
	hud.vertAlign = "bottom";
	hud.x = self.perk_hud.size * 30; 
	hud.y = hud.y - 70; 
	hud.alpha = 1;
	hud SetShader( shader, 24, 24 );

	self.perk_hud[ perk ] = hud;
}
perk_think( perk )
{
	self waittill_any( "fake_death", "death", "player_downed" );

	self UnsetPerk( perk );
	self.maxhealth = 100;
	self perk_hud_destroy( perk );
}		
perk_hud_destroy( perk )
{
	self.perk_hud[ perk ] destroy_hud();
	self.perk_hud[ perk ] = undefined;
}
destroy_hud()
{
	self Destroy(); 
}				
effects_init()
{
	if(!isdefined(self.target) || !isdefined(level._effect[self.script_noteworthy]))
		return;
 
	origin = getent(self.target, "targetname");
	playfx(level._effect[self.script_noteworthy], origin.origin);
	origin playloopsound("perks_machine_loop");
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_dev;

//delays the script by looping until the time var hits zero
script_wait_message(seconds, string1, string2, string3)
{
	level endon("wait_done");
	iprintln(string1);

	time = seconds;
	while(1)
	{
		iprintln(string2 + time + " seconds!");
		wait(1);
		time--;;
		if(time == 0)
		{
			if(isdefined(string3))
				iprintln(string3);
			level notify("wait_done");
 
		}
	}
}
// creates simple HUD element
create_simple_hud( client )
{
	if( IsDefined( client ) )
	{
		hud = NewClientHudElem( client ); 
	}
	else
	{
		hud = NewHudElem(); 
	}

	hud.foreground = true; 
	hud.sort = 1; 
	hud.hidewheninmenu = true; 

	return hud; 
}
// prints the vars array keys to the console
print_array_keys(var)
{
	if(!isDefined(var))
		assertMsg("Var is undefined ");

	if(!isarray(var))
		assertmsg("Var is not an array");

	keys = GetArrayKeys( var );

	if(!isdefined(keys))
		return "no_key";

	for(i=0;i<keys.size;i++)
		iprintln(keys[i]);
}
object_float(height, time)
{
	if(!isDefined(self) || !isDefined(height) || !isDefined(time))
		return undefined;

	self moveTo(self groundPos(self.origin) + (0,0,height), time);
}
do_threaded_tasks(tasks)
{
	if(!isDefined(tasks))
		assertMsg("Tasks not defined!");
	if(!isArray(tasks))
		assertMsg("Tasks is not an array!");

	for(i=0;i<tasks.size;i++)
		thread [[tasks[i]]]();

 
	dev_add_playback("soviet", "Threaded tasks have all been initalized");
}
// Searches through an array for something and returns either the index or a boolean
// Args:
// 	Array = the array you want to search
//	item = the thing your trying to find in the array. MUST be the same data type as whats stored in the array
// 	type = what to return if true. Currently just allows to return the index spot(i) or a boolean.
//
search_array(array, item, type)
{
	for(i=0;i<array.size;i++)
	{
		if(array[i] == item)
		{
			if(isDefined(type) && type == "index")
				return i;
			else
				return true;
		}
	}
	return false;
}
//	Name: spawn_trig_on_notify
//	Purpose: To spawn a trigger_radius at the given origin with the given radius, height, and flags
//	
//	Arguments(name(dataType), description:
//		notifyStr(String): The string to wait for before spawning the trig
//		Origin(origin): The origin of the trig you want to spawn
//		radius(int): radius of the trigger
//		height(int): height of the trigger
//		spawnflags(int): the spawnflags that you want the trigger to spawn with
//
//	Example code:
//		trig = spawn_trig_on_notify("ee_blocker_open", self.origin, 24, 24, 0);	
//
spawn_trig_on_notify(notifyStr, origin, radius, height, spawnflags)
{
	level waittill(notifyStr);
 
	trig = spawn("trigger_radius", origin, spawnflags, radius, height);
	trig SetCursorHint("HINT_NOICON");

	for(i=0;i<get_players().size;i++)
		trig setVisibleToPlayer(get_players()[i]);

	return trig;
}
get_basic_entity_info()
{
	if(!isDefined(self))
		return undefined;

	info = [];

	if(isDefined(self.targetname))	
		info["targetname"] = self.targetname;

	if(isDefined(self.script_noteworthy))
		info["script_noteworthy"] = self.script_noteworthy;

	if(isDefined(self.script_string))
		info["script_string"] = self.script_string;

	if(isDefined(self.script_sound))
		info["script_sound"] = self.script_sound;

	if(isDefined(self.script_activated))
		info["script_activated"] = self.script_activated;

	if(isDefined(self.target))
		info["target"] = self.target;

	return info;
}
set_basic_entity_info(infoArray)
{

	if(!isDefined(self) || !isDefined(infoArray))
		return;

	if(isDefined(infoArray["targetname"]))
		self.targetname = infoArray["targetname"];

	if(isDefined(infoArray["script_noteworthy"]))
		self.script_noteworthy = infoArray["script_noteworthy"];

	if(isDefined(infoArray["script_string"]))
		self.script_string = infoArray["script_string"];

	if(isDefined(infoArray["script_sound"]))
		self.script_sound = infoArray["script_sound"];

	if(isDefined(self.script_activated))
		self.script_activated = infoArray["script_activated"];

	if(isDefined(infoArray["target"]))
		self.target = infoArray["target"];

}
// returns all the spawners with the same script_noteworthy	
get_spawner_array_group(script_noteworthy)
{
	return getentarray(script_noteworthy, "script_noteworthy");
}
/*
	MATH SECTION
*/
get_percent_increase(change, original)
{
	return (change * 100) / original;
}
get_increase_amount(percent, original)
{
	return (percent * original) / 100;
}
get_original_amount(percent, increase)
{
	return (increase * 100) / percent;
}
roundOff(int, mod, mid)
{
	if(!isDefined(int) || !isDefined(mod) || !isDefined(mid))
		return undefined;

	while(int % mod != 0)
	{
		if(int % mod >= mid)
			int++;
		else
			int--;
	}
	return int;	
}

#include maps\_utility; 
#include common_scripts\utility;
#include maps\_soviet\soviet_utility;
#include maps\_soviet\soviet_dev;

init()
{
	if(!isdefined(level.weapon))
		level.weapon = [];
 
	level.weapon["weapons"] = getentarray("weapon","targetname");
	if(!isdefined(level.weapon["weapons"]))
		assertMsg("No Weapons!");
	array_thread(level.weapon["weapons"], ::init_guns);
 
}
init_guns()
{
	if(!isdefined(self.script_noteworthy))
		assertMsg("No script noteworthy for weapon at " + self.origin);


	self.cost = level.cost[level.soviet["gamemode"]][self.script_noteworthy];

	if(!isdefined(self.cost))
		assertMsg("Cost not defined for weapon: " + self.script_noteworthy);

	trig = spawn("trigger_radius",self.origin,0,20,20);
	trig SetCursorHint("HINT_NOICON");

	for(i=0;i<get_players().size;i++)
		trig setVisibleToPlayer(get_players()[i]);

	script_noteworthy_old = self.script_noteworthy;

	if(strTok(self.script_noteworthy, "_").size > 1)
		self.script_noteworthy = strTok(self.script_noteworthy, "_")[0] + " " + strTok(self.script_noteworthy, "_")[1];

	trig sethintstring("Press F for weapon " + self.script_noteworthy + "[" + self.cost + level.ctype + " required for weapon, " + (self.cost + 30) + " for ammo]");

 
	while(1)
	{
		trig waittill("trigger", player);
		if(player istouching(trig) && !player hasweapon(script_noteworthy_old) && player usebuttonpressed())
		{
			if(player.score >= self.cost)
			{
				player takeweapon(player getcurrentweapon());
				player giveweapon(script_noteworthy_old);
				player switchtoweapon(script_noteworthy_old);
			}
		}
		else if(player istouching(trig) && player hasweapon(script_noteworthy_old) && player getCurrentWeapon() == script_noteworthy_old && player usebuttonpressed())
		{
			if(player.score >= self.cost + 30)
				player giveMaxAmmo(player getCurrentWeapon());
		}
 
 
	}
}
init_weapon_affects()
{
	if(!isDefined(level.soviet["allow_weapon_rotation"]) || isDefined(level.soviet["allow_weapon_rotation"]) && level.soviet["allow_weapon_rotation"] == false)
		return;


	if(!isDefined(getentarray("weapon","targetname")))
		assertMsg("No Weapons in the map to rotate!");


	array_thread(getEntArray("weapon", "targetname"), ::affects_think);	
}
affects_think()
{
	if(!isDefined(level.fx["pickupAvailableEffect"]))
		assertMsg("No pickup effect defined!");

	if(isDefined(level.soviet["fixedWeaponHeight"]) && level.soviet["fixedWeaponHeight"])
		self object_float(45, .001);

	playFx(level.fx["pickupAvailableEffect"], self groundPos(self.origin));
	while(1)
	{
		self rotateYaw(-180, 2);
		wait(2);

	}
}
ammoRegen(weapon, type)
{
 

	while(1)
	{

	}
}