Added BO1 ZM rawfiles

BO1/PC/ZM/aim_assist/view_input_0.graph

@@ -0,0 +1,18 @@
+GRAPH_FLOAT_FILE
+
+15
+0.0000 0.0000
+0.1218 0.0171
+0.1972 0.0295
+0.2612 0.0451
+0.3244 0.0644
+0.3872 0.0897
+0.4543 0.1281
+0.5149 0.1729
+0.5723 0.2203
+0.6263 0.2771
+0.6771 0.3483
+0.7288 0.4296
+0.7781 0.5157
+0.8387 0.6301
+1.0000 1.0000

BO1/PC/ZM/aim_assist/view_input_1.graph

@@ -0,0 +1,16 @@
+GRAPH_FLOAT_FILE
+
+13
+0.0000 0.0000
+0.1323 0.0235
+0.2102 0.0469
+0.2939 0.0778
+0.3741 0.1170
+0.4555 0.1724
+0.5401 0.2400
+0.6118 0.3149
+0.6726 0.4018
+0.7268 0.4906
+0.7797 0.5833
+0.8386 0.6926
+1.0000 1.0000

BO1/PC/ZM/aim_assist/view_input_2.graph

@@ -0,0 +1,15 @@
+GRAPH_FLOAT_FILE
+
+12
+0.0000 0.0000
+0.1322 0.0396
+0.2338 0.0780
+0.3235 0.1267
+0.4022 0.1812
+0.4809 0.2479
+0.5561 0.3254
+0.6205 0.3936
+0.6930 0.4771
+0.7819 0.5943
+0.8598 0.7299
+1.0000 1.0000

BO1/PC/ZM/aim_assist/view_input_3.graph

@@ -0,0 +1,10 @@
+GRAPH_FLOAT_FILE
+
+7
+0.0000 0.0000
+0.1242 0.0423
+0.2238 0.0885
+0.3210 0.1553
+0.4118 0.2419
+0.5116 0.3508
+1.0000 1.0000

BO1/PC/ZM/animscripts/melee.gsc

