cod5-sdk/raw/maps/Payload.gsc

//
//	*******
//	Payload
//	*******
//	Gavin Niebel
//	Tony 'AmishThunder' Kramer
//	Alejandro 'Sparks' Romo

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

#using_animtree( "generic_human" ); 

main()
{
	// Don't load script when compiling Reflections
	if( getdvar( "r_reflectionProbeGenerate" ) == "1" )
	{
		return; 
	}

	// Co-op Callbacks
	level thread onFirstPlayerConnect(); 
	level thread onPlayerConnect(); 

	// Vehicles
	maps\_stuka::main( "vehicle_stuka_flying" ); 
	
	// All Precaching done in here
	// thread animscripts\dog_init::initDogAnimations(); 
	thread maps\_loadout::set_player_interactive_hands( "viewmodel_usa_marine_arms" ); 
	PrecacheStuff(); 

	maps\payload_fx::main(); 
	
	// _load
	maps\_load::main(); 

	// ZOMBIE MODE 
	level thread maps\payload_zombiemode::main(); 

	dvar_init(); 

	waittillframeend; 
	
	// Get the bad guys( we should make them into a prefab so easier to implement in different maps )
	level.Enemy_Spawns = getEntArray( "referenceSpawners", "targetname" ); 
	assertex( isdefined( level.Enemy_Spawns ), "The required Axis NPCs are not in the map." ); 
	
	level.Zombie_Spawns = getEntArray( "zombies", "targetname" ); 
	
	// Get our custom spawning system trigs
	level.Enemy_Triggers = getEntArray( "classSpawner", "targetname" ); 
	assertex( isdefined( level.Enemy_Triggers ), "There are no spawn triggers in the map." ); 
	array_thread( level.Enemy_Triggers, ::spawnTrigThink ); 
	
	// Get payload stuff
	//thread maps\_vehicle::scripted_spawn( 0 ); // Not using a vehicle anymore
	//waittillframeend; 
	level.payload = getEnt( "payload", "targetname" ); 
	level.payloadTrig = getEnt( "payload_trig", "targetname" ); 
	assertex( isDefined( level.payload ), "Payload does not exist." ); 
	assertex( isDefined( level.payloadTrig ), "Payload trigger_radius does not exist." ); 
	
	// Airborne dogs
	// dogsTrig(); 
	
	// Cow mortars
	cowTrigs(); 
	
	// Misc stuff
	level.npcCount = 0; 
	level.dogCount = 0; 
	level.payload_fx = "off"; // FX switch on payload
	level.ZombieMode = 0; // Turns off AI classes
	level.Zombie_Counter = 0; 
	level.zTimer = 0; // Zombie Timer round
	level.ZombiesKilled = 0; // Zombie death counter
	level.endGame = false; // Check for end game
	
	thread player_spawns(); 
	thread payload_think(); 
	
	wait_for_all_players(); 
	
	thread setup_objective(); 
	thread autoSaves(); 
	
	// Start the match
	//round_start(); 
}

////////////////////////////////////////////////
// Level Functions
////////////////////////////////////////////////

// Precache everything in here.
PrecacheStuff()
{
	
	// Strings
	precacheString( &"PAYLOAD_OBJECTIVE" ); 
	precacheString( &"PAYLOAD_TIMER" ); 
	precacheString( &"PAYLOAD_FAILED" ); 
	precacheString( &"PAYLOAD_MASTER" ); 
	
	// Shaders
	PrecacheShader( "hit_direction" ); 
	precacheShader( "compass_waypoint_capture" ); 
	precacheShader( "compass_waypoint_defend" ); 
	
	// Models
	precacheModel( "static_seelow_deadcow" ); 
	precacheModel( "static_seelow_deadcowb" ); 
	precacheModel( "clutter_okinawa_prchute_drpbox" ); 
	precacheModel( "static_seelow_tractor" ); 
	precacheModel( "skybox_mak1" ); 
	precachemodel( "char_ger_honorgd_zomb_behead" ); 
	precachemodel( "char_ger_zombieeye" ); 
	
	// Weapons            
	precacheItem( "molotov" );               
	precacheItem( "m2_flamethrower" );          
	precacheItem( "m1carbine" );                    
	precacheItem( "m1garand" );                 
	precacheItem( "ptrs41" );                   
	precacheItem( "kar98k_scoped" );            
	precacheItem( "shotgun" );                  
	precacheItem( "doublebarrel_sawed_grip" );  
	precacheItem( "doublebarrel" );             
	precacheItem( "gewehr43" );              
	precacheItem( "thompson" );                     
	precacheItem( "stg44" ); 
	precacheItem( "mp40" );         
	precacheItem( "mg42_bipod" );               
	precacheItem( "fg42_bipod" );               
	precacheItem( "bar" );             
	precacheItem( "kar98k" );                      
	precacheItem( "springfield" );               
	precacheItem( "colt" );                                 
	precacheItem( "panzerschrek" ); 	   
	precacheItem( "panzershark" ); 	   
	precacheItem( "walther" ); 
	precacheItem( "sw_357" ); 	
	precacheItem( "30cal_bipod" ); 
}

// Dvar stuff. Create, set, check, whatever you want in here.
dvar_init()
{
	
	// CoDWW Farm Mod Dvar
	setdvar( "payload_farmMod", 	"0" ); 
	
	// Max AI/ Dogs
	// Always make sure the two dvars add up to 32
	setdvar( "payload_maxAi", 	"28" ); 
	setdvar( "payload_maxDogs", 	"4" ); 
	
	// Seconds per match -- Perhaps make it dependent on AI skill?
	setdvar( "payload_timerSecs", 		"600" ); 
	
	// Pushing Points
	setdvar( "payload_pushPoints", 		"10" ); 
	setdvar( "payload_pushPointsSecs", 		"10" ); 
	
	// Kill Points
	setdvar( "payload_killPoints", 	"15" ); 

	// AI Attributes
	setdvar( "payload_attackerHealth", 		"125" ); 
	setdvar( "payload_defenderHealth", 	"100" ); 
	setdvar( "payload_kamikazeHealth", 				"80" ); 
	setdvar( "payload_stealerHealth", 	"175" ); 
}

