Added BO1 ZM rawfiles

BO1/PC/ZM/clientscripts/_airsupport.csc

@@ -0,0 +1,299 @@
+#include clientscripts\_utility;
+#include clientscripts\_utility_code;
+#include clientscripts\_vehicle;
+planeSounds( spawnSound, flybySound, flybySoundLoop, lengthOfFlyby )
+{
+	self endon("delete");
+	fake_ent_plane = spawnfakeent( 0 );
+	playsound (0, spawnSound, (0,0,0));
+	thread plane_position_updater (fake_ent_plane, self, flybySound, flybySoundLoop, lengthOfFlyBy);
+}
+plane_position_updater ( fake_ent, plane, flybySound, flybySoundLoop, lengthOfFlyby )
+{
+	soundid = -1;
+	dx = undefined;
+	lastTime = undefined;
+	lastPos = undefined;
+	startTime = 0;
+	while(IsDefined(plane))
+	{
+		setfakeentorg(0, fake_ent, plane.origin);
+		if((soundid < 0) && isdefined(lastPos))
+		{
+			dx = plane.origin - lastPos;
+			if(length(dx) > .01)
+			{
+				velocity = dx / (getrealtime()-lastTime);
+				assert(isdefined(velocity));
+				players = getlocalplayers();
+				assert(isdefined(players));
+				other_point = plane.origin + (velocity * 100000);
+				point = closest_point_on_line_to_point(players[0].origin, plane.origin, other_point );
+				assert(isdefined(point));
+				dist = Distance( point, plane.origin );
+				assert(isdefined(dist));
+				time = dist / length(velocity);
+				assert(isdefined(time));
+				if( time < lengthOfFlyby )
+				{
+					if ( isdefined ( flybysoundloop ) )
+						soundid = playloopsound(0, fake_ent, flybySoundLoop, 0 );
+					if ( isdefined ( flybySound ) )
+						plane playsound (0, flybySound);
+					startTime = getRealTime();
+				}
+			}
+		}
+		lastPos = plane.origin;
+		lastTime = getrealtime();
+		realwait(0.1);
+	}
+	wait (5);
+	deletefakeent(0, fake_ent);
+}
+closest_point_on_line_to_point( Point, LineStart, LineEnd )
+{
+	LineMagSqrd = lengthsquared(LineEnd - LineStart);
+	t =	( ( ( Point[0] - LineStart[0] ) * ( LineEnd[0] - LineStart[0] ) ) +
+	( ( Point[1] - LineStart[1] ) * ( LineEnd[1] - LineStart[1] ) ) +
+	( ( Point[2] - LineStart[2] ) * ( LineEnd[2] - LineStart[2] ) ) ) /
+	( LineMagSqrd );
+	if( t < 0.0 )
+	{
+		return LineStart;
+	}
+	else if( t > 1.0 )
+	{
+		return LineEnd;
+	}
+	else
+	{
+		start_x = LineStart[0] + t * ( LineEnd[0] - LineStart[0] );
+		start_y = LineStart[1] + t * ( LineEnd[1] - LineStart[1] );
+		start_z = LineStart[2] + t * ( LineEnd[2] - LineStart[2] );
+		return (start_x,start_y,start_z);
+	}
+}
+getPlaneModel( teamFaction )
+{
+	switch ( teamFaction )
+	{
+		case "vietcong":
+		planemodel = "t5_veh_air_mig_21_nva_flying";
+		break;
+		case "nva":
+		planemodel = "t5_veh_air_mig_21_nva_flying";
+		break;
+		case "japanese":
+		planemodel = "t5_veh_air_mig_21_ussr_flying";
+		break;
+		case "russian":
+		planemodel = "t5_veh_air_mig_21_ussr_flying";
+		break;
+		case "marines":
+		planemodel = "t5_veh_jet_f4_gearup";
+		break;
+		case "specops":
+		planemodel = "t5_veh_jet_f4_gearup";
+		break;
+		default:
+		println( "invalid faction, defaulting to marines" );
+		planemodel = "t5_veh_jet_f4_gearup";
+		break;
+	}
+	return planeModel;
+}
+planeTurnLeft( plane, yaw, halflife )
+{
+	plane endon("delete");
+	yawY = getDvarFloatDefault( #"scr_planeyaw", 0.6 );
+	rollZ = getDvarFloatDefault( #"scr_planeroll", -1.5 );
+	maxYaw = getDvarFloatDefault( #"scr_max_planeyaw", 45.0 );
+	minRoll = getDvarFloatDefault( #"scr_min_planeroll", -60.0 );
+	ox = getDvarFloatDefault( #"scr_planeox", 30000.0 );
+	oy = getDvarFloatDefault( #"scr_planeoy", 30000.0 );
+	maxoX = getDvarFloatDefault( #"scr_maxo_planex", -1.0 );
+	maxoY = getDvarFloatDefault( #"scr_maxo_planey", -1.0 );
+	if (plane.angles[1] == 360)
+		plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+	origX = plane.origin[0];
+	origY = plane.origin[1];
+	accumTurn = 0;
+	looptime = 0.1;
+	while( loopTime <= halflife )
+	{
+		if (plane.angles[1] == 360)
+			plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+		if ( minRoll != -1 && plane.angles[2] <= minRoll )
+			rollZ = 0.0;
+		accumTurn += yawY;
+		if ( accumTurn >= maxYaw )
+		{
+			yawY = 0.0;
+		}
+		plane.angles = ( plane.angles[0], plane.angles[1] + yawY, plane.angles[2] + rollZ);
+		mathX = ( sin ( 45 * looptime / halflife ) ) * ox ;
+		mathY = ( cos ( 45 * looptime / halflife ) ) * oy ;
+		oldX = mathX;
+		oldY = oy - mathY;
+		rotatedX = Cos(yaw) * oldX - Sin(yaw) * oldY;
+		rotatedY = Sin(yaw) * oldX + Cos(yaw) * oldY;
+		endPoint = ( origX + rotatedX, origY + rotatedY, plane.origin[2]);
+		plane moveTo( endPoint, 0.1, 0, 0 );
+		realwait (0.1);
+		loopTime += 0.1;
+	}
+	yawY = getDvarFloatDefault( #"scr_planeyaw2", 0.6 );
+	rollZ = getDvarFloatDefault( #"scr_planeroll2", -0.9 );
+	ox = getDvarFloatDefault( #"scr_planeox", 30000.0 );
+	oy = getDvarFloatDefault( #"scr_planeoy", 30000.0 );
+	maxoX = getDvarFloatDefault( #"scr_maxo_planex", -1.0 );
+	maxoY = getDvarFloatDefault( #"scr_maxo_planey", -1.0 );
+	y = getDvarFloatDefault( #"scr_planey2", 0.6 );
+	z = getDvarFloatDefault( #"scr_planez2", -1.5 );
+	maxy = getDvarFloatDefault( #"scr_max_planey2", 90);
+	accumTurn = 0;
+	while( loopTime < halflife + halflife )
+	{
+		if (plane.angles[1] == 360)
+			plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+		if ( minRoll != -1 && plane.angles[2] >= 0 )
+			rollZ = 0.0;
+		accumTurn += yawY;
+		if ( accumTurn >= maxYaw )
+		{
+			yawY = 0.0;
+		}
+		plane.angles = ( plane.angles[0], plane.angles[1] + yawY, plane.angles[2] - rollZ);
+		mathX = ( sin ( 45 * looptime / halflife ) ) * ox ;
+		mathY = ( cos ( 45 * looptime / halflife ) ) * oy ;
+		oldX = mathX;
+		oldY = oy - mathY;
+		rotatedX = Cos(yaw) * oldX - Sin(yaw) * oldY;
+		rotatedY = Sin(yaw) * oldX + Cos(yaw) * oldY;
+		endPoint = ( origX + rotatedX, origY + rotatedY, plane.origin[2]);
+		plane moveTo( endPoint, 0.1, 0, 0 );
+		realwait (0.1);
+		loopTime += 0.1;
+	}
+}
+planeTurnRight( plane, yaw, halflife )
+{
+	plane endon("delete");
+	yawY = getDvarFloatDefault( #"scr_planeyaw", -0.6 );
+	rollZ = getDvarFloatDefault( #"scr_planeroll", 1.5 );
+	maxYaw = getDvarFloatDefault( #"scr_max_planeyaw", -45.0 );
+	minRoll = getDvarFloatDefault( #"scr_min_planeroll", 60.0 );
+	ox = getDvarFloatDefault( #"scr_planeox", 30000.0 );
+	oy = getDvarFloatDefault( #"scr_planeoy", -30000.0 );
+	maxoX = getDvarFloatDefault( #"scr_maxo_planex", -1.0 );
+	maxoY = getDvarFloatDefault( #"scr_maxo_planey", -1.0 );
+	if (plane.angles[1] == 360)
+		plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+	origX = plane.origin[0];
+	origY = plane.origin[1];
+	accumTurn = 0;
+	looptime = 0.1;
+	while( loopTime <= halflife )
+	{
+		if (plane.angles[1] == 360)
+			plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+		if ( minRoll != -1 && plane.angles[2] >= minRoll )
+			rollZ = 0.0;
+		accumTurn += yawY;
+		if ( accumTurn <= maxYaw )
+		{
+			yawY = 0.0;
+		}
+		plane.angles = ( plane.angles[0], plane.angles[1] + yawY, plane.angles[2] + rollZ);
+		mathX = ( sin ( 45 * looptime / halflife ) ) * ox ;
+		mathY = ( cos ( 45 * looptime / halflife ) ) * oy ;
+		oldX = mathX;
+		oldY = oy - mathY;
+		rotatedX = Cos(yaw) * oldX - Sin(yaw) * oldY;
+		rotatedY = Sin(yaw) * oldX + Cos(yaw) * oldY;
+		println( rotatedX + " " + rotatedY + "\n" );
+		endPoint = ( origX + rotatedX, origY + rotatedY, plane.origin[2]);
+		plane moveTo( endPoint, 0.1, 0, 0 );
+		realwait (0.1);
+		loopTime += 0.1;
+	}
+	yawY = getDvarFloatDefault( #"scr_planeyaw2", 0.6 );
+	rollZ = getDvarFloatDefault( #"scr_planeroll2", -0.9 );
+	ox = getDvarFloatDefault( #"scr_planeox", 30000.0 );
+	oy = getDvarFloatDefault( #"scr_planeoy", -30000.0 );
+	maxoX = getDvarFloatDefault( #"scr_maxo_planex", -1.0 );
+	maxoY = getDvarFloatDefault( #"scr_maxo_planey", -1.0 );
+	y = getDvarFloatDefault( #"scr_planey2", 0.6 );
+	z = getDvarFloatDefault( #"scr_planez2", -1.5 );
+	maxy = getDvarFloatDefault( #"scr_max_planey2", 90);
+	accumTurn = 0;
+	while( loopTime < halflife + halflife )
+	{
+		if (plane.angles[1] == 360)
+			plane.angles = ( plane.angles[0], 0, plane.angles[2] );
+		if ( minRoll != -1 && plane.angles[2] >= 0 )
+			rollZ = 0.0;
+		accumTurn += yawY;
+		if ( accumTurn >= maxYaw )
+		{
+			yawY = 0.0;
+		}
+		plane.angles = ( plane.angles[0], plane.angles[1] + yawY, plane.angles[2] - rollZ);
+		mathX = ( sin ( 45 * looptime / halflife ) ) * ox ;
+		mathY = ( cos ( 45 * looptime / halflife ) ) * oy ;
+		oldX = mathX;
+		oldY = oy - mathY;
+		rotatedX = Cos(yaw) * oldX - Sin(yaw) * oldY;
+		rotatedY = Sin(yaw) * oldX + Cos(yaw) * oldY;
+		endPoint = ( origX + rotatedX, origY + rotatedY, plane.origin[2]);
+		plane moveTo( endPoint, 0.1, 0, 0 );
+		realwait (0.1);
+		loopTime += 0.1;
+	}
+}
+doABarrelRoll( plane, endPoint, time )
+{
+	plane endon("delete");
+	plane moveTo( endPoint, time, 0, 0 );
+	rollZ = getDvarFloatDefault( #"scr_barrelroll", 10 );
+	degreesToRoll = getDvarFloatDefault( #"scr_degreesToRoll", 720 );
+	degreesRolled = 0;
+	while ( degreesRolled < degreesToRoll )
+	{
+		plane.angles = ( plane.angles[0], plane.angles[1], plane.angles[2] + rollZ);
+		degreesRolled += rollZ;
+		realwait (0.01);
+	}
+}
+planeGoStraight( plane, endPoint, time )
+{
+	plane endon("delete");
+	plane moveTo( endPoint, time, 0, 0 );
+}
+debug_line( from, to, color, time )
+{
+}
+debug_star( origin, color, time )
+{
+}
+getDvarFloatDefault( dvarName, defaultValue)
+{
+	returnVal = defaultValue;
+	if (getDvar(dvarName) != "")
+	{
+		return getDvarFloat(dvarName);
+	}
+	return returnVal;
+}
+getDvarIntDefault( dvarName, defaultValue)
+{
+	returnVal = defaultValue;
+	if (getDvar(dvarName) != "")
+	{
+		return getDvarInt(dvarName);
+	}
+	return returnVal;
+}	
+
+

BO1/PC/ZM/clientscripts/_ambientpackage.csc

@@ -0,0 +1,644 @@
+#include clientscripts\_utility;
+deactivateAmbientPackage(client, package, priority)
+{
+	if ( !isdefined( level.ambientPackages[package] ) )
+	{
+		assertmsg( "deactivateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb main before it can be deactivated" );
+		return;
+	}
+	for( i = 0; i < level.ambientPackages[package].priority.size; i++)
+	{
+		if ( level.ambientPackages[package].priority[i] == priority && level.ambientPackages[package].refcount[i] )
+		{
+			level.ambientPackages[package].refcount[i]--;
+			level notify( "updateActiveAmbientPackage" );
+			return;
+		}
+	}
+}
+deactivateAmbientRoom(client, room, priority)
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "deactivateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb main before it can be deactivated" );
+		return;
+	}
+	for( i = 0; i < level.ambientRooms[room].priority.size; i++ )
+	{
+		if( level.ambientRooms[room].priority[i] == priority && level.ambientRooms[room].refcount[i] )
+		{
+			level.ambientRooms[room].refcount[i]--;
+			level notify( "updateActiveAmbientRoom" );
+			return;
+		}
+	}
+}
+trig_enter(ent)
+{
+	if( self.useAmbientPackage )
+		activateAmbientPackage( 0, self.script_ambientpackage, self.script_ambientpriority);
+	if( self.useAmbientRoom )
+		activateAmbientRoom( 0, self.script_ambientroom, self.script_ambientpriority );
+}
+trig_leave(ent)
+{
+	if( self.useAmbientPackage )
+		deactivateAmbientPackage( 0, self.script_ambientpackage, self.script_ambientpriority );
+	if( self.useAmbientRoom )
+		deactivateAmbientRoom( 0, self.script_ambientroom, self.script_ambientpriority );
+}
+AmbientPackageTrigger()
+{
+	hasAmbientRoom = isdefined ( self.script_ambientroom );
+	useAmbientRoom = hasAmbientRoom && isdefined( level.ambientRooms[self.script_ambientroom] );
+	hasAmbientPackage = isdefined ( self.script_ambientpackage );
+	useAmbientPackage = hasAmbientPackage && isdefined( level.ambientPackages[self.script_ambientpackage] );
+	self.useAmbientRoom = useAmbientRoom;
+	self.useAmbientPackage = useAmbientPackage;
+	if (hasAmbientRoom && !useAmbientRoom)
+	{
+		assertmsg( "Trigger at " + self.origin + " references ambient room '" + self.script_ambientroom + "', but no such room has been declared\n" );
+		return;
+	}
+	if (hasAmbientPackage && !useAmbientPackage)
+	{
+		assertmsg( "Trigger at " + self.origin + " references ambient package '" + self.script_ambientpackage + "', but no such package has been declared\n" );
+		return;
+	}
+	if(!useAmbientPackage && !useAmbientRoom)
+	{
+		assertmsg( "Trigger at " + self.origin + " is an ambient trigger but has no room or package \n" );
+		return;
+	}
+	if ( !isdefined( self.script_ambientpriority ) )
+	{
+		self.script_ambientpriority = 1;
+	}
+	self.in_volume = [];
+	for (;;)
+	{
+		self waittill ( "trigger", trigPlayer );
+		if(trigPlayer issplitscreenhost())
+		{
+			self thread trigger_thread(trigPlayer, ::trig_enter, ::trig_leave);
+		}
+		wait(0.01);
+	}
+}
+init_ambient_package_triggers()
+{
+	wait(0.1);
+	player = GetLocalPlayers()[0];
+	remove_triggers_from_ent( player );
+	trigs = GetEntArray( 0, "ambient_package","targetname");
+	array_thread( trigs, ::ambientPackageTrigger);
+	println("Client : " + trigs.size + " ambient package triggers.");
+}
+init()
+{
+	level.activeAmbientPackage = "";
+	level.ambientPackages = [];
+	level.ambientNumMissedSounds = 0;
+	level.ambientNumSeqMissedSounds = 0;
+	thread updateActiveAmbientPackage();
+	thread saveRestore();
+	level.ambientPackageScriptOriginPool = [];
+	for ( i = 0; i < 5; i++ )
+	{
+		level.ambientPackageScriptOriginPool[i] = spawnStruct();
+		level.ambientPackageScriptOriginPool[i].org = spawnfakeent(0);
+		level.ambientPackageScriptOriginPool[i].inuse = false;
+		level.ambientPackageScriptOriginPool[i] thread scriptOriginPoolThread();
+	}
+	level.activeAmbientRoom = "";
+	level.ambientRooms = [];
+	level thread updateActiveAmbientRoom();
+	clientscripts\_utility::registerSystem("ambientPackageCmd", ::ambientPackageCmdHandler);
+	clientscripts\_utility::registerSystem("ambientRoomCmd", ::ambientRoomCmdHandler);
+	level thread init_ambient_package_triggers();
+}
+declareAmbientPackage( package )
+{
+	if ( isdefined( level.ambientPackages[package] ) )
+		return;
+	level.ambientPackages[package] = spawnStruct();
+	level.ambientPackages[package].priority = [];
+	level.ambientPackages[package].refcount = [];
+	level.ambientPackages[package].elements = [];
+}
+addAmbientElement( package, alias, spawnMin, spawnMax, distMin, distMax, angleMin, angleMax )
+{
+	if ( !isdefined( level.ambientPackages[package] ) )
+	{
+		assertmsg( "addAmbientElement: must declare ambient package \"" + package + "\" in level_amb main before it can have elements added to it" );
+		return;
+	}
+	index = level.ambientPackages[package].elements.size;
+	level.ambientPackages[package].elements[index] = spawnStruct();
+	level.ambientPackages[package].elements[index].alias = alias;
+	if ( spawnMin < 0 )
+		spawnMin = 0;
+	if ( spawnMin >= spawnMax )
+		spawnMax = spawnMin + 1;
+	level.ambientPackages[package].elements[index].spawnMin = spawnMin;
+	level.ambientPackages[package].elements[index].spawnMax = spawnMax;
+	level.ambientPackages[package].elements[index].distMin = -1;
+	level.ambientPackages[package].elements[index].distMax = -1;
+	if ( isdefined( distMin ) && isdefined( distMax ) && distMin >= 0 && distMin < distMax )
+	{
+		level.ambientPackages[package].elements[index].distMin = distMin;
+		level.ambientPackages[package].elements[index].distMax = distMax;
+	}
+	level.ambientPackages[package].elements[index].angleMin = 0;
+	level.ambientPackages[package].elements[index].angleMax = 359;
+	if ( isdefined( angleMin ) && isdefined( angleMax ) && angleMin >= 0 && angleMin < angleMax && angleMax <= 720 )
+	{
+		level.ambientPackages[package].elements[index].angleMin = angleMin;
+		level.ambientPackages[package].elements[index].angleMax = angleMax;
+	}
+}
+declareAmbientRoom( room )
+{
+	if ( isdefined( level.ambientRooms[room] ) )
+		return;
+	level.ambientRooms[room] = spawnStruct();
+	level.ambientRooms[room].priority = [];
+	level.ambientRooms[room].refcount = [];
+	level.ambientRooms[room].ent = spawnfakeent(0);
+}
+setAmbientRoomTone( room, alias, fadeIn, fadeOut )
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "setAmbientRoomTone: must declare ambient room \"" + room + "\" in level_amb main before it can have a room tone set" );
+		return;
+	}
+	level.ambientRooms[room].tone = alias;
+	level.ambientRooms[room].fadeIn = 2;
+	if ( isDefined( fadeIn ) && fadeIn >= 0 )
+	{
+		level.ambientRooms[room].fadeIn = fadeIn;
+	}
+	level.ambientRooms[room].fadeOut = 2;
+	if ( isDefined( fadeOut ) && fadeOut >= 0 )
+	{
+		level.ambientRooms[room].fadeOut = fadeOut;
+	}
+}
+setAmbientRoomSnapshot( room, snapshot)
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "setAmbientRoomSnapshot: must declare ambient room \"" + room + "\" in level_amb main before it can have a room snapshot set" );
+		return;
+	}
+	level.ambientRooms[room].snapshot = snapshot;
+}
+setAmbientRoomContext( room, type, value)
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "setAmbientRoomContext: must declare ambient room \"" + room + "\" in level_amb main before it can have a room context set" );
+		return;
+	}
+	if(!isdefined(level.ambientRooms[room].context))
+	{
+		level.ambientRooms[room].context = [];
+	}
+	level.ambientRooms[room].context[type] = value;
+	if(!isdefined(level.ambientContexts))
+	{
+		level.ambientContexts = [];
+	}
+	level.ambientContexts[type] = type;
+}
+setAmbientRoomReverb( room, reverbRoomType, dry, wet, fade )
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "setAmbientRoomReverb: must declare ambient room \"" + room + "\" in level_amb main before it can have a room reverb set" );
+		return;
+	}
+	level.ambientRooms[room].reverb = spawnStruct();
+	level.ambientRooms[room].reverb.reverbRoomType = reverbRoomType;
+	level.ambientRooms[room].reverb.dry = dry;
+	level.ambientRooms[room].reverb.wet = wet;
+	level.ambientRooms[room].reverb.fade = 2;
+	if ( isDefined( fade ) && fade >= 0 )
+	{
+		level.ambientRooms[room].reverb.fade = fade;
+	}
+}
+activateAmbientPackage( clientNum, package, priority )
+{
+	if ( !isdefined( level.ambientPackages[package] ) )
+	{
+		assertmsg( "activateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be activated" );
+		return;
+	}
+	for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
+	{
+		if ( level.ambientPackages[package].priority[i] == priority )
+		{
+			level.ambientPackages[package].refcount[i]++;
+			break;
+		}
+	}
+	if ( i == level.ambientPackages[package].priority.size )
+	{
+		level.ambientPackages[package].priority[i] = priority;
+		level.ambientPackages[package].refcount[i] = 1;
+	}
+	level notify( "updateActiveAmbientPackage" );
+}
+activateAmbientRoom( clientNum, room, priority )
+{
+	if ( !isdefined( level.ambientRooms[room] ) )
+	{
+		assertmsg( "activateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be activated" );
+		return;
+	}
+	for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
+	{
+		if ( level.ambientRooms[room].priority[i] == priority )
+		{
+			level.ambientRooms[room].refcount[i]++;
+			break;
+		}
+	}
+	if ( i == level.ambientRooms[room].priority.size )
+	{
+		level.ambientRooms[room].priority[i] = priority;
+		level.ambientRooms[room].refcount[i] = 1;
+	}
+	level notify( "updateActiveAmbientRoom" );
+}
+ambientPackageCmdHandler(clientNum, state, oldState)
+{
+	if(state != "")
+	{
+		split_state = splitargs(state);
+		if(split_state.size != 3)
+		{
+			println("*** Client : Malformed arguements to ambient packages " + state);
+		}
+		else
+		{
+			command = split_state[0];
+			package = split_state[1];
+			priority = int(split_state[2]);
+			println("### APC : " + command + " " + package + " " + priority);
+			if(command == "A")
+			{
+				if ( !isdefined( level.ambientPackages[package] ) )
+				{
+					assertmsg( "activateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be activated" );
+					return;
+				}
+				for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
+				{
+					if ( level.ambientPackages[package].priority[i] == priority )
+					{
+						level.ambientPackages[package].refcount[i]++;
+						break;
+					}
+				}
+				if ( i == level.ambientPackages[package].priority.size )
+				{
+					level.ambientPackages[package].priority[i] = priority;
+					level.ambientPackages[package].refcount[i] = 1;
+				}
+				level notify( "updateActiveAmbientPackage" );
+			}
+			else if(command == "D")
+			{
+				if ( !isdefined( level.ambientPackages[package] ) )
+				{
+					assertmsg( "deactivateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be deactivated" );
+					return;
+				}
+				for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
+				{
+					if ( level.ambientPackages[package].priority[i] == priority && level.ambientPackages[package].refcount[i] )
+					{
+						level.ambientPackages[package].refcount[i]--;
+						level notify( "updateActiveAmbientPackage" );
+						return;
+					}
+				}
+			}
+			else
+			{
+				assertmsg("Unknown command in ambientPackageCmdHandler " + state);
+				return;
+			}
+		}
+	}
+}
+ambientRoomCmdHandler(clientNum, state, oldState)
+{
+	if(state != "")
+	{
+		split_state = splitargs(state);
+		if(split_state.size != 3)
+		{
+			println("*** Client : Malformed arguements to ambient packages " + state);
+		}
+		else
+		{
+			command = split_state[0];
+			room = split_state[1];
+			priority = int(split_state[2]);
+			if(command == "A")
+			{
+				if ( !isdefined( level.ambientRooms[room] ) )
+				{
+					assertmsg( "activateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be activated" );
+					return;
+				}
+				for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
+				{
+					if ( level.ambientRooms[room].priority[i] == priority )
+					{
+						level.ambientRooms[room].refcount[i]++;
+						break;
+					}
+				}
+				if ( i == level.ambientRooms[room].priority.size )
+				{
+					level.ambientRooms[room].priority[i] = priority;
+					level.ambientRooms[room].refcount[i] = 1;
+				}
+				level notify( "updateActiveAmbientRoom" );
+			}
+			else if(command == "D")
+			{
+				if ( !isdefined( level.ambientRooms[room] ) )
+				{
+					assertmsg( "deactivateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be deactivated" );
+					return;
+				}
+				for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
+				{
+					if ( level.ambientRooms[room].priority[i] == priority && level.ambientRooms[room].refcount[i] )
+					{
+						level.ambientRooms[room].refcount[i]--;
+						level notify( "updateActiveAmbientRoom" );
+						return;
+					}
+				}
+			}
+			else
+			{
+				assertmsg("Unknown command in ambientRoomCmdHandler " + state);
+				return;
+			}
+		}
+	}
+}
+ambientElementThread()
+{
+	level endon( "killambientElementThread" + level.activeAmbientPackage );
+	timer = 0;
+	if ( self.distMin < 0 )
+	{
+		for (;;)
+		{
+			timer = randomfloatrange( self.spawnMin, self.spawnMax );
+			wait timer;
+			if( getdvarint( #"debug_audio" ) > 0 )
+			{
+			}
+			playsound( 0, self.alias );
+		}
+	}
+	else
+	{
+		dist = 0;
+		angle = 0;
+		offset = (0, 0, 0);
+		index = -1;
+		for (;;)
+		{
+			timer = randomfloatrange( self.spawnMin, self.spawnMax );
+			wait timer;
+			index = getScriptOriginPoolIndex();
+			if ( index >= 0 )
+			{
+				dist = randomintrange( self.distMin, self.distMax );
+				angle = randomintrange( self.angleMin, self.angleMax );
+				player_angle = getlocalclientangles(0)[1];
+				offset = anglestoforward( ( 0, angle + player_angle, 0 ) );
+				offset = vector_scale( offset, dist );
+				pos = getlocalclienteyepos(0) + offset;
+				setfakeentorg(0, level.ambientPackageScriptOriginPool[index].org, pos);
+				level.ambientPackageScriptOriginPool[index].soundId = playSound( 0, self.alias, pos );
+				if( getdvarint( #"debug_audio" ) > 0 )
+				{
+					if(level.ambientPackageScriptOriginPool[index].soundId == -1)
+					{
+						col = (0.8, 0.0, 0.0);
+					}
+					else
+					{
+						col = (0.0, 0.8, 0.0);
+					}
+					print3d (pos, "AP : " + self.alias, col, 1, 3, 30);
+				}
+				while(level.ambientPackageScriptOriginPool[index].soundId != -1)
+				{
+					wait(0.01);
+				}
+			}
+		}
+	}
+}
+getScriptOriginPoolIndex()
+{
+	for ( index = 0; index < level.ambientPackageScriptOriginPool.size; index++ )
+	{
+		if ( !level.ambientPackageScriptOriginPool[index].inuse )
+		{
+			level.ambientPackageScriptOriginPool[index].inuse = true;
+			level.ambientNumSeqMissedSounds = 0;
+			return index;
+		}
+	}
+	level.ambientNumMissedSounds++;
+	level.ambientNumSeqMissedSounds++;
+	if( getdvarint( #"debug_audio" ) > 0 )
+	{
+	}
+	return -1;
+}
+scriptOriginPoolThread()
+{
+	for (;;)
+	{
+		if(self.inuse == true)
+		{
+			if(isdefined(self.soundId))
+			{
+				if(self.SoundId != -1)
+				{
+					if(!SoundPlaying(self.soundId))
+					{
+						self.inuse = false;
+						self.soundId = -1;
+					}
+				}
+				else
+				{
+					self.inUse = false;
+				}
+			}
+		}
+		wait(0.01);
+	}
+}
+findHighestPriorityAmbientPackage()
+{
+	package = "";
+	priority = -1;
+	packageArray = getArrayKeys( level.ambientPackages );
+	for ( i = 0; i < packageArray.size; i++ )
+	{
+		for ( j = 0; j < level.ambientPackages[packageArray[i]].priority.size; j++ )
+		{
+			if ( level.ambientPackages[packageArray[i]].refcount[j] && level.ambientPackages[packageArray[i]].priority[j] > priority )
+			{
+				package = packageArray[i];
+				priority = level.ambientPackages[packageArray[i]].priority[j];
+			}
+		}
+	}
+	return package;
+}
+updateActiveAmbientPackage()
+{
+	for (;;)
+	{
+		level waittill( "updateActiveAmbientPackage" );
+		newAmbientPackage = findHighestPriorityAmbientPackage();
+		println("*** nap " + newAmbientPackage + " " + level.activeAmbientPackage);
+		if ( newAmbientPackage != "" && level.activeAmbientPackage != newAmbientPackage )
+		{
+			level notify( "killambientElementThread" + level.activeAmbientPackage );
+			level.activeAmbientPackage = newAmbientPackage;
+			array_thread( level.ambientPackages[level.activeAmbientPackage].elements, ::ambientElementThread );
+		}
+	}
+}
+roomToneFadeOutTimerThread( fadeOut )
+{
+	self endon( "killRoomToneFadeOutTimer" );
+	wait fadeOut;
+	self.inuse = false;
+}
+findHighestPriorityAmbientRoom()
+{
+	room = "";
+	priority = -1;
+	roomArray = getArrayKeys( level.ambientRooms );
+	if(isdefined(roomArray))
+	{
+		for ( i = 0; i < roomArray.size; i++ )
+		{
+			for ( j = 0; j < level.ambientRooms[roomArray[i]].priority.size; j++ )
+			{
+				if ( level.ambientRooms[roomArray[i]].refcount[j] )
+				{
+				}
+				if ( level.ambientRooms[roomArray[i]].refcount[j] && level.ambientRooms[roomArray[i]].priority[j] > priority )
+				{
+					room = roomArray[i];
+					priority = level.ambientRooms[roomArray[i]].priority[j];
+				}
+			}
+		}
+	}
+	return room;
+}
+saveRestore()
+{
+	for(;;)
+	{
+		level waittill("save_restore");
+		level.activeAmbientRoom = "";
+		level notify( "updateActiveAmbientRoom" );
+	}
+}
+updateActiveAmbientRoom()
+{
+	for (;;)
+	{
+		newAmbientRoom = findHighestPriorityAmbientRoom();
+		if(newAmbientRoom == level.activeAmbientRoom)
+		{
+			level waittill( "updateActiveAmbientRoom" );
+		}
+		if(newAmbientRoom == level.activeAmbientRoom)
+		{
+			continue;
+		}
+		oldroom = level.ambientRooms[level.activeAmbientRoom];
+		newroom = level.ambientRooms[newAmbientRoom];
+		if(isdefined(oldroom) && isdefined(newroom)
+			&& isdefined(oldroom.tone) && isdefined(newroom.tone)
+		&& oldroom.tone == newroom.tone)
+		{
+			tmp = newroom.ent;
+			newroom.ent = oldroom.ent;
+			oldroom.ent = tmp;
+		}
+		else
+		{
+			if(isdefined(newroom) && isdefined(newroom.tone))
+			{
+				newroom.id = playloopsound( 0, newroom.ent, newroom.tone, newroom.fadeIn );
+			}
+			else
+			{
+			}
+			if(isdefined(oldroom) && isdefined(oldroom.tone))
+			{
+				stoploopsound(0, oldroom.ent, oldroom.fadeOut);
+			}
+			else
+			{
+			}
+		}
+		if ( !isdefined( newroom ) || !isdefined( newroom.reverb ) )
+		{
+			deactivateReverb( "snd_enveffectsprio_level", 2 );
+		}
+		else
+		{
+			setReverb( "snd_enveffectsprio_level", newroom.reverb.reverbRoomType, newroom.reverb.dry, newroom.reverb.wet, newroom.reverb.fade );
+		}
+		snapshot = "default";
+		if( isdefined( newroom ) && isdefined( newroom.snapshot ) )
+		{
+			snapshot = newroom.snapshot;
+		}
+		setAmbientSnapshot(snapshot);
+		if(isdefined(newroom) && isdefined(level.ambientContexts))
+		{
+			contexts = getArrayKeys(level.ambientContexts);
+			for(i=0; i<contexts.size; i++)
+			{
+				setsoundcontext( contexts[i], "");
+			}
+			if( isdefined( newroom.context ) )
+			{
+				keys = getArrayKeys(newroom.context);
+				for(i=0; i<keys.size; i++)
+				{
+					setsoundcontext( keys[i], newroom.context[ keys[i]]);
+				}
+			}
+		}
+		level.activeAmbientRoom = newAmbientRoom;
+	}
+}
+

BO1/PC/ZM/clientscripts/_audio.csc

@@ -0,0 +1,556 @@
+
+#include clientscripts\_utility;
+audio_init( localClientNum )
+{
+	if( localClientNum == 0 )
+	{
+		snd_snapshot_init();
+		thread snd_snapshot_level_fadein();
+		startSoundRandoms( localClientNum );
+		startSoundLoops();
+		startLineEmitters();
+		thread bump_trigger_start();
+		thread init_audio_step_triggers();
+		thread start_player_health_snapshot();
+		init_after_save_restore();
+	}
+}
+init_after_save_restore()
+{
+	level waittill( "save_restore" );
+	level thread audio_init( 0 );
+}
+snd_snapshot_init()
+{
+	level._sndActiveSnapshot = "default";
+	if(!isdefined(level._sndNextSnapshot))
+	{
+		level._sndNextSnapshot = "default";
+	}
+	setgroupsnapshot( level._sndActiveSnapshot );
+	thread snd_snapshot_think();
+	thread snd_snapshot_save();
+}
+snd_snapshot_save()
+{
+	level waittill( "save_restore" );
+	setgroupsnapshot( level._sndActiveSnapshot );
+}
+snd_set_snapshot( state )
+{
+	level._sndNextSnapshot = state;
+	println( "snd snapshot debug: set state '"+state+"'" );
+	level notify( "new_bus" );
+}
+snd_snapshot_think()
+{
+	level endon( "save_restore" );
+	for(;;)
+	{
+		if( level._sndActiveSnapshot == level._sndNextSnapshot )
+		{
+			level waittill( "new_bus" );
+		}
+		if( level._sndActiveSnapshot == level._sndNextSnapshot )
+		{
+			continue;
+		}
+		assert( IsDefined( level._sndNextSnapshot ) );
+		assert( IsDefined( level._sndActiveSnapshot ) );
+		setgroupsnapshot( level._sndNextSnapshot );
+		level._sndActiveSnapshot = level._sndNextSnapshot;
+	}
+}
+snd_snapshot_level_fadein()
+{
+	level notify( "end_duplicate_fadein" );
+	level endon( "end_duplicate_fadein" );
+	for(;;)
+	{
+		SetLevelFadeSnapshot( "fadein", 1.0 );
+		waitforclient( 0 );
+		wait( 0.5 );
+		snapshot_value = 1.0;
+		while( snapshot_value > 0.0 )
+		{
+			snapshot_value -= 0.05;
+			SetLevelFadeSnapshot( "fadein", snapshot_value );
+			wait( 0.02 );
+		}
+		SetLevelFadeSnapshot( "fadein", 0.0 );
+		if( level.zombiemode == true )
+		{
+			return;
+		}
+		player = getlocalplayer(0);
+		player waittill("respawn");
+	}
+}
+soundRandom_Thread( localClientNum, randSound )
+{
+	level endon( "save_restore" );
+	if( !IsDefined( randSound.script_wait_min ) )
+	{
+		randSound.script_wait_min = 1;
+	}
+	if( !IsDefined( randSound.script_wait_max ) )
+	{
+		randSound.script_wait_max = 3;
+	}
+	while( 1 )
+	{
+		wait( RandomFloatRange( randSound.script_wait_min, randSound.script_wait_max ) );
+		if( !IsDefined( randSound.script_sound ) )
+		{
+			println( "ambient sound at "+randSound.origin+" has undefined script_sound" );
+		}
+		else
+		{
+			playsound( localClientNum, randSound.script_sound, randSound.origin );
+		}
+	}
+}
+startSoundRandoms( localClientNum )
+{
+	randoms = GetStructArray( "random", "script_label" );
+	if( IsDefined( randoms ) && randoms.size > 0 )
+	{
+		println( "*** Client : Initialising random sounds - " + randoms.size + " emitters." );
+		for( i = 0; i < randoms.size; i++ )
+		{
+			thread soundRandom_Thread( localClientNum, randoms[i] );
+		}
+	}
+	else
+	{
+		println( "*** Client : No random sounds." );
+	}
+}
+soundLoopThink()
+{
+	if( !IsDefined( self.script_sound ) )
+	{
+		return;
+	}
+	if( !IsDefined( self.origin ) )
+	{
+		return;
+	}
+	level endon( "save_restore" );
+	notifyName = "";
+	assert( IsDefined( notifyName ) );
+	if( IsDefined( self.script_string ) )
+	{
+		notifyName = self.script_string;
+	}
+	assert( IsDefined( notifyName ) );
+	started = true;
+	if( IsDefined( self.script_int) )
+	{
+		started = self.script_int != 0;
+	}
+	if( started )
+	{
+		soundloopemitter( self.script_sound, self.origin );
+	}
+	if( notifyName != "" )
+	{
+		println( "starting loop notify" );
+		for(;;)
+		{
+			level waittill( notifyName );
+			if(started)
+			{
+				soundstoploopemitter( self.script_sound, self.origin );
+			}
+			else
+			{
+				soundloopemitter( self.script_sound, self.origin );
+			}
+			started = !started;
+		}
+	}
+	else
+	{
+	}
+}
+soundLineThink()
+{
+	level endon("save_restore");
+	if( !IsDefined( self.target) )
+	{
+		return;
+	}
+	target = getstruct( self.target, "targetname" );
+	if( !IsDefined( target) )
+	{
+		return;
+	}
+	notifyName = "";
+	if( IsDefined( self.script_string ) )
+	{
+		notifyName = self.script_string;
+	}
+	started = true;
+	if( IsDefined( self.script_int) )
+	{
+		started = self.script_int != 0;
+	}
+	if( started )
+	{
+		soundLineEmitter( self.script_sound, self.origin, target.origin );
+	}
+	if( notifyName != "" )
+	{
+		println( "starting line notify" );
+		for(;;)
+		{
+			level waittill( notifyName );
+			if( started )
+			{
+				soundStopLineEmitter( self.script_sound, self.origin, target.origin );
+			}
+			else
+			{
+				soundLineEmitter( self.script_sound, self.origin, target.origin );
+			}
+			started = !started;
+		}
+	}
+	else
+	{
+	}
+}
+startSoundLoops()
+{
+	loopers = GetStructArray( "looper", "script_label" );
+	if( IsDefined( loopers ) && loopers.size > 0 )
+	{
+		delay = 0;
+		println( "*** Client : Initialising looper sounds - " + loopers.size + " emitters." );
+		for( i = 0; i < loopers.size; i++ )
+		{
+			loopers[i] thread soundLoopThink();
+			delay += 1;
+			if( delay % 20 == 0 )
+			{
+				wait( 0.01 );
+			}
+		}
+	}
+	else
+	{
+		println( "*** Client : No looper sounds." );
+	}
+}
+startLineEmitters()
+{
+	lineEmitters = GetStructArray( "line_emitter", "script_label" );
+	if( IsDefined( lineEmitters ) && lineEmitters.size > 0 )
+	{
+		delay = 0;
+		println( "*** Client : Initialising line emitter sounds - " + lineEmitters.size + " emitters." );
+		for( i = 0; i < lineEmitters.size; i++ )
+		{
+			lineEmitters[i] thread soundLineThink();
+			delay += 1;
+			if( delay % 20 == 0 )
+			{
+				wait( 0.01 );
+			}
+		}
+	}
+	else
+	{
+		println( "*** Client : No line emitter sounds." );
+	}
+}
+init_audio_step_triggers()
+{
+	waitforclient( 0 );
+	trigs = GetEntArray( 0, "audio_step_trigger","targetname" );
+	println( "Client : " + trigs.size + " audio_step_triggers." );
+	array_thread( trigs, ::audio_step_trigger );
+}
+audio_step_trigger( trig )
+{
+	for(;;)
+	{
+		self waittill( "trigger", trigPlayer );
+		self thread trigger_thread( trigPlayer, ::trig_enter_audio_step_trigger, ::trig_leave_audio_step_trigger );
+	}
+}
+trig_enter_audio_step_trigger( trigPlayer )
+{
+	if( !IsDefined( trigPlayer.movementtype ) )
+	{
+		trigPlayer.movementtype = "null";
+	}
+	if( Isdefined( self.script_label) )
+	{
+		trigPlayer.step_sound = self.script_label;
+	}
+	if( Isdefined( self.script_sound ) && ( trigPlayer.movementtype == "sprint" ) )
+	{
+		volume = 9;
+		self playsound( 0, self.script_sound, self.origin, volume );
+	}
+}
+trig_leave_audio_step_trigger(trigPlayer)
+{
+	if( Isdefined( self.script_noteworthy ) && ( trigPlayer.movementtype == "sprint" ) )
+	{
+		volume = 9;
+		self playsound( 0, self.script_noteworthy, self.origin, volume );
+	}
+	trigPlayer.step_sound = "null";
+}
+bump_trigger_start()
+{
+	bump_trigs = GetEntArray( 0, "audio_bump_trigger", "targetname" );
+	for( i = 0; i < bump_trigs.size; i++)
+	{
+		bump_trigs[i] thread thread_bump_trigger();
+	}
+}
+thread_bump_trigger()
+{
+	self thread bump_trigger_listener();
+	if( !IsDefined( self.script_activated ) )
+	{
+		self.script_activated = 1;
+	}
+	for(;;)
+	{
+		self waittill ( "trigger", trigPlayer );
+		self thread trigger_thread( trigPlayer, ::trig_enter_bump, ::trig_leave_bump );
+	}
+}
+trig_enter_bump( ent )
+{
+	volume = get_vol_from_speed( ent );
+	if( IsDefined( self.script_sound ) && self.script_activated )
+	{
+		if( IsDefined( self.script_noteworthy ) && IsDefined(self.script_wait) && ( self.script_wait > volume ) )
+		{
+			test_id = self playsound( 0, self.script_noteworthy,self.origin, volume );
+		}
+		if( !IsDefined( self.script_wait ) || ( self.script_wait <= volume ) )
+		{
+			test_id = self playsound( 0, self.script_sound, self.origin, volume );
+		}
+	}
+}
+trig_leave_bump( ent )
+{
+}
+bump_trigger_listener()
+{
+	if( IsDefined( self.script_label ) )
+	{
+		level waittill( self.script_label );
+		self.script_activated = 0;
+	}
+}
+start_player_health_snapshot()
+{
+	if( IsDefined( level.zombiemode ) && level.zombiemode == true )
+	{
+		return;
+	}
+	level endon( "save_restore" );
+	wait( 1 );
+	max_health = GetLocalClientMaxHealth( 0 );
+	last_health = 0;
+	health_snapshot = "pain_heavy_occlude";
+	SetHealthSnapshot( health_snapshot, 0 );
+	for( ;; )
+	{
+		wait ( 0.05 );
+		health = GetLocalClientHealth( 0 );
+		if( health > 70 )
+		{
+			health_scale = 0;
+		}
+		else
+		{
+			health_scale = 1 - ( health * ( 1 / 100 ) );
+		}
+		SetHealthSnapshot( health_snapshot, health_scale );
+	}
+}
+scale_speed(x1 ,x2 ,y1 ,y2 ,z )
+{
+	if ( z < x1)
+		z = x1;
+	if ( z > x2)
+		z = x2;
+	dx = x2 - x1;
+	n = ( z - x1) / dx;
+	dy = y2 - y1;
+	w = (n*dy + y1);
+	return w;
+}
+get_vol_from_speed( player )
+{
+	min_speed = 21;
+	max_speed = 285;
+	max_vol = 1;
+	min_vol = .1;
+	speed = player getspeed();
+	if(speed == 0 )
+	{
+		speed = 175;
+	}
+	if( IsDefined( level.footstep_vol_override ) )
+	{
+		min_vol = .5;
+	}
+	abs_speed = absolute_value( int( speed ) );
+	volume = scale_speed( min_speed, max_speed, min_vol, max_vol, abs_speed );
+	return volume;
+}
+absolute_value( fowd )
+{
+	if( fowd < 0 )
+		return (fowd*-1);
+	else
+		return fowd;
+}
+closest_point_on_line_to_point( Point, LineStart, LineEnd )
+{
+	self endon ("end line sound");
+	LineMagSqrd = lengthsquared(LineEnd - LineStart);
+	t =	( ( ( Point[0] - LineStart[0] ) * ( LineEnd[0] - LineStart[0] ) ) +
+	( ( Point[1] - LineStart[1] ) * ( LineEnd[1] - LineStart[1] ) ) +
+	( ( Point[2] - LineStart[2] ) * ( LineEnd[2] - LineStart[2] ) ) ) /
+	( LineMagSqrd );
+	if( t < 0.0 )
+	{
+		self.origin = LineStart;
+	}
+	else if( t > 1.0 )
+	{
+		self.origin = LineEnd;
+	}
+	else
+	{
+		start_x = LineStart[0] + t * ( LineEnd[0] - LineStart[0] );
+		start_y = LineStart[1] + t * ( LineEnd[1] - LineStart[1] );
+		start_z = LineStart[2] + t * ( LineEnd[2] - LineStart[2] );
+		self.origin = ( start_x, start_y, start_z );
+	}
+}
+playloopat( localClientNum, aliasname, origin, fade )
+{
+	if( !IsDefined( fade ) )
+		fade = 0;
+	fake_ent = spawnfakeent( localClientNum );
+	setfakeentorg( localClientNum, fake_ent, origin );
+	playloopsound( localClientNum, fake_ent, aliasname, fade );
+	return fake_ent;
+}
+snd_play_auto_fx( fxid, alias )
+{
+	for( i = 0; i < level.createFXent.size; i++ )
+	{
+		if( level.createFXent[i].v["fxid"] == fxid && !IsDefined( level.createFXent[i].soundEnt ) )
+		{
+			level.createFXent[i].soundEnt = spawnFakeEnt( 0 );
+			setfakeentorg( 0, level.createFXent[i].soundEnt, level.createFXent[i].v["origin"] );
+			playloopsound( 0, level.createFXent[i].soundEnt, alias, .5 );
+		}
+	}
+}
+snd_delete_auto_fx( fxid )
+{
+	for( i = 0; i < level.createFXent.size; i++ )
+	{
+		if( level.createFXent[i].v["fxid"] == fxid && IsDefined( level.createFXent[i].soundEnt ) )
+		{
+			deletefakeent(0, level.createFXent[i].soundEnt);
+			level.createFXent[i].soundEnt = undefined;
+		}
+	}
+}
+snd_print_fx_id( fxid, type, ent )
+{
+	printLn( "^5 ******* fxid; " + fxid + "^5 type; " + type );
+}
+debug_line_emitter()
+{
+	while( 1 )
+	{
+	}
+}
+move_sound_along_line()
+{
+	closest_dist = undefined;
+	while( 1 )
+	{
+		self closest_point_on_line_to_point( getlocalclientpos( 0 ), self.start, self.end );
+		if( IsDefined( self.fake_ent ) )
+		{
+			setfakeentorg( self.localClientNum, self.fake_ent, self.origin );
+		}
+		closest_dist = DistanceSquared( getlocalclientpos( 0 ), self.origin );
+		if( closest_dist > 1024 * 1024 )
+		{
+			wait( 2 );
+		}
+		else if( closest_dist > 512 * 512 )
+		{
+			wait( 0.2 );
+		}
+		else
+		{
+			wait( 0.05 );
+		}
+	}
+}
+line_sound_player()
+{
+	if( IsDefined( self.script_looping ) )
+	{
+		self.fake_ent = spawnfakeent( self.localClientNum );
+		setfakeentorg( self.localClientNum, self.fake_ent, self.origin );
+		playloopsound( self.localClientNum, self.fake_ent, self.script_sound );
+	}
+	else
+	{
+		playsound( self.localClientNum, self.script_sound, self.origin );
+	}
+}
+soundwait( id )
+{
+	while( soundplaying( id ) )
+	{
+		wait( 0.1 );
+	}
+}
+sound_movie_snapshot_start()
+{
+	while(1)
+	{
+		level waittill ("pms");
+		wait(0.3);
+		snd_set_snapshot ("alloff_except_voice_music");
+	}
+}
+sound_movie_snapshot_alloff_but_mid_start()
+{
+	while(1)
+	{
+		level waittill ("pmsao");
+		wait(0.2);
+		snd_set_snapshot ("flashback_duck");
+	}
+}
+sound_movie_snapshot_stop()
+{
+	while(1)
+	{
+		level waittill ("pmo");
+		snd_set_snapshot ("default");
+	}
+}

BO1/PC/ZM/clientscripts/_callbacks.csc

@@ -0,0 +1,496 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_vehicle;
+#include clientscripts\_lights;
+#include clientscripts\_fx;
+statechange(clientNum, system, newState)
+{
+	if(!isdefined(level._systemStates))
+	{
+		level._systemStates = [];
+	}
+	if(!isdefined(level._systemStates[system]))
+	{
+		level._systemStates[system] = spawnstruct();
+	}
+	level._systemStates[system].state = newState;
+	if(isdefined(level._systemStates[system].callback))
+	{
+		[[level._systemStates[system].callback]](clientNum, newState);
+	}
+	else
+	{
+		println("*** Unhandled client system state change - " + system + " - has no registered callback function.");
+	}
+}
+maprestart()
+{
+	println("*** Client script VM map restart.");
+}
+glass_smash(org, dir)
+{
+	level notify("glass_smash", org, dir);
+}
+init_fx(clientNum)
+{
+	waitforclient(clientNum);
+	clientscripts\_fx::fx_init(clientNum);
+}
+AddCallback(event, func)
+{
+	AssertEx(IsDefined(event), "Trying to set a callback on an undefined event.");
+	if (!IsDefined(level._callbacks) || !IsDefined(level._callbacks[event]))
+	{
+		level._callbacks[event] = [];
+	}
+	level._callbacks[event] = add_to_array(level._callbacks[event], func, false);
+}
+Callback(event,clientNum)
+{
+	if (IsDefined(level._callbacks) && IsDefined(level._callbacks[event]))
+	{
+		for (i = 0; i < level._callbacks[event].size; i++)
+		{
+			callback = level._callbacks[event][i];
+			if (IsDefined(callback))
+			{
+				self thread [[callback]](clientNum);
+			}
+		}
+	}
+}
+localclientconnect(clientNum)
+{
+	println("*** Client script VM : Local client connect " + clientNum);
+	level.usetreadfx = 1;
+	if(isdefined(level._load_done) && clientNum > 0)
+	{
+		level notify( "kill_treads_forever" );
+		level.usetreadfx = 0;
+	}
+	if(!isdefined(level._laststand))
+	{
+		level._laststand = [];
+	}
+	level._laststand[clientNum] = false;
+	level notify("effects_init_"+clientNum);
+	level notify("connected", clientNum);
+	level thread localclientconnect_callback(clientNum);
+}
+localclientconnect_callback(clientNum)
+{
+	wait .01;
+	player = GetLocalPlayers()[clientNum];
+	player Callback("on_player_connect",clientNum);
+}
+localclientdisconnect(clientNum)
+{
+	println("*** Client script VM : Local client disconnect " + clientNum);
+}
+playerspawned(localClientNum)
+{
+	self endon( "entityshutdown" );
+	self thread clientscripts\_flamethrower_plight::play_pilot_light_fx( localClientNum );
+	if(isdefined(level._faceAnimCBFunc))
+		self thread [[level._faceAnimCBFunc]](localClientNum);
+	if(isdefined(level._playerCBFunc))
+		self thread [[level._playerCBFunc]](localClientNum);
+	level thread localclientspawned_callback(localClientNum);
+}
+localclientspawned_callback(localClientNum)
+{
+	wait .01;
+	player = GetLocalPlayers()[localClientNum];
+	player Callback( "playerspawned", localClientNum );
+}
+CodeCallback_GibEvent( localClientNum, type, locations )
+{
+	if ( isdefined( level._gibEventCBFunc ) )
+	{
+		self thread [[level._gibEventCBFunc]]( localClientNum, type, locations );
+	}
+}
+get_gib_def()
+{
+	if( !isdefined( level._gibbing_actor_models ) )
+	{
+		return -1;
+	}
+	for ( i = 0; i < level._gibbing_actor_models.size; i++ )
+	{
+		if ( self [[level._gibbing_actor_models[i].matches_me]]() )
+		{
+			self._original_model = self.model;
+			return i;
+		}
+	}
+	return -1;
+}
+entityspawned(localClientNum)
+{
+	self endon( "entityshutdown" );
+	if ( !isdefined( self.type ) )
+	{
+		PrintLn( "Entity type undefined!" );
+		return;
+	}
+	if ( self.type == "missile" )
+	{
+		switch( self.weapon )
+		{
+			case "explosive_bolt_sp":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, true, false );
+			break;
+			case "explosive_bolt_zm":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, true, false );
+			break;
+			case "explosive_bolt_upgraded_zm":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, true, true );
+			break;
+			case "crossbow_explosive_sp":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, true, false );
+			break;
+			case "crossbow_explosive_zm":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, true, false );
+			break;
+			case "crossbow_explosive_upgraded_zm":
+			self thread clientscripts\_explosive_bolt::spawned( localClientNum, false, true );
+			break;
+			case "sticky_grenade_zm":
+			if ( isdefined( level.zombie_sticky_grenade_spawned_func ) )
+			{
+				self thread [[level.zombie_sticky_grenade_spawned_func]]( localClientNum, true );
+			}
+			break;
+			case "zombie_quantum_bomb":
+			if( isdefined( level.zombie_quantum_bomb_spawned_func ) )
+			{
+				self thread [[level.zombie_quantum_bomb_spawned_func]]( localClientNum, true );
+			}
+		}
+	}
+	if( self.type == "vehicle" )
+	{
+		if( !isdefined( level.vehicles_inited ) )
+		{
+			clientscripts\_vehicle::init_vehicles();
+		}
+		clientscripts\_treadfx::loadtreadfx(self);
+		if( isdefined(level._customVehicleCBFunc) )
+		{
+			self thread [[level._customVehicleCBFunc]](localClientNum);
+		}
+		if ( !( self is_plane() ) && !(self is_helicopter()) && level.usetreadfx == 1 )
+		{
+			assert( isdefined( self.rumbleType ) );
+			precacherumble( self.rumbleType );
+			if( isdefined( self.exhaustfxname ) && self.exhaustfxname != "" )
+			{
+				self.exhaust_fx = loadfx( self.exhaustfxname );
+			}
+			self thread vehicle_treads(localClientNum);
+			self thread playTankExhaust(localClientNum);
+			self thread vehicle_rumble(localClientNum);
+			self thread vehicle_variants(localClientNum);
+			self thread vehicle_weapon_fired();
+		}
+		else if (self is_plane())
+		{
+			self thread aircraft_dustkick();
+		}
+		else if(self is_helicopter())
+		{
+			assert( isdefined( self.rumbleType ) );
+			precacherumble( self.rumbleType );
+			if( isdefined( self.exhaustfxname ) && self.exhaustfxname != "" )
+			{
+				self.exhaust_fx = loadfx( self.exhaustfxname );
+			}
+			self thread play_rotor_fx(localClientNum);
+			self thread delete_rotor_fx_on_save_restore(localClientNum);
+			self thread play_exhaust(localClientNum);
+			self thread aircraft_dustkick();
+			self clientscripts\_helicopter_sounds::start_helicopter_sounds();
+		}
+		self thread vehicle_clientmain(localClientNum);
+	}
+	else if (self.type == "actor" && GetDvarInt(#"zombiemode") > 0 )
+	{
+		if(isdefined(level._zombieCBFunc))
+		{
+			players = GetLocalPlayers();
+			for ( i = 0; i < players.size; i++ )
+			{
+				self thread [[level._zombieCBFunc]]( i );
+			}
+		}
+	}
+	if (self.type == "actor")
+	{
+		if(isdefined(level._faceAnimCBFunc))
+			self thread [[level._faceAnimCBFunc]](localClientNum);
+		if ( localClientNum == 0 )
+		{
+			self._gib_def = get_gib_def();
+			if( self._gib_def == -1 )
+			{
+				PrintLn( "*** Actor with model " + self.model + " not set for client-side gibbing." );
+			}
+		}
+	}
+	self.entity_spawned = true;
+	self notify("entity_spawned");
+}
+entityshutdown_callback( localClientNum, entity )
+{
+	if( IsDefined( level._entityShutDownCBFunc ) )
+	{
+		[[level._entityShutDownCBFunc]]( localClientNum, entity );
+	}
+}
+airsupport( localClientNum, x, y, z, type, yaw, team, teamfaction, owner, exittype )
+{
+	pos = ( x, y, z );
+	switch( teamFaction )
+	{
+		case "v":
+		teamfaction = "vietcong";
+		break;
+		case "n":
+		case "nva":
+		teamfaction = "nva";
+		break;
+		case "j":
+		teamfaction = "japanese";
+		break;
+		case "m":
+		teamfaction = "marines";
+		break;
+		case "s":
+		teamfaction = "specops";
+		break;
+		case "r":
+		teamfaction = "russian";
+		break;
+		default:
+		println( "Warning: Invalid team char provided, defaulted to marines" );
+		println( teamFaction + "\n" );
+		teamfaction = "marines";
+		break;
+	}
+	switch( team )
+	{
+		case "x":
+		team = "axis";
+		break;
+		case "l":
+		team = "allies";
+		break;
+		case "r":
+		team = "free";
+		break;
+		default:
+		println( "Invalid team used with playclientAirstike/napalm: " + team + "\n");
+		team = "allies";
+		break;
+	}
+	switch( exitType )
+	{
+		case "l":
+		exitType = "left";
+		break;
+		case "r":
+		exitType = "right";
+		break;
+		case "s":
+		exitType = "straight";
+		break;
+		case "b":
+		exitType = "barrelroll";
+		break;
+		default:
+		println( "Warning: Incorret exit type, defaulting to left" );
+		println( exitType + "\n" );
+		team = "left";
+		break;
+	}
+	if ( type == "n" )
+	{
+		clientscripts\_napalm::startNapalm( localClientNum, pos, yaw, teamfaction, team, owner, exitType );
+	}
+	else
+	{
+		println( "" );
+		println( "Unhandled airsupport type, only A (airstrike) and N (napalm) supported" );
+		println( type );
+		println( "" );
+	}
+}
+scriptmodelspawned(local_client_num, ent, destructable_index)
+{
+	if(destructable_index == 0)
+		return;
+	if(!isdefined(level.createFXent))
+		return;
+	fixed = false;
+	for(i = 0; i < level.createFXent.size; i ++)
+	{
+		if(level.createFXent[i].v["type"] != "exploder")
+			continue;
+		exploder = level.createFXent[i];
+		if(!isdefined(exploder.needs_fixup))
+			continue;
+		if(exploder.needs_fixup == destructable_index)
+		{
+			exploder.v["angles"] = VectorToAngles( ent.origin - exploder.v["origin"] );
+			exploder clientscripts\_fx::set_forward_and_up_vectors();
+			exploder.needs_fixup = undefined;
+			fixed = true;
+		}
+	}
+}
+callback_activate_exploder(exploder_id)
+{
+	if(!isdefined(level._exploder_ids))
+		return;
+	keys = getarraykeys(level._exploder_ids);
+	exploder = undefined;
+	for(i = 0; i < keys.size; i ++)
+	{
+		if(level._exploder_ids[keys[i]] == exploder_id)
+		{
+			exploder = keys[i];
+			break;
+		}
+	}
+	if(!isdefined(exploder))
+	{
+		println("*** Client : Exploder id " + exploder_id + " unknown.");
+		return;
+	}
+	println("*** Client callback - activate exploder " + exploder_id + " : " + exploder);
+	clientscripts\_fx::activate_exploder(exploder);
+}
+callback_deactivate_exploder(exploder_id)
+{
+	if(!isdefined(level._exploder_ids))
+		return;
+	keys = getarraykeys(level._exploder_ids);
+	exploder = undefined;
+	for(i = 0; i < keys.size; i ++)
+	{
+		if(level._exploder_ids[keys[i]] == exploder_id)
+		{
+			exploder = keys[i];
+			break;
+		}
+	}
+	if(!isdefined(exploder))
+	{
+		println("*** Client : Exploder id " + exploder_id + " unknown.");
+		return;
+	}
+	println("*** Client callback - deactivate exploder " + exploder_id + " : " + exploder);
+	clientscripts\_fx::deactivate_exploder(exploder);
+}
+level_notify(notify_name, param1, param2)
+{
+	level notify(notify_name, param1, param2);
+}
+sound_notify(client_num, entity, note )
+{
+	if ( note == "sound_dogstep_run_default" )
+	{
+		entity playsound( client_num, "fly_dog_step_run_default" );
+		return true;
+	}
+	prefix = getsubstr( note, 0, 5 );
+	if ( prefix != "sound" )
+		return false;
+	alias = "aml" + getsubstr( note, 5 );
+	entity play_dog_sound( client_num, alias);
+}
+dog_sound_print( message )
+{
+}
+play_dog_sound( localClientNum, sound, position )
+{
+	dog_sound_print( "SOUND " + sound);
+	if ( isdefined( position ) )
+	{
+		return self playsound( localClientNum, sound, position );
+	}
+	return self playsound( localClientNum, sound );
+}
+client_flag_callback(localClientNum, flag, set, newEnt)
+{
+	if ((self.type == "vehicle" || self.type == "actor" || self.type == "missle") && !IsDefined(self.entity_spawned))
+	{
+		self waittill("entity_spawned");
+	}
+	if(isdefined(level._client_flag_callbacks) && isdefined(level._client_flag_callbacks[self.type]) && IsDefined(level._client_flag_callbacks[self.type][flag]))
+	{
+		self thread [[level._client_flag_callbacks[self.type][flag]]](localClientNum, set, newEnt);
+	}
+	else
+	{
+	}
+}
+client_flagasval_callback(localClientNum, val)
+{
+	if(isdefined(level._client_flagasval_callbacks) && isdefined(level._client_flagasval_callbacks[self.type]))
+	{
+		self thread [[level._client_flagasval_callbacks[self.type]]](localClientNum, val);
+	}
+}
+CodeCallback_PlayerFootstep(client_num, player, movementtype, ground_type, firstperson, quiet)
+{
+	clientscripts\_footsteps::playerFootstep(client_num, player, movementtype, ground_type, firstperson, quiet);
+}
+CodeCallback_CreatingCorpse(localClientNum, player )
+{
+	player notify( "face", "face_death" );
+}
+CodeCallback_PlayerJump(client_num, player, ground_type, firstperson, quiet)
+{
+	clientscripts\_footsteps::playerJump(client_num, player, ground_type, firstperson, quiet);
+}
+CodeCallback_PlayerLand(client_num, player, ground_type, firstperson, quiet, damagePlayer)
+{
+	clientscripts\_footsteps::playerLand(client_num, player, ground_type, firstperson, quiet, damagePlayer);
+}
+CodeCallback_PlayerFoliage(client_num, player, firstperson, quiet)
+{
+	clientscripts\_footsteps::playerFoliage(client_num, player, firstperson, quiet);
+}
+AddPlayWeaponDeathEffectsCallback(weaponname, func)
+{
+	if (!IsDefined(level._playweapondeatheffectscallbacks))
+	{
+		level._playweapondeatheffectscallbacks = [];
+	}
+	level._playweapondeatheffectscallbacks[weaponname] = func;
+}
+CodeCallback_PlayWeaponDeathEffects( localclientnum, weaponname, userdata )
+{
+	if (IsDefined(level._playweapondeatheffectscallbacks) && IsDefined(level._playweapondeatheffectscallbacks[weaponname]))
+	{
+		self thread [[level._playweapondeatheffectscallbacks[weaponname]]]( localclientnum, weaponname, userdata );
+	}
+}
+AddPlayWeaponDamageEffectsCallback(weaponname, func)
+{
+	if (!IsDefined(level._playweapondamageeffectscallbacks))
+	{
+		level._playweapondamageeffectscallbacks = [];
+	}
+	level._playweapondamageeffectscallbacks[weaponname] = func;
+}
+CodeCallback_PlayWeaponDamageEffects( localclientnum, weaponname, userdata )
+{
+	if (IsDefined(level._playweapondamageeffectscallbacks) && IsDefined(level._playweapondamageeffectscallbacks[weaponname]))
+	{
+		self thread [[level._playweapondamageeffectscallbacks[weaponname]]]( localclientnum, weaponname, userdata );
+	}
+}
+

BO1/PC/ZM/clientscripts/_face_utility.csc

@@ -0,0 +1,346 @@
+
+setFaceRoot( root )
+{
+	if( !IsDefined( level.faceStates ) )
+	{
+		level.faceStates = [];
+	}
+	if( !IsDefined( level.faceStates[self.face_anim_tree] ) )
+	{
+		level.faceStates[self.face_anim_tree] = [];
+	}
+	level.faceStates[self.face_anim_tree]["face_root"] = root;
+}
+buildFaceState( face_state, looping, timer, priority, statetype, animation )
+{
+	if( !IsDefined( level.faceStates ) )
+	{
+		level.faceStates = [];
+	}
+	if( !IsDefined( level.faceStates[self.face_anim_tree] ) )
+	{
+		level.faceStates[self.face_anim_tree] = [];
+	}
+	level.faceStates[self.face_anim_tree][face_state][ "looping" ] = looping;
+	level.faceStates[self.face_anim_tree][face_state][ "timer" ] = timer;
+	level.faceStates[self.face_anim_tree][face_state][ "priority" ] = priority;
+	level.faceStates[self.face_anim_tree][face_state][ "statetype" ] = statetype;
+	level.faceStates[self.face_anim_tree][face_state][ "animation" ] = [];
+	level.faceStates[self.face_anim_tree][face_state][ "animation" ][0] = animation;
+}
+addAnimToFaceState( face_state, animation )
+{
+	Assert( IsDefined( level.faceStates[self.face_anim_tree][face_state] ) );
+	Assert( IsDefined( level.faceStates[self.face_anim_tree][face_state]["animation"] ) );
+	curr_size = level.faceStates[self.face_anim_tree][face_state][ "animation" ].size;
+	level.faceStates[self.face_anim_tree][face_state][ "animation" ][curr_size] = animation;
+}
+isHigherPriority( new_state, old_state )
+{
+	if( new_state == old_state && level.faceStates[self.face_anim_tree][old_state]["looping"] )
+	{
+		return false;
+	}
+	if( level.faceStates[self.face_anim_tree][new_state]["priority"] >= level.faceStates[self.face_anim_tree][old_state]["priority"] )
+	{
+		if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+		{
+			PrintLn( "FaceState "+new_state+" is higher priority than "+old_state+" for entity "+self GetEntityNumber() );
+		}
+		return true;
+	}
+	if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+	{
+		PrintLn( "FaceState "+new_state+" is not higher priority than "+old_state+" for entity "+self GetEntityNumber() );
+	}
+	return false;
+}
+faceFrameEndNotify()
+{
+	self endon( "entityshutdown" );
+	self endon( "stop_facial_anims" );
+	level endon( "save_restore" );
+	waittillframeend;
+	self notify( "face", "frameend" );
+}
+waitForAnyPriorityReturn( prevState )
+{
+	self endon( "entityshutdown" );
+	self endon( "stop_facial_anims" );
+	level endon( "save_restore" );
+	if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+	{
+		PrintLn( "Waiting for priority return for "+prevState+" for entity "+self GetEntityNumber() );
+	}
+	while( true )
+	{
+		self waittill( "face", newState );
+		if( isHigherPriority( newState, prevState ) )
+		{
+			break;
+		}
+	}
+	self thread faceFrameEndNotify();
+	while( true )
+	{
+		self waittill( "face", tempState );
+		if( tempState == "frameend" )
+		{
+			break;
+		}
+		if( isHigherPriority( tempState, newState ) )
+		{
+			newState = tempState;
+		}
+	}
+	return newState;
+}
+waitForFaceEventRepeat( base_time )
+{
+	self endon( "entityshutdown" );
+	self endon( "stop_face_anims" );
+	self endon( "new_face_event" );
+	self endon( "face_timer_expired" );
+	level endon( "save_restore" );
+	state = self.face_curr_event;
+	while( true )
+	{
+		self waittill( "face", newState );
+		if( newState == state )
+		{
+			self.face_timer = base_time;
+		}
+	}
+}
+waitForFaceEventComplete()
+{
+	self endon( "entityshutdown" );
+	self endon( "stop_face_anims" );
+	self endon( "new_face_event" );
+	level endon( "save_restore" );
+	if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+	{
+		PrintLn( "Trying to get animation for state "+self.face_curr_event+" # "+self.face_curr_event_idx+" for entity "+self GetEntityNumber() );
+	}
+	Assert( IsDefined( level.faceStates[self.face_anim_tree][self.face_curr_event]["animation"][self.face_curr_event_idx] ) );
+	if( IsDefined( level.faceStates[self.face_anim_tree][self.face_curr_event]["timer"] ) )
+	{
+		self.face_timer = level.faceStates[self.face_anim_tree][self.face_curr_event]["timer"];
+	}
+	else
+	{
+		self.face_timer = GetAnimLength( level.faceStates[self.face_anim_tree][self.face_curr_event]["animation"][self.face_curr_event_idx] );
+	}
+	base_time = self.face_timer;
+	if( level.faceStates[self.face_anim_tree][self.face_curr_event]["looping"] )
+	{
+		self thread waitForFaceEventRepeat( self.face_timer );
+	}
+	while( true )
+	{
+		if( self.face_timer <= 0 )
+		{
+			break;
+		}
+		wait( 0.05 );
+		self.face_timer -= 0.05;
+	}
+	self notify( "face_timer_expired" );
+	if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+	{
+		PrintLn( "Timing out face state "+self.face_curr_event+" # "+self.face_curr_event_idx+" for entity "+self GetEntityNumber()+" after "+base_time );
+	}
+	self.face_curr_event = undefined;
+	self.face_curr_event_idx = undefined;
+	self SetAnimKnob( level.faceStates[self.face_anim_tree][self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.1, 1.0 );
+	self notify( "face", "face_advance" );
+}
+processFaceEvents( localClientNum )
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	state = "face_alert";
+	self.face_curr_base = "face_alert";
+	numAnims = level.faceStates[self.face_anim_tree][state]["animation"].size;
+	self.face_curr_base_idx = RandomInt( numAnims );
+	if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+	{
+		PrintLn( "Starting entity "+ self GetEntityNumber() +" in state face_alert" );
+		PrintLn( "Found "+numAnims+" anims for state face_alert for entity "+self GetEntityNumber() );
+		PrintLn( "Selected anim "+self.face_curr_base_idx+" for entity "+self GetEntityNumber() );
+	}
+	self SetAnimKnob( level.faceStates[self.face_anim_tree][self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.0, 1.0 );
+	if ( isdefined( self.face_death ) && self.face_death )
+		state = "face_death";
+	self.face_state = state;
+	self thread showState();
+	self thread watchfor_death();
+	while ( true )
+	{
+		if( GetDvarInt( #"cg_debugFace" ) != 0 )
+		{
+			if( !IsDefined( level.faceStates ) )
+			{
+				PrintLn( "No face state array!\n" );
+			}
+			else if( !IsDefined( self.face_anim_tree ) )
+			{
+				PrintLn( "No face anim tree for entity "+self GetEntityNumber() );
+			}
+			else if( !IsDefined( state ) )
+			{
+				PrintLn( "No face state for entity "+self GetEntityNumber() );
+			}
+			else if( !IsDefined( level.faceStates[self.face_anim_tree] ) )
+			{
+				PrintLn( "No face state array for anim tree "+self.face_anim_tree+" used by entity "+self GetEntityNumber() );
+			}
+			else if( !IsDefined( level.faceStates[self.face_anim_tree][state] ) )
+			{
+				PrintLn( "No face state array entry for state "+state+" in anim tree "+self.face_anim_tree+" for entity "+self GetEntityNumber() );
+			}
+		}
+		if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+		{
+			PrintLn( "Found "+numAnims+" anims for state "+state+" for entity "+self GetEntityNumber() );
+		}
+		if( IsDefined( self.face_disable ) && self.face_disable )
+		{
+			if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+			{
+				PrintLn( "Disabling face anims for entity "+self GetEntityNumber() );
+			}
+			setFaceState( "face_disabled" );
+			self ClearAnim( level.faceStates[self.face_anim_tree][ "face_root" ], 0 );
+			self notify( "stop_face_anims" );
+			self.face_curr_event = undefined;
+			self.face_curr_event_idx = undefined;
+			while( self.face_disable )
+			{
+				wait( 0.05 );
+			}
+		}
+		numAnims = level.faceStates[self.face_anim_tree][state]["animation"].size;
+		setFaceState( state );
+		if( level.faceStates[self.face_anim_tree][state]["statetype"] == "nullstate" )
+		{
+			if( IsDefined( self.face_curr_event ) )
+			{
+				self SetAnimKnob( level.faceStates[self.face_anim_tree][self.face_curr_event]["animation"][self.face_curr_event_idx], 1.0, 0.1, 1.0 );
+			}
+			else if( IsDefined( self.face_curr_base ) )
+			{
+				self SetAnimKnob( level.faceStates[self.face_anim_tree][self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.1, 1.0 );
+			}
+		}
+		else if( level.faceStates[self.face_anim_tree][state]["statetype"] == "exitstate" )
+		{
+			if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+			{
+				PrintLn( "Exitstate found, returning for entity "+self GetEntityNumber() );
+			}
+			self SetAnimKnob( level.faceStates[self.face_anim_tree][state]["animation"][RandomInt(numAnims)], 1.0, 0.1, 1.0 );
+			self notify( "stop_face_anims" );
+			self.face_curr_event = undefined;
+			self.face_curr_event_idx = undefined;
+			return;
+		}
+		else if( level.faceStates[self.face_anim_tree][state]["statetype"] == "basestate" )
+		{
+			if( !IsDefined( self.face_curr_base ) || self.face_curr_base != state )
+			{
+				self.face_curr_base = state;
+				self.face_curr_base_idx = RandomInt( numAnims );
+				if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+				{
+					PrintLn( "New base face anim state "+self.face_curr_base+" anim # "+self.face_curr_base_idx+"  for entity "+self GetEntityNumber() );
+				}
+				if( !IsDefined( self.face_curr_event ) )
+				{
+					if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+					{
+						PrintLn( "trying to play animation for state "+self.face_curr_base+" w/ index "+self.face_curr_base_idx+" for entity "+self GetEntityNumber() );
+					}
+					self SetAnimKnob( level.faceStates[self.face_anim_tree][self.face_curr_base]["animation"][self.face_curr_base_idx], 1.0, 0.1, 1.0 );
+				}
+			}
+		}
+		else if( level.faceStates[self.face_anim_tree][state]["statetype"] == "eventstate" )
+		{
+			if( !IsDefined( self.face_curr_event ) || !level.faceStates[self.face_anim_tree][self.face_curr_event]["looping"] || self.face_curr_event != state )
+			{
+				self.face_curr_event= state;
+				self.face_curr_event_idx = RandomInt( numAnims );
+				if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+				{
+					PrintLn( "New face anim event "+self.face_curr_event+" anim # "+self.face_curr_event_idx+" for entity "+self GetEntityNumber() );
+				}
+				self SetFlaggedAnimKnob( "face_event", level.faceStates[self.face_anim_tree][self.face_curr_event]["animation"][self.face_curr_event_idx], 1.0, 0.1, 1.0 );
+				self thread waitForFaceEventComplete();
+			}
+		}
+		if( IsDefined( self.face_curr_event ) )
+		{
+			state = self waitForAnyPriorityReturn( self.face_curr_event );
+		}
+		else
+		{
+			state = self waitForAnyPriorityReturn( self.face_curr_base );
+		}
+	}
+}
+showState( state )
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	while ( true )
+	{
+		if ( GetDvarInt( #"cg_debugFace" ) != 0 )
+		{
+			if ( isdefined( self.face_state ) && isdefined( self.origin ) )
+			{
+				entNum = self getentitynumber();
+				if ( !isdefined( entNum ) )
+					entNum = "?";
+				if ( isdefined( self.face_disable ) && self.face_disable )
+					disableChar = "-";
+				else
+					disableChar = "+";
+				if ( isdefined( self.face_death ) && self.face_death )
+					deathChar = "D";
+				else
+					deathChar = "A";
+				Print3d( self.origin + ( 0, 0, 72 ), disableChar + deathChar + "["+ entNum +"]" + self.face_state, (1,1,1), 1, 0.25 );
+			}
+		}
+		wait( 0.01667 );
+	}
+}
+setFaceState( state )
+{
+	if( state == "face_advance" )
+	{
+		if( IsDefined( self.face_curr_event ) )
+		{
+			self.face_state = self.face_curr_event;
+		}
+		else if( IsDefined( self.face_curr_base ) )
+		{
+			self.face_state = self.face_curr_base;
+		}
+		return;
+	}
+	self.face_state = state;
+}
+watchfor_death()
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	if ( !isdefined( self.face_death ) )
+	{
+		self waittillmatch( "face", "face_death" );
+		self.face_death = true;
+	}
+}
+
+

BO1/PC/ZM/clientscripts/_filter.csc

@@ -0,0 +1,364 @@
+
+init_filter_indices()
+{
+	if ( isdefined( level.genericfilterinitialized ) )
+		return;
+	level.genericfilterinitialized = true;
+	level.filter_matcount = 4;
+	level.targetid_none = 0;
+	level.targerid_small0 = 1;
+	level.targerid_small1 = 2;
+	level.targerid_scene = 3;
+	level.targerid_postsun = 4;
+	level.targerid_smallblur = 5;
+}
+map_material_helper( player, materialname )
+{
+	level.filter_matid[materialname] = level.filter_matcount;
+	player map_material( level.filter_matcount, materialname );
+	level.filter_matcount++;
+}
+init_filter_binoculars( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_binoculars" );
+}
+enable_filter_binoculars( player, filterid, overlayid )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_binoculars"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+}
+disable_filter_binoculars( player, filterid, overlayid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_warp_sr71( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_warp_sr71" );
+}
+set_filter_warp_sr71_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+enable_filter_warp_sr71( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_warp_sr71"], level.targerid_scene, level.targerid_smallblur, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_warp_sr71_amount( player, filterid, amount );
+}
+disable_filter_warp_sr71( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_frost( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_frost" );
+}
+set_filter_frost_opacity( player, filterid, opacity )
+{
+	player set_filter_pass_constant( filterid, 0, 0, opacity );
+}
+enable_filter_frost( player, filterid, opacity )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_frost"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_frost_opacity( player, filterid, opacity );
+}
+disable_filter_frost( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_pentagon_fullscreen( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_pentagon_fullscreen" );
+}
+set_filter_pentagon_fullscreen_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+enable_filter_pentagon_fullscreen( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_pentagon_fullscreen"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_pentagon_fullscreen_amount( player, filterid, amount );
+}
+disable_filter_pentagon_fullscreen( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_pentagon_blowout( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_pentagon_blowout" );
+}
+set_filter_pentagon_blowout_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+enable_filter_pentagon_blowout( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_pentagon_blowout"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_pentagon_blowout_amount( player, filterid, amount );
+}
+disable_filter_pentagon_blowout( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_pentagon_bulgeblur( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_pentagon_bulgeblur" );
+}
+set_filter_pentagon_bulgeblur_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+enable_filter_pentagon_bulgeblur( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_pentagon_bulgeblur"], level.targerid_scene, level.targerid_smallblur, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_pentagon_bulgeblur_amount( player, filterid, amount );
+}
+disable_filter_pentagon_bulgeblur( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_pentagon_multicam1( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_pentagon_multicam1" );
+}
+set_filter_pentagon_multicam1_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+set_filter_pentagon_multicam1_bink1( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 1, amount );
+}
+set_filter_pentagon_multicam1_bink2( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 2, amount );
+}
+enable_filter_pentagon_multicam1( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_pentagon_multicam1"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_pentagon_multicam1_amount( player, filterid, amount );
+}
+disable_filter_pentagon_multicam1( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_pentagon_multicam2( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_pentagon_multicam2" );
+}
+set_filter_pentagon_multicam2_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+set_filter_pentagon_multicam2_bink1( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 1, amount );
+}
+set_filter_pentagon_multicam2_bink2( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 2, amount );
+}
+enable_filter_pentagon_multicam2( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_pentagon_multicam2"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_pentagon_multicam2_amount( player, filterid, amount );
+}
+disable_filter_pentagon_multicam2( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_hazmat( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_hazmat" );
+	map_material_helper( player, "generic_overlay_hazmat_1" );
+	map_material_helper( player, "generic_overlay_hazmat_2" );
+	map_material_helper( player, "generic_overlay_hazmat_3" );
+	map_material_helper( player, "generic_overlay_hazmat_4" );
+}
+set_filter_hazmat_opacity( player, filterid, overlayid, opacity )
+{
+	player set_filter_pass_constant( filterid, 0, 0, opacity );
+	player set_overlay_constant( overlayid, 0, opacity );
+}
+enable_filter_hazmat( player, filterid, overlayid, stage, opacity )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_hazmat"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	if ( stage == 1 )
+		player set_overlay_material( overlayid, level.filter_matid["generic_overlay_hazmat_1"], 1 );
+	else if ( stage == 2 )
+		player set_overlay_material( overlayid, level.filter_matid["generic_overlay_hazmat_2"], 1 );
+	else if ( stage == 3 )
+		player set_overlay_material( overlayid, level.filter_matid["generic_overlay_hazmat_3"], 1 );
+	else if ( stage == 4 )
+		player set_overlay_material( overlayid, level.filter_matid["generic_overlay_hazmat_4"], 1 );
+	player set_overlay_enabled( overlayid, true );
+	set_filter_hazmat_opacity( player, filterid, overlayid, opacity );
+}
+disable_filter_hazmat( player, filterid, overlayid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+	player set_overlay_enabled( overlayid, false );
+}
+init_filter_helmet( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_helmet" );
+	map_material_helper( player, "generic_overlay_helmet" );
+}
+enable_filter_helmet( player, filterid, overlayid )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_helmet"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	player set_overlay_material( overlayid, level.filter_matid["generic_overlay_helmet"], 1 );
+	player set_overlay_enabled( overlayid, true );
+}
+disable_filter_helmet( player, filterid, overlayid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+	player set_overlay_enabled( overlayid, false );
+}
+init_filter_tacticalmask( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_overlay_tacticalmask" );
+}
+enable_filter_tacticalmask( player, filterid )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_overlay_tacticalmask"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+}
+disable_filter_tacticalmask( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+init_filter_superflare( player, materialname )
+{
+	init_filter_indices();
+	map_material_helper( player, materialname );
+}
+set_filter_superflare_position( player, filterid, passid, x, y, z )
+{
+	player set_filter_pass_constant( filterid, passid, 0, x );
+	player set_filter_pass_constant( filterid, passid, 1, y );
+	player set_filter_pass_constant( filterid, passid, 2, z );
+}
+set_filter_superflare_intensity( player, filterid, passid, intensity )
+{
+	player set_filter_pass_constant( filterid, passid, 4, intensity );
+}
+set_filter_superflare_radius( player, filterid, passid, radius )
+{
+	player set_filter_pass_constant( filterid, passid, 5, radius );
+}
+enable_filter_superflare( player, materialname, filterid, passid, quads, x, y, z, intensity, radius )
+{
+	player set_filter_pass_material( filterid, passid, level.filter_matid[materialname], level.targerid_small0, level.targetid_none, level.targetid_none );
+	player set_filter_pass_quads( filterid, passid, quads );
+	player set_filter_pass_enabled( filterid, passid, true );
+	set_filter_superflare_intensity( player, filterid, passid, intensity );
+	set_filter_superflare_radius( player, filterid, passid, radius );
+	set_filter_superflare_position( player, filterid, passid, x, y, z );
+}
+disable_filter_superflare( player, materialname, filterid, passid )
+{
+	player set_filter_pass_enabled( filterid, passid, false );
+}
+init_filter_lensflare( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_lensflare_cutoff" );
+	map_material_helper( player, "generic_filter_lensflare_flip" );
+	map_material_helper( player, "generic_filter_lensflare_apply" );
+}
+set_filter_lensflare_cutoff( player, filterid, cutoff )
+{
+	player set_filter_pass_constant( filterid, 0, 0, cutoff );
+}
+set_filter_lensflare_intensity( player, filterid, intensity )
+{
+	player set_filter_pass_constant( filterid, 0, 1, intensity );
+}
+set_filter_lensflare_brightness( player, filterid, brightness )
+{
+	player set_filter_pass_constant( filterid, 1, 0, brightness );
+}
+enable_filter_lensflare( player, filterid, cutoff, intensity, brightness )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_lensflare_cutoff"], level.targerid_small0, level.targerid_smallblur, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	player set_filter_pass_material( filterid, 1, level.filter_matid["generic_filter_lensflare_flip"], level.targerid_small0, level.targerid_small0, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 1, true );
+	player set_filter_pass_material( filterid, 2, level.filter_matid["generic_filter_lensflare_apply"], level.targerid_scene, level.targerid_small0, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 2, true );
+	set_filter_lensflare_cutoff( player, filterid, cutoff );
+	set_filter_lensflare_intensity( player, filterid, intensity );
+	set_filter_lensflare_brightness( player, filterid, brightness );
+}
+disable_filter_lensflare( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+	player set_filter_pass_enabled( filterid, 1, false );
+	player set_filter_pass_enabled( filterid, 2, false );
+}
+init_filter_scope( player )
+{
+	init_filter_indices();
+	if( !isps3() || getlocalplayers().size == 1 )
+		player map_material( 0, "generic_filter_scope" );
+}
+init_filter_infrared( player )
+{
+	init_filter_indices();
+	if( !isps3() || getlocalplayers().size == 1 )
+		player map_material( 1, "generic_filter_infrared" );
+}
+init_filter_tvguided( player )
+{
+	init_filter_indices();
+	player map_material( 2, "tow_filter_overlay" );
+	player map_material( 3, "tow_overlay" );
+}
+init_filter_teargas( player )
+{
+	init_filter_indices();
+	map_material_helper( player, "generic_filter_teargas" );
+}
+set_filter_teargas_amount( player, filterid, amount )
+{
+	player set_filter_pass_constant( filterid, 0, 0, amount );
+}
+enable_filter_teargas( player, filterid, amount )
+{
+	player set_filter_pass_material( filterid, 0, level.filter_matid["generic_filter_teargas"], level.targerid_scene, level.targerid_scene, level.targetid_none );
+	player set_filter_pass_enabled( filterid, 0, true );
+	set_filter_teargas_amount( player, filterid, amount );
+}
+disable_filter_teargas( player, filterid )
+{
+	player set_filter_pass_enabled( filterid, 0, false );
+}
+
+
+
+
+
+
+
+
+

BO1/PC/ZM/clientscripts/_fx.csc

@@ -0,0 +1,487 @@
+#include clientscripts\_utility;
+#include clientscripts\_music;
+createLoopSound()
+{
+	ent = spawnStruct();
+	if (!isdefined(level.createFXent))
+		level.createFXent = [];
+	level.createFXent[level.createFXent.size] = ent;
+	ent.v = [];
+	ent.v["type"] = "soundfx";
+	ent.v["fxid"] = "No FX";
+	ent.v["soundalias"] = "nil";
+	ent.v["angles"] = (0,0,0);
+	ent.v["origin"] = (0,0,0);
+	ent.drawn = true;
+	return ent;
+}
+createEffect( type, fxid )
+{
+	ent = spawnStruct();
+	if (!isdefined(level.createFXent))
+		level.createFXent = [];
+	level.createFXent[level.createFXent.size] = ent;
+	ent.v = [];
+	ent.v["type"] = type;
+	ent.v["fxid"] = fxid;
+	ent.v["angles"] = (0,0,0);
+	ent.v["origin"] = (0,0,0);
+	ent.drawn = true;
+	return ent;
+}
+exploder_delay()
+{
+	if( !isdefined( self.v[ "delay" ] ) )
+		self.v[ "delay" ] = 0;
+	min_delay = self.v[ "delay" ];
+	max_delay = self.v[ "delay" ] + 0.001;
+	if( isdefined( self.v[ "delay_min" ] ) )
+		min_delay = self.v[ "delay_min" ];
+	if( isdefined( self.v[ "delay_max" ] ) )
+		max_delay = self.v[ "delay_max" ];
+	if( min_delay > 0 )
+		realwait( randomfloatrange( min_delay, max_delay ) );
+}
+fire_effect()
+{
+	forward = self.v[ "forward" ];
+	up = self.v[ "up" ];
+	org = undefined;
+	firefxSound = self.v[ "firefxsound" ];
+	origin = self.v[ "origin" ];
+	firefx = self.v[ "firefx" ];
+	ender = self.v[ "ender" ];
+	if( !isdefined( ender ) )
+		ender = "createfx_effectStopper";
+	timeout = self.v[ "firefxtimeout" ];
+	fireFxDelay = 0.5;
+	if( isdefined( self.v[ "firefxdelay" ] ) )
+		fireFxDelay = self.v[ "firefxdelay" ];
+	self exploder_delay();
+	if( isdefined( firefxSound ) )
+		level thread clientscripts\_utility::loop_fx_sound( firefxSound, origin, ender, timeout );
+	players = getlocalplayers();
+	for(i = 0; i < players.size; i ++)
+	{
+		println("fire fx " + level._effect[ firefx ]);
+		playfx( i, level._effect[ firefx ], self.v[ "origin" ], forward, up );
+	}
+}
+trail_effect()
+{
+	self exploder_delay();
+	if( !IsDefined( self.v["trailfxtag"] ) )
+	{
+		self.v["trailfxtag"] = "tag_origin";
+	}
+	if(isdefined(self.v["target"]))
+	{
+		println("*** Client Trail : target defined.");
+		temp_ent = GetEnt(0, self.v["target"], "targetname" );
+		if( IsDefined( temp_ent ) )
+		{
+			println("*** Client : Trail found target ent.");
+			org = temp_ent.origin;
+		}
+		else
+		{
+			temp_ent = GetStruct( self.v["target"], "targetname" );
+			org = temp_ent.origin;
+		}
+		if(isdefined(org))
+			self.v["angles"] = VectorToAngles( org - self.v["origin"] );
+		else
+			println("*** Client : Exploder " + self.v["trailfx"] + " Failed to find target " + self.v["target"]);
+	}
+	else
+	{
+		println("Client trail : target not defined.");
+	}
+	if(!isdefined(self.model))
+	{
+		println("*** Client : Trail effect has no model.");
+		keys = getarraykeys(self.v);
+		for(i = 0; i < keys.size; i ++)
+		{
+			println(keys[i] + " " + self.v[keys[i]]);
+		}
+		return;
+	}
+	else
+	{
+		println("*** Client : I should be a " + self.v["trailfx"] + " trail, connected to " + self.model + " by the " + self.v["trailfxtag"]);
+	}
+}
+exploder_playSound()
+{
+	if( !isdefined( self.v[ "soundalias" ] ) || self.v[ "soundalias" ] == "nil" )
+		return;
+	play_sound_in_space( 0, self.v[ "soundalias" ], self.v[ "origin" ] );
+	println("***Client: Exploder plays sound " + self.v["soundalias"]);
+}
+cannon_effect()
+{
+	if( isdefined( self.v[ "repeat" ] ) )
+	{
+		for( i = 0;i < self.v[ "repeat" ];i ++ )
+		{
+			players = getlocalplayers();
+			for(player = 0; player < players.size; player ++)
+			{
+				println("cannon fx " + level._effect[ self.v[ "fxid" ] ]);
+				playfx( player, level._effect[ self.v[ "fxid" ] ], self.v[ "origin" ], self.v[ "forward" ], self.v[ "up" ] );
+			}
+			self exploder_delay();
+		}
+		return;
+	}
+	self exploder_delay();
+	players = getlocalplayers();
+	if ( isdefined( self.loopFX ) )
+	{
+		for(i = 0; i < self.loopFX.size; i ++)
+		{
+			self.loopFX[i] delete();
+		}
+		self.loopFX = [];
+	}
+	if(!isdefined(self.loopFX))
+	{
+		self.loopFX = [];
+	}
+	if(!isdefined(level._effect[self.v["fxid"]]))
+	{
+		assertmsg("*** Client : Effect " + self.v["fxid"] + " not precached in level_fx.csc.");
+		return;
+	}
+	for(i = 0; i < players.size; i ++)
+	{
+		if(isdefined(self.v["fxid"]))
+		{
+			self.loopFX[i] = spawnFx( i, level._effect[ self.v[ "fxid" ] ], self.v[ "origin" ], self.v["delay"], self.v[ "forward" ], self.v[ "up" ] );
+			triggerfx(self.loopFX[i]);
+		}
+	}
+	self exploder_playSound();
+}
+exploder_earthquake()
+{
+	self exploder_delay();
+	eq = level.earthquake[ self.v[ "earthquake" ] ];
+	if(isdefined(eq))
+	{
+		getlocalplayers()[0] earthquake( eq[ "magnitude" ], eq[ "duration" ], self.v[ "origin" ], eq[ "radius" ] );
+	}
+	else
+	{
+		println("*** Client : Missing " + self.v[ "earthquake" ] + " from client side level object.");
+	}
+}
+activate_individual_exploder()
+{
+	if(!isdefined(self.v["angles"]))
+	{
+		self.v["angles"] = (0,0,0);
+		self set_forward_and_up_vectors();
+	}
+	if( isdefined( self.v[ "firefx" ] ) )
+		self thread fire_effect();
+	if( isdefined( self.v[ "fxid" ] ) && self.v[ "fxid" ] != "No FX" )
+		self thread cannon_effect();
+	else
+		if( isdefined( self.v[ "soundalias" ] ) )
+	{
+		println("** Client : missing sound_effect");
+	}
+	if( isdefined( self.v[ "earthquake" ] ) )
+	{
+		self thread exploder_earthquake();
+	}
+	if( isdefined( self.v[ "rumble" ] ) )
+	{
+		println("*** client : missing exploder_rumble");
+	}
+}
+deactivate_exploder(num)
+{
+	println("*** Client : Delete exploder " + num);
+	num = int( num );
+	for( i = 0;i < level.createFXent.size;i ++ )
+	{
+		ent = level.createFXent[ i ];
+		if( !IsDefined( ent ) )
+			continue;
+		if( ent.v[ "type" ] != "exploder" )
+			continue;
+		if( !isdefined( ent.v[ "exploder" ] ) )
+			continue;
+		if( ent.v[ "exploder" ] != num )
+			continue;
+		if(IsDefined(ent.soundEnt))
+		{
+			deletefakeent(0, ent.soundEnt);
+			ent.soundEnt = undefined;
+		}
+		if(isdefined(ent.loopFX))
+		{
+			for(j = 0; j < ent.loopFX.size; j ++)
+			{
+				if(isdefined(ent.loopFX[j]))
+				{
+					ent.loopFX[j] delete();
+					ent.loopFX[j] = undefined;
+				}
+			}
+			ent.loopFX = [];
+		}
+	}
+}
+lightning(normalFunc, flashFunc)
+{
+	[[flashFunc]]();
+	realWait(RandomFloatRange( 0.05, 0.1 ));
+	[[normalFunc]]();
+}
+exploder_is_lightning_exploder(num)
+{
+	if (isdefined(level.lightningExploder))
+	{
+		for(i = 0; i < level.lightningExploder.size; i ++)
+		{
+			if(level.lightningExploder[i] == num)
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+glass_exploder_watcher(num, dist, alias)
+{
+	ents = [];
+	for( i = 0;i < level.createFXent.size;i ++ )
+	{
+		ent = level.createFXent[ i ];
+		if( !IsDefined( ent ) )
+			continue;
+		if( ent.v[ "type" ] != "exploder" )
+			continue;
+		if( !isdefined( ent.v[ "exploder" ] ) )
+			continue;
+		if( ent.v[ "exploder" ] != num )
+			continue;
+		ents[ents.size] = ent;
+	}
+	if(ents.size == 0)
+	{
+		PrintLn("*** : No glass exploder with id " + num + " found.");
+		return;
+	}
+	dist_squared = dist * dist;
+	while(1)
+	{
+		level waittill("glass_smash", pos, vec);
+		for(i = 0; i < ents.size; i ++)
+		{
+			ds = DistanceSquared(pos, ents[i].v["origin"]);
+			if( ds <= dist_squared)
+			{
+				exploder(num);
+				if( IsDefined( alias ) )
+				{
+					sound_ent = spawn( 0, pos, "script_origin" );
+					sound_ent PlayLoopSound( alias, .25 );
+					sound_ent thread delete_window_sound_ent();
+				}
+				return;
+			}
+		}
+	}
+}
+exploder_is_glass_exploder(num, dist, alias)
+{
+	if(!IsDefined(dist))
+	{
+		dist = 24;
+	}
+	level thread glass_exploder_watcher(num, dist, alias);
+}
+delete_window_sound_ent()
+{
+	wait(30);
+	self stoploopsound(2);
+	wait(2);
+	self Delete();
+}
+activate_exploder( num )
+{
+	num = int( num );
+	prof_begin( "client activate_exploder" );
+	for( i = 0;i < level.createFXent.size;i ++ )
+	{
+		ent = level.createFXent[ i ];
+		if( !IsDefined( ent ) )
+			continue;
+		if( ent.v[ "type" ] != "exploder" )
+			continue;
+		if( !isdefined( ent.v[ "exploder" ] ) )
+			continue;
+		if( ent.v[ "exploder" ] != num )
+			continue;
+		ent activate_individual_exploder();
+	}
+	if(exploder_is_lightning_exploder(num))
+	{
+		if(isdefined(level.lightningNormalFunc) && isdefined(level.lightningFlashFunc))
+		{
+			thread lightning(level.lightningNormalFunc, level.lightningFlashFunc);
+		}
+	}
+	prof_end( "client activate_exploder" );
+}
+exploder( num )
+{
+	activate_exploder(num);
+}
+createOneshotEffect( fxid )
+{
+	ent = createEffect( "oneshotfx", fxid );
+	ent.v[ "delay" ] = -15;
+	return ent;
+}
+createLoopEffect( fxid )
+{
+	ent = createEffect( "loopfx", fxid );
+	ent.v[ "delay" ] = 0.5;
+	return ent;
+}
+createExploder( fxid )
+{
+	ent = createEffect( "exploder", fxid );
+	ent.v[ "delay" ] = 0;
+	ent.v[ "exploder_type" ] = "normal";
+	return ent;
+}
+set_forward_and_up_vectors()
+{
+	self.v["up"] = anglestoup(self.v["angles"]);
+	self.v["forward"] = anglestoforward(self.v["angles"]);
+}
+create_triggerfx(clientNum)
+{
+	self.looperFX = playFx( clientNum, level._effect[self.v["fxid"]], self.v["origin"], self.v["forward"], self.v["up"], self.v["delay"] );
+	create_loopsound(clientNum);
+}
+create_looper(clientNum)
+{
+	self thread loopfx(clientNum);
+	create_loopsound(clientNum);
+}
+loopfx(clientNum)
+{
+	self.looperFX = playFx( clientNum, level._effect[self.v["fxid"]], self.v["origin"], self.v["forward"], self.v["up"], self.v["delay"] );
+	while( 1 )
+	{
+		if( isdefined(self.v["delay"]) )
+			realWait( self.v["delay"] );
+		while( isfxplaying( clientNum, self.looperFX ) )
+		wait 0.1;
+		self.looperFX = playFx( clientNum, level._effect[self.v["fxid"]], self.v["origin"], self.v["forward"], self.v["up"] );
+	}
+}
+loopfxStop (clientNum, timeout)
+{
+	self endon("death");
+	realwait(timeout);
+	if(isdefined(self.looper))
+		self.looper delete();
+	if(isdefined(self.looperFX))
+		deletefx(clientNum, self.looperFX);
+}
+loopfxthread(clientNum)
+{
+	if (isdefined (self.fxStart))
+		level waittill ("start fx" + self.fxStart);
+	while (1)
+	{
+		create_looper(clientNum);
+		if (isdefined (self.timeout))
+			thread loopfxStop(clientNum, self.timeout);
+		if (isdefined (self.fxStop))
+			level waittill ("stop fx" + self.fxStop);
+		else
+			return;
+		if (isdefined (self.looperFX))
+			deletefx(clientNum, self.looperFX);
+		if (isdefined (self.fxStart))
+			level waittill ("start fx" + self.fxStart);
+		else
+			return;
+	}
+}
+oneshotfxthread(clientNum)
+{
+	if ( self.v["delay"] > 0 )
+		realWait(self.v["delay"]);
+	create_triggerfx(clientNum);
+}
+create_loopsound(clientNum)
+{
+	if(clientNum != 0)
+		return;
+	self notify( "stop_loop" );
+	if ( isdefined( self.v["soundalias"] ) && ( self.v["soundalias"] != "nil" ) )
+	{
+		if ( isdefined( self.v[ "stopable" ] ) && self.v[ "stopable" ] )
+		{
+			thread clientscripts\_utility::loop_fx_sound( clientNum, self.v["soundalias"], self.v["origin"], "stop_loop" );
+		}
+		else
+		{
+			thread clientscripts\_utility::loop_fx_sound( clientNum, self.v["soundalias"], self.v["origin"] );
+		}
+	}
+}
+fx_init(clientNum)
+{
+	clientscripts\_lights::init_lights(clientNum);
+	if (!isdefined(level.createFX_enabled))
+		return;
+	clientscripts\_destructibles::init(clientNum);
+	if(level.createFX_enabled)
+		return;
+	if(!isdefined(level.createFXent))
+		return;
+	if(clientNum == 0)
+	{
+		clientscripts\_utility::init_exploders();
+	}
+	println("*** Setting forward + up");
+	for ( i=0; i<level.createFXent.size; i++ )
+	{
+		ent = level.createFXent[i];
+		if(!isdefined(level._createfxforwardandupset))
+		{
+			if(!isdefined(level.needs_fixup))
+			{
+				if(isdefined(ent.v["angles"]))
+					ent set_forward_and_up_vectors();
+			}
+		}
+		if (ent.v["type"] == "loopfx")
+			ent thread loopfxthread(clientNum);
+		if (ent.v["type"] == "oneshotfx")
+			ent thread oneshotfxthread(clientNum);
+		if (ent.v["type"] == "soundfx")
+			ent thread create_loopsound(clientNum);
+	}
+	level._createfxforwardandupset = true;
+}
+reportNumEffects()
+{
+}
+spawnFX_wrapper( clientNum, fx_id, origin, delay, forward, up )
+{
+	fx_object = SpawnFx( clientNum, level._effect[fx_id], origin, delay, forward, up );
+	return fx_object;
+}

BO1/PC/ZM/clientscripts/_helicopter_sounds.csc

@@ -0,0 +1,621 @@
+#include clientscripts\_utility;
+#include clientscripts\_music;
+#include clientscripts\_audio;
+init()
+{
+	level._entityShutDownCBFunc = clientscripts\_helicopter_sounds::heli_linkto_sound_ents_delete;
+	level.heliSoundValues = [];
+	init_heli_sound_values( "huey", "cockpit", 65, 0.6, 0.8, 65, 1, 1.1 );
+	init_heli_sound_values( "huey", "cockpit2", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "int_eng", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "int_eng2", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "int_eng3", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "ext_rotor", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "tail_rotor", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey", "tail_rotor", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "hind", "cockpit", 95, 0.6, 0.8, 95, 1, 1.1 );
+	init_heli_sound_values( "hind", "cockpit2", 95, 0.5, 0.8, 95, 1, 1.2 );
+	init_heli_sound_values( "hind", "int_eng", 65, 0.5, 0.8, 65, 1, 1.1 );
+	init_heli_sound_values( "hind", "int_eng2", 65, 0.4, 0.9, 65, 1, 1.1 );
+	init_heli_sound_values( "hind", "eng_dmg", 40, 0.3, 0.5, 65, 1, 1.1 );
+	init_heli_sound_values( "hind", "ext_rotor", 70, 0.5, 1, 70, 0.95, 1.1 );
+	init_heli_sound_values( "hip", "turbine", 15, 0.85, 1, 20, 1, 1.0 );
+	init_heli_sound_values( "hip", "top_rotor", 15, 0.85, 1, 20, 0.95, 1);
+	init_heli_sound_values( "hip", "tail_rotor", 15, 0.85, 1, 20, 0.95, 1.1);
+	init_heli_sound_values( "hind_enemy", "turbine", 45, 0.6, 0.8, 65, 1, 1.0 );
+	init_heli_sound_values( "hind_enemy", "top_rotor", 15, 0.5, 1, 25, 0.95, 1.0);
+	init_heli_sound_values( "hind_enemy", "tail_rotor", 45, 0.5, 1, 45, 0.95, 1.0);
+	init_heli_sound_values( "huey_toda", "turbine", 25, 0.75, 0.8, 65, 1, 1);
+	init_heli_sound_values( "huey_toda", "top_rotor", 15, 0.85, 1, 25, 0.95, 1);
+	init_heli_sound_values( "huey_toda", "tail_rotor", 25, 0.95, 1, 35, 0.95, 1);
+	init_heli_sound_values( "heli_chinook", "turbine", 15, 0.80, 1, 35, 0.95, 1.05);
+	init_heli_sound_values( "heli_chinook", "top_rotor",	15, 0.80, 1, 35, 0.95, 1.05);
+	init_heli_sound_values( "huey_player", "turbine", 65, 0.6, 0.8, 65, 1, 1.1 );
+	init_heli_sound_values( "huey_player", "top_rotor", 45, 0.5, 1, 45, 0.95, 1.1);
+	init_heli_sound_values( "huey_player", "tail_rotor", 45, 0.5, 1, 45, 0.95, 1.0);
+	init_heli_sound_values( "huey_player", "wind_rt", 45, 0.5, 1, 45, 0.95, 1.0);
+	init_heli_sound_values( "huey_player", "wind_lft", 45, 0.5, 1, 45, 0.95, 1.0);
+}
+init_heli_sound_values( heli_type, part_type, max_speed_vol, min_vol, max_vol, max_speed_pitch, min_pitch, max_pitch )
+{
+	if( !IsDefined( level.heliSoundValues[heli_type] ) )
+	{
+		level.heliSoundValues[heli_type] = [];
+	}
+	if( !IsDefined( level.heliSoundValues[heli_type][part_type] ) )
+	{
+		level.heliSoundValues[heli_type][part_type] = spawnStruct();
+	}
+	level.heliSoundValues[heli_type][part_type].speedVolumeMax = max_speed_vol;
+	level.heliSoundValues[heli_type][part_type].speedPitchMax = max_speed_pitch;
+	level.heliSoundValues[heli_type][part_type].volumeMin = min_vol;
+	level.heliSoundValues[heli_type][part_type].volumeMax = max_vol;
+	level.heliSoundValues[heli_type][part_type].pitchMin = min_pitch;
+	level.heliSoundValues[heli_type][part_type].pitchMax = max_pitch;
+	if( getdvarint( #"debug_heli" ) > 0 )
+	{
+		println("Init Heli Sounds heli_type: " + heli_type );
+		println("Init Heli Sounds part_type: " + part_type );
+		println("Init Heli Sounds max_speed_vol: " + max_speed_vol );
+		println("Init Heli Sounds min_vol: " + min_vol );
+		println("Init Heli Sounds max_vol: " + max_vol );
+		println("Init Heli Sounds max_speed_pitch: " + max_speed_pitch );
+		println("Init Heli Sounds min_pitch: " + min_pitch );
+		println("Init Heli Sounds max_pitch: " + max_pitch );
+	}
+}
+init_heli_sounds_huey_toda()
+{
+	self setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_hind_turbine" );
+	self setup_heli_sounds( "top_rotor",	"engine", "snd_rotor", "veh_hind_rotor" );
+	self setup_heli_sounds( "tail_rotor",	"engine", "snd_tail_rotor",	"veh_hind_tail" );
+	self setup_heli_sounds( "lfe", "engine", "snd_rotor", "veh_hind_rotor_lfe" );
+}
+init_heli_sounds_huey()
+{
+	self setup_heli_sounds( "cockpit", "engine", "snd_cockpit", "veh_huey_whine_int_idle" );
+	self setup_heli_sounds( "cockpit2", "engine", "snd_rotor", "veh_huey_hf_int_idle" );
+	self setup_heli_sounds( "int_eng", "engine", "snd_rotor", "veh_huey_lf_int_idle" );
+	self setup_heli_sounds( "int_eng2", "engine", "snd_tail_rotor",	"veh_huey_dist_idle" );
+	self setup_heli_sounds( "int_eng3", "engine", "snd_wind_right",	"veh_huey_ringing_dist" );
+	self setup_heli_sounds( "ext_rotor",	"engine", "snd_wind_left",	"veh_huey_rotor_idle" );
+}
+init_heli_sounds_hind()
+{
+	self setup_heli_sounds( "cockpit", "engine", "snd_cockpit", "veh_hind_whine_int_idle" );
+	self setup_heli_sounds( "cockpit2", "engine", "snd_cockpit", "veh_hind_hf_int_idle" );
+	self setup_heli_sounds( "int_eng", "engine", "snd_int_rotor",	"veh_hind_lf_int_idle" );
+	self setup_heli_sounds( "int_eng2", "engine", "snd_int_rotor",	"veh_hind_dist_idle1" );
+	self setup_heli_sounds( "ext_rotor",	"engine", "snd_rotor", "veh_hind_rotor_idle" );
+	self setup_heli_sounds( "eng_dmg", "engine", "snd_int_rotor",	"veh_hind_sputter" );
+	self setup_heli_sounds( "eng_dmg_alarm","engine", "snd_cockpit", "veh_hind_alarm_damage_high_loop" );
+}
+init_heli_sounds_hip()
+{
+	self setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_hip_turbine" );
+	self setup_heli_sounds( "top_rotor",	"engine", "snd_rotor", "veh_hip_rotor" );
+	self setup_heli_sounds( "tail_rotor",	"engine", "snd_rotor", "veh_hip_tail" );
+	self setup_heli_sounds( "lfe", "engine", "snd_rotor", "veh_hip_rotor_lfe" );
+}
+init_heli_sounds_chinook()
+{
+	self setup_heli_sounds( "turbine", "engine", "tag_origin", "veh_chinook_turbine" );
+	self setup_heli_sounds( "top_rotor",	"engine", "main_rotor_jnt",	"veh_chinook_rotor" );
+	self setup_heli_sounds( "top_rotor",	"engine", "tail_rotor_jnt",	"veh_chinook_rotor" );
+	self setup_heli_sounds( "lfe", "engine", "tag_origin", "veh_chinook_rotor_lfe" );
+}
+init_heli_sounds_hind_enemy()
+{
+	self setup_heli_sounds( "lfe", "engine", "snd_cockpit", "veh_hind_epow_rotor_lfe" );
+	self setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_hind_epow_turbine" );
+	self setup_heli_sounds( "top_rotor",	"engine", "snd_rotor", "veh_hind_epow_rotor" );
+	self setup_heli_sounds( "tail_rotor",	"engine", "snd_tail_rotor",	"veh_hind_epow_tail" );
+}
+init_heli_sounds_hind_vorkuta()
+{
+	self setup_heli_sounds( "lfe", "engine", "snd_cockpit", "veh_hind_rotor_lfe" );
+	self setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_hind_turbine" );
+	self setup_heli_sounds( "top_rotor",	"engine", "snd_rotor", "veh_hind_rotor" );
+	self setup_heli_sounds( "tail_rotor",	"engine", "snd_tail_rotor",	"veh_hind_tail" );
+}
+init_heli_sounds_huey_player()
+{
+	setup_heli_sounds( "lfe", "engine", "snd_cockpit", "veh_huey_rotor_lfe" );
+	setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_huey_turbine" );
+	setup_heli_sounds( "top_rotor", "engine", "snd_rotor", "veh_huey_rotor" );
+	setup_heli_sounds( "tail_rotor",	"engine", "snd_tail_rotor",	"veh_huey_tail" );
+	setup_heli_sounds( "wind_rt", "engine", "snd_wind_right",	"veh_huey_door_wind");
+	setup_heli_sounds( "wind_lft", "engine", "snd_wind_left",	"veh_huey_door_wind");
+	setup_heli_sounds( "radio", "engine", "snd_cockpit", "veh_huey_radio");
+}
+init_heli_sounds_zombietron()
+{
+	self setup_heli_sounds( "turbine", "engine", "snd_rotor", "veh_hind_turbine_zt" );
+	self setup_heli_sounds( "top_rotor",	"engine", "snd_rotor", "veh_hind_rotor_zt" );
+}
+setup_heli_sounds( bone_location, type, tag, run, dmg1, dmg2, dmg3 )
+{
+	self.heli[bone_location] = spawnStruct();
+	self.heli[bone_location].sound_type = type;
+	self.heli[bone_location].run = spawn( 0, self.origin, "script_origin" );
+	self.heli[bone_location].run linkto( self, tag );
+	self.heli[bone_location].run.alias = run;
+	self.sound_ents[self.sound_ents.size] = self.heli[bone_location].run;
+	self thread delete_loop_sound_save_restore( self.heli[bone_location].run );
+	if( IsDefined( dmg1 ) )
+	{
+		self.heli[bone_location].dmg1 = spawn( 0, self.origin, "script_origin" );
+		self.heli[bone_location].dmg1 linkto( self, tag );
+		self.heli[bone_location].dmg1.alias = dmg1;
+		self.sound_ents[self.sound_ents.size] = self.heli[bone_location].dmg1;
+		self thread delete_loop_sound_save_restore( self.heli[bone_location].dmg1 );
+	}
+	if( IsDefined( dmg2 ) )
+	{
+		self.heli[bone_location].idle = spawn( 0, self.origin, "script_origin" );
+		self.heli[bone_location].idle linkto( self, tag );
+		self.heli[bone_location].idle.alias = dmg2;
+		self.sound_ents[self.sound_ents.size] = self.heli[bone_location].dmg2;
+		self thread delete_loop_sound_save_restore( self.heli[bone_location].dmg2 );
+	}
+	if( IsDefined( dmg3 ) )
+	{
+		self.heli[bone_location].idle = spawn( 0, self.origin, "script_origin" );
+		self.heli[bone_location].idle linkto( self, tag );
+		self.heli[bone_location].idle.alias = dmg3;
+		self.sound_ents[self.sound_ents.size] = self.heli[bone_location].dmg3;
+		self thread delete_loop_sound_save_restore( self.heli[bone_location].dmg3 );
+	}
+}
+init_terrain_sounds()
+{
+	self.surface_type = [];
+	self.surface_type["default"]	= "dirt";
+	self.surface_type["metal"] = "dirt";
+	self.surface_type["concrete"]	= "dirt";
+	self.surface_type["wood"] = "dirt";
+	self.surface_type["dirt"] = "dirt";
+	self.surface_type["gravel"] = "dirt";
+	self.surface_type["grass"] = "dirt";
+	self.surface_type["mud"] = "dirt";
+	self.surface_type["snow"] = "dirt";
+	self.surface_type["asphalt"]	= "dirt";
+	self.surface_type["brick"] = "dirt";
+	self.surface_type["glass"] = "dirt";
+	self.surface_type["plaster"]	= "dirt";
+	self.surface_type["sand"] = "dirt";
+	self.surface_type["rock"] = "dirt";
+	self.surface_type["water"] = "water";
+	self.surface_type["foliage"]	= "dirt";
+	self setup_terrain_sounds( "dirt", "veh_chopper_prop_wash_dirt"	);
+	self setup_terrain_sounds( "water", "veh_chopper_prop_wash_water"	);
+}
+setup_terrain_sounds( surface_type, alias )
+{
+	self.terrain_ent_array[surface_type] = spawn( 0, self.origin, "script_origin" );
+	self.terrain_ent_array[surface_type].alias = alias;
+	self thread terrain_loop_sound_delete( self.terrain_ent_array[surface_type] );
+}
+start_helicopter_sounds( localClientNum )
+{
+	if( IsDefined( self.vehicletype ) )
+	{
+		self.heli = [];
+		self.terrain = [];
+		self.sound_ents = [];
+		self.cur_speed = 0;
+		self.idle_run_trans_speed = 5;
+		play_terrain_sounds = true;
+		switch( self.vehicletype )
+		{
+			case "zombie_cobra":
+			self init_heli_sounds_huey();
+			self play_huey_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_huey_small":
+			case "heli_huey_gunship":
+			self init_heli_sounds_huey();
+			self play_huey_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_hind_player":
+			self init_heli_sounds_hind();
+			self play_hind_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_hind":
+			case "heli_hind_doublesize":
+			case "heli_hind_doublesize_uwb":
+			case "heli_hind_river":
+			self init_heli_sounds_hind_enemy();
+			self play_hind_enemy_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_hip":
+			case "rebirth_heli_hip_sidegun_spotlight":
+			case "heli_hip_sidegun_spotlight":
+			case "heli_hip_noseturret":
+			case "heli_cobra":
+			case "heli_cobra_khesanh":
+			case "heli_hip_sidegun_uwb":
+			self init_heli_sounds_hip();
+			self play_hip_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_huey_assault":
+			case "heli_huey":
+			case "heli_huey_usmc_heavyhog":
+			case "heli_huey_usmc":
+			case "heli_huey_usmc_khesanh":
+			case "heli_huey_side_minigun":
+			case "heli_huey_player":
+			case "heli_huey_player_uwb":
+			case "heli_huey_heavyhog_river":
+			case "heli_huey_assault_river":
+			case "heli_huey_gunship_river":
+			case "heli_huey_usmc_khesanh_std":
+			case "heli_huey_medivac_khesanh":
+			case "heli_huey_usmc_heavyhog_khesanh":
+			case "heli_huey_medivac_river":
+			case "heli_huey_side_minigun_uwb":
+			case "heli_huey_vista":
+			self init_heli_sounds_huey_toda();
+			self play_huey_toda_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_chinook":
+			case "heli_seaknight":
+			self init_heli_sounds_chinook();
+			self play_chinook_sounds();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_huey_heavyhog_creek":
+			case "heli_huey_heavyhog":
+			case "heli_hip_sidegun":
+			case "heli_hip_spotlight":
+			self init_heli_sounds_hind_vorkuta();
+			self play_hind_sounds_vorkuta();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			case "heli_mini_zt":
+			self init_heli_sounds_zombietron();
+			self play_hind_sounds_zombietron();
+			printLn( "helicopter type: " + self.vehicletype + " found; playing helicopter sounds" );
+			break;
+			default:
+			play_terrain_sounds = false;
+			printLn( "^5helicopter type: " + self.vehicletype + " NOT FOUND; playing NO helicopter sounds" );
+			break;
+		}
+		if( play_terrain_sounds )
+		{
+			self init_terrain_sounds();
+			self thread terrain_trace();
+		}
+	}
+	else
+	{
+		printLn( "^6helicopter type: " + self.vehicletype + " not defined" );
+	}
+}
+delete_loop_sound_save_restore( real_ent )
+{
+	self endon( "heli_entityshutdown" );
+	level waittill( "save_restore" );
+	PrintLn( "heli_script: got save restoring" );
+	if( IsDefined( real_ent ) )
+	{
+		PrintLn( "heli_script: killing helicopter sound ent" );
+		real_ent StopLoopSound( 0 );
+		real_ent Delete();
+	}
+}
+terrain_loop_sound_delete( real_ent )
+{
+	self thread delete_loop_sound_save_restore( real_ent );
+	level endon( "save_restore" );
+	self waittill( "entityshutdown" );
+	self notify( "heli_entityshutdown" );
+	PrintLn( "heli_script: deleting terrain ents" );
+	if( IsDefined( real_ent) )
+	{
+		real_ent StopLoopSound( 4 );
+		real_ent Delete();
+	}
+}
+heli_linkto_sound_ents_delete( localClientNum, entity )
+{
+	entity notify( "heli_entityshutdown" );
+	array_thread( entity.sound_ents, ::heli_delete_sound_loops );
+}
+heli_delete_sound_loops()
+{
+	PrintLn( "heli_script: deleting linkto ents" );
+	if( IsDefined( self ) )
+	{
+		self StopLoopSound( 4 );
+		self Delete();
+	}
+}
+play_hind_sounds()
+{
+	self thread heli_idle_run_transition( "hind", "cockpit" );
+	self thread heli_idle_run_transition( "hind", "cockpit2");
+	self thread heli_idle_run_transition( "hind", "int_eng");
+	self thread heli_idle_run_transition( "hind", "int_eng2" );
+	self thread heli_idle_run_transition( "hind", "ext_rotor");
+}
+play_hind_enemy_sounds()
+{
+	self thread heli_sound_play( self.heli["lfe"] );
+	self thread heli_idle_run_transition( "hind_enemy", "turbine" );
+	self thread heli_idle_run_transition( "hind_enemy", "top_rotor");
+	self thread heli_idle_run_transition( "hind_enemy", "tail_rotor");
+}
+play_huey_sounds()
+{
+	self thread heli_sound_play( self.heli["lfe"] );
+	self thread heli_idle_run_transition( "huey", "cockpit" );
+	self thread heli_idle_run_transition( "huey", "cockpit2");
+	self thread heli_idle_run_transition( "huey", "int_eng");
+	self thread heli_idle_run_transition( "huey", "int_eng2" );
+	self thread heli_idle_run_transition( "huey", "int_eng3");
+	self thread heli_idle_run_transition( "huey", "ext_rotor" );
+}
+play_hip_sounds()
+{
+	self thread heli_sound_play( self.heli["lfe"] );
+	self thread heli_idle_run_transition( "hip", "turbine" );
+	self thread heli_idle_run_transition( "hip", "top_rotor");
+	self thread heli_idle_run_transition( "hip", "tail_rotor");
+}
+play_huey_toda_sounds()
+{
+	self thread heli_sound_play( self.heli["lfe"] );
+	self thread heli_idle_run_transition( "huey_toda", "turbine" );
+	self thread heli_idle_run_transition( "huey_toda", "top_rotor");
+	self thread heli_idle_run_transition( "huey_toda", "tail_rotor");
+}
+play_chinook_sounds()
+{
+	self thread heli_idle_run_transition( "heli_chinook", "top_rotor");
+	self thread heli_idle_run_transition( "heli_chinook", "turbine");
+	self thread heli_sound_play( self.heli["lfe"] );
+}
+play_hind_sounds_vorkuta()
+{
+	self thread heli_idle_run_transition( "hip", "turbine" );
+	self thread heli_idle_run_transition( "hip", "top_rotor");
+	self thread heli_idle_run_transition( "hip", "tail_rotor");
+}
+play_hind_sounds_zombietron()
+{
+	self thread heli_idle_run_transition( "hip", "turbine" );
+	self thread heli_idle_run_transition( "hip", "top_rotor");
+}
+play_heli_sounds_huey_player()
+{
+	self heli_sound_play( self.heli["lfe"] );
+	self heli_sound_play( self.heli["radio"] );
+	self thread heli_idle_run_transition( "huey_player", "turbine" );
+	self thread heli_idle_run_transition( "huey_player", "top_rotor");
+	self thread heli_idle_run_transition( "huey_player", "tail_rotor");
+	self thread heli_idle_run_transition( "huey_player", "wind_rt" );
+	self thread heli_idle_run_transition( "huey_player", "wind_lft");
+}
+heli_sound_play( heli_bone )
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	while( 1 )
+	{
+		if( IsDefined( self.should_not_play_sounds ) && self.should_not_play_sounds )
+		{
+			heli_bone.run StopLoopSound( 0.5 );
+			self waittill( "play_heli_sounds" );
+		}
+		heli_bone.run PlayLoopSound( heli_bone.run.alias, 2 );
+		self waittill( "stop_heli_sounds" );
+	}
+}
+heli_idle_run_transition( heli_type, heli_part )
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	MPH_TO_INCHES_PER_SEC = 17.6;
+	heli_bone = self.heli[heli_part];
+	run_id = undefined;
+	heli_damage = "none";
+	if( !IsDefined( level.heliSoundValues[heli_type] ) )
+	{
+		printLn( "^5a speed vol/pitch parameter was not defined for heli_type '" + heli_type + "'." );
+		return;
+	}
+	if( !IsDefined( level.heliSoundValues[heli_type][heli_part] ) )
+	{
+		printLn( "^5a speed vol/pitch parameter was not defined for heli_type '" + heli_type + "' and heli_part '" + heli_part + "'." );
+		return;
+	}
+	while( IsDefined( self ) )
+	{
+		wait( 0.5 );
+		if( IsDefined( self.should_not_play_sounds ) && self.should_not_play_sounds )
+		{
+			heli_bone.run StopLoopSound( 0.5 );
+			run_id = undefined;
+			self waittill( "play_heli_sounds" );
+			continue;
+		}
+		if( !IsDefined( run_id ) )
+			run_id = heli_bone.run PlayLoopSound( heli_bone.run.alias, 0.5 );
+		max_speed_vol = level.heliSoundValues[heli_type][heli_part].speedVolumeMax;
+		min_vol = level.heliSoundValues[heli_type][heli_part].volumeMin;
+		max_vol = level.heliSoundValues[heli_type][heli_part].volumeMax;
+		max_speed_pitch =	level.heliSoundValues[heli_type][heli_part].speedPitchMax;
+		min_pitch = level.heliSoundValues[heli_type][heli_part].pitchMin;
+		max_pitch = level.heliSoundValues[heli_type][heli_part].pitchMax;
+		self.cur_speed = self getspeed() / MPH_TO_INCHES_PER_SEC;
+		run_volume = scale_speed( self.idle_run_trans_speed, max_speed_vol, min_vol, max_vol, self.cur_speed );
+		run_pitch = scale_speed( self.idle_run_trans_speed, max_speed_pitch, min_pitch, max_pitch, self.cur_speed );
+		if( IsDefined( run_volume ) && IsDefined( run_pitch ) )
+		{
+			setSoundVolume( run_id, run_volume );
+			setSoundPitch( run_id, run_pitch );
+			setSoundPitchRate( run_id, 0.25 );
+			if( IsDefined ( self.isdamaged ) && ( heli_damage == "none" ))
+			{
+				return;
+			}
+			if( getdvarint( #"debug_heli" ) > 0 )
+			{
+				printLn( "^5a self.cur_speed = " + self.cur_speed );
+				printLn( "^5a run_pitch . " + run_pitch );
+				printLn( "^5a self.cur_speed = " + self.cur_speed );
+				printLn( "^5a run_volume. " + run_volume );
+			}
+		}
+	}
+}
+terrain_trace()
+{
+	self endon( "entityshutdown" );
+	level endon( "save_restore" );
+	trace = undefined;
+	trace_ent = self;
+	pre_terrain = undefined;
+	next_terrain = undefined;
+	pre_trace_real_ent = undefined;
+	trace_real_ent = undefined;
+	pre_origin = ( 100000, 100000, 100000 );
+	while( IsDefined( self ) )
+	{
+		wait( 1 + RandomFloatRange( 0.0, 0.2) );
+		if( IsDefined( self.should_not_play_sounds ) && self.should_not_play_sounds )
+		{
+			if( IsDefined( pre_trace_real_ent ) )
+				pre_trace_real_ent StopLoopSound();
+			if( IsDefined( trace_real_ent ) )
+				trace_real_ent StopLoopSound();
+			self waittill( "play_heli_sounds" );
+			continue;
+		}
+		if( DistanceSquared( pre_origin, trace_ent.origin ) < 144 )
+		{
+			continue;
+		}
+		pre_origin = trace_ent.origin;
+		trace = tracepoint( trace_ent.origin, trace_ent.origin - ( 0, 0, 100000 ) );
+		trace_surface_type = trace["surfacetype"];
+		if( !IsDefined( trace ) )
+			continue;
+		pre_terrain = next_terrain;
+		next_terrain = trace_surface_type;
+		if( !IsDefined( pre_terrain ) || !IsDefined( next_terrain ) )
+		{
+			continue;
+		}
+		if( !IsDefined( self.surface_type[next_terrain] ) || !IsDefined( self.surface_type[pre_terrain] ) )
+		{
+			continue;
+		}
+		surf_type = self.surface_type[next_terrain];
+		trace_real_ent = self.terrain_ent_array[surf_type];
+		pre_surf_type = self.surface_type[pre_terrain];
+		pre_trace_real_ent = self.terrain_ent_array[pre_surf_type];
+		if( !IsDefined( trace["position"] ) )
+		{
+			if( IsDefined( pre_trace_real_ent ) )
+			{
+				pre_trace_real_ent StopLoopSound( 0.5 );
+			}
+			continue;
+		}
+		trace_real_ent.origin = trace["position"];
+		pre_trace_real_ent.origin = trace["position"];
+		if( IsDefined( surf_type ) )
+		{
+			if( ( surf_type == pre_surf_type ) && ( pre_trace_real_ent IsPlayingLoopSound() ) )
+				continue;
+			pre_trace_real_ent StopLoopSound( 0.5 );
+			trace_real_ent PlayLoopSound( trace_real_ent.alias, 0.5 );
+		}
+	}
+}
+update_helicopter_sounds()
+{
+	if( IsDefined( self.engine_damage_low ) && self.engine_damage_low )
+	{
+		switch( self.vehicletype )
+		{
+			case "heli_hind_player":
+			if( !IsDefined( self.low_dmg ) )
+			{
+				self thread heli_idle_run_transition( "hind", "eng_dmg" );
+			}
+			self.low_dmg = true;
+			playsound( 0, "veh_hind_alarm_damage_high", (0,0,0) );
+			level.heliSoundValues["hind"]["cockpit"].volumeMax = 1;
+			level.heliSoundValues["hind"]["ext_rotor"].pitchMax = 1.3;
+			printLn( "^5a activating heli sound damage stage 1");
+			break;
+			default:
+			printLn( "^5helicopter type: " + self.vehicletype + " vehicletype; has no helicopter damage sounds" );
+			break;
+		}
+	}
+	if( IsDefined( self.engine_damage_high ) && self.engine_damage_high && IsDefined( self.engine_damage_low ) && !self.engine_damage_low )
+	{
+		switch( self.vehicletype )
+		{
+			case "heli_hind_player":
+			level.heliSoundValues["hind"]["eng_dmg"].volumeMax = 1;
+			level.heliSoundValues["hind"]["ext_rotor"].pitchMax = 1.5;
+			wait( 0.1 );
+			level.heliSoundValues["hind"]["eng_dmg"].volumeMin = 1;
+			printLn( "^5a activating heli sound damage stage 2");
+			break;
+			default:
+			printLn( "^5helicopter type: " + self.vehicletype + " vehicletype; has no helicopter damage sounds" );
+			break;
+		}
+	}
+	if( IsDefined( self.engine_damage_high ) && self.engine_damage_high && IsDefined( self.engine_damage_low ) && self.engine_damage_low )
+	{
+		switch( self.vehicletype )
+		{
+			case "heli_hind_player":
+			playsound( 0, "veh_hind_alarm_damage_high", (0,0,0) );
+			level.heliSoundValues["hind"]["eng_dmg"].volumeMax = 1;
+			level.heliSoundValues["hind"]["ext_rotor"].pitchMax = 1.5;
+			wait( 0.1 );
+			level.heliSoundValues["hind"]["eng_dmg"].volumeMin = 1;
+			printLn( "^5a activating heli sound damage stage 3");
+			break;
+			default:
+			printLn( "^5helicopter type: " + self.vehicletype + " vehicletype; has no helicopter damage sounds" );
+			break;
+		}
+	}
+	if( IsDefined( self.engine_damage_low ) && !self.engine_damage_low && IsDefined( self.engine_damage_high ) && !self.engine_damage_high )
+	{
+		printLn( "^5helicopter type: " + self.vehicletype + " vehicletype; Atempting to reset Defaults" );
+		switch( self.vehicletype )
+		{
+			case "heli_hind_player":
+			init_heli_sound_values( "hind", "cockpit", 95, 0.6, 0.8, 95, 1, 1.1 );
+			init_heli_sound_values( "hind", "cockpit2", 95, 0.5, 0.8, 95, 1, 1.2);
+			init_heli_sound_values( "hind", "int_eng", 65, 0.5, 0.8, 65, 1, 1.1 );
+			init_heli_sound_values( "hind", "int_eng2", 65, 0.4, 0.9, 65, 1, 1.3 );
+			init_heli_sound_values( "hind", "eng_dmg", 40, 0.2, 0.4, 65, 1, 1.1 );
+			init_heli_sound_values( "hind", "ext_rotor", 70, 0.5, 1, 70, 0.95, 1.1);
+			printLn( "^5a Setting Defaults ");
+			break;
+			default:
+			printLn( "^5helicopter type: " + self.vehicletype + " vehicletype; has no helicopter damage sounds" );
+			break;
+		}
+	}
+}
+
+

BO1/PC/ZM/clientscripts/_load.csc

@@ -0,0 +1,310 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_lights;
+#include clientscripts\_music;
+#include clientscripts\_busing;
+#include clientscripts\_clientfaceanim;
+levelNotifyHandler(clientNum, state, oldState)
+{
+	if(state != "")
+	{
+		level notify(state, clientNum);
+	}
+}
+end_last_stand(clientNum)
+{
+	self waittill("lastStandEnd");
+	println("Last stand ending for client " + clientNum);
+	if(getlocalplayers().size == 1)
+	{
+		setBusState("return_default");
+	}
+	realwait(0.7);
+	println("Gasp.");
+	playsound(clientNum, "revive_gasp");
+}
+last_stand_thread(clientNum)
+{
+	self thread end_last_stand(clientNum);
+	self endon("lastStandEnd");
+	println("*** Client : Last stand starts on client " + clientNum);
+	if( IsDefined( level.zombie_intermission ) && level.zombie_intermission )
+	{
+		setBusState("zombie_death");
+	}
+	else if(getlocalplayers().size == 1)
+	{
+		setBusState("last_stand_start");
+		realWait(0.1);
+		setBusState("last_stand_duration");
+	}
+	startVol = 0.5;
+	maxVol = 1.0;
+	startPause = 0.5;
+	maxPause = 2.0;
+	pause = startPause;
+	vol = startVol;
+	while(1)
+	{
+		id = playsound(clientNum, "chr_heart_beat");
+		setSoundVolume(id, vol);
+		realWait(pause);
+		if(pause < maxPause)
+		{
+			pause *= 1.05;
+			if(pause > maxPause)
+			{
+				pause = maxPause;
+			}
+		}
+		if(vol < maxVol)
+		{
+			vol *= 1.05;
+			if(vol > maxVol)
+			{
+				vol = maxVol;
+			}
+		}
+	}
+}
+last_stand_monitor(clientNum, state, oldState)
+{
+	player = getlocalplayers()[clientNum];
+	players = getlocalplayers();
+	if ( !isdefined( level._laststand ) )
+	{
+		level._laststand = [];
+	}
+	if ( !isdefined( level._laststand[clientNum] ) )
+	{
+		level._laststand[clientNum] = 0;
+	}
+	if(state == "1")
+	{
+		if(!level._laststand[clientNum])
+		{
+			if(!isdefined(level.lslooper))
+			{
+				level.lslooper = spawn(0, player.origin, "script.origin");
+			}
+			player thread last_stand_thread(clientNum);
+			if( players.size <= 1 )
+			{
+				level.lslooper playloopsound("evt_laststand_loop", 0.3);
+			}
+			level._laststand[clientNum] = true;
+		}
+	}
+	else
+	{
+		if(level._laststand[clientNum])
+		{
+			if(isdefined(level.lslooper))
+			{
+				level.lslooper stoploopsound(0.7);
+			}
+			player notify("lastStandEnd");
+			level._laststand[clientNum] = false;
+		}
+	}
+}
+damage_visionset_think(local_client_num)
+{
+	player = getlocalplayers()[local_client_num];
+	player endon("disconnect");
+	level endon("save_restore");
+	wait(1.0);
+	max_health = 100;
+	health_threshold = max_health * 0.75;
+	health_threshold_off = max_health;
+	visionset = false;
+	PrintLn("*** HTH " + health_threshold);
+	while(1)
+	{
+		health = GetLocalClientHealth(local_client_num);
+		if(visionset == false)
+		{
+			if(health < health_threshold)
+			{
+				VisionSetDamage(local_client_num, 1, "low_health", 2);
+				visionset = true;
+			}
+		}
+		else
+		{
+			if(health >= max_health)
+			{
+				PrintLn("*** VS OFF");
+				VisionSetDamage(local_client_num, 0, "low_health", 2);
+				visionset = false;
+			}
+		}
+		realWait(0.01);
+	}
+}
+effects_init_thread(client, notify_name)
+{
+	if ( level.zombiemode && IsSplitscreen() && client == 1 )
+	{
+		level.effects_init = undefined;
+		level thread effects_init_failsafe();
+	}
+	level waittill(notify_name);
+	println("*** Client : Starting effects system for client " + client);
+	if ( level.zombiemode && IsSplitscreen() && client == 1 )
+	{
+		level.effects_init = true;
+	}
+	clientscripts\_fx::fx_init(client);
+	clientscripts\_ambient::init(client);
+}
+effects_init_failsafe()
+{
+	wait( 1 );
+	if ( !isdefined( level.effects_init ) )
+	{
+		println( "**** Client : Effects never started for client 1" );
+		level notify( "effects_init_1" );
+	}
+}
+default_flag_change_handler(localClientNum, flag, set, newEnt)
+{
+}
+init_client_flags()
+{
+	level.CF_PLAYER_UNDERWATER = 15;
+}
+register_default_vehicle_callbacks()
+{
+	level._client_flag_callbacks["vehicle"] = [];
+	register_clientflag_callback("vehicle", 0, clientscripts\_vehicle::vehicle_flag_0_handler);
+	register_clientflag_callback("vehicle", 1, clientscripts\_vehicle::vehicle_flag_1_handler);
+	register_clientflag_callback("vehicle", 2, clientscripts\_vehicle::vehicle_flag_toggle_sounds);
+	register_clientflag_callback("vehicle", 3, clientscripts\_vehicle::vehicle_flag_3_handler);
+	register_clientflag_callback("vehicle", 4, clientscripts\_vehicle::vehicle_flag_4_handler);
+	register_clientflag_callback("vehicle", 6, clientscripts\_vehicle::vehicle_flag_turn_off_treadfx);
+	register_clientflag_callback("vehicle", 7, clientscripts\_vehicle::vehicle_flag_change_treadfx_handler);
+	register_clientflag_callback("vehicle", 8, clientscripts\_vehicle::vehicle_flag_toggle_exhaustfx_handler);
+	register_clientflag_callback("vehicle", 9, clientscripts\_vehicle::vehicle_flag_change_exhaustfx_handler);
+	register_clientflag_callback("vehicle", 10, clientscripts\_vehicle::vehicle_flag_toggle_lights_handler);
+	register_clientflag_callback("vehicle", 11, clientscripts\_vehicle::vehicle_flag_toggle_siren_lights_handler);
+	register_clientflag_callback("vehicle", 12, clientscripts\_vehicle::vehicle_flag_toggle_interior_lights_handler);
+}
+register_default_actor_callbacks()
+{
+	level._client_flag_callbacks["actor"] = [];
+}
+register_default_player_callbacks()
+{
+	level._client_flag_callbacks["player"] = [];
+	register_clientflag_callback("player", level.CF_PLAYER_UNDERWATER, ::player_underwater_flag_handler);
+}
+register_default_NA_callbacks()
+{
+	level._client_flag_callbacks["NA"] = [];
+}
+register_default_general_callbacks()
+{
+	level._client_flag_callbacks["general"] = [];
+}
+register_default_missile_callbacks()
+{
+	level._client_flag_callbacks["missile"] = [];
+}
+register_default_scriptmover_callbacks()
+{
+	level._client_flag_callbacks["scriptmover"] = [];
+}
+register_default_mg42_callbacks()
+{
+	level._client_flag_callbacks["mg42"] = [];
+}
+register_default_plane_callbacks()
+{
+	level._client_flag_callbacks["plane"] = [];
+	register_clientflag_callback("plane", 6, clientscripts\_vehicle::vehicle_flag_turn_off_treadfx);
+}
+setup_default_client_flag_callbacks()
+{
+	init_client_flags();
+	level._client_flag_callbacks	= [];
+	register_default_vehicle_callbacks();
+	register_default_actor_callbacks();
+	register_default_player_callbacks();
+	register_default_NA_callbacks();
+	register_default_general_callbacks();
+	register_default_missile_callbacks();
+	register_default_scriptmover_callbacks();
+	register_default_mg42_callbacks();
+	register_default_plane_callbacks();
+}
+player_underwater_flag_handler(localClientNum, set, newEnt)
+{
+	action = "SET";
+	if(!set)
+	{
+		action = "CLEAR";
+	}
+	if(action == "SET")
+	{
+		if(isDefined(level.swimming_underwater_func))
+		{
+			self [[level.swimming_underwater_func]]();
+		}
+		else
+		{
+			self clientscripts\_swimming::underwater();
+		}
+	}
+	else
+	{
+		if(isDefined(level.swimming_surface_func))
+		{
+			self [[level.swimming_surface_func]]();
+		}
+		else
+		{
+			self clientscripts\_swimming::surface();
+		}
+	}
+}
+main()
+{
+	clientscripts\_utility_code::struct_class_init();
+	clientscripts\_utility::registerSystem("levelNotify", ::levelNotifyHandler);
+	clientscripts\_utility::registerSystem("lsm", ::last_stand_monitor);
+	level.createFX_enabled = ( getdvar( #"createfx" ) != "" );
+	level.zombiemode = ( GetDvar( #"zombiemode" ) == "1" );
+	if( !isDefined( level.scr_anim ) )
+		level.scr_anim[ 0 ][ 0 ] = 0;
+	setup_default_client_flag_callbacks();
+	clientscripts\_global_fx::main();
+	clientscripts\_busing::busInit();
+	clientscripts\_ambientpackage::init();
+	clientscripts\_music::music_init();
+	clientscripts\_vehicle::init_vehicles();
+	clientscripts\_contextual_melee::main();
+	clientscripts\_footsteps::init();
+	clientscripts\_helicopter_sounds::init();
+	clientscripts\_face_generichuman::init();
+	clientscripts\_clientfaceanim::init_clientfaceanim();
+	if(IsDefined(level._uses_crossbow) && level._uses_crossbow == true)
+	{
+		level thread clientscripts\_explosive_bolt::main();
+	}
+	for(i = 0; i < 4; i ++)
+	{
+		level thread effects_init_thread(i, "effects_init_"+i);
+	}
+	add_listen_thread( "rfo1", clientscripts\_utility::loop_sound_on_client, "chr_breathing_hurt", 0.3, 0.7, "rfo2" );
+	add_listen_thread( "rfo3", clientscripts\_utility::play_sound_on_client, "chr_breathing_better" );
+	add_listen_thread( "zi", ::zombie_intermission );
+	level.onlineGame = GetDvarInt( #"onlinegame" );
+	level._load_done = 1;
+}
+zombie_intermission()
+{
+	level.zombie_intermission = true;
+}
+
+

BO1/PC/ZM/clientscripts/_mortar.csc

@@ -0,0 +1,519 @@
+#include clientscripts\_utility;
+main()
+{
+}
+init_mortars()
+{
+	level._explosion_max_range = [];
+	level._explosion_min_range = [];
+	level._explosion_blast_radius = [];
+	level._explosion_quake_power = [];
+	level._explosion_quake_time = [];
+	level._explosion_quake_radius = [];
+	level._explosion_min_delay = [];
+	level._explosion_max_delay = [];
+	level._explosion_barrage_min_delay = [];
+	level._explosion_barrage_max_delay = [];
+	level._explosion_view_chance = [];
+	level._explosion_dust_range = [];
+	level._explosion_dust_name = [];
+}
+set_mortar_dust( mortar_name, dust_name, range )
+{
+	if( !IsDefined( level._explosion_dust_range ) )
+	{
+		init_mortars();
+	}
+	level._explosion_dust_name[mortar_name] = dust_name;
+	if( !IsDefined( range ) )
+	{
+		range = 512;
+	}
+	level._explosion_dust_range[mortar_name] = range;
+}
+set_mortar_quake( mortar_name, quake_power, quake_time, quake_radius, set_default )
+{
+	if( !IsDefined( level._explosion_quake_power ) )
+	{
+		init_mortars();
+	}
+	if( IsDefined( set_default ) && set_default )
+	{
+		if( !IsDefined( level._explosion_quake_power[mortar_name] ) )
+		{
+			level._explosion_quake_power[mortar_name] = quake_power;
+		}
+		if( !IsDefined( level._explosion_quake_power[mortar_name] ) )
+		{
+			level._explosion_quake_time[mortar_name] = quake_time;
+		}
+		if( !IsDefined( level._explosion_quake_radius[mortar_name] ) )
+		{
+			level._explosion_quake_radius[mortar_name] = quake_radius;
+		}
+	}
+	else
+	{
+		level._explosion_quake_power[mortar_name] = quake_power;
+		level._explosion_quake_time[mortar_name] = quake_time;
+		level._explosion_quake_radius[mortar_name] = quake_radius;
+	}
+}
+set_mortar_range( mortar_name, min_range, max_range, set_default )
+{
+	if( !IsDefined( level._explosion_min_range ) )
+	{
+		init_mortars();
+	}
+	if( IsDefined( set_default ) && set_default )
+	{
+		if( !IsDefined( level._explosion_min_range[mortar_name] ) )
+		{
+			level._explosion_min_range[mortar_name] = min_range;
+		}
+		if( !IsDefined( level._explosion_max_range[mortar_name] ) )
+		{
+			level._explosion_max_range[mortar_name] = max_range;
+		}
+	}
+	else
+	{
+		level._explosion_min_range[mortar_name] = min_range;
+		level._explosion_max_range[mortar_name] = max_range;
+	}
+}
+set_mortar_delays( mortar_name, min_delay, max_delay, barrage_min_delay, barrage_max_delay, set_default )
+{
+	if( !IsDefined( level._explosion_min_delay ) )
+	{
+		init_mortars();
+	}
+	if( IsDefined( set_default ) && set_default )
+	{
+		if( !IsDefined( level._explosion_min_delay[mortar_name] ) && IsDefined( min_delay ) )
+		{
+			level._explosion_min_delay[mortar_name] = min_delay;
+		}
+		if( !IsDefined( level._explosion_max_delay[mortar_name] ) && IsDefined( min_delay ) )
+		{
+			level._explosion_max_delay[mortar_name] = max_delay;
+		}
+		if( !IsDefined( level._explosion_barrage_min_delay[mortar_name] ) && IsDefined( barrage_min_delay ) )
+		{
+			level._explosion_barrage_min_delay[mortar_name] = barrage_min_delay;
+		}
+		if( !IsDefined( level._explosion_barrage_max_delay[mortar_name] ) && IsDefined( barrage_max_delay ) )
+		{
+			level._explosion_barrage_max_delay[mortar_name] = barrage_max_delay;
+		}
+	}
+	else
+	{
+		if( IsDefined( min_delay ) )
+		{
+			level._explosion_min_delay[mortar_name] = min_delay;
+		}
+		if( IsDefined( min_delay ) )
+		{
+			level._explosion_max_delay[mortar_name] = max_delay;
+		}
+		if( IsDefined( barrage_min_delay ) )
+		{
+			level._explosion_barrage_min_delay[mortar_name] = barrage_min_delay;
+		}
+		if( IsDefined( barrage_max_delay ) )
+		{
+			level._explosion_barrage_max_delay[mortar_name] = barrage_max_delay;
+		}
+	}
+}
+set_mortar_chance( mortar_name, chance, set_default )
+{
+	if( !IsDefined( level._explosion_view_chance ) )
+	{
+		init_mortars();
+	}
+	assertex( chance <= 1, "_mortar::set_mortar_chance(), the chance parameter needs to be between 0 and 1" );
+	if( IsDefined( set_default ) && set_default )
+	{
+		if( !IsDefined( level._explosion_view_chance[mortar_name] ) )
+		{
+			level._explosion_view_chance[mortar_name] = chance;
+		}
+	}
+	else
+	{
+		level._explosion_view_chance[mortar_name] = chance;
+	}
+}
+player_view_chance( view_chance, explosion_point )
+{
+	chance = RandomFloat( 1 );
+	if( chance <= view_chance )
+	{
+		if( within_fov( self GetEye(), self GetPlayerAngles(), explosion_point, cos( 30 ) ) )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+explosion_incoming( mortar_name, pos, soundnum )
+{
+	if( !IsDefined( level._explosion_last_incoming ) )
+	{
+		level._explosion_last_incoming = -1;
+	}
+	soundnum = RandomInt( 4 ) + 1;
+	while( soundnum == level._explosion_last_incoming )
+	{
+		soundnum = RandomInt( 4 ) + 1;
+	}
+	level._explosion_last_incoming = soundnum;
+	if( level._effectType[mortar_name] == "mortar" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_incoming1", pos );
+			wait( 1.07 - 0.25 );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_incoming2", pos );
+			wait( 0.67 - 0.25 );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_incoming3", pos );
+			wait( 1.55 - 0.25 );
+			break;
+			default:
+			wait( 1.75 );
+			break;
+		}
+	}
+	else if( level._effectType[mortar_name] == "artillery" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_incoming4", pos );
+			wait( 1.07 - 0.25 );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_incoming4_new", pos );
+			wait( 0.67 - 0.25 );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_incoming1_new", pos );
+			wait( 1.55 - 0.25 );
+			break;
+			default:
+			wait( 1.75 );
+			break;
+		}
+	}
+	else if( level._effectType[mortar_name] == "bomb" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_incoming2_new", pos );
+			wait( 1.75 );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_incoming3_new", pos );
+			wait( 1.75 );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_incoming4_new", pos );
+			wait( 1.75 );
+			break;
+			default:
+			wait( 1.75 );
+			break;
+		}
+	}
+}
+explosion_boom( mortar_name, explosion_origin, power, time, radius )
+{
+	if( !IsDefined( power ) )
+	{
+		power = 0.15;
+	}
+	if( !IsDefined( time ) )
+	{
+		time = 2;
+	}
+	if( !IsDefined( radius ) )
+	{
+		radius = 850;
+	}
+	explosion_sound( mortar_name, explosion_origin );
+	PlayFx( 0, level._effect[mortar_name], explosion_origin );
+	localPlayers = getlocalplayers();
+	for(i = 0; i < localPlayers.size; i ++)
+	{
+		localPlayers[i] Earthquake( power, time, explosion_origin, radius );
+	}
+}
+explosion_sound( mortar_name, pos )
+{
+	if( !IsDefined( level._explosion_last_sound ) )
+	{
+		level._explosion_last_sound = 0;
+	}
+	soundnum = RandomInt( 3 ) + 1;
+	while( soundnum == level._explosion_last_sound )
+	{
+		soundnum = RandomInt( 3 ) + 1;
+	}
+	level._explosion_last_sound = soundnum;
+	if( level._effectType[mortar_name] == "mortar" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_dirt", pos );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_dirt", pos );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_dirt", pos );
+			break;
+		}
+	}
+	if( level._effectType[mortar_name] == "mortar_water" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_water", pos );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_water", pos );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_water", pos );
+			break;
+		}
+	}
+	else if( level._effectType[mortar_name] == "artillery" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_explosion4", pos );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_explosion5", pos );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_explosion1", pos );
+			break;
+		}
+	}
+	else if( level._effectType[mortar_name] == "bomb" )
+	{
+		switch( soundnum )
+		{
+			case 1:
+			PlaySound( 0, "mortar_explosion1", pos );
+			break;
+			case 2:
+			PlaySound( 0, "mortar_explosion4", pos );
+			break;
+			case 3:
+			PlaySound( 0, "mortar_explosion5", pos );
+			break;
+		}
+	}
+}
+explosion_activate( mortar_name, blast_radius, min_damage, max_damage, quake_power, quake_time, quake_radius, dust_points )
+{
+	set_mortar_quake( mortar_name, 0.15, 2, 850, true );
+	if( !IsDefined( blast_radius ) )
+	{
+		blast_radius = level._explosion_blast_radius[mortar_name];
+	}
+	if( !IsDefined( quake_power ) )
+	{
+		quake_power = level._explosion_quake_power[mortar_name];
+	}
+	if( !IsDefined( quake_time ) )
+	{
+		quake_time = level._explosion_quake_time[mortar_name];
+	}
+	if( !IsDefined( quake_radius ) )
+	{
+		quake_radius = level._explosion_quake_radius[mortar_name];
+	}
+	explosion_incoming( mortar_name, self.origin );
+	level notify( "explosion", mortar_name );
+	explosion_boom( mortar_name, self.origin, quake_power, quake_time, quake_radius );
+	if( IsDefined( dust_points ) && dust_points.size > 0 )
+	{
+		max_range = 384;
+		if( IsDefined( level._explosion_dust_range ) && IsDefined( level._explosion_dust_range[mortar_name] ) )
+		{
+			max_range = level._explosion_dust_range[mortar_name];
+		}
+		for( i = 0; i < dust_points.size; i++ )
+		{
+			if( DistanceSquared( dust_points[i].origin, self.origin ) < max_range * max_range )
+			{
+				if( IsDefined( dust_points[i].script_fxid ) )
+				{
+					PlayFx( 0, level._effect[dust_points[i].script_fxid], dust_points[i].origin );
+				}
+				else
+				{
+					PlayFx( 0, level._effect[level._explosion_dust_name[mortar_name]], dust_points[i].origin );
+				}
+			}
+		}
+	}
+}
+mortar_loop( mortar_name, barrage_amount, no_terrain )
+{
+	level endon( "stop_all_mortar_loops" );
+	assertex( ( IsDefined( mortar_name ) &&( mortar_name != "" ) ), "mortar_name not passed. pass in level script" );
+	assertex( ( IsDefined( level._effect ) && IsDefined( level._effect[mortar_name] ) ), "level._effect[strMortars] not defined. define in level script" );
+	last_explosion = -1;
+	set_mortar_range( mortar_name, 300, 2200, true );
+	set_mortar_delays( mortar_name, 5, 7, 5, 7, true );
+	set_mortar_chance( mortar_name, 0, true );
+	if( !IsDefined( barrage_amount ) || barrage_amount < 1 )
+	{
+		barrage_amount = 1;
+	}
+	if( !IsDefined( no_terrain ) )
+	{
+		no_terrain = false;
+	}
+	if( IsDefined( level._explosion_stopNotify ) && IsDefined( level._explosion_stopNotify[mortar_name] ) )
+	{
+		level endon( level._explosion_stopNotify[mortar_name] );
+	}
+	if( !IsDefined( level._explosion_stop_barrage ) || !IsDefined( level._explosion_stop_barrage[mortar_name] ) )
+	{
+		level._explosion_stop_barrage[mortar_name] = false;
+	}
+	explosion_points = [];
+	explosion_points_structs = [];
+	num_points = 0;
+	while(num_points == 0)
+	{
+		explosion_points = GetEntArray( 0, mortar_name, "targetname" );
+		explosion_points_structs = getstructarray( mortar_name, "targetname" );
+		num_points = explosion_points.size + explosion_points_structs.size;
+		wait(0.5);
+	}
+	for( i = 0; i < explosion_points_structs.size; i++ )
+	{
+		explosion_points_structs[i].is_struct = true;
+		explosion_points = add_to_array( explosion_points, explosion_points_structs[i] );
+	}
+	explosion_points_structs = [];
+	dust_points = [];
+	if( IsDefined( level._explosion_dust_name[mortar_name] ) )
+	{
+		dust_name = level._explosion_dust_name[mortar_name];
+		dust_points = GetEntArray( 0, dust_name, "targetname" );
+		dust_points_structs = [];
+		dust_points_structs = getstructarray( dust_name, "targetname" );
+		for( i = 0; i < dust_points_structs.size; i++ )
+		{
+			dust_points_structs[i].is_struct = true;
+			dust_points = add_to_array( dust_points, dust_points_structs[i] );
+		}
+		dust_points_structs = [];
+	}
+	if( IsDefined( level._explosion_start_notify ) && IsDefined( level._explosion_start_notify[mortar_name] ) )
+	{
+		level waittill( level._explosion_start_notify[mortar_name] );
+	}
+	while( true )
+	{
+		while( !level._explosion_stop_barrage[mortar_name] )
+		{
+			do_mortar = false;
+			for( j = 0; j < barrage_amount; j++ )
+			{
+				max_rangeSQ = level._explosion_max_range[mortar_name] * level._explosion_max_range[mortar_name];
+				min_rangeSQ = level._explosion_min_range[mortar_name] * level._explosion_min_range[mortar_name];
+				random_num = RandomInt( explosion_points.size );
+				for( i = 0; i < explosion_points.size; i++ )
+				{
+					num = ( i + random_num ) % explosion_points.size;
+					do_mortar = false;
+					players = getlocalplayers();
+					for( q = 0; q < players.size; q++ )
+					{
+						dist = DistanceSquared( players[q] GetOrigin(), explosion_points[num].origin );
+						if( num != last_explosion && dist < max_rangeSQ && dist > min_rangeSQ )
+						{
+							if( level._explosion_view_chance[mortar_name] > 0 )
+							{
+								if( players[q] player_view_chance( level._explosion_view_chance[mortar_name], explosion_points[num].origin ) )
+								{
+									do_mortar = true;
+									break;
+								}
+								else
+								{
+									do_mortar = false;
+								}
+							}
+							else
+							{
+								do_mortar = true;
+								break;
+							}
+						}
+						else
+						{
+							do_mortar = false;
+						}
+					}
+					if( do_mortar )
+					{
+						explosion_points[num] thread explosion_activate( mortar_name, undefined, undefined, undefined, undefined, undefined, undefined, dust_points );
+						last_explosion = num;
+						break;
+					}
+				}
+				last_explosion = -1;
+				if( do_mortar )
+				{
+					if( IsDefined( level._explosion_delay ) && IsDefined( level._explosion_delay[mortar_name] ) )
+					{
+						wait( level._explosion_delay[mortar_name] );
+					}
+					else
+					{
+						wait( RandomFloatRange( level._explosion_min_delay[mortar_name], level._explosion_max_delay[mortar_name] ) );
+					}
+				}
+				else
+				{
+					j--;
+					wait( 0.25 );
+				}
+			}
+			if( barrage_amount > 1 )
+			{
+				if( IsDefined( level._explosion_barrage_delay ) && IsDefined( level._explosion_barrage_delay[mortar_name] ) )
+				{
+					wait( level._explosion_barrage_delay[mortar_name] );
+				}
+				else
+				{
+					wait( RandomFloatRange( level._explosion_barrage_min_delay[mortar_name], level._explosion_barrage_max_delay[mortar_name] ) );
+				}
+			}
+		}
+		wait( 0.05 );
+	}
+}
+

BO1/PC/ZM/clientscripts/_zombiemode.csc

@@ -0,0 +1,988 @@
+#include clientscripts\_music;
+#include clientscripts\_utility;
+#include clientscripts\_zombiemode_dissolve;
+main()
+{
+	level thread clientscripts\_zombiemode_ffotd::main_start();
+	level.zombiemode = true;
+	level.swimmingFeature = false;
+	clientscripts\_load::main();
+	clientscripts\_footsteps::SetAIFootstepPrepend( "fly_step_zombie_");
+	thread clientscripts\_audio::audio_init(0);
+	init_client_flags();
+	init_client_flag_callback_funcs();
+	init_blocker_fx();
+	init_riser_fx();
+	level._zombieCBFunc = clientscripts\_zombiemode::on_zombie_spawn;
+	level._playerCBFunc = clientscripts\_zombiemode::on_player_spawn;
+	level._gibEventCBFunc = clientscripts\_zombiemode::on_gib_event;
+	level thread ZPO_listener();
+	level._BOX_INDICATOR_NO_LIGHTS = -1;
+	level._BOX_INDICATOR_FLASH_LIGHTS_MOVING = 99;
+	level._BOX_INDICATOR_FLASH_LIGHTS_FIRE_SALE = 98;
+	level._box_indicator = level._BOX_INDICATOR_NO_LIGHTS;
+	registerSystem("box_indicator", ::box_monitor);
+	level._ZOMBIE_GIB_PIECE_INDEX_ALL = 0;
+	level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM = 1;
+	level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM = 2;
+	level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG = 3;
+	level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG = 4;
+	level._ZOMBIE_GIB_PIECE_INDEX_HEAD = 5;
+	level._ZOMBIE_GIB_PIECE_INDEX_GUTS = 6;
+	OnPlayerConnect_Callback( ::on_player_connect );
+	clientscripts\_zombiemode_weap_freezegun::init();
+	clientscripts\_zombiemode_weap_tesla::init();
+	clientscripts\_zombiemode_weap_thundergun::init();
+	level thread init_local_player_count();
+	level thread clientscripts\_zombiemode_ffotd::main_end();
+}
+init_local_player_count()
+{
+	waitforallclients();
+	level._num_local_players = getlocalplayers().size;
+}
+init_blocker_fx()
+{
+	level._effect["wood_chunk_destory"] = LoadFX( "impacts/fx_large_woodhit" );
+}
+init_riser_fx()
+{
+	if(isDefined(level.riser_fx_on_client) && level.riser_fx_on_client )
+	{
+		if(isDefined(level.use_new_riser_water) && level.use_new_riser_water)
+		{
+			level._effect["rise_burst_water"] = LoadFX("maps/zombie/fx_mp_zombie_hand_water_burst");
+			level._effect["rise_billow_water"] = LoadFX("maps/zombie/fx_mp_zombie_body_water_billowing");
+		}
+		level._effect["rise_dust_water"] = LoadFX("maps/zombie/fx_zombie_body_wtr_falling");
+		level._effect["rise_burst"] = LoadFX("maps/zombie/fx_mp_zombie_hand_dirt_burst");
+		level._effect["rise_billow"] = LoadFX("maps/zombie/fx_mp_zombie_body_dirt_billowing");
+		level._effect["rise_dust"] = LoadFX("maps/zombie/fx_mp_zombie_body_dust_falling");
+		if(isDefined(level.riser_type) && level.riser_type == "snow")
+		{
+			level._effect["rise_burst_snow"] = loadfx("maps/zombie/fx_mp_zombie_hand_snow_burst");
+			level._effect["rise_billow_snow"] = loadfx("maps/zombie/fx_mp_zombie_body_snow_billowing");
+			level._effect["rise_dust_snow"] = LoadFX("maps/zombie/fx_mp_zombie_body_snow_falling");
+		}
+	}
+}
+init_client_flags()
+{
+	level._ZOMBIE_SCRIPTMOVER_FLAG_BOX_RANDOM	= 15;
+	if(isDefined(level.use_clientside_board_fx) && level.use_clientside_board_fx)
+	{
+		level._ZOMBIE_SCRIPTMOVER_FLAG_BOARD_HORIZONTAL_FX	= 14;
+		level._ZOMBIE_SCRIPTMOVER_FLAG_BOARD_VERTICAL_FX	= 13;
+	}
+	if(isDefined(level.use_clientside_rock_tearin_fx) && level.use_clientside_rock_tearin_fx)
+	{
+		level._ZOMBIE_SCRIPTMOVER_FLAG_ROCK_FX	= 12;
+	}
+	level._ZOMBIE_PLAYER_FLAG_CLOAK_WEAPON = 14;
+	level._ZOMBIE_PLAYER_FLAG_DIVE2NUKE_VISION = 13;
+	level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK = 12;
+	if(isDefined(level.riser_fx_on_client) && level.riser_fx_on_client)
+	{
+		level._ZOMBIE_ACTOR_ZOMBIE_RISER_FX = 8;
+		if(!isDefined(level._no_water_risers))
+		{
+			level._ZOMBIE_ACTOR_ZOMBIE_RISER_FX_WATER = 9;
+		}
+		if(isDefined(level.risers_use_low_gravity_fx))
+		{
+			level._ZOMBIE_ACTOR_ZOMBIE_RISER_LOWG_FX = 7;
+		}
+	}
+}
+init_client_flag_callback_funcs()
+{
+	if(isDefined(level.use_clientside_board_fx) && level.use_clientside_board_fx)
+	{
+		register_clientflag_callback("scriptmover", level._ZOMBIE_SCRIPTMOVER_FLAG_BOARD_VERTICAL_FX, ::handle_vertical_board_clientside_fx);
+		register_clientflag_callback("scriptmover", level._ZOMBIE_SCRIPTMOVER_FLAG_BOARD_HORIZONTAL_FX, ::handle_horizontal_board_clientside_fx);
+	}
+	if(isDefined(level.use_clientside_rock_tearin_fx) && level.use_clientside_rock_tearin_fx)
+	{
+		register_clientflag_callback("scriptmover", level._ZOMBIE_SCRIPTMOVER_FLAG_ROCK_FX, ::handle_rock_clientside_fx);
+	}
+	register_clientflag_callback("scriptmover", level._ZOMBIE_SCRIPTMOVER_FLAG_BOX_RANDOM, clientscripts\_zombiemode_weapons::weapon_box_callback);
+	register_clientflag_callback( "player", level._ZOMBIE_PLAYER_FLAG_DIVE2NUKE_VISION, ::zombie_dive2nuke_visionset );
+	register_clientflag_callback("player", level._ZOMBIE_PLAYER_FLAG_CLOAK_WEAPON, ::player_toggle_cloak_handler);
+	register_clientflag_callback("player", level._ZOMBIE_PLAYER_FLAG_DEADSHOT_PERK, ::player_deadshot_perk_handler);
+	if(isDefined(level.riser_fx_on_client) && level.riser_fx_on_client)
+	{
+		register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_ZOMBIE_RISER_FX, ::handle_zombie_risers );
+		if(!isDefined(level._no_water_risers))
+		{
+			register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_ZOMBIE_RISER_FX_WATER, ::handle_zombie_risers_water );
+		}
+		if(isDefined(level.risers_use_low_gravity_fx))
+		{
+			register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_ZOMBIE_RISER_LOWG_FX, ::handle_zombie_lowg_risers );
+		}
+	}
+}
+handle_horizontal_board_clientside_fx(localClientNum, set, newEnt)
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (0, 0, 30));
+			wait( randomfloat( 0.3, 0.6 ));
+			if(!snd_played)
+			{
+				self thread do_teardown_sound("plank");
+				snd_played = true;
+			}
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (0, 0, -30));
+		}
+	}
+	else
+	{
+		playsound(0,"zmb_repair_boards",self.origin);
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		if(isDefined(level.override_board_repair_sound ))
+		{
+			sound = level.override_board_repair_sound;
+		}
+		else
+		{
+			sound = "zmb_repair_boards";
+		}
+		playsound(0,sound,self.origin);
+		wait(.3);
+		PlaySound(0, "zmb_board_slam",self.origin );
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			localPlayers[i] EarthQuake( RandomFloatRange( 0.3, 0.4 ), RandomFloatRange(0.2, 0.4), self.origin, 150 );
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (0, 0, 30));
+			wait( randomfloat( 0.3, 0.6 ));
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (0, 0, -30));
+		}
+	}
+}
+handle_vertical_board_clientside_fx(localClientNum, set, newEnt)
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (30, 0, 0));
+			wait( randomfloat( 0.3, 0.6 ));
+			if(!snd_played)
+			{
+				self thread do_teardown_sound("plank");
+				snd_played = true;
+			}
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (-30, 0, 0));
+		}
+	}
+	else
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		if(isDefined(level.override_board_repair_sound ))
+		{
+			sound = level.override_board_repair_sound;
+		}
+		else
+		{
+			sound = "zmb_repair_boards";
+		}
+		playsound(0,sound,self.origin);
+		wait(.3);
+		PlaySound(0, "zmb_board_slam",self.origin );
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			localPlayers[i] EarthQuake( RandomFloatRange( 0.3, 0.4 ), RandomFloatRange(0.2, 0.4), self.origin, 150 );
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (30, 0, 0));
+			wait( randomfloat( 0.3, 0.6 ));
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (-30, 0, 0));
+		}
+	}
+}
+handle_rock_clientside_fx(localClientNum, set, newEnt)
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (30, 0, 0));
+			wait( randomfloat( 0.3, 0.6 ));
+			if(!snd_played)
+			{
+				self thread do_teardown_sound("rock");
+				snd_played = true;
+			}
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (-30, 0, 0));
+		}
+	}
+	else
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		playsound(0,"zmb_repair_boards",self.origin);
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			localPlayers[i] EarthQuake( RandomFloatRange( 0.3, 0.4 ), RandomFloatRange(0.2, 0.4), self.origin, 150 );
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (30, 0, 0));
+			wait( randomfloat( 0.3, 0.6 ));
+			if(!snd_played)
+			{
+				PlaySound(0, "zmb_break_rock_barrier_fix",self.origin );
+				snd_played = true;
+			}
+			PlayFx( i,level._effect["wood_chunk_destory"], self.origin + (-30, 0, 0));
+		}
+	}
+}
+do_teardown_sound(type)
+{
+	switch(type)
+	{
+		case "rock":
+		PlaySound(0,"zmb_break_rock_barrier",self.origin );
+		wait( randomfloat( 0.3, 0.6 ));
+		PlaySound( 0,"zmb_break_rock_barrier",self.origin );
+		break;
+		case "plank":
+		if(	isDefined(level.override_board_teardown_sound))
+		{
+			sound = level.override_board_teardown_sound;
+		}
+		else
+		{
+			sound = "zmb_break_boards";
+		}
+		PlaySound(0,sound,self.origin );
+		wait( randomfloat( 0.3, 0.6 ));
+		PlaySound( 0,sound,self.origin );
+		break;
+	}
+}
+box_monitor(clientNum, state, oldState)
+{
+	if(IsDefined(level._custom_box_monitor))
+	{
+		[[level._custom_box_monitor]](clientNum, state, oldState);
+	}
+}
+ZPO_listener()
+{
+	while(1)
+	{
+		level waittill("ZPO");
+		level notify("power_on" );
+		level notify("revive_on");
+		level notify("middle_door_open");
+		level notify("fast_reload_on");
+		level notify("doubletap_on");
+		level notify("divetonuke_on");
+		level notify("marathon_on");
+		level notify("jugger_on");
+		level notify("additionalprimaryweapon_on");
+	}
+}
+player_deadshot_perk_handler(localClientNum, set, newEnt)
+{
+	if ( !self IsLocalPlayer() || self IsSpectating() || self GetEntityNumber() != GetLocalPlayers()[localClientNum] GetEntityNumber() )
+		return;
+	if(set)
+	{
+		self UseAlternateAimParams();
+	}
+	else
+	{
+		self ClearAlternateAimParams();
+	}
+}
+player_toggle_cloak_handler(localClientNum, set, newEnt)
+{
+	if ( set )
+	{
+		self thread cloak( localClientNum );
+	}
+	else
+	{
+		self thread uncloak( localClientNum );
+	}
+}
+createZombieEyes(localClientNum)
+{
+	if(isdefined(self._eyeArray))
+	{
+		if(!isdefined(self._eyeArray[localClientNum]))
+		{
+			linkTag = "J_Eyeball_LE";
+			fx_name = "eye_glow";
+			if(IsDefined(level._override_eye_fx))
+			{
+				fx_name = level._override_eye_fx;
+			}
+			self._eyeArray[localClientNum] = PlayFxOnTag( localClientNum, level._effect[fx_name], self, linkTag );
+		}
+	}
+}
+deleteZombieEyes(localClientNum)
+{
+	if(isdefined(self._eyeArray))
+	{
+		if(isdefined(self._eyeArray[localClientNum]))
+		{
+			DeleteFx( localClientNum, self._eyeArray[localClientNum] , true );
+			self._eyeArray[localClientNum] = undefined;
+		}
+	}
+}
+on_player_connect(localClientNum)
+{
+	ForceGameModeMappings( localClientNum, "default" );
+}
+on_player_spawn(localClientNum)
+{
+	ForceGameModeMappings( localClientNum, "default" );
+}
+on_zombie_spawn(localClientNum)
+{
+	self endon("entityshutdown");
+	if(!isdefined(self._eyeArray))
+	{
+		self._eyeArray = [];
+	}
+	wait( 0.05 );
+	if(self haseyes())
+	{
+		self createZombieEyes(localClientNum);
+	}
+	self mapshaderconstant( localClientNum, 0, "scriptVector0", -4.0, -1.0, 0.0, -1.0 );
+}
+zombie_eye_callback(localClientNum, hasEyes)
+{
+	players = GetLocalPlayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		if ( hasEyes )
+		{
+			self createZombieEyes( i );
+		}
+		else
+		{
+			self deleteZombieEyes( i );
+		}
+	}
+}
+init_perk_machines_fx()
+{
+	if ( GetDvar( #"createfx" ) == "on" || GetDvar( #"mutator_noPerks" ) == "1" )
+	{
+		return;
+	}
+	level._effect["sleight_light"] = loadfx( "misc/fx_zombie_cola_on" );
+	level._effect["doubletap_light"] = loadfx( "misc/fx_zombie_cola_dtap_on" );
+	level._effect["divetonuke_light"] = loadfx( "misc/fx_zombie_cola_dtap_on" );
+	level._effect["marathon_light"] = loadfx( "misc/fx_zombie_cola_dtap_on" );
+	level._effect["jugger_light"] = loadfx( "misc/fx_zombie_cola_jugg_on" );
+	level._effect["revive_light"] = loadfx( "misc/fx_zombie_cola_revive_on" );
+	level._effect["additionalprimaryweapon_light"] = loadfx( "misc/fx_zombie_cola_dtap_on" );
+	level thread perk_start_up();
+}
+perk_start_up()
+{
+	level waittill( "power_on" );
+	timer = 0;
+	duration = 0.1;
+	machines = GetStructArray( "perksacola", "targetname" );
+	while( true )
+	{
+		for( i = 0; i < machines.size; i++ )
+		{
+			switch( machines[i].script_sound )
+			{
+				case "mx_jugger_jingle":
+				machines[i] thread vending_machine_flicker_light( "jugger_light", duration );
+				break;
+				case "mx_speed_jingle":
+				machines[i] thread vending_machine_flicker_light( "sleight_light", duration );
+				break;
+				case "mx_doubletap_jingle":
+				machines[i] thread vending_machine_flicker_light( "doubletap_light", duration );
+				break;
+				case "mx_divetonuke_jingle":
+				machines[i] thread vending_machine_flicker_light( "divetonuke_light", duration );
+				break;
+				case "mx_marathon_jingle":
+				machines[i] thread vending_machine_flicker_light( "marathon_light", duration );
+				break;
+				case "mx_revive_jingle":
+				machines[i] thread vending_machine_flicker_light( "revive_light", duration );
+				break;
+				case "mx_additionalprimaryweapon_jingle":
+				machines[i] thread vending_machine_flicker_light( "additionalprimaryweapon_light", duration );
+				break;
+				default:
+				machines[i] thread vending_machine_flicker_light( "jugger_light", duration );
+				break;
+			}
+		}
+		timer += duration;
+		duration += 0.2;
+		if( timer >= 3 )
+		{
+			break;
+		}
+		realwait( duration );
+	}
+}
+vending_machine_flicker_light( fx_light, duration )
+{
+	players = getlocalplayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		self thread play_perk_fx_on_client( i, fx_light, duration );
+	}
+}
+play_perk_fx_on_client( client_num, fx_light, duration )
+{
+	fxObj = spawn( client_num, self.origin +( 0, 0, -50 ), "script_model" );
+	fxobj setmodel( "tag_origin" );
+	playfxontag( client_num, level._effect[fx_light], fxObj, "tag_origin" );
+	realwait( duration );
+	fxobj delete();
+}
+cloak( localClientNum )
+{
+	self thread run_cloak_effect( localClientNum, true, 1500 );
+}
+uncloak( localClientNum )
+{
+	self thread run_cloak_effect( localClientNum, false, 1000 );
+}
+run_cloak_effect( localClientNum, cloak, durationMsec )
+{
+	self endon( "entityshutdown" );
+	begin_time = GetRealTime();
+	while( 1 )
+	{
+		age = GetRealTime() - begin_time;
+		original_t = age / durationMsec;
+		original_t = clamp( original_t, 0.0, 1.0 );
+		adjusted_t = original_t;
+		if ( !cloak )
+		{
+			adjusted_t = 1.0 - adjusted_t ;
+		}
+		cloakMaskCompression = 1.0;
+		cloakAmount = (adjusted_t - 0.5) * 2.0;
+		cloakAmount = clamp( cloakAmount, -1.0, 1.0 );
+		cloakAmount = cloakAmount * cloakMaskCompression;
+		self setshaderconstant( localClientNum, 0, cloakMaskCompression, cloakAmount, 0, 0 );
+		if ( original_t == 1.0 )
+		{
+			break;
+		}
+		realwait(0.05);
+	}
+}
+mark_piece_gibbed( piece_index )
+{
+	if ( !isdefined( self.gibbed_pieces ) )
+	{
+		self.gibbed_pieces = [];
+	}
+	self.gibbed_pieces[self.gibbed_pieces.size] = piece_index;
+}
+has_gibbed_piece( piece_index )
+{
+	if ( !isdefined( self.gibbed_pieces ) )
+	{
+		return false;
+	}
+	for ( i = 0; i < self.gibbed_pieces.size; i++ )
+	{
+		if ( self.gibbed_pieces[i] == piece_index )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+do_headshot_gib_fx()
+{
+	fxTag = "j_neck";
+	fxOrigin = self GetTagOrigin( fxTag );
+	upVec = AnglesToUp( self GetTagAngles( fxTag ) );
+	forwardVec = AnglesToForward( self GetTagAngles( fxTag ) );
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		PlayFX( i, level._effect["headshot"], fxOrigin, forwardVec, upVec );
+		PlayFX( i, level._effect["headshot_nochunks"], fxOrigin, forwardVec, upVec );
+	}
+	wait( 0.3 );
+	if ( IsDefined( self ) )
+	{
+		players = getlocalplayers();
+		for ( i = 0; i < players.size; i++ )
+		{
+			PlayFxOnTag( i, level._effect["bloodspurt"], self, fxTag );
+		}
+	}
+}
+do_gib_fx( tag )
+{
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		PlayFxOnTag( i, level._effect["animscript_gib_fx"], self, tag );
+	}
+	PlaySound( 0, "zmb_death_gibs", self gettagorigin( tag ) );
+}
+do_gib( model, tag )
+{
+	start_pos = self gettagorigin( tag );
+	start_angles = self gettagangles(tag);
+	wait( 0.016 );
+	end_pos = undefined;
+	angles = undefined;
+	if(!IsDefined(self))
+	{
+		end_pos = start_pos + (AnglesToForward(start_angles) * 10);
+		angles = start_angles;
+	}
+	else
+	{
+		end_pos = self gettagorigin( tag );
+		angles = self gettagangles(tag);
+	}
+	if ( IsDefined( self._gib_vel ) )
+	{
+		forward = self._gib_vel;
+		self._gib_vel = undefined;
+	}
+	else
+	{
+		forward = VectorNormalize( end_pos - start_pos );
+		forward *= RandomIntRange( 600, 1000 );
+		forward += (0, 0, RandomIntRange( 400, 700 ));
+	}
+	CreateDynEntAndLaunch( 0, model, end_pos, angles, start_pos, forward, level._effect["animscript_gibtrail_fx"], 1 );
+	if(IsDefined(self))
+	{
+		self do_gib_fx( tag );
+	}
+	else
+	{
+		PlaySound( 0, "zmb_death_gibs", end_pos);
+	}
+}
+on_gib_event( localClientNum, type, locations )
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if( !is_mature() )
+	{
+		return;
+	}
+	if ( !isDefined( self._gib_def ) )
+	{
+		return;
+	}
+	if ( self._gib_def == -1 )
+	{
+		return;
+	}
+	if ( IsDefined( level._gib_overload_func ) )
+	{
+		PrintLn( "type " + type );
+		PrintLn( "loc size " + locations.size );
+		if ( self [[level._gib_overload_func]]( type, locations ) )
+		{
+			return;
+		}
+	}
+	for ( i = 0; i < locations.size; i++ )
+	{
+		if ( IsDefined( self.gibbed ) && level._ZOMBIE_GIB_PIECE_INDEX_HEAD != locations[i] )
+		{
+			continue;
+		}
+		switch( locations[i] )
+		{
+			case 0:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn1 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag1 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn1, level._gibbing_actor_models[self._gib_def].gibSpawnTag1 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn2 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag2 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn2, level._gibbing_actor_models[self._gib_def].gibSpawnTag2 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn3 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag3 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn3, level._gibbing_actor_models[self._gib_def].gibSpawnTag3 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn4 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag4 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn4, level._gibbing_actor_models[self._gib_def].gibSpawnTag4 );
+			}
+			self thread do_headshot_gib_fx();
+			self thread do_gib_fx( "J_SpineLower" );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_HEAD );
+			break;
+			case 1:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn1 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag1 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn1, level._gibbing_actor_models[self._gib_def].gibSpawnTag1 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM );
+			break;
+			case 2:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn2 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag2 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn2, level._gibbing_actor_models[self._gib_def].gibSpawnTag2 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM );
+			break;
+			case 3:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn3 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag3 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn3, level._gibbing_actor_models[self._gib_def].gibSpawnTag3 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG );
+			break;
+			case 4:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn4 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag4 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn4, level._gibbing_actor_models[self._gib_def].gibSpawnTag4 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG );
+			break;
+			case 5:
+			self thread do_headshot_gib_fx();
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_HEAD );
+			break;
+			case 6:
+			self thread do_gib_fx( "J_SpineLower" );
+			break;
+		}
+	}
+	self.gibbed = true;
+}
+zombie_vision_set_apply( str_visionset, int_priority, flt_transition_time, int_clientnum )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	if( !IsDefined( self._zombie_visionset_list ) )
+	{
+		self._zombie_visionset_list = [];
+	}
+	if( !IsDefined( str_visionset ) || !IsDefined( int_priority ) )
+	{
+		return;
+	}
+	if( !IsDefined( flt_transition_time ) )
+	{
+		flt_transition_time = 1;
+	}
+	if( !IsDefined( int_clientnum ) )
+	{
+		if(self IsLocalPlayer())
+		{
+			int_clientnum = self GetLocalClientNumber();
+		}
+		if(!IsDefined(int_clientnum))
+		{
+			return;
+		}
+	}
+	already_in_array = false;
+	if( self._zombie_visionset_list.size != 0 )
+	{
+		for( i = 0; i < self._zombie_visionset_list.size; i++ )
+		{
+			if( IsDefined( self._zombie_visionset_list[i].vision_set ) && self._zombie_visionset_list[i].vision_set == str_visionset )
+			{
+				already_in_array = true;
+				if( self._zombie_visionset_list[i].priority != int_priority )
+				{
+					self._zombie_visionset_list[i].priority = int_priority;
+				}
+				break;
+			}
+		}
+	}
+	if( !already_in_array )
+	{
+		temp_struct = spawnStruct();
+		temp_struct.vision_set = str_visionset;
+		temp_struct.priority = int_priority;
+		self._zombie_visionset_list = add_to_array( self._zombie_visionset_list, temp_struct, false );
+	}
+	vision_to_set = self zombie_highest_vision_set_apply();
+	if( IsDefined( vision_to_set ) )
+	{
+		VisionSetNaked( int_clientnum, vision_to_set, flt_transition_time );
+	}
+	else
+	{
+		VisionSetNaked( int_clientnum, "undefined", flt_transition_time );
+	}
+}
+zombie_vision_set_remove( str_visionset, flt_transition_time, int_clientnum )
+{
+	self endon( "death" );
+	self endon( "disconnect" );
+	if( !IsDefined( str_visionset ) )
+	{
+		return;
+	}
+	if( !IsDefined( flt_transition_time ) )
+	{
+		flt_transition_time = 1;
+	}
+	if( !IsDefined( self._zombie_visionset_list ) )
+	{
+		self._zombie_visionset_list = [];
+	}
+	if( !IsDefined( int_clientnum ) )
+	{
+		if(self IsLocalPlayer())
+		{
+			int_clientnum = self GetLocalClientNumber();
+		}
+		if(!IsDefined(int_clientnum))
+		{
+			return;
+		}
+	}
+	temp_struct = undefined;
+	for( i = 0; i < self._zombie_visionset_list.size; i++ )
+	{
+		if( IsDefined( self._zombie_visionset_list[i].vision_set ) && self._zombie_visionset_list[i].vision_set == str_visionset )
+		{
+			temp_struct = self._zombie_visionset_list[i];
+		}
+	}
+	if( IsDefined( temp_struct ) )
+	{
+		self._zombie_visionset_list = array_remove( self._zombie_visionset_list, temp_struct );
+	}
+	vision_to_set = self zombie_highest_vision_set_apply();
+	if( IsDefined( vision_to_set ) )
+	{
+		VisionSetNaked( int_clientnum, vision_to_set, flt_transition_time );
+	}
+	else
+	{
+		VisionSetNaked( int_clientnum, "undefined", flt_transition_time );
+	}
+}
+zombie_highest_vision_set_apply()
+{
+	if( !IsDefined( self._zombie_visionset_list ) )
+	{
+		return;
+	}
+	highest_score = 0;
+	highest_score_vision = undefined;
+	for( i = 0; i < self._zombie_visionset_list.size; i++ )
+	{
+		if( IsDefined( self._zombie_visionset_list[i].priority ) && self._zombie_visionset_list[i].priority > highest_score )
+		{
+			highest_score = self._zombie_visionset_list[i].priority;
+			highest_score_vision = self._zombie_visionset_list[i].vision_set;
+		}
+	}
+	return highest_score_vision;
+}
+zombie_dive2nuke_visionset( local_client_num, set, newEnt )
+{
+	self endon( "disconnect" );
+	if( local_client_num != 0 )
+	{
+		return;
+	}
+	if( set )
+	{
+		if( !IsDefined( self._zombie_visionset_list ) )
+		{
+			PrintLn( "********************* zombie visionset array is not defined *******************************" );
+		}
+		player = GetLocalPlayers()[ local_client_num ];
+		if ( player GetEntityNumber() != self GetEntityNumber() )
+		{
+			return;
+		}
+		time_to_apply_vision = 0;
+		time_to_remove_vision = 0.5;
+		self thread zombie_vision_set_apply( "zombie_cosmodrome_diveToNuke", 11, time_to_apply_vision, local_client_num );
+		wait( 0.5 );
+		self thread zombie_vision_set_remove( "zombie_cosmodrome_diveToNuke", time_to_remove_vision, local_client_num );
+	}
+}
+sidequest_solo_completed_watcher()
+{
+	level endon( "SQC" );
+	level waittill( "SQS" );
+	SetCollectible( level.zombie_sidequest_solo_collectible );
+}
+sidequest_coop_completed_watcher()
+{
+	level endon( "SQS" );
+	level waittill( "SQC" );
+	SetCollectible( level.zombie_sidequest_solo_collectible );
+	SetCollectible( level.zombie_sidequest_coop_collectible );
+}
+register_sidequest( solo_collectible, coop_collectible )
+{
+	level.zombie_sidequest_solo_collectible = solo_collectible;
+	level.zombie_sidequest_coop_collectible = coop_collectible;
+	level thread sidequest_solo_completed_watcher();
+	level thread sidequest_coop_completed_watcher();
+}
+handle_zombie_risers_water(localClientNum, set, newEnt)
+{
+	self endon("entityshutdown");
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			if(!snd_played)
+			{
+				playsound(0,"zmb_zombie_spawn_water", self.origin);
+				snd_played = 1;
+			}
+			playfx(i,level._effect["rise_burst_water"],self.origin + ( 0,0,randomintrange(5,10) ) );
+			wait(.25);
+			playfx(i,level._effect["rise_billow_water"],self.origin + ( randomintrange(-10,10),randomintrange(-10,10),randomintrange(5,10) ) );
+			self thread rise_dust_fx(i,"water");
+		}
+	}
+}
+handle_zombie_lowg_risers(localClientNum, set, newEnt)
+{
+	self endon("entityshutdown");
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			if(!snd_played)
+			{
+				playsound(0,"zmb_zombie_spawn", self.origin);
+				snd_played = 1;
+			}
+			playfx(i,level._effect["rise_burst_lg"],self.origin + ( 0,0,randomintrange(5,10) ) );
+			wait(.25);
+			playfx(i,level._effect["rise_billow_lg"],self.origin + ( randomintrange(-10,10),randomintrange(-10,10),randomintrange(5,10) ) );
+			self thread rise_dust_fx(i,"lowg");
+		}
+	}
+}
+handle_zombie_risers(localClientNum, set, newEnt)
+{
+	self endon("entityshutdown");
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if(set)
+	{
+		localPlayers = getlocalplayers();
+		snd_played = 0;
+		sound = "zmb_zombie_spawn";
+		burst_fx = level._effect["rise_burst"];
+		billow_fx = level._effect["rise_billow"];
+		type = "dirt";
+		if(isdefined(level.riser_type) && level.riser_type == "snow" )
+		{
+			sound = "zmb_zombie_spawn_snow";
+			burst_fx = level._effect["rise_burst_snow"];
+			billow_fx = level._effect["rise_billow_snow"];
+			type = "snow";
+		}
+		for(i = 0; i < localPlayers.size; i ++)
+		{
+			if(!snd_played)
+			{
+				playsound (0,sound, self.origin);
+				snd_played = 1;
+			}
+			playfx(i,burst_fx,self.origin + ( 0,0,randomintrange(5,10) ) );
+			wait(.25);
+			playfx(i,billow_fx,self.origin + ( randomintrange(-10,10),randomintrange(-10,10),randomintrange(5,10) ) );
+			self thread rise_dust_fx(i,type);
+		}
+	}
+}
+rise_dust_fx(clientnum,type)
+{
+	dust_tag = "J_SpineUpper";
+	self endon("entityshutdown");
+	if(!isDefined(self))
+	{
+		return;
+	}
+	dust_time = 7.5;
+	dust_interval = .1;
+	player = getlocalplayers()[clientnum];
+	effect = level._effect["rise_dust"];
+	switch(type)
+	{
+		case "water":
+		effect = level._effect["rise_dust_water"];
+		break;
+		case "snow":
+		effect = level._effect["rise_dust_snow"];
+		break;
+		case "lowg":
+		effect = level._effect["rise_dust_lg"];
+	}
+	for (t = 0; t < dust_time; t += dust_interval)
+	{
+		if(!isDefined(self))
+		{
+			return;
+		}
+		PlayfxOnTag(clientnum,effect, self, dust_tag);
+		wait dust_interval;
+	}
+}
+

BO1/PC/ZM/clientscripts/_zombiemode_ai_napalm.csc

@@ -0,0 +1,313 @@
+#include clientscripts\_utility;
+init_napalm_zombie()
+{
+	register_clientflag_callback( "actor", level._CF_ACTOR_IS_NAPALM_ZOMBIE, ::napalm_zombie_spawn);
+	register_clientflag_callback( "actor", level._CF_ACTOR_NAPALM_ZOMBIE_EXPLODE, ::napalm_zombie_explode_callback);
+	register_clientflag_callback( "actor", level._CF_ACTOR_NAPALM_ZOMBIE_WET, ::napalm_zombie_wet_callback);
+	level.napalmPlayerWarningRadiusSqr = 400.0;
+	level.napalmPlayerWarningRadiusSqr *= level.napalmPlayerWarningRadiusSqr;
+	napalm_fx();
+}
+napalm_fx()
+{
+	level._effect["napalm_fire_forearm"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_forearm" );
+	level._effect["napalm_fire_torso"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_torso" );
+	level._effect["napalm_distortion"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_heat" );
+	level._effect["napalm_fire_forearm_end"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_torso_end" );
+	level._effect["napalm_fire_torso_end"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_forearm_end" );
+	level._effect["napalm_steam"] = LoadFX( "maps/zombie_temple/fx_ztem_zombie_torso_steam_runner" );
+	level._effect["napalm_feet_steam"] = LoadFX( "maps/zombie_temple/fx_ztem_zombie_torso_steam_runner" );
+}
+napalm_zombie_spawn( client_num, set, newEnt )
+{
+	if(set)
+	{
+		level.napalm_zombie = self;
+		self thread napalm_glow_normal(client_num);
+		self thread _napalm_zombie_RunEffects(client_num);
+		self thread _napalm_zombie_RunSteamEffects(client_num);
+	}
+	else
+	{
+		self notify("stop_fx");
+		self notify("napalm_killed");
+		if(isDefined(self.steam_fx))
+		{
+			self.steam_fx delete();
+		}
+		level.napalm_zombie = undefined;
+	}
+}
+_napalm_zombie_RunSteamEffects(client_num)
+{
+	self endon("napalm_killed");
+	self endon("death");
+	self endon("entityshutdown");
+	while(1)
+	{
+		waterheight = getwaterHeight(self.origin);
+		underWater = waterHeight>self.origin[2];
+		if((isdefined(self.wet) && self.wet) || underWater)
+		{
+			self thread set_footstep_override_for_napalm_zombie(false);
+		}
+		else
+		{
+			self thread set_footstep_override_for_napalm_zombie(true);
+		}
+		if(underWater)
+		{
+			if(!isDefined(self.steam_fx))
+			{
+				effectEnt = Spawn(client_num, self.origin, "script_model");
+				effectEnt SetModel("tag_origin");
+				PlayFXOnTag(client_num, level._effect["napalm_feet_steam"], effectEnt, "tag_origin" );
+				self.steam_fx = effectEnt;
+			}
+			origin = (self.origin[0], self.origin[1], waterHeight);
+			self.steam_fx.origin = origin;
+		}
+		else
+		{
+			if(isDefined(self.steam_fx))
+			{
+				self.steam_fx Delete();
+				self.steam_fx = undefined;
+			}
+		}
+		wait .1;
+	}
+}
+_napalm_zombie_RunEffects(client_num)
+{
+	fx = [];
+	fx["J_Wrist_RI"] = "napalm_fire_forearm";
+	fx["J_Wrist_LE"] = "napalm_fire_forearm";
+	fx["J_SpineLower"] = "napalm_fire_torso";
+	fx["J_Head"] = "napalm_fire_forearm";
+	fx["tag_origin"] = "napalm_distortion";
+	offsets["J_SpineLower"] = (0.0, 10.0, 0.0);
+	watch = [];
+	keys = GetArrayKeys(fx);
+	for ( i = 0; i < keys.size; i++ )
+	{
+		jointName = keys[i];
+		fxName = fx[jointName];
+		offset = offsets[jointName];
+		effectEnt = self _zombie_SetupFXOnJoint(client_num, jointName, fxName, offset);
+		watch[i] = effectEnt;
+	}
+	if( isdefined( watch[0] ) )
+	{
+		watch[0] playloopsound( "evt_napalm_zombie_loop", 2 );
+	}
+	self waittill( "stop_fx" );
+	if( isdefined( watch[0] ) )
+	{
+		watch[0] stoploopsound( .25 );
+	}
+	for ( i = 0; i < watch.size; i++ )
+	{
+		if(isDefined(watch[i]))
+		{
+			watch[i] Delete();
+		}
+	}
+}
+napalm_zombie_explode_callback( client_num, set, newEnt )
+{
+	self thread napalm_glow_explode(client_num);
+	self thread _zombie_RunExplosionWindupEffects(client_num);
+}
+_zombie_RunExplosionWindupEffects(client_num)
+{
+	fx = [];
+	fx["J_Elbow_LE"] = "napalm_fire_forearm_end";
+	fx["J_Elbow_RI"] = "napalm_fire_forearm_end";
+	fx["J_Clavicle_RI"] = "napalm_fire_forearm_end";
+	fx["J_Clavicle_LE"] = "napalm_fire_forearm_end";
+	fx["J_SpineLower"] = "napalm_fire_torso_end";
+	offsets["J_SpineLower"] = (0.0, 10.0, 0.0);
+	watch = [];
+	keys = GetArrayKeys(fx);
+	for ( i = 0; i < keys.size; i++ )
+	{
+		jointName = keys[i];
+		fxName = fx[jointName];
+		offset = offsets[jointName];
+		effectEnt = self _zombie_SetupFXOnJoint(client_num, jointName, fxName, offset);
+		watch[i] = effectEnt;
+	}
+	self waittill( "stop_fx" );
+	for ( i = 0; i < watch.size; i++ )
+	{
+		if(isDefined(watch[i]))
+		{
+			watch[i] Delete();
+		}
+	}
+}
+_napalm_zombie_RunWetEffects(client_num)
+{
+	fx = [];
+	fx["J_SpineLower"] = "napalm_steam";
+	offsets["J_SpineLower"] = (0.0, 10.0, 0.0);
+	watch = [];
+	keys = GetArrayKeys(fx);
+	for ( i = 0; i < keys.size; i++ )
+	{
+		jointName = keys[i];
+		fxName = fx[jointName];
+		offset = offsets[jointName];
+		effectEnt = self _zombie_SetupFXOnJoint(client_num, jointName, fxName, offset);
+		watch[i] = effectEnt;
+	}
+	self waittill( "stop_fx" );
+	for ( i = 0; i < watch.size; i++ )
+	{
+		if(isDefined(watch[i]))
+		{
+			watch[i] Delete();
+		}
+	}
+}
+_zombie_SetupFXOnJoint(client_num, jointName, fxName, offset)
+{
+	origin = self GetTagOrigin(jointName);
+	effectEnt = Spawn(client_num, origin, "script_model");
+	effectEnt SetModel("tag_origin");
+	effectEnt.angles = self GetTagAngles(jointName);
+	if ( !IsDefined(offset) )
+	{
+		offset = (0,0,0);
+	}
+	effectEnt LinkTo(self, jointName, offset);
+	PlayFXOnTag(client_num, level._effect[fxName], effectEnt, "tag_origin" );
+	return effectEnt;
+}
+set_footstep_override_for_napalm_zombie(set)
+{
+	if ( set )
+	{
+		self._footstepOverrideEffect = "napalm_zombie_footstep";
+		self.step_sound = "zmb_napalm_step";
+	}
+	else
+	{
+		self._footstepOverrideEffect = undefined;
+		self.step_sound = "zmb_napalm_step";
+	}
+}
+player_napalm_radius_overlay_fade()
+{
+	self endon("death");
+	self endon("disconnect");
+	self endon("entityshutdown");
+	prevFrac = 0.0;
+	while ( 1 )
+	{
+		frac = 0.0;
+		if( !isdefined( level.napalm_zombie ) || isDefined(level.napalm_zombie.wet) && level.napalm_zombie.wet
+		|| player_can_see_napalm( level.napalm_zombie ) )
+		{
+			frac = 0.0;
+		}
+		else
+		{
+			dist_to_napalm = distancesquared( self.origin, level.napalm_zombie.origin );
+			if ( dist_to_napalm < level.napalmPlayerWarningRadiusSqr )
+			{
+				frac = (level.napalmPlayerWarningRadiusSqr-dist_to_napalm)/level.napalmPlayerWarningRadiusSqr;
+				frac *= 1.1;
+				if ( frac > 1.0 )
+				{
+					frac = 1.0;
+				}
+			}
+		}
+		delta = Clamp(frac - prevFrac, -.1,.1);
+		frac = prevFrac + delta;
+		prevFrac = frac;
+		SetSavedDvar("r_flameScaler",frac);
+		wait(0.1);
+	}
+}
+player_can_see_napalm( ent_napalm )
+{
+	trace = undefined;
+	if( IsDefined( level.napalm_zombie ) )
+	{
+		trace = bullettrace( self GetEye(), level.napalm_zombie.origin, false, self );
+		if( IsDefined( trace ) && trace["fraction"] < 0.85 )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+napalm_zombie_wet_callback( client_num, set, newEnt )
+{
+	if(set)
+	{
+		self napalm_start_wet_fx(client_num);
+	}
+	else
+	{
+		self napalm_end_wet_fx(client_num);
+	}
+}
+napalm_start_wet_fx(client_num)
+{
+	self notify( "stop_fx" );
+	self thread _napalm_zombie_RunWetEffects(client_num);
+	self.wet = true;
+	self thread napalm_glow_wet(client_num);
+}
+napalm_end_wet_fx(client_num)
+{
+	self notify( "stop_fx" );
+	self thread _napalm_zombie_RunEffects(client_num);
+	self.wet = false;
+	self thread napalm_glow_normal(client_num);
+}
+napalm_set_glow(client_num, glowVal)
+{
+	self.glow_val = glowVal;
+	self setshaderconstant( client_num, 0, 0, 0, 0, glowVal );
+}
+napalm_glow_normal(client_num)
+{
+	self thread napalm_glow_lerp(client_num, 2.5);
+}
+napalm_glow_explode(client_num)
+{
+	self thread napalm_glow_lerp(client_num, 10.0);
+}
+napalm_glow_wet(client_num)
+{
+	self thread napalm_glow_lerp(client_num, 0.5);
+}
+napalm_glow_lerp(client_num, glowVal)
+{
+	self notify("glow_lerp");
+	self endon("glow_lerp");
+	self endon("death");
+	self endon("entityshutdown");
+	startVal = self.glow_val;
+	endVal = glowVal;
+	if(isDefined(startVal))
+	{
+		delta = glowVal - self.glow_val;
+		lerpTime = 1000;
+		startTime = GetRealTime();
+		while(startTime + lerpTime > GetRealTime())
+		{
+			s = (GetRealTime() - startTime) / lerpTime;
+			newVal = startVal + ((endVal - startVal) * s);
+			self napalm_set_glow(client_num, newVal);
+			realwait(.05);
+		}
+	}
+	self napalm_set_glow(client_num, endVal);
+}
+

BO1/PC/ZM/clientscripts/_zombiemode_weap_black_hole_bomb.csc

@@ -0,0 +1,262 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_music;
+#include clientscripts\_zombiemode_weapons;
+#include clientscripts\_zombiemode;
+init()
+{
+	if ( GetDvar( #"createfx" ) == "on" )
+	{
+		return;
+	}
+	if ( !clientscripts\_zombiemode_weapons::is_weapon_included( "zombie_black_hole_bomb" ) )
+	{
+		return;
+	}
+	level._effect[ "black_hole_bomb_portal" ] = LoadFX( "maps/zombie/fx_zmb_blackhole_looping" );
+	level._effect[ "black_hole_bomb_event_horizon" ] = LoadFX( "maps/zombie/fx_zmb_blackhole_implode" );
+	level._effect[ "black_hole_bomb_marker_flare" ] = LoadFX( "maps/zombie/fx_zmb_blackhole_flare_marker" );
+	level._effect[ "black_hole_bomb_zombie_pull" ] = LoadFX( "maps/zombie/fx_blackhole_zombie_breakup" );
+	level._current_black_hole_bombs = [];
+	level._visionset_black_hole_bomb = "zombie_black_hole";
+	level._visionset_black_hole_bomb_transition_time_in = 2.0;
+	level._visionset_black_hole_bomb_transition_time_out = 1.0;
+	level._visionset_black_hole_bomb_priority = 10;
+	level._SCRIPTMOVER_CLIENT_FLAG_BLACKHOLE = 10;
+	register_clientflag_callback( "scriptmover", level._SCRIPTMOVER_CLIENT_FLAG_BLACKHOLE, ::black_hole_deployed );
+	level._ACTOR_CLIENT_FLAG_BLACKHOLE = 10;
+	register_clientflag_callback( "actor", level._ACTOR_CLIENT_FLAG_BLACKHOLE, ::black_hole_zombie_being_pulled );
+	OnPlayerConnect_Callback( ::black_hole_on_player_connect );
+	OnPlayerSpawned_Callback( ::black_hole_on_player_spawned );
+	level thread black_hole_visionset_think();
+}
+black_hole_on_player_connect( int_local_client_num )
+{
+	self endon( "disconnect" );
+	while ( !ClientHasSnapshot( int_local_client_num ) )
+	{
+		wait 0.05;
+	}
+	if( int_local_client_num != 0 )
+	{
+		return;
+	}
+	players = GetLocalPlayers();
+	for( i = 0 ; i < players.size; i++ )
+	{
+		players[i]._curr_black_hole_dist = 100000*100000;
+		players[i]._last_black_hole_dist = 100000*100000;
+	}
+}
+black_hole_on_player_spawned( int_local_client_num )
+{
+	self endon( "disconnect" );
+	while ( !self hasdobj( int_local_client_num ) )
+	{
+		wait( 0.05 );
+	}
+	if( int_local_client_num != 0 )
+	{
+		return;
+	}
+	players = GetLocalPlayers();
+	for( i = 0 ; i < players.size; i++ )
+	{
+		if( !IsDefined( players[i]._curr_black_hole_dist ) )
+		{
+			players[i]._curr_black_hole_dist = 100000*100000;
+		}
+		else if( !IsDefined( players[i]._last_black_hole_dist ) )
+		{
+			players[i]._last_black_hole_dist = 100000*100000;
+		}
+	}
+}
+black_hole_deployed( local_client_num, int_set, ent_new )
+{
+	if( local_client_num != 0 )
+	{
+		return;
+	}
+	players = GetLocalPlayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		level thread black_hole_fx_start( i, self );
+		level thread black_hole_activated( self, i );
+	}
+}
+black_hole_fx_start( local_client_num, ent_bomb )
+{
+	bomb_fx_spot = Spawn( local_client_num, ent_bomb.origin, "script_model" );
+	bomb_fx_spot SetModel( "tag_origin" );
+	PlayFXOnTag( local_client_num, level._effect[ "black_hole_bomb_portal" ], bomb_fx_spot, "tag_origin" );
+	PlayFXOnTag( local_client_num, level._effect[ "black_hole_bomb_marker_flare" ], bomb_fx_spot, "tag_origin" );
+	ent_bomb waittill( "entityshutdown" );
+	event_horizon_spot = Spawn( local_client_num, bomb_fx_spot.origin, "script_model" );
+	event_horizon_spot SetModel( "tag_origin" );
+	bomb_fx_spot Delete();
+	PlayFXOnTag( local_client_num, level._effect[ "black_hole_bomb_event_horizon" ], event_horizon_spot, "tag_origin" );
+	wait( 0.2 );
+	event_horizon_spot Delete();
+}
+black_hole_visionset_switch( str_switch, flt_transition_time, int_local_client_num )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	if( !IsDefined( flt_transition_time ) )
+	{
+		flt_transition_time = 2.0;
+	}
+	if( self IsSpectating() )
+	{
+		return;
+	}
+	switch( str_switch )
+	{
+		case "inside_bh":
+		self zombie_vision_set_apply( level._visionset_black_hole_bomb, level._visionset_black_hole_bomb_priority, level._visionset_black_hole_bomb_transition_time_in, int_local_client_num );
+		break;
+		case "outside_bh":
+		self zombie_vision_set_remove( level._visionset_black_hole_bomb, level._visionset_black_hole_bomb_transition_time_in, int_local_client_num );
+		break;
+		default:
+		self zombie_vision_set_remove( undefined, level._visionset_black_hole_bomb_transition_time_out, int_local_client_num );
+		break;
+	}
+}
+black_hole_visionset_think()
+{
+	flt_black_hole_vision_transition_time = 0;
+	min_black_hole_dist = 512*512;
+	self._visionset_think_running = 1;
+	temp_array = [];
+	while( IsDefined( level._current_black_hole_bombs ) )
+	{
+		players = GetLocalPlayers();
+		for( i = 0; i < players.size; i++ )
+		{
+			players[i]._curr_black_hole_dist = 100000*100000;
+		}
+		self._curr_black_hole_dist = 100000*100000;
+		if( level._current_black_hole_bombs.size == 0 )
+		{
+			players = GetLocalPlayers();
+			for( i = 0; i < players.size; i++ )
+			{
+				players[i] black_hole_visionset_switch( "default", 2.0, i );
+			}
+		}
+		else
+		{
+			players = GetLocalPlayers();
+			for( i = 0; i < players.size; i++ )
+			{
+				struct_closest_black_hole = players[i] get_closest_black_hole();
+				players[i] black_hole_vision_set( min_black_hole_dist, flt_black_hole_vision_transition_time, struct_closest_black_hole, i );
+				players[i]._last_black_hole_dist = players[i]._curr_black_hole_dist;
+			}
+		}
+		temp_array = level._current_black_hole_bombs;
+		for( i = 0; i < temp_array.size; i++ )
+		{
+			if( IsDefined( temp_array[i]._black_hole_active ) && temp_array[i]._black_hole_active == 0 )
+			{
+				level._current_black_hole_bombs = array_remove( level._current_black_hole_bombs, temp_array[i] );
+			}
+		}
+		wait( 0.1 );
+		temp_array = [];
+	}
+}
+get_closest_black_hole()
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	struct_closest_black_hole = undefined;
+	for( i = 0; i < level._current_black_hole_bombs.size; i++ )
+	{
+		curr_dist = DistanceSquared( level._current_black_hole_bombs[i].origin, self.origin );
+		if( curr_dist < self._curr_black_hole_dist )
+		{
+			self._curr_black_hole_dist = curr_dist;
+			struct_closest_black_hole = level._current_black_hole_bombs[i];
+		}
+	}
+	return struct_closest_black_hole;
+}
+black_hole_vision_set( min_black_hole_dist, flt_transition_time, struct_closest_black_hole, int_local_client_num )
+{
+	self endon( "disconnect" );
+	self endon( "death" );
+	set_dist = self._curr_black_hole_dist;
+	if( set_dist < min_black_hole_dist )
+	{
+		trace = bullettrace( self GetEye(), struct_closest_black_hole.origin, false, self );
+		if( trace["fraction"] > 0.85 && struct_closest_black_hole._black_hole_active == 1 )
+		{
+			self black_hole_visionset_switch( "inside_bh", flt_transition_time, int_local_client_num );
+		}
+		else
+		{
+			self black_hole_visionset_switch( "outside_bh", flt_transition_time, int_local_client_num );
+		}
+	}
+	else if( set_dist > min_black_hole_dist )
+	{
+		self black_hole_visionset_switch( "outside_bh", flt_transition_time, int_local_client_num );
+	}
+}
+black_hole_activated( ent_model, int_local_client_num )
+{
+	new_black_hole_struct = SpawnStruct();
+	new_black_hole_struct.origin = ent_model.origin;
+	new_black_hole_struct._black_hole_active = 1;
+	level._current_black_hole_bombs = add_to_array( level._cosmodrome_black_hole_bombs, new_black_hole_struct );
+	ent_model waittill( "entityshutdown" );
+	new_black_hole_struct._black_hole_active = 0;
+	wait( 0.2 );
+}
+black_hole_zombie_being_pulled( local_client_num, int_set, actor_new )
+{
+	self endon( "death" );
+	self endon( "entityshutdown" );
+	if( local_client_num != 0 )
+	{
+		return;
+	}
+	if( int_set )
+	{
+		self._bhb_pulled_in_fx = Spawn( local_client_num, self.origin, "script_model" );
+		self._bhb_pulled_in_fx.angles = self.angles;
+		self._bhb_pulled_in_fx LinkTo( self, "tag_origin" );
+		self._bhb_pulled_in_fx SetModel( "tag_origin" );
+		level thread black_hole_bomb_pulled_in_fx_clean( self, self._bhb_pulled_in_fx );
+		players = GetLocalPlayers();
+		for( i = 0; i < players.size; i++ )
+		{
+			PlayFXOnTag( i, level._effect[ "black_hole_bomb_zombie_pull" ], self._bhb_pulled_in_fx, "tag_origin" );
+		}
+	}
+	else
+	{
+		if( IsDefined( self._bhb_pulled_in_fx ) )
+		{
+			self._bhb_pulled_in_fx notify( "no_clean_up_needed" );
+			self._bhb_pulled_in_fx Unlink();
+			self._bhb_pulled_in_fx Delete();
+		}
+	}
+}
+black_hole_bomb_pulled_in_fx_clean( ent_zombie, ent_fx_origin )
+{
+	ent_fx_origin endon( "no_clean_up_needed" );
+	if( !IsDefined( ent_zombie ) )
+	{
+		return;
+	}
+	ent_zombie waittill( "entityshutdown" );
+	if( IsDefined( ent_fx_origin ) )
+	{
+		ent_fx_origin Delete();
+	}
+}

BO1/PC/ZM/clientscripts/_zombiemode_weap_freezegun.csc

@@ -0,0 +1,336 @@
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+init()
+{
+	if ( GetDvar( #"createfx" ) == "on" )
+	{
+		return;
+	}
+	if ( !clientscripts\_zombiemode_weapons::is_weapon_included( "freezegun_zm" ) )
+	{
+		return;
+	}
+	level._ZOMBIE_ACTOR_FLAG_FREEZEGUN_EXTREMITY_DAMAGE_FX = 15;
+	register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_FLAG_FREEZEGUN_EXTREMITY_DAMAGE_FX, ::freezegun_extremity_damage_fx );
+	level._ZOMBIE_ACTOR_FLAG_FREEZEGUN_TORSO_DAMAGE_FX = 14;
+	register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_FLAG_FREEZEGUN_TORSO_DAMAGE_FX, ::freezegun_torso_damage_fx );
+	level._gib_overload_func = clientscripts\_zombiemode_weap_freezegun::freezegun_gib_override;
+	level._effect[ "freezegun_shatter" ] = LoadFX( "weapon/freeze_gun/fx_freezegun_shatter" );
+	level._effect[ "freezegun_crumple" ] = LoadFX( "weapon/freeze_gun/fx_freezegun_crumple" );
+	level._effect[ "freezegun_damage_torso" ] = LoadFX( "maps/zombie/fx_zombie_freeze_torso" );
+	level._effect[ "freezegun_damage_sm" ] = LoadFX( "maps/zombie/fx_zombie_freeze_md" );
+	level._effect[ "freezegun_shatter_upgraded" ] = LoadFX( "weapon/freeze_gun/fx_exp_freezegun_impact" );
+	level._effect[ "freezegun_crumple_upgraded" ] = LoadFX( "weapon/freeze_gun/fx_exp_freezegun_impact" );
+	level._effect[ "freezegun_shatter_gib_fx" ] = LoadFX( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect[ "freezegun_shatter_gibtrail_fx" ]	= LoadFX( "weapon/freeze_gun/fx_trail_freezegun_blood_streak" );
+	level._effect[ "freezegun_crumple_gib_fx" ] = LoadFX( "system_elements/fx_null" );
+	level._effect[ "freezegun_crumple_gibtrail_fx" ]	= LoadFX( "system_elements/fx_null" );
+	level thread player_init();
+}
+player_init()
+{
+	waitforclient( 0 );
+	players = GetLocalPlayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		player = players[i];
+	}
+}
+freezegun_get_gibfx( shatter )
+{
+	if ( shatter )
+	{
+		return level._effect[ "freezegun_shatter_gib_fx" ];
+	}
+	else
+	{
+		return level._effect[ "freezegun_crumple_gib_fx" ];
+	}
+}
+freezegun_get_gibtrailfx( shatter )
+{
+	if ( shatter )
+	{
+		return level._effect[ "freezegun_shatter_gibtrail_fx" ];
+	}
+	else
+	{
+		return level._effect[ "freezegun_crumple_gibtrail_fx" ];
+	}
+}
+freezegun_get_gibsound( shatter )
+{
+	if ( shatter )
+	{
+		return "zmb_death_gibs";
+	}
+	else
+	{
+		return "zmb_death_gibs";
+	}
+}
+freezegun_get_gibforce( tag, force_from_torso, shatter )
+{
+	if ( shatter )
+	{
+		start_pos = self.origin;
+		if ( force_from_torso )
+		{
+			start_pos = self gettagorigin( "J_SpineLower" );
+		}
+		forward = VectorNormalize( self gettagorigin( tag ) - start_pos );
+		forward *= RandomIntRange( 600, 1000 );
+		forward += (0, 0, RandomIntRange( 400, 700 ));
+		return forward;
+	}
+	else
+	{
+		return (0, 0, 0);
+	}
+}
+freezegun_get_shatter_effect( upgraded )
+{
+	if ( upgraded )
+	{
+		return level._effect[ "freezegun_shatter_upgraded" ];
+	}
+	else
+	{
+		return level._effect[ "freezegun_shatter" ];
+	}
+}
+freezegun_get_crumple_effect( upgraded )
+{
+	if ( upgraded )
+	{
+		return level._effect[ "freezegun_crumple_upgraded" ];
+	}
+	else
+	{
+		return level._effect[ "freezegun_crumple" ];
+	}
+}
+freezegun_end_extremity_damage_fx( localclientnum, key )
+{
+	deletefx( localclientnum, self.freezegun_extremity_damage_fx_handles[localclientnum][key], false );
+}
+freezegun_end_all_extremity_damage_fx( localclientnum )
+{
+	keys = getArrayKeys( self.freezegun_extremity_damage_fx_handles[localclientnum] );
+	for ( i = 0; i < keys.size; i++ )
+	{
+		freezegun_end_extremity_damage_fx( localclientnum, keys[i] );
+	}
+}
+freezegun_end_extremity_damage_fx_for_all_localclients( key )
+{
+	players = GetLocalPlayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		freezegun_end_extremity_damage_fx( i, key );
+	}
+}
+freezegun_play_extremity_damage_fx( localclientnum, fx, key, tag )
+{
+	self.freezegun_extremity_damage_fx_handles[localclientnum][key] = PlayFxOnTag( localclientnum, fx, self, tag );
+}
+freezegun_play_all_extremity_damage_fx( localclientnum )
+{
+	if ( !IsDefined( self.freezegun_extremity_damage_fx_handles ) )
+	{
+		self.freezegun_extremity_damage_fx_handles = [];
+	}
+	if ( IsDefined( self.freezegun_extremity_damage_fx_handles[localclientnum] ) )
+	{
+		return;
+	}
+	self.freezegun_extremity_damage_fx_handles[localclientnum] = [];
+	if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM ) )
+	{
+		freezegun_play_extremity_damage_fx( localclientnum, level._effect[ "freezegun_damage_sm" ], "right_arm", "J_Elbow_RI" );
+	}
+	if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM ) )
+	{
+		freezegun_play_extremity_damage_fx( localclientnum, level._effect[ "freezegun_damage_sm" ], "left_arm", "J_Elbow_LE" );
+	}
+	if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG ) )
+	{
+		freezegun_play_extremity_damage_fx( localclientnum, level._effect[ "freezegun_damage_sm" ], "right_leg", "J_Knee_RI" );
+	}
+	if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG ) )
+	{
+		freezegun_play_extremity_damage_fx( localclientnum, level._effect[ "freezegun_damage_sm" ], "left_leg", "J_Knee_LE" );
+	}
+}
+freezegun_extremity_damage_fx( localClientNum, set, newEnt )
+{
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		if ( set )
+		{
+			self thread freezegun_play_all_extremity_damage_fx( i );
+		}
+		else
+		{
+			self thread freezegun_end_all_extremity_damage_fx( i );
+		}
+	}
+}
+freezegun_end_all_torso_damage_fx( localclientnum )
+{
+	deletefx( localclientnum, self.freezegun_damage_torso_fx[localclientnum], true );
+}
+freezegun_play_all_torso_damage_fx( localclientnum )
+{
+	if ( !IsDefined( self.freezegun_damage_torso_fx ) )
+	{
+		self.freezegun_damage_torso_fx = [];
+	}
+	if ( IsDefined( self.freezegun_damage_torso_fx[localclientnum] ) )
+	{
+		return;
+	}
+	self.freezegun_damage_torso_fx[localclientnum] = PlayFxOnTag( localclientnum, level._effect[ "freezegun_damage_torso" ], self, "J_SpineLower" );
+}
+freezegun_torso_damage_fx( localClientNum, set, newEnt )
+{
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		if ( set )
+		{
+			self thread freezegun_play_all_torso_damage_fx( i );
+		}
+		else
+		{
+			self thread freezegun_end_all_torso_damage_fx( i );
+		}
+	}
+}
+freezegun_do_gib_fx( tag, shatter )
+{
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		PlayFxOnTag( i, freezegun_get_gibtrailfx( shatter ), self, tag );
+	}
+}
+freezegun_do_gib( model, tag, force_from_torso, shatter )
+{
+	if ( shatter && !force_from_torso )
+	{
+		tag_pos = self.origin;
+		tag_angles = (0, 0, 1);
+	}
+	else
+	{
+		tag_pos = self gettagorigin( tag );
+		tag_angles = self gettagangles( tag );
+	}
+	CreateDynEntAndLaunch( 0, model, tag_pos, tag_angles, tag_pos, self freezegun_get_gibforce( tag, force_from_torso, shatter ), freezegun_get_gibtrailfx( shatter ), 1 );
+	self freezegun_do_gib_fx( tag, shatter );
+}
+freezegun_gib_override( type, locations )
+{
+	if ( "freeze" != type && "up" != type )
+	{
+		if ( IsDefined( self.freezegun_damage_fx_handles ) )
+		{
+			for ( i = 0; i < locations.size; i++ )
+			{
+				switch( locations[i] )
+				{
+					case 0:
+					players = getlocalplayers();
+					for ( i = 0; i < players.size; i++ )
+					{
+						self freezegun_end_all_extremity_damage_fx( i );
+					}
+					break;
+					case 1:
+					freezegun_end_extremity_damage_fx_for_all_localclients( "right_arm" );
+					break;
+					case 2:
+					freezegun_end_extremity_damage_fx_for_all_localclients( "left_arm" );
+					break;
+					case 3:
+					freezegun_end_extremity_damage_fx_for_all_localclients( "right_leg" );
+					break;
+					case 4:
+					freezegun_end_extremity_damage_fx_for_all_localclients( "left_leg" );
+					break;
+					case 6:
+					freezegun_end_extremity_damage_fx_for_all_localclients( "left_arm" );
+					break;
+				}
+			}
+		}
+		return false;
+	}
+	upgraded = false;
+	for ( i = 0; i < locations.size; i++ )
+	{
+		switch( locations[i] )
+		{
+			case 7:
+			upgraded = true;
+			break;
+		}
+	}
+	shatter = false;
+	explosion_effect = freezegun_get_crumple_effect( upgraded );
+	alias = "wpn_freezegun_collapse_zombie";
+	if ( "up" == type )
+	{
+		shatter = true;
+		explosion_effect = freezegun_get_shatter_effect( upgraded );
+		alias = "wpn_freezegun_shatter_zombie";
+	}
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		self clientscripts\_zombiemode::deleteZombieEyes( i );
+		self freezegun_end_all_extremity_damage_fx( i );
+		self freezegun_end_all_torso_damage_fx( i );
+		PlayFX( i, explosion_effect, self.origin );
+		PlaySound( 0, alias, self.origin );
+	}
+	for ( i = 0; i < locations.size; i++ )
+	{
+		switch( locations[i] )
+		{
+			case 0:
+			if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM ) &&
+			IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn1 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag1 ) )
+			{
+				self thread freezegun_do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn1, level._gibbing_actor_models[self._gib_def].gibSpawnTag1, true, shatter );
+			}
+			if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM ) &&
+			IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn2 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag2 ) )
+			{
+				self thread freezegun_do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn2, level._gibbing_actor_models[self._gib_def].gibSpawnTag2, true, shatter );
+			}
+			if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG ) &&
+			IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn3 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag3 ) )
+			{
+				self thread freezegun_do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn3, level._gibbing_actor_models[self._gib_def].gibSpawnTag3, false, shatter );
+			}
+			if ( !self clientscripts\_zombiemode::has_gibbed_piece( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG ) &&
+			IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn4 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag4 ) )
+			{
+				self thread freezegun_do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn4, level._gibbing_actor_models[self._gib_def].gibSpawnTag4, false, shatter );
+			}
+			self thread freezegun_do_gib_fx( "J_SpineLower", shatter );
+			self clientscripts\_zombiemode::mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM );
+			self clientscripts\_zombiemode::mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM );
+			self clientscripts\_zombiemode::mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG );
+			self clientscripts\_zombiemode::mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG );
+			self clientscripts\_zombiemode::mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_HEAD );
+			break;
+		}
+	}
+	self.gibbed = true;
+	return true;
+}
+

BO1/PC/ZM/clientscripts/_zombiemode_weap_humangun.csc

@@ -0,0 +1,285 @@
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_zombiemode;
+init()
+{
+	if ( GetDvar( #"createfx" ) == "on" )
+	{
+		return;
+	}
+	if ( !clientscripts\_zombiemode_weapons::is_weapon_included( "humangun_zm" ) )
+	{
+		return;
+	}
+	level._ZOMBIE_PLAYER_FLAG_HUMANGUN_HIT_RESPONSE = 11;
+	register_clientflag_callback( "player", level._ZOMBIE_PLAYER_FLAG_HUMANGUN_HIT_RESPONSE, ::humangun_player_hit_response );
+	level._ZOMBIE_PLAYER_FLAG_HUMANGUN_UPGRADED_HIT_RESPONSE = 10;
+	register_clientflag_callback( "player", level._ZOMBIE_PLAYER_FLAG_HUMANGUN_UPGRADED_HIT_RESPONSE, ::humangun_upgraded_player_hit_response );
+	level._ZOMBIE_ACTOR_FLAG_HUMANGUN_HIT_RESPONSE = 12;
+	register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_FLAG_HUMANGUN_HIT_RESPONSE, ::humangun_zombie_hit_response );
+	level._ZOMBIE_ACTOR_FLAG_HUMANGUN_UPGRADED_HIT_RESPONSE = 11;
+	register_clientflag_callback( "actor", level._ZOMBIE_ACTOR_FLAG_HUMANGUN_UPGRADED_HIT_RESPONSE, ::humangun_upgraded_zombie_hit_response );
+	level._humangun_player_hit_visionset = "zombie_humangun_player_hit";
+	level._humangun_player_hit_visionset_priority = 8;
+	level._humangun_upgraded_player_hit_visionset = "zombie_humangun_upgraded_player_hit";
+	level._humangun_upgraded_player_hit_visionset_priority = 9;
+	level._humangun_visionset_transition_time = 0.3;
+	level._effect["humangun_viewmodel_reload"] = LoadFX( "weapon/human_gun/fx_hgun_reload" );
+	level._effect["humangun_viewmodel_reload_upgraded"]	= LoadFX( "weapon/human_gun/fx_hgun_reload_ug" );
+	level._effect["humangun_glow_neck"] = LoadFX( "weapon/human_gun/fx_hgun_1st_hit_glow_zombie" );
+	level._effect["humangun_glow_neck_upgraded"] = LoadFX( "weapon/human_gun/fx_hgun_1st_hit_glow_zombie_ug" );
+	level._effect["humangun_glow_neck_critical"] = LoadFX( "weapon/human_gun/fx_hgun_timer_glow_zombie_ug" );
+	level._effect["humangun_glow_spine_upgraded"] = LoadFX( "weapon/human_gun/fx_hgun_2nd_hit_glow_zombie_ug" );
+	level._effect["humangun_explosion"] = LoadFX( "weapon/human_gun/fx_hgun_explosion_ug" );
+	level._effect["humangun_explosion_death_mist"] = loadfx( "maps/zombie/fx_zmb_coast_jackal_death" );
+	level thread player_init();
+	level thread humangun_notetrack_think();
+}
+player_init()
+{
+	waitforclient( 0 );
+	level.humangun_play_sfx = [];
+	players = GetLocalPlayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		player = players[i];
+		level.humangun_play_sfx[i] = false;
+		level.humangun_sfx_is_playing[i] = false;
+		player thread humangun_sfx( i );
+	}
+}
+humangun_sfx( localclientnum )
+{
+	self endon( "disconnect" );
+	for( ;; )
+	{
+		realwait( 0.1 );
+		currentweapon = GetCurrentWeapon( localclientnum );
+		if ( !level.humangun_play_sfx[localclientnum] || IsThrowingGrenade( localclientnum ) || IsMeleeing( localclientnum ) || IsOnTurret( localclientnum ) || (currentweapon != "humangun_zm" && currentweapon != "humangun_upgraded_zm") )
+		{
+			humangun_sfx_off( localclientnum );
+			continue;
+		}
+		humangun_sfx_on( localclientnum );
+	}
+}
+humangun_sfx_off( localclientnum )
+{
+	if ( level.humangun_sfx_is_playing[localclientnum] )
+	{
+		level thread deactivate_humangun_loop();
+		level.humangun_sfx_is_playing[localclientnum] = false;
+	}
+}
+humangun_sfx_on( localclientnum )
+{
+	if ( !level.humangun_sfx_is_playing[localclientnum] )
+	{
+		level thread activate_humangun_loop();
+		level.humangun_sfx_is_playing[localclientnum] = true;
+	}
+}
+humangun_get_eject_viewmodel_effect( upgraded )
+{
+	if ( upgraded )
+	{
+		return level._effect["humangun_viewmodel_reload_upgraded"];
+	}
+	else
+	{
+		return level._effect["humangun_viewmodel_reload"];
+	}
+}
+humangun_notetrack_think()
+{
+	level.humangun_sound_ent = spawn( 0, (0,0,0), "script_origin" );
+	for ( ;; )
+	{
+		level waittill( "notetrack", localclientnum, note );
+		currentweapon = GetCurrentWeapon( localclientnum );
+		switch( note )
+		{
+			case "audio_deactivate_humangun_loop":
+			level.humangun_play_sfx[localclientnum] = false;
+			break;
+			case "audio_activate_humangun_loop":
+			level.humangun_play_sfx[localclientnum] = true;
+			break;
+			case "eject_fx":
+			PlayViewmodelFx( localclientnum, humangun_get_eject_viewmodel_effect( currentweapon == "humangun_upgraded_zm" ), "tag_eject_fx" );
+			break;
+		}
+	}
+}
+humangun_create_hit_response_fx( localClientNum, tag, effect )
+{
+	if ( !isdefined( self._humangun_hit_response_fx[localClientNum][tag] ) )
+	{
+		self._humangun_hit_response_fx[localClientNum][tag] = PlayFxOnTag( localClientNum, effect, self, tag );
+	}
+}
+humangun_delete_hit_response_fx( localClientNum, tag )
+{
+	if ( isdefined( self._humangun_hit_response_fx[localClientNum][tag] ) )
+	{
+		DeleteFx( localClientNum, self._humangun_hit_response_fx[localClientNum][tag], false );
+		self._humangun_hit_response_fx[localClientNum][tag] = undefined;
+	}
+}
+humangun_zombie_hit_response_internal( localClientNum, set, newEnt, upgraded, zombie )
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if ( !isdefined( self._humangun_hit_response_fx ) )
+	{
+		self._humangun_hit_response_fx = [];
+	}
+	players = GetLocalPlayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		if(!zombie && players[i] IsSpectating())
+		{
+			continue;
+		}
+		if ( !isdefined( self._humangun_hit_response_fx[i] ) )
+		{
+			self._humangun_hit_response_fx[i] = [];
+		}
+		self humangun_delete_hit_response_fx( i, "j_neck" );
+		self humangun_delete_hit_response_fx( i, "J_SpineLower" );
+		if ( set )
+		{
+			if ( zombie )
+			{
+				self clientscripts\_zombiemode::deleteZombieEyes( i );
+			}
+			if ( !upgraded )
+			{
+				self humangun_create_hit_response_fx( i, "j_neck", level._effect["humangun_glow_neck"] );
+			}
+			else
+			{
+				self humangun_create_hit_response_fx( i, "j_neck", level._effect["humangun_glow_neck_upgraded"] );
+				self humangun_create_hit_response_fx( i, "J_SpineLower", level._effect["humangun_glow_spine_upgraded"] );
+			}
+		}
+	}
+}
+humangun_player_hit_response( localClientNum, set, newEnt )
+{
+	self thread humangun_player_visionset( localClientNum, set, newEnt, false );
+	self humangun_zombie_hit_response_internal( localClientNum, set, newEnt, false, false );
+}
+humangun_upgraded_player_hit_response( localClientNum, set, newEnt )
+{
+	self thread humangun_player_visionset( localClientNum, set, newEnt, true );
+	self humangun_zombie_hit_response_internal( localClientNum, set, newEnt, true, false );
+}
+humangun_zombie_hit_response( localClientNum, set, newEnt )
+{
+	if ( isdefined( self.humangun_zombie_hit_response ) )
+	{
+		self [[ self.humangun_zombie_hit_response ]]( localClientNum, set, newEnt, false );
+		return;
+	}
+	if ( isdefined( self.humangun_zombie_1st_hit_was_upgraded ) && self.humangun_zombie_1st_hit_was_upgraded )
+	{
+		if ( localClientNum != 0 )
+		{
+			return;
+		}
+		if ( set )
+		{
+			players = GetLocalPlayers();
+			for ( i = 0; i < players.size; i++ )
+			{
+				self humangun_delete_hit_response_fx( i, "j_neck" );
+				self humangun_create_hit_response_fx( i, "j_neck", level._effect["humangun_glow_neck_critical"] );
+			}
+		}
+		else
+		{
+			self humangun_zombie_hit_response_internal( localClientNum, set, newEnt, false, true );
+			tag_pos = self gettagorigin( "J_SpineLower" );
+			players = GetLocalPlayers();
+			for ( i = 0; i < players.size; i++ )
+			{
+				playfx( i, level._effect["humangun_explosion"], tag_pos );
+				playfx( i, level._effect["humangun_explosion_death_mist"], tag_pos );
+			}
+		}
+	}
+	else
+	{
+		self humangun_zombie_hit_response_internal( localClientNum, set, newEnt, false, true );
+	}
+}
+humangun_upgraded_zombie_hit_response( localClientNum, set, newEnt )
+{
+	if ( isdefined( self.humangun_zombie_hit_response ) )
+	{
+		self [[ self.humangun_zombie_hit_response ]]( localClientNum, set, newEnt, true );
+		return;
+	}
+	if ( set )
+	{
+		self.humangun_zombie_1st_hit_was_upgraded = true;
+	}
+	self humangun_zombie_hit_response_internal( localClientNum, set, newEnt, true, true );
+}
+humangun_player_visionset( int_local_client, set, ent_new, bool_upgraded )
+{
+	self endon( "disconnect" );
+	if(self IsSpectating())
+	{
+		return;
+	}
+	if(IsDefined(ent_new) && ent_new)
+	{
+		return;
+	}
+	player = GetLocalPlayers()[ int_local_client ];
+	if( player GetEntityNumber() != self GetEntityNumber() )
+	{
+		return;
+	}
+	if( set )
+	{
+		if( bool_upgraded )
+		{
+			self thread zombie_vision_set_apply( level._humangun_upgraded_player_hit_visionset, level._humangun_upgraded_player_hit_visionset_priority, level._humangun_visionset_transition_time, int_local_client );
+		}
+		else
+		{
+			self thread zombie_vision_set_apply( level._humangun_player_hit_visionset, level._humangun_player_hit_visionset_priority, level._humangun_visionset_transition_time, int_local_client );
+		}
+	}
+	else
+	{
+		if( bool_upgraded )
+		{
+			zombie_vision_set_remove( level._humangun_upgraded_player_hit_visionset, level._humangun_visionset_transition_time, int_local_client );
+		}
+		else
+		{
+			zombie_vision_set_remove( level._humangun_player_hit_visionset, level._humangun_visionset_transition_time, int_local_client );
+		}
+	}
+}
+activate_humangun_loop()
+{
+	level endon( "audio_deact_hg_loop" );
+	level notify( "audio_act_hg_loop" );
+	PlaySound( 0, "wpn_humangun_loop_start", (0,0,0) );
+	level.humangun_sound_ent PlayLoopSound( "wpn_humangun_loop", 1 );
+}
+deactivate_humangun_loop()
+{
+	level endon( "audio_act_hg_loop" );
+	level notify( "audio_deact_hg_loop" );
+	PlaySound( 0, "wpn_humangun_loop_end", (0,0,0) );
+	level.humangun_sound_ent stoploopsound( .5 );
+}
+

BO1/PC/ZM/clientscripts/_zombietron.csc

@@ -0,0 +1,923 @@
+#include clientscripts\_music;
+#include clientscripts\_utility;
+main()
+{
+	level.zombiemode = true;
+	level.swimmingFeature = false;
+	clientscripts\_load::main();
+	clientscripts\_footsteps::SetAIFootstepPrepend( "fly_step_zombie_");
+	thread clientscripts\_audio::audio_init(0);
+	level._zombieCBFunc = clientscripts\_zombietron::on_zombie_spawn;
+	level._playerCBFunc = clientscripts\_zombietron::on_player_spawn;
+	init_client_flags();
+	init_client_flag_callbacks();
+	OnPlayerConnect_Callback( ::on_player_connect );
+	level._customVehicleCBFunc = ::vehicle_spawned_callback;
+	level.bomb_model = "zombie_bomb";
+	level.head_model = "char_ger_ansel_head";
+	level._ZOMBIE_GIB_PIECE_INDEX_ALL = 0;
+	level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM = 1;
+	level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM = 2;
+	level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG = 3;
+	level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG = 4;
+	level._ZOMBIE_GIB_PIECE_INDEX_HEAD = 5;
+	level._ZOMBIE_GIB_PIECE_INDEX_GUTS = 6;
+	level._gib_overload_func = ::gib_handler;
+	level._gibEventCBFunc = ::on_gib_event;
+}
+vehicle_spawned_callback( localClientNum )
+{
+	if( self.vehicletype == "tank_t55_mini" )
+	{
+		self thread collisionHandler( localClientNum );
+		self thread jump_landing_thread( localClientNum );
+	}
+}
+collisionHandler( localClientNum )
+{
+	self endon( "entityshutdown" );
+	while( 1 )
+	{
+		self waittill( "veh_collision", hip, hitn, hit_intensity );
+		driver_local_client = self GetLocalClientDriver();
+		if( IsDefined( driver_local_client ) )
+		{
+			player = getlocalplayer( driver_local_client );
+			if( IsDefined( player ) )
+			{
+				if( hit_intensity > 15 )
+				{
+					player PlayRumbleOnEntity( driver_local_client, "damage_heavy" );
+				}
+				else
+				{
+					player PlayRumbleOnEntity( driver_local_client, "damage_light" );
+				}
+			}
+		}
+	}
+}
+jump_landing_thread( localClientNum )
+{
+	self endon( "entityshutdown" );
+	while( 1 )
+	{
+		self waittill( "veh_landed" );
+		driver_local_client = self GetLocalClientDriver();
+		if( IsDefined( driver_local_client ) )
+		{
+			player = getlocalplayer( driver_local_client );
+			if( IsDefined( player ) )
+			{
+				player PlayRumbleOnEntity( driver_local_client, "damage_heavy" );
+			}
+		}
+	}
+}
+lightning_flash( intensity_low, intensity_high, lightningdir )
+{
+	lightningintensity = RandomFloatRange( intensity_low, intensity_high );
+	lightningexposure = 2;
+	SetSavedDvar( "r_lightTweakSunLight", lightningintensity );
+	SetSavedDvar( "r_lightTweakSunDirection", lightningdir );
+	SetDvar( "r_exposureValue", lightningexposure );
+}
+lighting_flash_cycle( intensity_low, intensity_high, min_flash_time, max_flash_time, flash_wait_time_min, flash_wait_time_max )
+{
+	flash_time = RandomFloatRange(min_flash_time, max_flash_time);
+	oldlight = GetDvarFloat( "r_lightTweakSunLight" );
+	oldsundir = GetDvarVector( "r_lightTweakSunDirection" );
+	oldexposure = GetDvarFloat( "r_exposureValue" );
+	lightningdir = ( RandomFloatRange(-60, -20), RandomFloatRange(0, 360) , 0 );
+	while( flash_time > 0.0 )
+	{
+		lightning_flash(intensity_low, intensity_high, lightningdir);
+		PlaySound( 0, "amb_thunder_clap", (0,0,0) );
+		flash_wait_time = RandomFloatRange(flash_wait_time_min, flash_wait_time_max);
+		wait( flash_wait_time );
+		SetSavedDvar( "r_lightTweakSunLight", oldlight );
+		SetSavedDvar( "r_lightTweakSunDirection", oldsundir );
+		SetDvar( "r_exposureValue", oldexposure );
+		flash_time = flash_time - flash_wait_time;
+	}
+}
+lightning(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if( set )
+	{
+		intensity_low = 10;
+		intensity_high = 30;
+		min_flash_time = 0.3;
+		max_flash_time = 0.7;
+		flash_wait_time_min = 0.05;
+		flash_wait_time_max = 0.1;
+		level thread lighting_flash_cycle( intensity_low,
+		intensity_high,
+		min_flash_time,
+		max_flash_time,
+		flash_wait_time_min,
+		flash_wait_time_max );
+	}
+}
+show_scores(localClientNum, set, newEnt)
+{
+	if( localClientNum != 0 )
+	{
+		return;
+	}
+	if (isPC())
+	{
+		return;
+	}
+	if( set )
+	{
+		ShowScores(localClientNum);
+	}
+	else
+	{
+		HideScores(localClientNum);
+	}
+}
+zombie_helicopter_kill(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(set)
+	{
+		temp = (0,0,270);
+		if(IsDefined(level._heli_pilot_ent))
+		{
+			temp = self.origin - level._heli_pilot_ent.origin;
+		}
+		temp = VectorNormalize( temp );
+		launch_dir = VectorCross( temp, (0,0,1) );
+		launch_dir = VectorNormalize( launch_dir );
+		launch_dir *= 100;
+		self LaunchRagdoll( launch_dir );
+		PlaySound( 0, "zmb_ragdoll_launched", self.origin );
+		origin = self GetTagOrigin( "j_head" );
+		angles = self GetTagAngles( "j_head" );
+		forcex = RandomFloatRange( -200, 200 );
+		forcey = RandomFloatRange( -200, 200 );
+		forcez = RandomFloatRange( 1300, 3100 );
+		camera_angles = GetDvarVector( "player_TopDownCamAngles" );
+		launchDir = AnglesToForward( camera_angles );
+		launchDir = launchDir * forcez * -1;
+		launchDir += ( forcex, forcey, 0 );
+		contactPoint = origin + ( RandomFloatRange( -1, 1 ), RandomFloatRange( -1, 1 ), RandomFloatRange( -1, 1 ) ) * 5;
+		CreateDynEntAndLaunch( 0, level.head_model, origin, angles, contactPoint, launchDir, level._effect["animscript_gibtrail_fx"] );
+	}
+}
+heli_pilot(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(set)
+	{
+		level._heli_pilot_ent = self;
+	}
+	else
+	{
+		level._heli_pilot_ent = undefined;
+	}
+}
+init_client_flag_callbacks()
+{
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_GIB_DEATH_P1, ::gib_death_1);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_GIB_DEATH_P2, ::gib_death_2);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_GIB_DEATH_P3, ::gib_death_3);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_GIB_DEATH_P4, ::gib_death_4);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_BLOOD, ::zombie_blood);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_LAUNCH_AND_BURN, ::zombie_launch_and_burn);
+	register_clientflag_callback("actor", level._ZT_ACTOR_CF_KILLED_BY_HELI, ::zombie_helicopter_kill);
+	register_clientflag_callback("scriptmover", level._ZT_SCRIPTMOVER_CF_SACRED_COW, ::sacred_cow);
+	register_clientflag_callback("scriptmover", level._ZT_SCRIPTMOVER_CF_POWERUP, ::powerup);
+	register_clientflag_callback("scriptmover", level._ZT_SCRIPTMOVER_CF_ELEC_TRAP, ::electrap_handler);
+	register_clientflag_callback("player", level._ZT_PLAYER_CF_UPDATEPROFILE, ::update_player_profile);
+	register_clientflag_callback("player", level._ZT_PLAYER_CF_HELI_PILOT, ::heli_pilot);
+	register_clientflag_callback("player", level._ZT_PLAYER_CF_START_SMART_BOMB, ::smartbomb_handler);
+	register_clientflag_callback("player", level._ZT_PLAYER_CF_LIGHTNING, ::lightning);
+	register_clientflag_callback("player", level._ZT_PLAYER_CF_SHOW_SCORES, ::show_scores);
+}
+update_player_profile(localClientNum, set, newEnt)
+{
+	PrintLn("*** Update player profile. ***");
+	UpdateGamerProfile(localClientNum);
+}
+randomize_array( array )
+{
+	for( i = 0; i < array.size; i++ )
+	{
+		j = RandomInt( array.size );
+		temp = array[i];
+		array[i] = array[j];
+		array[j] = temp;
+	}
+	return array;
+}
+flame_death_fx()
+{
+	self endon( "entityshutdown" );
+	if (IsDefined(self.is_on_fire) && self.is_on_fire )
+	{
+		return;
+	}
+	self.is_on_fire = true;
+	if( IsDefined( level._effect ) && IsDefined( level._effect["character_fire_death_torso"] ) )
+	{
+		PlayFxOnTag(0, level._effect["character_fire_death_torso"], self, "J_SpineLower" );
+	}
+	if( IsDefined( level._effect ) && IsDefined( level._effect["character_fire_death_sm"] ) )
+	{
+		wait 1;
+		tagArray = [];
+		tagArray[0] = "J_Elbow_LE";
+		tagArray[1] = "J_Elbow_RI";
+		tagArray[2] = "J_Knee_RI";
+		tagArray[3] = "J_Knee_LE";
+		tagArray = randomize_array( tagArray );
+		PlayFxOnTag( 0, level._effect["character_fire_death_sm"], self, tagArray[0] );
+		wait 1;
+		tagArray[0] = "J_Wrist_RI";
+		tagArray[1] = "J_Wrist_LE";
+		tagArray[2] = "J_Ankle_RI";
+		tagArray[3] = "J_Ankle_LE";
+		tagArray = randomize_array( tagArray );
+		PlayFxOnTag( 0, level._effect["character_fire_death_sm"], self, tagArray[0] );
+		PlayFxOnTag( 0, level._effect["character_fire_death_sm"], self, tagArray[1] );
+	}
+}
+zombie_launch_and_burn(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(!set)
+	{
+		return;
+	}
+	if(!IsDefined(level._nukepoint))
+	{
+		return;
+	}
+	dist_squared = DistanceSquared( self.origin, level._nukepoint );
+	if( dist_squared < 130 * 130 )
+	{
+		self LaunchRagdoll( (0,0,270) );
+	}
+	else if( dist_squared < 360 * 360 )
+	{
+		dir = VectorNormalize( self.origin - level._nukepoint );
+		dir = dir * 100;
+		dir = dir + (0,0,120);
+		self LaunchRagdoll( dir );
+	}
+	self thread flame_death_fx();
+}
+smartbomb_handler(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(!set)
+	{
+		return;
+	}
+	if (IsDefined( self.tank ))
+	{
+		level._nukepoint = self.tank.origin;
+	}
+	else
+	{
+		level._nukepoint = self.origin;
+	}
+	origin = self.origin + (20,0,800);
+	bomb = Spawn( 0, origin, "script_model" );
+	bomb SetModel( level.bomb_model );
+	bomb.angles = (90, 0, 0);
+	bomb MoveTo( self.origin, 0.3, 0, 0 );
+	PlaySound( 0, "zmb_nuke_incoming", self.origin );
+	bomb waittill("movedone");
+	PlaySound( 0, "zmb_nuke_impact", self.origin );
+	PlayFX( 0, level._effect["bomb"], self.origin );
+	bomb Delete();
+	players = getlocalplayers();
+	for(i = 0; i < players.size; i ++)
+	{
+		players[i] EarthQuake( 1.0, 0.8, self.origin, 1000 );
+	}
+}
+trap_tear_down_monitor(parent)
+{
+	self endon("done");
+	parent waittill("entityshutdown");
+	self notify("torn_down");
+	self Delete();
+}
+fx_tear_down_monitor()
+{
+	self waittill("entityshutdown");
+	if(IsDefined(self.fx))
+	{
+		self.fx Delete();
+		self.fx = undefined;
+	}
+	if(IsDefined(self.fx2))
+	{
+		self.fx2 Delete();
+		self.fx2 = undefined;
+	}
+}
+electrap_loop_sound(parent)
+{
+	self endon("torn_down");
+	self PlayLoopSound( "zmb_hazard_loop", .5 );
+	self waittill("deactivate");
+	self notify("done");
+	self stoploopsound(0.5);
+	if(IsDefined(self.fx))
+	{
+		self.fx Delete();
+		self.fx = undefined;
+	}
+	if(IsDefined(self.fx2))
+	{
+		self.fx2 Delete();
+		self.fx2 = undefined;
+	}
+	self Delete();
+}
+get_camera_launch_direction()
+{
+	pos = GetDvarVector( "player_topDownCamCenterPos" ) + GetDvarVector( "player_topDownCamOffset" );
+	return VectorNormalize( pos - self.origin );
+}
+gib_handler(type, locations)
+{
+	if(type == "up")
+	{
+		up = get_camera_launch_direction();
+		self._gib_vel = up * RandomIntRange( 1400, 3500 );
+	}
+	return false;
+}
+electrap_handler(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	self endon("entityshutdown");
+	if ( !isDefined(self.first_tickle) )
+	{
+		self.first_tickle = 1;
+		self thread fx_tear_down_monitor();
+		return;
+	}
+	if(set)
+	{
+		if ( isDefined(self.fx2) )
+		{
+			self.fx2 Delete();
+			self.fx2 = SpawnFx( 0, level._effect["trap_red"], self.origin, 0,(1,0,0),(0,0,1) );
+			if ( isDefined(self.fx2) )
+			{
+				triggerFx( self.fx2 );
+			}
+		}
+		wait 1;
+		self.fx = SpawnFx( 0, level._effect["electric_trap"], self.origin + (0,0,100), 0 );
+		if ( isDefined(self.fx) )
+		{
+			triggerFx( self.fx );
+			self.soundent = spawn(0, self.origin, "script_origin");
+			self.soundent thread electrap_loop_sound(self);
+		}
+	}
+	else
+	{
+		if ( isDefined(self.fx) )
+		{
+			self.fx Delete();
+			self.soundent notify("deactivate");
+		}
+		if ( isDefined(self.fx2) )
+		{
+			self.fx2 Delete();
+		}
+		self.fx2 = SpawnFx( 0, level._effect["trap_green"], self.origin, 0,(1,0,0),(0,0,1) );
+		if ( isDefined(self.fx2) )
+		{
+			triggerFx( self.fx2 );
+		}
+	}
+}
+get_pickup_type_from_model(model)
+{
+	ret = "NA";
+	switch(model)
+	{
+		case "zombietron_gold_brick":
+		case "zombietron_gold_bricks":
+		case "zombietron_gold_coin":
+		case "zombietron_silver_brick":
+		case "zombietron_silver_bricks":
+		case "zombietron_silver_coin":
+		case "zombie_z_money_icon":
+		case "zombietron_ruby":
+		case "zombietron_sapphire":
+		case "zombietron_diamond":
+		ret = "money";
+		break;
+		case "c_usa_blackops_body1_fb":
+		ret = "extra_life";
+		break;
+		case "t5_veh_tank_t55_mini_static":
+		ret = "tank";
+		break;
+		case "t5_veh_helo_hind_mini":
+		ret = "heli";
+		break;
+		case "p_glo_barrel_metal_blue":
+		ret = "spinning_blockers";
+		break;
+		case "zombietron_electric_ball":
+		ret = "tesla_blockers";
+		break;
+		case "zombie_teddybear":
+		ret = "stun_blockers";
+		break;
+		case "anim_chicken":
+		ret = "double_shot";
+		break;
+		case "zombie_bomb":
+		ret = "bomb";
+		break;
+		case "zombietron_lightning_bolt":
+		ret = "booster";
+		break;
+		case "p_rus_boots":
+		ret = "speed";
+		break;
+		case "m2_flamethrower_zt":
+		case "ray_gun_zt":
+		case "weapon_usa_ray_gun":
+		case "weapon_usa_flamethrower":
+		case "m60_zt":
+		case "minigun_zt":
+		case "t5_weapon_carry_minigun_world":
+		case "spas_zt":
+		case "t5_weapon_spas_world":
+		case "china_lake_zt":
+		case "t5_weapon_ex41_world":
+		case "rpg_zt":
+		case "weapon_rpg7":
+		ret = "weapon";
+		break;
+		case "zombie_auto_turret":
+		ret = "mini_turret";
+		break;
+		case "weapon_zombie_monkey_bomb":
+		case "weapon_zombie_monkey_bomb_zt":
+		ret = "monkey";
+		break;
+	}
+	return(ret);
+}
+pickup_tear_down_monitor(parent)
+{
+	self endon("done");
+	parent waittill("entityshutdown");
+	self notify("torn_down");
+	self stoploopsound(0.5);
+	self Delete();
+}
+pickup_loop_sound(parent, sound)
+{
+	self endon("torn_down");
+	self thread pickup_tear_down_monitor(parent);
+	self PlayLoopSound( sound, .5 );
+	self waittill("picked_up");
+	self notify("done");
+	self stoploopsound(0.5);
+	self Delete();
+}
+powerup(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(set)
+	{
+		play_sound = true;
+		loop_sound = "";
+		switch(get_pickup_type_from_model(self.model))
+		{
+			case "extra_life":
+			case "extra_life_directed":
+			loop_sound = "zmb_pickup_life_shimmer";
+			playfxontag (localClientNum, level._effect["powerup_on"], self, "tag_origin");
+			break;
+			case "money":
+			loop_sound = "zmb_pickup_money_shimmer";
+			model = self.model;
+			if ( model == "zombietron_ruby" )
+			{
+				PlayFxOnTag(localClientNum, level._effect["red_gem"], self, "tag_origin" );
+			}
+			else if ( model == "zombietron_sapphire" )
+			{
+				PlayFxOnTag(localClientNum, level._effect["blue_gem"], self, "tag_origin" );
+			}
+			else if ( model == "zombietron_diamond" )
+			{
+				PlayFxOnTag(localClientNum, level._effect["white_gem"], self, "tag_origin" );
+			}
+			else if ( issubstr(self.model,"silver" ) )
+			{
+				playfxontag (localClientNum, level._effect["powerup_on_silver"], self, "tag_origin");
+			}
+			else
+			{
+				playfxontag (localClientNum, level._effect["powerup_on"], self, "tag_origin");
+			}
+			break;
+			case "speed":
+			case "spinning_blockers":
+			case "tesla_blockers":
+			case "stun_blockers":
+			case "bomb":
+			case "booster":
+			case "mini_turret":
+			case "monkey":
+			loop_sound = "zmb_pickup_powerup_shimmer";
+			break;
+			case "double_shot":
+			PlaySound(localClientNum, "zmb_dblshot_spawn", self.origin);
+			loop_sound = "zmb_pickup_powerup_shimmer";
+			break;
+			case "weapon":
+			loop_sound = "zmb_pickup_weapon_shimmer";
+			break;
+			case "tank":
+			case "heli":
+			loop_sound = "zmb_pickup_vehicle_shimmer";
+			break;
+			default:
+			PrintLn("Spawned " + self.model);
+			play_sound = false;
+			break;
+		}
+		if(play_sound)
+		{
+			PlaySound( localClientNum, "zmb_pickup_spawn", self.origin );
+		}
+		if(loop_sound != "")
+		{
+			self.loopsound = spawn(0, self.origin, "script_origin");
+			self.loopsound thread pickup_loop_sound(self, loop_sound);
+		}
+	}
+	else
+	{
+		if(IsDefined(self.loopsound))
+		{
+			self.loopsound notify("picked_up");
+		}
+		PlayFx( 0, level._effect["powerup_grabbed"], self.origin, AnglesToForward(self.angles) );
+		switch(get_pickup_type_from_model(self.model))
+		{
+			case "extra_life":
+			case "extra_life_directed":
+			PlaySound( localClientNum, "zmb_pickup_life", self.origin );
+			break;
+			case "money":
+			PlaySound( localClientNum, "zmb_pickup_money", self.origin );
+			break;
+			case "tank":
+			case "heli":
+			PlaySound( localClientNum, "zmb_pickup_vehicle", self.origin );
+			break;
+			case "spinning_blockers":
+			case "tesla_blockers":
+			case "stun_blockers":
+			case "double_shot":
+			case "bomb":
+			case "booster":
+			case "speed":
+			PlaySound( localClientNum, "zmb_pickup_powerup", self.origin );
+			break;
+			case "weapon":
+			case "mini_turret":
+			case "monkey":
+			PlaySound( localClientNum, "zmb_pickup_weapon", self.origin );
+			break;
+			default:
+			PrintLn("Grabbed " + self.model);
+			break;
+		}
+	}
+}
+sacred_cow(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	self PlayLoopSound( "zmb_pickup_money_shimmer" );
+	playfxontag (localClientNum,level._effect["powerup_on"], self, "J_Ankle_LE");
+	playfxontag (localClientNum,level._effect["powerup_on"], self, "J_Ankle_RI");
+	playfxontag (localClientNum,level._effect["powerup_on"], self, "J_Wrist_LE");
+	playfxontag (localClientNum,level._effect["powerup_on"], self, "J_Wrist_RI");
+	playfxontag (localClientNum,level._effect["torch_light"], self, "J_Tail2");
+}
+zombie_blood(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(set)
+	{
+		if(is_mature())
+		{
+			PlayFX(localClientNum, level._effect["big_blood"], self.origin, AnglesToForward(self.angles) * -1);
+		}
+	}
+}
+gib_death(localClientNum, set, newEnt, player)
+{
+	if(set)
+	{
+		if(is_mature())
+		{
+			PlayFX( localClientNum, level._effect["gib_death"], self.origin, AnglesToForward(self.angles) );
+		}
+	}
+}
+gib_death_1(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	gib_death(localClientNum, set, newEnt, 1);
+}
+gib_death_2(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	gib_death(localClientNum, set, newEnt, 2);
+}
+gib_death_3(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	gib_death(localClientNum, set, newEnt, 3);
+}
+gib_death_4(localClientNum, set, newEnt)
+{
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	gib_death(localClientNum, set, newEnt, 4);
+}
+init_client_flags()
+{
+	level._ZT_ACTOR_CF_GIB_DEATH_P1 = 2;
+	level._ZT_ACTOR_CF_GIB_DEATH_P2 = 3;
+	level._ZT_ACTOR_CF_GIB_DEATH_P3 = 4;
+	level._ZT_ACTOR_CF_GIB_DEATH_P4 = 5;
+	level._ZT_ACTOR_CF_BLOOD = 6;
+	level._ZT_ACTOR_CF_LAUNCH_AND_BURN = 7;
+	level._ZT_ACTOR_CF_KILLED_BY_HELI = 8;
+	level._ZT_SCRIPTMOVER_CF_SACRED_COW = 0;
+	level._ZT_SCRIPTMOVER_CF_POWERUP = 1;
+	level._ZT_SCRIPTMOVER_CF_ELEC_TRAP = 2;
+	level._ZT_PLAYER_CF_UPDATEPROFILE = 10;
+	level._ZT_PLAYER_CF_HELI_PILOT = 11;
+	level._ZT_PLAYER_CF_LIGHTNING = 12;
+	level._ZT_PLAYER_CF_SHOW_SCORES = 13;
+	level._ZT_PLAYER_CF_START_SMART_BOMB = 14;
+}
+createZombieEyes(localClientNum)
+{
+	if(isdefined(self._eyeArray))
+	{
+		if(!isdefined(self._eyeArray[localClientNum]))
+		{
+			linkTag = "J_Eyeball_LE";
+			self._eyeArray[localClientNum] = PlayFxOnTag( localClientNum, level._effect["eye_glow"], self, linkTag );
+		}
+	}
+}
+deleteZombieEyes(localClientNum)
+{
+	if(isdefined(self._eyeArray))
+	{
+		if(isdefined(self._eyeArray[localClientNum]))
+		{
+			DeleteFx( localClientNum, self._eyeArray[localClientNum] , true );
+			self._eyeArray[localClientNum] = undefined;
+		}
+	}
+}
+on_player_connect(localClientNum)
+{
+	ForceGameModeMappings( localClientNum, "zombietron" );
+}
+on_player_spawn(localClientNum)
+{
+	ForceGameModeMappings( localClientNum, "zombietron" );
+	self mapshaderconstant( localClientNum, 0, "scriptVector0", 1.0, -1.0, 0.0, 0.0 );
+}
+on_zombie_spawn(localClientNum)
+{
+	if(!isdefined(self._eyeArray))
+	{
+		self._eyeArray = [];
+	}
+	wait( 0.05 );
+	if( isDefined(self) && self haseyes())
+	{
+		self createZombieEyes(localClientNum);
+	}
+	if ( isDefined(self) )
+		self mapshaderconstant( localClientNum, 0, "scriptVector0", -4.0, -1.0, 0.0, -1.0 );
+}
+zombie_eye_callback(localClientNum, hasEyes)
+{
+	players = GetLocalPlayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		if ( hasEyes )
+		{
+			self createZombieEyes( i );
+		}
+		else
+		{
+			self deleteZombieEyes( i );
+		}
+	}
+}
+mark_piece_gibbed( piece_index )
+{
+	if ( !isdefined( self.gibbed_pieces ) )
+	{
+		self.gibbed_pieces = [];
+	}
+	self.gibbed_pieces[self.gibbed_pieces.size] = piece_index;
+}
+has_gibbed_piece( piece_index )
+{
+	if ( !isdefined( self.gibbed_pieces ) )
+	{
+		return false;
+	}
+	for ( i = 0; i < self.gibbed_pieces.size; i++ )
+	{
+		if ( self.gibbed_pieces[i] == piece_index )
+		{
+			return true;
+		}
+	}
+	return false;
+}
+do_gib_fx( tag )
+{
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		PlayFxOnTag( i, level._effect["animscript_gib_fx"], self, tag );
+	}
+	PlaySound( 0, "zmb_death_gibs", self gettagorigin( tag ) );
+}
+do_gib( model, tag )
+{
+	start_pos = self gettagorigin( tag );
+	wait( 0.03 );
+	end_pos = self gettagorigin( tag );
+	if ( IsDefined( self._gib_vel ) )
+	{
+		forward = self._gib_vel;
+		self._gib_vel = undefined;
+	}
+	else
+	{
+		forward = VectorNormalize( end_pos - start_pos );
+		forward *= RandomIntRange( 600, 1000 );
+		forward += (0, 0, RandomIntRange( 400, 700 ));
+	}
+	CreateDynEntAndLaunch( 0, model, end_pos, self gettagangles(tag), start_pos, forward, level._effect["animscript_gibtrail_fx"], 1 );
+	self do_gib_fx( tag );
+}
+on_gib_event( localClientNum, type, locations )
+{
+	if ( localClientNum != 0 )
+	{
+		return;
+	}
+	if( !is_mature() )
+	{
+		return;
+	}
+	if ( self._gib_def == -1 )
+	{
+		return;
+	}
+	if ( IsDefined( level._gib_overload_func ) )
+	{
+		PrintLn( "type " + type );
+		PrintLn( "loc size " + locations.size );
+		if ( self [[level._gib_overload_func]]( type, locations ) )
+		{
+			return;
+		}
+	}
+	for ( i = 0; i < locations.size; i++ )
+	{
+		if ( IsDefined( self.gibbed ) && level._ZOMBIE_GIB_PIECE_INDEX_HEAD != locations[i] )
+		{
+			continue;
+		}
+		switch( locations[i] )
+		{
+			case 0:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn1 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag1 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn1, level._gibbing_actor_models[self._gib_def].gibSpawnTag1 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn2 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag2 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn2, level._gibbing_actor_models[self._gib_def].gibSpawnTag2 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn3 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag3 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn3, level._gibbing_actor_models[self._gib_def].gibSpawnTag3 );
+			}
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn4 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag4 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn4, level._gibbing_actor_models[self._gib_def].gibSpawnTag4 );
+			}
+			self thread do_gib_fx( "J_SpineLower" );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG );
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_HEAD );
+			break;
+			case 1:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn1 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag1 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn1, level._gibbing_actor_models[self._gib_def].gibSpawnTag1 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_ARM );
+			break;
+			case 2:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn2 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag2 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn2, level._gibbing_actor_models[self._gib_def].gibSpawnTag2 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_ARM );
+			break;
+			case 3:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn3 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag3 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn3, level._gibbing_actor_models[self._gib_def].gibSpawnTag3 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_RIGHT_LEG );
+			break;
+			case 4:
+			if ( IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawn4 ) && IsDefined( level._gibbing_actor_models[self._gib_def].gibSpawnTag4 ) )
+			{
+				self thread do_gib( level._gibbing_actor_models[self._gib_def].gibSpawn4, level._gibbing_actor_models[self._gib_def].gibSpawnTag4 );
+			}
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_LEFT_LEG );
+			break;
+			case 5:
+			mark_piece_gibbed( level._ZOMBIE_GIB_PIECE_INDEX_HEAD );
+			break;
+			case 6:
+			self thread do_gib_fx( "J_SpineLower" );
+			break;
+		}
+	}
+	self.gibbed = true;
+}
+

BO1/PC/ZM/clientscripts/createfx/zombie_cod5_prototype_fx.csc

@@ -0,0 +1,677 @@
+
+main()
+{
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -673.074, -766.968, -26.5289 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -571.381, -1636.91, 80.8831 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 440.201, -1321.61, 26.6093 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 755.909, 220.307, 7.31731 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 1063.98, -871.593, 5.95168 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 1396.97, 688.073, 5.34588 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 317.986, 1688.19, 149.969 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -649.748, 101.867, -29.5503 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -764.255, 1136.32, 22.8691 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -727.275, 546.164, -19.4539 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "battlefield_smokebank_sm_tan" );
+	ent.v[ "origin" ] = ( 1084.51, -131.344, 34.4557 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "battlefield_smokebank_sm_tan";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 2609.53, 748.956, 236.421 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 1695.81, 1489.26, 195.006 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1132.59, 876.375, -1.77614 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1178.44, 925.081, -1.14948 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1105.55, 830.055, -1.03921 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "battlefield_smokebank_sm_tan" );
+	ent.v[ "origin" ] = ( -767.711, 266.941, 13.8245 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "battlefield_smokebank_sm_tan";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "battlefield_smokebank_sm_tan" );
+	ent.v[ "origin" ] = ( 1390.83, 1892.45, 150.931 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "battlefield_smokebank_sm_tan";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( 616.654, -474.242, -7.7898 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks" );
+	ent.v[ "origin" ] = ( 1213.24, 272.034, 228.049 );
+	ent.v[ "angles" ] = ( 358, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks_blue" );
+	ent.v[ "origin" ] = ( 1693.84, 833.98, 293.807 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks_blue";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks" );
+	ent.v[ "origin" ] = ( 1240.67, 626.144, 167.241 );
+	ent.v[ "angles" ] = ( 358, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -223.015, 382.993, 80.125 );
+	ent.v[ "angles" ] = ( 328.986, 200.478, 173.603 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = 1;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -214.088, 478.767, 85.017 );
+	ent.v[ "angles" ] = ( 328.986, 200.478, 173.603 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = 1;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -218.12, -194.662, 79.9335 );
+	ent.v[ "angles" ] = ( 328.986, 200.478, 173.603 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = 1;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -75.2952, 397.105, 306.125 );
+	ent.v[ "angles" ] = ( 332.494, 179.712, -176.791 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -112.262, 109.56, 305.125 );
+	ent.v[ "angles" ] = ( 334.743, 175.524, -173.608 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -91.8475, -57.8259, 297.125 );
+	ent.v[ "angles" ] = ( 332.494, 179.712, -176.791 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( 63.7406, 511.513, 305.125 );
+	ent.v[ "angles" ] = ( 320.515, 178.848, -176.312 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( 136.001, 937.865, 302.125 );
+	ent.v[ "angles" ] = ( 332.39, 190.995, 177.976 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_column_creep_xsm" );
+	ent.v[ "origin" ] = ( 1238.68, 925.793, -0.367569 );
+	ent.v[ "angles" ] = ( 0, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_column_creep_xsm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_column_creep_xsm" );
+	ent.v[ "origin" ] = ( 196.436, -100.571, 72.2384 );
+	ent.v[ "angles" ] = ( 274, 270, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_column_creep_xsm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 123.133, -957.101, 45.687 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 113.333, -946.185, 45.9968 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 114.712, -963.247, 44.0852 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( -541.668, 411.021, 27.8858 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( -553.995, 392.761, 26.0101 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 195.468, -103.679, 77.6072 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( -552.565, 404.588, 21.5665 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 109.682, -957.513, 45.1729 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 1185.91, 939.156, 25.8573 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_column_creep_xsm" );
+	ent.v[ "origin" ] = ( 1227.52, 926.134, 6.50701 );
+	ent.v[ "angles" ] = ( 270, 359.484, 0.516024 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_column_creep_xsm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1270.73, 935.509, 54.712 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1215.44, 846.265, -5.43003 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1253.25, 845.307, -6.45285 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 1171.86, 934.887, 0.800284 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( -247.291, -118.17, 2.46084 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( -242.899, -137.244, 2.125 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 188.991, -91.1148, 69.1965 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 731.812, 997.333, 172.404 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_room_fill" );
+	ent.v[ "origin" ] = ( 624.812, 851.8, 192.125 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_room_fill";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 759.595, 995.422, 163.336 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_room_fill" );
+	ent.v[ "origin" ] = ( 39.2104, 308.372, 183.312 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_room_fill";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_room_fill" );
+	ent.v[ "origin" ] = ( -12.6183, 61.0479, 13 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_room_fill";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 331.642, 1368.99, 150 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_window" );
+	ent.v[ "origin" ] = ( 396.393, 1426.42, 159 );
+	ent.v[ "angles" ] = ( 350.098, 188.122, -1.40582 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_window";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_column_creep_sm" );
+	ent.v[ "origin" ] = ( 451.185, 1350.84, 148.857 );
+	ent.v[ "angles" ] = ( 276, 360, -30 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_column_creep_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_impact_smolder_w" );
+	ent.v[ "origin" ] = ( 263.046, 1483.61, 149 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_impact_smolder_w";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "ash_and_embers_hall" );
+	ent.v[ "origin" ] = ( 406.49, 1427.08, 303.732 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "ash_and_embers_hall";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 765.818, 1200.04, 157.092 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 779.809, 1467.59, 249.11 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 750.794, 1361.53, 191.019 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_column_creep_sm" );
+	ent.v[ "origin" ] = ( 789.211, 1263.44, 164.607 );
+	ent.v[ "angles" ] = ( 276, 0, -30 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_column_creep_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "dlight_fire_glow" );
+	ent.v[ "origin" ] = ( 794.627, 1242.43, 229.58 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "dlight_fire_glow";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_static_small" );
+	ent.v[ "origin" ] = ( 778.149, 991.334, 158.245 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_static_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks_blue" );
+	ent.v[ "origin" ] = ( -711.989, -659.275, 166.679 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks_blue";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( -698.403, -50.8306, 169.117 );
+	ent.v[ "angles" ] = ( 84, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_window_out_small" );
+	ent.v[ "origin" ] = ( 787.976, 1284.28, 195.561 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_window_out_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_window_out_small" );
+	ent.v[ "origin" ] = ( 396.751, 1498.32, 175.461 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_window_out_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_window_out_small" );
+	ent.v[ "origin" ] = ( 1209.56, 938.742, 34.7518 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_window_out_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 39.4743, 738.771, 245.475 );
+	ent.v[ "angles" ] = ( 90, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 415.027, 738.228, 240.27 );
+	ent.v[ "angles" ] = ( 90, 325.915, -34.086 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( -1.25879, 1056.03, 244.722 );
+	ent.v[ "angles" ] = ( 90, 231.116, -148.884 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 284.943, 179.486, 241.701 );
+	ent.v[ "angles" ] = ( 36.2014, 146.157, 172.598 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 340.258, 921.943, 104.219 );
+	ent.v[ "angles" ] = ( 90, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 176.59, 716.579, 98.898 );
+	ent.v[ "angles" ] = ( 90, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( -140.158, 679.738, 99.312 );
+	ent.v[ "angles" ] = ( 90, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 770.58, 868.499, 10.8021 );
+	ent.v[ "angles" ] = ( 318, 132, -8 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( -105.469, 847.873, 155.457 );
+	ent.v[ "angles" ] = ( 317.139, 130.431, -141.616 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -212.425, 230.206, 236 );
+	ent.v[ "angles" ] = ( 334.459, 184.343, -177.968 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -215.96, 697.257, 316.283 );
+	ent.v[ "angles" ] = ( 296.696, 194.71, 179.73 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -115.003, 16.9401, 309.795 );
+	ent.v[ "angles" ] = ( 327.896, 175.836, -177.016 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( -270.61, -98.519, -5.09015 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( -291.366, -221.531, -8.65272 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( -364.303, -71.5915, -9.93956 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 121.346, -979.991, 5.94707 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 208.852, -35.6098, 94.9997 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "fire_detail" );
+	ent.v[ "origin" ] = ( 166.312, -109.213, 63.4913 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fire_detail";
+	ent.v[ "delay" ] = 0.5;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small_short" );
+	ent.v[ "origin" ] = ( -226.854, 428.31, 237.955 );
+	ent.v[ "angles" ] = ( 332, 180, 180 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small_short";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks" );
+	ent.v[ "origin" ] = ( -649.279, -676.415, 162.774 );
+	ent.v[ "angles" ] = ( 358, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "wire_sparks" );
+	ent.v[ "origin" ] = ( 185.052, -541.766, 14.6714 );
+	ent.v[ "angles" ] = ( 358, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "wire_sparks";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -201.126, -619.109, 316.453 );
+	ent.v[ "angles" ] = ( 332.322, 186.48, -179.929 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -204.341, -785.792, 324.193 );
+	ent.v[ "angles" ] = ( 332.494, 179.712, -176.791 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( 33.0982, 933.13, 302.875 );
+	ent.v[ "angles" ] = ( 304.322, 186.421, -179.888 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small_short" );
+	ent.v[ "origin" ] = ( -64.7752, 403.158, 285.819 );
+	ent.v[ "angles" ] = ( 328, 180, 180 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small_short";
+	ent.v[ "delay" ] = 0.1;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small_short" );
+	ent.v[ "origin" ] = ( -209.538, 388.18, 40.6552 );
+	ent.v[ "angles" ] = ( 342.283, 190.503, 176.771 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small_short";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small_short" );
+	ent.v[ "origin" ] = ( -65.1621, 322.689, 279.139 );
+	ent.v[ "angles" ] = ( 328, 180, 180 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small_short";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( -813.243, 188.308, 85.114 );
+	ent.v[ "angles" ] = ( 346.13, 178.007, -178.697 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_room_fill" );
+	ent.v[ "origin" ] = ( 567.681, 767.122, 5.125 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_room_fill";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( 55.1426, -331.655, 149.747 );
+	ent.v[ "angles" ] = ( 322.322, 186.464, -179.921 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "god_rays_small" );
+	ent.v[ "origin" ] = ( 82.4609, -207.678, 157.05 );
+	ent.v[ "angles" ] = ( 318.322, 186.457, -179.915 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "god_rays_small";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fog_thick" );
+	ent.v[ "origin" ] = ( -782.453, -42.4873, -1.64706 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fog_thick";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "smoke_room_fill" );
+	ent.v[ "origin" ] = ( -735.247, 26.4439, 18.4918 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "smoke_room_fill";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_moon_prototype" );
+	ent.v[ "origin" ] = ( -64347.8, 7452.44, 4675.17 );
+	ent.v[ "angles" ] = ( 0, 0, -178 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_moon_prototype";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( -193.061, -74.501, 189.565 );
+	ent.v[ "angles" ] = ( 280, 360, 2 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( -200.287, -670.795, 9.787 );
+	ent.v[ "angles" ] = ( 300.295, 194.555, 179.19 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( 220.791, 417.625, 16.1917 );
+	ent.v[ "angles" ] = ( 280, 0, 14 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( 1002.02, 651.422, 40.3735 );
+	ent.v[ "angles" ] = ( 0, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( -190.951, 949.658, 35.6854 );
+	ent.v[ "angles" ] = ( 0, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_lamp_glow_amber" );
+	ent.v[ "origin" ] = ( -100.703, 159.574, 67.0611 );
+	ent.v[ "angles" ] = ( 276, 180, 180 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_lamp_glow_amber";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 681.676, 469.066, 138.047 );
+	ent.v[ "angles" ] = ( 16.3433, 128.747, 172.22 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "light_ceiling_dspot" );
+	ent.v[ "origin" ] = ( 313.619, 544.581, 237.275 );
+	ent.v[ "angles" ] = ( 44.4603, 125.778, 124.278 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "light_ceiling_dspot";
+	ent.v[ "delay" ] = -15;
+}
+

BO1/PC/ZM/clientscripts/createfx/zombietron_fx.csc

@@ -0,0 +1,257 @@
+
+main()
+{
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_wake_creek_mouth_froth" );
+	ent.v[ "origin" ] = ( -330.813, 1596.81, -70 );
+	ent.v[ "angles" ] = ( 0, 228, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_wake_creek_mouth_froth";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -292.497, 1630.76, -70 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -254.492, 1597.14, -70 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -377.161, 1591.18, -70 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -327.084, 1477.49, -71.0546 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -410.078, 1570.12, -70 );
+	ent.v[ "angles" ] = ( 0, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_fall_sm" );
+	ent.v[ "origin" ] = ( -218.161, 1647.28, 189.358 );
+	ent.v[ "angles" ] = ( 16, 30, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_fall_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_fall_sm" );
+	ent.v[ "origin" ] = ( -428.771, 1657.8, 164.684 );
+	ent.v[ "angles" ] = ( 351.26, 342.514, -10.8069 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_fall_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_fall_xsm" );
+	ent.v[ "origin" ] = ( -234.155, 1612.77, 128.281 );
+	ent.v[ "angles" ] = ( 2.09763, 342.033, 0.618335 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_fall_xsm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_light_glow_green" );
+	ent.v[ "origin" ] = ( -2656.76, -355.61, 17.6156 );
+	ent.v[ "angles" ] = ( 272, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_light_glow_green";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_zombie_light_glow_green" );
+	ent.v[ "origin" ] = ( -2657.36, -491.985, 21.5298 );
+	ent.v[ "angles" ] = ( 272, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_zombie_light_glow_green";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_search_light_tower" );
+	ent.v[ "origin" ] = ( -2918.15, -4991.38, 306.658 );
+	ent.v[ "angles" ] = ( 23.6543, 262.702, -177.788 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_search_light_tower";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks" );
+	ent.v[ "origin" ] = ( -226.844, -970.443, 42.0333 );
+	ent.v[ "angles" ] = ( 4, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_fluorescent_tubes" );
+	ent.v[ "origin" ] = ( 197.754, -3560.1, 297.182 );
+	ent.v[ "angles" ] = ( 62, 182, -90 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_fluorescent_tubes";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_fluorescent_tubes" );
+	ent.v[ "origin" ] = ( -696.924, -4087.43, 302.161 );
+	ent.v[ "angles" ] = ( 61.2309, 13.2821, -81.3789 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_fluorescent_tubes";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_elec_short_random" );
+	ent.v[ "origin" ] = ( -435.855, -3484.98, 265.287 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_elec_short_random";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_elec_short_random" );
+	ent.v[ "origin" ] = ( -2744.71, -2113.04, 203.932 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_elec_short_random";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_elec_short_random" );
+	ent.v[ "origin" ] = ( -8227.02, 1951.3, 359.978 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_elec_short_random";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_elec_short_random" );
+	ent.v[ "origin" ] = ( -7755.19, 1666.7, 195.786 );
+	ent.v[ "angles" ] = ( 292.879, 194.071, 172.25 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_elec_short_random";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_elec_short_random" );
+	ent.v[ "origin" ] = ( -8284.97, 1680.92, 261.125 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_elec_short_random";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( 4239.56, 1183.06, 236.905 );
+	ent.v[ "angles" ] = ( 88, 270, 90 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( 4236.61, 963.73, 239.836 );
+	ent.v[ "angles" ] = ( 88, 270, 90 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_snow_wall_avalanche" );
+	ent.v[ "origin" ] = ( -2636.69, 2132.59, 173.662 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_snow_wall_avalanche";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_snow_wall_avalanche" );
+	ent.v[ "origin" ] = ( -2051.24, 1714.1, 207.444 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_snow_wall_avalanche";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_pow_cave_water_fall" );
+	ent.v[ "origin" ] = ( -300.783, 1681.27, 202.285 );
+	ent.v[ "angles" ] = ( 347.876, 273.067, 1.71468 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_pow_cave_water_fall";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_pow_cave_water_fall" );
+	ent.v[ "origin" ] = ( -361.465, 1646.88, 188.778 );
+	ent.v[ "angles" ] = ( 352.62, 253.138, -0.331623 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_pow_cave_water_fall";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( -2556.09, -2135.06, 171.471 );
+	ent.v[ "angles" ] = ( 63.7108, 261.728, -9.05611 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( 3514.17, 1610.4, 239.721 );
+	ent.v[ "angles" ] = ( 88, 270, -52 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( 3559.33, 594.379, 241.505 );
+	ent.v[ "angles" ] = ( 88, 270, -142 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_column_xsm_thin" );
+	ent.v[ "origin" ] = ( -2949.75, -882.637, 9.53891 );
+	ent.v[ "angles" ] = ( 3.88683, 87.5677, -0.738694 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_column_xsm_thin";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_column_xsm_thin" );
+	ent.v[ "origin" ] = ( -3089.41, -877.806, 4.72826 );
+	ent.v[ "angles" ] = ( 3.88683, 87.5677, -0.738694 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_column_xsm_thin";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_column_xsm_thin" );
+	ent.v[ "origin" ] = ( -698.079, 976.305, -50.4247 );
+	ent.v[ "angles" ] = ( 3.88683, 87.5677, -0.738694 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_column_xsm_thin";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_column_xsm_thin" );
+	ent.v[ "origin" ] = ( -695.002, 1219.16, -52.0319 );
+	ent.v[ "angles" ] = ( 3.88683, 87.5677, -0.738694 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_column_xsm_thin";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_ash_embers_light" );
+	ent.v[ "origin" ] = ( -3061.74, -2258.66, 144.712 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_ash_embers_light";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_ash_embers_light" );
+	ent.v[ "origin" ] = ( -2298, -3017.66, 85.7147 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_ash_embers_light";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_ash_embers_light" );
+	ent.v[ "origin" ] = ( -2388.7, -2131.84, 83.8043 );
+	ent.v[ "angles" ] = ( 270, 0, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_ash_embers_light";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -329.376, 1623.75, -34.5418 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_water_splash_creek_rocks_sm" );
+	ent.v[ "origin" ] = ( -342.49, 1585.82, -53.875 );
+	ent.v[ "angles" ] = ( 0, 252, 0 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_water_splash_creek_rocks_sm";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_md" );
+	ent.v[ "origin" ] = ( -2390.24, -2086.6, -39.2392 );
+	ent.v[ "angles" ] = ( 274.694, 94.9798, 179.249 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_md";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_md" );
+	ent.v[ "origin" ] = ( -2263.93, -3018.37, -41 );
+	ent.v[ "angles" ] = ( 272.137, 341.109, 13.0109 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_md";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_fire_md" );
+	ent.v[ "origin" ] = ( -3095.27, -2256, -38 );
+	ent.v[ "angles" ] = ( 359.855, 182.136, 1.99578 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_fire_md";
+	ent.v[ "delay" ] = -15;
+	ent = clientscripts\_fx::createOneshotEffect( "fx_light_kow_ray_street" );
+	ent.v[ "origin" ] = ( -2791.47, -3133.8, 173.961 );
+	ent.v[ "angles" ] = ( 67.9601, 88.1653, -1.18928 );
+	ent.v[ "type" ] = "oneshotfx";
+	ent.v[ "fxid" ] = "fx_light_kow_ray_street";
+	ent.v[ "delay" ] = -15;
+}
+

BO1/PC/ZM/clientscripts/zombie_coast_fx.csc

@@ -0,0 +1,367 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	clientscripts\createfx\zombie_coast_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	footsteps();
+	precache_scripted_fx();
+	precache_util_fx();
+	precache_createfx_fx();
+	disableFX = GetDvarInt( #"disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread manage_player_rain();
+	level thread clientscripts\_zombiemode::init_perk_machines_fx();
+	level.blizzard = false;
+}
+footsteps()
+{
+}
+precache_util_fx()
+{
+}
+precache_scripted_fx()
+{
+	level._effect["eye_glow"] = LoadFx( "misc/fx_zombie_eye_single" );
+	level._effect["player_rain"] = loadfx( "maps/zombie/fx_zombie_coast_snow_oneshot" );
+	level._effect["headshot"] = LoadFX( "impacts/fx_flesh_hit" );
+	level._effect["headshot_nochunks"] = LoadFX( "misc/fx_zombie_bloodsplat" );
+	level._effect["bloodspurt"] = LoadFX( "misc/fx_zombie_bloodspurt" );
+	level._effect["animscript_gib_fx"] = LoadFx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect["animscript_gibtrail_fx"] = LoadFx( "trail/fx_trail_blood_streak" );
+	level._effect["buff_electrified"] = LoadFX( "maps/zombie/fx_zmb_coast_electrified_torso" );
+	level._effect[ "lighthouse_morse_code" ] = LoadFX( "maps/zombie/fx_zmb_coast_morse_code" );
+	level._effect["waterfreeze"] = LoadFX( "maps/zombie/fx_zmb_coast_waterfreeze_lower_body" );
+	level._effect[ "flare" ] = LoadFX( "maps/zombie/fx_zmb_coast_flare" );
+	level._effect[ "flare_no_dlight" ] = LoadFX( "maps/zombie/fx_zmb_coast_flare_no_dlight" );
+}
+precache_createfx_fx()
+{
+	level._effect["fx_zombie_boss_water_intro"] = loadfx("maps/zombie/fx_zombie_boss_water_intro");
+	level._effect["fx_zombie_boss_water_boil"] = loadfx("maps/zombie/fx_zombie_boss_water_boil");
+	level._effect["fx_zombie_boss_water_boil_sm"] = loadfx("maps/zombie/fx_zombie_boss_water_boil_sm");
+	level._effect["fx_zmb_coast_spotlight_main"] = loadfx("maps/zombie/fx_zmb_coast_spotlight_main");
+	level._effect["fx_zmb_coast_spotlight_burst"] = loadfx("maps/zombie/fx_zmb_coast_spotlight_burst");
+	level._effect["fx_fire_line_xsm"] = loadfx("env/fire/fx_fire_line_xsm");
+	level._effect["fx_zmb_coast_sparks_int_runner"] = loadfx("maps/zombie/fx_zmb_coast_sparks_int_runner");
+	level._effect["fx_zmb_coast_packapunch"] = loadfx("maps/zombie/fx_zmb_coast_packapunch");
+	level._effect["fx_zmb_coast_packapunch_rising"] = loadfx("maps/zombie/fx_zmb_coast_packapunch_rising");
+	level._effect["fx_zmb_coast_spotlight_packapunch"] = loadfx("maps/zombie/fx_zmb_coast_spotlight_packapunch");
+	level._effect["fx_zmb_coast_spotlight_pap_202"] = loadfx("maps/zombie/fx_zmb_coast_spotlight_pap_202");
+	level._effect["fx_zmb_coast_ray_moon_md"] = loadfx("maps/zombie/fx_zmb_coast_ray_moon_md");
+	level._effect["fx_zmb_coast_ray_moon_lg"] = loadfx("maps/zombie/fx_zmb_coast_ray_moon_lg");
+	level._effect["fx_zmb_coast_light_floodlight"] = loadfx("maps/zombie/fx_zmb_coast_light_floodlight");
+	level._effect["fx_zmb_coast_light_tinhat_cage"] = loadfx("maps/zombie/fx_zmb_coast_light_tinhat_cage");
+	level._effect["fx_zmb_coast_perk_dlight"] = loadfx("maps/zombie/fx_zmb_coast_perk_dlight");
+	level._effect["fx_light_bulb_incandescent_red"] = loadfx("env/light/fx_light_bulb_incandescent_red");
+	level._effect["fx_light_bulb_incandescent"] = loadfx("env/light/fx_light_bulb_incandescent");
+	level._effect["fx_zmb_coast_light_lantern"] = loadfx("maps/zombie/fx_zmb_coast_light_lantern");
+	level._effect["zombie_coast_snow_med"] = loadfx("maps/zombie/fx_zombie_coast_snow_med");
+	level._effect["fx_zmb_coast_blizzard_med"] = loadfx("maps/zombie/fx_zmb_coast_blizzard_med");
+	level._effect["fx_zmb_coast_snow_gust_xsm"] = loadfx("maps/zombie/fx_zmb_coast_snow_gust_xsm");
+	level._effect["fx_zmb_coast_snow_gust_sml"] = loadfx("maps/zombie/fx_zmb_coast_snow_gust_sml");
+	level._effect["fx_zmb_coast_snow_gust_med"] = loadfx("maps/zombie/fx_zmb_coast_snow_gust_med");
+	level._effect["fx_zmb_coast_snow_gust_vertical"] = loadfx("maps/zombie/fx_zmb_coast_snow_gust_vertical");
+	level._effect["fx_zmb_coast_snow_window"] = loadfx("maps/zombie/fx_zmb_coast_snow_window");
+	level._effect["fx_zmb_coast_snowfall_entrance_lrg"]	= loadfx("maps/zombie/fx_zmb_coast_snowfall_entrance_lrg");
+	level._effect["fx_zmb_coast_snowfall_ledge"] = loadfx("maps/zombie/fx_zmb_coast_snowfall_ledge");
+	level._effect["fx_zmb_coast_cloud_1"] = loadfx("maps/zombie/fx_zmb_coast_cloud_1");
+	level._effect["fx_zmb_coast_cloud_2"] = loadfx("maps/zombie/fx_zmb_coast_cloud_2");
+	level._effect["fx_zmb_coast_lightning_burst"] = loadfx("maps/zombie/fx_zmb_coast_lightning_burst");
+	level._effect["fx_zmb_coast_lightning_d_light"] = loadfx("maps/zombie/fx_zmb_coast_lightning_d_light");
+	level._effect["fx_lightning_flash_single_md"] = loadfx("env/weather/fx_lightning_flash_single_md");
+	level._effect["fx_zmb_coast_lightning_intro_xlg"] = loadfx("maps/zombie/fx_zmb_coast_lightning_intro_xlg");
+	level._effect["fx_zmb_coast_interior_fog"] = loadfx("maps/zombie/fx_zmb_coast_interior_fog");
+	level._effect["fx_zmb_coast_corridor_fog"] = loadfx("maps/zombie/fx_zmb_coast_corridor_fog");
+	level._effect["fx_zmb_coast_offshore_fog_1"] = loadfx("maps/zombie/fx_zmb_coast_offshore_fog_1");
+	level._effect["fx_zmb_coast_beam_submarine"] = loadfx("maps/zombie/fx_zmb_coast_beam_submarine");
+	level._effect["fx_zmb_coast_beam_vert_shaft"] = loadfx("maps/zombie/fx_zmb_coast_beam_vert_shaft");
+	level._effect["fx_zmb_coast_sacrifice_flash"] = loadfx("maps/zombie/fx_zmb_coast_sacrifice_flash");
+	level._effect["fx_zmb_coast_vault_door_glow"] = loadfx("maps/zombie/fx_zmb_coast_vault_door_glow");
+	level._effect["fx_zmb_coast_dest_fuse_box"] = loadfx("maps/zombie/fx_zmb_coast_dest_fuse_box");
+}
+manage_player_rain()
+{
+	while ( 1 )
+	{
+		time = RandomFloat( 10, 30 );
+		thread start_player_rain();
+		realwait( time );
+		level notify( "stop_player_rain" );
+		time = RandomFloat( 10, 30 );
+		realwait( time );
+	}
+}
+start_player_rain()
+{
+	level endon( "stop_player_rain" );
+	players = getlocalplayers();
+	while( 1 )
+	{
+		if ( isdefined( players[0] ) )
+		{
+			PlayFxOnTag( 0, level._effect["player_rain"], players[0], "tag_origin" );
+		}
+		realwait(0.3);
+	}
+	realwait(0.05);
+}
+coast_fog_triggers_init(localClientNum)
+{
+	lighthouse_array = GetEntArray(localClientNum, "lighthouseFog_interior", "targetname");
+	array_thread( lighthouse_array, ::fog_trigger, ::lighthouse_fog_change, 1);
+	shipfront_array = GetEntArray(localClientNum, "shipFrontDeck_interior", "targetname");
+	array_thread( shipfront_array, ::fog_trigger, ::shipfront_fog_change, 2 );
+	shipback_array = GetEntArray(localClientNum, "shipMedium_interior", "targetname");
+	array_thread( shipback_array, ::fog_trigger, ::shipback_fog_change, 3 );
+	shipback_array = GetEntArray(localClientNum, "shipIce_interior", "targetname");
+	array_thread( shipback_array, ::fog_trigger, ::shipIce_fog_change, 4);
+	exterior_array = GetEntArray(localClientNum, "exteriorfog_trigger", "targetname");
+	array_thread( exterior_array, ::fog_trigger, ::exterior_fog_change, 0);
+}
+fog_trigger(change_func, inside_val)
+{
+	while(1)
+	{
+		self waittill("trigger", who);
+		who.inside = inside_val;
+		if(who IsLocalPlayer())
+		{
+			self thread trigger_thread( who, change_func);
+		}
+	}
+}
+exterior_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	ent_player endon("entityshutdown");
+	if(level.blizzard == true)
+	{
+		start_dist = 120;
+		half_dist = 250;
+		half_height = 700.242;
+		base_height = 976.119;
+		fog_r = 0.137255;
+		fog_g = 0.192157;
+		fog_b = 0.239216;
+		fog_scale = 7;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 1;
+		setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+lighthouse_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	ent_player endon("entityshutdown");
+	if(level.blizzard == true)
+	{
+		start_dist = 251.982;
+		half_dist = 700;
+		half_height = 697.379;
+		base_height = 1000.6;
+		fog_r = 0.235294;
+		fog_g = 0.290196;
+		fog_b = 0.337255;
+		fog_scale = 10;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 0.97;
+		setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+shipfront_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	ent_player endon("entityshutdown");
+	if(level.blizzard == true)
+	{
+		start_dist = 80;
+		half_dist = 1700;
+		half_height = 697.379;
+		base_height = 1000.6;
+		fog_r = 0.235294;
+		fog_g = 0.290196;
+		fog_b = 0.337255;
+		fog_scale = 10;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 0.97;
+		setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+shipback_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	ent_player endon("entityshutdown");
+	if(level.blizzard == true)
+	{
+		start_dist = 251.982;
+		half_dist = 700;
+		half_height = 697.379;
+		base_height = 1000.6;
+		fog_r = 0.235294;
+		fog_g = 0.290196;
+		fog_b = 0.337255;
+		fog_scale = 10;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 0.97;
+		setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+shipIce_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	ent_player endon("entityshutdown");
+	if(level.blizzard == true)
+	{
+		start_dist = 220;
+		half_dist = 2300;
+		half_height = 697.379;
+		base_height = 1000.6;
+		fog_r = 0.235294;
+		fog_g = 0.290196;
+		fog_b = 0.337255;
+		fog_scale = 10;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 0.97;
+		setVolFogForClient(ent_player GetLocalClientNumber(), start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+coast_fog_blizzard(localClientNum, set,newEnt)
+{
+	if(!self isLocalPlayer() )
+	{
+		return;
+	}
+	if(!isDefined(self GetLocalClientNumber() ))
+	{
+		return;
+	}
+	if(localClientNum != 0)
+	{
+		return;
+	}
+	if(set)
+	{
+		level.blizzard = true;
+		if(IsDefined(self.inside) && self.inside == 1)
+		{
+			println("*** Client :(fog) blizzard started while inside lighthouse");
+			lighthouse_fog_change( self );
+		}
+		else if(IsDefined(self.inside) && self.inside == 2)
+		{
+			println("*** Client :(fog) blizzard started while inside shipfront");
+			shipfront_fog_change( self );
+		}
+		else if(IsDefined(self.inside) && self.inside == 3)
+		{
+			println("*** Client :(fog) blizzard started while inside shipback");
+			shipback_fog_change( self );
+		}
+		else if(IsDefined(self.inside) && self.inside == 4)
+		{
+			println("*** Client :(fog) blizzard started while inside shipback");
+			shipIce_fog_change( self );
+		}
+		else
+		{
+			println("*** Client :(fog) blizzard started while outside");
+			exterior_fog_change( self );
+		}
+	}
+	else
+	{
+		level.blizzard = false;
+		start_dist = 500;
+		half_dist = 1700;
+		half_height = 697.379;
+		base_height = 1000.6;
+		fog_r = 0.235294;
+		fog_g = 0.290196;
+		fog_b = 0.337255;
+		fog_scale = 10;
+		sun_col_r = 0.760784;
+		sun_col_g = 0.796079;
+		sun_col_b = 0.807843;
+		sun_dir_x = -0.862899;
+		sun_dir_y = 0.264579;
+		sun_dir_z = 0.430586;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 10;
+		max_fog_opacity = 1;
+		setVolFogForClient(self GetLocalClientNumber(), start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}

BO1/PC/ZM/clientscripts/zombie_cod5_factory_amb.csc

@@ -0,0 +1,299 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_ambientpackage;
+#include clientscripts\_music;
+#include clientscripts\_audio;
+main()
+{
+	declareAmbientRoom( "outside" );
+	declareAmbientPackage( "outside" );
+	setAmbientRoomReverb( "outside", "RV_ZOMBIES_OUTDOOR", 1, 1 );
+	setAmbientRoomContext( "outside", "ringoff_plr", "outdoor" );
+	setAmbientRoomTone( "outside", "ghost_wind", 1.5, 2 );
+	addAmbientElement( "outside", "ember", .1, .6, 50, 150 );
+	declareAmbientRoom( "int_small_room" );
+	declareAmbientPackage( "int_small_pkg" );
+	setAmbientRoomReverb ("int_small_room","RV_ZOMBIES_MEDIUM_ROOM", 1, 1 );
+	setAmbientRoomContext( "int_small_room", "ringoff_plr", "indoor" );
+	declareAmbientRoom( "int_large_room" );
+	declareAmbientPackage( "int_large_pkg" );
+	setAmbientRoomReverb ("int_large_room","RV_ZOMBIES_LARGE_ROOM", 1, 1 );
+	setAmbientRoomContext( "int_large_room", "ringoff_plr", "indoor" );
+	declareAmbientRoom( "darkroom" );
+	declareAmbientPackage( "darkroom" );
+	setAmbientRoomReverb ("darkroom","RV_ZOMBIES_MEDIUM_ROOM", 1, 1 );
+	setAmbientRoomContext( "darkroom", "ringoff_plr", "indoor" );
+	activateAmbientPackage( 0, "outside", 0 );
+	activateAmbientRoom( 0, "outside", 0 );
+	declareMusicState("SPLASH_SCREEN");
+	musicAlias("mx_splash_screen", 12);
+	musicwaittilldone();
+	declareMusicState("WAVE");
+	musicAliasloop("mus_zombie_wave_loop", 0, 4);
+	declareMusicState("EGG");
+	musicAlias("mus_factory_egg", 1 );
+	declareMusicState( "SILENCE" );
+	musicAlias("null", 1 );
+	thread clientscripts\_waw_zombiemode_radio::init();
+	thread start_lights();
+	thread teleport_pad_init(0);
+	thread teleport_pad_init(1);
+	thread teleport_pad_init(2);
+	thread teleport_2d();
+	thread pa_init(0);
+	thread pa_init(1);
+	thread pa_init(2);
+	thread pa_single_init();
+	thread pole_fx_audio_init(0);
+	thread pole_fx_audio_init(1);
+	thread pole_fx_audio_init(2);
+	thread homepad_loop();
+	thread power_audio_2d();
+	thread linkall_2d();
+}
+start_lights()
+{
+	level waittill ("pl1");
+	array_thread(getstructarray( "dyn_light", "targetname" ), ::light_sound);
+	array_thread(getstructarray( "switch_progress", "targetname" ), ::switch_progress_sound);
+	array_thread(getstructarray( "dyn_generator", "targetname" ), ::generator_sound);
+	array_thread(getstructarray( "dyn_breakers", "targetname" ), ::breakers_sound);
+}
+light_sound()
+{
+	if(isdefined( self ) )
+	{
+		playsound(0,"light_start", self.origin);
+		e1 = clientscripts\_audio::playloopat(0,"light",self.origin);
+	}
+}
+generator_sound()
+{
+	if(isdefined( self ) )
+	{
+		wait(3);
+		playsound(0, "switch_progress", self.origin);
+		playsound(0, "gen_start", self.origin);
+		g1 = clientscripts\_audio::playloopat(0,"gen_loop",self.origin, 1);
+	}
+}
+breakers_sound()
+{
+	if(isdefined( self ) )
+	{
+		playsound(0, "break_start", self.origin);
+		b1 = clientscripts\_audio::playloopat(0,"break_loop",self.origin, 2);
+	}
+}
+switch_progress_sound()
+{
+	if(isdefined( self.script_noteworthy ) )
+	{
+		if( self.script_noteworthy == "1" )
+			time = .5;
+		else if( self.script_noteworthy == "2" )
+			time = 1;
+		else if( self.script_noteworthy == "3" )
+			time = 1.5;
+		else if( self.script_noteworthy == "4" )
+			time = 2;
+		else if( self.script_noteworthy == "5" )
+			time = 2.5;
+		else
+			time = 0;
+		wait(time);
+		playsound(0, "switch_progress", self.origin);
+	}
+}
+homepad_loop()
+{
+	level waittill( "pap1" );
+	homepad = getstruct( "homepad_power_looper", "targetname" );
+	home_breaker = getstruct( "homepad_breaker", "targetname" );
+	if(isdefined( homepad ))
+	{
+		clientscripts\_audio::playloopat( 0, "homepad_power_loop", homepad.origin, 1 );
+	}
+	if(isdefined( home_breaker ) )
+	{
+		clientscripts\_audio::playloopat( 0, "break_arc", home_breaker.origin, 1 );
+	}
+}
+teleport_pad_init( pad )
+{
+	telepad = getstructarray( "telepad_" + pad, "targetname" );
+	telepad_loop = getstructarray( "telepad_" + pad + "_looper", "targetname" );
+	homepad = getstructarray( "homepad", "targetname" );
+	level waittill( "tp" + pad);
+	array_thread( telepad_loop, ::telepad_loop );
+	array_thread( telepad, ::teleportation_audio, pad );
+	array_thread( homepad, ::teleportation_audio, pad );
+}
+telepad_loop()
+{
+	clientscripts\_audio::playloopat( 0, "power_loop", self.origin, 1 );
+}
+teleportation_audio( pad )
+{
+	teleport_delay = 2;
+	while(1)
+	{
+		level waittill( "tpw" + pad );
+		if(IsDefined( self.script_sound ))
+		{
+			if(self.targetname == "telepad_" + pad)
+			{
+				playsound( 0, self.script_sound + "_warmup", self.origin );
+				realwait(teleport_delay);
+				playsound( 0, self.script_sound + "_cooldown", self.origin );
+			}
+			if(self.targetname == "homepad")
+			{
+				realwait(teleport_delay);
+				playsound( 0, self.script_sound + "_warmup", self.origin );
+				playsound( 0, self.script_sound + "_cooldown", self.origin );
+			}
+		}
+	}
+}
+pa_init( pad )
+{
+	pa_sys = getstructarray( "pa_system", "targetname" );
+	array_thread( pa_sys, ::pa_teleport, pad );
+	array_thread( pa_sys, ::pa_countdown, pad );
+	array_thread( pa_sys, ::pa_countdown_success, pad );
+}
+pa_single_init()
+{
+	pa_sys = getstructarray( "pa_system", "targetname" );
+	array_thread( pa_sys, ::pa_electric_trap, "bridge" );
+	array_thread( pa_sys, ::pa_electric_trap, "wuen" );
+	array_thread( pa_sys, ::pa_electric_trap, "warehouse" );
+	array_thread( pa_sys, ::pa_level_start );
+	array_thread( pa_sys, ::pa_power_on );
+}
+pa_countdown( pad )
+{
+	level endon( "scd" + pad );
+	while(1)
+	{
+		level waittill( "pac" + pad );
+		playsound( 0, "pa_buzz", self.origin );
+		self thread pa_play_dialog( "pa_audio_link_start" );
+		count = 30;
+		while ( count > 0 )
+		{
+			play = count == 20 || count == 15 || count <= 10;
+			if ( play )
+			{
+				playsound( 0, "pa_audio_link_" + count, self.origin );
+			}
+			playsound( 0, "clock_tick_1sec", (0,0,0) );
+			realwait( 1 );
+			count--;
+		}
+		playsound( 0, "pa_buzz", self.origin );
+		wait(1.2);
+		self thread pa_play_dialog( "pa_audio_link_fail" );
+	}
+	wait(1);
+}
+pa_countdown_success( pad )
+{
+	level waittill( "scd" + pad );
+	playsound( 0, "pa_buzz", self.origin );
+	wait(1.2);
+	self pa_play_dialog( "pa_audio_act_pad_" + pad );
+}
+pa_teleport( pad )
+{
+	while(1)
+	{
+		level waittill( "tpc" + pad );
+		wait(1);
+		playsound( 0, "pa_buzz", self.origin );
+		wait(1.2);
+		self pa_play_dialog( "pa_teleport_finish" );
+	}
+}
+pa_electric_trap( location )
+{
+	while(1)
+	{
+		level waittill( location );
+		playsound( 0, "pa_buzz", self.origin );
+		wait(1.2);
+		self thread pa_play_dialog( "pa_trap_inuse_" + location );
+		realwait(48.5);
+		playsound( 0, "pa_buzz", self.origin );
+		wait(1.2);
+		self thread pa_play_dialog( "pa_trap_active_" + location );
+	}
+}
+pa_play_dialog( alias )
+{
+	if( !IsDefined( self.pa_is_speaking ) )
+	{
+		self.pa_is_speaking = 0;
+	}
+	if( self.pa_is_speaking != 1 )
+	{
+		self.pa_is_speaking = 1;
+		self.pa_id = playsound( 0, alias, self.origin );
+		while( SoundPlaying( self.pa_id ) )
+		{
+			wait( 0.01 );
+		}
+		self.pa_is_speaking = 0;
+	}
+}
+teleport_2d()
+{
+	while(1)
+	{
+		level waittill( "t2d" );
+		playsound( 0, "teleport_2d_fnt", (0,0,0) );
+		playsound( 0, "teleport_2d_rear", (0,0,0) );
+	}
+}
+power_audio_2d()
+{
+	wait(2);
+	playsound( 0, "power_down_2d", (0,0,0) );
+	level waittill ("pl1");
+	playsound( 0, "power_up_2d", (0,0,0) );
+}
+linkall_2d()
+{
+	level waittill( "pap1" );
+	playsound( 0, "linkall_2d", (0,0,0) );
+}
+pole_fx_audio_init( pad )
+{
+	pole = getstructarray( "pole_fx_" + pad, "targetname" );
+	array_thread( pole, ::pole_fx_audio, pad );
+}
+pole_fx_audio( pad )
+{
+	level waittill( "scd" + pad );
+	while(1)
+	{
+		playfx(0, level._effect["zombie_elec_pole_terminal"], self.origin, anglestoforward( self.angles ) );
+		playsound(0,"pole_spark", self.origin );
+		realwait(randomintrange(2,7));
+	}
+}
+pa_level_start()
+{
+	wait(2);
+	playsound( 0, "pa_buzz", self.origin );
+	wait(1.2);
+	self pa_play_dialog( "pa_level_start" );
+}
+pa_power_on()
+{
+	level waittill ("pl1");
+	playsound( 0, "pa_buzz", self.origin );
+	wait(1.2);
+	self pa_play_dialog( "pa_power_on" );
+}

BO1/PC/ZM/clientscripts/zombie_cod5_factory_fx.csc

@@ -0,0 +1,561 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	clientscripts\createfx\zombie_cod5_factory_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	footsteps();
+	precache_scripted_fx();
+	precache_createfx_fx();
+	level thread trap_fx_monitor("warehouse_trap","warehouse");
+	level thread trap_fx_monitor("wuen_trap", "wuen");
+	level thread trap_fx_monitor("bridge_trap", "bridge");
+	disableFX = GetDvarInt( "disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread perk_wire_fx( "pw0", "pad_0_wire", "t01" );
+	level thread perk_wire_fx( "pw1", "pad_1_wire", "t11" );
+	level thread perk_wire_fx( "pw2", "pad_2_wire", "t21" );
+	level thread teleporter_map_light( "sm_light_tp_0", "t01" );
+	level thread teleporter_map_light( "sm_light_tp_1", "t11" );
+	level thread teleporter_map_light( "sm_light_tp_2", "t21" );
+	level.map_light_receiver_on = false;
+	level thread teleporter_map_light_receiver();
+	level thread dog_start_monitor();
+	level thread dog_stop_monitor();
+	level thread level_fog_init();
+	level thread light_model_swap( "smodel_light_electric", "lights_indlight_on" );
+	level thread light_model_swap( "smodel_light_electric_milit", "lights_milit_lamp_single_int_on" );
+	level thread light_model_swap( "smodel_light_electric_tinhatlamp",	"lights_tinhatlamp_on" );
+	level thread flytrap_lev_objects();
+}
+trap_fx_monitor(name,side)
+{
+	while(1)
+	{
+		level waittill(name);
+		fire_points = getstructarray(name,"targetname");
+		for(i=0;i<fire_points.size;i++)
+		{
+			fire_points[i] thread electric_trap_fx(name,side);
+		}
+	}
+}
+electric_trap_fx(name,side)
+{
+	ang = self.angles;
+	forward = anglestoforward(ang);
+	up = anglestoup(ang);
+	if ( isdefined( self.loopFX ) )
+	{
+		for(i = 0; i < self.loopFX.size; i ++)
+		{
+			self.loopFX[i] delete();
+		}
+		self.loopFX = [];
+	}
+	if(!isdefined(self.loopFX))
+	{
+		self.loopFX = [];
+	}
+	players = getlocalplayers();
+	for(i = 0; i < players.size; i++)
+	{
+		self.loopFX[i] = SpawnFx( i, level._effect["zapper"], self.origin, 0,forward,up);
+		triggerfx(self.loopFX[i]);
+	}
+	level waittill(side + "off");
+	for(i = 0; i < self.loopFX.size; i ++)
+	{
+		self.loopFX[i] delete();
+	}
+	self.loopFX = [];
+}
+footsteps()
+{
+	clientscripts\_utility::setFootstepEffect( "asphalt", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "brick", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "carpet", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "cloth", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "concrete", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "dirt", LoadFx( "bio/player/fx_footstep_sand" ) );
+	clientscripts\_utility::setFootstepEffect( "foliage", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "gravel", LoadFx( "bio/player/fx_footstep_sand" ) );
+	clientscripts\_utility::setFootstepEffect( "grass", LoadFx( "bio/player/fx_footstep_sand" ) );
+	clientscripts\_utility::setFootstepEffect( "metal", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "mud", LoadFx( "bio/player/fx_footstep_mud" ) );
+	clientscripts\_utility::setFootstepEffect( "paper", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "plaster", LoadFx( "bio/player/fx_footstep_dust" ) );
+	clientscripts\_utility::setFootstepEffect( "rock", LoadFx( "bio/player/fx_footstep_sand" ) );
+	clientscripts\_utility::setFootstepEffect( "sand", LoadFx( "bio/player/fx_footstep_sand" ) );
+	clientscripts\_utility::setFootstepEffect( "water", LoadFx( "bio/player/fx_footstep_water" ) );
+	clientscripts\_utility::setFootstepEffect( "wood", LoadFx( "bio/player/fx_footstep_dust" ) );
+}
+precache_scripted_fx()
+{
+	level._effect["zombie_grain"] = LoadFx( "misc/fx_zombie_grain_cloud" );
+	level._effect["electric_short_oneshot"] = loadfx("env/electrical/fx_elec_short_oneshot");
+	level._effect["switch_sparks"] = loadfx ("env/electrical/fx_elec_wire_spark_burst");
+	level._effect["zapper_fx"] = loadfx("misc/fx_zombie_zapper_powerbox_on");
+	level._effect["zapper_wall"] = loadfx("misc/fx_zombie_zapper_wall_control_on");
+	level._effect["elec_trail_one_shot"] = loadfx("misc/fx_zombie_elec_trail_oneshot");
+	level._effect["zapper_light_ready"] = loadfx("maps/zombie/fx_zombie_light_glow_green");
+	level._effect["zapper_light_notready"] = loadfx("maps/zombie/fx_zombie_light_glow_red");
+	level._effect["wire_sparks_oneshot"] = loadfx("env/electrical/fx_elec_wire_spark_dl_oneshot");
+	level._effect["wire_spark"] = loadfx("maps/zombie/fx_zombie_wire_spark");
+	level._effect["eye_glow"] = LoadFx( "misc/fx_zombie_eye_single" );
+	level._effect["powerup_on"] = loadfx( "misc/fx_zombie_powerup_on" );
+	level._effect["headshot"] = LoadFX( "impacts/fx_flesh_hit" );
+	level._effect["headshot_nochunks"] = LoadFX( "misc/fx_zombie_bloodsplat" );
+	level._effect["bloodspurt"] = LoadFX( "misc/fx_zombie_bloodspurt" );
+	level._effect["animscript_gib_fx"] = LoadFx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect["animscript_gibtrail_fx"] = LoadFx( "trail/fx_trail_blood_streak" );
+}
+precache_createfx_fx()
+{
+	level._effect["mp_battlesmoke_lg"] = loadfx("maps/mp_maps/fx_mp_battlesmoke_thin_lg");
+	level._effect["mp_fire_distant_150_150"] = loadfx("maps/mp_maps/fx_mp_fire_150x150_tall_distant");
+	level._effect["mp_fire_distant_150_600"] = loadfx("maps/mp_maps/fx_mp_fire_150x600_tall_distant");
+	level._effect["mp_fire_static_small_detail"] = loadfx("maps/mp_maps/fx_mp_fire_small_detail");
+	level._effect["mp_fire_window_smk_rt"] = loadfx("maps/mp_maps/fx_mp_fire_window_smk_rt");
+	level._effect["mp_fire_window_smk_lf"] = loadfx("maps/mp_maps/fx_mp_fire_window_smk_lf");
+	level._effect["mp_fire_window"] = loadfx("maps/mp_maps/fx_mp_fire_window");
+	level._effect["mp_fire_rubble_small"] = loadfx("maps/mp_maps/fx_mp_fire_rubble_small");
+	level._effect["mp_fire_rubble_md_smk"] = loadfx("maps/mp_maps/fx_mp_fire_rubble_md_smk");
+	level._effect["mp_fire_rubble_md_lowsmk"] = loadfx("maps/mp_maps/fx_mp_fire_rubble_md_lowsmk");
+	level._effect["mp_fire_rubble_detail_grp"] = loadfx("maps/mp_maps/fx_mp_fire_rubble_detail_grp");
+	level._effect["mp_ray_fire_thin"] = loadfx("maps/mp_maps/fx_mp_ray_fire_thin");
+	level._effect["mp_ray_fire_ribbon"] = loadfx("maps/mp_maps/fx_mp_ray_fire_ribbon");
+	level._effect["mp_fire_column_lg"] = loadfx("maps/mp_maps/fx_mp_fire_column_lg");
+	level._effect["mp_fire_furnace"] = loadfx("maps/mp_maps/fx_mp_fire_furnace");
+	level._effect["mp_ray_light_sm"] = loadfx("maps/mp_maps/fx_mp_ray_moon_sm");
+	level._effect["mp_ray_light_md"] = loadfx("maps/mp_maps/fx_mp_ray_moon_md");
+	level._effect["mp_ray_light_md"] = loadfx("maps/mp_maps/fx_mp_ray_moon_md");
+	level._effect["mp_ray_light_lg"] = loadfx("maps/mp_maps/fx_mp_ray_moon_lg");
+	level._effect["fx_mp_ray_fire_ribbon"] = loadfx("maps/mp_maps/fx_mp_ray_fire_ribbon");
+	level._effect["fx_mp_ray_fire_ribbon_med"] = loadfx("maps/mp_maps/fx_mp_ray_fire_ribbon_med");
+	level._effect["mp_ray_light_lg_1sd"] = loadfx("maps/mp_maps/fx_mp_ray_moon_lg_1sd");
+	level._effect["mp_smoke_fire_column"] = loadfx("maps/mp_maps/fx_mp_smoke_fire_column");
+	level._effect["mp_smoke_plume_lg"] = loadfx("maps/mp_maps/fx_mp_smoke_plume_lg");
+	level._effect["mp_smoke_hall"] = loadfx("maps/mp_maps/fx_mp_smoke_hall");
+	level._effect["mp_ash_and_embers"] = loadfx("maps/mp_maps/fx_mp_ash_falling_large");
+	level._effect["mp_light_glow_indoor_short"] = loadfx("maps/mp_maps/fx_mp_light_glow_indoor_short_loop");
+	level._effect["mp_light_glow_outdoor_long"] = loadfx("maps/mp_maps/fx_mp_light_glow_outdoor_long_loop");
+	level._effect["mp_insects_lantern"] = loadfx("maps/mp_maps/fx_mp_insects_lantern");
+	level._effect["fx_mp_fire_torch_noglow"] = loadfx("maps/mp_maps/fx_mp_fire_torch_noglow");
+	level._effect["a_embers_falling_sm"] = loadfx("env/fire/fx_embers_falling_sm");
+	level._effect["transporter_beam"] = loadfx("maps/zombie/fx_transporter_beam");
+	level._effect["transporter_pad_start"] = loadfx("maps/zombie/fx_transporter_pad_start");
+	level._effect["transporter_start"] = loadfx("maps/zombie/fx_transporter_start");
+	level._effect["transporter_ambient"] = loadfx("maps/zombie/fx_transporter_ambient");
+	level._effect["zombie_mainframe_link_all"] = loadfx("maps/zombie/fx_zombie_mainframe_link_all");
+	level._effect["zombie_mainframe_link_single"] = loadfx("maps/zombie/fx_zombie_mainframe_link_single");
+	level._effect["zombie_mainframe_linked"] = loadfx("maps/zombie/fx_zombie_mainframe_linked");
+	level._effect["zombie_mainframe_beam"] = loadfx("maps/zombie/fx_zombie_mainframe_beam");
+	level._effect["zombie_mainframe_flat"] = loadfx("maps/zombie/fx_zombie_mainframe_flat");
+	level._effect["zombie_mainframe_flat_start"] = loadfx("maps/zombie/fx_zombie_mainframe_flat_start");
+	level._effect["zombie_mainframe_beam_start"] = loadfx("maps/zombie/fx_zombie_mainframe_beam_start");
+	level._effect["zombie_flashback_american"] = loadfx("maps/zombie/fx_zombie_flashback_american");
+	level._effect["gasfire2"] = LoadFx("destructibles/fx_dest_fire_vert");
+	level._effect["mp_light_lamp"] = Loadfx("maps/mp_maps/fx_mp_light_lamp");
+	level._effect["zombie_difference"] = loadfx("maps/zombie/fx_zombie_difference");
+	level._effect["zombie_mainframe_steam"] = loadfx("maps/zombie/fx_zombie_mainframe_steam");
+	level._effect["zombie_heat_sink"] = loadfx("maps/zombie/fx_zombie_heat_sink");
+	level._effect["mp_smoke_stack"] = loadfx("maps/mp_maps/fx_mp_smoke_stack");
+	level._effect["mp_elec_spark_fast_random"] = loadfx("maps/mp_maps/fx_mp_elec_spark_fast_random");
+	level._effect["zombie_elec_gen_idle"] = loadfx("misc/fx_zombie_elec_gen_idle");
+	level._effect["zombie_moon_eclipse"] = loadfx("maps/zombie/fx_zombie_moon_eclipse");
+	level._effect["zombie_clock_hand"] = loadfx("maps/zombie/fx_zombie_clock_hand");
+	level._effect["zombie_elec_pole_terminal"] = loadfx("maps/zombie/fx_zombie_elec_pole_terminal");
+	level._effect["mp_elec_broken_light_1shot"] = loadfx("maps/mp_maps/fx_mp_elec_broken_light_1shot");
+	level._effect["mp_light_lamp_no_eo"] = loadfx("maps/mp_maps/fx_mp_light_lamp_no_eo");
+	level._effect["zombie_packapunch"] = loadfx("maps/zombie/fx_zombie_packapunch");
+	level._effect["zapper"] = loadfx("misc/fx_zombie_electric_trap");
+}
+perk_wire_fx(notify_wait, init_targetname, done_notify )
+{
+	level waittill(notify_wait);
+	players = getlocalplayers();
+	for(i = 0; i < players.size;i++)
+	{
+		players[i] thread perk_wire_fx_client( i, init_targetname, done_notify );
+	}
+}
+perk_wire_fx_client( clientnum, init_targetname, done_notify )
+{
+	println( "perk_wire_fx_client for client #"+clientnum );
+	targ = getstruct(init_targetname,"targetname");
+	if ( !IsDefined( targ ) )
+	{
+		return;
+	}
+	mover = Spawn( clientnum, targ.origin, "script_model" );
+	mover SetModel( "tag_origin" );
+	fx = PlayFxOnTag( clientnum, level._effect["wire_spark"], mover, "tag_origin" );
+	fake_ent = spawnfakeent(0);
+	setfakeentorg(0, fake_ent, mover.origin);
+	playsound( 0, "tele_spark_hit", mover.origin );
+	playloopsound( 0, fake_ent, "tele_spark_loop");
+	mover thread tele_spark_audio_mover(fake_ent);
+	while(isDefined(targ))
+	{
+		if(isDefined(targ.target))
+		{
+			println( "perk_wire_fx_client#"+clientnum+" next target: "+targ.target );
+			target = getstruct(targ.target,"targetname");
+			mover MoveTo( target.origin, 0.1 );
+			wait( 0.1 );
+			targ = target;
+		}
+		else
+		{
+			break;
+		}
+	}
+	level notify( "spark_done" );
+	mover Delete();
+	deletefakeent(0,fake_ent);
+	level notify( done_notify );
+}
+tele_spark_audio_mover(fake_ent)
+{
+	level endon( "spark_done" );
+	while (1)
+	{
+		realwait(0.05);
+		setfakeentorg(0, fake_ent, self.origin);
+	}
+}
+dog_start_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_start" );
+		start_dist = 229;
+		half_dist = 200;
+		half_height = 380;
+		base_height = 200;
+		fog_r = 0.0117647;
+		fog_g = 0.0156863;
+		fog_b = 0.0235294;
+		fog_scale = 5.5;
+		sun_col_r = 0.0313726;
+		sun_col_g = 0.0470588;
+		sun_col_b = 0.0823529;
+		sun_dir_x = -0.1761;
+		sun_dir_y = 0.689918;
+		sun_dir_z = 0.702141;
+		sun_start_ang = 0;
+		sun_stop_ang = 49.8549;
+		time = 7;
+		max_fog_opacity = 1;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+dog_stop_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_stop" );
+		start_dist = 440;
+		half_dist = 3200;
+		half_height = 225;
+		base_height = 64;
+		fog_r = 0.533;
+		fog_g = 0.717;
+		fog_b = 1;
+		fog_scale = 1;
+		sun_col_r = 0.0313726;
+		sun_col_g = 0.0470588;
+		sun_col_b = 0.0823529;
+		sun_dir_x = -0.1761;
+		sun_dir_y = 0.689918;
+		sun_dir_z = 0.702141;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 7;
+		max_fog_opacity = 1;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+level_fog_init()
+{
+	start_dist = 440;
+	half_dist = 3200;
+	half_height = 225;
+	base_height = 64;
+	fog_r = 0.219608;
+	fog_g = 0.403922;
+	fog_b = 0.686275;
+	fog_scale = 1;
+	sun_col_r = 0.0313726;
+	sun_col_g = 0.0470588;
+	sun_col_b = 0.0823529;
+	sun_dir_x = -0.1761;
+	sun_dir_y = 0.689918;
+	sun_dir_z = 0.702141;
+	sun_start_ang = 0;
+	sun_stop_ang = 0;
+	time = 0;
+	max_fog_opacity = 1;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+}
+light_model_swap( name, model )
+{
+	level waittill( "pl1" );
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, name, "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( model );
+		}
+	}
+}
+get_guide_struct_angles( ent )
+{
+	guide_structs = GetStructArray( "map_fx_guide_struct", "targetname" );
+	if ( guide_structs.size > 0 )
+	{
+		guide = guide_structs[0];
+		dist = DistanceSquared(ent.origin, guide.origin);
+		for ( i=1; i<guide_structs.size; i++ )
+		{
+			new_dist = DistanceSquared(ent.origin, guide_structs[i].origin);
+			if ( new_dist < dist )
+			{
+				guide = guide_structs[i];
+				dist = new_dist;
+			}
+		}
+		return guide.angles;
+	}
+	return (0, 0, 0);
+}
+teleporter_map_light( light_name, on_msg )
+{
+	level waittill( "pl1" );
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, light_name, "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( "zombie_zapper_cagelight_red" );
+			if(isDefined(lamps[i].fx))
+			{
+				lamps[i].fx delete();
+			}
+			angles = lamps[i].angles;
+			println( light_name + "- model angles : "+angles[0]+", "+angles[1]+", "+angles[2] );
+			angles = get_guide_struct_angles( lamps[i] );
+			lamps[i].fx = SpawnFx( p, level._effect["zapper_light_notready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+			TriggerFX(lamps[i].fx);
+		}
+	}
+	level waittill( on_msg );
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, light_name, "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( "zombie_zapper_cagelight_green" );
+			if(isDefined(lamps[i].fx))
+			{
+				lamps[i].fx delete();
+			}
+			angles = get_guide_struct_angles( lamps[i] );
+			lamps[i].fx = SpawnFx( p, level._effect["zapper_light_ready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+			TriggerFX(lamps[i].fx);
+		}
+	}
+}
+teleporter_map_light_receiver()
+{
+	level waittill( "pl1" );
+	level thread teleporter_map_light_receiver_flash();
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, "sm_light_tp_r", "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( "zombie_zapper_cagelight_red" );
+			if(isDefined(lamps[i].fx))
+			{
+				lamps[i].fx delete();
+			}
+			angles = get_guide_struct_angles( lamps[i] );
+			lamps[i].fx = SpawnFx( p, level._effect["zapper_light_notready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+			TriggerFX(lamps[i].fx);
+		}
+	}
+	level waittill( "pap1" );
+	wait( 1.5 );
+	level.map_light_receiver_on = true;
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, "sm_light_tp_r", "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( "zombie_zapper_cagelight_green" );
+			if(isDefined(lamps[i].fx))
+			{
+				lamps[i].fx delete();
+			}
+			angles = get_guide_struct_angles( lamps[i] );
+			lamps[i].fx = SpawnFx( p, level._effect["zapper_light_ready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+			TriggerFX(lamps[i].fx);
+		}
+	}
+}
+teleporter_map_light_receiver_flash()
+{
+	level endon( "pap1" );
+	level waittill( "TRf" );
+	level endon( "TRs" );
+	level thread teleporter_map_light_receiver_stop();
+	while (1)
+	{
+		players = getlocalplayers();
+		for ( p=0; p<players.size; p++ )
+		{
+			lamps = GetEntArray( p, "sm_light_tp_r", "targetname" );
+			for ( i=0; i<lamps.size; i++ )
+			{
+				lamps[i] SetModel( "zombie_zapper_cagelight_red" );
+				if(isDefined(lamps[i].fx))
+				{
+					lamps[i].fx delete();
+				}
+				angles = get_guide_struct_angles( lamps[i] );
+				lamps[i].fx = SpawnFx( p, level._effect["zapper_light_notready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+				TriggerFX(lamps[i].fx);
+			}
+		}
+		wait( 0.5 );
+		players = getlocalplayers();
+		for ( p=0; p<players.size; p++ )
+		{
+			lamps = GetEntArray( p, "sm_light_tp_r", "targetname" );
+			for ( i=0; i<lamps.size; i++ )
+			{
+				lamps[i] SetModel( "zombie_zapper_cagelight" );
+				if(isDefined(lamps[i].fx))
+				{
+					lamps[i].fx delete();
+				}
+			}
+		}
+		wait( 0.5 );
+	}
+}
+teleporter_map_light_receiver_stop()
+{
+	level endon( "pap1" );
+	level waittill( "TRs" );
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, "sm_light_tp_r", "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( "zombie_zapper_cagelight_red" );
+			if(isDefined(lamps[i].fx))
+			{
+				lamps[i].fx delete();
+			}
+			angles = get_guide_struct_angles( lamps[i] );
+			lamps[i].fx = SpawnFx( p, level._effect["zapper_light_notready"], lamps[i].origin, 0, AnglesToForward( angles ) );
+			TriggerFX(lamps[i].fx);
+		}
+	}
+	level thread teleporter_map_light_receiver_flash();
+}
+flytrap_lev_objects()
+{
+	level waittill( "ag1" );
+	i = 0;
+	hover_spots = [];
+	hover_spots[i] = GetStruct( "trap_ag_spot0", "targetname" );
+	while ( IsDefined( hover_spots[i].target ) )
+	{
+		hover_spots[i+1] = GetStruct( hover_spots[i].target, "targetname" );
+		i++;
+	}
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		floaters = GetEntArray( p, "ee_floaty_stuff", "targetname" );
+		for ( k=0; k<floaters.size; k++ )
+		{
+			floaters[k] thread anti_grav_move( p, hover_spots, k );
+		}
+	}
+}
+anti_grav_move( clientnum, spots, start_index )
+{
+	sound_ent = spawnfakeent(0);
+	setfakeentorg( 0, sound_ent, self.origin);
+	playloopsound( 0, sound_ent, "flytrap_loop");
+	self thread flytrap_audio_mover( sound_ent );
+	playfxontag (clientnum, level._effect["powerup_on"], self, "tag_origin");
+	playsound( 0, "flytrap_spin", self.origin );
+	self MoveTo( spots[start_index].origin, 4 );
+	wait( 4 );
+	stop_spinning = false;
+	index = start_index;
+	interval = 0.4;
+	z_increment = 0;
+	offset = 0;
+	while( !stop_spinning )
+	{
+		index++;
+		if ( index >= spots.size )
+		{
+			index = 0;
+		}
+		if ( index == start_index )
+		{
+			interval = interval - 0.1;
+			z_increment = 15;
+		}
+		if ( interval <= 0.1 && index == 0 )
+		{
+			stop_spinning = true;
+		}
+		offset = offset + z_increment;
+		self MoveTo( spots[index].origin+(0,0,offset), interval );
+		wait( interval );
+	}
+	end_spot = GetStruct( "trap_flyaway_spot", "targetname" );
+	self MoveTo( end_spot.origin+(RandomFloatRange(-100,100),0,0), 5 );
+	playsound( 0, "shoot_off", self.origin );
+	wait( 4.7 );
+	level notify( "delete_sound_ent" );
+	deletefakeent(0,sound_ent);
+	self delete();
+}
+flytrap_audio_mover( sound_ent )
+{
+	level endon( "delete_sound_ent" );
+	while (1)
+	{
+		realwait(0.05);
+		setfakeentorg( 0, sound_ent, self.origin);
+	}
+}
+

BO1/PC/ZM/clientscripts/zombie_cosmodrome_fx.csc

@@ -0,0 +1,260 @@
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	clientscripts\createfx\zombie_cosmodrome_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	footsteps();
+	precache_scripted_fx();
+	precache_util_fx();
+	precache_createfx_fx();
+	level thread trap_fx_monitor( "fire_trap_group1", "f1", "fire" );
+	level thread trap_fx_monitor( "fire_trap_group2", "f2", "fire" );
+	level thread trap_fx_monitor( "rocket_trap_group1", "r1", "fire" );
+	level thread trap_fx_monitor( "rocket_trap_group2", "r2", "fire" );
+	level thread level_fog_init();
+	disableFX = GetDvarInt( #"disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread clientscripts\_zombiemode::init_perk_machines_fx();
+	level thread lander_dock_lights_red();
+	level thread lander_dock_lights_green();
+}
+footsteps()
+{
+}
+precache_util_fx()
+{
+}
+level_fog_init()
+{
+	start_dist = 2013.52;
+	half_dist = 2400.04;
+	half_height = 640.408;
+	base_height = 805;
+	fog_r = 0.054902;
+	fog_g = 0.0862;
+	fog_b = 0.0862;
+	fog_scale = 3.29585;
+	sun_col_r = 0.341176;
+	sun_col_g = 0.368627;
+	sun_col_b = 0.388235;
+	sun_dir_x = -0.492497;
+	sun_dir_y = 0.584479;
+	sun_dir_z = 0.64485;
+	sun_start_ang = 14.832;
+	sun_stop_ang = 113.6;
+	time = 0;
+	max_fog_opacity = 1;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+}
+precache_scripted_fx()
+{
+	level._effect["zombie_power_switch"] = loadfx("maps/zombie/fx_zombie_power_switch");
+	level._effect["zapper_light_ready"] = loadfx("misc/fx_zombie_zapper_light_green");
+	level._effect["zapper_light_notready"] = loadfx("misc/fx_zombie_zapper_light_red");
+	level._effect["eye_glow"] = LoadFx( "misc/fx_zombie_eye_single" );
+	level._effect["zombie_eye_glow"] = level._effect["eye_glow"];
+	level._effect["monkey_eye_glow"] = LoadFx( "maps/zombie/fx_zmb_monkey_eyes" );
+	level._effect["fire_trap_cosmo"] = Loadfx("maps/zombie/fx_zmb_cosmo_trap_fire_md");
+	level._effect["zapper"] = loadfx("misc/fx_zombie_electric_trap");
+	level._effect["wire_spark"] = loadfx("maps/zombie/fx_zombie_wire_spark");
+	level._effect["soul_spark"] = loadfx("maps/zombie/fx_zmb_blackhole_zombie_death");
+	level._effect["headshot"] = LoadFX( "impacts/fx_flesh_hit" );
+	level._effect["headshot_nochunks"] = LoadFX( "misc/fx_zombie_bloodsplat" );
+	level._effect["bloodspurt"] = LoadFX( "misc/fx_zombie_bloodspurt" );
+	level._effect["animscript_gib_fx"] = LoadFx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect["animscript_gibtrail_fx"] = LoadFx( "trail/fx_trail_blood_streak" );
+	level._effect["lander_green_left"] = loadfx("maps/zombie/fx_zmb_csm_lander_pad_green_lft");
+	level._effect["lander_green_right"] = loadfx("maps/zombie/fx_zmb_csm_lander_pad_green");
+	level._effect["lander_red_left"] = loadfx("maps/zombie/fx_zmb_csm_lander_pad_red_lft");
+	level._effect["lander_red_right"] = loadfx("maps/zombie/fx_zmb_csm_lander_pad_red");
+	level._effect["lander_green"] = loadfx("maps/zombie/fx_zmb_csm_lander_post_green");
+	level._effect["lander_red"] = loadfx("maps/zombie/fx_zmb_csm_lander_post_red");
+	level._effect["rocket_blast_trail"] = loadfx("maps/zombie/fx_russian_rocket_exhaust_zmb");
+	level._effect["rocket_exp_1"] = loadfx("maps/zombie/fx_zmb_csm_rocket_exp");
+	level._effect["lunar_lander_thruster_bellow"] = loadfx("maps/zombie/fx_zombie_lunar_lander_thruster_bellow");
+	level._effect["lunar_lander_thruster_leg"] = loadfx("maps/zombie/fx_zombie_lunar_lander_thruster_leg");
+	level._effect["debris_trail"] = loadfx("maps/flashpoint/fx_exp_rocket_debris_trail");
+	level._effect["debris_hit"] = loadfx("maps/zombie/fx_zombie_ape_spawn_dust");
+	level._effect["mig_trail"] = loadfx("trail/fx_geotrail_jet_contrail");
+	level._effect["panel_green"] = LoadFX("maps/zombie/fx_zmb_csm_lander_panel_green");
+	level._effect["panel_red"] = LoadFX("maps/zombie/fx_zmb_csm_lander_panel_red");
+	level._effect[ "centrifuge_warning_light" ] = LoadFX( "maps/zombie/fx_zmb_light_centrifuge_top" );
+	level._effect[ "centrifuge_light_spark" ] = LoadFX( "maps/zombie/fx_zombie_centrifuge_spark" );
+	level._effect[ "centrifuge_start_steam" ] = LoadFX( "maps/zombie/fx_zmb_csm_centrifuge_steam_blst" );
+	level._effect["test_spin_fx"] = LoadFX( "env/light/fx_light_warning");
+	level._effect["monkey_spawn"] = loadfx("maps/zombie/fx_zombie_ape_spawn_dust");
+	level._effect["monkey_trail"] = loadfx("maps/zombie/fx_zombie_ape_spawn_trail");
+}
+precache_createfx_fx()
+{
+	level._effect["fx_tower_light_glow"] = loadfx("maps/flashpoint/fx_tower_light_glow");
+	level._effect["fx_zombie_rocket_trap_heat_glow"]	= loadfx("maps/zombie/fx_zombie_rocket_trap_heat_glow");
+	level._effect["fx_zombie_nuke_distant"] = loadfx("maps/zombie/fx_zombie_nuke_distant");
+	level._effect["fx_zmb_water_spray_leak_sm"] = loadfx("maps/zombie/fx_zmb_water_spray_leak_sm");
+	level._effect["fx_zmb_pipe_steam_md"] = loadfx("maps/zombie/fx_zmb_pipe_steam_md");
+	level._effect["fx_zmb_pipe_steam_md_runner"] = loadfx("maps/zombie/fx_zmb_pipe_steam_md_runner");
+	level._effect["fx_zmb_steam_hallway_md"] = loadfx("maps/zombie/fx_zmb_steam_hallway_md");
+	level._effect["fx_zmb_fog_lit_overhead_amber"] = loadfx("maps/zombie/fx_zmb_fog_lit_overhead_amber");
+	level._effect["fx_zmb_fog_thick_300x300"] = loadfx("maps/zombie/fx_zmb_fog_thick_300x300");
+	level._effect["fx_zmb_fog_thick_600x600"] = loadfx("maps/zombie/fx_zmb_fog_thick_600x600");
+	level._effect["fx_zmb_fog_thick_1200x1200"] = loadfx("maps/zombie/fx_zmb_fog_thick_1200x1200");
+	level._effect["fx_zmb_fog_dropdown"] = loadfx("maps/zombie/fx_zmb_fog_dropdown");
+	level._effect["fx_zmb_fog_interior_md"] = loadfx("maps/zombie/fx_zmb_fog_interior_md");
+	level._effect["fx_zmb_fog_lit_overhead"] = loadfx("maps/zombie/fx_zmb_fog_lit_overhead");
+	level._effect["fx_zmb_light_floodlight_bright"] = loadfx("maps/zombie/fx_zmb_light_floodlight_bright");
+	level._effect["fx_zmb_light_fluorescent_tube"] = loadfx("maps/zombie/fx_zmb_light_fluorescent_tube");
+	level._effect["fx_zmb_light_incandescent"] = loadfx("maps/zombie/fx_zmb_light_incandescent");
+	level._effect["fx_zmb_light_square_white"] = loadfx("maps/zombie/fx_zmb_light_square_white");
+	level._effect["fx_zmb_light_cagelight01"] = loadfx("maps/zombie/fx_zmb_csm_light_cagelight01");
+	level._effect["fx_zmb_light_flashlight"] = loadfx("maps/zombie/fx_zmb_light_flashlight");
+	level._effect["fx_light_dust_motes_xsm"] = loadfx("env/light/fx_light_dust_motes_xsm");
+	level._effect["fx_zmb_booster_condensation"] = loadfx("maps/zombie/fx_zmb_booster_condensation");
+	level._effect["fx_zmb_elec_spark_burst_loop"] = loadfx("maps/zombie/fx_zmb_elec_spark_burst_loop");
+	level._effect["fx_zmb_fire_sm_smolder"] = loadfx("maps/zombie/fx_zmb_fire_sm_smolder");
+	level._effect["fx_fire_line_xsm"] = loadfx("env/fire/fx_fire_line_xsm");
+	level._effect["fx_fire_line_sm"] = loadfx("env/fire/fx_fire_line_sm");
+	level._effect["fx_fire_wall_back_sm"] = loadfx("env/fire/fx_fire_wall_back_sm");
+	level._effect["fx_fire_destruction_lg"] = loadfx("env/fire/fx_fire_destruction_lg");
+	level._effect["fx_zmb_smk_linger_lit"] = loadfx("maps/zombie/fx_zmb_smk_linger_lit");
+	level._effect["fx_zmb_smk_plume_md_wht_wispy"] = loadfx("maps/zombie/fx_zmb_smk_plume_md_wht_wispy");
+	level._effect["fx_smk_fire_md_black"] = loadfx("env/smoke/fx_smk_fire_md_black");
+	level._effect["fx_ship_smk_fire_xlg_black"] = loadfx("maps/underwaterbase/fx_ship_smk_fire_xlg_black");
+	level._effect["fx_zmb_pad_light"] = loadfx("maps/zombie/fx_zmb_csm_rocket_pad_light");
+	level._effect["fx_zmb_gantry_coolant_md"] = loadfx("maps/zombie/fx_zmb_gantry_coolant_md");
+	level._effect["fx_elec_terminal"] = loadfx("maps/zombie/fx_zmb_elec_terminal_arc");
+	level._effect["fx_zmb_elec_terminal_bridge"] = loadfx("maps/zombie/fx_zmb_elec_terminal_bridge");
+	level._effect["fx_zmb_russian_rocket_smk"] = loadfx("maps/zombie/fx_zmb_russian_rocket_smk");
+}
+trap_fx_monitor( name, loc, trap_type )
+{
+	structs = getstructarray( name, "targetname" );
+	points = [];
+	for ( i=0; i<structs.size; i++ )
+	{
+		if ( !IsDefined(structs[i].model ) )
+		{
+			points[ points.size ] = structs[i];
+		}
+	}
+	while(1)
+	{
+		level waittill( loc+"1" );
+		for( i=0; i<points.size; i++ )
+		{
+			points[i] thread trap_play_fx( loc, trap_type );
+		}
+	}
+}
+trap_play_fx( loc, trap_type )
+{
+	ang = self.angles;
+	forward = anglestoforward( ang );
+	up = anglestoup( ang );
+	if ( isdefined( self.loopFX ) )
+	{
+		for( i=0; i<self.loopFX.size; i++ )
+		{
+			self.loopFX[i] delete();
+		}
+		self.loopFX = [];
+	}
+	if(!isdefined(self.loopFX))
+	{
+		self.loopFX = [];
+	}
+	fx_name = "";
+	if ( IsDefined( self.script_string ) )
+	{
+		fx_name = self.script_string;
+	}
+	else
+	{
+		switch( trap_type )
+		{
+			case "electric":
+			fx_name = "zapper";
+			break;
+			default:
+			case "fire":
+			fx_name = "fire_trap_cosmo";
+			break;
+		}
+	}
+	players = getlocalplayers();
+	for( i=0; i<players.size; i++ )
+	{
+		self.loopFX[i] = SpawnFx( i, level._effect[ fx_name ], self.origin, 0, forward, up );
+		triggerfx( self.loopFX[i] );
+	}
+	level waittill( loc + "0" );
+	for(i=0; i<self.loopFX.size; i++ )
+	{
+		self.loopFX[i] delete();
+	}
+	self.loopFX = [];
+}
+lander_dock_lights_red()
+{
+	while(1)
+	{
+		level waittill("L_R");
+		toggle_lander_lights("red");
+	}
+}
+lander_dock_lights_green()
+{
+	while(1)
+	{
+		level waittill("L_G");
+		toggle_lander_lights("green");
+	}
+}
+toggle_lander_lights(color)
+{
+	right_fx = level._effect["lander_green_right"];
+	left_fx = level._effect["lander_green_left"];
+	if(color == "red")
+	{
+		right_fx = level._effect["lander_red_right"];
+		left_fx = level._effect["lander_red_left"];
+	}
+	players = getlocalplayers();
+	for(x = 0;x<players.size;x++)
+	{
+		doors1 = getentarray(x,"centrifuge_zip_door","targetname");
+		doors2 = getentarray(x,"base_entry_zip_door","targetname");
+		doors3 = getentarray(x,"storage_zip_door","targetname");
+		doors4 = getentarray(x,"catwalk_zip_door","targetname");
+		doorsa = array_combine(doors1,doors2);
+		doorsb = array_combine(doors3,doors4);
+		all_doors = array_combine(doorsa,doorsb);
+		for(i=0;i<all_doors.size;i++)
+		{
+			if(all_doors[i].model == "p_zom_lander_doors_right")
+			{
+				if(isDefined(all_doors[i].fx))
+				{
+					StopFX(x,all_doors[i].fx);
+				}
+				all_doors[i].fx = PlayFxOnTag( x, right_fx, all_doors[i], "tag_origin" );
+			}
+			else if(all_doors[i].model == "p_zom_lander_doors_left")
+			{
+				if(isDefined(all_doors[i].fx))
+				{
+					StopFX(x,all_doors[i].fx);
+				}
+				all_doors[i].fx = PlayFxOnTag( x, left_fx , all_doors[i], "tag_origin" );
+			}
+		}
+	}
+}	
+
+

BO1/PC/ZM/clientscripts/zombie_moon_fx.csc

@@ -0,0 +1,476 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	precache_createfx_fx();
+	clientscripts\createfx\zombie_moon_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	footsteps();
+	disableFX = GetDvarInt( #"disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread clientscripts\_zombiemode::init_perk_machines_fx();
+	level thread fog_triggers_setup();
+	level thread airlock_fx_init();
+	level thread breach_receiving_fx();
+	level thread breach_labs_lower_fx();
+	level thread breach_labs_upper_fx();
+	level thread power_on_spinning_lights();
+}
+fog_triggers_setup()
+{
+	waitforclient(0);
+	wait(3);
+	players = getlocalplayers();
+	for(i = 0;i<players.size;i++)
+	{
+		level thread moon_fog_triggers_init(i);
+	}
+}
+footsteps()
+{
+}
+airlock_fx_init()
+{
+	waitforallclients();
+	players = getlocalplayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		players[i] thread airlock_fx(i);
+	}
+}
+airlock_fx(localClientNum)
+{
+	level waittill("power_on");
+	airlock_fx = GetEntArray(localClientNum, "airlock_jambs_fx", "targetname");
+	for(i = 0;i<airlock_fx.size;i++)
+	{
+		forwardVec = VectorNormalize( AnglesToForward(airlock_fx[i].angles) );
+		PlayFX(localClientNum, level._effect["airlock_fx"], airlock_fx[i].origin, forwardVec);
+	}
+}
+precache_scripted_fx()
+{
+	level._effect["switch_sparks"] = loadfx ("env/electrical/fx_elec_wire_spark_burst");
+	level._effect["zapper_light_ready"] = loadfx("misc/fx_zombie_zapper_light_green");
+	level._effect["zapper_light_notready"] = loadfx("misc/fx_zombie_zapper_light_red");
+	level._effect["wire_sparks_oneshot"] = loadfx("env/electrical/fx_elec_wire_spark_dl_oneshot");
+	level._effect["airlock_fx"] = loadfx("maps/zombie_moon/fx_moon_airlock_door_forcefield");
+	level._effect["eye_glow"] = LoadFx( "misc/fx_zombie_eye_single" );
+	level._effect["headshot"] = LoadFX( "impacts/fx_flesh_hit" );
+	level._effect["headshot_nochunks"] = LoadFX( "misc/fx_zombie_bloodsplat" );
+	level._effect["bloodspurt"] = LoadFX( "misc/fx_zombie_bloodspurt" );
+	level._effect["animscript_gib_fx"] = LoadFx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect["animscript_gibtrail_fx"] = LoadFx( "trail/fx_trail_blood_streak" );
+	level._effect["jump_pad_active"] = loadfx("maps/zombie_moon/fx_moon_jump_pad_on");
+	level._effect["glass_impact"] = loadfx("maps/zombie_moon/fx_moon_break_window" );
+	level._effect["fx_weak_sauce_trail"] = loadfx("maps/zombie_temple/fx_ztem_weak_sauce_trail");
+	level._effect["soul_swap_trail"] = loadfx("maps/zombie_moon/fx_moon_soul_swap");
+	level._effect["vrill_glow"] = LoadFX("maps/zombie_moon/fx_moon_vril_glow");
+	level._effect["rise_billow_lg"] = loadFx("maps/zombie_moon/fx_moon_body_dirt_billowing");
+	level._effect["rise_dust_lg"] = loadfx("maps/zombie_moon/fx_moon_body_dust_falling");
+	level._effect["rise_burst_lg"] = loadFx("maps/zombie_moon/fx_moon_hand_dirt_burst");
+	level._effect["exca_beam"]	= loadfx("maps/zombie_moon/fx_digger_light_beam");
+	level._effect["exca_blink"] = loadfx("maps/zombie_moon/fx_beacon_light_red");
+	level._effect["digger_treadfx_fwd"] = loadfx("maps/zombie_moon/fx_digger_treadfx_fwd");
+	level._effect["digger_treadfx_bkwd"] = loadfx("maps/zombie_moon/fx_digger_treadfx_rev");
+	level._effect["panel_on"] = loadfx("maps/zombie_moon/fx_moon_digger_panel_on");
+	level._effect["panel_off"] = loadfx("maps/zombie_moon/fx_moon_digger_panel_off");
+	level._effect["lght_marker_flare"] = Loadfx("maps/zombie/fx_zombie_coast_marker_fl");
+	level._effect["test_spin_fx"] = LoadFX( "env/light/fx_light_warning");
+	level._effect["blue_eyes"] = LoadFX( "misc/fx_zombie_eye_single_blue" );
+	level._effect["osc_button_glow"] = LoadFX("maps/zombie_moon/fx_moon_button_console_glow");
+}
+precache_createfx_fx()
+{
+	level._effect["fx_mp_fog_xsm_int"] = Loadfx("maps/mp_maps/fx_mp_fog_xsm_int");
+	level._effect["fx_moon_fog_spawn_closet"] = Loadfx("maps/zombie_moon/fx_moon_fog_spawn_closet");
+	level._effect["fx_zmb_fog_thick_300x300"] = Loadfx("maps/zombie/fx_zmb_fog_thick_300x300");
+	level._effect["fx_zmb_fog_thick_600x600"] = Loadfx("maps/zombie/fx_zmb_fog_thick_600x600");
+	level._effect["fx_moon_fog_canyon"] = Loadfx("maps/zombie_moon/fx_moon_fog_canyon");
+	level._effect["fx_moon_vent_wall_mist"] = Loadfx("maps/zombie_moon/fx_moon_vent_wall_mist");
+	level._effect["fx_dust_motes_blowing"] = Loadfx("env/debris/fx_dust_motes_blowing");
+	level._effect["fx_zmb_coast_sparks_int_runner"] = Loadfx("maps/zombie/fx_zmb_coast_sparks_int_runner");
+	level._effect["fx_moon_floodlight_narrow"] = Loadfx("maps/zombie_moon/fx_moon_floodlight_narrow");
+	level._effect["fx_moon_floodlight_wide"] = Loadfx("maps/zombie_moon/fx_moon_floodlight_wide");
+	level._effect["fx_moon_tube_light"] = Loadfx("maps/zombie_moon/fx_moon_tube_light");
+	level._effect["fx_moon_lamp_glow"] = Loadfx("maps/zombie_moon/fx_moon_lamp_glow");
+	level._effect["fx_moon_trap_switch_light_glow"] = Loadfx("maps/zombie_moon/fx_moon_trap_switch_light_glow");
+	level._effect["fx_moon_teleporter_beam"] = Loadfx("maps/zombie_moon/fx_moon_teleporter_beam");
+	level._effect["fx_moon_teleporter_start"] = Loadfx("maps/zombie_moon/fx_moon_teleporter_start");
+	level._effect["fx_moon_teleporter_pad_start"] = Loadfx("maps/zombie_moon/fx_moon_teleporter_pad_start");
+	level._effect["fx_moon_teleporter2_beam"] = Loadfx("maps/zombie_moon/fx_moon_teleporter2_beam");
+	level._effect["fx_moon_teleporter2_pad_start"] = Loadfx("maps/zombie_moon/fx_moon_teleporter2_pad_start");
+	level._effect["fx_moon_pyramid_egg"] = Loadfx("maps/zombie_moon/fx_moon_pyramid_egg");
+	level._effect["fx_moon_pyramid_drop"] = Loadfx("maps/zombie_moon/fx_moon_pyramid_drop");
+	level._effect["fx_moon_pyramid_opening"] = Loadfx("maps/zombie_moon/fx_moon_pyramid_opening");
+	level._effect["fx_moon_ceiling_cave_dust"] = Loadfx("maps/zombie_moon/fx_moon_ceiling_cave_dust");
+	level._effect["fx_moon_ceiling_cave_collapse"] = Loadfx("maps/zombie_moon/fx_moon_ceiling_cave_collapse");
+	level._effect["fx_moon_digger_dig_dust"] = Loadfx("maps/zombie_moon/fx_moon_digger_dig_dust");
+	level._effect["fx_moon_airlock_hatch_forcefield"] = Loadfx("maps/zombie_moon/fx_moon_airlock_hatch_forcefield");
+	level._effect["fx_moon_biodome_ceiling_breach"] = Loadfx("maps/zombie_moon/fx_moon_biodome_ceiling_breach");
+	level._effect["fx_moon_biodome_breach_dirt"] = Loadfx("maps/zombie_moon/fx_moon_biodome_breach_dirt");
+	level._effect["fx_moon_breach_debris_room_os"] = Loadfx("maps/zombie_moon/fx_moon_breach_debris_room_os");
+	level._effect["fx_moon_breach_debris_out_os"] = Loadfx("maps/zombie_moon/fx_moon_breach_debris_out_os");
+	level._effect["fx_earth_destroyed"] = Loadfx("maps/zombie_moon/fx_earth_destroyed");
+	level._effect["fx_quad_vent_break"] = LoadFX("maps/zombie/fx_zombie_crawler_vent_break");
+}
+power_on_spinning_lights()
+{
+	level waittill("power_on");
+}
+trap_fx_monitor( name, side, trap_type )
+{
+	while(1)
+	{
+		level waittill( name );
+		points = getstructarray( name, "targetname" );
+		for( i=0; i<points.size; i++ )
+		{
+			points[i] thread electric_trap_fx( name, side, trap_type );
+		}
+	}
+}
+breach_receiving_fx()
+{
+	level waittill( "Az1" );
+	clientscripts\_fx::activate_exploder(300);
+	if(level.power_on == false)
+	{
+		level waittill("ZPO");
+	}
+	level notify("sl0");
+}
+breach_labs_lower_fx()
+{
+	level waittill( "Az4a" );
+	clientscripts\_fx::activate_exploder(320);
+	if(level.power_on == false)
+	{
+		level waittill("ZPO");
+	}
+	level notify("sl5");
+	level notify("sl6");
+}
+breach_labs_upper_fx()
+{
+	level waittill( "Az4b" );
+	clientscripts\_fx::activate_exploder(340);
+	if(level.power_on == false)
+	{
+		level waittill("ZPO");
+	}
+	level notify("sl4");
+}
+electric_trap_fx( name, side, trap_type )
+{
+	ang = self.angles;
+	forward = anglestoforward( ang );
+	up = anglestoup( ang );
+	if ( isdefined( self.loopFX ) )
+	{
+		for( i=0; i<self.loopFX.size; i++ )
+		{
+			self.loopFX[i] delete();
+		}
+		self.loopFX = [];
+	}
+	if(!isdefined(self.loopFX))
+	{
+		self.loopFX = [];
+	}
+	players = getlocalplayers();
+	for( i=0; i<players.size; i++ )
+	{
+		switch( trap_type )
+		{
+			case "electric":
+			self.loopFX[i] = SpawnFx( i, level._effect["zapper"], self.origin, 0, forward, up );
+			break;
+			default:
+			case "fire":
+			self.loopFX[i] = SpawnFx( i, level._effect["fire_trap_med"], self.origin, 0, forward, up );
+			break;
+		}
+		triggerfx( self.loopFX[i] );
+	}
+	level waittill( side + "off" );
+	for(i=0; i<self.loopFX.size; i++ )
+	{
+		self.loopFX[i] delete();
+	}
+	self.loopFX = [];
+}
+moon_fog_triggers_init(localClientNum)
+{
+	exterior_array = GetEntArray(localClientNum, "zombie_moonExterior", "targetname");
+	array_thread( exterior_array, ::fog_trigger, ::moon_exterior_fog_change);
+	moon_interior_array = GetEntArray(localClientNum, "zombie_moonInterior", "targetname");
+	array_thread( moon_interior_array, ::fog_trigger, ::moon_interior_fog_change);
+	moon_biodome_array = GetEntArray(localClientNum, "zombie_moonBiodome", "targetname");
+	array_thread( moon_biodome_array, ::fog_trigger, ::moon_biodome_fog_change);
+	moon_biodome_array = GetEntArray(localClientNum, "zombie_moonTunnels", "targetname");
+	array_thread( moon_biodome_array, ::fog_trigger, ::moon_tunnels_fog_change);
+	nml_array = GetEntArray( localClientNum, "zombie_nmlVision", "targetname" );
+	if( IsDefined( nml_array ) && nml_array.size > 0 )
+	{
+		array_thread( nml_array, ::fog_trigger, ::moon_nml_fog_change );
+	}
+}
+fog_trigger(change_func)
+{
+	while(1)
+	{
+		self waittill("trigger", who);
+		if(who IsLocalPlayer())
+		{
+			self thread trigger_thread( who, change_func);
+		}
+	}
+}
+Moon_Exterior_Fog_Change(Ent_Player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	local_clientnum = ent_player GetLocalClientNumber();
+	ent_player endon("entityshutdown");
+	start_dist = 2098.71;
+	half_dist = 1740.12;
+	half_height = 1332.23;
+	base_height = 576.887;
+	fog_r = 0.0196078;
+	fog_g = 0.0235294;
+	fog_b = 0.0352941;
+	fog_scale = 4.1367;
+	sun_col_r = 0.247;
+	sun_col_g = 0.235;
+	sun_col_b = 0.160;
+	sun_dir_x = 0.796421;
+	sun_dir_y = 0.425854;
+	sun_dir_z = 0.429374;
+	sun_start_ang = 0;
+	sun_stop_ang = 55;
+	time = 0;
+	max_fog_opacity = 0.95;
+	setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	sunlight = 8;
+	sundirection = (-16.28, 56.06, 0);
+	suncolor = (0.655, 0.768, 0.817);
+	SetSavedDvar( "r_lightTweakSunLight", sunlight );
+	SetSavedDvar( "r_lightTweakSunDirection", sundirection );
+	SetSavedDvar("sm_sunSampleSizeNear", "1.8");
+	SetSavedDvar( "r_skyColorTemp", (6400));
+	if( !IsDefined( ent_player._previous_vision ) )
+	{
+		ent_player._previous_vision = "zme";
+	}
+	new_vision = "zme";
+	ent_player clientscripts\zombie_moon_fx::moon_vision_set( ent_player._previous_vision, new_vision, local_clientnum, self.script_int );
+	ent_player._previous_vision = "zme";
+}
+moon_interior_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	local_clientnum = ent_player GetLocalClientNumber();
+	ent_player endon("entityshutdown");
+	start_dist = 2098.71;
+	half_dist = 1740.12;
+	half_height = 1332.23;
+	base_height = 576.887;
+	fog_r = 0.0196078;
+	fog_g = 0.0235294;
+	fog_b = 0.0352941;
+	fog_scale = 4.1367;
+	sun_col_r = 0.247;
+	sun_col_g = 0.235;
+	sun_col_b = 0.160;
+	sun_dir_x = 0.796421;
+	sun_dir_y = 0.425854;
+	sun_dir_z = 0.429374;
+	sun_start_ang = 0;
+	sun_stop_ang = 55;
+	time = 0;
+	max_fog_opacity = 0.95;
+	setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	sunlight = 8;
+	sundirection = (-16.28, 56.06, 0);
+	suncolor = (0.655, 0.768, 0.817);
+	SetSavedDvar( "r_lightTweakSunLight", sunlight );
+	SetSavedDvar( "r_lightTweakSunDirection", sundirection );
+	SetSavedDvar("sm_sunSampleSizeNear", ".8");
+	SetSavedDvar( "r_skyColorTemp", (6400));
+	if( !IsDefined( ent_player._previous_vision ) )
+	{
+		ent_player._previous_vision = "zmi";
+	}
+	new_vision = "zmi";
+	ent_player clientscripts\zombie_moon_fx::moon_vision_set( ent_player._previous_vision, new_vision, local_clientnum, self.script_int );
+	ent_player._previous_vision = "zmi";
+}
+moon_biodome_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	local_clientnum = ent_player GetLocalClientNumber();
+	ent_player endon("entityshutdown");
+	start_dist = 65.3744;
+	half_dist = 860.241;
+	half_height = 35.1158;
+	base_height = 116.637;
+	fog_r = 0.117647;
+	fog_g = 0.137255;
+	fog_b = 0.101961;
+	fog_scale = 2.96282;
+	sun_col_r = 0.341176;
+	sun_col_g = 0.231373;
+	sun_col_b = 0.141176;
+	sun_dir_x = 0.315232;
+	sun_dir_y = 0.132689;
+	sun_dir_z = -0.939693;
+	sun_start_ang = 0;
+	sun_stop_ang = 44.4323;
+	time = 0;
+	max_fog_opacity = 0.836437;
+	setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	sunlight = 1.13;
+	sundirection = (-33.34, -38.56, 0);
+	SetSavedDvar( "r_lightTweakSunLight", sunlight );
+	SetSavedDvar( "r_lightTweakSunDirection", sundirection );
+	SetSavedDvar("sm_sunSampleSizeNear", "2");
+	SetSavedDvar( "r_sky_intensity_factor0", 2 );
+	SetSavedDvar( "r_sky_intensity_useDebugValues", true );
+	SetSavedDvar( "r_skyColorTemp", (3600));
+	SetSavedDvar( "r_lightGridEnableTweaks", 1 );
+	SetSavedDvar( "r_lightGridIntensity", 1.25 );
+	SetSavedDvar( "r_lightGridContrast", .45 );
+	if( !IsDefined( ent_player._previous_vision ) )
+	{
+		ent_player._previous_vision = "zmb";
+	}
+	new_vision = "zmb";
+	ent_player clientscripts\zombie_moon_fx::moon_vision_set( ent_player._previous_vision, new_vision, local_clientnum, self.script_int );
+	ent_player._previous_vision = "zmb";
+}
+moon_tunnels_fog_change(ent_player)
+{
+	if(!isDefined(ent_player))
+	{
+		return;
+	}
+	local_clientnum = ent_player GetLocalClientNumber();
+	ent_player endon("entityshutdown");
+	start_dist = 1413.46;
+	half_dist = 4300.81;
+	half_height = 32.2476;
+	base_height = -238.873;
+	fog_r = 0.192157;
+	fog_g = 0.137255;
+	fog_b = 0.180392;
+	fog_scale = 3.2984;
+	sun_col_r = 0.34902;
+	sun_col_g = 0.129412;
+	sun_col_b = 0.219608;
+	sun_dir_x = 0.954905;
+	sun_dir_y = 0.280395;
+	sun_dir_z = 0.0976461;
+	sun_start_ang = 0;
+	sun_stop_ang = 0;
+	time = 0;
+	max_fog_opacity = 0.22;
+	setVolFogForClient(ent_player GetLocalClientNumber(),start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	if( !IsDefined( ent_player._previous_vision ) )
+	{
+		ent_player._previous_vision = "zmt";
+	}
+	new_vision = "zmt";
+	ent_player clientscripts\zombie_moon_fx::moon_vision_set( ent_player._previous_vision, new_vision, local_clientnum, self.script_int );
+	ent_player._previous_vision = "zmt";
+	SetSavedDvar( "r_skyColorTemp", (6400));
+}
+moon_nml_fog_change( ent_player )
+{
+	if( !IsDefined( ent_player ) || (IsDefined( level._dte_done ) && level._dte_done) )
+	{
+		return;
+	}
+	local_clientnum = ent_player GetLocalClientNumber();
+	ent_player endon( "entityshutdown" );
+	start_dist = 1662.13;
+	half_dist = 18604.1;
+	half_height = 2618.86;
+	base_height = -5373.56;
+	fog_r = 0.764706;
+	fog_g = 0.505882;
+	fog_b = 0.231373;
+	fog_scale = 5;
+	sun_col_r = 0.8;
+	sun_col_g = 0.435294;
+	sun_col_b = 0.101961;
+	sun_dir_x = 0.796421;
+	sun_dir_y = 0.425854;
+	sun_dir_z = 0.429374;
+	sun_start_ang = 0;
+	sun_stop_ang = 45.87;
+	time = 0;
+	max_fog_opacity = 0.72;
+	sunlight = 5;
+	sundirection = (-16, 56.06, 0);
+	suncolor = (.924, .775, .651);
+	SetSavedDvar("sm_sunSampleSizeNear", "1.18");
+	if( !IsDefined( ent_player._previous_vision ) )
+	{
+		ent_player._previous_vision = "zmh";
+	}
+	new_vision = "zmh";
+	ent_player clientscripts\zombie_moon_fx::moon_vision_set( ent_player._previous_vision, new_vision, local_clientnum, self.script_int );
+	ent_player._previous_vision = "zmh";
+	setVolFogForClient(local_clientnum,start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	setClientDvar( "r_lightTweakSunLight", sunlight);
+	setClientDvar(	"r_lightTweakSunColor", suncolor);
+	setClientDvar(	"r_lightTweakSunDirection", sundirection);
+	SetSavedDvar( "r_skyColorTemp", (6400));
+}
+moon_vision_set( str_vision_old, str_vision_new, int_clientnum, int_trans )
+{
+	if( str_vision_old == str_vision_new )
+	{
+		return;
+	}
+	if( IsDefined( str_vision_old ) )
+	{
+		remove_vision = clientscripts\zombie_moon::moon_vision_set_choice( str_vision_old );
+		clientscripts\_zombiemode::zombie_vision_set_remove( remove_vision[0], 0, int_clientnum );
+	}
+	if( IsDefined( int_trans ) )
+	{
+		trans_time = int_trans;
+	}
+	else
+	{
+		trans_time = 0;
+	}
+	start_vision = clientscripts\zombie_moon::moon_vision_set_choice( str_vision_new );
+	clientscripts\_zombiemode::zombie_vision_set_apply( start_vision[0], start_vision[1], trans_time, int_clientnum );
+}
+

BO1/PC/ZM/clientscripts/zombie_temple_fx.csc

@@ -0,0 +1,330 @@
+
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	clientscripts\createfx\zombie_temple_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	precache_util_fx();
+	precache_createfx_fx();
+	precache_creek_fx();
+	precache_fx_prop_anims();
+	disableFX = GetDvarInt( "disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread cave_fog_off();
+	waitforclient( 0 );
+	wait( 3 );
+	players = GetLocalPlayers();
+	for ( i = 0; i < players.size; i++ )
+	{
+		play_fx_prop_anims( i );
+	}
+}
+precache_util_fx()
+{
+	level._effect["fx_trail_blood_streak"] = LoadFx("trail/fx_trail_blood_streak");
+	level._effect["eye_glow"] = LoadFx("misc/fx_zombie_eye_single");
+	level._effect["headshot"] = LoadFX("impacts/fx_flesh_hit");
+	level._effect["headshot_nochunks"] = LoadFX("misc/fx_zombie_bloodsplat");
+	level._effect["bloodspurt"] = LoadFX("misc/fx_zombie_bloodspurt");
+	level._effect["animscript_gib_fx"] = LoadFx("weapon/bullet/fx_flesh_gib_fatal_01");
+	level._effect["animscript_gibtrail_fx"] = LoadFx("trail/fx_trail_blood_streak");
+}
+precache_scripted_fx()
+{
+	level._effect["napalm_zombie_footstep"] = LoadFX( "maps/zombie_temple/fx_ztem_napalm_zombie_ground2" );
+	level._effect["punji_dust"] = LoadFX("maps/zombie_temple/fx_ztem_dust_punji");
+	level._effect["maze_wall_impact"] = LoadFX("maps/zombie_temple/fx_ztem_dust_impact_maze");
+	level._effect["maze_wall_raise"] = LoadFX("maps/zombie_temple/fx_ztem_dust_maze_raise");
+	level._effect[ "rag_doll_gib_mini" ] = loadfx( "maps/zombie_temple/fx_ztem_zombie_mini_squish" );
+}
+precache_createfx_fx()
+{
+	level._effect["fx_water_temple_geyser_ready"] = loadfx("env/water/fx_water_temple_geyser_ready");
+	level._effect["fx_fire_md"] = loadfx("env/fire/fx_fire_md");
+	level._effect["fx_fire_sm"] = loadfx("env/fire/fx_fire_sm");
+	level._effect["fx_zombie_light_dust_motes_md"] = loadfx("maps/zombie/fx_zombie_light_dust_motes_md");
+	level._effect["fx_mp_insects_lantern"] = loadfx("maps/zombie/fx_mp_insects_lantern");
+	level._effect["fx_dust_crumble_int_md"] = loadfx("env/dirt/fx_dust_crumble_int_md");
+	level._effect["fx_zmb_light_incandescent"] = loadfx("maps/zombie/fx_zmb_light_incandescent");
+	level._effect["fx_ztem_drips"] = loadfx("maps/zombie_temple/fx_ztem_drips");
+	level._effect["fx_ztem_waterfall_mist"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_mist");
+	level._effect["fx_ztem_waterfall_mist_trap"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_mist_trap");
+	level._effect["fx_ztem_leaves_falling"] = loadfx("maps/zombie_temple/fx_ztem_leaves_falling");
+	level._effect["fx_ztem_leaves_falling_wide"] = loadfx("maps/zombie_temple/fx_ztem_leaves_falling_wide");
+	level._effect["fx_ztem_dust_motes_blowing_lg"] = loadfx("maps/zombie_temple/fx_ztem_dust_motes_blowing_lg");
+	level._effect["fx_ztem_butterflies"] = loadfx("maps/zombie_temple/fx_ztem_butterflies");
+	level._effect["fx_ztem_tinhat_indoor"] = loadfx("maps/zombie_temple/fx_ztem_tinhat_indoor");
+	level._effect["fx_ztem_godray_md"] = loadfx("maps/zombie_temple/fx_ztem_godray_md");
+	level._effect["fx_ztem_fog_cave"] = loadfx("maps/zombie_temple/fx_ztem_fog_cave");
+	level._effect["fx_ztem_fog_cave_lg"] = loadfx("maps/zombie_temple/fx_ztem_fog_cave_lg");
+	level._effect["fx_ztem_fog_cave_drk"] = loadfx("maps/zombie_temple/fx_ztem_fog_cave_drk");
+	level._effect["fx_ztem_fog_cave_drk2"] = loadfx("maps/zombie_temple/fx_ztem_fog_cave_drk2");
+	level._effect["fx_ztem_spider"] = loadfx("maps/zombie_temple/fx_ztem_spider");
+	level._effect["fx_ztem_birds"] = loadfx("maps/zombie_temple/fx_ztem_birds");
+	level._effect["fx_ztem_fog_outdoor"] = loadfx("maps/zombie_temple/fx_ztem_fog_outdoor");
+	level._effect["fx_ztem_fog_tunnels"] = loadfx("maps/zombie_temple/fx_ztem_fog_tunnels");
+	level._effect["fx_ztem_fog_outdoor_lg"] = loadfx("maps/zombie_temple/fx_ztem_fog_outdoor_lg");
+	level._effect["fx_ztem_power_on"] = loadfx("maps/zombie_temple/fx_ztem_power_on");
+	level._effect["fx_ztem_power_onb"] = loadfx("maps/zombie_temple/fx_ztem_power_onb");
+	level._effect["fx_ztem_dragonflies_lg"] = loadfx("maps/zombie_temple/fx_ztem_dragonflies_lg");
+	level._effect["fx_slide_wake"] = LoadFX("bio/player/fx_player_water_swim_wake");
+	level._effect["fx_ztem_splash_3"] = LoadFX("maps/zombie_temple/fx_ztem_splash_3");
+	level._effect["fx_ztem_splash_4"] = LoadFX("maps/zombie_temple/fx_ztem_splash_4");
+	level._effect["fx_ztem_splash_exploder"] = LoadFX("maps/zombie_temple/fx_ztem_splash_exploder");
+	level._effect["fx_ztem_water_wake_exploder"] = LoadFX("maps/zombie_temple/fx_ztem_water_wake_exploder");
+	level._effect["fx_pow_cave_water_splash_sm"] = LoadFX("maps/pow/fx_pow_cave_water_splash_sm");
+	level._effect["fx_ztem_pap"] = LoadFX("maps/zombie_temple/fx_ztem_pap");
+	level._effect["fx_ztem_pap_splash"] = LoadFX("maps/zombie_temple/fx_ztem_pap_splash");
+	level._effect["fx_ztem_water_wake"] = loadfx("maps/zombie_temple/fx_ztem_water_wake");
+	level._effect["fx_ztem_waterfall_body"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_body");
+	level._effect["fx_ztem_waterfall_body_b"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_body_b");
+	level._effect["fx_ztem_waterfall_trap"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_trap");
+	level._effect["fx_ztem_waterfall_notrap"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_notrap");
+	level._effect["fx_ztem_waterfall_trap_h"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_trap_h");
+	level._effect["fx_ztem_waterfall_drips"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_drips");
+	level._effect["fx_ztem_waterfall_low"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_low");
+	level._effect["fx_ztem_waterslide_splashes"] = loadfx("maps/zombie_temple/fx_ztem_waterslide_splashes");
+	level._effect["fx_ztem_waterslide_splashes_wide"]	= loadfx("maps/zombie_temple/fx_ztem_waterslide_splashes_wide");
+	level._effect["fx_ztem_water_troff_power"] = loadfx("maps/zombie_temple/fx_ztem_water_troff_power");
+	level._effect["fx_ztem_pap_stairs_splashes"] = loadfx("maps/zombie_temple/fx_ztem_pap_stairs_splashes");
+	level._effect["fx_ztem_spikemore"] = loadfx("maps/zombie_temple/fx_ztem_spikemore");
+	level._effect["fx_ztem_geyser"] = loadfx("maps/zombie_temple/fx_ztem_geyser");
+	level._effect["fx_ztem_power_sparks"] = loadfx("maps/zombie_temple/fx_ztem_power_sparks");
+	level._effect["fx_elec_wire_spark_burst_xsm"] = loadfx("env/electrical/fx_elec_wire_spark_burst_xsm");
+	level._effect["fx_ztem_smk_ceiling_crawl"] = loadfx("maps/zombie_temple/fx_ztem_smk_ceiling_crawl");
+	level._effect["fx_ztem_dust_crumble_int_md_runner"]	= loadfx("maps/zombie_temple/fx_ztem_dust_crumble_int_md_runner");
+	level._effect["fx_ztem_ember_xsm"] = loadfx("maps/zombie_temple/fx_ztem_ember_xsm");
+	level._effect["fx_ztem_dust_door_round"] = loadfx("maps/zombie_temple/fx_ztem_dust_door_round");
+	level._effect["fx_ztem_dust_impact_maze"] = loadfx("maps/zombie_temple/fx_ztem_dust_impact_maze");
+	level._effect["fx_ztem_torch"] = loadfx("maps/zombie_temple/fx_ztem_torch");
+	level._effect["fx_ztem_geyser_bloom"] = loadfx("maps/zombie_temple/fx_ztem_geyser_bloom");
+	level._effect["fx_ztem_cart_stop"] = loadfx("maps/zombie_temple/fx_ztem_cart_stop");
+	level._effect["fx_mp_dlc4_roof_spill"] = loadfx("maps/mp_maps/fx_mp_dlc4_roof_spill");
+	level._effect["fx_ztem_fountain_splash"] = loadfx("maps/zombie_temple/fx_ztem_fountain_splash");
+	level._effect["fx_ztem_waterfall_distort"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_distort");
+	level._effect["fx_ztem_waterfall_bottom"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_bottom");
+	level._effect["fx_ztem_waterfall_b_bottom"] = loadfx("maps/zombie_temple/fx_ztem_waterfall_b_bottom");
+	level._effect["fx_ztem_cave_wtr_sld_bttm"] = loadfx("maps/zombie_temple/fx_ztem_cave_wtr_sld_bttm");
+	level._effect["fx_ztem_pap_warning"] = loadfx("maps/zombie_temple/fx_ztem_pap_warning");
+	level._effect["fx_ztem_dest_wood_barrier"] = LoadFX("maps/zombie_temple/fx_ztem_dest_wood_barrier");
+	level._effect["fx_ztem_fireflies"] = loadfx("maps/zombie_temple/fx_ztem_fireflies");
+	level._effect["fx_ztem_tunnel_water_gush"] = loadfx("maps/zombie_temple/fx_ztem_tunnel_water_gush");
+	level._effect["fx_ztem_tunnel_water_splash"] = loadfx("maps/zombie_temple/fx_ztem_tunnel_water_splash");
+	level._effect["fx_ztem_leak_gas_jet"] = loadfx("maps/zombie_temple/fx_ztem_leak_gas_jet");
+	level._effect["fx_ztem_leak_flame_jet_runner"] = loadfx("maps/zombie_temple/fx_ztem_leak_flame_jet_runner");
+	level._effect["fx_ztem_leak_water_jet_runner"] = loadfx("maps/zombie_temple/fx_ztem_leak_water_jet_runner");
+	level._effect["fx_ztem_moon_eclipse"] = loadfx("maps/zombie_temple/fx_ztem_moon_eclipse");
+	level._effect["fx_ztem_star_shooting_runner"] = loadfx("maps/zombie_temple/fx_ztem_star_shooting_runner");
+	level._effect["fx_ztem_crystal_hit_success"] = loadfx("maps/zombie_temple/fx_ztem_crystal_hit_success");
+	level._effect["fx_ztem_crystal_hit_fail"] = loadfx("maps/zombie_temple/fx_ztem_crystal_hit_fail");
+	level._effect["fx_ztem_crystal_pause_success"] = loadfx("maps/zombie_temple/fx_ztem_crystal_pause_success");
+	level._effect["fx_ztem_crystal_pause_fail"] = loadfx("maps/zombie_temple/fx_ztem_crystal_pause_fail");
+	level._effect["fx_hot_sauce_trail"] = loadfx("maps/zombie_temple/fx_ztem_hot_sauce_trail");
+	level._effect["fx_weak_sauce_trail"] = loadfx("maps/zombie_temple/fx_ztem_weak_sauce_trail");
+	level._effect["fx_ztem_meteor_shrink"] = loadfx("maps/zombie_temple/fx_ztem_meteor_shrink");
+	level._effect["fx_ztem_hot_sauce_end"] = loadfx("maps/zombie_temple/fx_ztem_hot_sauce_end");
+	level._effect["fx_ztem_weak_sauce_end"] = loadfx("maps/zombie_temple/fx_ztem_weak_sauce_end");
+	level._effect["fx_ztem_meteorite_trail_big"] = loadfx("maps/zombie_temple/fx_ztem_meteorite_trail_big");
+	level._effect["fx_ztem_meteorite_tell"] = loadfx("maps/zombie_temple/fx_ztem_meteorite_tell");
+	level._effect["fx_ztem_meteorite_shimmer"] = loadfx("maps/zombie_temple/fx_ztem_meteorite_shimmer");
+	level._effect["fx_ztem_meteorite_small_shimmer"]	= loadfx("maps/zombie_temple/fx_ztem_meteorite_small_shimmer");
+	level._effect["fx_ztem_meteorite_big_shimmer"] = loadfx("maps/zombie_temple/fx_ztem_meteorite_big_shimmer");
+	level._effect["fx_crystal_water_trail"] = LoadFX("maps/zombie_temple/fx_ztem_meteorite_splash_run");
+}
+	precache_creek_fx(){
+	level._effect["fx_insect_swarm_lg"] = loadfx("maps/creek/fx_insect_swarm_lg");
+	level._effect["fx_insect_swarm"] = loadfx("maps/creek/fx_insect_swarm");
+	level._effect["fx_ztem_smoke_thick_indoor"] = loadfx("maps/zombie_temple/fx_ztem_smoke_thick_indoor");
+}
+dog_start_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_start" );
+		start_dist = 0;
+		half_dist = 302.622;
+		half_height = 306.395;
+		base_height = 344.622;
+		fog_r = 0.501961;
+		fog_g = 0.286275;
+		fog_b = 0.227451;
+		fog_scale = 1.20564;
+		sun_col_r = 0.243137;
+		sun_col_g = 0.270588;
+		sun_col_b = 0.270588;
+		sun_dir_x = 0.291692;
+		sun_dir_y = -0.720765;
+		sun_dir_z = 0.628819;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 7;
+		max_fog_opacity = 0.65;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+dog_stop_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_stop" );
+		level.tweakfile = true;
+		start_dist = 888.062;
+		half_dist = 2714.58;
+		half_height = 2242.93;
+		base_height = 4338.83;
+		fog_r = 0.266667;
+		fog_g = 0.14902;
+		fog_b = 0.0705882;
+		fog_scale = 2.84504;
+		sun_col_r = 0.901961;
+		sun_col_g = 0.427451;
+		sun_col_b = 0.156863;
+		sun_dir_x = -0.854245;
+		sun_dir_y = 0.337731;
+		sun_dir_z = 0.395225;
+		sun_start_ang = 20;
+		sun_stop_ang = 99;
+		time = 3;
+		max_fog_opacity = 0.734468;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);;
+	}
+}
+eclipse_fog_on()
+{
+	start_dist = 151.622;
+	half_dist = 136.124;
+	half_height = 392.122;
+	base_height = -626.865;
+	fog_r = 0.168627;
+	fog_g = 0.168627;
+	fog_b = 0.168627;
+	fog_scale = 4.39448;
+	sun_col_r = 0.376471;
+	sun_col_g = 0.470588;
+	sun_col_b = 0.513726;
+	sun_dir_x = -0.893398;
+	sun_dir_y = -0.219239;
+	sun_dir_z = 0.392141;
+	sun_start_ang = 11.4807;
+	sun_stop_ang = 88.2474;
+	time = 0;
+	max_fog_opacity = 0.593122;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+}
+cave_fog_on()
+{
+	level.tweakfile = true;
+	start_dist = 683.36;
+	half_dist = 2628.91;
+	half_height = 1277.89;
+	base_height = 1540.34;
+	fog_r = 0.345098;
+	fog_g = 0.47451;
+	fog_b = 0.541176;
+	fog_scale = 4.0001;
+	sun_col_r = 0.301961;
+	sun_col_g = 0.380392;
+	sun_col_b = 0.427451;
+	sun_dir_x = -0.889059;
+	sun_dir_y = 0.215284;
+	sun_dir_z = 0.404014;
+	sun_start_ang = 11.4807;
+	sun_stop_ang = 37.3192;
+	time = 5;
+	max_fog_opacity = 0.369586;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	SetDvar("r_exposureTweak", "1");
+	SetDvar("r_exposureValue", "1.15");
+}
+cave_fog_off()
+{
+	level.tweakfile = true;
+	start_dist = 151.081;
+	half_dist = 526.479;
+	half_height = 461.457;
+	base_height = -652.425;
+	fog_r = 0.0784314;
+	fog_g = 0.129412;
+	fog_b = 0.105882;
+	fog_scale = 5.97369;
+	sun_col_r = 1;
+	sun_col_g = 0.380392;
+	sun_col_b = 0.109804;
+	sun_dir_x = -0.893398;
+	sun_dir_y = -0.219239;
+	sun_dir_z = 0.392141;
+	sun_start_ang = 11.4807;
+	sun_stop_ang = 94.7812;
+	time = 5;
+	max_fog_opacity = 0.604413;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+	SetDvar("r_exposureTweak", "1");
+	SetDvar("r_exposureValue", "1.1");
+}
+#using_animtree("fxanim_props");
+precache_fx_prop_anims()
+{
+	level._fxanims = [];
+	level._fxanims[ "fxanim_gp_chain01" ] = %fxanim_gp_chain01_anim;
+	level._fxanims[ "fxanim_gp_chain02" ] = %fxanim_gp_chain02_anim;
+	level._fxanims[ "fxanim_gp_chain03" ] = %fxanim_gp_chain03_anim;
+	level.waits = [];
+	level.speeds = [];
+	for ( i = 0; i < 32; i++ )
+	{
+		level.waits[ i ] = RandomFloatRange( 0.1, 1.5 );
+		level.speeds[ i ] = RandomFloatRange( 0.75, 1.4 );
+	}
+}
+play_fx_prop_anims(localClientNum)
+{
+	fxanim_chains = GetEntArray( localClientNum, "fxanim_gp_chain01_mod", "targetname" );
+	for ( i = 0; i < fxanim_chains.size; i++ )
+	{
+		fxanim_chains[i] thread fxanim_think( localClientNum, "fxanim_gp_chain01", 1, 1 );
+	}
+	fxanim_chains = GetEntArray( localClientNum, "fxanim_gp_chain02_mod", "targetname" );
+	for ( i = 0; i < fxanim_chains.size; i++ )
+	{
+		fxanim_chains[i] thread fxanim_think( localClientNum, "fxanim_gp_chain02", 1, 1 );
+	}
+	fxanim_chains = GetEntArray( localClientNum, "fxanim_gp_chain03_mod", "targetname" );
+	for ( i = 0; i < fxanim_chains.size; i++ )
+	{
+		fxanim_chains[i] thread fxanim_think( localClientNum, "fxanim_gp_chain03", level.waits[i], 1 );
+	}
+}
+fxanim_think( localClientNum, anim_index, wait_time, speed )
+{
+	self endon( "death" );
+	self endon( "entityshutdown" );
+	self endon( "delete" );
+	self waittill_dobj( localClientNum );
+	self UseAnimTree( #animtree );
+	wait( wait_time );
+	self SetAnim( level._fxanims[ anim_index ], 1.0, 0.0, speed );
+}
+waittill_dobj(localClientNum)
+{
+	while( isdefined( self ) && !(self hasdobj(localClientNum)) )
+	{
+		wait(0.01);
+	}
+}
+
+

BO1/PC/ZM/clientscripts/zombie_theater.csc

@@ -0,0 +1,371 @@
+#include clientscripts\_utility;
+#include clientscripts\_music;
+#include clientscripts\_zombiemode_weapons;
+main()
+{
+	level._uses_crossbow = true;
+	include_weapons();
+	clientscripts\_zombiemode::main();
+	clientscripts\zombie_theater_teleporter::main();
+	clientscripts\zombie_theater_fx::main();
+	thread clientscripts\zombie_theater_amb::main();
+	clientscripts\_zombiemode_deathcard::init();
+	init_theater_box_indicator();
+	thread waitforclient(0);
+	level._power_on = false;
+	level thread theatre_ZPO_listener();
+	level thread eeroom_visionset_init();
+	level thread theater_light_model_swap_init();
+	register_zombie_types();
+}
+register_zombie_types()
+{
+	character\clientscripts\c_ger_honorguard_zt::register_gibs();
+	character\clientscripts\c_zom_quad::register_gibs();
+}
+include_weapons()
+{
+	include_weapon( "frag_grenade_zm", false );
+	include_weapon( "claymore_zm", false );
+	include_weapon( "m1911_zm", false );
+	include_weapon( "m1911_upgraded_zm", false );
+	include_weapon( "python_zm" );
+	include_weapon( "python_upgraded_zm", false );
+	include_weapon( "cz75_zm" );
+	include_weapon( "cz75_upgraded_zm", false );
+	include_weapon( "m14_zm", false );
+	include_weapon( "m14_upgraded_zm", false );
+	include_weapon( "m16_zm", false );
+	include_weapon( "m16_gl_upgraded_zm", false );
+	include_weapon( "g11_lps_zm" );
+	include_weapon( "g11_lps_upgraded_zm", false );
+	include_weapon( "famas_zm" );
+	include_weapon( "famas_upgraded_zm", false );
+	include_weapon( "ak74u_zm", false );
+	include_weapon( "ak74u_upgraded_zm", false );
+	include_weapon( "mp5k_zm", false );
+	include_weapon( "mp5k_upgraded_zm", false );
+	include_weapon( "mp40_zm", false );
+	include_weapon( "mp40_upgraded_zm", false );
+	include_weapon( "mpl_zm", false );
+	include_weapon( "mpl_upgraded_zm", false );
+	include_weapon( "pm63_zm", false );
+	include_weapon( "pm63_upgraded_zm", false );
+	include_weapon( "spectre_zm" );
+	include_weapon( "spectre_upgraded_zm", false );
+	include_weapon( "cz75dw_zm" );
+	include_weapon( "cz75dw_upgraded_zm", false );
+	include_weapon( "ithaca_zm", false );
+	include_weapon( "ithaca_upgraded_zm", false );
+	include_weapon( "rottweil72_zm", false );
+	include_weapon( "rottweil72_upgraded_zm", false );
+	include_weapon( "spas_zm" );
+	include_weapon( "spas_upgraded_zm", false );
+	include_weapon( "hs10_zm" );
+	include_weapon( "hs10_upgraded_zm", false );
+	include_weapon( "aug_acog_zm" );
+	include_weapon( "aug_acog_mk_upgraded_zm", false );
+	include_weapon( "galil_zm" );
+	include_weapon( "galil_upgraded_zm", false );
+	include_weapon( "commando_zm" );
+	include_weapon( "commando_upgraded_zm", false );
+	include_weapon( "fnfal_zm" );
+	include_weapon( "fnfal_upgraded_zm", false );
+	include_weapon( "dragunov_zm" );
+	include_weapon( "dragunov_upgraded_zm", false );
+	include_weapon( "l96a1_zm" );
+	include_weapon( "l96a1_upgraded_zm", false );
+	include_weapon( "rpk_zm" );
+	include_weapon( "rpk_upgraded_zm", false );
+	include_weapon( "hk21_zm" );
+	include_weapon( "hk21_upgraded_zm", false );
+	include_weapon( "m72_law_zm" );
+	include_weapon( "m72_law_upgraded_zm", false );
+	include_weapon( "china_lake_zm" );
+	include_weapon( "china_lake_upgraded_zm", false );
+	include_weapon( "zombie_cymbal_monkey" );
+	include_weapon( "ray_gun_zm" );
+	include_weapon( "ray_gun_upgraded_zm", false );
+	include_weapon( "thundergun_zm", true );
+	include_weapon( "thundergun_upgraded_zm", false );
+	include_weapon( "crossbow_explosive_zm" );
+	include_weapon( "crossbow_explosive_upgraded_zm", false );
+}
+init_theater_box_indicator()
+{
+	level._custom_box_monitor = ::theater_box_monitor;
+	level._box_locations = array(	"start_chest_loc",
+	"foyer_chest_loc",
+	"crematorium_chest_loc",
+	"alleyway_chest_loc",
+	"control_chest_loc",
+	"stage_chest_loc",
+	"dressing_chest_loc",
+	"dining_chest_loc",
+	"theater_chest_loc");
+	OnPlayerConnect_Callback( ::init_board_lights);
+}
+init_board_lights(clientNum)
+{
+	structs = getstructarray("magic_box_loc_light", "targetname");
+	for(j = 0; j <structs.size; j ++)
+	{
+		s = structs[j];
+		if(!IsDefined(s.lights))
+		{
+			s.lights = [];
+		}
+		if(IsDefined(s.lights[clientNum]))
+		{
+			if(IsDefined(s.lights[clientNum].fx))
+			{
+				s.lights[clientNum].fx Delete();
+				s.lights[clientNum].fx = undefined;
+			}
+			s.lights[clientNum] Delete();
+			s.lights[clientNum] = undefined;
+		}
+		s.lights[clientNum] = spawn( clientNum, s.origin, "script_model");
+		s.lights[clientNum].angles = s.angles;
+		s.lights[clientNum] setmodel("zombie_zapper_cagelight");
+	}
+}
+get_lights(clientNum, name)
+{
+	structs = getstructarray(name, "script_noteworthy");
+	lights = [];
+	for(i = 0; i < structs.size; i ++)
+	{
+		lights[lights.size] = structs[i].lights[clientNum];
+	}
+	return(lights);
+}
+turn_off_all_box_lights(clientNum)
+{
+	level notify("kill_box_light_threads_"+clientNum);
+	for(i = 0; i < level._box_locations.size; i ++)
+	{
+		turn_off_light(clientNum, i);
+	}
+}
+flash_lights(clientNum,period)
+{
+	level notify("kill_box_light_threads_"+clientNum);
+	level endon("kill_box_light_threads_"+clientNum);
+	while(1)
+	{
+		wait(period);
+		for(i = 0; i < level._box_locations.size; i ++)
+		{
+			turn_light_green(clientNum, i);
+		}
+		wait(period);
+		for(i = 0; i < level._box_locations.size; i ++)
+		{
+			turn_off_light(clientNum, i, true);
+		}
+	}
+}
+turn_light_red(clientNum,light_num, play_fx)
+{
+	if(light_num == level._BOX_INDICATOR_NO_LIGHTS)
+	{
+		return;
+	}
+	name = level._box_locations[light_num];
+	lights = get_lights(clientNum, name);
+	for(i = 0; i < lights.size; i ++)
+	{
+		if (isDefined(lights[i].fx))
+		{
+			lights[i].fx Delete();
+			lights[i].fx = undefined;
+		}
+		if(IsDefined(play_fx) && play_fx)
+		{
+			lights[i] setmodel("zombie_zapper_cagelight_red");
+			lights[i].fx = spawn( clientNum, ( lights[i].origin[0], lights[i].origin[1], lights[i].origin[2] - 10 ) , "script_model");
+			lights[i].fx setmodel("tag_origin");
+			lights[i].fx.angles = lights[i].angles;
+			playfxontag(clientNum, level._effect["boxlight_light_ready"],lights[i].fx,"tag_origin");
+		}
+		else
+		{
+			lights[i] setmodel("zombie_zapper_cagelight_red");
+		}
+	}
+}
+turn_light_green(clientNum,light_num, play_fx)
+{
+	if(light_num == level._BOX_INDICATOR_NO_LIGHTS)
+	{
+		return;
+	}
+	name = level._box_locations[light_num];
+	lights = get_lights(clientNum, name);
+	for(i = 0; i < lights.size; i ++)
+	{
+		if (isDefined(lights[i].fx))
+		{
+			lights[i].fx Delete();
+			lights[i].fx = undefined;
+		}
+		if(IsDefined(play_fx) && play_fx)
+		{
+			lights[i] setmodel("zombie_zapper_cagelight_green");
+			lights[i].fx = spawn( clientNum, ( lights[i].origin[0], lights[i].origin[1], lights[i].origin[2] - 10 ) , "script_model");
+			lights[i].fx setmodel("tag_origin");
+			lights[i].fx.angles = lights[i].angles;
+			playfxontag(clientNum, level._effect["boxlight_light_ready"],lights[i].fx,"tag_origin");
+		}
+		else
+		{
+			lights[i] setmodel("zombie_zapper_cagelight_green");
+		}
+	}
+}
+turn_off_light(clientNum,light_num,dont_kill_threads)
+{
+	if(!IsDefined(dont_kill_threads))
+	{
+		level notify("kill_box_light_threads_"+clientNum);
+	}
+	if(light_num == level._BOX_INDICATOR_NO_LIGHTS)
+	{
+		return;
+	}
+	name = level._box_locations[light_num];
+	lights = get_lights(clientNum, name);
+	for(i=0;i<lights.size;i++)
+	{
+		if (isDefined(lights[i].fx))
+		{
+			lights[i].fx Delete();
+			lights[i].fx = undefined;
+		}
+		lights[i] setmodel("zombie_zapper_cagelight");
+	}
+}
+theater_box_monitor(clientNum, state, oldState)
+{
+	s = Int(state);
+	if(s == level._BOX_INDICATOR_NO_LIGHTS)
+	{
+		turn_off_all_box_lights(clientNum);
+	}
+	else if(s == level._BOX_INDICATOR_FLASH_LIGHTS_MOVING)
+	{
+		level thread flash_lights(clientNum,0.25);
+	}
+	else if(s == level._BOX_INDICATOR_FLASH_LIGHTS_FIRE_SALE)
+	{
+		level thread flash_lights(clientNum,0.3);
+	}
+	else
+	{
+		if(s < 0 || s > level._box_locations.size)
+		{
+			return;
+		}
+		level notify("kill_box_light_threads_"+clientNum);
+		turn_off_all_box_lights(clientNum);
+		level._box_indicator = s;
+		if(level._power_on)
+		{
+			turn_light_green(clientNum,level._box_indicator, true);
+		}
+	}
+}
+theatre_ZPO_listener()
+{
+	while(1)
+	{
+		level waittill("ZPO");
+		level._power_on = true;
+		if(level._box_indicator != level._BOX_INDICATOR_NO_LIGHTS)
+		{
+			for(i = 0; i < getlocalplayers().size; i ++)
+			{
+				theater_box_monitor(i, level._box_indicator);
+			}
+		}
+		level notify("threeprimaries_on");
+		level notify( "pl1" );
+	}
+}
+eeroom_visionset_init()
+{
+	eeroom_visionset_triggers = GetEntArray( 0, "trigger_eeroom_visionset", "targetname" );
+	if( !IsDefined( eeroom_visionset_triggers ) )
+	{
+		return;
+	}
+	array_thread( eeroom_visionset_triggers, ::theater_player_in_eeroom );
+}
+theater_player_in_eeroom()
+{
+	while( 1 )
+	{
+		self waittill( "trigger", ent_player );
+		if(ent_player IsLocalPlayer())
+		{
+			self thread trigger_thread( ent_player, ::eeroom_visionset_on, ::eeroom_visionset_off );
+		}
+	}
+}
+eeroom_visionset_on( ent_player )
+{
+	if( !IsDefined( self.script_string ) )
+	{
+		return;
+	}
+	wait( 1.0 );
+	switch( self.script_string )
+	{
+		case "asylum_room":
+		VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater_eroom_asylum", 0 );
+		break;
+		case "pentagon_room":
+		VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater_erooms_pentagon", 0 );
+		break;
+		case "girls_new_room":
+		VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater_eroom_girlnew", 0 );
+		break;
+		case "girls_old_room":
+		VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater_eroom_girlold", 0 );
+		break;
+		default:
+		VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater", 0 );
+		break;
+	}
+}
+eeroom_visionset_off( ent_player )
+{
+	VisionSetNaked( ent_player GetLocalClientNumber(), "zombie_theater", 0 );
+}
+theater_light_model_swap_init()
+{
+	players = getlocalplayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		theater_light_models = GetEntArray( i, "model_lights_on", "targetname" );
+		if( IsDefined( theater_light_models ) && theater_light_models.size > 0 )
+		{
+			array_thread( theater_light_models, ::theater_light_model_swap );
+		}
+	}
+}
+theater_light_model_swap()
+{
+	level waittill( "ZPO" );
+	if( self.model == "lights_hang_single" )
+	{
+		self SetModel( "lights_hang_single_on_nonflkr" );
+	}
+	else if( self.model == "zombie_zapper_cagelight" )
+	{
+		self SetModel( "zombie_zapper_cagelight_on" );
+	}
+}
+
+

BO1/PC/ZM/clientscripts/zombie_theater_fx.csc

@@ -0,0 +1,322 @@
+#include clientscripts\_utility;
+#include clientscripts\_fx;
+#include clientscripts\_music;
+main()
+{
+	clientscripts\createfx\zombie_theater_fx::main();
+	clientscripts\_fx::reportNumEffects();
+	precache_util_fx();
+	precache_createfx_fx();
+	disableFX = GetDvarInt( #"disable_fx" );
+	if( !IsDefined( disableFX ) || disableFX <= 0 )
+	{
+		precache_scripted_fx();
+	}
+	level thread clientscripts\_zombiemode::init_perk_machines_fx();
+	level thread trap_fx_monitor( "dressing_room_trap", "e4", "electric" );
+	level thread trap_fx_monitor( "vip_room_trap", "e2", "electric" );
+	level thread trap_fx_monitor( "foyer_room_trap", "e1", "electric" );
+	level thread trap_fx_monitor( "control_room_trap", "e3", "electric" );
+	level thread trap_fx_monitor( "crematorium_room_trap", "f1", "fire" );
+	level thread light_model_swap( "smodel_light_electric", "lights_indlight_on" );
+	level thread dog_start_monitor();
+	level thread dog_stop_monitor();
+	level thread level_fog_init();
+	level thread projector_screen_fx();
+}
+precache_util_fx()
+{
+}
+precache_scripted_fx()
+{
+	level._effect["eye_glow"] = LoadFx( "misc/fx_zombie_eye_single" );
+	level._effect["boxlight_light_ready"] = loadfx("maps/zombie/fx_zombie_theater_lightboard_green");
+	level._effect["boxlight_light_notready"] = loadfx("maps/zombie/fx_zombie_theater_lightboard_red");
+	level._effect["theater_projector_beam"] = loadfx("maps/zombie/fx_zombie_theater_projector_beam");
+	level._effect[ "projector_screen_0" ] = LoadFX( "maps/zombie/fx_zombie_theater_screen_0" );
+	level._effect[ "ps1" ] = LoadFX( "maps/zombie/fx_zombie_theater_screen_1" );
+	level._effect[ "ps2" ] = LoadFX( "maps/zombie/fx_zombie_theater_screen_2" );
+	level._effect[ "ps3" ] = LoadFX( "maps/zombie/fx_zombie_theater_screen_3" );
+	level._effect["headshot"] = LoadFX( "impacts/fx_flesh_hit" );
+	level._effect["headshot_nochunks"] = LoadFX( "misc/fx_zombie_bloodsplat" );
+	level._effect["bloodspurt"] = LoadFX( "misc/fx_zombie_bloodspurt" );
+	level._effect["animscript_gib_fx"] = LoadFx( "weapon/bullet/fx_flesh_gib_fatal_01" );
+	level._effect["animscript_gibtrail_fx"] = LoadFx( "trail/fx_trail_blood_streak" );
+}
+precache_createfx_fx()
+{
+	level._effect["fx_mp_smoke_thick_indoor"] = loadfx("maps/zombie/fx_mp_smoke_thick_indoor");
+	level._effect["fx_mp_smoke_amb_indoor_misty"] = loadfx("maps/zombie/fx_zombie_theater_smoke_amb_indoor");
+	level._effect["fx_smoke_smolder_md_gry"] = loadfx("maps/zombie/fx_smoke_smolder_md_gry");
+	level._effect["fx_smk_smolder_sm"] = loadfx("env/smoke/fx_smk_smolder_sm");
+	level._effect["fx_mp_smoke_crater"] = loadfx("maps/zombie/fx_mp_smoke_crater");
+	level._effect["fx_mp_smoke_sm_slow"] = loadfx("maps/zombie/fx_mp_smoke_sm_slow");
+	level._effect["fx_mp_fog_low"] = loadfx("maps/zombie/fx_mp_fog_low");
+	level._effect["fx_zombie_theater_fog_lg"] = loadfx("maps/zombie/fx_zombie_theater_fog_lg");
+	level._effect["fx_zombie_theater_fog_xlg"] = loadfx("maps/zombie/fx_zombie_theater_fog_xlg");
+	level._effect["fx_mp_fog_ground_md"] = loadfx("maps/mp_maps/fx_mp_fog_ground_md");
+	level._effect["fx_water_drip_light_long"] = loadfx("env/water/fx_water_drip_light_long");
+	level._effect["fx_water_drip_light_short"] = loadfx("env/water/fx_water_drip_light_short");
+	level._effect["fx_mp_ray_light_sm"] = loadfx("env/light/fx_light_godray_overcast_sm");
+	level._effect["fx_mp_ray_light_md"] = loadfx("maps/zombie/fx_mp_ray_overcast_md");
+	level._effect["fx_mp_ray_light_lg"] = loadfx("maps/zombie/fx_light_godray_overcast_lg");
+	level._effect["fx_mp_dust_motes"] = loadfx("maps/zombie/fx_mp_ray_motes_lg");
+	level._effect["fx_mp_dust_mote_pcloud_sm"] = loadfx("maps/zombie/fx_mp_dust_mote_pcloud_sm");
+	level._effect["fx_mp_dust_mote_pcloud_md"] = loadfx("maps/zombie/fx_mp_dust_mote_pcloud_md");
+	level._effect["fx_mp_pipe_steam"] = loadfx("env/smoke/fx_pipe_steam_md");
+	level._effect["fx_mp_pipe_steam_random"] = loadfx("maps/zombie/fx_mp_pipe_steam_random");
+	level._effect["fx_mp_fumes_vent_sm_int"] = loadfx("maps/mp_maps/fx_mp_fumes_vent_sm_int");
+	level._effect["fx_mp_fumes_vent_xsm_int"] = loadfx("maps/mp_maps/fx_mp_fumes_vent_xsm_int");
+	level._effect["fx_mp_elec_spark_burst_xsm_thin_runner"] = loadfx("maps/mp_maps/fx_mp_elec_spark_burst_xsm_thin_runner");
+	level._effect["fx_mp_elec_spark_burst_sm_runner"] = loadfx("maps/mp_maps/fx_mp_elec_spark_burst_sm_runner");
+	level._effect["fx_mp_light_lamp"] = loadfx("maps/zombie/fx_mp_light_lamp");
+	level._effect["fx_mp_light_corona_cool"] = loadfx("maps/zombie/fx_mp_light_corona_cool");
+	level._effect["fx_mp_light_corona_bulb_ceiling"] = loadfx("maps/zombie/fx_mp_light_corona_bulb_ceiling");
+	level._effect["fx_pent_tinhat_light"] = LoadFX("maps/pentagon/fx_pent_tinhat_light");
+	level._effect["fx_light_floodlight_bright"] = loadfx("maps/zombie/fx_zombie_light_floodlight_bright");
+	level._effect["fx_light_overhead_sm_amber"] = loadfx("maps/zombie/fx_zombie_overhead_sm_amber");
+	level._effect["fx_light_overhead_sm_amber_flkr"] = loadfx("maps/zombie/fx_zombie_overhead_sm_amber_flkr");
+	level._effect["fx_light_overhead_sm_blue"] = loadfx("maps/zombie/fx_zombie_overhead_sm_blu");
+	level._effect["fx_light_overhead_sm_blue_flkr"] = loadfx("maps/zombie/fx_zombie_overhead_sm_blu_flkr");
+	level._effect["fx_mp_birds_circling"] = loadfx("maps/zombie/fx_mp_birds_circling");
+	level._effect["fx_mp_insects_lantern"] = loadfx("maps/zombie/fx_mp_insects_lantern");
+	level._effect["fx_insects_swarm_md_light"] = loadfx("bio/insects/fx_insects_swarm_md_light");
+	level._effect["fx_insects_maggots"] = loadfx("bio/insects/fx_insects_maggots_sm");
+	level._effect["fx_insects_moths_light_source"] = loadfx("bio/insects/fx_insects_moths_light_source");
+	level._effect["fx_insects_moths_light_source_md"] = loadfx("bio/insects/fx_insects_moths_light_source_md");
+	level._effect["fx_pent_movie_projector"] = LoadFX("maps/pentagon/fx_pent_movie_projector");
+	level._effect["fx_zombie_light_theater_blue"] = LoadFX("maps/zombie/fx_zombie_light_theater_blue");
+	level._effect["fx_zombie_light_theater_green"] = LoadFX("maps/zombie/fx_zombie_light_theater_green");
+	level._effect["fx_zombie_theater_projector_beam"] = loadfx("maps/zombie/fx_zombie_theater_projector_beam");
+	level._effect["fx_zombie_theater_projector_screen"] = loadfx("maps/zombie/fx_zombie_theater_projection_screen");
+	level._effect["fx_transporter_beam"] = loadfx("maps/zombie/fx_transporter_beam");
+	level._effect["fx_transporter_pad_start"] = loadfx("maps/zombie/fx_transporter_pad_start");
+	level._effect["fx_transporter_start"] = loadfx("maps/zombie/fx_transporter_start");
+	level._effect["fx_transporter_ambient"] = loadfx("maps/zombie/fx_transporter_ambient");
+	level._effect["fx_zombie_mainframe_beam"] = loadfx("maps/zombie/fx_zombie_mainframe_beam");
+	level._effect["fx_zombie_mainframe_flat"] = loadfx("maps/zombie/fx_zombie_mainframe_flat");
+	level._effect["fx_zombie_mainframe_flat_start"] = loadfx("maps/zombie/fx_zombie_mainframe_flat_start");
+	level._effect["fx_zombie_mainframe_beam_start"] = loadfx("maps/zombie/fx_zombie_mainframe_beam_start");
+	level._effect["fx_zombie_flashback_theater"] = loadfx("maps/zombie/fx_zombie_flashback_theater");
+	level._effect["fx_zombie_difference"] = loadfx("maps/zombie/fx_zombie_difference");
+	level._effect["fx_zombie_heat_sink"] = loadfx("maps/zombie/fx_zombie_heat_sink");
+	level._effect["zapper"] = loadfx("misc/fx_zombie_electric_trap");
+	level._effect["switch_sparks"]	= loadfx("env/electrical/fx_elec_wire_spark_burst");
+	level._effect["fire_trap_med"] = loadfx("maps/zombie/fx_zombie_fire_trap_med");
+	level._effect["fx_quad_roof_break"] = loadfx("maps/zombie/fx_zombie_crawler_roof_break");
+	level._effect["fx_quad_roof_break_theater"] = loadfx("maps/zombie/fx_zombie_crawler_roof_theater");
+	level._effect["fx_quad_dust_roof"] = loadfx("maps/zombie/fx_zombie_crawler_dust_roof");
+}
+trap_fx_monitor( name, loc, trap_type )
+{
+	structs = getstructarray( name, "targetname" );
+	points = [];
+	for ( i=0; i<structs.size; i++ )
+	{
+		if ( !IsDefined(structs[i].model ) )
+		{
+			points[ points.size ] = structs[i];
+		}
+	}
+	while(1)
+	{
+		level waittill( loc+"1" );
+		for( i=0; i<points.size; i++ )
+		{
+			points[i] thread trap_play_fx( loc, trap_type );
+		}
+	}
+}
+trap_play_fx( loc, trap_type )
+{
+	ang = self.angles;
+	forward = anglestoforward( ang );
+	up = anglestoup( ang );
+	if ( isdefined( self.loopFX ) )
+	{
+		for( i=0; i<self.loopFX.size; i++ )
+		{
+			self.loopFX[i] delete();
+		}
+		self.loopFX = [];
+	}
+	if(!isdefined(self.loopFX))
+	{
+		self.loopFX = [];
+	}
+	fx_name = "";
+	if ( IsDefined( self.script_string ) )
+	{
+		fx_name = self.script_string;
+	}
+	else
+	{
+		switch( trap_type )
+		{
+			case "electric":
+			fx_name = "zapper";
+			break;
+			default:
+			case "fire":
+			fx_name = "fire_trap_med";
+			break;
+		}
+	}
+	players = getlocalplayers();
+	for( i=0; i<players.size; i++ )
+	{
+		self.loopFX[i] = SpawnFx( i, level._effect[ fx_name ], self.origin, 0, forward, up );
+		triggerfx( self.loopFX[i] );
+	}
+	level waittill( loc + "0" );
+	for(i=0; i<self.loopFX.size; i++ )
+	{
+		self.loopFX[i] delete();
+	}
+	self.loopFX = [];
+}
+light_model_swap( name, model )
+{
+	level waittill( "pl1" );
+	players = getlocalplayers();
+	for ( p=0; p<players.size; p++ )
+	{
+		lamps = GetEntArray( p, name, "targetname" );
+		for ( i=0; i<lamps.size; i++ )
+		{
+			lamps[i] SetModel( model );
+		}
+	}
+}
+projector_screen_fx()
+{
+	projector_struct = getstruct( "struct_theater_projector_beam", "targetname" );
+	projector_ang = projector_struct.angles;
+	projector_up = AnglesToUp( projector_ang );
+	projector_forward = AnglesToForward( projector_ang );
+	screen_struct = getstruct( "struct_theater_screen", "targetname" );
+	screen_ang = screen_struct.angles;
+	screen_up = AnglesToUp( screen_ang );
+	screen_forward = AnglesToForward( screen_ang );
+	projector_struct.screen_beam = [];
+	projector_struct.vid = [];
+	if( !IsDefined( screen_struct.script_string ) )
+	{
+		screen_struct.script_string = "ps0";
+	}
+	level waittill( "sip" );
+	players = getlocalplayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		projector_struct.screen_beam[i] = Spawn( i, projector_struct.origin, "script_model" );
+		projector_struct.screen_beam[i].angles = projector_struct.angles;
+		projector_struct.screen_beam[i] SetModel( "tag_origin" );
+		PlayFXOnTag( i, level._effect[ "theater_projector_beam" ], projector_struct.screen_beam[i], "tag_origin" );
+	}
+	for( i = 0; i < players.size; i++ )
+	{
+		projector_struct.vid[i] = Spawn( i, screen_struct.origin, "script_model" );
+		projector_struct.vid[i].angles = screen_struct.angles;
+		projector_struct.vid[i] SetModel( "tag_origin" );
+		PlayFXOnTag( i, level._effect[ "projector_screen_0" ], projector_struct.vid[i], "tag_origin" );
+	}
+	projector_reel_change_init( projector_struct );
+}
+projector_reel_change_init( struct_projector )
+{
+	level thread projector_reel_swap( struct_projector, "ps1" );
+	level thread projector_reel_swap( struct_projector, "ps2" );
+	level thread projector_reel_swap( struct_projector, "ps3" );
+}
+projector_reel_swap( struct_screen, str_clientnotify )
+{
+	level waittill( str_clientnotify );
+	players = getlocalplayers();
+	for( i = 0; i < players.size; i++ )
+	{
+		if( IsDefined( struct_screen.vid[i] ) )
+		{
+			PlayFXOnTag( i, level._effect[ str_clientnotify ], struct_screen.vid[i], "tag_origin" );
+		}
+	}
+}
+dog_start_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_start" );
+		start_dist = 0;
+		half_dist = 302.622;
+		half_height = 306.395;
+		base_height = 344.622;
+		fog_r = 0.458824;
+		fog_g = 0.556863;
+		fog_b = 0.619608;
+		fog_scale = 1;
+		sun_col_r = 0.243137;
+		sun_col_g = 0.270588;
+		sun_col_b = 0.270588;
+		sun_dir_x = 0.291692;
+		sun_dir_y = -0.720765;
+		sun_dir_z = 0.628819;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 7;
+		max_fog_opacity = 0.65;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+dog_stop_monitor()
+{
+	while( 1 )
+	{
+		level waittill( "dog_stop" );
+		start_dist = 155.625;
+		half_dist = 2332.79;
+		half_height = 677.241;
+		base_height = 23.2733;
+		fog_r = 0.639216;
+		fog_g = 0.639216;
+		fog_b = 0.639216;
+		fog_scale = 1;
+		sun_col_r = 0.243137;
+		sun_col_g = 0.270588;
+		sun_col_b = 0.270588;
+		sun_dir_x = 0.291692;
+		sun_dir_y = -0.720765;
+		sun_dir_z = 0.628819;
+		sun_start_ang = 0;
+		sun_stop_ang = 0;
+		time = 7;
+		max_fog_opacity = 1;
+		setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+		sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+		sun_stop_ang, time, max_fog_opacity);
+	}
+}
+level_fog_init()
+{
+	start_dist = 155.625;
+	half_dist = 2332.79;
+	half_height = 677.241;
+	base_height = 23.2733;
+	fog_r = 0.639216;
+	fog_g = 0.639216;
+	fog_b = 0.639216;
+	fog_scale = 1;
+	sun_col_r = 0.243137;
+	sun_col_g = 0.270588;
+	sun_col_b = 0.270588;
+	sun_dir_x = 0.291692;
+	sun_dir_y = -0.720765;
+	sun_dir_z = 0.628819;
+	sun_start_ang = 0;
+	sun_stop_ang = 0;
+	time = 0.1;
+	max_fog_opacity = 1;
+	setVolFog(start_dist, half_dist, half_height, base_height, fog_r, fog_g, fog_b, fog_scale,
+	sun_col_r, sun_col_g, sun_col_b, sun_dir_x, sun_dir_y, sun_dir_z, sun_start_ang,
+	sun_stop_ang, time, max_fog_opacity);
+}