@@ -0,0 +1,513 @@
+#include maps\_utility;
+#include animscripts\Utility;
+#include animscripts\SetPoseMovement;
+#include animscripts\Combat_Utility;
+#include animscripts\Debug;
+#include animscripts\anims;
+#include common_scripts\Utility;
+#using_animtree ("generic_human");
+MeleeCombat()
+{
+	self endon("killanimscript");
+	self melee_notify_wrapper();
+	assert( CanMeleeAnyRange() );
+	if(IsDefined(level.allow_ai_vs_ai_melee ))
+	{
+		doingAIMelee = (isAI( self.enemy ) && self.enemy.type == "human");
+	}
+	else
+	{
+		doingAIMelee = false;
+	}
+	if ( doingAiMelee )
+	{
+		assert( animscripts\utility::okToMelee( self.enemy ) );
+		animscripts\utility::IAmMeleeing( self.enemy );
+		AiVsAiMeleeCombat();
+		animscripts\utility::ImNotMeleeing( self.enemy );
+		scriptChange();
+		return;
+	}
+	realMelee = true;
+	if ( animscripts\utility::okToMelee(self.enemy) )
+	{
+		animscripts\utility::IAmMeleeing(self.enemy);
+	}
+	else
+	{
+		realMelee = false;
+	}
+	self thread EyesAtEnemy();
+	self OrientMode("face enemy");
+	MeleeDebugPrint("Melee begin");
+	self AnimMode( "zonly_physics" );
+	resetGiveUpTime();
+	first_time = true;
+	for ( ;; )
+	{
+		if ( !PrepareToMelee(first_time) )
+		{
+			self.lastMeleeGiveUpTime = GetTime();
+			break;
+		}
+		first_time = false;
+		assert( self.a.pose == "stand");
+		MeleeDebugPrint("Melee main loop" + RandomInt(100));
+		if ( !realMelee && animscripts\utility::okToMelee(self.enemy) )
+		{
+			realMelee = true;
+			animscripts\utility::IAmMeleeing(self.enemy);
+		}
+		self thread EyesAtEnemy();
+		self OrientMode("face current");
+		if ( self maps\_bayonet::has_bayonet() && RandomInt( 100 ) < 0 )
+		{
+			self SetFlaggedAnimKnobAllRestart("meleeanim", animArray("bayonet"), %body, 1, .2, 1);
+		}
+		else
+		{
+			self SetFlaggedAnimKnobAllRestart("meleeanim", animArray("melee"), %body, 1, .2, 1);
+		}
+		while ( 1 )
+		{
+			self waittill("meleeanim", note);
+			if ( note == "end" )
+			{
+				break;
+			}
+			else if ( note == "fire" )
+			{
+				if ( !IsDefined( self.enemy ) )
+				{
+					break;
+				}
+				oldhealth = self.enemy.health;
+				self melee();
+				if ( self.enemy.health < oldhealth )
+				{
+					resetGiveUpTime();
+				}
+			}
+			else if ( note == "stop" )
+			{
+				if ( !CanContinueToMelee() )
+				{
+					break;
+				}
+			}
+		}
+		self OrientMode("face default");
+	}
+	if (realMelee)
+	{
+		animscripts\utility::ImNotMeleeing(self.enemy);
+	}
+	self AnimMode("none");
+	self thread backToCombat();
+}
+backToCombat()
+{
+	self notify("killanimscript");
+	waittillframeend;
+	self thread animscripts\combat::main();
+	self notify ("stop EyesAtEnemy");
+	self notify ("stop_melee_debug_print");
+	scriptChange();
+}
+resetGiveUpTime()
+{
+	if ( DistanceSquared( self.origin, self.enemy.origin ) > anim.chargeRangeSq )
+	{
+		self.giveUpOnMeleeTime = GetTime() + randomintrange( 2700, 3300 );
+	}
+	else
+	{
+		self.giveUpOnMeleeTime = GetTime() + randomintrange( 1700, 2300 );
+	}
+}
+MeleeDebugPrint(text)
+{
+	return;
+	self.meleedebugprint = text;
+	self thread meleeDebugPrintThreadWrapper();
+}
+meleeDebugPrintThreadWrapper()
+{
+	if ( !IsDefined(self.meleedebugthread) )
+	{
+		self.meleedebugthread = true;
+		self meleeDebugPrintThread();
+		self.meleedebugthread = undefined;
+	}
+}
+meleeDebugPrintThread()
+{
+	self endon("death");
+	self endon("killanimscript");
+	self endon("stop_melee_debug_print");
+	while(1)
+	{
+		Print3d(self.origin + (0,0,60), self.meleedebugprint, (1,1,1), 1, .1);
+		wait .05;
+	}
+}
+debug_melee_on_actor()
+{
+	return false;
+}
+debug_melee( msg )
+{
+}
+debug_melee_line( start, end, color, duration )
+{
+}
+getEnemyPose()
+{
+	if ( IsPlayer( self.enemy ) )
+	{
+		return self.enemy getStance();
+	}
+	else
+	{
+		return self.enemy.a.pose;
+	}
+}
+CanContinueToMelee()
+{
+	return CanMeleeInternal( "already started" );
+}
+CanMeleeAnyRange()
+{
+	return CanMeleeInternal( "any range" );
+}
+CanMeleeDesperate()
+{
+	return CanMeleeInternal( "long range" );
+}
+CanMelee()
+{
+	return CanMeleeInternal( "normal" );
+}
+CanMeleeInternal( state )
+{
+	if ( !IsSentient( self.enemy ) )
+	{
+		debug_melee( "Not doing melee - Does not have a valid target." );
+		return false;
+	}
+	if (!IsAlive(self.enemy))
+	{
+		return false;
+	}
+	if ( IsDefined( self.disableMelee ) )
+	{
+		assert( self.disableMelee );
+		debug_melee( "Not doing melee - Melee is disabled, self.disableMelee is set to true." );
+		return false;
+	}
+	if (self.a.pose != "stand")
+	{
+		debug_melee( "Not doing melee - Cant melee in " + self.a.pose );
+		return false;
+	}
+	enemypose = getEnemyPose();
+	if ( !IsPlayer( self.enemy ) && enemypose != "stand" && enemypose != "crouch" )
+	{
+		if ( !( self is_banzai() && enemypose == "prone" ) )
+		{
+			debug_melee( "Not doing melee - Enemy is in prone." );
+			return false;
+		}
+	}
+	yaw = abs(getYawToEnemy());
+	if ( self.a.allow_shooting && ((yaw > 60 && state != "already started") || yaw > 110) )
+	{
+		debug_melee( "Not doing melee - Not facing the enemy." );
+		return false;
+	}
+	enemyPoint = self.enemy GetOrigin();
+	vecToEnemy = enemyPoint - self.origin;
+	self.enemyDistanceSq = lengthSquared( vecToEnemy );
+	nearest_enemy_sqrd_dist = self GetClosestEnemySqDist();
+	epsilon = 0.1;
+	if( IsDefined( nearest_enemy_sqrd_dist ) && ( nearest_enemy_sqrd_dist - epsilon > self.enemyDistanceSq ) )
+	{
+		debug_melee( "Not doing melee - Entity " + self getEntityNumber() + " can't melee entity " + self.enemy getEntityNumber() + " at distSq " + self.enemyDistanceSq + " because there is a closer enemy at distSq " + nearest_enemy_sqrd_dist + "." );
+		return false;
+	}
+	if(IsDefined(level.allow_ai_vs_ai_melee ))
+	{
+		doingAIMelee = (isAI( self.enemy ) && self.enemy.type == "human");
+	}
+	else
+	{
+		doingAIMelee = false;
+	}
+	if ( doingAIMelee )
+	{
+		if ( !animscripts\utility::okToMelee(self.enemy) )
+		{
+			debug_melee( "Not doing melee - Enemy is already being meleed." );
+			return false;
+		}
+		if ( IsDefined( self.magic_bullet_shield ) && self.magic_bullet_shield && IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+		{
+			debug_melee( "Not doing melee - Enemy has magic bullet shield." );
+			return false;
+		}
+		if ( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+		{
+			self notify("melee_path_blocked");
+			return false;
+		}
+	}
+	else
+	{
+		if ( IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+		{
+			if ( !( self is_banzai() ) )
+			{
+				debug_melee( "Not doing melee - Enemy has magic bullet shield." );
+				return false;
+			}
+		}
+		if (self.enemyDistanceSq <= anim.meleeRangeSq)
+		{
+			if ( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+			{
+				if ( !self is_banzai() )
+				{
+					self notify("melee_path_blocked");
+					return false;
+				}
+			}
+			return true;
+		}
+		else if ( self is_banzai() )
+		{
+			return false;
+		}
+		if ( state != "any range" )
+		{
+			chargeRangeSq = anim.chargeRangeSq;
+			if ( state == "long range" )
+			{
+				chargeRangeSq = anim.chargeLongRangeSq;
+			}
+			if (self.enemyDistanceSq > chargeRangeSq)
+			{
+				debug_melee( "Not doing melee - Enemy is not close enough to charge." );
+				return false;
+			}
+		}
+		if ( state == "already started" )
+		{
+			return false;
+		}
+		if ( ( !self is_banzai() || IsPlayer( self.enemy ) ) && self.a.allow_shooting && IsDefined( self.lastMeleeGiveUpTime ) && GetTime() - self.lastMeleeGiveUpTime < 3000 )
+		{
+			debug_melee( "Not doing melee - Recently meleed someone and missed." );
+			return false;
+		}
+		if ( !animscripts\utility::okToMelee(self.enemy) )
+		{
+			debug_melee( "Not doing melee - Enemy is being meleed." );
+			return false;
+		}
+		if ( self.enemy animscripts\banzai::in_banzai_attack() )
+		{
+			return false;
+		}
+		if ( self animscripts\banzai::in_banzai_attack() )
+		{
+			return false;
+		}
+		if( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+		{
+			self notify("melee_path_blocked");
+			return false;
+		}
+	}
+	return true;
+}
+isMeleePathClear( vecToEnemy, enemyPoint )
+{
+	dirToEnemy = VectorNormalize( (vecToEnemy[0], vecToEnemy[1], 0 ) );
+	meleePoint = enemyPoint - ( dirToEnemy[0]*32, dirToEnemy[1]*32, 0 );
+	thread debug_melee_line( self.origin, meleePoint, ( 1,0,0 ), 1.5 );
+	if ( !self IsInGoal( meleePoint ) )
+	{
+		debug_melee( "Not doing melee - Enemy is outside not in goal." );
+		return false;
+	}
+	if ( self maymovetopoint(meleePoint) )
+	{
+		return true;
+	}
+	debug_melee( "Not doing melee - Can not move to the melee point, MayMoveToPoint failed." );
+	return false;
+}
+PrepareToMelee(first_time)
+{
+	if ( !CanMeleeAnyRange() )
+	{
+		return false;
+	}
+	if (self.enemyDistanceSq <= anim.meleeRangeSq)
+	{
+		isBatonGuard = IsDefined(self.baton_guard) && self.baton_guard;
+		isRegularAi = self.animType != "spetsnaz" && !isBatonGuard;
+		if( first_time || isRegularAi )
+		{
+			self SetFlaggedAnimKnobAll("readyanim", animArray("stand_2_melee"), %body, 1, .3, 1);
+			self animscripts\shared::DoNoteTracks("readyanim");
+		}
+		return true;
+	}
+	self PlayMeleeSound();
+	prevEnemyPos = self.enemy.origin;
+	sampleTime = 0.1;
+	runToMeleeAnim = animArray("run_2_melee");
+	raiseGunAnimTravelDist = length(getmovedelta(runToMeleeAnim, 0, 1));
+	meleeAnimTravelDist = 32;
+	shouldRaiseGunDist = anim.meleeRange * 0.75 + meleeAnimTravelDist + raiseGunAnimTravelDist;
+	shouldRaiseGunDistSq = shouldRaiseGunDist * shouldRaiseGunDist;
+	shouldMeleeDist = anim.meleeRange + meleeAnimTravelDist;
+	shouldMeleeDistSq = shouldMeleeDist * shouldMeleeDist;
+	raiseGunFullDuration = getanimlength(runToMeleeAnim) * 1000;
+	raiseGunFinishDuration = raiseGunFullDuration - 100;
+	raiseGunPredictDuration = raiseGunFullDuration - 200;
+	raiseGunStartTime = 0;
+	predictedEnemyDistSqAfterRaiseGun = undefined;
+	runAnim = animscripts\run::GetRunAnim();
+	self SetFlaggedAnimKnobAll("chargeanim", runAnim, %body, 1, .3, 1);
+	raisingGun = false;
+	while ( 1 )
+	{
+		MeleeDebugPrint("PrepareToMelee loop" + RandomInt(100));
+		time = GetTime();
+		willBeWithinRangeWhenGunIsRaised = (IsDefined( predictedEnemyDistSqAfterRaiseGun ) && predictedEnemyDistSqAfterRaiseGun <= shouldRaiseGunDistSq);
+		if ( !raisingGun )
+		{
+			if ( willBeWithinRangeWhenGunIsRaised )
+			{
+				self SetFlaggedAnimKnobAllRestart("chargeanim", runToMeleeAnim, %body, 1, .2, 1);
+				raiseGunStartTime = time;
+				raisingGun = true;
+			}
+		}
+		else
+		{
+			withinRangeNow = self.enemyDistanceSq <= shouldRaiseGunDistSq;
+			if ( time - raiseGunStartTime >= raiseGunFinishDuration || (!willBeWithinRangeWhenGunIsRaised && !withinRangeNow) )
+			{
+				self SetFlaggedAnimKnobAll("chargeanim", runAnim, %body, 1, .3, 1);
+				raisingGun = false;
+			}
+		}
+		self animscripts\shared::DoNoteTracksForTime(sampleTime, "chargeanim");
+		if ( !CanMeleeAnyRange() )
+		{
+			return false;
+		}
+		assert( IsDefined( self.enemyDistanceSq ) );
+		enemyVel = vector_scale( self.enemy.origin - prevEnemyPos, 1 / (GetTime() - time) );
+		prevEnemyPos = self.enemy.origin;
+		predictedEnemyPosAfterRaiseGun = self.enemy.origin + vector_scale( enemyVel, raiseGunPredictDuration );
+		predictedEnemyDistSqAfterRaiseGun = DistanceSquared( self.origin, predictedEnemyPosAfterRaiseGun );
+		if ( raisingGun && self.enemyDistanceSq <= shouldMeleeDistSq && GetTime() - raiseGunStartTime >= raiseGunFinishDuration )
+		{
+			break;
+		}
+		if ( !raisingGun && GetTime() >= self.giveUpOnMeleeTime )
+		{
+			return false;
+		}
+	}
+	return true;
+}
+PlayMeleeSound()
+{
+	if ( !IsDefined ( self.a.nextMeleeChargeSound ) )
+	{
+		self.a.nextMeleeChargeSound = 0;
+	}
+	if ( GetTime() > self.a.nextMeleeChargeSound )
+	{
+		self animscripts\face::SaySpecificDialogue( undefined, "chr_play_grunt_" + self.voice, 0.3 );
+		self.a.nextMeleeChargeSound = GetTime() + 8000;
+	}
+}
+AiVsAiMeleeCombat()
+{
+	self endon("killanimscript");
+	self melee_notify_wrapper();
+	self OrientMode("face enemy");
+	self ClearAnim( %root, 0.3 );
+	IWin = ( RandomInt(10) < 8 );
+	if ( IsDefined( self.magic_bullet_shield ) && self.magic_bullet_shield )
+	{
+		IWin = true;
+	}
+	if ( IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+	{
+		IWin = false;
+	}
+	winAnim = animArray("ai_vs_ai_win");
+	loseAnim = animArray("ai_vs_ai_lose");
+	if ( IWin )
+	{
+		myAnim = winAnim;
+		theirAnim = loseAnim;
+	}
+	else
+	{
+		myAnim = loseAnim;
+		theirAnim = winAnim;
+	}
+	desiredDistSqrd = 72 * 72;
+	self PlayMeleeSound();
+	AiVsAiMeleeCharge( desiredDistSqrd );
+	if ( DistanceSquared( self.origin, self.enemy.origin ) > desiredDistSqrd )
+	{
+		return false;
+	}
+	self.meleePartner = self.enemy;
+	self.enemy.meleePartner = self;
+	self.enemy.meleeAnim = theirAnim;
+	self.enemy animcustom( ::AiVsAiAnimCustom );
+	self.meleeAnim = myAnim;
+	self animcustom( ::AiVsAiAnimCustom );
+}
+AiVsAiMeleeCharge( desiredDistSqrd )
+{
+	giveUpTime = GetTime() + 2500;
+	self SetAnimKnobAll( animscripts\run::GetRunAnim(), %body, 1, 0.2 );
+	while ( DistanceSquared( self.origin, self.enemy.origin ) > desiredDistSqrd && GetTime() < giveUpTime )
+	{
+		wait .05;
+	}
+}
+AiVsAiAnimCustom()
+{
+	self endon("killanimscript");
+	self AiVsAiMeleeAnim( self.meleeAnim );
+}
+AiVsAiMeleeAnim( myAnim )
+{
+	self endon("end_melee");
+	self thread endMeleeOnKillanimscript();
+	partnerDir = self.meleePartner.origin - self.origin;
+	self OrientMode( "face angle", VectorToAngles( partnerDir )[1] );
+	self AnimMode( "zonly_physics" );
+	self SetFlaggedAnimKnobAllRestart( "meleeAnim", myAnim, %body, 1, 0.2 );
+	self animscripts\shared::DoNoteTracks( "meleeAnim" );
+	self notify("end_melee");
+}
+endMeleeOnKillanimscript()
+{
+	self endon("end_melee");
+	self waittill("killanimscript");
+	self.meleePartner notify("end_melee");
+}
+

BO1/PC/ZM/animscripts/revive.gsc

@@ -0,0 +1,540 @@
+#include maps\_utility;
+#include common_scripts\utility;
+#include animscripts\Utility;
+#include animscripts\Debug;
+#include maps\_anim;
+#using_animtree ("generic_human");
+precacheReviveModels()
+{
+	if ( IsDefined( level.reviveFeature ) && !level.reviveFeature )
+		return;
+	precacheModel( "char_rus_bandages1" );
+}
+revive_main()
+{
+	anim.nextReviveSequenceTime = GetTime() + RandomIntRange(0, 20000);
+	anim.nextReviveSequencePlayerTimeMin = 15000;
+	anim.nextReviveSequencePlayerTimeMax = 30000;
+	anim.nextReviveSequenceTimeMin = 5000;
+	anim.nextReviveSequenceTimeMax = 10000;
+	anim.bleederBleedOutTimeMin = 5000;
+	anim.bleederBleedOutTimeMax = 10000;
+	anim.reviverPingDist = 512;
+	anim.reviverIgnorePlayerDistSq = 200*200;
+	anim.reviveSequencePlayerVisibleDistSq = 1000*1000;
+	anim.revive = [];
+	anim.bleed["stand"]["fall"] = %ai_revive_wounded_onback_fall_stand;
+	anim.bleed["crouch"]["fall"] = %ai_revive_wounded_onback_fall_crouch;
+	anim.bleed["prone"]["fall"] = %ai_dying_crawl_2_back_revive;
+	anim.bleed["bleed_loop"] = %ai_revive_wounded_onback_loop;
+	anim.bleed["left"]["being_revived"] = %ai_revive_wounded_onback_left_revive;
+	anim.bleed["left"]["get_up"] = %ai_revive_wounded_onback_left_get_up;
+	anim.revive["left"]["reviving"] = %ai_revive_reviver_onback_left_revive;
+	anim.revive["left"]["get_up"] = %ai_revive_reviver_onback_left_get_up;
+}
+revive_init()
+{
+	self.a.revivedOnce = false;
+	self.a.reviveMe = false;
+	self.a.falling = false;
+	self.a.bleeding = false;
+	self.a.isReviver = false;
+	self.a.isReviving = false;
+	self.a.canBleed = true;
+	self.a.canRevive = true;
+	self.a.reviver = undefined;
+	self.a.bleeder = undefined;
+	self.a.oldRevivers = [];
+}
+tryGoingDown(damage, hitloc)
+{
+	Assert(IsDefined(level.reviveFeature), "level.reviveFeature is not initialized.");
+	if(!level.reviveFeature)
+		return false;
+	if(!GetDvarInt( #"scr_aiReviveFeature"))
+	{
+		if(!shouldReviveSequenceHappen())
+			return false;
+	}
+	if( !IsAI( self ) || !IsAlive(self) || (self.isdog) || (self.team != "axis") || (self.a.canBleed == false) || (self.a.pose == "back") )
+		return false;
+	if( self.a.pose == "prone" )
+		return false;
+	if( IsDefined( self.a.usingTurret ) )
+		return false;
+	if(!GetDvarInt( #"scr_aiReviveFeature"))
+	{
+		friendlies = GetAIArray(self.team);
+		alive_nearby_ai = get_array_of_closest( self.origin, friendlies, undefined, undefined, anim.reviverPingDist );
+		if( alive_nearby_ai.size <= 2 )
+			return false;
+	}
+	if( (self.a.isreviver == false ) && (self.a.revivedOnce == false) && (self.a.reviveMe == false) && isAIDamageFatal(damage) && !damageLocation(hitloc) )
+	{
+		if( !IsReviveOnSafeTerrain() )
+			return false;
+		Assert(IsAlive(self) == true, "AI is already dead or in extended death and cant be put down.");
+		self.a.reviveMe = true;
+		self thread killMeOnScriptInterrupt();
+		self.health = self.health + damage + RandomIntRange(60,100);
+		return true;
+	}
+	return false;
+}
+killMeOnScriptInterrupt()
+{
+	self endon( "death" );
+	self waittill( "killanimscript" );
+	self waittill( "killanimscript" );
+	if( self isBleeder() && IsAlive(self) )
+	{
+		self DoDamage( self.health + 200, self.origin );
+	}
+}
+revive_strat()
+{
+	self endon("death");
+	self endon("killanimscript");
+	self thread bleeder_bleed_to_death();
+	self thread fall_down_to_bleed();
+	self waittill("ready_after_revived");
+}
+reviver_selection_think(team)
+{
+	self endon("death");
+	self endon("revived");
+	self endon("reevaluate_reviver");
+	self endon("killanimscript");
+	Assert(IsAlive(self) == true, "AI is already dead or in extended death and cant be put down.");
+	if( self.a.revivedOnce != true )
+	{
+		self waittill_players_goes_away();
+		reviver_found = false;
+		while(!reviver_found)
+		{
+			friendlies = GetAIArray( self.team );
+			if( self.a.oldRevivers.size > 0 )
+				ai = get_array_of_closest( self.origin, friendlies, self.a.oldRevivers, undefined, anim.reviverPingDist );
+			else
+				ai = get_array_of_closest( self.origin, friendlies, undefined, undefined, anim.reviverPingDist );
+			for( i = 0; i < ai.size; i++ )
+			{
+				current_ai = ai[i];
+				if( isAIOldReviver( current_ai ) || ( current_ai.a.canRevive == false ) )
+					continue;
+				if( IsDefined( current_ai.ignoreall ) && current_ai.ignoreall == true )
+					continue;
+				if( ( current_ai != self ) && IsDefined( current_ai.a.revivedOnce ) && ( current_ai.a.reviveMe == false ) && ( current_ai.a.isReviver == false ) )
+				{
+					AssertEx(IsDefined(self.predictedRevivePoint), "Predicted revive point is not calculated.");
+					if( findpath( current_ai.origin, self.predictedRevivePoint ) )
+					{
+						reviver_found = true;
+						self.a.oldRevivers[self.a.oldRevivers.size] = current_ai;
+						self.a.reviver = current_ai;
+						current_ai.a.bleeder = self;
+						self thread revive_process();
+						break;
+					}
+				}
+			}
+			if( !reviver_found )
+				wait(2);
+		}
+	}
+}
+revive_process()
+{
+	self endon("death");
+	self.a.reviver thread reviver_think();
+	self thread handle_bleeder_death();
+	self.a.reviver thread handle_reviver_death();
+}
+waittill_players_goes_away()
+{
+	while( IsAlive(self) )
+	{
+		player = get_closest_player(self.origin);
+		if( DistanceSquared( player.origin, self.origin) > anim.reviverIgnorePlayerDistSq )
+			break;
+		wait(1);
+	}
+}
+handle_reviver_death()
+{
+	self endon("revive_complete");
+	self endon("bleeder_death");
+	self waittill_any( "death" );
+	self free_reviver("death");
+	wait(0.05);
+	if( IsDefined( self.a.bleeder ) && IsAlive(self.a.bleeder))
+	{
+		if( self.a.revivedOnce )
+		{
+			self.a.bleeder thread bleeder_getup();
+		}
+		else
+		{
+			self .a.bleeder play_bleed_loop();
+			self.a.bleeder thread reviver_selection_think(self.a.bleeder.team);
+		}
+	}
+}
+handle_reviver_goal_change()
+{
+	self endon("revive_complete");
+	self endon("bleeder_death");
+	self endon("reevaluate_reviver");
+	self endon("reviving_bleeder");
+	self waittill_any("goalradius_changed");
+	self free_reviver("goalradius_changed");
+	wait(0.05);
+	if( IsDefined( self.a.bleeder ) && IsAlive(self.a.bleeder) )
+	{
+		if( self.a.revivedOnce )
+			self.a.bleeder thread bleeder_getup();
+		else
+			self.a.bleeder thread reviver_selection_think(self.a.bleeder.team);
+	}
+}
+handle_bleeder_death(reviver)
+{
+	self endon("revived");
+	self endon("reevaluate_reviver");
+	self waittill("death");
+	self.a.reviver notify("bleeder_death");
+	self.a.reviver free_reviver("bleeder_death");
+}
+reviver_think()
+{
+	self endon("death");
+	self endon("bleeder_death");
+	self endon("reevaluate_reviver");
+	self.a.isReviver = true;
+	while(!self.a.bleeder.a.bleeding)
+	{
+		wait(0.05);
+	}
+	self.ReviveOldgoalradius = self.goalradius;
+	self.goalradius = 4;
+	self thread handle_reviver_goal_change();
+	revive_anim = getReviverReviveAnim();
+	approach_angle = GetStartAngles( self.a.bleeder.origin, self.a.bleeder.angles, revive_anim );
+	revive_point = getRevivePoint(self.a.bleeder);
+	self SetGoalPos(revive_point, approach_angle);
+	self waittill("goal");
+	self reviver_revive(revive_anim, revive_point);
+}
+free_reviver(reason)
+{
+	self endon("death");
+	if( IsDefined(self) )
+	{
+		self.a.isReviver = false;
+		self.a.isReviving = false;
+		self.ignoreme = false;
+		if( IsDefined(reason) && ( (reason == "death") || (reason == "goalradius_changed" ) ) )
+		{
+			self notify("reevaluate_reviver");
+			self.a.bleeder notify("reevaluate_reviver");
+		}
+		if( IsDefined(self.ReviveOldgoalradius) )
+			self.goalradius = self.ReviveOldgoalradius;
+		if( IsAlive(self) && IsDefined(reason) && reason != "death" )
+		{
+			self notify( "killanimscript" );
+			waittillframeend;
+			self thread call_overloaded_func( "animscripts\combat", "main" );
+		}
+	}
+}
+free_bleeder()
+{
+	self endon("death");
+	if (IsDefined(self))
+	{
+		self.a.reviveMe = false;
+		self.a.bleeding = false;
+		self.a.falling = false;
+		self.health = RandomIntRange(90, 120);
+		self notify("ready_after_revived");
+		if( IsDefined( self.a.special ) && self.a.special == "bleeder_death" )
+			self.a.special = "none";
+		if( IsAlive(self) )
+		{
+			self notify( "killanimscript" );
+			waittillframeend;
+			self thread call_overloaded_func( "animscripts\combat", "main" );
+		}
+	}
+}
+reviver_revive(revive_anim, revive_point)
+{
+	self endon("bleeder_death");
+	self.a.isReviving = true;
+	bleeder = self.a.bleeder;
+	bleeder notify("being_revived");
+	self notify("reviving_bleeder");
+	self.ignoreme = true;
+	resetReviveSequenceTimer();
+	bleeder SetFlaggedAnimKnob( "being_revived", getBleederReviveAnim(), 1, 0.1, 1 );
+	self AnimScripted( "revive", bleeder.origin, bleeder.angles, revive_anim, "normal", %body, 1 );
+	self animscripts\shared::DoNoteTracks("revive", ::handleReviverNotetracks);
+	self notify("revive_complete");
+	self revive_getup_process();
+}
+revive_getup_process()
+{
+	self.a.bleeder thread bleeder_getup();
+	self animcustom( ::reviver_getup );
+}
+bleeder_getup()
+{
+	self SetFlaggedAnimKnobAllRestart( "bleeder_get_up", getBleederGetUpAnim(), %body ,1, 0.1, 1.0 );
+	self animscripts\shared::DoNoteTracks( "bleeder_get_up" );
+	self free_bleeder();
+}
+reviver_getup()
+{
+	self SetFlaggedAnimKnobAllRestart( "reviver_get_up", getReviverGetUpAnim(), %body, 1, 0.1, 1.0 );
+	self animscripts\shared::DoNoteTracks( "reviver_get_up" );
+	self free_reviver("revive_complete");
+}
+bleeder_bleed_to_death()
+{
+	self endon("revived");
+	self.bleedOutTime = RandomIntRange(anim.bleederBleedOutTimeMin,anim.bleederBleedOutTimeMax);
+	wait( self.bleedOutTime/1000 );
+	if( IsDefined(self) && IsAlive(self) )
+		self DoDamage( self.health + 200, self.origin );
+}
+fall_down_to_bleed()
+{
+	self endon("death");
+	self endon("revived");
+	self endon("being_revived");
+	self endon("killanimscript");
+	self SetAnimKnobAll( %revive, %body, 1, 0.1, 1 );
+	transAnim = getTransitionAnim();
+	self.a.falling = true;
+	self SetFlaggedAnimKnob( "fall_transition", transAnim, 1, 0.1, 1.5 );
+	self thread handleBleederNotetracks("fall_transition");
+	self animscripts\shared::DoNoteTracks( "fall_transition");
+	Assert( self.a.pose == "back", "Fall transition animation is missing the anim_pose = back notetrack." );
+	self ClearAnim(transAnim, 0.2);
+	self.a.bleeding = true;
+	self play_bleed_loop();
+}
+play_bleed_loop()
+{
+	self SetFlaggedAnimKnobAllRestart( "bleeding", getBleedLoopAnim(), %body ,1, 0.1, 1.0 );
+}
+handleBleederNotetracks(anim_name)
+{
+	self endon("death");
+	for (;;)
+	{
+		self waittill(anim_name, note);
+		switch ( note )
+		{
+			case "reviver_selection":
+			{
+				self thread reviver_selection_think(self.team);
+				break;
+			}
+			case "anim_pose = \"back\"":
+			{
+				self.a.special = "bleeder_death";
+				break;
+			}
+		}
+		if(note == "end")
+		{
+			break;
+		}
+	}
+}
+handleReviverNotetracks(note)
+{
+	switch ( note )
+	{
+		case "attach_bandage":
+		{
+			bleeder = self.a.bleeder;
+			bleeder Attach("char_rus_bandages1");
+			bleeder.a.revivedOnce = true;
+			bleeder notify("revived");
+			break;
+		}
+	}
+}
+getTransitionAnim()
+{
+	assert( self.a.pose == "stand" || self.a.pose == "crouch" || self.a.pose == "prone" );
+	transitionAnim = anim.bleed[self.a.pose]["fall"];
+	Assert(animHasNoteTrack( transitionAnim, "anim_pose = \"back\"" ));
+	Assert(animHasNoteTrack( transitionAnim, "reviver_selection" ));
+	return transitionAnim;
+}
+getBleedLoopAnim()
+{
+	bleedLoopAnim = anim.bleed["bleed_loop"];
+	return bleedLoopAnim;
+}
+getBleederReviveAnim()
+{
+	reviveAnim = anim.bleed["left"]["being_revived"];
+	return reviveAnim;
+}
+getReviverReviveAnim()
+{
+	reviveAnim = anim.revive["left"]["reviving"];
+	Assert(animHasNoteTrack( reviveAnim, "anim_pose = \"crouch\"" ));
+	Assert(animHasNoteTrack( reviveAnim, "attach_bandage" ));
+	return reviveAnim;
+}
+getBleederGetUpAnim()
+{
+	bleederGetUpAnim = anim.bleed["left"]["get_up"];
+	Assert(animHasNoteTrack( bleederGetUpAnim, "anim_pose = \"stand\"" ));
+	return bleederGetUpAnim;
+}
+getReviverGetUpAnim()
+{
+	reviverGetUpAnim = anim.revive["left"]["get_up"];
+	Assert(animHasNoteTrack( reviverGetUpAnim, "anim_pose = \"stand\"" ));
+	return reviverGetUpAnim;
+}
+damageLocation(hitloc)
+{
+	if( hitloc == "helmet" || hitloc == "head" )
+		return true;
+	return false;
+}
+isAIOldReviver(ai)
+{
+	if( self.a.oldRevivers.size > 0 )
+	{
+		for( i = 0; i < self.a.oldRevivers.size; i++ )
+		{
+			if( IsDefined( self.a.oldRevivers[i] ) && self.a.oldRevivers[i] == ai )
+				return true;
+		}
+	}
+	return false;
+}
+getRevivePoint(bleeder)
+{
+	revive_point = GetStartOrigin(bleeder.origin, bleeder.angles, getReviverReviveAnim() );
+	return revive_point;
+}
+IsReviveOnSafeTerrain()
+{
+	self endon("death");
+	groundPos = physicstrace( self.origin, self.origin - ( 0, 0, 10000 ) );
+	bleederDistanceFromGround = distance( self.origin, groundPos );
+	if( ( bleederDistanceFromGround > 2 ) || ( bleederDistanceFromGround < 0 ) )
+		return false;
+	angleDelta = getAngleDelta(anim.bleed[self.a.pose]["fall"], 0, 1);
+	finalYaw = self.angles[1] + angleDelta;
+	finalAngles = ( self.angles[0], finalYaw, self.angles[2] );
+	moveDelta = GetMoveDelta( anim.bleed[self.a.pose]["fall"], 0, 1 );
+	endPoint = self localToWorldCoords( moveDelta );
+	if( !self mayMoveToPoint( endPoint ) )
+		return false;
+	self.predictedRevivePoint = getPredictedRevivePoint( endPoint, finalAngles );
+	groundPos = physicstrace( self.predictedRevivePoint, self.predictedRevivePoint - ( 0, 0, 10000 ) );
+	revivePointDistanceFromGround = distance( self.predictedRevivePoint, groundPos );
+	if( revivePointDistanceFromGround < 0 || revivePointDistanceFromGround > 15 )
+		return false;
+	diff = abs( bleederDistanceFromGround - revivePointDistanceFromGround );
+	if( diff > 15 )
+		return false;
+	return true;
+}
+getPredictedRevivePoint( endPoint, finalAngles )
+{
+	revive_point = GetStartOrigin(endPoint, finalAngles, getReviverReviveAnim());
+	return revive_point;
+}
+isAIDamageFatal(damage)
+{
+	Assert(IsAlive(self) == true, "AI is already dead or in extended death and cant be put down.");
+	health = self.health - damage;
+	if( health <= 0 )
+		return true;
+	return false;
+}
+shouldBleed()
+{
+	self endon("death");
+	Assert(IsAlive(self) == true, "AI is already dead or in extended death and cant be put down.");
+	Assert(IsAlive(self.a.revivedOnce) == false, "AI is already revived/bleeded once.");
+	if( ( self.a.reviveMe == true ) && ( self.a.bleeding == false ) && ( self.a.falling == false ) )
+		return true;
+	return false;
+}
+isBleedingOrFalling()
+{
+	Assert(IsAlive(self) == true, "AI is already dead or in extended death and cant be put down.");
+	if( (self.a.bleeding == true) || (self.a.falling == true) )
+		return true;
+	return false;
+}
+shouldReviveSequenceHappen()
+{
+	if ( GetTime() < anim.nextReviveSequenceTime )
+	{
+		return false;
+	}
+	if( ( randomint(100) > 40 ) )
+		return false;
+	return true;
+}
+resetReviveSequenceTimer()
+{
+	players = GetPlayers();
+	anybody_nearby = 0;
+	for (i=0;i<players.size;i++)
+	{
+		if ( IsDefined(players[i]) && DistanceSquared( self.origin, players[i].origin ) < anim.reviveSequencePlayerVisibleDistSq )
+		{
+			anybody_nearby = 1;
+			break;
+		}
+	}
+	if ( anybody_nearby )
+	{
+		anim.nextReviveSequenceTime = GetTime() + RandomIntRange( anim.nextReviveSequencePlayerTimeMin, anim.nextReviveSequencePlayerTimeMax );
+	}
+	else
+	{
+		anim.nextReviveSequenceTime = GetTime() + RandomIntRange( anim.nextReviveSequenceTimeMin, anim.nextReviveSequenceTimeMax );
+	}
+}
+isReviverOrBleeder()
+{
+	if(IsDefined(self) & IsAI(self))
+	{
+		if(self.a.isReviver || self.a.reviveMe)
+			return true;
+	}
+	return false;
+}
+isBleeder()
+{
+	if(IsDefined(self) & IsAI(self))
+	{
+		if( self.a.reviveMe )
+			return true;
+	}
+	return false;
+}
+
+
+
+
+
+
+
+

BO1/PC/ZM/animscripts/setposemovement.gsc

@@ -0,0 +1,892 @@
+
+#include animscripts\Utility;
+#include animscripts\anims;
+#include maps\_Utility;
+#include common_scripts\utility;
+#using_animtree ("generic_human");
+SetPoseMovement(desiredPose, desiredMovement)
+{
+	if (desiredPose=="")
+	{
+		if ( (self.a.pose=="prone") && ((desiredMovement=="walk")||(desiredMovement=="run")) )
+		{
+			desiredPose = "crouch";
+		}
+		else
+		{
+			desiredPose = self.a.pose;
+		}
+	}
+	if (!IsDefined(desiredMovement) || desiredMovement=="")
+	{
+		desiredMovement = self.a.movement;
+	}
+	[[anim.SetPoseMovementFnArray[desiredPose][desiredMovement]]]();
+}
+InitPoseMovementFunctions()
+{
+	anim.SetPoseMovementFnArray["stand"]["stop"] =	::BeginStandStop;
+	anim.SetPoseMovementFnArray["stand"]["walk"] =	::BeginStandWalk;
+	anim.SetPoseMovementFnArray["stand"]["run"] =	::BeginStandRun;
+	anim.SetPoseMovementFnArray["crouch"]["stop"] =	::BeginCrouchStop;
+	anim.SetPoseMovementFnArray["crouch"]["walk"] =	::BeginCrouchWalk;
+	anim.SetPoseMovementFnArray["crouch"]["run"] =	::BeginCrouchRun;
+	anim.SetPoseMovementFnArray["prone"]["stop"] =	::BeginProneStop;
+	anim.SetPoseMovementFnArray["prone"]["walk"] =	::BeginProneWalk;
+	anim.SetPoseMovementFnArray["prone"]["run"] =	::BeginProneRun;
+}
+BeginStandStop()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			return false;
+			case "walk":
+			StandWalkToStand();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			StandRunToStand();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToStand();
+			break;
+			case "walk":
+			CrouchWalkToStand();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			CrouchRunToStand();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		switch (self.a.movement)
+		{
+			case "stop":
+			ProneToStand();
+			break;
+			default:
+			assert(self.a.movement == "walk" || self.a.movement == "run");
+			ProneToStand();
+			break;
+		}
+		break;
+	}
+	return true;
+}
+BeginStandWalk()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			BlendIntoStandWalk();
+			break;
+			case "walk":
+			return false;
+			default:
+			assert(self.a.movement == "run");
+			BlendIntoStandWalk();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToStandWalk();
+			break;
+			case "walk":
+			BlendIntoStandWalk();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			BlendIntoStandWalk();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		ProneToStandWalk();
+		break;
+	}
+	return true;
+}
+BeginStandRun()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			BlendIntoStandRun();
+			break;
+			case "walk":
+			BlendIntoStandRun();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			return false;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToStandRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			BlendIntoStandRun();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		ProneToStandRun();
+		break;
+	}
+	return true;
+}
+BeginCrouchStop()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			StandToCrouch();
+			break;
+			case "walk":
+			StandWalkToCrouch();
+			break;
+			case "run":
+			StandRunToCrouch();
+			break;
+			default:
+			assertEX(0, "SetPoseMovement::BeginCrouchStop "+self.a.pose+" "+self.a.movement);
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			break;
+			case "walk":
+			CrouchWalkToCrouch();
+			break;
+			case "run":
+			CrouchRunToCrouch();
+			break;
+			default:
+			assertEX(0, "SetPoseMovement::BeginCrouchStop "+self.a.pose+" "+self.a.movement);
+		}
+		break;
+		case "prone":
+		ProneToCrouch();
+		break;
+		default:
+		assertEX(0, "SetPoseMovement::BeginCrouchStop "+self.a.pose+" "+self.a.movement);
+	}
+}
+BeginCrouchWalk()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			BlendIntoStandWalk();
+			BlendIntoCrouchWalk();
+			break;
+			case "walk":
+			BlendIntoCrouchWalk();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			BlendIntoCrouchWalk();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToCrouchWalk();
+			break;
+			case "walk":
+			return false;
+			default:
+			assert(self.a.movement == "run");
+			BlendIntoCrouchWalk();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		ProneToCrouchWalk();
+		break;
+	}
+	return true;
+}
+BeginCrouchRun()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			BlendIntoStandRun();
+			BlendIntoCrouchRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			BlendIntoCrouchRun();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToCrouchRun();
+			break;
+			case "walk":
+			BlendIntoCrouchRun();
+			break;
+			default:
+			assert(self.a.movement == "run");
+			return false;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		ProneToCrouchRun();
+		break;
+	}
+	return true;
+}
+BeginProneStop()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			StandToProne();
+			break;
+			case "walk":
+			StandToProne();
+			break;
+			case "run":
+			CrouchRunToProne();
+			break;
+			default:
+			assertEX(0, "SetPoseMovement::BeginCrouchRun "+self.a.pose+" "+self.a.movement);
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToProne();
+			break;
+			case "walk":
+			CrouchToProne();
+			break;
+			case "run":
+			CrouchRunToProne();
+			break;
+			default:
+			assertEX(0, "SetPoseMovement::BeginCrouchRun "+self.a.pose+" "+self.a.movement);
+		}
+		break;
+		case "prone":
+		switch (self.a.movement)
+		{
+			case "stop":
+			break;
+			case "walk":
+			case "run":
+			ProneCrawlToProne();
+			break;
+			default:
+			assertEX(0, "SetPoseMovement::BeginCrouchRun "+self.a.pose+" "+self.a.movement);
+		}
+		break;
+		default:
+		assertEX(0, "SetPoseMovement::BeginCrouchRun "+self.a.pose+" "+self.a.movement);
+	}
+}
+BeginProneWalk()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			StandToProneWalk();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			CrouchRunToProneWalk();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToProneWalk();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			CrouchRunToProneWalk();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		switch (self.a.movement)
+		{
+			case "stop":
+			ProneToProneRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			self.a.movement = "walk";
+			return false;
+		}
+		break;
+	}
+	return true;
+}
+BeginProneRun()
+{
+	switch (self.a.pose)
+	{
+		case "stand":
+		switch (self.a.movement)
+		{
+			case "stop":
+			StandToProneRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			CrouchRunToProneRun();
+			break;
+		}
+		break;
+		case "crouch":
+		switch (self.a.movement)
+		{
+			case "stop":
+			CrouchToProneRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			CrouchRunToProneRun();
+			break;
+		}
+		break;
+		default:
+		assert(self.a.pose == "prone");
+		switch (self.a.movement)
+		{
+			case "stop":
+			assert(self.a.movement == "stop");
+			ProneToProneRun();
+			break;
+			default:
+			assert(self.a.movement == "run" || self.a.movement == "walk");
+			self.a.movement = "run";
+			return false;
+		}
+		break;
+	}
+	return true;
+}
+PlayBlendTransition( transAnim, crossblendTime, endPose, endMovement, endAiming )
+{
+	endTime = GetTime() + crossblendTime * 1000;
+	self SetAnimKnobAll( transAnim, %body, 1, crossblendTime, 1 );
+	wait crossblendTime / 2;
+	self.a.pose = endPose;
+	self.a.movement = endMovement;
+	if ( endAiming )
+	{
+		self.a.alertness = "aiming";
+	}
+	else
+	{
+		self.a.alertness = "casual";
+	}
+	waittime = (endTime - GetTime()) / 1000;
+	if ( waittime < 0.05 )
+	{
+		waittime = 0.05;
+	}
+	wait waittime;
+}
+PlayTransitionStandWalk(transAnim, finalAnim)
+{
+	PlayTransitionAnimation(transAnim, "stand", "walk", 1, finalAnim);
+}
+StandWalkToStand()
+{
+	assertEX(self.a.pose == "stand", "SetPoseMovement::StandWalkToStand "+self.a.pose);
+	assertEX(self.a.movement == "walk", "SetPoseMovement::StandWalkToStand "+self.a.movement);
+	self.a.movement = "stop";
+}
+StandWalkToCrouch()
+{
+	StandWalkToStand();
+	StandToCrouch();
+}
+StandRunToStand()
+{
+	assertEX(self.a.pose == "stand", "SetPoseMovement::StandRunToStand "+self.a.pose);
+	assertEX(self.a.movement == "run", "SetPoseMovement::StandRunToStand "+self.a.movement);
+	self.a.movement = "stop";
+}
+StandRunToCrouch()
+{
+	self.a.movement = "stop";
+	self.a.pose = "crouch";
+}
+PlayBlendTransitionStandRun(animname)
+{
+	transtime = 0.3;
+	if (self.a.movement != "stop")
+	{
+		self endon("movemode");
+		transtime = 1.0;
+	}
+	PlayBlendTransition(animname, transtime, "stand", "run", 0);
+}
+BlendIntoStandRun()
+{
+	if( self call_overloaded_func( "animscripts\cqb", "shouldCQB" ) )
+	{
+		PlayBlendTransitionStandRun( animArray("start_cqb_run_f", "move") );
+	}
+	else if( self animscripts\utility::IsInCombat() && IsDefined(self.run_combatanim) )
+	{
+		PlayBlendTransitionStandRun(self.run_combatanim);
+	}
+	else if (IsDefined(self.run_noncombatanim))
+	{
+		PlayBlendTransitionStandRun(self.run_noncombatanim);
+	}
+	else
+	{
+		runAnimTransTime = 0.0;
+		if ( self.a.movement != "stop" )
+		{
+			runAnimTransTime = 0.5;
+		}
+		useLeans = true;
+		transitionAnimParent	= %combatrun;
+		forwardRunAnim = %combatrun_forward;
+		shouldShootWhileMoving	= false;
+		runAnimName = "start_stand_run_f";
+		if( self.a.pose == "stand" )
+		{
+			if ( call_overloaded_func( "animscripts\move", "MayShootWhileMoving" ) && self.bulletsInClip > 0 && isValidEnemy( self.enemy ) )
+			{
+				shouldShootWhileMoving = true;
+				if( self.a.pose == "stand" )
+				{
+					runAnimName = "run_n_gun_f";
+				}
+				if( call_overloaded_func( "animscripts\run", "ShouldShootWhileRunningBackward" ) )
+				{
+					self OrientMode( "face direction", vector_scale(self.lookaheaddir, -1) );
+				}
+			}
+		}
+		self SetAnimKnobLimited( animArray(runAnimName), 1, runAnimTransTime, 1 );
+		if( shouldShootWhileMoving && self.a.pose == "stand" )
+		{
+			self thread call_overloaded_func( "animscripts\run", "UpdateRunWeights", "BlendIntoStandRun",
+			forwardRunAnim,
+			animArray("run_n_gun_b")
+			);
+		}
+		else if( useLeans && self.isfacingmotion )
+		{
+			self thread call_overloaded_func( "animscripts\run", "UpdateRunWeights", "BlendIntoStandRun",
+			forwardRunAnim,
+			animArray("combat_run_b"),
+			animArray("combat_run_lean_l"),
+			animArray("combat_run_lean_r")
+			);
+		}
+		else
+		{
+			self thread call_overloaded_func( "animscripts\run", "UpdateRunWeights", "BlendIntoStandRun",
+			forwardRunAnim,
+			animArray("combat_run_b"),
+			animArray("combat_run_l"),
+			animArray("combat_run_r")
+			);
+		}
+		PlayBlendTransitionStandRun(transitionAnimParent);
+	}
+	self notify ("BlendIntoStandRun");
+}
+PlayBlendTransitionStandWalk(animname)
+{
+	if (self.a.movement != "stop")
+		self endon("movemode");
+	PlayBlendTransition(animname, 0.6, "stand", "walk", 1);
+}
+BlendIntoStandWalk()
+{
+	walkanim = animscripts\walk::getStandWalkAnim();
+	PlayBlendTransitionStandWalk( walkanim );
+}
+CrouchToStand()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchToStand "+self.a.pose);
+	assertEX(self.a.movement == "stop", "SetPoseMovement::CrouchToStand "+self.a.movement);
+	standSpeed = 0.5;
+	if (IsDefined (self.fastStand))
+	{
+		standSpeed = 1.8;
+		self.fastStand = undefined;
+	}
+	if ( (self animscripts\utility::weaponAnims() == "pistol") || (self animscripts\utility::weaponAnims() == "none") )
+	{
+		PlayTransitionAnimation( animArray("crouch_2_stand"), "stand", "stop", standSpeed );
+	}
+	else
+	{
+		self randomizeIdleSet();
+		PlayTransitionAnimation( animArray("crouch_2_stand"), "stand", "stop", standSpeed );
+	}
+	self ClearAnim(%shoot, 0);
+}
+CrouchToCrouchWalk()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchToCrouchWalk "+self.a.pose);
+	assertEX(self.a.movement == "stop", "SetPoseMovement::CrouchToCrouchWalk "+self.a.movement);
+	BlendIntoCrouchWalk();
+}
+CrouchToStandWalk()
+{
+	CrouchToCrouchWalk();
+	BlendIntoStandWalk();
+}
+CrouchWalkToCrouch()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchWalkToCrouch "+self.a.pose);
+	assertEX(self.a.movement == "walk", "SetPoseMovement::CrouchWalkToCrouch "+self.a.movement);
+	self.a.movement = "stop";
+}
+CrouchWalkToStand()
+{
+	CrouchWalkToCrouch();
+	CrouchToStand();
+}
+CrouchRunToCrouch()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchRunToCrouch "+self.a.pose);
+	assertEX(self.a.movement == "run", "SetPoseMovement::CrouchRunToCrouch "+self.a.movement);
+	self.a.movement = "stop";
+}
+CrouchRunToStand()
+{
+	CrouchRunToCrouch();
+	CrouchToStand();
+}
+CrouchToCrouchRun()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchToCrouchRun "+self.a.pose);
+	assertEX(self.a.movement == "stop", "SetPoseMovement::CrouchToCrouchRun "+self.a.movement);
+	BlendIntoCrouchRun();
+}
+CrouchToStandRun()
+{
+	BlendIntoStandRun();
+}
+BlendIntoCrouchRun()
+{
+	if (IsDefined(self.crouchrun_combatanim))
+	{
+		self SetAnimKnobAll(self.crouchrun_combatanim, %body, 1, 0.4);
+		PlayBlendTransition(self.crouchrun_combatanim, 0.6, "crouch", "run", 0);
+		self notify ("BlendIntoCrouchRun");
+	}
+	else
+	{
+		self setanimknob( call_overloaded_func( "animscripts\run", "GetCrouchRunAnim" ), 1, 0.4 );
+		self thread call_overloaded_func( "animscripts\run", "UpdateRunWeights", "BlendIntoCrouchRun",
+		%combatrun_forward,
+		animArray("combat_run_b"),
+		animArray("combat_run_l"),
+		animArray("combat_run_r")
+		);
+		PlayBlendTransition(%combatrun, 0.6, "crouch", "run", 0);
+		self notify ("BlendIntoCrouchRun");
+	}
+}
+ProneToCrouchRun()
+{
+	assertEX(self.a.pose == "prone", "SetPoseMovement::ProneToCrouchRun "+self.a.pose);
+	self OrientMode ("face current");
+	self ExitProneWrapper(1.0);
+	ProneLegsStraightTree(0.2);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	PlayTransitionAnimation( animArray("prone_2_crouch_run"), "crouch", "run", 0, animArray("crouch_run_f") );
+}
+ProneToStandRun()
+{
+	ProneToCrouchRun();
+	BlendIntoStandRun();
+}
+ProneToCrouchWalk()
+{
+	ProneToCrouchRun();
+	BlendIntoCrouchWalk();
+}
+BlendIntoCrouchWalk()
+{
+	if (IsDefined(self.crouchrun_combatanim))
+	{
+		self SetAnimKnobAll(self.crouchrun_combatanim, %body, 1, 0.4);
+		PlayBlendTransition(self.crouchrun_combatanim, 0.6, "crouch", "walk", 0);
+		self notify ("BlendIntoCrouchWalk");
+	}
+	else
+	{
+		PlayBlendTransition( animArray("crouch_run_f"), 0.8, "crouch", "walk", 1 );
+	}
+}
+StandToCrouch()
+{
+	assertEX(self.a.pose == "stand", "SetPoseMovement::StandToCrouch "+self.a.pose);
+	assertEX(self.a.movement == "stop", "SetPoseMovement::StandToCrouch "+self.a.movement);
+	self randomizeIdleSet();
+	crouchSpeed = 0.5;
+	if (IsDefined (self.fastCrouch))
+	{
+		crouchSpeed = 1.8;
+		self.fastCrouch = undefined;
+	}
+	if( self is_zombie() )
+	{
+		self ClearAnim(%shoot, 0);
+		return;
+	}
+	PlayTransitionAnimation( animArray("stand_2_crouch"), "crouch", "stop", 1, undefined, crouchspeed );
+	self ClearAnim(%shoot, 0);
+}
+ProneToCrouch()
+{
+	assertEX(self.a.pose == "prone", "SetPoseMovement::StandToCrouch "+self.a.pose);
+	self randomizeIdleSet();
+	self OrientMode("face current");
+	self ExitProneWrapper(1.0);
+	ProneLegsStraightTree(0.1);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	PlayTransitionAnimation( animArray("prone_2_crouch"), "crouch", "stop", 1 );
+}
+ProneToStand()
+{
+	assertEx( self.a.pose == "prone", self.a.pose );
+	self OrientMode ("face current");
+	self ExitProneWrapper(1.0);
+	ProneLegsStraightTree(0.1);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	PlayTransitionAnimation( animArray("prone_2_stand"), "stand", "stop", 1 );
+}
+ProneToStandWalk()
+{
+	ProneToCrouch();
+	CrouchToCrouchWalk();
+	BlendIntoStandWalk();
+}
+ProneToProneMove(movement)
+{
+	assertEX(self.a.pose == "prone", "SetPoseMovement::ProneToProneMove "+self.a.pose);
+	assertEX(self.a.movement == "stop", "SetPoseMovement::ProneToProneMove "+self.a.movement);
+	assertEX( (movement == "walk" || movement == "run"), "SetPoseMovement::ProneToProneMove got bad parameter "+movement);
+	ProneLegsStraightTree(0.1);
+	PlayTransitionAnimation( animArray("aim_2_crawl"), "prone", movement, 0, animArray("combat_run_f") );
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+}
+ProneToProneRun()
+{
+	ProneToProneMove("run");
+}
+ProneCrawlToProne()
+{
+	assertEX(self.a.pose == "prone", "SetPoseMovement::ProneCrawlToProne "+self.a.pose);
+	assertEX( (self.a.movement=="walk" || self.a.movement=="run"), "SetPoseMovement::ProneCrawlToProne "+self.a.movement);
+	ProneLegsStraightTree(0.1);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	PlayTransitionAnimation( animArray("crawl_2_aim"), "prone", "stop", 1 );
+	self ClearAnim( %exposed_modern, 0.2 );
+}
+CrouchToProne()
+{
+	assertEX(self.a.pose == "crouch", "SetPoseMovement::CrouchToProne "+self.a.pose);
+	self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
+	self EnterProneWrapper(1.0);
+	ProneLegsStraightTree(0.3);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	PlayTransitionAnimation( animArray("crouch_2_prone"), "prone", "stop", 1 );
+	self ClearAnim( %exposed_modern, 0.2 );
+}
+CrouchToProneWalk()
+{
+	CrouchToProne();
+	ProneToProneRun();
+}
+CrouchToProneRun()
+{
+	CrouchToProne();
+	ProneToProneRun();
+}
+StandToProne()
+{
+	assertEX(self.a.pose == "stand", "SetPoseMovement::StandToProne "+self.a.pose);
+	proneTime = 0.5;
+	transAnim = animArray("stand_2_prone");
+	thread PlayTransitionAnimationThread_WithoutWaitSetStates( transAnim, "prone", "stop", proneTime );
+	self waittillmatch("transAnimDone2", "anim_pose = \"prone\"");
+	waittillframeend;
+	self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
+	self EnterProneWrapper(proneTime);
+	self.a.movement = "stop";
+	self waittillmatch("transAnimDone2", "end");
+	self ClearAnim( %exposed_modern, 0.2 );
+}
+StandToProneWalk()
+{
+	StandToProne();
+	ProneToProneRun();
+}
+StandToProneRun()
+{
+	StandToProne();
+	ProneToProneRun();
+}
+CrouchRunToProne()
+{
+	assertEX((self.a.pose == "crouch")||(self.a.pose == "stand"), "SetPoseMovement::CrouchRunToProne "+self.a.pose);
+	assertEX((self.a.movement == "run"||self.a.movement == "walk"), "SetPoseMovement::CrouchRunToProne "+self.a.movement);
+	pronetime = 0.5;
+	self setProneAnimNodes( -45, 45, %prone_legs_down, %exposed_aiming, %prone_legs_up );
+	self EnterProneWrapper(proneTime);
+	ProneLegsStraightTree(0.2);
+	self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+	runDirection = animscripts\utility::getQuadrant ( self getMotionAngle() );
+	diveanim = animArray("run_2_prone_dive", "move");
+	localDeltaVector = GetMoveDelta (diveanim, 0, 1);
+	endPoint = self LocalToWorldCoords( localDeltaVector );
+	if (self maymovetopoint(endPoint))
+	{
+		PlayTransitionAnimation( diveanim, "prone", "stop", pronetime );
+	}
+	else
+	{
+		PlayTransitionAnimation( animArray("run_2_prone_gunsupport", "move"), "prone", "stop", pronetime );
+	}
+}
+CrouchRunToProneWalk()
+{
+	CrouchRunToProne();
+	ProneToProneRun();
+}
+CrouchRunToProneRun()
+{
+	CrouchRunToProne();
+	ProneToProneRun();
+}
+PlayTransitionAnimationThread_WithoutWaitSetStates(transAnim, endPose, endMovement, endAiming, finalAnim, rate)
+{
+	self endon ("killanimscript");
+	self endon ("entered_pose" + endPose);
+	PlayTransitionAnimationFunc(transAnim, endPose, endMovement, endAiming, finalAnim, rate, false);
+}
+PlayTransitionAnimation(transAnim, endPose, endMovement, endAiming, finalAnim, rate)
+{
+	PlayTransitionAnimationFunc(transAnim, endPose, endMovement, endAiming, finalAnim, rate, true);
+}
+PlayTransitionAnimationFunc(transAnim, endPose, endMovement, endAiming, finalAnim, rate, waitSetStatesEnabled)
+{
+	if (!IsDefined (rate))
+		rate = 1;
+	if (waitSetStatesEnabled)
+	{
+		self thread waitSetStates ( getanimlength(transAnim)/2.0, "killtimerscript", endPose);
+	}
+	self SetFlaggedAnimKnobAllRestart("transAnimDone2", transAnim, %body, 1, .2, rate);
+	if (!IsDefined(self.a.pose))
+	{
+		self.pose = "undefined";
+	}
+	if (!IsDefined(self.a.movement))
+	{
+		self.movement = "undefined";
+	}
+	debugIdentifier = "";
+	self animscripts\shared::DoNoteTracks("transAnimDone2", undefined, debugIdentifier);
+	self notify ("killtimerscript");
+	self.a.pose = endPose;
+	self notify ("entered_pose" + endPose);
+	self.a.movement = endMovement;
+	if (endAiming)
+	{
+		self.a.alertness = "aiming";
+	}
+	else
+	{
+		self.a.alertness = "casual";
+	}
+	if (IsDefined(finalAnim))
+	{
+		self SetAnimKnobAll(finalAnim, %body, 1, 0.3, rate);
+	}
+}
+waitSetStates ( timetowait, killmestring, endPose )
+{
+	self endon("killanimscript");
+	self endon ("death");
+	self endon(killmestring);
+	oldpose = self.a.pose;
+	wait timetowait;
+	if ( oldpose!="prone" && endPose =="prone" )
+	{
+		self call_overloaded_func( "animscripts\cover_prone", "UpdateProneWrapper", 0.1 );
+		self EnterProneWrapper(1.0);
+	}
+	else if ( oldpose=="prone" && endPose !="prone" )
+	{
+		self ExitProneWrapper(1.0);
+		self OrientMode ("face default");
+	}
+}
+ProneLegsStraightTree(blendtime)
+{
+}