// Secures a check point every so often via script.
autoSaves()
{
	level endon( "reached_end" ); 
	
	counter = 0; 
	min = 10; // Seconds
	max = 16; // Seconds
	
	while( 1 )
	{		
		wait( RandomIntRange( min , max ) ); 
	
		doSave = maps\_autosave::autosave_check_simple(); 
	
		if( doSave == true )
		{
			autosave_by_name( counter ); 
			counter++; 
		}
	}
}

// Anything pertaining to setting up/handling the payload should be managed from here.
payload_think()
{
	// Link collision to payload
	level.payload_col = getent( "payload_collision", "targetname" ); 
	level.payload_col linkto( level.payload ); 
		
	level.payload.hud = newHudElem(); 
	level.payload.hud.hideWhenInMenu = true; 
	level.payload.hud SetTargetEnt( level.payload ); 
	level.payload.hud setWayPoint( true, "compass_waypoint_capture" ); 
	
	level.payload thread payload_trig_update(); 
	//level.payload thread payload_speed(); // Not using a vehicle anymore
	level.payload thread payload_movement(); 
	//level.payload thread payload_clamp(); // Buggy, perhaps we can use a vehicle
}

// Can't do linkTo with a trigger, so lets just move it with the payload : )
payload_trig_update()
{
	self endon( "death" ); // Do we want the payload to be destroyable?
	
	while( 1 )
	{
		org1 = self getorigin(); 
		level.payloadTrig.origin = org1; 
		wait( 0.2 ); 
	}
}

// Handles the payload moving goal to goal
payload_movement()
{
	
	self endon( "death" ); // Do we want the payload to be destroyable?
	
	// Speed + Acceleration can't be 0 before assigning a Goal
	//self setspeed( 1, 1, 1 ); // Not using a vehicle anymore
	
	self.wayPoints = []; 	
	self.wayPoints = getGoals(); // Stores all the waypoint origins
	self.current_waypoint = 0; 
	
	self getMoving(); 
}

// This handles checking if players are near payload.
// By ChrisP. Modified by Sparks.
getMoving()
{
	level endon( "reached_end" ); 
	
	while( !any_player_isTouching( level.payloadTrig ) )
	{
		level.payload notify( "movedone" ); 
		
		self thread move_tractor( 1, self.origin ); 
		
		self notify( "payload_not_moving" ); // Turns off payload FX
		wait( 0.2 ); 
	}
	
	while( any_player_IsTouching( level.payloadTrig ) )
	{
		// Lets call up the FX first so player( s ) knows they at least came in contact
		if( level.payload_fx == "off" )
		{
			self thread payloadFxThink(); 
		}
			
		// Somebody is near Payload, get how many are near it
		speed = thread how_many_IsTouching( level.payloadTrig ); 	
		
		self thread move_tractor( speed ); 
		wait( 0.2 ); 
	}
	
	self thread getMoving(); 
}

// This just handles the actual moveto of the tractor, and will stop when notified.
// By ChrisP. Modified by Sparks.
move_tractor( speed, origin )
{
	level endon( "reached_end" ); 
	
	if( !isDefined( speed ) )
	{
		speed = 1; 
	}
	
	if( !isDefined( origin ) )
	{
		origin = self.wayPoints[self.current_waypoint]; 
	}
	
	if( !isDefined( self.ismoving ) )
	{
		self.ismoving = true; 
		deadZone = 16; // CoD Units		
		
		// Since we're not using a vehicle, getting the script_model to move faster with more
		// people became a bit more complex to implement. So I placed the script_struct waypoints
		// about 434 units apart from each other on the path that way there would always be
		// just about the same distance between points and we can play with the < time > for moveTo
		// and not worry about having the payload go way too fast between two waypoints with a small gap.
		
		baseSpeed = self thread baseSpeed_tweak(); 
		
		actualSpeed = baseSpeed + speed; 
		
		self moveto( origin , actualSpeed ); 
		
		// Lets check to see if it's within deadZone so it can start moving to next wayPoint
		if( DistanceSquared( self.origin, self.wayPoints[self.current_waypoint] ) < deadZone*deadZone )
		{
			self.current_waypoint++; 
			if( isDefined(self.wayPoints[self.current_waypoint]) )
			{
				angles = VectorToAngles( self.wayPoints[self.current_waypoint] - self.origin ); 
			     self RotateTo( angles +( 0, -90, 0 ), 1 ); 
			}
		}
		
		if( !isDefined( self.wayPoints[self.current_waypoint] ) )
		{
			autosave_by_name( "Zombies" ); 
			wait( .8 ); 
			thread ZombInit(); 
			
			// Payload made it to the end!!!
			level notify( "we_win" ); 
			level notify( "reached_end" ); 
		}
		
		self.ismoving = undefined; 
	}
}

// This just tweaks the moveTo speed based on distance from payload to next point.
baseSpeed_tweak()
{
	distance = Distance( self.origin, self.wayPoints[self.current_waypoint] ); 
	
	if( distance > 375 )
	{
		return 2.5; 
	}

	if( distance > 300 )
	{
		return 2; 
	}

	if( distance > 200 )
	{
		return 1.75; 
	}
	else if( distance > 50 )
	{
		return 1; 
	}
	else if( distance > 25 )
	{
		return .6; 
	}
	else
	{
		return .7; 
	}
}

// Created after we switched to using a script_model. Doesn't well though. :( 
// Will probably be commented out.
payload_clamp()
{
	self endon( "death" ); 

	while( 1 )
	{
		trace = bulletTrace( self.origin +( 0, 0, 10 ), self.origin +( 0, 0, -100 ), false, self ); 

		self.origin = ( trace["position"] ); 
		self.currentsurface = trace["surfacetype"]; 
			
		if( self.currentsurface == "none" )
		{
			self.currentsurface = "default"; 
		}

		wait( 0.05 ); 
	}
}

