1
0
KF2-Dev-Scripts/KFGame/Classes/KFPawnAnimInfo.uc
2020-12-13 18:01:13 +03:00

868 lines
34 KiB
Ucode

//=============================================================================
// KFPawnAnimInfo
//=============================================================================
// Contains information on using a character specific AnimSet. Since UObjects
// don't support static members, we can use abstract/archetype.
// Relates to KFPawnSoundGroup, but uses archetype for editability
//=============================================================================
// Killing Floor 2
// Copyright (C) 2015 Tripwire Interactive LLC
// - Andrew "Strago" Ladenberger
//=============================================================================
class KFPawnAnimInfo extends Object
hidecategories(Object)
editinlinenew;
/*********************************************************************************************
* @name Attack Animations
*********************************************************************************************/
enum EAttackRating
{
AR_Weak,
AR_Medium,
AR_Strong
};
struct AttackAnimInfo
{
/** Optional attack name for quick reference */
var() const name Tag;
/** Animation names/variants */
var() const array<Name> Anims;
/** If set, enable root motion for this attack */
var() const bool bUseRootMotion;
/** If set, play on the upper body (note: UpperBody and RootMotion are exclusive) */
var() const bool bPlayUpperBodyOnly;
/** If set, can be canceled by other actions (e.g. stumble). Use with caution if RootMotion is enabled! */
var() const bool bIsInterruptible;
/** If Interruptible, is this attack affected by parry stumble */
var() const bool bCannotBeParried<EditCondition=bIsInterruptible>;
/** If set, this attack will not be able to be pushed around by damage impulses */
var() const bool bNoDamageImpulses;
/** If set, only perform this attack while sprinting */
var() const bool bOnlyWhileSprinting;
/** If set, only perform this attack while not sprinting */
var() const bool bOnlyWhileNotSprinting;
/** If set, only perform this attack when enemy is moving */
var() const bool bOnlyWhileEnemyMoving;
/** If set, only perform this attack when enemy is stationary */
var() const bool bOnlyWhileEnemyNotMoving;
/** If set, only perform this attack when surrounded */
var() const bool bOnlyWhileSurrounded;
/** If set, this pawn has cloaking */
var() const bool bHasCloaking;
/** If set, only performs this attack when cloaked */
var() const bool bOnlyWhileCloaked<EditCondition=bHasCloaking>;
/** If set, only perform this attack when uncloaked */
var() const bool bOnlyWhileDeCloaked<EditCondition=bHasCloaking>;
/** The radius around the AI pawn to determine if surrounded */
var() const float SurroundedRadius<EditCondition=bOnlyWhileSurrounded | ClampMin=1>;
/** The minimum number of players that need to surround AI pawn for this attack to be considered */
var() const int MinSurroundedBy<EditCondition=bOnlyWhileSurrounded | ClampMin=2>;
/** If set, attack only usable when AI using custom mode/ability ("e.g, FleshPound rage, siren cloak, etc.") */
var() const bool bOnlyWhileInSpecializedMode;
/** If set, attack only usable when AI NOT using custom mode/ability ("e.g, FleshPound rage, siren cloak, etc.") */
var() const bool bOnlyWhileNotInSpecializedMode;
/** If set, use this EXCLUSIVELY when headless */
var() const bool bOnlyWhileHeadless;
/** If set, attack requires a clear path to enemy (no leg obstructions) to perform this anim */
var() const bool bOnlyWhilePathClear;
/** If set along with BattlePhaseMinimum, determines the battle phases this attack is allowed in (Bosses only) */
var() const bool bIsBattlePhaseAttack;
/** The minimum battle phase a boss must be at for this attack to be allowed */
var() const int BattlePhaseMinimum<EditCondition=bIsBattlePhaseAttack | ClampMin=1>;
/** The maximum battle phase a boss can be at to use this attack */
var() const int BattlePhaseMaximum<EditCondition=bIsBattlePhaseAttack>;
/** Chance this attack will be considered */
var() const float Chance<ClampMin=0.0>;
/** If > 0, will not target distance enemies */
var() const float MaxDistance<ClampMin=0.0>;
/** If > 0 and bUseRootMotion, will not target nearby enemies */
var() const float MinDistance<ClampMin=0.0>;
/** If > 0, no characters of this type can perform this attack */
var() const float GlobalCooldown<ClampMin=0.0>;
/** Create and manage an instanced (per zed) cooldown timer */
var const float InstancedCooldown<ClampMin=0.0>;
/** Attack rating that can be filtered by difficulty */
var() const EAttackRating DifficultyRating;
/** example: If DiffultyRating is weak and GameDifficulty allows medium attacks then ignore */
var() const bool bSkipIfDifficultyIsExceeded;
/** Global (any character of this type) picked this animation */
var transient float LastTimePlayed;
structdefaultproperties
{
//Priority=1.f
Chance=1.f
SurroundedRadius=200.f
BattlePhaseMinimum=1
BattlePhaseMaximum=4
MinSurroundedBy=3
}
};
struct sTheatricAnimInfo
{
var() const Name AnimationName;
var() const CameraAnim CameraAnimation;
var() const vector CameraAnimOffset;
};
var(Attacks) array<AttackAnimInfo> Attacks<DisplayName=MeleeAttacks>;
/** list of attack anim variants used on doors */
var(Attacks) array<Name> DoorAttacks;
/** If checked, allow game difficulty to modify attack selection */
var(Attacks) bool bEnableDifficultyScaling;
/** Chance of allowing this type of attack for a given difficulty */
var transient float WeakAttackChance;
var transient float MediumAttackChance;
var transient float HardAttackChance;
var(Debug) bool bDebugLog;
/*********************************************************************************************
* @name Hit Reaction Animation
*********************************************************************************************/
enum EHitReactionAnimType
{
HIT_Light, // AdditiveHitReaction
HIT_Medium,
HIT_Heavy, // CauseStumble, HighKickDeathAnimation, FullBodyHitReaction
};
struct native AnimVariants
{
var() array<Name> Anims;
};
/** array entry for each HitZoneGruop */
var(HitReaction) const array<AnimVariants> LightHitAnims;
var(HitReaction) const array<AnimVariants> MediumHitAnims<DisplayName=GunHitAnims>;
var(HitReaction) const array<AnimVariants> HeavyHitAnims<DisplayName=MeleeHitAnims>;
var(HitReaction) const array<name> DmgOverTimeHitAnims;
var(HitReaction) bool bCanPlayAnimHitReactions;
/** Anims for stumble special move
0: Body_Forward,
1: Body_Backward,
2: Body_Left,
3: Body_Right,
4: Leg_L_Forward,
5: Leg_L_Backward,
6: Leg_L_Left,
7: Leg_L_Right,
8: Leg_R_Forward,
9: Leg_R_Backward,
10: Leg_R_Left,
11: Leg_R_Right,
12: Parry
*/
var(HitReaction) editfixedsize array<AnimVariants> StumbleAnims;
/*********************************************************************************************
* @name Physics Hit Reactions
*********************************************************************************************/
/** If Pawn can or cannot play physics hit reactions. */
var(HitReaction) editconst bool bCanPlayPhysicsHitReactions;
/*********************************************************************************************
* @name Death Animations
*********************************************************************************************/
struct native DeathAnimInfo
{
/** Bone name to use these anims with */
var() const name BoneName;
/** Animation names/variants */
var() const array<Name> Anims_F;
var() const array<Name> Anims_B;
var() const array<Name> Anims_L;
var() const array<Name> Anims_R;
var() const array<Name> DismemberedAnims;
/** Chance no death animation will be selected */
var() const float RagdollChance<ClampMin=0.0>;
/** (Body Part Death) Chance the generic death will be selected */
var() const float IgnoreChance<ClampMin=0.0>;
structdefaultproperties
{
IgnoreChance=0.1f
}
};
/** Default death animation list */
var(Death) const DeathAnimInfo DefaultDeathAnims;
/** Death animas used by weapons with high kickback (explosives) */
var(Death) const DeathAnimInfo ExplosiveDeathAnims;
/** Death anims used when shot in specific location */
var(Death) const array<DeathAnimInfo> BodyPartDeathAnims;
/** Random chance that this death with play a hit zone specific animation */
//var(Death) const float BodyPartDeathChance;
/** If set, this actor can play death animations */
var(Death) const bool bCanPlayDeathAnimations;
/** Global (for this character) tracking of previous animation */
var transient byte LastDeathAnimIndex;
/** temp */
var(Death) const Vector2D DeathPhysMotorStrength;
/*********************************************************************************************
* @name Taunt Animations
*********************************************************************************************/
/** List of randomly selected taunt anims */
var(Taunt) array<name> TauntAnims;
var(Taunt) array<name> TauntKillAnims;
var(Taunt) array<name> TauntEnragedAnims;
/*********************************************************************************************
* @name Theatric Boss Animations
*********************************************************************************************/
var(BossTheatrics) array<sTheatricAnimInfo> TheatricBossEntranceAnimInfos;
var(BossTheatrics) array<sTheatricAnimInfo> TheatricBossVictoryAnimInfos;
/*********************************************************************************************
* @name Melee attack anim helpers
*********************************************************************************************/
/** Finds a attack info by index. */
function name InitMeleeSpecialMove(KFSM_MeleeAttack InSpecialMove, int Index, int Variant)
{
local name AnimName;
AnimName = Attacks[Index].Anims[Variant];
if ( AnimName == '' )
{
`log(self@GetFuncName()@"failed to find a valid attack");
}
// if a special move is passed in set up the flags based on this attack. This is a little bit reverse
// logic, but it gets around having to pass the AttackAnimInfo structs by value all over script
if ( InSpecialMove != None )
{
InSpecialMove.bUseRootMotion = Attacks[Index].bUseRootMotion;
InSpecialMove.bCanBeInterrupted = Attacks[Index].bIsInterruptible;
InSpecialMove.bCannotBeParried = Attacks[Index].bCannotBeParried;
InSpecialMove.bAllowMomentumPush = !Attacks[Index].bNoDamageImpulses;
}
return AnimName;
}
/** Finds a attack animation by name */
function Name ChooseAttackByName(name AttackName, optional KFPawn_Monster Instigator, optional Actor Target, optional out byte outFlags)
{
local int idx, variant;
idx = Attacks.Find('Tag', AttackName);
if ( idx != INDEX_NONE )
{
// if there is an instigator, check to see if this is a valid attack
if ( Instigator != None && !CanDoAttackAnim(idx, Instigator, Target) )
{
return '';
}
variant = Rand(Attacks[idx].Anims.Length);
// update the global cooldown
if ( Attacks[idx].GlobalCooldown > 0 )
{
Attacks[idx].LastTimePlayed = class'Engine'.static.GetCurrentWorldInfo().TimeSeconds;
}
outFlags = (idx + (variant << 4));
return Attacks[idx].Anims[variant];
}
`log(self@GetFuncName()@"failed to find a valid attack");
return '';
}
/** Chooses a valid (random) attack animation */
function int ChooseNextStrike(KFPawn Instigator, optional Actor Target)
{
local int i;
local array<int> IndexList;
// Add up the total weight for all valid attacks
for(i = 0; i < Attacks.Length; i++)
{
if ( CanDoAttackAnim(i, Instigator, Target) )
{
IndexList.AddItem(i);
}
}
// If we have valid animations to choose from
if ( IndexList.Length > 0 )
{
// return one of the possible attacks
return IndexList[Rand(IndexList.Length)];
}
return 255;
}
function UpdateAttackCooldown( KFAIController KFAIC, byte DesiredStrikeIndex )
{
// update the global cooldown
if( Attacks[DesiredStrikeIndex].GlobalCooldown > 0 )
{
Attacks[DesiredStrikeIndex].LastTimePlayed = class'Engine'.static.GetCurrentWorldInfo().TimeSeconds;
}
// Assume attack is going to play, if a cooldown is set handle it here
if( Attacks[DesiredStrikeIndex].InstancedCooldown > 0 )
{
/** Once attack has been selected activate a cooldown time on the owning pawn */
KFAIC.AddCooldownTimer(Attacks[DesiredStrikeIndex].Tag, Attacks[DesiredStrikeIndex].InstancedCooldown);
}
// Let the Game Conductor know an attack happened
if( KFAIC != none && KFGameInfo(KFAIC.WorldInfo.Game) != none && KFGameInfo(KFAIC.WorldInfo.Game).GameConductor != none )
{
KFGameInfo(KFAIC.WorldInfo.Game).GameConductor.UpdateOverallAttackCoolDowns(KFAIC);
}
}
/** Find the min/max range of each Tag (attack category) defined in my KFPawn_AnimGroup. Used to determine when
a zed should consider attacking */
function float GetAttackRange( KFAIController KFAIC )
{
local int TagIdx;
local float MaxAttackRange;
for( TagIdx = 0; TagIdx < Attacks.Length; TagIdx++ )
{
if( Attacks[TagIdx].Tag == '' )
{
continue;
}
if( MaxAttackRange == 0 || (Attacks[TagIdx].MaxDistance > MaxAttackRange) )
{
MaxAttackRange = Attacks[TagIdx].MaxDistance;
}
}
return MaxAttackRange;
}
/** Find the min/max range of each Tag (attack category) defined in my KFPawn_AnimGroup. This is per-Tag,
* not per attack animation, and is used to pre-determine if any of the attacks for a Tag is within range. */
function float GetMedianStrikeRange( byte MeleeAttackIndex, float StrikeRangePercentage, float CollisionRadius )
{
local float MinMeleeRange, MaxMeleeRange;
MaxMeleeRange = Attacks[MeleeAttackIndex].MaxDistance;
MinMeleeRange = Attacks[MeleeAttackIndex].MinDistance;
if( MinMeleeRange < CollisionRadius )
{
MinMeleeRange = CollisionRadius;
}
return MinMeleeRange + (MaxMeleeRange - MinMeleeRange) * StrikeRangePercentage;
}
function int GetAttackIndexByTag( name AttackTag )
{
return Attacks.Find('Tag', AttackTag);
}
function name GetAttackAnimName( int AttackIndex, byte VariantIndex )
{
return Attacks[AttackIndex].Anims[VariantIndex];
}
function byte GetStrikeFlags(int DesiredStrikeIndex)
{
local int Variant;
if( DesiredStrikeIndex > Attacks.length )
{
return 255;
}
// Get a random animation (random variant)
Variant = Rand(Attacks[DesiredStrikeIndex].Anims.Length);
return (DesiredStrikeIndex + (variant << 4));
}
/** Ensures that LastTimePlayed is never greater than world time */
function CheckForValidCooldown( int AtkIdx )
{
if( class'WorldInfo'.static.GetWorldInfo().TimeSeconds < Attacks[AtkIdx].LastTimePlayed )
{
`log("[ANIMINFO] WorldInfo.TimeSeconds mismatch! Resetting cooldowns.");
Attacks[AtkIdx].LastTimePlayed = 0.f;
}
}
/** Checks the AttackAnimInfo to see if this attack is valid to perform */
function bool CanDoAttackAnim(int Idx, KFPawn P, optional Actor Target)
{
local AttackAnimInfo Attack;
// Solve edge case where world time has reset but LastUsedTime hasn't
CheckForValidCooldown( Idx );
Attack = Attacks[Idx];
if ( Attack.Anims.Length <= 0 )
{
`log(self@"CanDoAttackAnim missing attack anim names for"@Attacks[Idx].Tag);
return false;
}
if( Attack.bOnlyWhilePathClear && P.MyKFAIC.bIsBodyBlocked )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhilePathClear is true but Pawn is blocked", bDebugLog );
return false;
}
if( Attack.bHasCloaking && (Attack.bOnlyWhileCloaked && !P.bIsCloaking) || (Attack.bOnlyWhileDeCloaked && P.bIsCloaking) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because it is not allowed in this cloaking state", bDebugLog );
return false;
}
if( Attack.bIsBattlePhaseAttack && (P.GetCurrentBattlePhase() < Attack.BattlePhaseMinimum || P.GetCurrentBattlePhase() > Attack.BattlePhaseMaximum) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because not allowed in this Battle Phase", bDebugLog );
return false;
}
if( P.MyKFAIC != none && !P.MyKFAIC.CheckOverallCooldownTimer())
{
`AILog_Ext( GetFuncName()$"() PREVENTING attack "$Attack.Tag$" because Overall Cooldown is active", 'Command_Attack_Melee', P.MyKFAIC );
return false;
}
if ( Attack.GlobalCooldown > 0 && Attack.LastTimePlayed > 0.f
&& `TimeSinceEx(P, Attack.LastTimePlayed) < Attack.GlobalCooldown )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because GlobalCooldown ("$Attack.GlobalCooldown$") LastTimePlayed:"$`TimeSinceEx(P, Attack.LastTimePlayed), bDebugLog );
return false;
}
if ( Attack.Chance < 1.f && FRand() > Attack.Chance )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because random chance missed (Chance:"$Attack.Chance$")", bDebugLog );
return false;
}
if( !AllowAttackByMovement( Idx, P ) )
{
return false;
}
if ( Attack.bOnlyWhileHeadless != P.ShouldPlayHeadlessMeleeAnims() )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhileHeadless is true but Pawn has a head", bDebugLog );
return false;
}
if ( Attack.InstancedCooldown > 0 && IsAttackOnCooldown(P, Attack.Tag, Attack.InstancedCooldown) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because Cooldown is still active", bDebugLog );
return false;
}
if ( Attack.bOnlyWhileSurrounded && !P.IsSurrounded(true, Attack.MinSurroundedBy, Attack.SurroundedRadius) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because pawn is not surrounded", bDebugLog );
return false;
}
if ( Target != None )
{
if ( Attack.bOnlyWhileEnemyMoving && IsZero(Target.Velocity) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because target velocity is 0", bDebugLog );
return false;
}
else if ( Attack.bOnlyWhileEnemyNotMoving && !IsZero(Target.Velocity) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because target velocity is not 0", bDebugLog );
return false;
}
if ( Attack.MaxDistance > 0 && VSizeSq(P.Location - Target.Location) > Square(Attack.MaxDistance) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because target dist ("$VSize(P.Location - Target.Location)$") is greater than "$Attack.MaxDistance, bDebugLog );
return false;
}
if ( Attack.MinDistance > 0 && VSizeSq(P.Location - Target.Location) < Square(Attack.MinDistance) )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because target dist is less than "$Attack.MinDistance, bDebugLog );
return false;
}
}
if ( !AllowAttackByDifficulty(Idx) )
{
if( P.MyKFAIC != none )
{
`AILog_Ext( GetFuncName()$"() PREVENTING attack "$Attack.Tag$" because it has a DifficultyRating of "$Attack.DifficultyRating, 'Command_Attack_Melee', P.MyKFAIC );
}
return false; // do this last so perf is consistant
}
return true;
}
/** Return true if this attack was recently used and has a cooldown timer */
function bool IsAttackOnCooldown(KFPawn P, name CooldownTag, float CooldownTime)
{
if ( P.MyKFAIC != None )
{
return !P.MyKFAIC.CheckCooldownTimer(CooldownTag);
}
return false;
}
/** Returns the range of an attack for AI behavior modification */
function Vector2D GetAttackRangeByName(name AttackName)
{
local int idx;
idx = Attacks.Find('Tag', AttackName);
if ( idx != INDEX_NONE )
{
return vect2d(Attacks[Idx].MinDistance, Attacks[Idx].MaxDistance);
}
return vect2d(0,0);
}
/** Returns the range of an attack for AI behavior modification */
function Vector2D GetAttackRangeExtent(name AttackName)
{
local int i;
local float MinRange, MaxRange;
MinRange = MAXINT;
// Find smallest min and greatest max
for(i = 0; i < Attacks.Length; i++)
{
if ( Attacks[i].Chance > 0.f )
{
MinRange = Min(MinRange, Attacks[i].MinDistance);
MaxRange = Max(MaxRange, Attacks[i].MaxDistance);
}
}
return vect2d(MinRange,MaxRange);
}
/*********************************************************************************************
* @name Difficulty Scaling
*********************************************************************************************/
/** Cache any values from the difficulty info that we may be using */
function SetDifficultyValues( KFGameDifficultyInfo DifficultyInfo )
{
WeakAttackChance = DifficultyInfo.GetWeakAttackChance();
MediumAttackChance = DifficultyInfo.GetMediumAttackChance();
HardAttackChance = DifficultyInfo.GetHardAttackChance();
}
function bool AllowAttackByMovement( byte Idx, KFPawn P )
{
if ( Attacks[Idx].bOnlyWhileSprinting && !P.bIsSprinting )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhileSprinting is true but Pawn is not sprinting", bDebugLog );
return false;
}
else if ( Attacks[Idx].bOnlyWhileNotSprinting && P.bIsSprinting )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhileNotSprinting is true but Pawn is sprinting", bDebugLog );
return false;
}
if( Attacks[Idx].bOnlyWhileInSpecializedMode && !P.ShouldPlaySpecialMeleeAnims() )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhileInSpecializedMode is true but Pawn not in SpecializedMode", bDebugLog );
return false;
}
else if( Attacks[Idx].bOnlyWhileNotInSpecializedMode && P.ShouldPlaySpecialMeleeAnims() )
{
`log( P@GetFuncName()$"() rejecting attack idx "$idx$" because bOnlyWhileNotInSpecializedMode is true but Pawn is in SpecializedMode", bDebugLog );
return false;
}
return true;
}
function bool AllowAttackByDifficulty( byte Index )
{
if ( bEnableDifficultyScaling )
{
switch ( Attacks[Index].DifficultyRating )
{
case AR_Weak:
if ( MediumAttackChance >= WeakAttackChance && Attacks[Index].bSkipIfDifficultyIsExceeded )
return false;
return (WeakAttackChance >= 1.f || FRand() < WeakAttackChance);
case AR_Medium:
if ( HardAttackChance >= MediumAttackChance && Attacks[Index].bSkipIfDifficultyIsExceeded )
return false;
return (MediumAttackChance >= 1.f || FRand() < MediumAttackChance);
case AR_Strong:
return (HardAttackChance >= 1.f || FRand() < HardAttackChance);
}
}
return true;
}
/*********************************************************************************************
* @name Death Animations
*********************************************************************************************/
/**
* Pick a random death animation from supplied list.
* Also makes sure we don't pick up the same animation twice in a row.
*/
function Name ChooseDeathAnimation(KFPawn P, class<DamageType> DamageType, vector HitDir, optional name HitBoneName)
{
local int idx;
// First try to do a 'high kickback' death animation
if ( ClassIsChildOf(damageType, class'KFDT_Explosive') )
{
return EvaulateDeathAnimList(ExplosiveDeathAnims, P, HitDir);
}
// Then look for a hit zone specific animation
idx = BodyPartDeathAnims.Find('BoneName', HitBoneName);
if ( idx != INDEX_NONE )
{
if ( BodyPartDeathAnims[idx].IgnoreChance > 0.f && FRand() < BodyPartDeathAnims[idx].IgnoreChance )
{
// use the default death animation list
return EvaulateDeathAnimList(DefaultDeathAnims, P, HitDir);
}
return EvaulateDeathAnimList(BodyPartDeathAnims[idx], P, HitDir);
}
// Finally, use the default death animation list
return EvaulateDeathAnimList(DefaultDeathAnims, P, HitDir);
}
/** Once a death type is selected, choose animation variant based on hit direction */
function Name EvaulateDeathAnimList(const out DeathAnimInfo DeathAnims, KFPawn P, vector HitDir)
{
local EPawnOctant Region;
// If this list has a ragdoll chance it may return NAME_None
if ( DeathAnims.RagdollChance > 0.f && FRand() < DeathAnims.RagdollChance )
{
return '';
}
if ( DeathAnims.DismemberedAnims.Length > 0 && P.bHasBrokenConstraints && P.Mesh.IsBrokenConstraint(DeathAnims.BoneName) )
{
LastDeathAnimIndex = Rand(DeathAnims.DismemberedAnims.Length);
return DeathAnims.DismemberedAnims[LastDeathAnimIndex];
}
// if this set has direction anims than calculate hit direction
if ( DeathAnims.Anims_B.Length > 0 )
{
Region = P.CalcQuadRegion(P.Rotation, -HitDir);
switch (Region)
{
case DIR_Backward:
if ( DeathAnims.Anims_B.Length > 0 )
{
LastDeathAnimIndex = Rand(DeathAnims.Anims_B.Length);
return DeathAnims.Anims_B[LastDeathAnimIndex];
}
break;
case DIR_Left:
if ( DeathAnims.Anims_L.Length > 0 )
{
LastDeathAnimIndex = Rand(DeathAnims.Anims_L.Length);
return DeathAnims.Anims_L[LastDeathAnimIndex];
}
break;
case DIR_Right:
if ( DeathAnims.Anims_R.Length > 0 )
{
LastDeathAnimIndex = Rand(DeathAnims.Anims_R.Length);
return DeathAnims.Anims_R[LastDeathAnimIndex];
}
break;
}
}
LastDeathAnimIndex = Rand(DeathAnims.Anims_F.Length);
return DeathAnims.Anims_F[LastDeathAnimIndex];
}
/*********************************************************************************************
* @name Hit Reactions
*********************************************************************************************/
function bool PlayHitReactionAnim(KFPawn P, EHitReactionAnimType Type, EPawnOctant Dir)
{
local name AnimName;
local float Duration;
if ( !bCanPlayAnimHitReactions )
{
return false;
}
if ( Dir == DIR_None && DmgOverTimeHitAnims.Length > 0 )
{
AnimName = DmgOverTimeHitAnims[Rand(DmgOverTimeHitAnims.Length)];
Duration = P.PlayBodyAnim(AnimName, EAS_Additive, 1.f, 0.1f);
P.NextHitReactionAnim_ActorTime = P.GetActorTimeSeconds() + RandRange(0.15f, 0.33f);
}
else if ( Type == HIT_Light && LightHitAnims[Dir].Anims.Length > 0 )
{
AnimName = LightHitAnims[Dir].Anims[Rand(LightHitAnims[Dir].Anims.Length)];
Duration = P.PlayBodyAnim(AnimName, EAS_Additive, 1.f, 0.1f);
P.NextHitReactionAnim_ActorTime = P.GetActorTimeSeconds() + RandRange(0.15f, 0.33f);
}
else if ( Type == HIT_Medium && MediumHitAnims[Dir].Anims.Length > 0 )
{
AnimName = MediumHitAnims[Dir].Anims[Rand(MediumHitAnims[Dir].Anims.Length)];
Duration = P.PlayBodyAnim(AnimName, EAS_UpperBody);
P.NextHitReactionAnim_ActorTime = P.GetActorTimeSeconds() + 0.33f;//RandRange(0.0f, 0.1f);
P.SoundGroupArch.PlayPainSound(P);
}
else if ( Type == HIT_Heavy && HeavyHitAnims[Dir].Anims.Length > 0 )
{
AnimName = HeavyHitAnims[Dir].Anims[Rand(HeavyHitAnims[Dir].Anims.Length)];
Duration = P.PlayBodyAnim(AnimName, EAS_UpperBody);
P.NextHitReactionAnim_ActorTime = P.GetActorTimeSeconds() + 0.33f;//RandRange(0.5f, 1.5f);
P.SoundGroupArch.PlayPainSound(P);
}
return ( Duration > 0 );
}
defaultproperties
{
bCanPlayDeathAnimations=true
bCanPlayAnimHitReactions=true
LightHitAnims(DIR_Forward)=(Anims=(ADD_Bullet_F_V1, ADD_Bullet_F_V2, ADD_Bullet_F_V3))
LightHitAnims(DIR_Backward)=(Anims=(ADD_Bullet_B_V1, ADD_Bullet_B_V2, ADD_Bullet_B_V3))
LightHitAnims(DIR_ForwardLeft)=(Anims=(ADD_Bullet_FL_V1, ADD_Bullet_FL_V2, ADD_Bullet_FL_V3))
LightHitAnims(DIR_ForwardRight)=(Anims=(ADD_Bullet_FR_V1, ADD_Bullet_FR_V2, ADD_Bullet_FR_V3))
LightHitAnims(DIR_BackwardLeft)=(Anims=(ADD_Bullet_BL_V1, ADD_Bullet_BL_V2, ADD_Bullet_BL_V3))
LightHitAnims(DIR_BackwardRight)=(Anims=(ADD_Bullet_BR_V1, ADD_Bullet_BR_V2, ADD_Bullet_BR_V3))
LightHitAnims(DIR_Left)=(Anims=(ADD_Bullet_L_V1, ADD_Bullet_L_V2, ADD_Bullet_L_V3))
LightHitAnims(DIR_Right)=(Anims=(ADD_Bullet_R_V1, ADD_Bullet_R_V2, ADD_Bullet_R_V3))
MediumHitAnims(DIR_Forward)=(Anims=(Hit_F_V1, Hit_F_V2, Hit_F_V3))
MediumHitAnims(DIR_Backward)=(Anims=(Hit_B_V1, Hit_B_V2, Hit_B_V3))
MediumHitAnims(DIR_ForwardLeft)=(Anims=(Hit_FL_V1, Hit_FL_V2, Hit_FL_V3))
MediumHitAnims(DIR_ForwardRight)=(Anims=(Hit_FR_V1, Hit_FR_V2, Hit_FR_V3))
MediumHitAnims(DIR_BackwardLeft)=(Anims=(Hit_BL_V1, Hit_BL_V2, Hit_BL_V3))
MediumHitAnims(DIR_BackwardRight)=(Anims=(Hit_BR_V1, Hit_BR_V2, Hit_BR_V3))
MediumHitAnims(DIR_Left)=(Anims=(Hit_L_V1, Hit_L_V2, Hit_L_V3))
MediumHitAnims(DIR_Right)=(Anims=(Hit_R_V1, Hit_R_V2, Hit_R_V3))
HeavyHitAnims(DIR_Forward)=(Anims=(Hit_Hard_F_V1, Hit_Hard_F_V2, Hit_Hard_F_V3))
HeavyHitAnims(DIR_Backward)=(Anims=(Hit_Hard_B_V1, Hit_Hard_B_V2, Hit_Hard_B_V3))
HeavyHitAnims(DIR_ForwardLeft)=(Anims=(Hit_Hard_FL_V1, Hit_Hard_FL_V2, Hit_Hard_FL_V3))
HeavyHitAnims(DIR_ForwardRight)=(Anims=(Hit_Hard_FR_V1, Hit_Hard_FR_V2, Hit_Hard_FR_V3))
HeavyHitAnims(DIR_BackwardLeft)=(Anims=(Hit_Hard_BL_V1, Hit_Hard_BL_V2, Hit_Hard_BL_V3))
HeavyHitAnims(DIR_BackwardRight)=(Anims=(Hit_Hard_BR_V1, Hit_Hard_BR_V2, Hit_Hard_BR_V3))
HeavyHitAnims(DIR_Left)=(Anims=(Hit_Hard_L_V1, Hit_Hard_L_V2, Hit_Hard_L_V3))
HeavyHitAnims(DIR_Right)=(Anims=(Hit_Hard_R_V1, Hit_Hard_R_V2, Hit_Hard_R_V3))
DmgOverTimeHitAnims=(ADD_Bullet_F_V1, ADD_Bullet_F_V2, ADD_Bullet_F_V3, ADD_Bullet_FL_V1, ADD_Bullet_FL_V2, ADD_Bullet_FL_V3, ADD_Bullet_FR_V1, ADD_Bullet_FR_V2, ADD_Bullet_FR_V3)
DefaultDeathAnims={( IgnoreChance=0.f,
Anims_F=(Death_F_V1, Death_F_V2, Death_F_V3, Death_F_V4, Death_F_V5, Death_F_V6, Death_F_V7, Death_F_V8),
Anims_B=(Death_B_V1, Death_B_V2, Death_B_V3, Death_B_V4, Death_B_V5, Death_B_V6),
Anims_L=(Death_L_V1, Death_L_V2, Death_L_V3, Death_L_V4, Death_L_V5, Death_L_V6),
Anims_R=(Death_R_V1, Death_R_V2, Death_R_V3, Death_R_V4, Death_R_V5, Death_R_V6) )}
ExplosiveDeathAnims={( IgnoreChance=0.f,
Anims_F=(DeathEXP_F_V1, DeathEXP_F_V2, DeathEXP_F_V3, DeathEXP_F_V4, DeathEXP_Up_V1, DeathEXP_Up_V2),
Anims_B=(DeathEXP_B_V1, DeathEXP_B_V2, DeathEXP_B_V3, DeathEXP_Up_V1, DeathEXP_Up_V2),
Anims_L=(DeathEXP_L_V1, DeathEXP_L_V2, DeathEXP_L_V3, DeathEXP_L_V4),
Anims_R=(DeathEXP_R_V1, DeathEXP_R_V2, DeathEXP_R_V3, DeathEXP_R_V4) )}
// Hit zone specific death anims
BodyPartDeathAnims.Add((BoneName=Head, RagdollChance=0.25f, Anims_F=(Death_Head_V1, Death_Head_V2, Death_Head_V3, Death_Head_V4, Death_Head_V5, Death_Head_V6, Death_Head_V7, Death_Head_V8, Death_Convulsion_V1, Death_Convulsion_V2, Death_Neck_V4, Death_Neck_V5, Death_Neck_V6))
BodyPartDeathAnims.Add((BoneName=Neck, Anims_F=(Death_Neck_V1, Death_Neck_V2, Death_Neck_V3, Death_Neck_V4, Death_Neck_V5, Death_Neck_V6, Death_Neck_V7))
BodyPartDeathAnims.Add((BoneName=Hips, RagdollChance=0.20f, Anims_F=(Death_Stomach_V1, Death_Stomach_V2, Death_Stomach_V3, Death_Stomach_V4, Death_Stomach_V5, Death_Stomach_V6, Death_Stomach_V7, Death_Neck_V1, Death_Neck_V2, Death_Neck_V7))
BodyPartDeathAnims.Add((BoneName=Spine1, RagdollChance=0.20f, Anims_F=(Death_Stomach_V1, Death_Stomach_V2, Death_Stomach_V3, Death_Stomach_V4, Death_Stomach_V5, Death_Stomach_V6, Death_Stomach_V7, Death_Neck_V1, Death_Neck_V2, Death_Neck_V7))
BodyPartDeathAnims.Add((BoneName=Spine2, IgnoreChance=0.50f, RagdollChance=0.1f, Anims_F=(Death_FL_V5, Death_FL_V6, Death_FR_V6, Death_Head_V5, Death_Head_V7, Death_Head_V8, Death_Neck_V5, Death_Neck_V6, Death_Neck_V7, Death_Stomach_V5, Death_Convulsion_V2, Death_Convulsion_V4))
BodyPartDeathAnims.Add((BoneName=LeftUpLeg, Anims_F=(Death_LegL_V1, Death_LegL_V2, Death_LegL_V3, Death_LegL_V4))
BodyPartDeathAnims.Add((BoneName=LeftLeg, Anims_F=(Death_LegL_V1, Death_LegL_V2, Death_LegL_V3, Death_LegL_V4))
BodyPartDeathAnims.Add((BoneName=LeftFoot, Anims_F=(Death_LegL_V1, Death_LegL_V2, Death_LegL_V3, Death_LegL_V4))
BodyPartDeathAnims.Add((BoneName=RightUpLeg, Anims_F=(Death_LegR_V1, Death_LegR_V2, Death_LegR_V3, Death_LegR_V4))
BodyPartDeathAnims.Add((BoneName=RightLeg, Anims_F=(Death_LegR_V1, Death_LegR_V2, Death_LegR_V3, Death_LegR_V4))
BodyPartDeathAnims.Add((BoneName=RightFoot, Anims_F=(Death_LegR_V1, Death_LegR_V2, Death_LegR_V3, Death_LegR_V4))
BodyPartDeathAnims.Add((BoneName=LeftShoulder, Anims_F=(Death_FL_V1, Death_FL_V2, Death_FL_V3, Death_LegL_V2, Death_LegR_V1), Anims_B=(Death_BL_V1, Death_BL_V2, Death_BL_V3))
BodyPartDeathAnims.Add((BoneName=RightShoulder, Anims_F=(Death_FR_V1, Death_FR_V2, Death_FR_V3, Death_LegL_V1), Anims_B=(Death_BR_V1, Death_BR_V2, Death_BR_V3))
BodyPartDeathAnims.Add((BoneName=LeftArm, Anims_F=(Death_FL_V1, Death_FL_V2, Death_FL_V3, Death_FL_V4, Death_FL_V5), Anims_B=(Death_BL_V1, Death_BL_V2, Death_BL_V3))
BodyPartDeathAnims.Add((BoneName=LeftForearm, Anims_F=(Death_FL_V1, Death_FL_V2, Death_FL_V3, Death_FL_V4, Death_FL_V5), Anims_B=(Death_BL_V1, Death_BL_V2, Death_BL_V3))
BodyPartDeathAnims.Add((BoneName=LeftHand, Anims_F=(Death_FL_V1, Death_FL_V2, Death_FL_V3, Death_FL_V4, Death_FL_V5), Anims_B=(Death_BL_V1, Death_BL_V2, Death_BL_V3))
BodyPartDeathAnims.Add((BoneName=RightArm, Anims_F=(Death_FR_V1, Death_FR_V2, Death_FR_V3, Death_FR_V4), Anims_B=(Death_BR_V1, Death_BR_V2, Death_BR_V3))
BodyPartDeathAnims.Add((BoneName=RightForearm, Anims_F=(Death_FR_V1, Death_FR_V2, Death_FR_V3, Death_FR_V4), Anims_B=(Death_BR_V1, Death_BR_V2, Death_BR_V3))
BodyPartDeathAnims.Add((BoneName=RightHand, Anims_F=(Death_FR_V1, Death_FR_V2, Death_FR_V3, Death_FR_V4), Anims_B=(Death_BR_V1, Death_BR_V2, Death_BR_V3))
DeathPhysMotorStrength=(X=70000,Y=2000)
WeakAttackChance=1.f
MediumAttackChance=1.f
HardAttackChance=1.f
bEnableDifficultyScaling=true
bDebugLog=false
// Taunts
TauntAnims.Add(Taunt_V1)
TauntAnims.Add(Taunt_V2)
TauntKillAnims.Add(Taunt_Kill_V1)
TauntKillAnims.Add(Taunt_Kill_V2)
// KFSM_Stumble
StumbleAnims(ESA_Body_Forward)=(Anims=(Stumble_F_V1, Stumble_F_V2, Stumble_F_V3, Stumble_F_V4))
StumbleAnims(ESA_Body_Backward)=(Anims=(Stumble_B_V1, Stumble_B_V2, Stumble_B_V3, Stumble_B_V4))
StumbleAnims(ESA_Body_Left)=(Anims=(Stumble_L_V1, Stumble_L_V2, Stumble_L_V3, Stumble_L_V4))
StumbleAnims(ESA_Body_Right)=(Anims=(Stumble_R_V1, Stumble_R_V2, Stumble_R_V3, Stumble_R_V4))
StumbleAnims(ESA_Leg_L_Forward)=(Anims=(Stumble_L_Leg_F_V1, Stumble_L_Leg_F_V2))
StumbleAnims(ESA_Leg_L_Backward)=(Anims=(Stumble_L_Leg_B_V1, Stumble_L_Leg_B_V2))
StumbleAnims(ESA_Leg_L_Left)=(Anims=(Stumble_L_Leg_L_V1, Stumble_L_Leg_L_V2))
StumbleAnims(ESA_Leg_L_Right)=(Anims=(Stumble_L_Leg_R_V1, Stumble_L_Leg_R_V2))
StumbleAnims(ESA_Leg_R_Forward)=(Anims=(Stumble_R_Leg_F_V1, Stumble_R_Leg_F_V2))
StumbleAnims(ESA_Leg_R_Backward)=(Anims=(Stumble_R_Leg_B_V1, Stumble_R_Leg_B_V2))
StumbleAnims(ESA_Leg_R_Left)=(Anims=(Stumble_R_Leg_L_V1, Stumble_R_Leg_L_V2))
StumbleAnims(ESA_Leg_R_Right)=(Anims=(Stumble_R_Leg_R_V1, Stumble_R_Leg_R_V2))
StumbleAnims(ESA_Parry)=(Anims=(Stumble_F_V1, Stumble_F_V2, Stumble_F_V3, Stumble_F_V4))
}