BO1/PC/ZM/animscripts/squadmanager.gsc

@@ -0,0 +1,741 @@
+
+init_squadManager()
+{
+	if (IsDefined (anim.squadInitialized) && anim.squadInitialized)
+	{
+		return;
+	}
+	anim.squadCreateFuncs = [];
+	anim.squadCreateStrings = [];
+	anim.squads = [];
+	anim.squadIndex = [];
+	anim.squadRand = 0;
+	anim.squadInitialized = true;
+}
+createSquad(squadName)
+{
+	assertex (!IsDefined (anim.squads[squadName]), "createSquad attempted to create a squad with the same name as an existing squad");
+	anim.squads[squadName] = SpawnStruct();
+	squad = anim.squads[squadName];
+	squad.squadName = squadName;
+	squad.sightTime = 0;
+	squad.origin = undefined;
+	squad.forward = undefined;
+	squad.enemy = undefined;
+	squad.isInCombat = false;
+	squad.memberCount = 0;
+	squad.members = [];
+	squad.officers = [];
+	squad.officerCount = 0;
+	squad.squadList = [];
+	squad.memberAddFuncs = [];
+	squad.memberAddStrings = [];
+	squad.memberRemoveFuncs = [];
+	squad.memberRemoveStrings = [];
+	squad.squadUpdateFuncs = [];
+	squad.squadUpdateStrings = [];
+	squad.squadID = anim.squadIndex.size;
+	squad initState ("combat", 0.75);
+	squad initState ("cover", 0.75);
+	squad initState ("move", 0.75);
+	squad initState ("stop", 0.75);
+	squad initState ("death", 0.75);
+	squad initState ("suppressed", 0.75);
+	squad initState ("attacking", 0.5);
+	anim.squadIndex[anim.squadIndex.size] = squad;
+	squad updateSquadList();
+	level notify ("squad created " + squadName);
+	anim notify ("squad created " + squadName);
+	for (i = 0; i < anim.squadCreateFuncs.size; i++)
+	{
+		squadCreateFunc = anim.squadCreateFuncs[i];
+		squad thread [[squadCreateFunc]] ();
+	}
+	for (i = 0; i < anim.squadIndex.size; i++)
+	{
+		anim.squadIndex[i] updateSquadList();
+	}
+	squad thread updateMemberStates();
+	return (squad);
+}
+deleteSquad(squadName)
+{
+	assertex (IsDefined (anim.squads[squadName]), "deleteSquad attempted to delete a squad that does not exist");
+	if (squadName == "axis" || squadName == "allies")
+	{
+		return;
+	}
+	squadID = anim.squads[squadName].squadID;
+	squad = anim.squads[squadName];
+	while (squad.members.size)
+	{
+		squad.members[0] addToSquad(squad.members[0].team);
+	}
+	anim.squadIndex[squadID] = anim.squadIndex[anim.squadIndex.size - 1];
+	anim.squadIndex[squadID].squadID = squadID;
+	anim.squadIndex[anim.squadIndex.size - 1] = undefined;
+	anim.squads[squadName] = undefined;
+	level notify ("squad deleted " + squadName);
+	anim notify ("squad deleted " + squadName);
+	for (i = 0; i < anim.squadIndex.size; i++)
+	{
+		anim.squadIndex[i] updateSquadList();
+	}
+}
+generateSquadName()
+{
+	squadName = "auto" + anim.squadRand;
+	anim.squadRand++;
+	return (squadName);
+}
+addPlayerToSquad(squadName)
+{
+	if (!IsDefined (squadName))
+	{
+		if (IsDefined (self.script_squadname))
+		{
+			squadName = self.script_squadname;
+		}
+		else
+		{
+			squadName = self.team;
+		}
+	}
+	if (!IsDefined (anim.squads[squadName]))
+	{
+		anim createSquad (squadName);
+	}
+	squad = anim.squads[squadName];
+	self.squad = squad;
+}
+squadChange()
+{
+	self endon ("death");
+	wait (10.0);
+	if (!IsDefined (self.script_squadname))
+	{
+		squadName = (self.team + self.script_flanker);
+	}
+	else
+	{
+		squadName = (self.script_squadname + self.script_flanker);
+	}
+	self addToSquad (squadName);
+}
+addToSquad( squadName )
+{
+	assertex (IsSentient (self), "addToSquad attempted to add a non-sentient member to a squad");
+	if ( !IsDefined( squadName ) )
+	{
+		if ( IsDefined( self.script_flanker ) )
+		{
+			self thread squadChange();
+		}
+		if (IsDefined (self.script_squadname))
+		{
+			squadName = self.script_squadname;
+		}
+		else
+		{
+			squadName = self.team;
+		}
+	}
+	if ( !IsDefined( anim.squads[squadName] ) )
+	{
+		anim createSquad( squadName );
+	}
+	squad = anim.squads[squadName];
+	if ( IsDefined( self.squad ) )
+	{
+		if ( self.squad == squad )
+		{
+			return;
+		}
+		else
+		{
+			self removeFromSquad();
+		}
+	}
+	self.lastEnemySightTime = 0;
+	self.combatTime = 0;
+	self.squad = squad;
+	self.memberID = squad.members.size;
+	squad.members[self.memberID] = self;
+	squad.memberCount = squad.members.size;
+	if ( IsDefined( level.loadoutComplete ) )
+	{
+		if ( self.team == "allies" && self isOfficer() )
+		{
+			self addOfficerToSquad();
+		}
+	}
+	for (i = 0; i < self.squad.memberAddFuncs.size; i++)
+	{
+		memberAddFunc = self.squad.memberAddFuncs[i];
+		self thread [[memberAddFunc]] (self.squad.squadName);
+	}
+	self thread memberDeathWaiter();
+}
+removeFromSquad()
+{
+	assertex (IsDefined (self.squad), "removeFromSquad attempted to remove a member who was not part of a squad (self.squad == undefined)");
+	squad = self.squad;
+	memberID = -1;
+	if (IsDefined (self))
+	{
+		memberID = self.memberID;
+	}
+	else
+	{
+		for (i = 0; i < squad.members.size; i++)
+		{
+			if (squad.members[i] == self)
+			{
+				memberID = i;
+			}
+		}
+	}
+	assertex (memberID > -1, "removeFromSquad could not find memberID");
+	if (memberID != squad.members.size - 1)
+	{
+		other = squad.members[squad.members.size - 1];
+		squad.members[memberID] = other;
+		if (IsDefined (other))
+		{
+			other.memberID = memberID;
+		}
+	}
+	squad.members[squad.members.size - 1] = undefined;
+	squad.memberCount = squad.members.size;
+	if (IsDefined (self.officerID))
+	{
+		self removeOfficerFromSquad();
+	}
+	for (i = 0; i < self.squad.memberRemoveFuncs.size; i++)
+	{
+		memberRemoveFunc = self.squad.memberRemoveFuncs[i];
+		self thread [[memberRemoveFunc]] (squad.squadName);
+	}
+	assert (squad.members.size == squad.memberCount);
+	if (squad.memberCount == 0)
+	{
+		deleteSquad (squad.squadName);
+	}
+	if (IsDefined (self))
+	{
+		self.squad = undefined;
+		self.memberID = undefined;
+	}
+	self notify ("removed from squad");
+}
+addOfficerToSquad()
+{
+	squad = self.squad;
+	if (IsDefined (self.officerID))
+	{
+		return;
+	}
+	assertex (!IsDefined (self.officerID), "addOfficerToSquad attempted to add a member that is already in an officers");
+	self.officerID = squad.officers.size;
+	squad.officers[self.officerID] = self;
+	squad.officerCount = squad.officers.size;
+}
+removeOfficerFromSquad()
+{
+	squad = self.squad;
+	officerID = -1;
+	if (IsDefined (self))
+	{
+		officerID = self.officerID;
+	}
+	else
+	{
+		for (i = 0; i < squad.officers.size; i++)
+		{
+			if (squad.officers[i] == self)
+			{
+				officerID = i;
+			}
+		}
+	}
+	assertex (officerID > -1, "removeOfficerFromSquad could not find officerID");
+	if (officerID != squad.officers.size - 1)
+	{
+		other = squad.officers[squad.officers.size - 1];
+		squad.officers[officerID] = other;
+		if (IsDefined (other))
+		{
+			other.officerID = officerID;
+		}
+	}
+	squad.officers[squad.officers.size - 1] = undefined;
+	squad.officerCount = squad.officers.size;
+	assert (squad.officers.size == squad.officerCount);
+	if (IsDefined (self))
+	{
+		self.officerID = undefined;
+	}
+}
+officerWaiter()
+{
+	if (!IsDefined (level.loadoutComplete))
+	{
+		anim waittill ("loadout complete");
+	}
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (self.members[i] isOfficer())
+		{
+			self.members[i] addOfficerToSquad();
+		}
+	}
+}
+updateWaiter()
+{
+	while (1)
+	{
+		anim waittill ("squadupdate", action);
+		switch (action)
+		{
+			case "squadlist":
+			self updateSquadList();
+			break;
+			case "combat":
+			self updateCombat();
+			break;
+			case "origin":
+			self updateOrigin();
+			break;
+			case "forward":
+			self updateHeading();
+			break;
+		}
+	}
+}
+squadTracker()
+{
+	anim endon ("squad deleted " + self.squadName);
+	while (1)
+	{
+		self updateAll();
+		wait (0.1);
+	}
+}
+memberDeathWaiter()
+{
+	self endon ("removed from squad");
+	self waittill ("death", attacker);
+	self removeFromSquad();
+}
+memberCombatWaiter()
+{
+	self endon ("removed from squad");
+	while (1)
+	{
+		self waittill ("enemy");
+		if (!IsDefined (self.enemy))
+		{
+			self.squad notify ("squadupdate", "combat");
+		}
+		else
+		{
+			self.squad.isInCombat = true;
+		}
+		wait ( 0.05 );
+	}
+}
+updateHeading()
+{
+	if (IsDefined (self.enemy))
+	{
+		self.forward = VectorNormalize (self.enemy.origin - self.origin);
+		return;
+	}
+	newHeading = (0, 0, 0);
+	numInfluences = 0;
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (!IsAlive(self.members[i]))
+		{
+			continue;
+		}
+		newHeading += AnglesToForward (self.members[i].angles);
+		numInfluences++;
+	}
+	if (numInfluences)
+	{
+		self.forward = (newHeading[0] / numInfluences, newHeading[1] / numInfluences, newHeading[2] / numInfluences);
+	}
+	else
+	{
+		self.forward = newHeading;
+	}
+}
+updateOrigin()
+{
+	newOrigin = (0, 0, 0);
+	numInfluences = 0;
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (!IsAlive (self.members[i]))
+		{
+			continue;
+		}
+		newOrigin += self.members[i].origin;
+		numInfluences++;
+	}
+	if (numInfluences)
+	{
+		self.origin = (newOrigin[0] / numInfluences, newOrigin[1] / numInfluences, newOrigin[2] / numInfluences);
+	}
+	else
+	{
+		self.origin = newOrigin;
+	}
+}
+updateCombat()
+{
+	self.isInCombat = false;
+	for (i = 0; i < anim.squadIndex.size; i++)
+	{
+		if (IsDefined (anim.squadIndex[i].squadName) )
+		{
+			self.squadList[anim.squadIndex[i].squadName].isInContact = false;
+		}
+	}
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (IsDefined (self.members[i].enemy) &&
+		IsDefined (self.members[i].enemy.squad) &&
+		IsDefined(self.members[i].enemy.squad.squadName) &&
+		self.members[i].combatTime > 0)
+		{
+			if( isdefined( self.squadList[self.members[i].enemy.squad.squadName] ) )
+			{
+				self.squadList[self.members[i].enemy.squad.squadName].isInContact = true;
+			}
+		}
+	}
+}
+updateAll()
+{
+	newOrigin = (0, 0, 0);
+	numInfluences = 0;
+	curEnemy = undefined;
+	isInCombat = false;
+	self updateCombat();
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (!IsAlive (self.members[i]))
+		{
+			continue;
+		}
+		newOrigin += self.members[i].origin;
+		numInfluences++;
+		if (IsDefined (self.members[i].enemy) && IsDefined (self.members[i].enemy.squad))
+		{
+			if (!IsDefined (curEnemy))
+			{
+				curEnemy = self.members[i].enemy.squad;
+			}
+			else if (self.members[i].enemy.squad.memberCount > curEnemy.memberCount)
+			{
+				curEnemy = self.members[i].enemy.squad;
+			}
+		}
+	}
+	if (numInfluences)
+	{
+		self.origin = (newOrigin[0] / numInfluences, newOrigin[1] / numInfluences, newOrigin[2] / numInfluences);
+	}
+	else
+	{
+		self.origin = newOrigin;
+	}
+	self.isInCombat = isInCombat;
+	self.enemy = curEnemy;
+	self updateHeading();
+}
+updateSquadList()
+{
+	for (i = 0; i < anim.squadIndex.size; i++)
+	{
+		if (!IsDefined (self.squadList[anim.squadIndex[i].squadName]))
+		{
+			self.squadList[anim.squadIndex[i].squadName] = SpawnStruct();
+			self.squadList[anim.squadIndex[i].squadName].isInContact = false;
+		}
+		for (j = 0; j < self.squadUpdateFuncs.size; j++)
+		{
+			squadUpdateFunc = self.squadUpdateFuncs[j];
+			self thread [[squadUpdateFunc]] (anim.squadIndex[i].squadName);
+		}
+	}
+}
+isOfficer()
+{
+	fullRank = self animscripts\battlechatter::getRank();
+	return (fullRank == "sergeant" || fullRank == "lieutenant" || fullRank == "captain" || fullRank == "sergeant");
+}
+aiUpdateAnimState(animscript)
+{
+	switch (animscript)
+	{
+		case "combat":
+		case "move":
+		case "stop":
+		case "death":
+		self.a.state = animscript;
+		break;
+		case "pain":
+		case "grenadecower":
+		break;
+		case "cover_crouch":
+		case "cover_left":
+		case "cover_prone":
+		case "cover_right":
+		case "cover_stand":
+		case "cover_wide_left":
+		case "cover_wide_right":
+		case "concealment_crouch":
+		case "concealment_prone":
+		case "concealment_stand":
+		case "stalingrad_cover_crouch":
+		self.a.state = "cover";
+		break;
+		case "aim":
+		case "l33t truckride combat":
+		self.a.state = "combat";
+		break;
+	}
+}
+updateStates()
+{
+	self resetState ("combat");
+	self resetState ("cover");
+	self resetState ("move");
+	self resetState ("stop");
+	self resetState ("death");
+	self resetState ("suppressed");
+	self resetState ("attacking");
+	for (i = 0; i < self.members.size; i++)
+	{
+		if (!IsAlive (self.members[i]))
+		{
+			continue;
+		}
+		self queryMemberAnimState (self.members[i]);
+		self queryMemberState (self.members[i], "suppressed");
+		self queryMemberState (self.members[i], "combat");
+		self queryMemberState (self.members[i], "attacking");
+		self queryMemberState (self.members[i], "cover");
+	}
+}
+updateMemberStates()
+{
+	anim endon ("squad deleted " + self.squadName);
+	timeSlice = 0.2;
+	while (1)
+	{
+		for (i = 0; i < self.members.size; i++)
+		{
+			if (!IsAlive (self.members[i]))
+			{
+				continue;
+			}
+			self.members[i] aiUpdateMessages(timeSlice);
+		}
+		wait (timeSlice);
+	}
+}
+aiUpdateCombat(timeSlice)
+{
+	if (IsDefined (self.lastEnemySightPos))
+	{
+		if (self.combatTime < 0)
+		{
+			self.combatTime = timeSlice;
+		}
+		else
+		{
+			self.combatTime += timeSlice;
+		}
+		self.lastEnemySightTime = GetTime();
+		return;
+	}
+	else if (self issuppressed())
+	{
+		self.combatTime += timeSlice;
+		return;
+	}
+	if (self.combatTime > 0)
+	{
+		self.combatTime = (0 - timeSlice);
+	}
+	else
+	{
+		self.combatTime -= timeSlice;
+	}
+}
+aiUpdateSuppressed(timeSlice)
+{
+	if (self.suppressed)
+	{
+		if (self.suppressedTime < 0)
+		{
+			self.suppressedTime = timeSlice;
+		}
+		else
+		{
+			self.suppressedTime += timeSlice;
+		}
+		return;
+	}
+	if (self.suppressedTime > 0)
+	{
+		self.suppressedTime = (0 - timeSlice);
+	}
+	else
+	{
+		self.suppressedTime -= timeSlice;
+	}
+}
+initState(state, activateRatio)
+{
+	self.squadStates[state] = SpawnStruct();
+	self.squadStates[state].activateRatio = activateRatio;
+	self.squadStates[state].isActive = false;
+	self.squadStates[state].numActive = 0;
+}
+resetState(state)
+{
+	self.squadStates[state].isActive = false;
+	self.squadStates[state].numActive = 0;
+}
+queryMemberAnimState(member)
+{
+	self.squadStates[member.a.state].numActive++;
+	if (self.squadStates[member.a.state].numActive > (self.squadStates[member.a.state].activateRatio * self.members.size))
+	{
+		self.squadStates[member.a.state].isActive = true;
+	}
+}
+queryMemberState(member, state)
+{
+	switch (state)
+	{
+		case "suppressed":
+		if (member.suppressedTime > 1.0)
+		{
+			self.squadStates[state].numActive++;
+		}
+		break;
+		case "combat":
+		if (member.combatTime > 0.0)
+		{
+			self.squadStates[state].numActive++;
+		}
+		break;
+		case "attacking":
+		if (GetTime() < member.a.lastShootTime + 2000)
+		{
+			self.squadStates[state].numActive++;
+		}
+		break;
+		case "cover":
+		if (!member animscripts\battlechatter::isExposed())
+		{
+			self.squadStates[state].numActive++;
+		}
+		break;
+	}
+	if (self.squadStates[state].numActive > (self.squadStates[state].activateRatio * self.members.size))
+	{
+		self.squadStates[state].isActive = true;
+	}
+}
+aiUpdateMessages(timeSlice)
+{
+	self removeExpiredMessages();
+}
+constructMessage(contents, lifetime, sender)
+{
+	assert( IsDefined(contents) );
+	if( IsDefined(contents) )
+	{
+		message = SpawnStruct();
+		if( !IsDefined(lifetime) )
+		{
+			lifetime = 0.05;
+		}
+		message.contents	= contents;
+		message.sender = sender;
+		message.sendTime	= GetTime();
+		message.expireTime	= GetTime() + lifetime * 1000;
+		return message;
+	}
+	return undefined;
+}
+postSquadMessage(contents, lifetime)
+{
+	assert( IsDefined(self.squad) );
+	assert( IsDefined(self.squad.members) );
+	message = constructMessage( contents, lifetime, self );
+	if( IsDefined(message) )
+	{
+		for( i=0; i < self.squad.members.size; i++ )
+		{
+			if( !IsAlive(self.squad.members[i]) || self == self.squad.members[i] )
+			{
+				continue;
+			}
+			self.squad.members[i] postMessage(message);
+		}
+	}
+}
+postMessage(message)
+{
+	assert( IsDefined(message) );
+	if( IsDefined(message) )
+	{
+		if( !IsDefined(self.messages) )
+		{
+			self.messages = [];
+		}
+		self.messages[ self.messages.size ] = message;
+	}
+}
+hasMessage(contents)
+{
+	if( IsDefined(self.messages) && self.messages.size > 0 )
+	{
+		for( i=0; i < self.messages.size; i++ )
+		{
+			message = self.messages[i];
+			if( IsDefined(message) && message.contents == contents )
+			{
+				return true;
+			}
+		}
+	}
+	return false;
+}
+removeExpiredMessages()
+{
+	if( IsDefined(self.messages) && self.messages.size > 0 )
+	{
+		newArray = [];
+		for( i=0; i < self.messages.size; i++ )
+		{
+			message = self.messages[i];
+			if( !IsDefined(message) || message.expireTime < GetTime() )
+			{
+				continue;
+			}
+			newArray[newArray.size] = message;
+		}
+		self.messages = newArray;
+	}
+}
+
+