// Gets all the script_structs for the payload and builds a path.
getGoals()
{	
	wayPoints = []; 
	
	// Get the first point
	Point = getStruct( "firstPoint", "targetname" ); 
	assert( isDefined( Point ), "There is no first point for Payload path." ); 
	
	// Set up path for Payload
	while( isdefined( Point ) )
	{
		wayPoints[wayPoints.size] = Point.origin; 
		
		if( isdefined( Point.target ) )
		{
			Point = getStruct( Point.target, "targetname" ); 
		}
		else // No next point
		{
			break; 
		}
		
	}

	return wayPoints; 
}

get( value )
{	
	return getEnt( value, "targetname" ); 
}

// Dependent upon how many players( non-NPC ) are near the Payload
// Or do we want NPCs to push back?
payload_speed()
{
	self endon( "death" ); // Do we want payload to be destroyable?
	self endon( "reached_end" ); // Finished path, stop moving
	
	while( 1 )
	{
		can_move = false; 
		players = get_players(); 
		
		for( i = 0; i < players.size; i++ )
		{
			if( any_player_IsTouching( level.payloadTrig ) )
			{
				can_move = true; 
			}
		}
		
		if( can_move == true )
		{
			// Lets call up the FX first so player( s ) knows they at least came in contact
			if( level.payload_fx == "off" )
			{
				self thread payloadFxThink(); 
			}
			
			// Somebody is near Payload, get how many are near it
			count = how_many_IsTouching( level.payloadTrig ); 
			
			if( count == 0 ) // Fail safe incase someone has ninja moving skills between can_move check and how_many_isTouching check
			{
				self setspeed( 0, 3, 5 ); 
				self notify( "payload_not_moving" ); // Turns off payload FX
			}
			else if( count == 1 )
			{
				self setspeed( 2, 3, 5 ); 
			}
			else if( count == 2 )
			{
				self setspeed( 3, 4, 5 ); 
			}
			else if( count == 3 )
			{
				self setspeed( 4, 5, 5 ); 
			}
			else // count == 4
			{
				self setspeed( 5, 5, 5 ); 
			}
		}
		else // can_move == false
		{
			// No one is near Payload
			self setspeed( 0, 3, 5 ); 
			self notify( "payload_not_moving" ); // Turns off payload FX
		}	
			
		wait( 0.3 ); 
	}
}

// Spawns an FX on the Payload so players know they're moving it
// Do we want to have different visual FXs for how many people are moving it?
payloadFxThink()
{
	level.payload_fx = "on"; 
	
	level.payload.hud destroy(); 
	level.payload.hud = newHudElem(); 
	level.payload.hud.hideWhenInMenu = true; 
	level.payload.hud SetTargetEnt( level.payload ); 
	level.payload.hud setWayPoint( true, "compass_waypoint_defend" ); 
	
	self waittill( "payload_not_moving" ); 

	level.payload.hud destroy(); 
	level.payload.hud = newHudElem(); 
	level.payload.hud.hideWhenInMenu = true; 
	level.payload.hud SetTargetEnt( level.payload ); 
	level.payload.hud setWayPoint( true, "compass_waypoint_capture" ); 

	level.payload_fx = "off"; 
}

// Returns how many people are moving the Payload
how_many_IsTouching( ent )
{
	players = get_players(); 
	count = 0; 

	for( i = 0; i < players.size; i++ )
	{
		if( IsAlive( players[i] ) && players[i] IsTouching( ent ) )
		{
			weapon = players[i] GetCurrentWeapon(); 
			
			// Players get more ammo for pushing the payload
			if( isDefined( weapon ) &&( weapon != "none" ) )
			{
				players[i] GiveMaxAmmo( weapon ); 
			}
			
			count++; 
		}
	}

	return count; 
}

// Return closest node from array.
get_closest_node( org, nodes )
{
	return getClosest( org, nodes ); 
}

// Just displays an objective for the players incase they're lost.
setup_objective()
{
	objective_add( 1, "active", &"PAYLOAD_OBJECTIVE" ); 
	objective_current( 1 ); 
	
	level waittill( "we_win" ); 
	
	objective_state( 1, "done" ); 
}

////////////////////////////////////////////////
// Zombies
////////////////////////////////////////////////
ZombInit()
{
	// Just a safe re-notify
	level notify( "reached_end" ); 
	
	// Don't let any remaining enemies spawn
	array_thread( level.Enemy_Triggers, ::trigger_off ); 
	
	// Kill any remaining enemies
	ai = GetAIArray( "axis" ); 
	array_thread( ai, ::self_delete ); 
	
	masterHud = newHudElem(); 
	masterHud.alpha = 1; 
	masterHud.hidewheninmenu = true; 
	masterHud.horzAlign = "center"; 
	masterHud.vertAlign = "middle"; 
	masterHud.alignX = "center"; 
	masterHud.alignY = "middle"; 
	masterHud.x = 0; 
	masterHud.y = -60; 
	masterHud.font = "big"; 
	masterHud.fontscale = 2.0; 
	masterHud.color = ( 1, 1, 0.5 ); 
	masterHud setText( &"PAYLOAD_MASTER" ); 
	
	level.ZombieMode = 1; 

	players = get_players(); 
	for( x = 0; x < players.size ; x++ )
	{
		players[x] setExpFog( 50, 256, 0, 0, 0, 0 ); 
		players[x] VisionSetNaked( "mak", 2.0 ); 
		players[x] playSound( "laugh" ); 
		players[x] playLoopSound( "bg_zombie_madness" ); 
		players[x] thread watchDuringZombie(); 
	}
		
	// Make spawners into Zombie
	array_thread( level.Zombie_Spawns, ::add_spawn_function, maps\payload_zombiemode_spawner::zombie_spawn_init );
	
	// How much time players have
	thread zombTimer(); 
	
	// Spawn loot of Zombies by barn
	thread BarnSpawn(); 
	
	masterHud destroy(); 
}

watchDuringZombie()
{
	self endon( "death" ); 
	self endon( "disconnect" ); 
	
	while( 1 )
	{
		self waittill( "damage" ); 
		
		if( self maps\_laststand::player_is_in_laststand() )
		{
			// lol @ player
			self 	playSound( "laugh" ); 
			
			// Don't want to spam the laugh while they're in the same last stand
			while( self maps\_laststand::player_is_in_laststand() )
			{
				wait( 1 ); 
			}
		}
			
		wait( .4 ); 
	}
}

