1144 lines
30 KiB
Ucode
1144 lines
30 KiB
Ucode
|
//=============================================================================
|
||
|
|
// KFPawn_Scripted
|
||
|
|
//=============================================================================
|
||
|
|
// Pawn for scripted characters
|
||
|
|
//=============================================================================
|
||
|
|
// Killing Floor 2
|
||
|
|
// Copyright (C) 2018 Tripwire Interactive LLC
|
||
|
|
//=============================================================================
|
||
|
|
class KFPawn_Scripted extends KFPawn
|
||
|
|
native(Pawn)
|
||
|
|
implements(KFInterface_TriggerOwner);
|
||
|
|
|
||
|
|
var localized string ScriptedPawnString;
|
||
|
|
|
||
|
|
// Character archetype for the pawn
|
||
|
|
var repnotify KFCharacterInfo_ScriptedPawn ScriptedCharArchTemplate;
|
||
|
|
var KFCharacterInfo_ScriptedPawn ScriptedCharArch;
|
||
|
|
var bool bCanCurrentlyBeTargetedByZeds;
|
||
|
|
var repnotify transient KFWeldableComponent WeldableComponent;
|
||
|
|
var repnotify transient KFWeldableTrigger WeldableTrigger;
|
||
|
|
|
||
|
|
var transient KFTrigger_NotifyOwner ZedProximityTrigger, PlayerProximityTrigger;
|
||
|
|
var transient bool bZedInProximity, bPlayerInProximity;
|
||
|
|
|
||
|
|
var repnotify byte CurrentState;
|
||
|
|
var byte PreviousState;
|
||
|
|
|
||
|
|
var transient repnotify bool bActive;
|
||
|
|
var transient bool bStartInactive;
|
||
|
|
|
||
|
|
var string IconPath;
|
||
|
|
|
||
|
|
var KFDoorActor BlockingDoor;
|
||
|
|
var float SpeedScalarForObstacles;
|
||
|
|
|
||
|
|
var array<ExtraVFXInfo> ScriptedStateVFX;
|
||
|
|
|
||
|
|
/** Amount of timer since last damage to consider "recent" in terms of UI messaging to the player*/
|
||
|
|
var float RecentDamageTimerLength;
|
||
|
|
|
||
|
|
/** Default material for this scripted pawn's mesh*/
|
||
|
|
var MaterialInterface DefaultMaterial;
|
||
|
|
|
||
|
|
/** Whether to block PCs */
|
||
|
|
var() bool bBlockPlayers<DisplayName = Block Human Players>;
|
||
|
|
/** Whether to block PC controlled zeds (team == 255) */
|
||
|
|
var() bool bBlockZedPlayers<DisplayName = Block Zed Players>;
|
||
|
|
/** Whether to block AI Zeds */
|
||
|
|
var() bool bBlockMonsters<DisplayName = Block AI>;
|
||
|
|
/** Whether to block anything when at zero health or marked dead */
|
||
|
|
var() bool bBlockInStoppedState<DisplayName = Block When In Stopped State>;
|
||
|
|
/** If the current scripted pawn state doesn't allow movement */
|
||
|
|
var bool bIsInStoppedState;
|
||
|
|
|
||
|
|
delegate Delegate_OnReachedRouteMarker(int MarkerIdx, SplineActor Marker, int SubIdx, float DistSinceLastMarker);
|
||
|
|
delegate Delegate_OnEndedRoute(bool bSuccess);
|
||
|
|
delegate Delegate_OnTakeDamage(int Damage);
|
||
|
|
delegate Delegate_OnHealDamage(int HealAmount);
|
||
|
|
delegate Delegate_OnChangeState(int CurrState, int PrevState);
|
||
|
|
|
||
|
|
replication
|
||
|
|
{
|
||
|
|
if (bNetDirty)
|
||
|
|
ScriptedCharArchTemplate, CurrentState, WeldableComponent, WeldableTrigger, bActive;
|
||
|
|
}
|
||
|
|
|
||
|
|
cpptext
|
||
|
|
{
|
||
|
|
virtual UBOOL ShouldTrace(UPrimitiveComponent* Primitive,AActor *SourceActor, DWORD TraceFlags);
|
||
|
|
virtual UBOOL IgnoreBlockingBy(const AActor* Other) const;
|
||
|
|
// also checks whether the pawn is active
|
||
|
|
virtual UBOOL IsAliveAndWell() const;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated event ReplicatedEvent(name VarName)
|
||
|
|
{
|
||
|
|
switch (VarName)
|
||
|
|
{
|
||
|
|
case nameof(ScriptedCharArchTemplate):
|
||
|
|
SetCharacterArch(ScriptedCharArchTemplate, true);
|
||
|
|
|
||
|
|
// attempts to initialize weldable component will fail before we get our archetype
|
||
|
|
InitializeWeldableComponent();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case nameof(WeldableComponent):
|
||
|
|
InitializeWeldableComponent();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case nameof(WeldableTrigger):
|
||
|
|
InitializeWeldableTrigger();
|
||
|
|
break;
|
||
|
|
|
||
|
|
case nameof(CurrentState):
|
||
|
|
SetPawnState(CurrentState);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case nameof(bActive):
|
||
|
|
SetActive(bActive);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
super.ReplicatedEvent(VarName);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Initialize(KFCharacterInfo_ScriptedPawn InCharInfo, int InHealth, int InHealthMax)
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
|
||
|
|
if (Role < ROLE_Authority)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetCharacterArch(InCharInfo, true);
|
||
|
|
|
||
|
|
if (ScriptedCharArch.bDisableCollisionOnStart)
|
||
|
|
{
|
||
|
|
SetCollision(false, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
Health = Clamp(InHealth, 1, InHealthMax);
|
||
|
|
HealthMax = InHealthMax;
|
||
|
|
|
||
|
|
if (ScriptedCharArch.bPawnCanBeWelded || ScriptedCharArch.bPawnCanBeUnwelded)
|
||
|
|
{
|
||
|
|
InitializeWeldable();
|
||
|
|
}
|
||
|
|
|
||
|
|
// if pawn isn't allowed to die, then make sure any state set to a health percentage less than 1
|
||
|
|
// gets set to something a little bit more than 1
|
||
|
|
if (!ScriptedCharArch.bPawnCanBeKilled)
|
||
|
|
{
|
||
|
|
for (i = 0; i < ScriptedCharArch.States.Length; ++i)
|
||
|
|
{
|
||
|
|
ScriptedCharArch.States[i].HealthPctThreshold = FMax(ScriptedCharArch.States[i].HealthPctThreshold, (1.1f / float(HealthMax)));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ScriptedCharArch.bUseZedProximityTrigger || ScriptedCharArch.bUsePlayerProximityTrigger)
|
||
|
|
{
|
||
|
|
InitializeProximityTriggers();
|
||
|
|
}
|
||
|
|
|
||
|
|
// save off the default material in case a specific state does not specify a material
|
||
|
|
DefaultMaterial = Mesh.GetMaterial(0);
|
||
|
|
|
||
|
|
SetPawnState(0);
|
||
|
|
UpdatePawnState();
|
||
|
|
SetCanBeTargeted(false);
|
||
|
|
|
||
|
|
if (ScriptedCharArch.bIsFlyingPawn)
|
||
|
|
{
|
||
|
|
SetPhysics(PHYS_Flying);
|
||
|
|
bCollideWorld = false;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
SetPhysics(PHYS_Walking);
|
||
|
|
bCollideWorld = true; // must collide with world until it lands
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function InitializeWeldable()
|
||
|
|
{
|
||
|
|
WeldableComponent = Spawn(class'KFWeldableComponent', self);
|
||
|
|
InitializeWeldableComponent();
|
||
|
|
|
||
|
|
WeldableTrigger = Spawn(class'KFWeldableTrigger', self);
|
||
|
|
InitializeWeldableTrigger();
|
||
|
|
|
||
|
|
WeldableTrigger.SetCollision(false, false);
|
||
|
|
UpdateWeldIntegrity();
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function InitializeWeldableComponent()
|
||
|
|
{
|
||
|
|
local float WeldCompRadius, WeldCompHeight;
|
||
|
|
local KFGameReplicationInfo KFGRI;
|
||
|
|
|
||
|
|
// If we don't have an archetype, wait for it
|
||
|
|
// (InitializeWeldableComponent will be called from ReplicatedEvent)
|
||
|
|
if (ScriptedCharArch != none && WeldableComponent != none)
|
||
|
|
{
|
||
|
|
KFGRI = KFGameReplicationInfo(WorldInfo.GRI);
|
||
|
|
|
||
|
|
WeldableComponent.SetOwner(self);
|
||
|
|
WeldableComponent.SetBase(self);
|
||
|
|
WeldableComponent.MaxWeldIntegrity = ScriptedCharArch.PawnMaxWeldIntegrityPerPlayer[KFGRI.GetNumPlayers()-1];
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
WeldableComponent.WeldIntegrity = WeldableComponent.MaxWeldIntegrity;
|
||
|
|
}
|
||
|
|
WeldableComponent.bWeldable = ScriptedCharArch.bPawnCanBeWelded;
|
||
|
|
WeldableComponent.bUnweldable = ScriptedCharArch.bPawnCanBeUnwelded;
|
||
|
|
WeldableComponent.Delegate_OnWeldIntegrityChanged = OnWelded;
|
||
|
|
|
||
|
|
WeldCompRadius = WeldableComponent.GetCollisionCylinderRadius();
|
||
|
|
WeldCompHeight = WeldableComponent.GetCollisionCylinderHeight();
|
||
|
|
WeldableComponent.SetCollisionCylinderSize(WeldCompRadius * ScriptedCharArch.PawnWeldableComponentScale, WeldCompHeight);
|
||
|
|
WeldableComponent.SetCollision(bActive, false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function InitializeWeldableTrigger()
|
||
|
|
{
|
||
|
|
if (WeldableTrigger != none)
|
||
|
|
{
|
||
|
|
WeldableTrigger.SetOwner(self);
|
||
|
|
WeldableTrigger.SetBase(self);
|
||
|
|
WeldableTrigger.WeldableComponent = WeldableComponent;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function InitializeProximityTriggers()
|
||
|
|
{
|
||
|
|
local float TrigRadius, TrigHeight;
|
||
|
|
|
||
|
|
PlayerProximityTrigger = Spawn(class'KFTrigger_NotifyOwner', self);
|
||
|
|
PlayerProximityTrigger.SetOwner(self);
|
||
|
|
PlayerProximityTrigger.SetBase(self);
|
||
|
|
|
||
|
|
TrigRadius = CylinderComponent(PlayerProximityTrigger.CollisionComponent).CollisionRadius;
|
||
|
|
TrigHeight = CylinderComponent(PlayerProximityTrigger.CollisionComponent).CollisionHeight;
|
||
|
|
CylinderComponent(PlayerProximityTrigger.CollisionComponent).SetCylinderSize(TrigRadius * ScriptedCharArch.PlayerProximityTriggerScale, TrigHeight);
|
||
|
|
|
||
|
|
ZedProximityTrigger = Spawn(class'KFTrigger_NotifyOwner', self);
|
||
|
|
ZedProximityTrigger.SetOwner(self);
|
||
|
|
ZedProximityTrigger.SetBase(self);
|
||
|
|
|
||
|
|
TrigRadius = CylinderComponent(ZedProximityTrigger.CollisionComponent).CollisionRadius;
|
||
|
|
TrigHeight = CylinderComponent(ZedProximityTrigger.CollisionComponent).CollisionHeight;
|
||
|
|
CylinderComponent(ZedProximityTrigger.CollisionComponent).SetCylinderSize(TrigRadius * ScriptedCharArch.ZedProximityTriggerScale, TrigHeight);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function OnWelded(int Amount, KFPawn Welder)
|
||
|
|
{
|
||
|
|
local float WeldAmountPct;
|
||
|
|
local float HealAmount;
|
||
|
|
|
||
|
|
if (Role == ROLE_Authority && WeldableComponent != none)
|
||
|
|
{
|
||
|
|
WeldAmountPct = float(Amount) / float(WeldableComponent.MaxWeldIntegrity);
|
||
|
|
HealAmount = WeldAmountPct * float(HealthMax);
|
||
|
|
Health += HealAmount;
|
||
|
|
|
||
|
|
UpdateWeldIntegrity();
|
||
|
|
UpdatePawnState(1);
|
||
|
|
|
||
|
|
if (Delegate_OnHealDamage != none)
|
||
|
|
{
|
||
|
|
Delegate_OnHealDamage(HealAmount);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function UpdateWeldIntegrity()
|
||
|
|
{
|
||
|
|
if (Role == ROLE_Authority && WeldableComponent != none)
|
||
|
|
{
|
||
|
|
// set weldintegrity based on current health, because health and weldintegrity can get out of sync due to rounding error
|
||
|
|
WeldableComponent.SetWeldIntegrity((float(Health) / float(HealthMax)) * WeldableComponent.MaxWeldIntegrity);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function SetEscortPawnOnHud()
|
||
|
|
{
|
||
|
|
local KFPlayerController KFPC;
|
||
|
|
|
||
|
|
ForEach LocalPlayerControllers(class'KFPlayerController', KFPC)
|
||
|
|
{
|
||
|
|
if (KFPC.MyGFxHUD != None && KFPC.MyGFxHUD.BossHealthBar != none)
|
||
|
|
{
|
||
|
|
KFPC.MyGFxHUD.BossHealthBar.SetEscortPawn(self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
simulated function RemoveEscortPawnOnHud()
|
||
|
|
{
|
||
|
|
local KFPlayerController KFPC;
|
||
|
|
|
||
|
|
ForEach LocalPlayerControllers(class'KFPlayerController', KFPC)
|
||
|
|
{
|
||
|
|
if (KFPC.MyGFxHUD != None && KFPC.MyGFxHUD.BossHealthBar != none)
|
||
|
|
{
|
||
|
|
KFPC.MyGFxHUD.BossHealthBar.Deactivate();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Called from Possessed event when this controller has taken control of a Pawn */
|
||
|
|
function PossessedBy(Controller C, bool bVehicleTransition)
|
||
|
|
{
|
||
|
|
Super.PossessedBy(C, bVehicleTransition);
|
||
|
|
|
||
|
|
/** Set MyKFAIC for convenience to avoid casting */
|
||
|
|
if (KFAIController(C) != none)
|
||
|
|
{
|
||
|
|
MyKFAIC = KFAIController(C);
|
||
|
|
}
|
||
|
|
|
||
|
|
KFGameInfo(WorldInfo.Game).Teams[0].AddToTeam(C);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated event byte ScriptGetTeamNum()
|
||
|
|
{
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
function AdjustDamage(out int InDamage, out vector Momentum, Controller InstigatedBy, vector HitLocation, class<DamageType> DamageType, TraceHitInfo HitInfo, Actor DamageCauser)
|
||
|
|
{
|
||
|
|
if (InstigatedBy.GetTeamNum() == GetTeamNum() || !bCanCurrentlyBeTargetedByZeds || !bActive)
|
||
|
|
{
|
||
|
|
InDamage = 0;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
super.AdjustDamage(InDamage, Momentum, InstigatedBy, HitLocation, DamageType, HitInfo, DamageCauser);
|
||
|
|
|
||
|
|
if (InDamage >= Health && !ScriptedCharArch.bPawnCanBeKilled)
|
||
|
|
{
|
||
|
|
InDamage = Max(Health - 1, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function Timer_RecentDamage() {}
|
||
|
|
function bool WasAttackedRecently()
|
||
|
|
{
|
||
|
|
return IsTimerActive(nameof(Timer_RecentDamage));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
event TakeDamage(int Damage, Controller InstigatedBy, vector HitLocation, vector Momentum, class<DamageType> DamageType, optional TraceHitInfo HitInfo, optional Actor DamageCauser)
|
||
|
|
{
|
||
|
|
local int OldHealth, ActualDamage;
|
||
|
|
|
||
|
|
OldHealth = Health;
|
||
|
|
Super.TakeDamage(Damage, InstigatedBy, HitLocation, Momentum, DamageType, HitInfo, DamageCauser);
|
||
|
|
ActualDamage = OldHealth - Health;
|
||
|
|
|
||
|
|
if (ActualDamage > 0)
|
||
|
|
{
|
||
|
|
SetTimer(RecentDamageTimerLength, false, nameof(Timer_RecentDamage), self);
|
||
|
|
|
||
|
|
if (WeldableComponent != none)
|
||
|
|
{
|
||
|
|
UpdateWeldIntegrity();
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnState(-1);
|
||
|
|
|
||
|
|
if (Delegate_OnTakeDamage != none)
|
||
|
|
{
|
||
|
|
Delegate_OnTakeDamage(ActualDamage);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function PlayTakeHitEffects(vector HitDirection, vector HitLocation, optional bool bUseHitImpulse = true)
|
||
|
|
{
|
||
|
|
TryPlayHitReactionAnim(HitDirection, HitFxInfo.DamageType, HitFxInfo.HitBoneIndex);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Calculate type of hit reaction animation from damage info */
|
||
|
|
simulated function bool TryPlayHitReactionAnim(vector HitDirection, class<KFDamageType> damageType, byte HitZoneIdx)
|
||
|
|
{
|
||
|
|
local EPawnOctant AnimDir;
|
||
|
|
local EHitReactionAnimType HitReactionType;
|
||
|
|
local EHitZoneBodyPart BodyPart;
|
||
|
|
local bool bOnlyAdditiveHits;
|
||
|
|
|
||
|
|
if( damageType == none || ActorTimeSince(NextHitReactionAnim_ActorTime) < 0 )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// cannot play hit reaction anims during special moves
|
||
|
|
if ( IsDoingSpecialMove() )
|
||
|
|
{
|
||
|
|
bOnlyAdditiveHits = true;
|
||
|
|
if ( !SpecialMoves[SpecialMove].bAllowHitReactions )
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Set the limb used for incap effects
|
||
|
|
BodyPart = (HitZoneIdx != 255 && HitZoneIdx < HitZones.Length) ? HitZones[HitZoneIdx].Limb : BP_Torso;
|
||
|
|
|
||
|
|
HitReactionType = HIT_Light;
|
||
|
|
// If we're moving (e.g. DoPauseAI wasn't called because of incap cooldown) don't try hard/medium
|
||
|
|
// This is not 100% reliable, but worst case we get a reasonable upper body blend while moving
|
||
|
|
bOnlyAdditiveHits = bOnlyAdditiveHits || VSizeSq(Velocity) > 50.f;
|
||
|
|
|
||
|
|
if ( !bOnlyAdditiveHits )
|
||
|
|
{
|
||
|
|
HitReactionType = EHitReactionAnimType(AfflictionHandler.GetPredictedHitReaction(DamageType, BodyPart));
|
||
|
|
}
|
||
|
|
|
||
|
|
switch (BodyPart)
|
||
|
|
{
|
||
|
|
case BP_LeftArm:
|
||
|
|
AnimDir = CalcOctagonRegion(Rotation, -HitDirection);
|
||
|
|
if ( AnimDir == DIR_Forward || AnimDir == DIR_ForwardLeft || AnimDir == DIR_ForwardRight )
|
||
|
|
AnimDir = DIR_ForwardLeft;
|
||
|
|
else
|
||
|
|
AnimDir = DIR_BackwardLeft;
|
||
|
|
break;
|
||
|
|
case BP_RightArm:
|
||
|
|
AnimDir = CalcOctagonRegion(Rotation, -HitDirection);
|
||
|
|
if ( AnimDir == DIR_Forward || AnimDir == DIR_ForwardLeft || AnimDir == DIR_ForwardRight )
|
||
|
|
AnimDir = DIR_ForwardRight;
|
||
|
|
else
|
||
|
|
AnimDir = DIR_BackwardRight;
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
AnimDir = CalcOctagonRegion(Rotation, -HitDirection);
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Play animation
|
||
|
|
return PawnAnimInfo.PlayHitReactionAnim(self, HitReactionType, AnimDir);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function bool CanBeHealed()
|
||
|
|
{
|
||
|
|
return ScriptedCharArch.bPawnCanBeHealed;
|
||
|
|
}
|
||
|
|
|
||
|
|
event bool HealDamage(int Amount, Controller Healer, class<DamageType> DamageType, optional bool bRepairArmor=true, optional bool bMessageHealer=true)
|
||
|
|
{
|
||
|
|
local bool result;
|
||
|
|
local int PrevHealth;
|
||
|
|
|
||
|
|
if (!bActive || !ScriptedCharArch.bPawnCanBeHealed)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
PrevHealth = Health;
|
||
|
|
result = Super.HealDamage(Amount, Healer, DamageType, bRepairArmor, bMessageHealer);
|
||
|
|
|
||
|
|
UpdateWeldIntegrity();
|
||
|
|
UpdatePawnState(1);
|
||
|
|
|
||
|
|
if (Delegate_OnHealDamage != none)
|
||
|
|
{
|
||
|
|
Delegate_OnHealDamage(Health - PrevHealth);
|
||
|
|
}
|
||
|
|
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpdatePawnState(optional int HealthDelta = 0)
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
local float HealthPct;
|
||
|
|
|
||
|
|
HealthPct = float(Health) / float(HealthMax);
|
||
|
|
|
||
|
|
if (HealthDelta > 0)
|
||
|
|
{
|
||
|
|
for (i = 0; i < CurrentState; ++i)
|
||
|
|
{
|
||
|
|
if (HealthPct >= ScriptedCharArch.States[i].HealthPctThreshold)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for (i = CurrentState; i < ScriptedCharArch.States.Length - 1; ++i)
|
||
|
|
{
|
||
|
|
if (HealthPct >= ScriptedCharArch.States[i + 1].HealthPctThreshold)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
SetPawnState(i);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function SetPawnState(int InState)
|
||
|
|
{
|
||
|
|
local int ExitTransitionType, EnterTransitionType;
|
||
|
|
|
||
|
|
if (Role == ROLE_Authority && InState == CurrentState)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ScriptedCharArchTemplate != none)
|
||
|
|
{
|
||
|
|
if (CharacterArch == none)
|
||
|
|
{
|
||
|
|
// Make sure arch is set because this function could be called after ScriptedCharArchTemplate is
|
||
|
|
// replicated but before ScriptedCharArchTemplate is repnotified
|
||
|
|
SetCharacterArch(ScriptedCharArchTemplate, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
CurrentState = InState;
|
||
|
|
SetCanBeTargeted(ScriptedCharArch.States[InState].bCanBeTargetedByZeds);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (CurrentState != PreviousState)
|
||
|
|
{
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
|
||
|
|
// set whether this current state allows movement
|
||
|
|
bIsInStoppedState = ScriptedCharArch.States[CurrentState].SpeedScalar <= 0.0f;
|
||
|
|
|
||
|
|
if (PreviousState < CurrentState)
|
||
|
|
{
|
||
|
|
ExitTransitionType = FXTransitionType_PlayGreaterStateTransition;
|
||
|
|
EnterTransitionType = FXTransitionType_PlayLesserStateTransition;
|
||
|
|
}
|
||
|
|
else if (PreviousState > CurrentState)
|
||
|
|
{
|
||
|
|
ExitTransitionType = FXTransitionType_PlayLesserStateTransition;
|
||
|
|
EnterTransitionType = FXTransitionType_PlayGreaterStateTransition;
|
||
|
|
}
|
||
|
|
|
||
|
|
StopExtraVFX(Name("EnterState"$PreviousState));
|
||
|
|
|
||
|
|
PlayExtraVFX(Name("ExitState"$PreviousState$"-"$ExitTransitionType));
|
||
|
|
PlayExtraVFX(Name("EnterState"$CurrentState$"-"$EnterTransitionType));
|
||
|
|
|
||
|
|
PlayExtraVFX(Name("ExitState"$PreviousState));
|
||
|
|
PlayExtraVFX(Name("EnterState"$CurrentState));
|
||
|
|
|
||
|
|
CheckScriptedPawnMaterial();
|
||
|
|
DoSpecialMove(SM_ScriptedPawnStateChange, true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Delegate_OnChangeState != none)
|
||
|
|
{
|
||
|
|
Delegate_OnChangeState(CurrentState, PreviousState);
|
||
|
|
}
|
||
|
|
|
||
|
|
PreviousState = CurrentState;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function CheckScriptedPawnMaterial()
|
||
|
|
{
|
||
|
|
//change the material based on the new state
|
||
|
|
if (bActive && ScriptedCharArch.States[CurrentState].HighlightedStateMaterial != none)
|
||
|
|
{
|
||
|
|
Mesh.SetMaterial(0, ScriptedCharArch.States[CurrentState].HighlightedStateMaterial);
|
||
|
|
}
|
||
|
|
else if (ScriptedCharArch.States[CurrentState].DefaultStateMaterial != none)
|
||
|
|
{
|
||
|
|
Mesh.SetMaterial(0, ScriptedCharArch.States[CurrentState].DefaultStateMaterial);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// if there isn't a material set, use the default material
|
||
|
|
Mesh.SetMaterial(0, DefaultMaterial);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function bool IsBlockedByZed()
|
||
|
|
{
|
||
|
|
return ScriptedCharArch.bUseZedProximityTrigger && bZedInProximity;
|
||
|
|
}
|
||
|
|
|
||
|
|
function UpdatePawnSpeed()
|
||
|
|
{
|
||
|
|
GroundSpeed = ScriptedCharArch.PawnSpeed * ScriptedCharArch.States[CurrentState].SpeedScalar;
|
||
|
|
|
||
|
|
if (IsBlockedByZed())
|
||
|
|
{
|
||
|
|
GroundSpeed *= ScriptedCharArch.SpeedScalarForZedProximity;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ScriptedCharArch.bUsePlayerProximityTrigger && bPlayerInProximity)
|
||
|
|
{
|
||
|
|
GroundSpeed *= ScriptedCharArch.SpeedScalarForPlayerProximity;
|
||
|
|
}
|
||
|
|
|
||
|
|
// used to pause the scripted pawn in front of closed doors and other obstacles
|
||
|
|
GroundSpeed *= SpeedScalarForObstacles;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function bool IsInCriticalCondition()
|
||
|
|
{
|
||
|
|
return CurrentState == ScriptedCharArch.States.Length - 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function name GetStateTransitionAnim()
|
||
|
|
{
|
||
|
|
if (CurrentState != PreviousState)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.States[CurrentState].EnterAnim != `NAME_None)
|
||
|
|
{
|
||
|
|
return ScriptedCharArch.States[CurrentState].EnterAnim;
|
||
|
|
}
|
||
|
|
else if (PreviousState != 255 && ScriptedCharArch.States[PreviousState].ExitAnim != `NAME_None)
|
||
|
|
{
|
||
|
|
return ScriptedCharArch.States[PreviousState].ExitAnim;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return `NAME_None;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function SetCharacterArch(KFCharacterInfoBase Info, optional bool bForce)
|
||
|
|
{
|
||
|
|
local int i, j;
|
||
|
|
local ExtraVFXInfo FX;
|
||
|
|
|
||
|
|
super.SetCharacterArch(Info, bForce);
|
||
|
|
|
||
|
|
// SetCharacterArch sets CharacterArch, which is an instance of Info and can't be replicated,
|
||
|
|
// so replicate the template (Info) instead
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
ScriptedCharArchTemplate = KFCharacterInfo_ScriptedPawn(Info);
|
||
|
|
}
|
||
|
|
|
||
|
|
ScriptedCharArch = KFCharacterInfo_ScriptedPawn(CharacterArch);
|
||
|
|
|
||
|
|
// utilized by the PlayExtraVFX system similar to the archetype's ExtraVFX array
|
||
|
|
// putting these effects in a separate array so that the archetype asset storing ExtraVFX won't be modified
|
||
|
|
// must be setup before updating pawn state
|
||
|
|
|
||
|
|
// normally ExtraVFX has start and stop SFX events, but EnterFX will handle the start and ExitFX
|
||
|
|
// will handle the stop
|
||
|
|
for (i = 0; i < ScriptedCharArch.States.Length; ++i)
|
||
|
|
{
|
||
|
|
for (j = 0; j < ScriptedCharArch.States[i].EnterFX.Length; ++j)
|
||
|
|
{
|
||
|
|
FX.VFX = ScriptedCharArch.States[i].EnterFX[j].VFX;
|
||
|
|
FX.SFXStartEvent = ScriptedCharArch.States[i].EnterFX[j].SFX;
|
||
|
|
FX.SocketName = ScriptedCharArch.States[i].EnterFX[j].SocketName;
|
||
|
|
FX.Label = Name("EnterState"$i);
|
||
|
|
if (ScriptedCharArch.States[i].EnterFX[j].TransitionType != FXTransitionType_PlayAlways)
|
||
|
|
{
|
||
|
|
FX.Label = Name(FX.Label $ "-" $ int(ScriptedCharArch.States[i].EnterFX[j].TransitionType));
|
||
|
|
}
|
||
|
|
ScriptedStateVFX.AddItem(FX);
|
||
|
|
}
|
||
|
|
|
||
|
|
for (j = 0; j < ScriptedCharArch.States[i].ExitFX.Length; ++j)
|
||
|
|
{
|
||
|
|
FX.VFX = ScriptedCharArch.States[i].ExitFX[j].VFX;
|
||
|
|
FX.SFXStartEvent = ScriptedCharArch.States[i].ExitFX[j].SFX;
|
||
|
|
FX.SocketName = ScriptedCharArch.States[i].ExitFX[j].SocketName;
|
||
|
|
FX.Label = Name("ExitState"$i);
|
||
|
|
if (ScriptedCharArch.States[i].ExitFX[j].TransitionType != FXTransitionType_PlayAlways)
|
||
|
|
{
|
||
|
|
FX.Label = Name(FX.Label $ "-" $ int(ScriptedCharArch.States[i].ExitFX[j].TransitionType));
|
||
|
|
}
|
||
|
|
ScriptedStateVFX.AddItem(FX);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function bool Died(Controller Killer, class<DamageType> damageType, vector HitLocation)
|
||
|
|
{
|
||
|
|
local KFAIController KFAIC;
|
||
|
|
|
||
|
|
KFAIC = KFAIController(Controller);
|
||
|
|
if (KFAIC != none && KFAIC.CommandList != none)
|
||
|
|
{
|
||
|
|
KFAIC.AbortCommand(KFAIC.CommandList);
|
||
|
|
}
|
||
|
|
|
||
|
|
return super.Died(Killer, damageType, HitLocation);
|
||
|
|
}
|
||
|
|
|
||
|
|
function HandleMomentum(vector Momentum, Vector HitLocation, class<DamageType> DamageType, optional TraceHitInfo HitInfo)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bPawnHandlesMomentum)
|
||
|
|
{
|
||
|
|
super.HandleMomentum(Momentum, HitLocation, DamageType, HitInfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function bool CanBeGrabbed(KFPawn GrabbingPawn, optional bool bIgnoreFalling, optional bool bAllowSameTeamGrab)
|
||
|
|
{
|
||
|
|
return ScriptedCharArch.bPawnCanBeGrabbed;
|
||
|
|
}
|
||
|
|
|
||
|
|
event Landed(vector HitNormal, Actor FloorActor)
|
||
|
|
{
|
||
|
|
super.Landed(HitNormal, FloorActor);
|
||
|
|
bCollideWorld = false;
|
||
|
|
}
|
||
|
|
|
||
|
|
function StartRoute(SplineActor SplineStart, SplineActor SplineEnd, int SegmentGranularity)
|
||
|
|
{
|
||
|
|
class'AICommand_ScriptedPawn_TraverseSpline'.static.TraverseSpline(MyKFAIC, SplineStart, SplineEnd, SegmentGranularity);
|
||
|
|
}
|
||
|
|
|
||
|
|
function ReachedRouteMarker(int MarkerIdx, SplineActor Marker, int SubIdx, float DistSinceLastMarker)
|
||
|
|
{
|
||
|
|
if (Delegate_OnReachedRouteMarker != none)
|
||
|
|
{
|
||
|
|
Delegate_OnReachedRouteMarker(MarkerIdx, Marker, SubIdx, DistSinceLastMarker);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// ReachedGoal is called when the pawn successfully completes its scripted route
|
||
|
|
function ReachedGoal()
|
||
|
|
{
|
||
|
|
FinishSequence();
|
||
|
|
Finish(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
// EndedRoute is called when the pawn either reaches the last node in the route (and should disappear)
|
||
|
|
// or dies and does not reach its goal
|
||
|
|
function EndedRoute(bool bSuccess)
|
||
|
|
{
|
||
|
|
FinishSequence();
|
||
|
|
|
||
|
|
if (bSuccess)
|
||
|
|
{
|
||
|
|
Finish(true);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Delegate_OnEndedRoute != none)
|
||
|
|
{
|
||
|
|
Delegate_OnEndedRoute(bSuccess);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Allow the sequence action to resolve itself
|
||
|
|
// NOTE: Must be called before "Finish"
|
||
|
|
function FinishSequence()
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
local Sequence GameSeq;
|
||
|
|
local array<SequenceObject> AllPawnStartActions;
|
||
|
|
|
||
|
|
GameSeq = WorldInfo.GetGameSequence();
|
||
|
|
if (GameSeq != None)
|
||
|
|
{
|
||
|
|
// find any matinee actions that exist
|
||
|
|
GameSeq.FindSeqObjectsByClass(class'KFSeqAct_StartScriptedPawn', true, AllPawnStartActions);
|
||
|
|
for (i = 0; i < AllPawnStartActions.Length; i++)
|
||
|
|
{
|
||
|
|
KFSeqAct_StartScriptedPawn(AllPawnStartActions[i]).CheckPawnFinished(self);
|
||
|
|
}
|
||
|
|
|
||
|
|
AllPawnStartActions.length = 0;
|
||
|
|
GameSeq.FindSeqObjectsByClass(class'KFSeqAct_RestartScriptedPawn', true, AllPawnStartActions);
|
||
|
|
for (i = 0; i < AllPawnStartActions.Length; i++)
|
||
|
|
{
|
||
|
|
KFSeqAct_RestartScriptedPawn(AllPawnStartActions[i]).CheckPawnFinished(self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stuff that happens when the pawn starts its route
|
||
|
|
function Start()
|
||
|
|
{
|
||
|
|
SetCollision(true, true);
|
||
|
|
|
||
|
|
if (WeldableComponent != none)
|
||
|
|
{
|
||
|
|
WeldableComponent.SetCollision(bActive, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WeldableTrigger != none)
|
||
|
|
{
|
||
|
|
WeldableTrigger.SetCollision(bActive, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnState();
|
||
|
|
|
||
|
|
if (bStartInactive)
|
||
|
|
{
|
||
|
|
SetActive(false);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function PlayFinishedSounds()
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
|
||
|
|
// generally used to stop the looping sounds
|
||
|
|
for (i = 0; i < ScriptedCharArch.FinishSoundEvents.length; i++)
|
||
|
|
{
|
||
|
|
PlaySoundBase(ScriptedCharArch.FinishSoundEvents[i], false, WorldInfo.NetMode == NM_DedicatedServer);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Stuff that happens when the pawn ends its route
|
||
|
|
function Finish(bool bHide)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bHideOnFinish)
|
||
|
|
{
|
||
|
|
if (bHide)
|
||
|
|
{
|
||
|
|
SetPhysics(PHYS_None);
|
||
|
|
SetHidden(true);
|
||
|
|
|
||
|
|
// only used when hiding the pawn, otherwise want to keep playing its normal sounds
|
||
|
|
PlayFinishedSounds();
|
||
|
|
}
|
||
|
|
|
||
|
|
SetCollision(false, false);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// manually stop the cart at the end since physics are still enabled if the pawn doesn't get hidden
|
||
|
|
if (bHide)
|
||
|
|
{
|
||
|
|
GroundSpeed = 0.0f;
|
||
|
|
Velocity = vect(0, 0, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
DamageOverTimeArray.length = 0; // remove damage over time effects
|
||
|
|
//bPlayedDeath = true; // forces zeds to find a new target // Now accomplished in ZedBaseCommand with CanAITargetThisPawn
|
||
|
|
SetCanBeTargeted(false); // prevents zeds from re-targeting
|
||
|
|
|
||
|
|
if (WeldableComponent != none)
|
||
|
|
{
|
||
|
|
WeldableComponent.SetCollision(false, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WeldableTrigger != none)
|
||
|
|
{
|
||
|
|
WeldableTrigger.SetCollision(false, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetActive(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated event Bump(Actor Other, PrimitiveComponent OtherComp, Vector HitNormal)
|
||
|
|
{
|
||
|
|
local vector ToOther;
|
||
|
|
if (KFPawn(Other) != none)
|
||
|
|
{
|
||
|
|
ToOther = Normal(Other.Location - Location);
|
||
|
|
if ((ToOther Dot HitNormal) < 0)
|
||
|
|
{
|
||
|
|
// This is the case where the scripted pawn bumps into another pawn.
|
||
|
|
// Move the pawn.
|
||
|
|
KFPawn(Other).AddVelocity(HitNormal*(-ScriptedCharArch.PawnBumpImpulse), vect(0,0,0), none);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// This is the case where another pawn bumps into the scripted pawn.
|
||
|
|
// Probably don't need to do anything.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function bool CanAITargetThisPawn(Controller TargetingController)
|
||
|
|
{
|
||
|
|
return bCanCurrentlyBeTargetedByZeds;
|
||
|
|
}
|
||
|
|
|
||
|
|
function SetCanBeTargeted(bool InCanBeTargeted)
|
||
|
|
{
|
||
|
|
local bool bCouldPreviouslyBeTargetedByZeds;
|
||
|
|
local KFPawn_Monster KFPM;
|
||
|
|
|
||
|
|
bCouldPreviouslyBeTargetedByZeds = bCanCurrentlyBeTargetedByZeds;
|
||
|
|
bCanCurrentlyBeTargetedByZeds = ScriptedCharArch != none && ScriptedCharArch.States[CurrentState].bCanBeTargetedByZeds && InCanBeTargeted;
|
||
|
|
if (bCouldPreviouslyBeTargetedByZeds && !bCanCurrentlyBeTargetedByZeds)
|
||
|
|
{
|
||
|
|
foreach WorldInfo.AllPawns(class'KFPawn_Monster', KFPM)
|
||
|
|
{
|
||
|
|
if (KFPM.GetEnemy() == self)
|
||
|
|
{
|
||
|
|
KFAIController(KFPM.Controller).FindNewEnemy();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function Texture2D GetStateIconTexture()
|
||
|
|
{
|
||
|
|
if (CurrentState == 255)
|
||
|
|
{
|
||
|
|
return none;
|
||
|
|
}
|
||
|
|
|
||
|
|
return ScriptedCharArch.States[CurrentState].Icon;
|
||
|
|
}
|
||
|
|
|
||
|
|
function NotifyTriggerTouch(KFTrigger_NotifyOwner Sender, Actor Toucher, PrimitiveComponent OtherComp, vector HitLocation, vector HitNormal)
|
||
|
|
{
|
||
|
|
local KFPawn_Monster Zed;
|
||
|
|
local KFPawn_Human Player;
|
||
|
|
|
||
|
|
if (Sender == ZedProximityTrigger)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bUseZedProximityTrigger)
|
||
|
|
{
|
||
|
|
Zed = KFPawn_Monster(Toucher);
|
||
|
|
if (Zed != none)
|
||
|
|
{
|
||
|
|
bZedInProximity = true;
|
||
|
|
|
||
|
|
// aggro
|
||
|
|
if (bCanCurrentlyBeTargetedByZeds && KFAIController(Zed.Controller) != none)
|
||
|
|
{
|
||
|
|
KFAIController(Zed.Controller).SetEnemy(self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Sender == PlayerProximityTrigger)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bUsePlayerProximityTrigger)
|
||
|
|
{
|
||
|
|
Player = KFPawn_Human(Toucher);
|
||
|
|
if (Player != none)
|
||
|
|
{
|
||
|
|
bPlayerInProximity = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
function NotifyTriggerUnTouch(KFTrigger_NotifyOwner Sender, Actor UnToucher)
|
||
|
|
{
|
||
|
|
local KFPawn_Monster Zed;
|
||
|
|
local KFPawn_Human Player;
|
||
|
|
|
||
|
|
if (Sender == ZedProximityTrigger)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bUseZedProximityTrigger)
|
||
|
|
{
|
||
|
|
Zed = KFPawn_Monster(UnToucher);
|
||
|
|
if (Zed != none)
|
||
|
|
{
|
||
|
|
bZedInProximity = false;
|
||
|
|
foreach ZedProximityTrigger.TouchingActors(class'KFPawn_Monster', Zed)
|
||
|
|
{
|
||
|
|
if (Zed != UnToucher)
|
||
|
|
{
|
||
|
|
bZedInProximity = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (Sender == PlayerProximityTrigger)
|
||
|
|
{
|
||
|
|
if (ScriptedCharArch.bUsePlayerProximityTrigger)
|
||
|
|
{
|
||
|
|
Player = KFPawn_Human(UnToucher);
|
||
|
|
if (Player != none)
|
||
|
|
{
|
||
|
|
bPlayerInProximity = false;
|
||
|
|
foreach PlayerProximityTrigger.TouchingActors(class'KFPawn_Human', Player)
|
||
|
|
{
|
||
|
|
if (Player != UnToucher)
|
||
|
|
{
|
||
|
|
bPlayerInProximity = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function SetActive(bool InActive)
|
||
|
|
{
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
if (bActive == InActive)
|
||
|
|
{
|
||
|
|
// Don't retrigger activation events if we are already active/unactive.
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
bActive = InActive;
|
||
|
|
SetCanBeTargeted(bActive);
|
||
|
|
UpdateWeldIntegrity();
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WeldableComponent != none)
|
||
|
|
{
|
||
|
|
WeldableComponent.SetCollision(bActive, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WeldableTrigger != none)
|
||
|
|
{
|
||
|
|
WeldableTrigger.SetCollision(bActive, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (InActive)
|
||
|
|
{
|
||
|
|
SetEscortPawnOnHud();
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//hide boss healthbar
|
||
|
|
RemoveEscortPawnOnHud();
|
||
|
|
}
|
||
|
|
|
||
|
|
CheckScriptedPawnMaterial();
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function bool ShouldShowOnHUD()
|
||
|
|
{
|
||
|
|
return bActive;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function float GetHealthPercent()
|
||
|
|
{
|
||
|
|
return fclamp(float(Health) / float(HealthMax), 0.0f, 1.0f);
|
||
|
|
}
|
||
|
|
|
||
|
|
static function string GetLocalizedName()
|
||
|
|
{
|
||
|
|
return default.ScriptedPawnString;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function string GetIconPath()
|
||
|
|
{
|
||
|
|
return IconPath;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function StartDoorWait(KFDoorActor Door)
|
||
|
|
{
|
||
|
|
BlockingDoor = Door;
|
||
|
|
SpeedScalarForObstacles = 0.0f;
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
SetTimer(0.5f, true, nameof(Timer_DoorWait), self);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function PlayExtraVFX(Name FXLabel)
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
local ExtraVFXAttachmentInfo VFXAttachment;
|
||
|
|
local bool bActivatedExistingSystem;
|
||
|
|
|
||
|
|
if (WorldInfo.NetMode != NM_DedicatedServer && FXLabel != `NAME_NONE)
|
||
|
|
{
|
||
|
|
// if this has already been spawned before, play the existing system in the parent instead
|
||
|
|
for (i = 0; i < ExtraVFXAttachments.Length; ++i)
|
||
|
|
{
|
||
|
|
if (ExtraVFXAttachments[i].Info.Label == FXLabel)
|
||
|
|
{
|
||
|
|
bActivatedExistingSystem = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!bActivatedExistingSystem)
|
||
|
|
{
|
||
|
|
for (i = 0; i < ScriptedStateVFX.Length; ++i)
|
||
|
|
{
|
||
|
|
if (ScriptedStateVFX[i].Label == FXLabel)
|
||
|
|
{
|
||
|
|
VFXAttachment.VFXComponent = SpawnExtraVFX(ScriptedStateVFX[i]);
|
||
|
|
VFXAttachment.Info = ScriptedStateVFX[i];
|
||
|
|
ExtraVFXAttachments.AddItem(VFXAttachment);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
super.PlayExtraVFX(FXLabel);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function Timer_DoorWait()
|
||
|
|
{
|
||
|
|
if (BlockingDoor == none || BlockingDoor.bIsDoorOpen || BlockingDoor.bIsDestroyed)
|
||
|
|
{
|
||
|
|
BlockingDoor = none;
|
||
|
|
SpeedScalarForObstacles = 1.0f;
|
||
|
|
UpdatePawnSpeed();
|
||
|
|
ClearTimer(nameof(Timer_DoorWait), self);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
defaultproperties
|
||
|
|
{
|
||
|
|
ControllerClass=class'KFGame.KFAIController_ScriptedPawn'
|
||
|
|
|
||
|
|
CurrentState=255
|
||
|
|
PreviousState=255
|
||
|
|
|
||
|
|
AccelRate=0
|
||
|
|
|
||
|
|
bAlwaysRelevant=true
|
||
|
|
|
||
|
|
// Bone names (don't need 'em, having them causes warnings)
|
||
|
|
LeftFootBoneName=""
|
||
|
|
RightFootBoneName=""
|
||
|
|
LeftHandBoneName=""
|
||
|
|
RightHandBoneName=""
|
||
|
|
HeadBoneName=""
|
||
|
|
TorsoBoneName=""
|
||
|
|
PelvisBoneName=""
|
||
|
|
|
||
|
|
// ---------------------------------------------
|
||
|
|
// Special moves
|
||
|
|
Begin Object Name=SpecialMoveHandler_0
|
||
|
|
SpecialMoveClasses(SM_ScriptedPawnStateChange)=class'KFGame.KFSM_PlaySingleAnim_ScriptedPawn'
|
||
|
|
End Object
|
||
|
|
|
||
|
|
IconPath="ZED_Patriarch_UI.ZED-VS_Icon_Boss"
|
||
|
|
|
||
|
|
SpeedScalarForObstacles=1.0f;
|
||
|
|
RecentDamageTimerLength=5.0f;
|
||
|
|
|
||
|
|
Begin Object Name=CollisionCylinder
|
||
|
|
CollisionRadius=+0108.000000
|
||
|
|
CollisionHeight=+0086.000000
|
||
|
|
BlockZeroExtent=false // blocked by mesh
|
||
|
|
End Object
|
||
|
|
|
||
|
|
bBlockPlayers=false
|
||
|
|
bBlockZedPlayers=true
|
||
|
|
bBlockMonsters=true
|
||
|
|
|
||
|
|
bCanBeAdheredTo=false
|
||
|
|
bCanBeFrictionedTo=false
|
||
|
|
|
||
|
|
bBlockInStoppedState=false
|
||
|
|
bIsInStoppedState=false
|
||
|
|
}
|