BO1/PC/ZM/animscripts/traverse/zombie_shared.gsc

@@ -0,0 +1,364 @@
+#include common_scripts\utility;
+#using_animtree ("generic_human");
+init_traverse()
+{
+	point = GetEnt(self.target, "targetname");
+	if (IsDefined(point))
+	{
+		self.traverse_height = point.origin[2];
+		point Delete();
+	}
+	else
+	{
+		point = getstruct(self.target, "targetname");
+		if (IsDefined(point))
+		{
+			self.traverse_height = point.origin[2];
+		}
+	}
+}
+teleportThread( verticalOffset )
+{
+	self endon ("killanimscript");
+	self notify("endTeleportThread");
+	self endon("endTeleportThread");
+	reps = 5;
+	offset = ( 0, 0, verticalOffset / reps);
+	for ( i = 0; i < reps; i++ )
+	{
+		self Teleport( self.origin + offset );
+		wait .05;
+	}
+}
+teleportThreadEx( verticalOffset, delay, frames )
+{
+	self endon ("killanimscript");
+	self notify("endTeleportThread");
+	self endon("endTeleportThread");
+	if ( verticalOffset == 0 )
+		return;
+	wait delay;
+	amount = verticalOffset / frames;
+	if ( amount > 10.0 )
+		amount = 10.0;
+	else if ( amount < -10.0 )
+		amount = -10.0;
+	offset = ( 0, 0, amount );
+	for ( i = 0; i < frames; i++ )
+	{
+		self Teleport( self.origin + offset );
+		wait .05;
+	}
+}
+PrepareForTraverse()
+{
+	self.a.pose = "stand";
+}
+DoTraverse( traverseData )
+{
+	self endon( "killanimscript" );
+	self.traverseAnimIsSequence = (
+	IsDefined(traverseData[ "traverseAnimType" ])
+	&& (traverseData[ "traverseAnimType" ] == "sequence")
+	);
+	self.traverseAnim = traverseData[ "traverseAnim" ];
+	self.traverseAnimTransIn =	traverseData[ "traverseAnimTransIn" ];
+	self.traverseAnimTransOut =	traverseData[ "traverseAnimTransOut" ];
+	self.traverseSound = traverseData[ "traverseSound" ];
+	self.traverseAlertness =	traverseData[ "traverseAlertness" ];
+	self.traverseStance = traverseData[ "traverseStance" ];
+	self.traverseHeight = traverseData[ "traverseHeight" ];
+	self.traverseMovement = traverseData[ "traverseMovement" ];
+	self.traverseToCoverAnim =	traverseData[ "traverseToCoverAnim" ];
+	self.traverseToCoverSound =	traverseData[ "traverseToCoverSound" ];
+	self.traverseDeathAnim =	traverseData[ "interruptDeathAnim" ];
+	self.traverseDeathIndex = 0;
+	self traverseMode( "nogravity" );
+	self traverseMode( "noclip" );
+	if (!IsDefined(self.traverseStance))
+	{
+		self.desired_anim_pose = "stand";
+	}
+	else
+	{
+		self.desired_anim_pose = self.traverseStance;
+	}
+	animscripts\zombie_utility::UpdateAnimPose();
+	self.traverseStartNode = self GetNegotiationStartNode();
+	self.traverseEndNode = self GetNegotiationEndNode();
+	assert( IsDefined( self.traverseStartNode ) );
+	assert( IsDefined( self.traverseEndNode ) );
+	self OrientMode( "face angle", self.traverseStartNode.angles[1] );
+	self.traverseStartZ = self.origin[2];
+	toCover = false;
+	if ( IsDefined( self.traverseToCoverAnim ) && IsDefined( self.node ) && self.node.type == traverseData[ "coverType" ] && DistanceSquared( self.node.origin, self.traverseEndNode.origin ) < 25 * 25 )
+	{
+		if ( AbsAngleClamp180( self.node.angles[1] - self.traverseEndNode.angles[1] ) > 160 )
+		{
+			toCover = true;
+			self.traverseAnim = self.traverseToCoverAnim;
+		}
+	}
+	if (IsArray(self.traverseAnim) && !self.traverseAnimIsSequence)
+	{
+		self.traverseAnim = random(self.traverseAnim);
+	}
+	self DoTraverse_Animation();
+	self traverseMode("gravity");
+	if (self.delayedDeath)
+	{
+		return;
+	}
+	self.a.nodeath = false;
+	if (toCover && IsDefined(self.node) && DistanceSquared(self.origin, self.node.origin) < 16 * 16)
+	{
+		self.a.movement = "stop";
+		self Teleport( self.node.origin );
+	}
+	else
+	{
+		if (IsDefined(self.traverseAlertness))
+		{
+			self.a.alertness = self.traverseAlertness;
+		}
+		if (IsDefined(self.traverseMovement))
+		{
+			self.a.movement = self.traverseMovement;
+		}
+		self SetAnimKnobAllRestart( animscripts\zombie_run::GetRunAnim(), %body, 1, 0.2, 1 );
+		wait(.2);
+	}
+}
+DoTraverse_Animation()
+{
+	traverseAnim = self.traverseAnim;
+	if (!IsArray(traverseAnim))
+	{
+		traverseAnim = add_to_array(undefined, traverseAnim);
+	}
+	self ClearAnim(%body, 0.2);
+	played_trans_in = false;
+	if (IsDefined(self.traverseAnimTransIn))
+	{
+		played_trans_in = true;
+		self SetFlaggedAnimKnobRestart("traverseAnim", self.traverseAnimTransIn, 1, 0.2, 1);
+		if (traverseAnim.size || IsDefined(self.traverseAnimTransOut))
+		{
+			self animscripts\zombie_shared::DoNoteTracks("traverseAnim", ::handleTraverseNotetracks);
+		}
+		else
+		{
+			self thread animscripts\zombie_shared::DoNoteTracks("traverseAnim", ::handleTraverseNotetracks);
+			wait_anim_length(self.traverseAnimTransIn, .2);
+		}
+	}
+	blend = .2;
+	for (i = 0; i < traverseAnim.size; i++)
+	{
+		if (played_trans_in || i > 0 )
+		{
+			blend = 0;
+		}
+		DoMainTraverse_Animation(traverseAnim[i], blend);
+	}
+	if (IsDefined(self.traverseAnimTransOut))
+	{
+		self SetFlaggedAnimKnobRestart("traverseAnim", self.traverseAnimTransOut, 1, 0, 1);
+		self thread animscripts\zombie_shared::DoNoteTracks("traverseAnim", ::handleTraverseNotetracks);
+		wait_anim_length(self.traverseAnimTransOut, .2);
+	}
+}
+DoMainTraverse_Animation(animation, blend)
+{
+	self SetFlaggedAnimKnobRestart("traverseAnim", animation, 1, blend, 1);
+	self thread TraverseRagdollDeath(animation);
+	self animscripts\zombie_shared::DoNoteTracks("traverseAnim", ::handleTraverseNotetracks);
+}
+wait_anim_length(animation, blend)
+{
+	len = GetAnimLength(animation) - blend;
+	if (len > 0)
+	{
+		wait len;
+	}
+}
+handleTraverseNotetracks( note )
+{
+	if ( note == "traverse_death" )
+	{
+		return handleTraverseDeathNotetrack();
+	}
+}
+handleTraverseDeathNotetrack()
+{
+	self endon( "killanimscript" );
+	if ( self.delayedDeath )
+	{
+		self.a.noDeath = true;
+		self.exception["move"] = ::doNothingFunc;
+		self traverseDeath();
+		return true;
+	}
+	self.traverseDeathIndex++;
+}
+handleTraverseAlignment()
+{
+	self traverseMode( "nogravity" );
+	self traverseMode( "noclip" );
+	if ( IsDefined( self.traverseHeight ) && IsDefined( self.traverseStartNode.traverse_height ) )
+	{
+		currentHeight = self.traverseStartNode.traverse_height - self.traverseStartZ;
+		self thread teleportThread( currentHeight - self.traverseHeight );
+	}
+}
+doNothingFunc()
+{
+	self AnimMode( "zonly_physics" );
+	self waittill ( "killanimscript" );
+}
+traverseDeath()
+{
+	self notify("traverse_death");
+	if ( !IsDefined( self.triedTraverseRagdoll ) )
+		self animscripts\zombie_death::PlayDeathSound();
+	deathAnimArray = self.traverseDeathAnim[ self.traverseDeathIndex ];
+	deathAnim = deathAnimArray[ RandomInt( deathAnimArray.size ) ];
+	animscripts\zombie_death::play_death_anim( deathAnim );
+	self DoDamage( self.health + 5, self.origin );
+}
+TraverseStartRagdollDeath()
+{
+	self.prevDelayedDeath = self.delayedDeath;
+	self.prevAllowDeath = self.allowDeath;
+	self.prevDeathFunction = self.deathFunction;
+	self.delayedDeath = false;
+	self.allowDeath = true;
+	self.deathFunction = ::TraverseRagdollDeathSimple;
+}
+TraverseStopRagdollDeath()
+{
+	self.delayedDeath = self.prevDelayedDeath;
+	self.allowDeath = self.prevAllowDeath;
+	self.deathFunction = self.prevDeathFunction;
+	self.prevDelayedDeath = undefined;
+	self.prevAllowDeath = undefined;
+	self.prevDeathFunction = undefined;
+}
+TraverseRagdollDeathSimple()
+{
+	self animscripts\zombie_death::PlayDeathSound();
+	self startRagdoll();
+	deathAnim = animscripts\zombie_death::get_death_anim();
+	self SetFlaggedAnimKnobAllRestart( "deathanim", deathAnim, %body, 1, .1 );
+	if( AnimHasNotetrack( deathAnim, "death_neckgrab_spurt" ) )
+	{
+		PlayFXOnTag( level._effects[ "death_neckgrab_spurt" ], self, "j_neck" );
+	}
+	wait 0.5;
+	return true;
+}
+TraverseRagdollDeath( traverseAnim )
+{
+	self notify("TraverseRagdollDeath");
+	self endon("TraverseRagdollDeath");
+	self endon("traverse_death");
+	self endon("killanimscript");
+	while(1)
+	{
+		self waittill("damage");
+		if ( !self.delayedDeath )
+		{
+			continue;
+		}
+		scriptedDeathTimes = GetNotetrackTimes( traverseAnim, "traverse_death" );
+		currentTime = self GetAnimTime( traverseAnim );
+		scriptedDeathTimes[ scriptedDeathTimes.size ] = 1.0;
+		for ( i = 0; i < scriptedDeathTimes.size; i++ )
+		{
+			if ( scriptedDeathTimes[i] > currentTime )
+			{
+				animLength = GetAnimLength( traverseAnim );
+				timeUntilScriptedDeath = (scriptedDeathTimes[i] - currentTime) * animLength;
+				if ( timeUntilScriptedDeath < 0.5 )
+				{
+					return;
+				}
+				break;
+			}
+		}
+		self.deathFunction = ::postTraverseDeathAnim;
+		self.exception["move"] = ::doNothingFunc;
+		self animscripts\zombie_death::PlayDeathSound();
+		behindMe = self.origin + (0,0,30) - AnglesToForward( self.angles ) * 20;
+		self startRagdoll();
+		thread physExplosionForRagdoll( behindMe );
+		self.a.triedTraverseRagdoll = true;
+		break;
+	}
+}
+physExplosionForRagdoll( pos )
+{
+	wait .1;
+	physicsExplosionSphere( pos, 55, 35, 1 );
+}
+postTraverseDeathAnim()
+{
+	self endon( "killanimscript" );
+	if ( !IsDefined( self ) )
+		return;
+	deathAnim = animscripts\zombie_death::get_death_anim();
+	self SetFlaggedAnimKnobAllRestart( "deathanim", deathAnim, %body, 1, .1 );
+	if( animHasNoteTrack( deathAnim, "death_neckgrab_spurt" ) )
+	{
+		PlayFXOnTag( level._effects[ "death_neckgrab_spurt" ], self, "j_neck" );
+	}
+}
+#using_animtree ("dog");
+dog_wall_and_window_hop( traverseName, height )
+{
+	self endon("killanimscript");
+	self traverseMode("nogravity");
+	self traverseMode("noclip");
+	startnode = self GetNegotiationStartNode();
+	assert( IsDefined( startnode ) );
+	self OrientMode( "face angle", startnode.angles[1] );
+	if (IsDefined(startnode.traverse_height))
+	{
+		realHeight = startnode.traverse_height - startnode.origin[2];
+		self thread teleportThread( realHeight - height );
+	}
+	self ClearAnim(%root, 0.2);
+	self SetFlaggedAnimRestart( "dog_traverse", anim.dogAnims["zombie"].traverse[ traverseName ], 1, 0.2, 1);
+	self animscripts\zombie_shared::DoNoteTracks( "dog_traverse" );
+	self.traverseComplete = true;
+}
+dog_jump_down( height, frames )
+{
+	self endon("killanimscript");
+	self traverseMode("noclip");
+	startnode = self GetNegotiationStartNode();
+	assert( IsDefined( startnode ) );
+	self OrientMode( "face angle", startnode.angles[1] );
+	self thread teleportThreadEx( 40.0 - height, 0.1, frames );
+	self ClearAnim(%root, 0.2);
+	self SetFlaggedAnimRestart( "traverse", anim.dogAnims["zombie"].traverse["jump_down_40"], 1, 0.2, 1);
+	self animscripts\zombie_shared::DoNoteTracks( "traverse" );
+	self ClearAnim(anim.dogAnims["zombie"].traverse["jump_down_40"], 0);
+	self traverseMode("gravity");
+	self.traverseComplete = true;
+}
+dog_jump_up( height, frames )
+{
+	self endon("killanimscript");
+	self traverseMode("noclip");
+	startnode = self GetNegotiationStartNode();
+	assert( IsDefined( startnode ) );
+	self OrientMode( "face angle", startnode.angles[1] );
+	self thread teleportThreadEx( height - 40.0, 0.2, frames );
+	self ClearAnim(%root, 0.25);
+	self SetFlaggedAnimRestart( "traverse", anim.dogAnims["zombie"].traverse["jump_up_40"], 1, 0.2, 1);
+	self animscripts\zombie_shared::DoNoteTracks( "traverse" );
+	self ClearAnim(anim.dogAnims["zombie"].traverse["jump_up_40"], 0);
+	self traverseMode("gravity");
+	self.traverseComplete = true;
+}