zombTimer()
{
	players = get_players(); 
	
	// Tweak how many seconds per player
	if( players.size == 0 )
	{
		level.zTimer = 100; 
	}
	if( players.size == 1 )
	{
		level.zTimer = 90; 
	}
	if( players.size == 2 )
	{
		level.zTimer = 80; 
	}
	else
	{
		level.zTimer = 60; 
	}
		
	level.timer = maps\_hud_util::get_countdown_hud(); 
	level.timer.label = &"PAYLOAD_TIMER"; 
	level.timer settenthstimer( level.zTimer ); 
	level.start_time = gettime(); 
	
	// Wait for timer
	wait( level.zTimer ); 
	// Timer out!
	
	if( level.ZombiesKilled >= 30 )
	{
		iPrintLnBold( "TEMP: YOU WIN!" ); 
		level.endGame = true; 
		
		wait( 2 ); 
		
		nextmission(); 
	}
	else
	{
		setDvar( "ui_deadquote", &"PAYLOAD_FAILED" ); 
		maps\_utility::missionFailedWrapper(); 	
	}
}

BarnSpawn()
{
	ai = undefined; 
	rand = undefined; 
	eSpawned = undefined; 
	zombsToSpawn = 30; // We can push 32 but lets just be safe : )
	
	while( level.endGame != true )
	{
		while( level.Zombie_Counter < zombsToSpawn )
		{
			rand = RandomInt( level.Zombie_Spawns.size ); 
			
			level.Zombie_Spawns[rand].count = 999; 
			eSpawned = level.Zombie_Spawns[rand] StalingradSpawn(); 
			
			if( spawn_failed( eSpawned ) )
			{
			}
			else
			{
					level.Zombie_Counter++; 
			}
			
			wait( 0.1 ); 
		}
		
		wait( .1 ); 
	}
}

////////////////////////////////////////////////
// Cow Mortars
////////////////////////////////////////////////

// Handles and checks triggers for when to drop cows.
cowTrigs()
{
	array_thread( getEntArray( "cow_drop", "targetname" ), :: cowThink ); 
}

// Handles user triggering for cows.
cowThink()
{
	xmodels = []; 
	xmodels[xmodels.size] = "static_seelow_deadcow"; 
	xmodels[xmodels.size] = "static_seelow_deadcowb"; 
	
	while( 1 )
	{
		self waittill( "trigger" ); 
		
		spawnLocs = getStructArray( self.target, "targetname" ); 
		// TODO: Assert
		
		howManyToSpawn = RandomIntRange( 2, spawnLocs.size ); 
		
		newSpawnLocs = array_randomize( spawnLocs ); 
		
		for( x = 0 ; x < howManyToSpawn ; x++ )
		{
			
			tSpawned = spawn( "script_model", newSpawnLocs[x].origin ); 
			tSpawned setModel( xmodels[RandomInt( xmodels.size )] ); 
			tSpawned RotatePitch( -180, 0.01 ); 
			
			thread fallCow( tSpawned, newSpawnLocs[x] ); 
			
			wait( RandomFloatRange( 0.8, 1.4 ) ); 
		}
		
		wait( RandomIntRange( 4, 10 ) ); 
	}
}

// Drops the cows. Perhaps we can just use BulletTrace later?
fallCow( cow, start )
{
	tTarget = getStruct( start.target, "targetname" ); 
	cow MoveTo( tTarget.origin, RandomIntRange( 1, 3 ), RandomFloatRange( .03, .7 ) , .01 ); 
	
	cow waittill( "movedone" ); 
	
	playfx( level._effect["cow_milk"], cow.origin, ( 1, 0, 0 ) ); 
	thread dropletCheck( cow.origin ); 
	
	cow delete(); 
}

// Checks for player collision with milk splash and plays overlay.
dropletCheck( cowOrigin )
{
	players = get_players(); 
	for( x = 0 ; x < players.size ; x++ )
	{
		if( ( DistanceSquared( players[x].origin, cowOrigin ) < 220*220 ) )
		{
			thread do_milk_drops_on_camera_for_time( RandomIntRange( 5, 10 ), players[x] ); 
		}
	}
}

////////////////////////////////////////////////
// Airborne Dogs
////////////////////////////////////////////////

// Handles and checks triggers for when to drop dogs.
dogsTrig()
{
	array_thread( getEntArray( "dog_drop", "targetname" ), ::dogChuteThink ); 
	thread setup_supply_drop_anims(); 
}

// Handles user triggering for dogs.
dogChuteThink()
{
	level endon( "reached_end" ); 
	
	while( 1 )
	{
		self waittill( "trigger" ); 
		
		thread maps\_vehicle::create_vehicle_from_spawngroup_and_gopath( 1 ); 
		// TODO: Assert
		waittillframeend; 
		
		dog = getEnt( "airborne_dog", "targetname" ); 
		plane = getEnt( "dogPlane", "targetname" ); 
	
		thread spawnerMove( dog, plane ); 
		
		// TODO: Modulate which paths plane can use so map only needs 1 plane for all different paths.
		//plane thread maps\_vehicle::goPath(); 
		
		skyTrig = getent( self.script_linkto, "script_linkname" ); 
		// TODO: Assert
		
		// Plane reaches drop point
		skyTrig waittill( "trigger" ); 
		
		skyTrig thread parachuteAway( dog, self ); 
		
		plane waittill( "reached_end_node" ); 
		plane delete(); 
	
		wait( RandomIntRange( 10, 15 ) ); 
	}
}

// Moves the dog spawner with the plane.
spawnerMove( dog, plane )
{
	while( isDefined( plane ) ) // Should probably use a flag
	{
		dog.origin = plane.origin; 
		wait( 0.3 ); 
	}
}

// Spawn a dog.
parachuteAway( dog, trig )
{
	canSpawn = calculateDogs(); 
	
	for( x = 0 ; x < canSpawn ; x++ )
	{
		dSpawned = dog StalingradSpawn(); 
		
		if( spawn_failed( dSpawned ) )
		{
			continue; 
		}
		
		level.dogCount++; 
		dSpawned thread dogDeathDevent(); 
		dSpawned thread parachuteThink(); 
		
		wait( RandomFloat( 2.0 ) ); 
	}
}

// Lower dog limiter when dog dies.
dogDeathDevent()
{
	self waittill( "death" ); 
	level.dogCount--; 
}

#using_animtree( "supply_drop" ); 
// Handles how the dog parachutes down.
parachuteThink( goal )
{
	self.landedEarly = false; 
	self thread magic_bullet_shield(); 
	
	harness = spawn( "script_model", self.origin ); 
	harness setModel( "clutter_okinawa_prchute_drpbox" ); 
	harness.animName = "drop1"; 
	harness useanimtree( #animtree ); 
	
	anchor = spawn( "script_origin", harness.origin ); 
	harness linkto( self ); 
	
	self linkTo( anchor ); 
	
	if( randomint( 100 ) > 50 )
	{
		str = "landing"; 
	}
	else
	{
		str = "landingb"; 
	}
	
	trace = bulletTrace( self.origin +( 0, 0, 0 ), self.origin +( 0, 0, -10000 ), false, self ); 
	dropLocation = ( trace["position"] ); 
	dropLocation += ( 0, 0, 8 ); 
	
	anchor MoveTo( dropLocation, randomintrange( 4, 6 ) ); 	
	harness thread DogVibrate(); 
	self thread checkLanded( anchor ); 
	
	self DogSplat( anchor, harness ); 
	
	harness notify( "movedone" ); 
	
	if( isAlive( self ) && isDefined( self ) )
	{
		self thread attackPlayers(); 
	}
		
	if( self.landedEarly == false )
	{
		harness thread anim_single_solo( harness, str ); 
		harness waittill( "single anim" ); 
	}
	else
	{
		RadiusDamage( self.origin, 100, self.health + 1000, self.health + 10 ); 
	}
	
	harness delete(); 
	anchor delete(); 
}

// Parachute notifies dog when landed.
checkLanded( anchor )
{
	anchor waittill( "movedone" );	
	self notify( "landed" ); 
}

// Splat. Enough said.
DogSplat( anchor, harness )
{
	self waittill_any( "damage", "landed" ); 
	
	self unLink(); 
	harness unLink(); 
	
	trace = bulletTrace( self.origin +( 0, 0, 0 ), self.origin +( 0, 0, -10000 ), false, self ); 
	fallLocation = ( trace["position"] ); 
	
	if( ( DistanceSquared( self.origin, fallLocation ) > 10*10 ) )
	{
		self.landedEarly = true; 
		
		freeFall = spawn( "script_origin", self.origin ); 
		self linkTo( freeFall ); 
		
		harness hide(); 
		
		freeFall moveto( fallLocation, 0.8 ); 
		freeFall waittill( "movedone" ); 
		
		playfx( level._effect["dog_splat"], freeFall.origin, ( 1, 0, 0 ) ); 
		
		self thread stop_magic_bullet_shield(); 
		
		freeFall delete(); 
	}
	else
	{
		self thread stop_magic_bullet_shield(); 
	}
	
	anchor notify( "movedone" ); 
}

#using_animtree( "supply_drop" ); 
// Originally was just shaking the dog, but now using animations for chute.
DogVibrate()
{
	self.animname = "drop1"; 
	self useanimtree( #animtree ); 
	
	self endon( "movedone" ); 
	
	while( 1 )
	{
		self anim_single_solo( self, "drop" ); 
		self waittill( "single anim" ); 
	}
	
}

// Checks how many Dogs can be spawned in when triggered
calculateDogs()
{
	min = 1; // Always try to spawn at least # 
	max = GetDvarInt( "payload_maxDogs" ); // AI allowed per map
	allocationFree = max - level.dogCount; 
	
	if( allocationFree == 0 ) // No room
	{
		return 0; 
	}
	else if( allocationFree > max ) // Enough for max spawn
	{
		return( RandomIntRange( min, max ) ); 
	}
	else // Already dogs spawned
	{
		return( RandomIntRange( min, allocationFree ) ); 
	}
		
	return min; 
}

////////////////////////////////////////////////
// AI Classes And Logic
////////////////////////////////////////////////

chooseClass( howManyCanSpawn, eLocos )
{
	
	// Defender : Will hold their ground.
	// Attacker : Will charge players.
	// Stealer  : Will try to stop Payload.
	// Kamikaze : Blow up on death.
	
	// Add classes here
	// You can stress/bug test a class by commenting out the rest
	eClasses = []; 
	eClasses[eClasses.size] = "Defender"; 
	eClasses[eClasses.size] = "Attacker"; 
	eClasses[eClasses.size] = "Stealer"; 
	eClasses[eClasses.size] = "Kamikaze"; 
		
	// Cycle and choose what classes are going to spawn
	// Then spawn.
	for( x = 0 ; x < howManyCanSpawn ; x++ )
	{
		eSpawner = undefined; 
		
		tempClass = array_randomize( eClasses ); 
		classToSpawn = tempClass[RandomInt( tempClass.size )]; 
		
		guyWeapon = thread weaponClassThink( classToSpawn ); 
				
		thread moveSpawners( eLocos[x] );

		switch( guyWeapon )
		{
			case "ptrs41":
			case "kar98k":
			case "kar98k_scoped":
			case "gewehr43":
			case "shotgun":
			case "doublebarrel_sawed_grip":
			case "doublebarrel":
				eSpawner = findSpawnerScript( "rifle" );
				break;

			case "m2_flamethrower":
				eSpawner = findSpawnerScript( "flame" );
				break;

			case "mg42_bipod":
			case "fg42_bipod":
			case "30cal_bipod":
				eSpawner = findSpawnerScript( "portable" );
				break;

			case "panzerschrek":
			case "panzershark":
				eSpawner = findSpawnerScript( "bazooka" );
				break;

			case "stg44":
			case "mp40":
				eSpawner = findSpawnerScript( "smg" ); 
				break;

			default:
				eSpawner = findSpawnerScript( "rifle" );
				break;
		}

		wait( 0.3 ); 
		eSpawned = eSpawner doSpawn(); 
		if( spawn_failed( eSpawned ) )
		{
			// empty check
		}
		else
		{
			eSpawned thread spawnEvent( classToSpawn, guyWeapon ); 				
			eSpawned thread flyingBodies(); 
		}
	}
	
	thread resetSpawners(); // Return those spawners back to original location until next time
	
	//level notify( "spawners_ready" ); 
}

flyingBodies()
{
	/* Notes:
		Handles how all the AI go flying when you kill them.
	*/
	
	level endon( "reached_end" ); 
	
	self waittill( "death", player ); 
	origin = self.origin; 
	
	explosionPos = origin +( 0, 0, 24 ); 
	explosionPos -= ( 0, 0, 0 ) * 20; 
	explosionRadius = 70; 
	explosionForce = 4; 

	if( IsPlayer( player ) )
	{
		// Humor Mod Merge -- This isn't working yet.
		//temp = spawn( "script_struct", origin ); 
		//player.kill = newClientHudElem(); 
		//player.kill.hideWhenInMenu = true; 
		//player.kill SetTargetEnt( temp ); 
		//player.kill setShader( "compass_waypoint_capture" ); 
		
		if( ( player GetCurrentWeapon() ) != "m2_flamethrower" ) // Letting burning guys burn
		{
			self startragdoll( 1 ); 
			wait( .05 ); 
			physicsExplosionSphere( explosionPos, explosionRadius, explosionRadius/1.2, explosionForce ); 
			
			// Do a second send off incase the first one was too early.
			wait( .04 ); 			
			physicsExplosionSphere( explosionPos, explosionRadius, explosionRadius/1.5, explosionForce/1.3 ); 
		}
		
		//player.kill fadeovertime( 1.3 ); 
		wait( 1.3 ); 
		//player.kill destroy(); 
		//temp delete(); 
	}
}

// Trys to find the best possible actor for a specific gun.
// That way an actor with flame thrower anims isn't trying
// to fire a bazooka for example.
findSpawnerScript( eNoteWorthy )
{
	spawner = undefined; 
	
	for( x = 0 ; x < level.Enemy_Spawns.size ; x++ )
	{
		if( level.Enemy_Spawns[x].script_noteworthy == eNoteWorthy )
		{
			spawner = level.Enemy_Spawns[x]; 
			continue; 
		}
	}
	
	return spawner; 
}

// Main logic for how the enemy team plays against players.
npcClassInit( classToSpawn, weapon )
{
	assert( isDefined( classToSpawn ), "Enemy does not have an assigned class at: " + self.origin ); 
	
	// Class stuff
	switch( classToSpawn )
	{
		case "Defender":
			self PushPlayer( true ); 
			self enable_pain(); 
			self.goalradius = 1024; 
			self.maxhealth = GetDvarInt( "payload_defenderHealth" ) + 10; 
			self thread getToPlayers(); 
			break; 
		case "Attacker":
			self PushPlayer( true ); 
			self disable_pain(); 
			self.goalradius = 512; 
			self.maxhealth = GetDvarInt( "payload_attackerHealth" ) + 10; 
			self thread getToPlayers(); 
			break; 
		case "Stealer":
			self PushPlayer( true ); 
			self enable_pain(); 
			self.goalradius = 256; 
			self set_force_cover( "none" ); 
			self.maxhealth = GetDvarInt( "payload_stealerHealth" ) + 10; 
			self thread getToCart(); 
			break; 
		case "Kamikaze":
			self PushPlayer( true ); 
			self disable_pain(); 
			self.goalradius = 75; 
			self set_force_cover( "none" ); 
			self.maxhealth = GetDvarInt( "payload_kamikazeHealth" ) + 10; 
			//self thread getToPlayers(); 
			break; 
	}
	
	// Weapon stuff
	switch( weapon )
	{
		case "ptrs41":
		case "kar98k":
		case "kar98k_scoped":
		case "gewehr43":
		case "shotgun":
		case "doublebarrel_sawed_grip":
		case "doublebarrel":
			// Rifles & Shotguns
			self set_npc_weapon( weapon ); 
			break;

		case "m2_flamethrower":
			// Flamethrower
			self set_npc_weapon( weapon ); 
			self.baseaccuracy = 0.05; 
			self.a.flamethrowerShootTime_min = 10000; 
			self.a.flamethrowerShootTime_max = 15000; 
			self.a.flamethrowerShootDelay_min = 0; 
			self.a.flamethrowerShootDelay_max = 1;
			break;

		case "mg42_bipod":
		case "fg42_bipod":
		case "30cal_bipod":
			self set_npc_weapon( weapon ); 
			break;
		case "panzerschrek":
		case "panzershark":
			// Bazooka
			self.grenadeAmmo = 5; 
			//self.dropweapon = false; 
			self set_npc_weapon( weapon ); 
			self.a.no_weapon_switch = true; // They will stick to just using bazookas
			break;

		case "stg44":
		case "mp40":
			// SMGs
			self set_npc_weapon( weapon ); 
			break;
	}
	
	// Need to call this whenever we switch weapons on the fly, 
	// else errors/warnings/bugs galore.
	if( weapon != "m2_flamethrower" ) // Flame thrower guys start with flame throwers, skip the
	{
		self animscripts\init::initWeapon( weapon, "primary" ); 
	}
}

set_npc_weapon( weapon )
{
	self.primaryweapon = weapon;
	self animscripts\init::initWeapon( weapon, "primary" );
	self gun_switchto( weapon, "right" );
}

// Assigns a gun to an enemy dependent upon their class.
weaponClassThink( class )
{
	weaponList = []; 
	weapon = ""; 
	
	switch( class )
	{
		case "Defender":
			weaponList[weaponList.size] = "30cal_bipod"; 
			weaponList[weaponList.size] = "gewehr43"; 
			weaponList[weaponList.size] = "panzershark"; 
			break; 
		case "Attacker":
			weaponList[weaponList.size] = "stg44"; 
			weaponList[weaponList.size] = "gewehr43"; 
			weaponList[weaponList.size] = "doublebarrel_sawed_grip"; 
			weaponList[weaponList.size] = "doublebarrel"; 
			weaponList[weaponList.size] = "shotgun"; 
			break; 
		case "Stealer":
			weaponList[weaponList.size] = "m2_flamethrower"; 
			break; 
		case "Kamikaze":
			weaponList[weaponList.size] = "panzershark"; 
			break; 
		default:
			weaponList[weaponList.size] = "gewehr43"; 
			break; 
	}	
	
	if( weaponList.size > 1 )
	{
		tWeaponList = array_randomize( weaponList ); 
		weapon = tWeaponList[RandomInt( tWeaponList.size )]; 
		return weapon; 
	}
	else
	{
		return weaponList[0]; 
	}
}

// Do anything here we want to happen/check when AI spawn.
spawnEvent( classToSpawn, weapon )
{
	level.npcCount++; 
	self thread npcClassInit( classToSpawn, weapon ); 
	
	self waittill( "death", player ); 

	// Do anything here we want to happen/check when AI die.
	
	if( isDefined( player ) && isPlayer( player ) && isAlive( player ) )
	{
		if( player GetCurrentWeapon() == "m2_flamethrower" )
		{
			RadiusDamage( self.origin, 200, 20, 5 ); 
			playfx( level._effect["kamikaze_boom"], self.origin, ( 1, 0, 0 ) ); 
		}
	}
	
	self.grenadeAmmo = 0; 		
	level.npcCount--; 
}

// Handles user triggering for spawners
spawnTrigThink()
{
	level endon( "reached_end" ); 
	
	while( 1 )
	{
		self waittill( "trigger" ); 
		
		eLocos = getStructArray( self.target, "targetname" ); 
		
		if( !isDefined( eLocos ) )
		{
			continue; // No where to spawn :( 
		}
		
		howManyToSpawn = eLocos.size; 
		howManyCanSpawn = allocationFree( howManyToSpawn ); 
		
		if( !isDefined( howManyCanSpawn ) || howManyCanSpawn <= 0 )
		{
			continue; 
		}
		
		// Fail safe incase we go into Zombie mode
		if( !level.ZombieMode )
		{
			chooseClass( howManyCanSpawn, eLocos ); 
		}
		
		wait( RandomIntRange( 4, 10 ) ); 
	}
}

allocationFree( howManyToSpawn )
{
	/* Notes:
		Checks how many AI can be spawned in when triggered
	*/
	
	min = 2; // Always try to spawn at least # 
	max = GetDvarInt( "payload_maxAi" ); // AI allowed per map
	allocationFree = max - level.npcCount; 
	
	if( allocationFree == 0 ) // No room
	{
		return 0; 
	}
	else if( allocationFree > howManyToSpawn ) // More than enough spawn locos
	{
		if( min >= howManyToSpawn )
		{
			return min; 
		}
		
		return( RandomIntRange( min, howManyToSpawn ) ); 
	}
	else // Enough room for each spawn loco
	{
		if( min >= allocationFree )
		{
			return min; 
		}
		
		return( RandomIntRange( min, allocationFree ) ); 
	}
}

// Moves all the spawners to the same location to location.
// findSpawnerScript() chooses which actor to spawn from then moves them.
// It won't/shouldn't telefrag since Spawners are only visual references. ; )
moveSpawners( eLoc )
{
	for( x = 0 ; x < level.Enemy_Spawns.size ; x++ )
	{
		level.Enemy_Spawns[x].origin = eLoc.origin; 
	}
}

// Takes the spawners back to their original location.
// Not really necessary but hey, might as well know where
// our spawners are at when not creating AI.
resetSpawners()
{
	for( x = 0 ; x < level.Enemy_Spawns.size ; x++ )
	{
		tLoc = getEnt( level.Enemy_Spawns[x].target, "targetname" ); 
		level.Enemy_Spawns[x].origin = tLoc getorigin(); 
	}
}

// Reset a single spawner back to its original location.
resetSpawner()
{
	
	tLoc = getEnt( self.target, "targetname" ); 
	self.origin = tLoc getorigin(); 
}

////////////////////////////////////////////////
// AI House Keeping
////////////////////////////////////////////////

// Makes a guy fire at the players.
fireAtPlayers()
{
	self endon( "death" ); 
	
	while( 1 )
	{
		temp = get_players(); 
		mixMeUp = array_randomize( temp ); 
		player = mixMeUp[RandomInt( mixMeUp.size )]; 
		self.goal = player; 
		self thread timeout( RandomIntRange( 4, 6 ) ); 
		
		self waittill_any( "damage", "timeout" ); 
		
		wait( 1 ); 
	}
}

// Makes a dog go straight for players.
// Woof! >: )
attackPlayers()
{
	self endon( "death" ); 
	
	while( 1 )
	{
		temp = get_players(); 
		mixMeUp = array_randomize( temp ); 
		player = mixMeUp[RandomInt( mixMeUp.size )]; 
		self SetGoalPos( player.origin ); 
		self.team = "axis"; 
		self thread timeout( RandomIntRange( 3, 4 ) ); 
		
		self waittill_any( "damage", "timeout" ); 
		
		wait( 1  ); 
	}
}

// Makes an AI go straight for players.
// Watch out! : )
getToPlayers()
{
	self endon( "death" ); 
	
	while( 1 )
	{
		temp = get_players(); 
		players = array_randomize( temp ); 
		self SetGoalPos( players[RandomInt( players.size )] getOrigin() ); 
		self thread timeout( RandomIntRange( 2, 5 ) ); 
		
		self waittill_any( "goal", "damage", "timeout" ); 
		
		wait( 1 ); 
	}
}

// Makes an AI go straight for the payload.
getToCart()
{
	
	self endon( "death" ); 
	
	self SetGoalPos( level.payload getOrigin() ); 
	self waittill( "goal" ); 
	
	while( 1 )
	{
		self SetGoalPos( level.payload getOrigin() ); 
		
		self waittill_any( "goal" ); 
		
		wait( RandomInt( 5 )  ); 
	}
}

// Disable all spawners for xyz reason.
disableSpawners()
{	
	for( x = 0 ; x < level.Enemy_Spawns.size ; x++ )
	{
		level.Enemy_Spawns[x].count = 0; 
	}
}

// Disable a spawner for xyz reason.
disableSpawner()
{	
	self.count = 0; 
}

// Enable all spawners for xyz reason.
enableSpawners()
{
	for( x = 0 ; x < level.Enemy_Spawns.size ; x++ )
	{
		level.Enemy_Spawns[x].count = 9999999; 
	}
}

// Enable a spawner for xyz reason.
enableSpawner()
{	
	self.count = 9999999; 
}

////////////////////////////////////////////////
// Co-Op Callbacks
////////////////////////////////////////////////

onFirstPlayerConnect()
{
	level waittill( "connecting_first_player", player ); 
	
	// put any calls here that you want to happen when the FIRST player connects to the game
	println( "First player connected to game." ); 
}

onPlayerConnect()
{
	for( ;; )
	{
		level waittill( "connecting", player ); 

		player thread onPlayerDisconnect(); 
		player thread onPlayerSpawned(); 
		player thread onPlayerKilled(); 
	
		// put any calls here that you want to happen when the player connects to the game
		println( "Player connected to game." ); 
		
		player.score = 0;
		
		// Dvars
		player setClientDvars( "ragdoll_explode_force", 30000, 
							 "jump_height", 110, 
							 "jump_slowdownEnable", 0, 
							 "player_sprintUnlimited", 1, 
							 "player_clipSizeMultiplier", 1.0, 
							 "phys_gravity", -400, 
							 "ragdoll_bullet_force", 500, 
							 "ragdoll_explode_upbias", 0.7, 
							 "bg_fallDamageMinHeight", 256, 
							 "bg_fallDamageMaxHeight", 512 ); 
	}
}

onPlayerDisconnect()
{
	self waittill( "disconnect" ); 
	
	// put any calls here that you want to happen when the player disconnects from the game
	// this is a good place to do any clean up you need to do
	println( "Player disconnected from the game." ); 
}

onPlayerSpawned()
{
	self endon( "disconnect" ); 	
	
	for( ;; )
	{
		self waittill( "spawned_player" ); 
		
		wait( 0.4 ); 
		
		self takeallweapons(); 
		
		self thread onPlayerSpawned_ChooseClass(); 
		
		self thread maps\_loadout::set_laststand_pistol( "colt" ); 
	}
}

onPlayerSpawned_ChooseClass()
{
	class = RandomInt( 2 ); 
	
	switch( class )
	{
		case 0:
			// MG guy
			self GiveWeapon( "fg42_bipod" ); 
			self GiveMaxAmmo( "fg42_bipod" ); 
			self GiveWeapon( "mg42_bipod" ); 
			self GiveMaxAmmo( "mg42_bipod" ); 
			self GiveWeapon( "30cal_bipod" ); 
			self GiveMaxAmmo( "30cal_bipod" ); 
			
			self GiveWeapon( "fraggrenade" ); 
			
			self SwitchToWeapon( "fg42_bipod" ); 
			break; 
			
		case 1:
			// Explosives guy
			self GiveWeapon( "colt_dirty_harry" ); 
			self GiveWeapon( "m2_flamethrower" ); 
			self GiveWeapon( "fraggrenade" ); 
			self GiveWeapon( "molotov" ); 
			
			self GiveWeapon( "panzershark" ); 
			self GiveMaxAmmo( "panzershark" ); 
			
			self SwitchToWeapon( "colt_dirty_harry" ); 
			break; 
			
		case 2:
			// Maximum damage guy
			self GiveWeapon( "doublebarrel_sawed_grip" ); 
			self GiveMaxAmmo( "doublebarrel_sawed_grip" ); 
			self GiveWeapon( "doublebarrel" ); 
			self GiveMaxAmmo( "doublebarrel" ); 
			self GiveWeapon( "shotgun" ); 
			self GiveMaxAmmo( "shotgun" ); 			
			
			self GiveWeapon( "fraggrenade" ); 
			
			self SwitchToWeapon( "doublebarrel_sawed_grip" ); 
			break; 
	}
}

onPlayerKilled()
{
	self endon( "disconnect" ); 
	
	for( ;; )
	{
		self waittill( "killed_player" ); 

		// put any calls here that you want to happen when the player gets killed
		//println( "Player killed at " + self.origin ); 
		
	}
}

////////////////////////////////////////////////
// Co-Op House Keeping
////////////////////////////////////////////////

player_spawns()
{
	/* Notes:
		At the start of the map place players at spots.
		Otherwise they'll spawn inside each other.
	*/
	
	structs = getStructArray( "player_spawn", "targetname" ); 
	
	flag_wait( "all_players_connected" ); 
	
	players = get_players(); 
	
	for( i = 0; i < players.size; i++ )
	{
		players[i] setorigin( structs[i].origin ); 
		players[i] setplayerangles( structs[i].angles ); 
	}
}

do_milk_drops_on_camera_for_time( wait_time, player )
{
	/* Notes:
		If a player gets hit with milk.
			From Pel2. Modified by Sparks.
	*/
	
	players_water_drops_on( player ); 
	
	wait( wait_time ); 
	
	players_water_drops_off( player ); 
}

players_water_drops_on( player )
{
	player setwaterdrops( 300 ); 
}

players_water_drops_off( player )
{
	player setwaterdrops( 0 ); 
}

////////////////////////////////////////////////
// Anims
////////////////////////////////////////////////

#using_animtree( "supply_drop" ); 
setup_supply_drop_anims()
{
	/* Notes:
		Parachute animations for the airborne dogs.
	*/
	
	level.scr_anim["drop"]["drop"]							 = %o_supplydrop_loop; 
	level.scr_anim["drop"]["landing"]					 = %o_supplydrop_landing; 
	level.scr_anim["drop"]["landingb"] 				 = %o_supplydrop_landingB; 
	level.scr_anim["drop1"]["drop"]							 = %o_supplydrop_loop; 
	level.scr_anim["drop1"]["landing"]					 = %o_supplydrop_landing; 
	level.scr_anim["drop1"]["landingb"] 				 = %o_supplydrop_landingB; 
	
}