BO1/PC/ZM/animscripts/zombie_dog_stop.gsc

@@ -0,0 +1,352 @@
+#include animscripts\zombie_utility;
+#include animscripts\weaponList;
+#include common_scripts\utility;
+#include animscripts\Combat_Utility;
+#include maps\_utility;
+#using_animtree ("zombie_dog");
+main()
+{
+	self endon("killanimscript");
+	self ClearAnim( %root, 0.2 );
+	self ClearAnim( anim.dogAnims[self.animSet].idle, 0.2 );
+	self ClearAnim( anim.dogAnims[self.animSet].attack["attackidle_knob"], 0.2 );
+	self thread lookAtTarget( "attackIdle" );
+	while (1)
+	{
+		if ( shouldAttackIdle() )
+		{
+			self ClearAnim( anim.dogAnims[self.animSet].idle, 0.2 );
+			self randomAttackIdle();
+		}
+		else
+		{
+			self OrientMode( "face current" );
+			self ClearAnim( anim.dogAnims[self.animSet].attack["attackidle_knob"], 0.2 );
+			self SetFlaggedAnimRestart( "dog_idle", anim.dogAnims[self.animSet].idle, 1, 0.2, self.animplaybackrate );
+		}
+		animscripts\zombie_shared::DoNoteTracks( "dog_idle", ::dogIdleNotetracks );
+	}
+}
+dogIdleNotetracks(note)
+{
+	if ( note == "breathe_fire" )
+	{
+		if(IsDefined(level._effect["dog_breath"]))
+		{
+			self.breath_fx = Spawn( "script_model", self GetTagOrigin( "TAG_MOUTH_FX" ) );
+			self.breath_fx.angles = self GetTagAngles( "TAG_MOUTH_FX" );
+			self.breath_fx SetModel( "tag_origin" );
+			self.breath_fx LinkTo( self, "TAG_MOUTH_FX" );
+			PlayFxOnTag( level._effect["dog_breath"], self.breath_fx, "tag_origin" );
+		}
+	}
+}
+isFacingEnemy( toleranceCosAngle )
+{
+	assert( IsDefined( self.enemy ) );
+	vecToEnemy = self.enemy.origin - self.origin;
+	distToEnemy = length( vecToEnemy );
+	if ( distToEnemy < 1 )
+	{
+		return true;
+	}
+	forward = AnglesToForward( self.angles );
+	return ( ( forward[0] * vecToEnemy[0] ) + ( forward[1] * vecToEnemy[1] ) ) / distToEnemy > toleranceCosAngle;
+}
+randomAttackIdle()
+{
+	if ( isFacingEnemy( -0.5 ) )
+	{
+		self OrientMode( "face current" );
+	}
+	else
+	{
+		self OrientMode( "face enemy" );
+	}
+	self ClearAnim( anim.dogAnims[self.animSet].attack["attackidle_knob"], 0.1 );
+	if ( IsDefined( self.enemy ) && IsPlayer( self.enemy ) && IsAlive( self.enemy ) )
+	{
+		range = GetDvarFloat( "ai_meleeRange" );
+		distance_ok = DistanceSquared( self.origin, self.enemy.origin ) < ( range * range );
+		if ( distance_ok == true )
+		{
+			self notify( "dog_combat" );
+			self animscripts\zombie_dog_combat::meleeBiteAttackPlayer( self.enemy );
+			return;
+		}
+	}
+	if ( should_growl() )
+	{
+		self SetFlaggedAnimRestart( "dog_idle", anim.dogAnims[self.animSet].combatIdle["attackidle_growl"], 1, 0.2, 1 );
+		return;
+	}
+	idleChance = 33;
+	barkChance = 66;
+	if ( IsDefined( self.mode ) )
+	{
+		if ( self.mode == "growl" )
+		{
+			idleChance = 15;
+			barkChance = 30;
+		}
+		else if ( self.mode == "bark" )
+		{
+			idleChance = 15;
+			barkChance = 85;
+		}
+	}
+	rand = RandomInt( 100 );
+	if ( rand < idleChance )
+	{
+		self SetFlaggedAnimRestart( "dog_idle", anim.dogAnims[self.animSet].combatIdle["attackidle_growl"], 1, 0.2, self.animplaybackrate );
+	}
+	else if ( rand < barkChance )
+	{
+		self SetFlaggedAnimRestart( "dog_idle", anim.dogAnims[self.animSet].combatIdle["attackidle_bark"], 1, 0.2, self.animplaybackrate );
+	}
+	else
+	{
+		self SetFlaggedAnimRestart( "dog_idle", anim.dogAnims[self.animSet].combatIdle["attackidle_growl"], 1, 0.2, self.animplaybackrate );
+	}
+}
+shouldAttackIdle()
+{
+	return ( IsDefined( self.enemy ) && IsAlive( self.enemy ) && DistanceSquared( self.origin, self.enemy.origin ) < 1000000 );
+}
+should_growl()
+{
+	if ( IsDefined( self.script_growl ) )
+	{
+		return true;
+	}
+	if ( !IsAlive( self.enemy ) )
+	{
+		return true;
+	}
+	return !( self cansee( self.enemy ) );
+}
+lookAtTarget( lookPoseSet )
+{
+	self endon( "killanimscript" );
+	self endon( "stop tracking" );
+	self ClearAnim( anim.dogAnims[self.animSet].lookKnob[2], 0 );
+	self ClearAnim( anim.dogAnims[self.animSet].lookKnob[4], 0 );
+	self ClearAnim( anim.dogAnims[self.animSet].lookKnob[6], 0 );
+	self ClearAnim( anim.dogAnims[self.animSet].lookKnob[8], 0 );
+	self.rightLookLimit = 90;
+	self.leftLookLimit = -90;
+	self.upLookLimit = 45;
+	self.downLookLimit = -45;
+	self SetAnimLimited( anim.dogAnims[self.animSet].look[lookPoseSet][2], 1, 0 );
+	self SetAnimLimited( anim.dogAnims[self.animSet].look[lookPoseSet][4], 1, 0 );
+	self SetAnimLimited( anim.dogAnims[self.animSet].look[lookPoseSet][6], 1, 0 );
+	self SetAnimLimited( anim.dogAnims[self.animSet].look[lookPoseSet][8], 1, 0 );
+	self setAnimLookWeight( 1, 0.2 );
+	self trackLoop( anim.dogAnims[self.animSet].lookKnob[2], anim.dogAnims[self.animSet].lookKnob[4], anim.dogAnims[self.animSet].lookKnob[6], anim.dogAnims[self.animSet].lookKnob[8] );
+}
+trackLoop( look2, look4, look6, look8 )
+{
+	players = GetPlayers();
+	deltaChangePerFrame = 5;
+	lookBlendTime = .05;
+	prevYawDelta = 0;
+	prevPitchDelta = 0;
+	maxYawDeltaChange = 5;
+	maxPitchDeltaChange = 5;
+	pitchAdd = 0;
+	yawAdd = 0;
+	doMaxAngleCheck = false;
+	self.lookEnt = self.enemy;
+	yawDelta = 0;
+	pitchDelta = 0;
+	firstFrame = true;
+	for(;;)
+	{
+		rightLookLimit	= self.rightLookLimit;
+		leftLookLimit	= self.leftLookLimit;
+		upLookLimit = self.upLookLimit;
+		downLookLimit	= self.downLookLimit;
+		if ( prevYawDelta > rightLookLimit )
+		{
+			prevYawDelta = rightLookLimit;
+		}
+		else if ( prevYawDelta < leftLookLimit )
+		{
+			prevYawDelta = leftLookLimit;
+		}
+		if ( prevPitchDelta > upLookLimit )
+		{
+			prevPitchDelta = upLookLimit;
+		}
+		else if ( prevPitchDelta < downLookLimit )
+		{
+			prevPitchDelta = downLookLimit;
+		}
+		incrAnimLookWeight();
+		selfLookAtPos = (self.origin[0], self.origin[1], self geteyeapprox()[2]);
+		lookPos = self.lookPos;
+		if ( IsDefined( self.lookEnt ) )
+		{
+			lookPos = self.lookEnt GetLookAtPos();
+		}
+		if ( !IsDefined( lookPos ) )
+		{
+			assert( !IsDefined( self.lookEnt ) );
+			if ( IsDefined( self.node ) && self.node.type == "Guard" && DistanceSquared(self.origin, self.node.origin) < 16 )
+			{
+				yawDelta = AngleClamp180( self.angles[1] - self.node.angles[1] );
+				pitchDelta = 0;
+			}
+			else
+			{
+				likelyEnemyDir = self getAnglesToLikelyEnemyPath();
+				if ( IsDefined( likelyEnemyDir ) )
+				{
+					yawDelta = AngleClamp180( self.angles[1] - likelyEnemyDir[1] );
+					pitchDelta = AngleClamp180( 360 - likelyEnemyDir[0] );
+				}
+				else
+				{
+					yawDelta = 0;
+					pitchDelta = 0;
+				}
+			}
+		}
+		else
+		{
+			vectorToLookPos = lookPos - selfLookAtPos;
+			anglesToLookPos = VectorToAngles( vectorToLookPos );
+			pitchDelta = 360 - anglesToLookPos[0];
+			pitchDelta = AngleClamp180( pitchDelta + pitchAdd );
+			yawDelta = self.angles[1] - anglesToLookPos[1];
+			yawDelta = AngleClamp180( yawDelta + yawAdd );
+		}
+		if ( doMaxAngleCheck && ( abs( yawDelta ) > 60 || abs( pitchDelta ) > 60 ) )
+		{
+			yawDelta = 0;
+			pitchDelta = 0;
+		}
+		else
+		{
+			if ( yawDelta > rightLookLimit )
+			{
+				yawDelta = rightLookLimit;
+			}
+			else if ( yawDelta < leftLookLimit )
+			{
+				yawDelta = leftLookLimit;
+			}
+			if ( pitchDelta > upLookLimit )
+			{
+				pitchDelta = upLookLimit;
+			}
+			else if ( pitchDelta < downLookLimit )
+			{
+				pitchDelta = downLookLimit;
+			}
+		}
+		if ( firstFrame )
+		{
+			firstFrame = false;
+		}
+		else
+		{
+			yawDeltaChange = yawDelta - prevYawDelta;
+			if ( abs( yawDeltaChange ) > maxYawDeltaChange )
+				yawDelta = prevYawDelta + maxYawDeltaChange * sign( yawDeltaChange );
+			pitchDeltaChange = pitchDelta - prevPitchDelta;
+			if ( abs( pitchDeltaChange ) > maxPitchDeltaChange )
+				pitchDelta = prevPitchDelta + maxPitchDeltaChange * sign( pitchDeltaChange );
+		}
+		prevYawDelta = yawDelta;
+		prevPitchDelta = pitchDelta;
+		if ( yawDelta > 0 )
+		{
+			assert( yawDelta <= rightLookLimit );
+			weight = yawDelta / rightLookLimit * self.a.lookweight;
+			self SetAnimLimited( look4, 0, lookBlendTime );
+			self SetAnimLimited( look6, weight, lookBlendTime );
+		}
+		else if ( yawDelta < 0 )
+		{
+			assert( yawDelta >= leftLookLimit );
+			weight = yawDelta / leftLookLimit * self.a.lookweight;
+			self SetAnimLimited( look6, 0, lookBlendTime );
+			self SetAnimLimited( look4, weight, lookBlendTime );
+		}
+		if ( pitchDelta > 0 )
+		{
+			assert( pitchDelta <= upLookLimit );
+			weight = pitchDelta / upLookLimit * self.a.lookweight;
+			self SetAnimLimited( look2, 0, lookBlendTime );
+			self SetAnimLimited( look8, weight, lookBlendTime );
+		}
+		else if ( pitchDelta < 0 )
+		{
+			assert( pitchDelta >= downLookLimit );
+			weight = pitchDelta / downLookLimit * self.a.lookweight;
+			self SetAnimLimited( look8, 0, lookBlendTime );
+			self SetAnimLimited( look2, weight, lookBlendTime );
+		}
+		if ( players.size == 1 )
+		{
+			wait( 0.2 );
+		}
+		else
+		{
+			wait( 1 );
+		}
+	}
+}
+setAnimLookWeight(goalweight, goaltime)
+{
+	if ( !IsDefined( goaltime ) || goaltime <= 0 )
+	{
+		self.a.lookweight = goalweight;
+		self.a.lookweight_start = goalweight;
+		self.a.lookweight_end = goalweight;
+		self.a.lookweight_transframes = 0;
+	}
+	else
+	{
+		self.a.lookweight = goalweight;
+		self.a.lookweight_start = self.a.lookweight;
+		self.a.lookweight_end = goalweight;
+		self.a.lookweight_transframes = int(goaltime * 20);
+	}
+	self.a.lookweight_t = 0;
+}
+incrAnimLookWeight()
+{
+	if ( self.a.lookweight_t < self.a.lookweight_transframes )
+	{
+		self.a.lookweight_t++;
+		t = 1.0 * self.a.lookweight_t / self.a.lookweight_transframes;
+		self.a.lookweight = self.a.lookweight_start * (1 - t) + self.a.lookweight_end * t;
+	}
+}
+getPitchToLookEntOrPos()
+{
+	pitch = getPitchToLookEntOrPos();
+	if ( self.a.script == "cover_crouch" && IsDefined( self.a.coverMode ) && self.a.coverMode == "lean" )
+	{
+		pitch -= anim.coverCrouchLeanPitch;
+	}
+	return pitch;
+}
+getLookYawToPoint(point)
+{
+	yaw = GetYawToSpot(point);
+	dist = distance(self.origin,point);
+	if(dist > 3)
+	{
+		angleFudge = asin(-3/dist);
+		yaw += angleFudge;
+	}
+	yaw = AngleClamp180( yaw );
+	return yaw;
+}
+GetLookAtPos()
+{
+	return self GetShootAtPos();
+}

BO1/PC/ZM/animscripts/zombie_init.gsc

@@ -0,0 +1,814 @@
+
+#include animscripts\zombie_utility;
+#include maps\_utility;
+#include animscripts\Combat_utility;
+#include common_scripts\Utility;
+#using_animtree ("generic_human");
+main()
+{
+	prof_begin("animscript_init");
+	self.a = SpawnStruct();
+	self.root_anim = %root;
+	self thread beginGrenadeTracking();
+	firstInit();
+	anim.reacquireNum--;
+	if (anim.reacquireNum <= 0 && self.team == "axis")
+	{
+		anim.reacquireNum = 1;
+		self.a.reacquireGuy = true;
+	}
+	else
+	{
+		self.a.reacquireGuy = false;
+	}
+	self.a.pose = "stand";
+	self.a.movement = "stop";
+	self.a.state = "stop";
+	self.a.special = "none";
+	self.a.combatEndTime = GetTime();
+	self.a.script = "init";
+	self.a.alertness = "casual";
+	self.a.lastEnemyTime = GetTime();
+	self.a.forced_cover = "none";
+	self.a.desired_script = "none";
+	self.a.current_script = "none";
+	self.a.disableLongDeath = self.team != "axis";
+	self.a.lookangle = 0;
+	self.a.painTime = 0;
+	self.a.nextGrenadeTryTime = 0;
+	self.walk = false;
+	self.sprint = false;
+	self.a.flamepainTime = 0;
+	self.a.postScriptFunc = undefined;
+	self.a.stance = "stand";
+	self._animActive = 0;
+	self._lastAnimTime = 0;
+	self thread deathNotify();
+	self.baseAccuracy = self.accuracy;
+	if( !IsDefined(self.script_accuracy) )
+	{
+		self.script_accuracy = 1;
+	}
+	if (self.team == "axis")
+	{
+		self thread maps\_gameskill::axisAccuracyControl();
+	}
+	else if (self.team == "allies")
+	{
+		self thread maps\_gameskill::alliesAccuracyControl();
+	}
+	self.a.missTime = 0;
+	self.a.yawTransition = "none";
+	self.a.nodeath = false;
+	self.a.missTime = 0;
+	self.a.missTimeDebounce = 0;
+	self.a.disablePain = false;
+	self.accuracyStationaryMod = 1;
+	self.chatInitialized = false;
+	self.sightPosTime = 0;
+	self.sightPosLeft = true;
+	self.preCombatRunEnabled = true;
+	self.is_zombie = true;
+	self.a.grenadeFlee = animscripts\zombie_run::GetRunAnim();
+	self.a.crouchpain = false;
+	self.a.nextStandingHitDying = false;
+	anim_set_next_move_to_new_cover();
+	if (!IsDefined (self.script_forcegrenade))
+	{
+		self.script_forcegrenade = 0;
+	}
+	self.a.StopCowering = ::DoNothing;
+	SetupUniqueAnims();
+	self.lastEnemySightTime = 0;
+	self.combatTime = 0;
+	if ( self.team == "allies" )
+	{
+		self.randomGrenadeRange = 0;
+	}
+	else
+	{
+		self.randomGrenadeRange = 128;
+	}
+	self.ramboChance = 0;
+	if (self.team == "axis")
+	{
+		self.ramboChance *= 2;
+	}
+	self.coverIdleSelectTime = -696969;
+	self.exception = [];
+	self.exception[ "corner" ] = 1;
+	self.exception[ "cover_crouch" ] = 1;
+	self.exception[ "stop" ] = 1;
+	self.exception[ "stop_immediate" ] = 1;
+	self.exception[ "move" ] = 1;
+	self.exception[ "exposed" ] = 1;
+	self.exception[ "corner_normal" ] = 1;
+	keys = getArrayKeys( self.exception );
+	for ( i=0; i < keys.size; i++ )
+	{
+		clear_exception( keys[ i ] );
+	}
+	self.old = SpawnStruct();
+	self.reacquire_state = 0;
+	self thread setNameAndRank();
+	self.shouldConserveAmmoTime = 0;
+	self thread onDeath();
+	self.a.allow_shooting = false;
+	prof_end("animscript_init");
+}
+setNameAndRank()
+{
+	self endon ( "death" );
+	if (!IsDefined (level.loadoutComplete))
+	{
+		level waittill ("loadout complete");
+	}
+	self maps\_names::get_name();
+}
+DoNothing()
+{
+}
+SetupUniqueAnims()
+{
+	if ( !IsDefined( self.animplaybackrate ) || !IsDefined( self.moveplaybackrate ) )
+	{
+		set_anim_playback_rate();
+	}
+}
+set_anim_playback_rate()
+{
+	self.animplaybackrate = 0.9 + RandomFloat( 0.2 );
+	self.moveplaybackrate = 1;
+}
+infiniteLoop(one, two, three, whatever)
+{
+	anim waittill("new exceptions");
+}
+empty(one, two, three, whatever)
+{
+}
+clearEnemy()
+{
+	self notify ("stop waiting for enemy to die");
+	self endon ("stop waiting for enemy to die");
+	self.sightEnemy waittill ("death");
+	self.sightpos = undefined;
+	self.sightTime = 0;
+	self.sightEnemy = undefined;
+}
+previewSightPos()
+{
+}
+previewAccuracy()
+{
+}
+trackVelocity()
+{
+	self endon ("death");
+	for (;;)
+	{
+		self.oldOrigin = self.origin;
+		wait (0.2);
+	}
+}
+deathNotify()
+{
+	self waittill( "death", other );
+	self notify( anim.scriptChange );
+}
+setupHats()
+{
+	anim.noHat = [];
+	addNoHat("character_british_africa_price");
+	addNoHat("character_british_normandy_price");
+	addNoHat("character_british_normandy_price");
+	addNoHat("character_german_winter_masked_dark");
+	addNoHat("character_russian_trench_d");
+	anim.noHatClassname = [];
+	addNoHatClassname("actor_ally_rus_volsky");
+	anim.metalHat = [];
+	addMetalHat("character_british_duhoc_driver");
+	addMetalHat("character_us_ranger_cpl_a");
+	addMetalHat("character_us_ranger_lt_coffey");
+	addMetalHat("character_us_ranger_medic_wells");
+	addMetalHat("character_us_ranger_pvt_a");
+	addMetalHat("character_us_ranger_pvt_a_low");
+	addMetalHat("character_us_ranger_pvt_a_wounded");
+	addMetalHat("character_us_ranger_pvt_b");
+	addMetalHat("character_us_ranger_pvt_b_low");
+	addMetalHat("character_us_ranger_pvt_b_wounded");
+	addMetalHat("character_us_ranger_pvt_braeburn");
+	addMetalHat("character_us_ranger_pvt_c");
+	addMetalHat("character_us_ranger_pvt_c_low");
+	addMetalHat("character_us_ranger_pvt_d");
+	addMetalHat("character_us_ranger_pvt_d_low");
+	addMetalHat("character_us_ranger_pvt_mccloskey");
+	addMetalHat("character_us_ranger_radio");
+	addMetalHat("character_us_ranger_sgt_randall");
+	addMetalHat("character_us_wet_ranger_cpl_a");
+	addMetalHat("character_us_wet_ranger_lt_coffey");
+	addMetalHat("character_us_wet_ranger_medic_wells");
+	addMetalHat("character_us_wet_ranger_pvt_a");
+	addMetalHat("character_us_wet_ranger_pvt_a_low");
+	addMetalHat("character_us_wet_ranger_pvt_a_wounded");
+	addMetalHat("character_us_wet_ranger_pvt_b");
+	addMetalHat("character_us_wet_ranger_pvt_b_low");
+	addMetalHat("character_us_wet_ranger_pvt_b_wounded");
+	addMetalHat("character_us_wet_ranger_pvt_braeburn");
+	addMetalHat("character_us_wet_ranger_pvt_c");
+	addMetalHat("character_us_wet_ranger_pvt_c_low");
+	addMetalHat("character_us_wet_ranger_pvt_d");
+	addMetalHat("character_us_wet_ranger_pvt_d_low");
+	addMetalHat("character_us_wet_ranger_pvt_mccloskey");
+	addMetalHat("character_us_wet_ranger_radio");
+	addMetalHat("character_us_wet_ranger_sgt_randall");
+	addMetalHat("character_british_afrca_body");
+	addMetalHat("character_british_afrca_body_low");
+	addMetalHat("character_british_afrca_mac_body");
+	addMetalHat("character_british_afrca_mac_radio");
+	addMetalHat("character_british_afrca_mcgregor_low");
+	addMetalHat("character_british_afrca_shortsleeve_body");
+	addMetalHat("character_british_normandy_a");
+	addMetalHat("character_british_normandy_b");
+	addMetalHat("character_british_normandy_c");
+	addMetalHat("character_british_normandy_mac_body");
+	addMetalHat("character_german_afrca_body");
+	addMetalHat("character_german_afrca_casualbody");
+	addMetalHat("character_german_camo_fat");
+	addMetalHat("character_german_normandy_coat_dark");
+	addMetalHat("character_german_normandy_fat");
+	addMetalHat("character_german_normandy_fat_injured");
+	addMetalHat("character_german_normandy_officer");
+	addMetalHat("character_german_normandy_thin");
+	addMetalHat("character_german_normandy_thin_injured");
+	addMetalHat("character_german_winter_light");
+	addMetalHat("character_german_winter_masked_dark");
+	addMetalHat("character_german_winter_mg42_low");
+	addMetalHat("character_russian_padded_b");
+	addMetalHat("character_russian_trench_b");
+	anim.fatGuy = [];
+	addFatGuy("character_german_camo_fat");
+	addFatGuy("character_german_normandy_fat");
+	addFatGuy("character_russian_trench_a");
+	addFatGuy("character_german_normandy_fat_injured");
+}
+addNoHat(model)
+{
+	anim.noHat[model] = 1;
+}
+addNoHatClassname(model)
+{
+	anim.noHatClassname[model] = 1;
+}
+addMetalHat(model)
+{
+	anim.metalHat[model] = 1;
+}
+addFatGuy(model)
+{
+	anim.fatGuy[model] = 1;
+}
+initWindowTraverse()
+{
+	level.window_down_height[0] = -36.8552;
+	level.window_down_height[1] = -27.0095;
+	level.window_down_height[2] = -15.5981;
+	level.window_down_height[3] = -4.37769;
+	level.window_down_height[4] = 17.7776;
+	level.window_down_height[5] = 59.8499;
+	level.window_down_height[6] = 104.808;
+	level.window_down_height[7] = 152.325;
+	level.window_down_height[8] = 201.052;
+	level.window_down_height[9] = 250.244;
+	level.window_down_height[10] = 298.971;
+	level.window_down_height[11] = 330.681;
+}
+initMoveStartStopTransitions()
+{
+	transTypes = [];
+	transTypes[0] = "left";
+	transTypes[1] = "right";
+	transTypes[2] = "left_crouch";
+	transTypes[3] = "right_crouch";
+	transTypes[4] = "crouch";
+	transTypes[5] = "stand";
+	transTypes[6] = "exposed";
+	transTypes[7] = "exposed_crouch";
+	transTypes[8] = "stand_saw";
+	transTypes[9] = "crouch_saw";
+	anim.approach_types = [];
+	standing = 0;
+	crouching = 1;
+	anim.approach_types[ "Cover Left" ] = [];
+	anim.approach_types[ "Cover Left" ][ standing ] = "left";
+	anim.approach_types[ "Cover Left" ][ crouching ] = "left_crouch";
+	anim.approach_types[ "Cover Left Wide" ] = anim.approach_types[ "Cover Left" ];
+	anim.approach_types[ "Cover Right" ] = [];
+	anim.approach_types[ "Cover Right" ][ standing ] = "right";
+	anim.approach_types[ "Cover Right" ][ crouching ] = "right_crouch";
+	anim.approach_types[ "Cover Right Wide" ] = anim.approach_types[ "Cover Right" ];
+	anim.approach_types[ "Cover Crouch" ] = [];
+	anim.approach_types[ "Cover Crouch" ][ standing ] = "crouch";
+	anim.approach_types[ "Cover Crouch" ][ crouching ] = "crouch";
+	anim.approach_types[ "Conceal Crouch" ] = anim.approach_types[ "Cover Crouch" ];
+	anim.approach_types[ "Cover Crouch Window" ] = anim.approach_types[ "Cover Crouch" ];
+	anim.approach_types[ "Cover Stand" ] = [];
+	anim.approach_types[ "Cover Stand" ][ standing ] = "stand";
+	anim.approach_types[ "Cover Stand" ][ crouching ] = "stand";
+	anim.approach_types[ "Conceal Stand" ] = anim.approach_types[ "Cover Stand" ];
+	anim.approach_types[ "Path" ] = [];
+	anim.approach_types[ "Path" ][ standing ] = "exposed";
+	anim.approach_types[ "Path" ][ crouching ] = "exposed_crouch";
+	anim.approach_types[ "Guard"] = anim.approach_types[ "Path" ];
+	anim.approach_types[ "Turret"] = anim.approach_types[ "Path" ];
+	anim.coverTrans = [];
+	anim.coverExit = [];
+	anim.traverseInfo = [];
+	anim.coverTrans["right" ][1] = %corner_standR_trans_IN_1;
+	anim.coverTrans["right" ][2] = %corner_standR_trans_IN_2;
+	anim.coverTrans["right" ][3] = %corner_standR_trans_IN_3;
+	anim.coverTrans["right" ][4] = %corner_standR_trans_IN_4;
+	anim.coverTrans["right" ][6] = %corner_standR_trans_IN_6;
+	anim.coverTrans["right" ][8] = %corner_standR_trans_IN_8;
+	anim.coverTrans["right" ][9] = %corner_standR_trans_IN_9;
+	anim.coverTrans["right_crouch"][1] = %CornerCrR_trans_IN_ML;
+	anim.coverTrans["right_crouch"][2] = %CornerCrR_trans_IN_M;
+	anim.coverTrans["right_crouch"][3] = %CornerCrR_trans_IN_MR;
+	anim.coverTrans["right_crouch"][4] = %CornerCrR_trans_IN_L;
+	anim.coverTrans["right_crouch"][6] = %CornerCrR_trans_IN_R;
+	anim.coverTrans["right_crouch"][8] = %CornerCrR_trans_IN_F;
+	anim.coverTrans["right_crouch"][9] = %CornerCrR_trans_IN_MF;
+	anim.coverTrans["left" ][1] = %corner_standL_trans_IN_1;
+	anim.coverTrans["left" ][2] = %corner_standL_trans_IN_2;
+	anim.coverTrans["left" ][3] = %corner_standL_trans_IN_3;
+	anim.coverTrans["left" ][4] = %corner_standL_trans_IN_4;
+	anim.coverTrans["left" ][6] = %corner_standL_trans_IN_6;
+	anim.coverTrans["left" ][7] = %corner_standL_trans_IN_7;
+	anim.coverTrans["left" ][8] = %corner_standL_trans_IN_8;
+	anim.coverTrans["left_crouch" ][1] = %CornerCrL_trans_IN_ML;
+	anim.coverTrans["left_crouch" ][2] = %CornerCrL_trans_IN_M;
+	anim.coverTrans["left_crouch" ][3] = %CornerCrL_trans_IN_MR;
+	anim.coverTrans["left_crouch" ][4] = %CornerCrL_trans_IN_L;
+	anim.coverTrans["left_crouch" ][6] = %CornerCrL_trans_IN_R;
+	anim.coverTrans["left_crouch" ][7] = %CornerCrL_trans_IN_MF;
+	anim.coverTrans["left_crouch" ][8] = %CornerCrL_trans_IN_F;
+	anim.coverTrans["crouch" ][1] = %covercrouch_run_in_ML;
+	anim.coverTrans["crouch" ][2] = %covercrouch_run_in_M;
+	anim.coverTrans["crouch" ][3] = %covercrouch_run_in_MR;
+	anim.coverTrans["crouch" ][4] = %covercrouch_run_in_L;
+	anim.coverTrans["crouch" ][6] = %covercrouch_run_in_R;
+	anim.coverTrans["stand" ][1] = %coverstand_trans_IN_ML;
+	anim.coverTrans["stand" ][2] = %coverstand_trans_IN_M;
+	anim.coverTrans["stand" ][3] = %coverstand_trans_IN_MR;
+	anim.coverTrans["stand" ][4] = %coverstand_trans_IN_L;
+	anim.coverTrans["stand" ][6] = %coverstand_trans_IN_R;
+	anim.coverTrans["stand_saw" ][1] = %saw_gunner_runin_ML;
+	anim.coverTrans["stand_saw" ][2] = %saw_gunner_runin_M;
+	anim.coverTrans["stand_saw" ][3] = %saw_gunner_runin_MR;
+	anim.coverTrans["stand_saw" ][4] = %saw_gunner_runin_L;
+	anim.coverTrans["stand_saw" ][6] = %saw_gunner_runin_R;
+	anim.coverTrans["crouch_saw" ][1] = %saw_gunner_lowwall_runin_ML;
+	anim.coverTrans["crouch_saw" ][2] = %saw_gunner_lowwall_runin_M;
+	anim.coverTrans["crouch_saw" ][3] = %saw_gunner_lowwall_runin_MR;
+	anim.coverTrans["crouch_saw" ][4] = %saw_gunner_lowwall_runin_L;
+	anim.coverTrans["crouch_saw" ][6] = %saw_gunner_lowwall_runin_R;
+	anim.coverTrans["exposed" ] = [];
+	anim.coverTrans["exposed" ][1] = undefined;
+	anim.coverTrans["exposed" ][2] = %run_2_stand_F_6;
+	anim.coverTrans["exposed" ][3] = undefined;
+	anim.coverTrans["exposed" ][4] = %run_2_stand_90L;
+	anim.coverTrans["exposed" ][6] = %run_2_stand_90R;
+	anim.coverTrans["exposed" ][7] = undefined;
+	anim.coverTrans["exposed" ][8] = %run_2_stand_180L;
+	anim.coverTrans["exposed" ][9] = undefined;
+	anim.coverTrans["exposed_crouch"] = [];
+	anim.coverTrans["exposed_crouch"][1] = undefined;
+	anim.coverTrans["exposed_crouch"][2] = %run_2_crouch_F;
+	anim.coverTrans["exposed_crouch"][3] = undefined;
+	anim.coverTrans["exposed_crouch"][4] = %run_2_crouch_90L;
+	anim.coverTrans["exposed_crouch"][6] = %run_2_crouch_90R;
+	anim.coverTrans["exposed_crouch"][7] = undefined;
+	anim.coverTrans["exposed_crouch"][8] = %run_2_crouch_180L;
+	anim.coverTrans["exposed_crouch"][9] = undefined;
+	anim.coverExit["right" ][1] = %corner_standR_trans_OUT_1;
+	anim.coverExit["right" ][2] = %corner_standR_trans_OUT_2;
+	anim.coverExit["right" ][3] = %corner_standR_trans_OUT_3;
+	anim.coverExit["right" ][4] = %corner_standR_trans_OUT_4;
+	anim.coverExit["right" ][6] = %corner_standR_trans_OUT_6;
+	anim.coverExit["right" ][8] = %corner_standR_trans_OUT_8;
+	anim.coverExit["right" ][9] = %corner_standR_trans_OUT_9;
+	anim.coverExit["right_crouch"][1] = %CornerCrR_trans_OUT_ML;
+	anim.coverExit["right_crouch"][2] = %CornerCrR_trans_OUT_M;
+	anim.coverExit["right_crouch"][3] = %CornerCrR_trans_OUT_MR;
+	anim.coverExit["right_crouch"][4] = %CornerCrR_trans_OUT_L;
+	anim.coverExit["right_crouch"][6] = %CornerCrR_trans_OUT_R;
+	anim.coverExit["right_crouch"][8] = %CornerCrR_trans_OUT_F;
+	anim.coverExit["right_crouch"][9] = %CornerCrR_trans_OUT_MF;
+	anim.coverExit["left" ][1] = %corner_standL_trans_OUT_1;
+	anim.coverExit["left" ][2] = %corner_standL_trans_OUT_2;
+	anim.coverExit["left" ][3] = %corner_standL_trans_OUT_3;
+	anim.coverExit["left" ][4] = %corner_standL_trans_OUT_4;
+	anim.coverExit["left" ][6] = %corner_standL_trans_OUT_6;
+	anim.coverExit["left" ][7] = %corner_standL_trans_OUT_7;
+	anim.coverExit["left" ][8] = %corner_standL_trans_OUT_8;
+	anim.coverExit["left_crouch" ][1] = %CornerCrL_trans_OUT_ML;
+	anim.coverExit["left_crouch" ][2] = %CornerCrL_trans_OUT_M;
+	anim.coverExit["left_crouch" ][3] = %CornerCrL_trans_OUT_MR;
+	anim.coverExit["left_crouch" ][4] = %CornerCrL_trans_OUT_L;
+	anim.coverExit["left_crouch" ][6] = %CornerCrL_trans_OUT_R;
+	anim.coverExit["left_crouch" ][7] = %CornerCrL_trans_OUT_MF;
+	anim.coverExit["left_crouch" ][8] = %CornerCrL_trans_OUT_F;
+	anim.coverExit["crouch" ][1] = %covercrouch_run_out_ML;
+	anim.coverExit["crouch" ][2] = %covercrouch_run_out_M;
+	anim.coverExit["crouch" ][3] = %covercrouch_run_out_MR;
+	anim.coverExit["crouch" ][4] = %covercrouch_run_out_L;
+	anim.coverExit["crouch" ][6] = %covercrouch_run_out_R;
+	anim.coverExit["stand" ][1] = %coverstand_trans_OUT_ML;
+	anim.coverExit["stand" ][2] = %coverstand_trans_OUT_M;
+	anim.coverExit["stand" ][3] = %coverstand_trans_OUT_MR;
+	anim.coverExit["stand" ][4] = %coverstand_trans_OUT_L;
+	anim.coverExit["stand" ][6] = %coverstand_trans_OUT_R;
+	anim.coverExit["stand_saw" ][1] = %saw_gunner_runout_ML;
+	anim.coverExit["stand_saw" ][2] = %saw_gunner_runout_M;
+	anim.coverExit["stand_saw" ][3] = %saw_gunner_runout_MR;
+	anim.coverExit["stand_saw" ][4] = %saw_gunner_runout_L;
+	anim.coverExit["stand_saw" ][6] = %saw_gunner_runout_R;
+	anim.coverExit["crouch_saw" ][1] = %saw_gunner_lowwall_runout_ML;
+	anim.coverExit["crouch_saw" ][2] = %saw_gunner_lowwall_runout_M;
+	anim.coverExit["crouch_saw" ][3] = %saw_gunner_lowwall_runout_MR;
+	anim.coverExit["crouch_saw" ][4] = %saw_gunner_lowwall_runout_L;
+	anim.coverExit["crouch_saw" ][6] = %saw_gunner_lowwall_runout_R;
+	anim.coverExit["exposed" ] = [];
+	anim.coverExit["exposed" ][1] = undefined;
+	anim.coverExit["exposed" ][2] = %stand_2_run_180_med;
+	anim.coverExit["exposed" ][3] = undefined;
+	anim.coverExit["exposed" ][4] = %stand_2_run_L;
+	anim.coverExit["exposed" ][6] = %stand_2_run_R;
+	anim.coverExit["exposed" ][7] = undefined;
+	anim.coverExit["exposed" ][8] = %stand_2_run_F_2;
+	anim.coverExit["exposed" ][9] = undefined;
+	anim.coverExit["exposed_crouch"] = [];
+	anim.coverExit["exposed_crouch"][1] = undefined;
+	anim.coverExit["exposed_crouch"][2] = %crouch_2run_180;
+	anim.coverExit["exposed_crouch"][3] = undefined;
+	anim.coverExit["exposed_crouch"][4] = %crouch_2run_L;
+	anim.coverExit["exposed_crouch"][6] = %crouch_2run_R;
+	anim.coverExit["exposed_crouch"][7] = undefined;
+	anim.coverExit["exposed_crouch"][8] = %crouch_2run_F;
+	anim.coverExit["exposed_crouch"][9] = undefined;
+	anim.coverTransDist = [];
+	anim.coverExitDist = [];
+	anim.coverExitPostDist = [];
+	anim.coverTransPreDist = [];
+	anim.coverTransAngles = [];
+	anim.coverExitAngles = [];
+	for ( i = 1; i <= 6; i++ )
+	{
+		if ( i == 5 )
+		{
+			continue;
+		}
+		for ( j = 0; j < transTypes.size; j++ )
+		{
+			trans = transTypes[j];
+			if ( IsDefined( anim.coverTrans[ trans ][i] ) )
+			{
+				anim.coverTransDist [ trans ][i] = getMoveDelta ( anim.coverTrans[ trans ][i], 0, 1 );
+				anim.coverTransAngles[ trans ][i] = getAngleDelta( anim.coverTrans[ trans ][i], 0, 1 );
+			}
+			if ( IsDefined( anim.coverExit [ trans ] ) && IsDefined( anim.coverExit [ trans ][i] ) )
+			{
+				anim.coverExitDist [ trans ][i] = getMoveDelta ( anim.coverExit [ trans ][i], 0, 1 );
+				anim.coverExitAngles [ trans ][i] = getAngleDelta( anim.coverExit [ trans ][i], 0, 1 );
+			}
+		}
+	}
+	exposedTransTypes = [];
+	exposedTransTypes[0] = "exposed";
+	exposedTransTypes[1] = "exposed_crouch";
+	anim.longestExposedApproachDist = 0;
+	for ( j = 0; j < exposedTransTypes.size; j++ )
+	{
+		trans = exposedTransTypes[j];
+		for ( i = 7; i <= 9; i++ )
+		{
+			if ( IsDefined( anim.coverTrans[ trans ][i] ) )
+			{
+				anim.coverTransDist [ trans ][i] = getMoveDelta ( anim.coverTrans[ trans ][i], 0, 1 );
+				anim.coverTransAngles[ trans ][i] = getAngleDelta( anim.coverTrans[ trans ][i], 0, 1 );
+			}
+			if ( IsDefined( anim.coverExit [ trans ][i] ) )
+			{
+				anim.coverExitDist [ trans ][i] = getMoveDelta ( anim.coverExit [ trans ][i], 0, 1 );
+				anim.coverExitAngles [ trans ][i] = getAngleDelta( anim.coverExit [ trans ][i], 0, 1 );
+			}
+		}
+		for ( i = 1; i <= 9; i++ )
+		{
+			if ( !IsDefined( anim.coverTrans[trans][i] ) )
+			{
+				continue;
+			}
+			len = length( anim.coverTransDist[trans][i] );
+			if ( len > anim.longestExposedApproachDist )
+			{
+				anim.longestExposedApproachDist = len;
+			}
+		}
+	}
+	anim.coverExitSplit = [];
+	anim.coverTransSplit = [];
+	anim.coverTransSplit["left"][7] = 0.369369;
+	anim.coverTransSplit["left_crouch"][7] = 0.277277;
+	anim.coverExitSplit["left"][7] = 0.646647;
+	anim.coverExitSplit["left_crouch"][7] = 0.764765;
+	anim.coverTransSplit["left"][8] = 0.463463;
+	anim.coverTransSplit["left_crouch"][8] = 0.339339;
+	anim.coverExitSplit["left"][8] = 0.677678;
+	anim.coverExitSplit["left_crouch"][8] = 0.58959;
+	anim.coverTransSplit["right"][8] = 0.458458;
+	anim.coverTransSplit["right_crouch"][8] = 0.329329;
+	anim.coverExitSplit["right"][8] = 0.457457;
+	anim.coverExitSplit["right_crouch"][8] = 0.636637;
+	anim.coverTransSplit["right"][9] = 0.546547;
+	anim.coverTransSplit["right_crouch"][9] = 0.349349;
+	anim.coverExitSplit["right"][9] = 0.521522;
+	anim.coverExitSplit["right_crouch"][9] = 0.664665;
+	for ( i = 7; i <= 8; i++ )
+	{
+		anim.coverTransPreDist["left" ][i] = getMoveDelta ( anim.coverTrans["left" ][i], 0, getTransSplitTime( "left", i ) );
+		anim.coverTransDist ["left" ][i] = getMoveDelta ( anim.coverTrans["left" ][i], 0, 1 ) - anim.coverTransPreDist["left"][i];
+		anim.coverTransAngles ["left" ][i] = getAngleDelta( anim.coverTrans["left" ][i], 0, 1 );
+		anim.coverTransPreDist["left_crouch" ][i] = getMoveDelta ( anim.coverTrans["left_crouch" ][i], 0, getTransSplitTime( "left_crouch", i ) );
+		anim.coverTransDist ["left_crouch" ][i] = getMoveDelta ( anim.coverTrans["left_crouch" ][i], 0, 1 ) - anim.coverTransPreDist["left_crouch"][i];
+		anim.coverTransAngles ["left_crouch" ][i] = getAngleDelta( anim.coverTrans["left_crouch" ][i], 0, 1 );
+		anim.coverExitDist ["left" ][i] = getMoveDelta ( anim.coverExit ["left" ][i], 0, getExitSplitTime( "left", i ) );
+		anim.coverExitPostDist["left" ][i] = getMoveDelta ( anim.coverExit ["left" ][i], 0, 1 ) - anim.coverExitDist["left"][i];
+		anim.coverExitAngles ["left" ][i] = getAngleDelta( anim.coverExit ["left" ][i], 0, 1 );
+		anim.coverExitDist ["left_crouch" ][i] = getMoveDelta ( anim.coverExit ["left_crouch" ][i], 0, getExitSplitTime( "left_crouch", i ) );
+		anim.coverExitPostDist["left_crouch" ][i] = getMoveDelta ( anim.coverExit ["left_crouch" ][i], 0, 1 ) - anim.coverExitDist["left_crouch"][i];
+		anim.coverExitAngles ["left_crouch" ][i] = getAngleDelta( anim.coverExit ["left" ][i], 0, 1 );
+	}
+	for ( i = 8; i <= 9; i++ )
+	{
+		anim.coverTransPreDist["right" ][i] = getMoveDelta ( anim.coverTrans["right" ][i], 0, getTransSplitTime( "right", i ) );
+		anim.coverTransDist ["right" ][i] = getMoveDelta ( anim.coverTrans["right" ][i], 0, 1 ) - anim.coverTransPreDist["right"][i];
+		anim.coverTransAngles ["right" ][i] = getAngleDelta( anim.coverTrans["right" ][i], 0, 1 );
+		anim.coverTransPreDist["right_crouch"][i] = getMoveDelta ( anim.coverTrans["right_crouch"][i], 0, getTransSplitTime( "right_crouch", i ) );
+		anim.coverTransDist ["right_crouch"][i] = getMoveDelta ( anim.coverTrans["right_crouch"][i], 0, 1 ) - anim.coverTransPreDist["right_crouch"][i];
+		anim.coverTransAngles ["right_crouch"][i] = getAngleDelta( anim.coverTrans["right_crouch"][i], 0, 1 );
+		anim.coverExitDist ["right" ][i] = getMoveDelta ( anim.coverExit ["right" ][i], 0, getExitSplitTime( "right", i ) );
+		anim.coverExitPostDist["right" ][i] = getMoveDelta ( anim.coverExit ["right" ][i], 0, 1 ) - anim.coverExitDist["right"][i];
+		anim.coverExitAngles ["right" ][i] = getAngleDelta( anim.coverExit ["right" ][i], 0, 1 );
+		anim.coverExitDist ["right_crouch"][i] = getMoveDelta ( anim.coverExit ["right_crouch"][i], 0, getExitSplitTime( "right_crouch", i ) );
+		anim.coverExitPostDist["right_crouch"][i] = getMoveDelta ( anim.coverExit ["right_crouch"][i], 0, 1 ) - anim.coverExitDist["right_crouch"][i];
+		anim.coverExitAngles ["right_crouch"][i] = getAngleDelta( anim.coverExit ["right_crouch"][i], 0, 1 );
+	}
+	anim.coverNotetrackExitInfo = [];
+	anim.coverNotetrackArrivalInfo = [];
+	for( i = 1; i <= 9; i++ )
+	{
+		for( j = 0; j < transTypes.size - 1; j++ )
+		{
+			trans = transTypes[j];
+			if( IsDefined( anim.coverTrans[ trans ] ) && IsDefined( anim.coverTrans[ trans ][i] ) )
+			{
+				notetracks = getnotetracksindelta( anim.coverTrans[ trans ][i], 0, 9999 );
+				if(notetracks.size > 0)
+				{
+					anim.coverNotetrackArrivalInfo[ trans + "_" + i ] = [];
+					anim.coverNotetrackArrivalInfo[ trans + "_" + i ] = notetracks;
+				}
+			}
+			if( IsDefined( anim.coverExit[ trans ] ) && IsDefined( anim.coverExit[ trans ][i] ) )
+			{
+				notetracks = getnotetracksindelta( anim.coverExit[ trans ][i], 0, 9999 );
+				if(notetracks.size > 0)
+				{
+					anim.coverNotetrackExitInfo[ trans + "_" + i ] = [];
+					anim.coverNotetrackExitInfo[ trans + "_" + i ] = notetracks;
+				}
+			}
+		}
+	}
+}
+getExitSplitTime( approachType, dir )
+{
+	return anim.coverExitSplit[ approachType ][ dir ];
+}
+getTransSplitTime( approachType, dir )
+{
+	return anim.coverTransSplit[ approachType ][ dir ];
+}
+firstInit()
+{
+	if ( IsDefined (anim.NotFirstTime) )
+	{
+		return;
+	}
+	anim.NotFirstTime = true;
+	anim.useFacialAnims = false;
+	if ( !IsDefined( anim.dog_health ) )
+	{
+		anim.dog_health = 1;
+	}
+	if ( !IsDefined( anim.dog_presstime ) )
+	{
+		anim.dog_presstime = 350;
+	}
+	if ( !IsDefined( anim.dog_hits_before_kill ) )
+	{
+		anim.dog_hits_before_kill = 1;
+	}
+	level.nextGrenadeDrop = RandomInt(3);
+	level.lastPlayerSighted = 100;
+	anim.defaultException = animscripts\zombie_init::empty;
+	anim.sniperRifles = [];
+	anim.sniperRifles["aw50"] = 1;
+	anim.sniperRifles["dragunov"] = 1;
+	anim.sniperRifles["m14_scoped"] = 1;
+	anim.sniperRifles["m14_scoped_ghil"] = 1;
+	anim.sniperRifles["m14_scoped_silencer"] = 1;
+	anim.sniperRifles["m14_scoped_silencer_woodland"] = 1;
+	anim.sniperRifles["m14_scoped_woodland"] = 1;
+	anim.sniperRifles["m40a3"] = 1;
+	anim.sniperRifles["remington700"] = 1;
+	anim.sniperRifles["barrett"] = 1;
+	SetDvar( "scr_expDeathMayMoveCheck", "on" );
+	maps\_names::setup_names();
+	anim.lastSideStepAnim = 0;
+	anim.meleeRange = 64;
+	anim.meleeRangeSq = anim.meleeRange * anim.meleeRange;
+	anim.standRangeSq = 512*512;
+	anim.chargeRangeSq = 200*200;
+	anim.chargeLongRangeSq = 512*512;
+	anim.aiVsAiMeleeRangeSq = 400*400;
+	anim.animFlagNameIndex = 0;
+	if (!IsDefined (level.squadEnt))
+	{
+		level.squadEnt = [];
+	}
+	anim.masterGroup["axis"] = SpawnStruct();
+	anim.masterGroup["axis"].sightTime = 0;
+	anim.masterGroup["allies"] = SpawnStruct();
+	anim.masterGroup["allies"].sightTime = 0;
+	anim.scriptSquadGroup = [];
+	initMoveStartStopTransitions();
+	thread setupHats();
+	anim.lastUpwardsDeathTime = 0;
+	anim.backpedalRangeSq = 60*60;
+	anim.dodgeRangeSq = 300*300;
+	anim.blindAccuracyMult["allies"] = 0.5;
+	anim.blindAccuracyMult["axis"] = 0.1;
+	anim.ramboAccuracyMult = 1.0;
+	anim.runAccuracyMult = 0.5;
+	anim.combatMemoryTimeConst = 10000;
+	anim.combatMemoryTimeRand = 6000;
+	anim.scriptChange = "script_change";
+	anim.grenadeTimers["player_fraggrenade"] = randomIntRange( 1000, 20000 );
+	anim.grenadeTimers["player_flash_grenade"] = randomIntRange( 1000, 20000 );
+	anim.grenadeTimers["player_double_grenade"] = randomIntRange( 10000, 60000 );
+	anim.grenadeTimers["AI_fraggrenade"] = randomIntRange( 0, 20000 );
+	anim.grenadeTimers["AI_flash_grenade"] = randomIntRange( 0, 20000 );
+	anim.numGrenadesInProgressTowardsPlayer = 0;
+	anim.lastGrenadeLandedNearPlayerTime = -1000000;
+	anim.lastFragGrenadeToPlayerStart = -1000000;
+	thread setNextPlayerGrenadeTime();
+	anim.lastGibTime = 0;
+	anim.gibDelay = 3 * 1000;
+	anim.minGibs = 2;
+	anim.maxGibs = 4;
+	anim.totalGibs = RandomIntRange( anim.minGibs, anim.maxGibs );
+	setEnv("none");
+	anim.corner_straight_yaw_limit = 36;
+	if (!IsDefined(anim.optionalStepEffectFunction))
+	{
+		anim.optionalStepEffects = [];
+		anim.optionalStepEffectFunction = ::empty;
+	}
+	anim.notetracks = [];
+	animscripts\zombie_shared::registerNoteTracks();
+	if ( !IsDefined( level.flag ) )
+	{
+		level.flag = [];
+		level.flags_lock = [];
+	}
+	maps\_gameskill::setSkill(undefined,1);
+	level.painAI = undefined;
+	animscripts\zombie_SetPoseMovement::InitPoseMovementFunctions();
+	animscripts\face::InitLevelFace();
+	anim.set_a_b[0] = "a";
+	anim.set_a_b[1] = "b";
+	anim.set_a_b_c[0] = "a";
+	anim.set_a_b_c[1] = "b";
+	anim.set_a_b_c[2] = "c";
+	anim.set_a_c[0] = "a";
+	anim.set_a_c[1] = "c";
+	anim.num_to_letter[1] = "a";
+	anim.num_to_letter[2] = "b";
+	anim.num_to_letter[3] = "c";
+	anim.num_to_letter[4] = "d";
+	anim.num_to_letter[5] = "e";
+	anim.num_to_letter[6] = "f";
+	anim.num_to_letter[7] = "g";
+	anim.num_to_letter[8] = "h";
+	anim.num_to_letter[9] = "i";
+	anim.num_to_letter[10] = "j";
+	anim.maymoveCheckEnabled = true;
+	anim.badPlaces = [];
+	anim.badPlaceInt = 0;
+	animscripts\squadmanager::init_squadManager();
+	anim thread animscripts\battleChatter::bcsDebugWaiter();
+	anim.reacquireNum = 0;
+	initWindowTraverse();
+	anim.coverCrouchLeanPitch = -55;
+	anim.lastCarExplosionTime = -100000;
+	setupRandomTable();
+}
+onPlayerConnect()
+{
+	player = self;
+	firstInit();
+	player.invul = false;
+	println("*************************************init::onPlayerConnect");
+	player thread animscripts\battlechatter::player_init();
+	player thread animscripts\combat_utility::player_init();
+	player thread maps\_serverfaceanim::init_serverfaceanim();
+	player thread animscripts\combat_utility::watchReloading();
+	player thread animscripts\squadManager::addPlayerToSquad();
+	player thread animscripts\battleChatter_ai::addToSystem();
+}
+setNextPlayerGrenadeTime()
+{
+	waittillframeend;
+	if ( IsDefined( anim.playerGrenadeRangeTime ) )
+	{
+		maxTime = int( anim.playerGrenadeRangeTime * 0.7 );
+		if ( maxTime < 1 )
+		{
+			maxTime = 1;
+		}
+		anim.grenadeTimers["player_fraggrenade"] = randomIntRange( 0, maxTime );
+		anim.grenadeTimers["player_flash_grenade"] = randomIntRange( 0, maxTime );
+	}
+	if ( IsDefined( anim.playerDoubleGrenadeTime ) )
+	{
+		maxTime = int( anim.playerDoubleGrenadeTime );
+		minTime = int( maxTime / 2 );
+		if ( maxTime <= minTime )
+		{
+			maxTime = minTime + 1;
+		}
+		anim.grenadeTimers["player_double_grenade"] = randomIntRange( minTime, maxTime );
+	}
+}
+beginGrenadeTracking()
+{
+	self endon ( "death" );
+	for ( ;; )
+	{
+		self waittill ( "grenade_fire", grenade, weaponName );
+		grenade thread grenade_earthQuake();
+	}
+}
+setupRandomTable()
+{
+	anim.randomIntTableSize = 60;
+	anim.randomIntTable = [];
+	for ( i = 0; i < anim.randomIntTableSize; i++ )
+	{
+		anim.randomIntTable[i] = i;
+	}
+	for ( i = 0; i < anim.randomIntTableSize; i++ )
+	{
+		switchwith = RandomInt( anim.randomIntTableSize );
+		temp = anim.randomIntTable[i];
+		anim.randomIntTable[i] = anim.randomIntTable[switchwith];
+		anim.randomIntTable[switchwith] = temp;
+	}
+}
+endOnDeath()
+{
+	self waittill( "death" );
+	waittillframeend;
+	self notify ( "end_explode" );
+}
+grenade_earthQuake()
+{
+	self thread endOnDeath();
+	self endon( "end_explode" );
+	self waittill( "explode", position );
+	PlayRumbleOnPosition( "grenade_rumble", position );
+	earthquake( 0.3, 0.5, position, 400 );
+}
+onDeath()
+{
+	self waittill("death");
+	if ( !IsDefined( self ) )
+	{
+		if ( IsDefined( self.a.usingTurret ) )
+		{
+			self.a.usingTurret delete();
+		}
+	}
+}

BO1/PC/ZM/animscripts/zombie_melee.gsc

@@ -0,0 +1,502 @@
+#include maps\_utility;
+#include animscripts\zombie_utility;
+#include animscripts\zombie_SetPoseMovement;
+#include animscripts\Combat_Utility;
+#include animscripts\Debug;
+#include common_scripts\utility;
+#using_animtree ("generic_human");
+MeleeCombat()
+{
+	self endon( "end_melee" );
+	self endon("killanimscript");
+	self melee_notify_wrapper();
+	assert( CanMeleeAnyRange() );
+	if(IsDefined(level.allow_ai_vs_ai_melee ))
+	{
+		doingAIMelee = (isAI( self.enemy ) && self.enemy.type == "human");
+	}
+	else
+	{
+		doingAIMelee = false;
+	}
+	if ( doingAiMelee )
+	{
+		assert( animscripts\zombie_utility::okToMelee( self.enemy ) );
+		animscripts\zombie_utility::IAmMeleeing( self.enemy );
+		AiVsAiMeleeCombat();
+		animscripts\zombie_utility::ImNotMeleeing( self.enemy );
+		scriptChange();
+		return;
+	}
+	realMelee = true;
+	if ( animscripts\zombie_utility::okToMelee(self.enemy) )
+	{
+		animscripts\zombie_utility::IAmMeleeing(self.enemy);
+	}
+	else
+	{
+		realMelee = false;
+	}
+	self thread EyesAtEnemy();
+	self OrientMode("face enemy");
+	MeleeDebugPrint("Melee begin");
+	self AnimMode( "zonly_physics" );
+	resetGiveUpTime();
+	for ( ;; )
+	{
+		if ( IsDefined(self.marked_for_death) )
+		{
+			return;
+		}
+		MeleeDebugPrint("Melee main loop" + RandomInt(100));
+		if ( !realMelee && animscripts\zombie_utility::okToMelee(self.enemy) )
+		{
+			realMelee = true;
+			animscripts\zombie_utility::IAmMeleeing(self.enemy);
+		}
+		self thread EyesAtEnemy();
+		self animscripts\battleChatter_ai::evaluateMeleeEvent();
+		if( IsDefined( self.enemy ) )
+		{
+			angles = VectorToAngles( self.enemy.origin - self.origin );
+			self OrientMode( "face angle", angles[1] );
+		}
+		if( !IsDefined(level.zombietron_mode) )
+		{
+			switch( self.animname )
+			{
+				case "zombie":
+				self PlaySound( "zmb_vocals_zombie_attack" );
+				break;
+				case "quad_zombie":
+				self PlaySound( "zmb_vocals_quad_attack" );
+				break;
+				case "boss_zombie":
+				self PlaySound( "zmb_vocals_boss_attack" );
+				break;
+				case "napalm_zombie":
+				self PlaySound( "zmb_vocals_napalm_attack" );
+				break;
+				case "sonic_zombie":
+				self PlaySound( "zmb_vocals_sonic_attack" );
+				break;
+			}
+		}
+		if ( is_true( self.noChangeDuringMelee ) )
+		{
+			self.safeToChangeScript = false;
+		}
+		zombie_attack = pick_zombie_melee_anim( self );
+		if ( isDefined( self.melee_anim_func ) )
+		{
+			self thread [[ self.melee_anim_func ]]( zombie_attack );
+		}
+		self SetFlaggedAnimKnobAllRestart("meleeanim", zombie_attack, %body, 1, .2, 1);
+		while ( 1 )
+		{
+			self waittill("meleeanim", note);
+			if ( note == "end" )
+			{
+				break;
+			}
+			else if ( note == "fire" )
+			{
+				if ( !IsDefined( self.enemy ) )
+				{
+					break;
+				}
+				oldhealth = self.enemy.health;
+				self melee();
+				if ( self.enemy.health < oldhealth )
+				{
+					resetGiveUpTime();
+				}
+				else
+				{
+					if ( isDefined( self.melee_miss_func ) )
+					{
+						self [[ self.melee_miss_func ]]();
+					}
+					else if ( isDefined( level.melee_miss_func ) )
+					{
+						self [[ level.melee_miss_func ]]();
+					}
+				}
+			}
+			else if ( note == "stop" )
+			{
+				if ( !CanContinueToMelee() )
+				{
+					break;
+				}
+			}
+		}
+		self OrientMode("face default");
+		if ( is_true( self.noChangeDuringMelee ) )
+		{
+			if ( isDefined( self.enemy ) )
+			{
+				dist_sq = DistanceSquared( self.origin, self.enemy.origin );
+				if ( dist_sq > self.meleeAttackDist * self.meleeAttackDist )
+				{
+					self.safeToChangeScript = true;
+					wait_network_frame();
+					break;
+				}
+			}
+			else
+			{
+				self.safeToChangeScript = true;
+				wait_network_frame();
+				break;
+			}
+		}
+	}
+	if (realMelee)
+	{
+		animscripts\zombie_utility::ImNotMeleeing(self.enemy);
+	}
+	self AnimMode("none");
+	self thread animscripts\zombie_combat::main();
+	self notify ("stop EyesAtEnemy");
+	self notify ("stop_melee_debug_print");
+	scriptChange();
+}
+resetGiveUpTime()
+{
+	if ( DistanceSquared( self.origin, self.enemy.origin ) > anim.chargeRangeSq )
+	{
+		self.giveUpOnMeleeTime = GetTime() + randomintrange( 2700, 3300 );
+	}
+	else
+	{
+		self.giveUpOnMeleeTime = GetTime() + randomintrange( 1700, 2300 );
+	}
+}
+MeleeDebugPrint(text)
+{
+	return;
+	self.meleedebugprint = text;
+	self thread meleeDebugPrintThreadWrapper();
+}
+meleeDebugPrintThreadWrapper()
+{
+	if ( !IsDefined(self.meleedebugthread) )
+	{
+		self.meleedebugthread = true;
+		self meleeDebugPrintThread();
+		self.meleedebugthread = undefined;
+	}
+}
+meleeDebugPrintThread()
+{
+	self endon("death");
+	self endon("killanimscript");
+	self endon("stop_melee_debug_print");
+	while(1)
+	{
+		Print3d(self.origin + (0,0,60), self.meleedebugprint, (1,1,1), 1, .1);
+		wait .05;
+	}
+}
+debug_melee_on_actor()
+{
+	return false;
+}
+debug_melee( msg )
+{
+	if ( !debug_melee_on_actor() )
+	{
+		return;
+	}
+	PrintLn( msg );
+}
+debug_melee_line( start, end, color, duration )
+{
+}
+CanContinueToMelee()
+{
+	return CanMeleeInternal( "already started" );
+}
+CanMeleeAnyRange()
+{
+	return CanMeleeInternal( "any range" );
+}
+CanMeleeDesperate()
+{
+	return CanMeleeInternal( "long range" );
+}
+CanMelee()
+{
+	return CanMeleeInternal( "normal" );
+}
+CanMeleeInternal( state )
+{
+	if ( !IsSentient( self.enemy ) )
+	{
+		debug_melee( "Not doing melee - Does not have a valid target." );
+		return false;
+	}
+	if (!IsAlive(self.enemy))
+	{
+		return false;
+	}
+	if ( IsDefined( self.disableMelee ) )
+	{
+		assert( self.disableMelee );
+		debug_melee( "Not doing melee - Melee is disabled, self.disableMelee is set to true." );
+		return false;
+	}
+	yaw = abs(getYawToEnemy());
+	if ( (yaw > 60 && state != "already started") || yaw > 110 )
+	{
+		debug_melee( "Not doing melee - Not facing the enemy." );
+		return false;
+	}
+	enemyPoint = self.enemy GetOrigin();
+	vecToEnemy = enemyPoint - self.origin;
+	self.enemyDistanceSq = lengthSquared( vecToEnemy );
+	nearest_enemy_sqrd_dist = self GetClosestEnemySqDist();
+	epsilon = 0.1;
+	if( IsDefined( nearest_enemy_sqrd_dist ) && ( nearest_enemy_sqrd_dist - epsilon > self.enemyDistanceSq ) )
+	{
+		debug_melee( "Not doing melee - Entity " + self getEntityNumber() + " can't melee entity " + self.enemy getEntityNumber() + " at distSq " + self.enemyDistanceSq + " because there is a closer enemy at distSq " + nearest_enemy_sqrd_dist + "." );
+		return false;
+	}
+	if(IsDefined(level.allow_ai_vs_ai_melee ))
+	{
+		doingAIMelee = (isAI( self.enemy ) && self.enemy.type == "human");
+	}
+	else
+	{
+		doingAIMelee = false;
+	}
+	if ( doingAIMelee )
+	{
+		if ( !animscripts\zombie_utility::okToMelee(self.enemy) )
+		{
+			debug_melee( "Not doing melee - Enemy is already being meleed." );
+			return false;
+		}
+		if ( IsDefined( self.magic_bullet_shield ) && self.magic_bullet_shield && IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+		{
+			debug_melee( "Not doing melee - Enemy has magic bullet shield." );
+			return false;
+		}
+		if ( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+		{
+			return false;
+		}
+	}
+	else
+	{
+		if ( IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+		{
+			if ( !( self is_banzai() ) )
+			{
+				debug_melee( "Not doing melee - Enemy has magic bullet shield." );
+				return false;
+			}
+		}
+		if (self.enemyDistanceSq <= anim.meleeRangeSq)
+		{
+			if ( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+			{
+				if ( !self is_banzai() )
+				{
+					return false;
+				}
+			}
+			return true;
+		}
+		else if ( self is_banzai() )
+		{
+			return false;
+		}
+		if ( state != "any range" )
+		{
+			chargeRangeSq = anim.chargeRangeSq;
+			if ( state == "long range" )
+			{
+				chargeRangeSq = anim.chargeLongRangeSq;
+			}
+			if (self.enemyDistanceSq > chargeRangeSq)
+			{
+				debug_melee( "Not doing melee - Enemy is not close enough to charge." );
+				return false;
+			}
+		}
+		if ( state == "already started" )
+		{
+			return false;
+		}
+		if ( ( !self is_banzai() || IsPlayer( self.enemy ) ) && IsDefined( self.lastMeleeGiveUpTime ) && GetTime() - self.lastMeleeGiveUpTime < 3000 )
+		{
+			debug_melee( "Not doing melee - Recently meleed someone and missed." );
+			return false;
+		}
+		if ( !animscripts\zombie_utility::okToMelee(self.enemy) )
+		{
+			debug_melee( "Not doing melee - Enemy is being meleed." );
+			return false;
+		}
+		if ( is_true( self.check_melee_path ) )
+		{
+			if( !isMeleePathClear( vecToEnemy, enemyPoint ) )
+			{
+				self notify("melee_path_blocked");
+				return false;
+			}
+		}
+	}
+	return true;
+}
+isMeleePathClear( vecToEnemy, enemyPoint )
+{
+	dirToEnemy = VectorNormalize( (vecToEnemy[0], vecToEnemy[1], 0 ) );
+	meleePoint = enemyPoint - ( dirToEnemy[0]*28, dirToEnemy[1]*28, 0 );
+	thread debug_melee_line( self.origin, meleePoint, ( 1,0,0 ), 1.5 );
+	if ( !self IsInGoal( meleePoint ) )
+	{
+		debug_melee( "Not doing melee - Enemy is outside not in goal." );
+		return false;
+	}
+	if ( self maymovetopoint(meleePoint) )
+	{
+		return true;
+	}
+	trace1 = bullettrace( self.origin + (0,0,20), meleePoint + (0,0,20), true, self );
+	trace2 = bullettrace( self.origin + (0,0,72), meleePoint + (0,0,72), true, self );
+	if ( isDefined(trace1["fraction"]) && trace1["fraction"] == 1 &&
+	isDefined(trace2["fraction"]) && trace2["fraction"] == 1 )
+	{
+		return true;
+	}
+	if ( isDefined(trace1["entity"]) && trace1["entity"] == self.enemy &&
+	isDefined(trace2["entity"]) && trace2["entity"] == self.enemy )
+	{
+		return true;
+	}
+	if ( is_true( level.zombie_melee_in_water ) )
+	{
+		if ( isDefined( trace1["surfacetype"] ) && trace1["surfacetype"] == "water" &&
+		isDefined( trace2["fraction"] ) && trace2["fraction"] == 1 )
+		{
+			return true;
+		}
+	}
+	debug_melee( "Not doing melee - Can not move to the melee point, MayMoveToPoint failed." );
+	return false;
+}
+PlayMeleeSound()
+{
+	if ( !IsDefined ( self.a.nextMeleeChargeSound ) )
+	{
+		self.a.nextMeleeChargeSound = 0;
+	}
+	if ( GetTime() > self.a.nextMeleeChargeSound )
+	{
+		self animscripts\face::SaySpecificDialogue( undefined, "chr_play_grunt_" + self.voice, 0.3 );
+		self.a.nextMeleeChargeSound = GetTime() + 8000;
+	}
+}
+AiVsAiMeleeCombat()
+{
+	self endon("killanimscript");
+	self melee_notify_wrapper();
+	self OrientMode("face enemy");
+	self ClearAnim( %root, 0.3 );
+	IWin = ( RandomInt(10) < 8 );
+	if ( IsDefined( self.magic_bullet_shield ) && self.magic_bullet_shield )
+	{
+		IWin = true;
+	}
+	if ( IsDefined( self.enemy.magic_bullet_shield ) && self.enemy.magic_bullet_shield )
+	{
+		IWin = false;
+	}
+	winAnim = %bog_melee_R_attack;
+	loseAnim = %bog_melee_R_defend;
+	if ( IWin )
+	{
+		myAnim = winAnim;
+		theirAnim = loseAnim;
+	}
+	else
+	{
+		myAnim = loseAnim;
+		theirAnim = winAnim;
+	}
+	desiredDistSqrd = 72 * 72;
+	self PlayMeleeSound();
+	AiVsAiMeleeCharge( desiredDistSqrd );
+	if ( DistanceSquared( self.origin, self.enemy.origin ) > desiredDistSqrd )
+	{
+		return false;
+	}
+	self.meleePartner = self.enemy;
+	self.enemy.meleePartner = self;
+	self.enemy.meleeAnim = theirAnim;
+	self.enemy animcustom( ::AiVsAiAnimCustom );
+	self.meleeAnim = myAnim;
+	self animcustom( ::AiVsAiAnimCustom );
+}
+AiVsAiMeleeCharge( desiredDistSqrd )
+{
+	giveUpTime = GetTime() + 2500;
+	self SetAnimKnobAll( animscripts\zombie_run::GetRunAnim(), %body, 1, 0.2 );
+	while ( DistanceSquared( self.origin, self.enemy.origin ) > desiredDistSqrd && GetTime() < giveUpTime )
+	{
+		wait .05;
+	}
+}
+AiVsAiAnimCustom()
+{
+	self endon("killanimscript");
+	self AiVsAiMeleeAnim( self.meleeAnim );
+}
+AiVsAiMeleeAnim( myAnim )
+{
+	self endon("end_melee");
+	self thread endMeleeOnKillanimscript();
+	partnerDir = self.meleePartner.origin - self.origin;
+	self OrientMode( "face angle", VectorToAngles( partnerDir )[1] );
+	self AnimMode( "zonly_physics" );
+	self SetFlaggedAnimKnobAllRestart( "meleeAnim", myAnim, %body, 1, 0.2 );
+	self animscripts\zombie_shared::DoNoteTracks( "meleeAnim" );
+	self notify("end_melee");
+}
+endMeleeOnKillanimscript()
+{
+	self endon("end_melee");
+	self waittill("killanimscript");
+	self.meleePartner notify("end_melee");
+}
+pick_zombie_melee_anim( zombie_guy )
+{
+	melee_anim = undefined;
+	if ( zombie_guy.has_legs )
+	{
+		switch(zombie_guy.zombie_move_speed)
+		{
+			case "walk":
+			anims = array_combine(level._zombie_melee[zombie_guy.animname],level._zombie_walk_melee[zombie_guy.animname]);
+			melee_anim = random(anims);
+			break;
+			case "run":
+			case "sprint":
+			anims = array_combine(level._zombie_melee[zombie_guy.animname],level._zombie_run_melee[zombie_guy.animname]);
+			melee_anim = random(anims);
+			break;
+		}
+	}
+	else if(zombie_guy.a.gib_ref == "no_legs")
+	{
+		melee_anim = random(level._zombie_stumpy_melee[zombie_guy.animname]);
+	}
+	else
+	{
+		melee_anim = random(level._zombie_melee_crawl[zombie_guy.animname]);
+	}
+	return melee_anim;
+}

BO1/PC/ZM/animscripts/zombie_move.gsc

@@ -0,0 +1,396 @@
+#include animscripts\zombie_SetPoseMovement;
+#include animscripts\combat_utility;
+#include animscripts\zombie_utility;
+#include animscripts\zombie_shared;
+#include common_scripts\utility;
+#using_animtree ("generic_human");
+main()
+{
+	self endon("killanimscript");
+	[[ self.exception[ "move" ] ]]();
+	previousScript = self.a.script;
+	animscripts\zombie_utility::initialize("zombie_move");
+	if (self.moveMode == "run")
+	{
+		switch (previousScript)
+		{
+			case "combat":
+			case "stop":
+			self animscripts\battleChatter_ai::evaluateMoveEvent (false);
+			break;
+			case "cover_crouch":
+			case "cover_left":
+			case "cover_right":
+			case "cover_stand":
+			case "concealment_crouch":
+			case "concealment_stand":
+			case "cover_wide_left":
+			case "cover_wide_right":
+			case "stalingrad_cover_crouch":
+			case "Hide":
+			case "turret":
+			self animscripts\battleChatter_ai::evaluateMoveEvent (true);
+			break;
+			default:
+			self animscripts\battleChatter_ai::evaluateMoveEvent (false);
+			break;
+		}
+	}
+	MoveMainLoop();
+}
+MoveMainLoop()
+{
+	prevLoopTime = self getAnimTime( %walk_and_run_loops );
+	self.a.runLoopCount = RandomInt( 10000 );
+	moveMode = self.moveMode;
+	if ( IsDefined( self.pathGoalPos ) && DistanceSquared( self.origin, self.pathGoalPos ) < 4096 )
+	{
+		moveMode = "walk";
+	}
+	self.needs_run_update = true;
+	self sideStepInit();
+	for (;;)
+	{
+		loopTime = self getAnimTime( %walk_and_run_loops );
+		if ( loopTime < prevLoopTime )
+		{
+			self.a.runLoopCount++;
+		}
+		prevLoopTime = loopTime;
+		self animscripts\face::SetIdleFaceDelayed( anim.alertface );
+		self animscripts\zombie_run::MoveRun();
+		self.exitingCover = false;
+		self trySideStep();
+	}
+}
+moveAgain()
+{
+	self notify("killanimscript");
+	animscripts\zombie_move::main();
+}
+sideStepInit()
+{
+	self.a.steppedDir = 0;
+	self.a.lastSideStepTime	= GetTime();
+	if( !IsDefined( level.sideStepAnims ) )
+	{
+		level.MIN_REACTION_DIST_SQ = 64*64;
+		level.MAX_REACTION_DIST_SQ = 1000*1000;
+		level.REACTION_INTERVAL = 2000;
+		level.SIDE_STEP_CHANCE = 0.7;
+		level.RIGHT_STEP_CHANCE = 0.5;
+		level.FORWARD_REACTION_INTERVAL = 2000;
+		level.FORWARD_MIN_REACTION_DIST_SQ = 120*120;
+		level.FORWARD_MAX_REACTION_DIST_SQ = 2400*2400;
+		level.sideStepAnims = [];
+		level.sideStepAnims["step_left"]	= array( %ai_zombie_spets_sidestep_left_a, %ai_zombie_spets_sidestep_left_b );
+		level.sideStepAnims["step_right"]	= array( %ai_zombie_spets_sidestep_right_a, %ai_zombie_spets_sidestep_right_b );
+		level.sideStepAnims["roll_forward"]	= array( %ai_zombie_spets_roll_a, %ai_zombie_spets_roll_b, %ai_zombie_spets_roll_c );
+	}
+}
+trySideStep()
+{
+	if ( isdefined( self.shouldSideStepFunc ) )
+	{
+		self.sideStepType = self [[ self.shouldSideStepFunc ]]();
+	}
+	else
+	{
+		self.sideStepType = shouldSideStep();
+	}
+	if( self.sideStepType == "none" )
+	{
+		if ( is_true( self.zombie_can_forwardstep ) )
+		{
+			self.sideStepType = shouldForwardStep();
+		}
+	}
+	if( self.sideStepType == "none" )
+	{
+		return false;
+	}
+	self.desiredStepDir = getDesiredSideStepDir( self.sideStepType );
+	animName = self.sideStepType + "_" + self.desiredStepDir;
+	sideStepAnims = level.sideStepAnims;
+	if ( IsDefined( self.sideStepAnims ) )
+	{
+		sideStepAnims = self.sideStepAnims;
+	}
+	self.stepAnim = sideStepAnims[ animName ][RandomInt( sideStepAnims[ animName ].size )];
+	assertex( IsDefined(self.stepAnim), "Sidestep anim " + animName + " not found" );
+	if ( !self checkRoomForAnim( self.stepAnim ) )
+	{
+		hasRoom = false;
+		if( self.sideStepType == "roll" && self.desiredStepDir != "forward" )
+		{
+			self.desiredStepDir = "forward";
+			animName = self.sideStepType + "_" + self.desiredStepDir;
+			self.stepAnim = sideStepAnims[ animName ][RandomInt( sideStepAnims[ animName ].size )];
+			assertex( IsDefined(self.stepAnim), "Sidestep anim " + animName + " not found" );
+			hasRoom = self checkRoomForAnim( self.stepAnim );
+		}
+		if( !hasRoom )
+		{
+			return false;
+		}
+	}
+	self AnimCustom( ::doSideStep );
+}
+getDesiredSideStepDir( sideStepType )
+{
+	if( sideStepType == "roll" || sideStepType == "phase" )
+	{
+		self.desiredStepDir = "forward";
+		return self.desiredStepDir;
+	}
+	AssertEx( sideStepType == "step", "Unsupported SideStepType" );
+	randomRoll = RandomFloat(1);
+	if( self.a.steppedDir < 0 )
+	{
+		self.desiredStepDir = "right";
+	}
+	else if( self.a.steppedDir > 0 )
+	{
+		self.desiredStepDir = "left";
+	}
+	else if( randomRoll < level.RIGHT_STEP_CHANCE )
+	{
+		self.desiredStepDir = "right";
+	}
+	else if( randomRoll < level.RIGHT_STEP_CHANCE*2 )
+	{
+		self.desiredStepDir = "left";
+	}
+	return self.desiredStepDir;
+}
+checkRoomForAnim( stepAnim )
+{
+	if ( !self MayMoveFromPointToPoint( self.origin, getAnimEndPos( stepAnim ) ) )
+	{
+		return false;
+	}
+	return true;
+}
+shouldSideStep()
+{
+	if( canSideStep() && IsPlayer(self.enemy) && self.enemy IsLookingAt(self) )
+	{
+		if( self.zombie_move_speed != "sprint" || RandomFloat(1) < level.SIDE_STEP_CHANCE )
+			return "step";
+		else
+			return "roll";
+	}
+	return "none";
+}
+canSideStep()
+{
+	if ( !IsDefined( self.zombie_can_sidestep ) || !self.zombie_can_sidestep )
+	{
+		if( !issubstr( self.classname, "zombie_spetznaz" ) )
+			return false;
+	}
+	if( GetTime() - self.a.lastSideStepTime < level.REACTION_INTERVAL )
+		return false;
+	if( !IsDefined(self.enemy) )
+		return false;
+	if( self.a.pose != "stand" )
+		return false;
+	distSqFromEnemy = DistanceSquared(self.origin, self.enemy.origin);
+	if( distSqFromEnemy < level.MIN_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( distSqFromEnemy > level.MAX_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( !IsDefined(self.pathgoalpos) || DistanceSquared(self.origin, self.pathgoalpos) < level.MIN_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( abs(self GetMotionAngle()) > 15 )
+	{
+		return false;
+	}
+	yaw = GetYawToOrigin(self.enemy.origin);
+	if( abs(yaw) > 45 )
+	{
+		return false;
+	}
+	return true;
+}
+shouldForwardStep()
+{
+	if ( canForwardStep() && IsPlayer( self.enemy ) )
+	{
+		return "phase";
+	}
+	return "none";
+}
+canForwardStep()
+{
+	if ( !isdefined( self.zombie_can_forwardstep ) || !self.zombie_can_forwardstep )
+	{
+		return false;
+	}
+	if( GetTime() - self.a.lastSideStepTime < level.FORWARD_REACTION_INTERVAL )
+		return false;
+	if( !IsDefined(self.enemy) )
+		return false;
+	if( self.a.pose != "stand" )
+		return false;
+	distSqFromEnemy = DistanceSquared(self.origin, self.enemy.origin);
+	if( distSqFromEnemy < level.FORWARD_MIN_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( distSqFromEnemy > level.FORWARD_MAX_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( !IsDefined(self.pathgoalpos) || DistanceSquared(self.origin, self.pathgoalpos) < level.MIN_REACTION_DIST_SQ )
+	{
+		return false;
+	}
+	if( abs(self GetMotionAngle()) > 15 )
+	{
+		return false;
+	}
+	yaw = GetYawToOrigin(self.enemy.origin);
+	if( abs(yaw) > 45 )
+	{
+		return false;
+	}
+	return true;
+}
+doSideStep()
+{
+	self endon("death");
+	self endon("killanimscript");
+	playSideStepAnim( self.stepAnim, self.sideStepType );
+	if( self.desiredStepDir == "left" )
+	{
+		self.a.steppedDir--;
+	}
+	else
+	{
+		self.a.steppedDir++;
+	}
+	self.a.lastSideStepTime = GetTime();
+	return true;
+}
+playSideStepAnim( stepAnim, sideStepType )
+{
+	self AnimMode( "gravity", false );
+	self OrientMode( "face angle", self.angles[1] );
+	runBlendOutTime = 0.20;
+	if ( isdefined( self.sideStepFunc ) )
+	{
+		self thread [[ self.sideStepFunc ]]( "stepAnim", stepAnim );
+	}
+	self ClearAnim( %body, runBlendOutTime );
+	self SetFlaggedAnimRestart( "stepAnim", stepAnim, 1, runBlendOutTime, self.moveplaybackrate );
+	animStartTime = GetTime();
+	animLength = GetAnimLength(stepAnim);
+	hasExitAlign = animHasNotetrack( stepAnim, "exit_align" );
+	if ( !hasExitAlign )
+	{
+		println("^1Side step animation has no \"exit_align\" notetrack");
+	}
+	self thread animscripts\shared::DoNoteTracks( "stepAnim" );
+	self thread sideStepBlendOut( animLength, "stepAnim", hasExitAlign );
+	self.exit_align = false;
+	self waittillmatch( "stepAnim", "exit_align" );
+	self.exit_align = true;
+	elapsed = (getTime() - animStartTime) / 1000.0;
+	timeLeft = animLength - elapsed;
+	hasCodeMoveNoteTrack = animHasNotetrack( stepAnim, "code_move" );
+	if( hasCodeMoveNoteTrack )
+	{
+		times = getNotetrackTimes( stepAnim, "code_move" );
+		assertEx( times.size == 1, "More than one code_move notetrack found" );
+		timeLeft = times[0] * animLength - elapsed;
+	}
+	self AnimMode( "pos deltas", false );
+	maxYawDelta = 2;
+	timer = 0;
+	while( timer < timeLeft )
+	{
+		lookaheadAngles = VectorToAngles( self.lookaheaddir );
+		yawDelta = AngleClamp180(lookaheadAngles[1] - self.angles[1]);
+		if( yawDelta > maxYawDelta )
+		{
+			yawDelta = maxYawDelta;
+		}
+		else if( yawDelta < maxYawDelta*-1 )
+		{
+			yawDelta = maxYawDelta*-1;
+		}
+		newAngles = (self.angles[0], self.angles[1] + yawDelta, self.angles[2]);
+		self Teleport( self.origin, newAngles );
+		timer += 0.05 * self.moveplaybackrate;
+		wait( 0.05 );
+	}
+	self OrientMode( "face angle", self.angles[1] );
+	elapsed = (getTime() - animStartTime) / 1000.0;
+	timeLeft = animLength - elapsed;
+	if( timeLeft > 0 )
+	{
+		wait(timeLeft / self.moveplaybackrate);
+	}
+	if( IsAlive(self) )
+	{
+		self thread faceLookaheadForABit();
+		restorePain();
+		self.deathFunction = maps\_zombiemode_spawner::zombie_death_animscript;
+	}
+}
+faceLookaheadForABit()
+{
+	self endon("death");
+	self endon("killanimscript");
+	lookaheadAngles = VectorToAngles(self.lookaheaddir);
+	self OrientMode( "face angle", lookaheadAngles[1] );
+	wait(0.2);
+	self AnimMode( "normal", false );
+	self OrientMode( "face default" );
+}
+sideStepBlendOut( animLength, animName, hasExitAlign )
+{
+	self endon("killanimscript");
+	self endon("death");
+	self endon("stopTurnBlendOut");
+	runBlendInTime = 0.2;
+	assert( animLength > runBlendInTime );
+	wait( (animLength - runBlendInTime) / self.moveplaybackrate );
+	if( !hasExitAlign )
+	{
+		self notify( animName, "exit_align" );
+	}
+	self ClearAnim( %exposed_modern, 0 );
+	self SetFlaggedAnimKnobAllRestart( "run_anim", animscripts\zombie_run::GetRunAnim(), %body, 1, runBlendInTime, self.moveplaybackrate );
+}
+restorePainOnKillanimscript()
+{
+	self waittill("killanimscript");
+	if( IsDefined(self) && IsAlive(self) )
+	{
+		restorePain();
+		self.deathFunction = undefined;
+	}
+}
+disablePain()
+{
+	self.a.storedDisablePain = self.a.disablePain;
+	self.a.storedAllowPain = self.a.allowPain;
+	self.a.disablePain	= true;
+	self.allowPain = false;
+}
+restorePain()
+{
+	if( IsDefined(self.a.storedDisablePain) && IsDefined(self.a.storedAllowPain) )
+	{
+		self.a.disablePain	= self.a.storedDisablePain;
+		self.allowPain = self.a.storedAllowPain;
+	}
+}