505 lines
13 KiB
Ucode
505 lines
13 KiB
Ucode
|
//=============================================================================
|
||
|
|
// KFProjectileStickHelper
|
||
|
|
//=============================================================================
|
||
|
|
// Manages projectile sticking and pinning functionality
|
||
|
|
//=============================================================================
|
||
|
|
// Killing Floor 2
|
||
|
|
// Copyright (C) 2019 Tripwire Interactive LLC
|
||
|
|
//=============================================================================
|
||
|
|
|
||
|
|
class KFProjectileStickHelper extends Object within KFProjectile;
|
||
|
|
|
||
|
|
var transient Pawn PinPawn;
|
||
|
|
var transient name PinBoneName;
|
||
|
|
var transient RB_ConstraintActorSpawnable PinConstraint;
|
||
|
|
|
||
|
|
var transient vector PinLocation;
|
||
|
|
var transient Actor PinHitActor;
|
||
|
|
|
||
|
|
var AkEvent StickAkEvent;
|
||
|
|
|
||
|
|
/** Tries to stick projectile to hit actor. alternatively, tries to bounce it off of hit actor. */
|
||
|
|
simulated function TryStick(vector HitNormal, optional vector HitLocation, optional Actor HitActor)
|
||
|
|
{
|
||
|
|
local TraceHitInfo HitInfo;
|
||
|
|
|
||
|
|
if (Instigator == None || !Instigator.IsLocallyControlled() || (Physics == PHYS_None && StuckToActor != none))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (HitActor != none && (HitActor == StuckToActor || HitActor == PinPawn))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
GetImpactInfo(Velocity, HitLocation, HitNormal, HitInfo);
|
||
|
|
|
||
|
|
if (HitInfo.HitComponent != none && GetImpactResult(HitActor, HitInfo.HitComponent))
|
||
|
|
{
|
||
|
|
Stick(HitActor, HitLocation, HitNormal, HitInfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Get all relevant impact info (called after collision occurs to fill in details that we don't get in HitWall or ProcessTouch) */
|
||
|
|
simulated function GetImpactInfo(vector in_Velocity, out vector out_HitLocation, out vector out_HitNormal, out TraceHitInfo out_HitInfo)
|
||
|
|
{
|
||
|
|
local vector VelNorm;
|
||
|
|
local vector VelScaled;
|
||
|
|
|
||
|
|
VelNorm = Normal(in_Velocity);
|
||
|
|
VelScaled = VelNorm * 30;
|
||
|
|
Trace(out_HitLocation, out_HitNormal, out_HitLocation + VelScaled, out_HitLocation - VelScaled,,,
|
||
|
|
out_HitInfo, TRACEFLAG_Bullet /*for complex collision*/ );
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Returns appropriate interaction with HitActor (stick or ignore, for now. add bounce later?) */
|
||
|
|
simulated function bool GetImpactResult(Actor HitActor, PrimitiveComponent HitComp)
|
||
|
|
{
|
||
|
|
local KFPawn_Human KFP;
|
||
|
|
local KFDestructibleActor D;
|
||
|
|
local StaticMeshComponent StaticMeshComp;
|
||
|
|
|
||
|
|
if (HitActor == none)
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (HitActor.RemoteRole == ROLE_None && !HitActor.bWorldGeometry)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if we've already been dislodged from an actor, don't keep trying to stick to it while falling
|
||
|
|
if (HitActor.bTearOff || HitActor.bDeleteMe || HitActor.bPendingDelete || HitActor == PrevStuckToActor)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
StaticMeshComp = StaticMeshComponent(HitComp);
|
||
|
|
if (StaticMeshComp != none)
|
||
|
|
{
|
||
|
|
// NOTE: Door actors fall into this category!
|
||
|
|
|
||
|
|
// pass through meshes that can move
|
||
|
|
return !StaticMeshComp.CanBecomeDynamic();
|
||
|
|
}
|
||
|
|
|
||
|
|
KFP = KFPawn_Human(HitActor);
|
||
|
|
if (KFP != none)
|
||
|
|
{
|
||
|
|
// bounce off of player pawns, stick to other pawns
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
D = KFDestructibleActor(HitActor);
|
||
|
|
if (D != none)
|
||
|
|
{
|
||
|
|
// don't react to client-side-only destructibles, stick to others
|
||
|
|
return D.ReplicationMode != RT_ClientSide;
|
||
|
|
}
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Stops movement of projectile and calculates orientation to surface */
|
||
|
|
simulated function Stick(Actor HitActor, vector HitLocation, vector HitNormal, const out TraceHitInfo HitInfo)
|
||
|
|
{
|
||
|
|
local int BoneIdx;
|
||
|
|
|
||
|
|
local KFPawn_Monster HitMonster;
|
||
|
|
local array<ImpactInfo> HitZoneImpactList;
|
||
|
|
local vector StartTrace, EndTrace, Direction, ClosestBoneLocation;
|
||
|
|
local name BoneName;
|
||
|
|
|
||
|
|
BoneName = HitInfo.BoneName;
|
||
|
|
|
||
|
|
HitMonster = KFPawn_Monster(HitActor);
|
||
|
|
if (HitMonster != none)
|
||
|
|
{
|
||
|
|
// get injury hit zone
|
||
|
|
StartTrace = HitLocation;
|
||
|
|
Direction = Normal(Velocity);
|
||
|
|
EndTrace = StartTrace + Direction * (HitMonster.CylinderComponent.CollisionRadius * 6.0);
|
||
|
|
TraceProjHitZones(HitMonster, EndTrace, StartTrace, HitZoneImpactList);
|
||
|
|
|
||
|
|
if (BoneName == '')
|
||
|
|
{
|
||
|
|
// get the best bone to attach to
|
||
|
|
ClosestBoneLocation = HitMonster.Mesh.GetClosestCollidingBoneLocation(HitLocation, true, false);
|
||
|
|
BoneName = HitMonster.Mesh.FindClosestBone(ClosestBoneLocation, ClosestBoneLocation);
|
||
|
|
}
|
||
|
|
|
||
|
|
// do impact damage
|
||
|
|
if (KFWeapon(Owner) != none)
|
||
|
|
{
|
||
|
|
HitZoneImpactList[0].RayDir = Normal(EndTrace - StartTrace); // add a raydir here since TraceProjHitZones doesn't fill this out (so certain afflictions apply)
|
||
|
|
KFWeapon(Owner).HandleProjectileImpact(WeaponFireMode, HitZoneImpactList[0], PenetrationPower);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!IsZero(HitLocation))
|
||
|
|
{
|
||
|
|
SetLocation(HitLocation);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetStickOrientation(HitNormal);
|
||
|
|
|
||
|
|
BoneIdx = INDEX_NONE;
|
||
|
|
|
||
|
|
if (BoneName != '')
|
||
|
|
{
|
||
|
|
BoneIdx = GetBoneIndexFromActor(HitActor, BoneName);
|
||
|
|
}
|
||
|
|
|
||
|
|
StickToActor(HitActor, HitInfo.HitComponent, BoneIdx, true);
|
||
|
|
|
||
|
|
if (Role < ROLE_Authority)
|
||
|
|
{
|
||
|
|
Outer.ServerStick(HitActor, BoneIdx, StuckToLocation, StuckToRotation);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WorldInfo.NetMode != NM_DedicatedServer && StickAkEvent != none)
|
||
|
|
{
|
||
|
|
PlaySoundBase(StickAkEvent);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Changes the base of the charge to the stick actor and sets its relative loc/rot */
|
||
|
|
simulated function StickToActor(Actor StickTo, PrimitiveComponent HitComp, int BoneIdx, optional bool bCalculateRelativeLocRot)
|
||
|
|
{
|
||
|
|
local SkeletalMeshComponent SkelMeshComp;
|
||
|
|
local Name BoneName;
|
||
|
|
|
||
|
|
local vector RelStuckToLocation;
|
||
|
|
local rotator RelStuckToRotation;
|
||
|
|
|
||
|
|
local KFPawn StickToPawn;
|
||
|
|
|
||
|
|
StickToPawn = KFPawn(StickTo);
|
||
|
|
|
||
|
|
if (bCanPin && (StickToPawn == none || StickToPawn.bCanBePinned))
|
||
|
|
{
|
||
|
|
// if StickTo pawn is dead, pin it and keep flying
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
if (StickToPawn != none && !StickToPawn.IsAliveAndWell())
|
||
|
|
{
|
||
|
|
if (PinPawn == none)
|
||
|
|
{
|
||
|
|
Pin(StickTo, BoneIdx);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WorldInfo.NetMode != NM_DedicatedServer && PinPawn != none)
|
||
|
|
{
|
||
|
|
if (StickToPawn == none)
|
||
|
|
{
|
||
|
|
// Pin pinned pawn to StickTo actor
|
||
|
|
//PinPawn.Mesh.RetardRBLinearVelocity(vector(Rotation), 0.75);
|
||
|
|
PinPawn.Mesh.SetRBPosition(Location, PinBoneName);
|
||
|
|
|
||
|
|
PinConstraint = Spawn(class'RB_ConstraintActorSpawnable',,,Location);
|
||
|
|
PinConstraint.InitConstraint(PinPawn, none, PinBoneName, '');
|
||
|
|
}
|
||
|
|
|
||
|
|
PinPawn = none;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (StickToPawn != none && !StickToPawn.IsAliveAndWell())
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
SetPhysics(PHYS_None);
|
||
|
|
|
||
|
|
PrevStuckToActor = StuckToActor;
|
||
|
|
StuckToActor = StickTo;
|
||
|
|
StuckToBoneIdx = BoneIdx;
|
||
|
|
|
||
|
|
// if we found a skel mesh, set our base to it and set relative loc/rot
|
||
|
|
if (BoneIdx != INDEX_NONE)
|
||
|
|
{
|
||
|
|
SkelMeshComp = SkeletalMeshComponent(HitComp);
|
||
|
|
|
||
|
|
BoneName = SkelMeshComp.GetBoneName(BoneIdx);
|
||
|
|
|
||
|
|
if (bCalculateRelativeLocRot)
|
||
|
|
{
|
||
|
|
StuckToLocation = Location;
|
||
|
|
StuckToRotation = Rotation;
|
||
|
|
}
|
||
|
|
|
||
|
|
SkelMeshComp.TransformToBoneSpace(BoneName, StuckToLocation, StuckToRotation, RelStuckToLocation, RelStuckToRotation);
|
||
|
|
|
||
|
|
SetBase(StickTo,, SkelMeshComp, BoneName);
|
||
|
|
SetRelativeLocation(RelStuckToLocation);
|
||
|
|
SetRelativeRotation(RelStuckToRotation);
|
||
|
|
|
||
|
|
}
|
||
|
|
// otherwise, just set our base
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (bCalculateRelativeLocRot)
|
||
|
|
{
|
||
|
|
// set replicated loc/rot
|
||
|
|
StuckToLocation = Location;
|
||
|
|
StuckToRotation = Rotation;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// set loc/rot to replicated loc/rot
|
||
|
|
SetLocation(StuckToLocation);
|
||
|
|
SetRotation(StuckToRotation);
|
||
|
|
}
|
||
|
|
|
||
|
|
SetBase(StickTo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function Pin(Actor PinTo, int BoneIdx)
|
||
|
|
{
|
||
|
|
if (Role == ROLE_Authority)
|
||
|
|
{
|
||
|
|
bUpdateSimulatedPosition = false;
|
||
|
|
PinActor = PinTo;
|
||
|
|
PinBoneIdx = BoneIdx;
|
||
|
|
}
|
||
|
|
|
||
|
|
PinPawn = Pawn(PinTo);
|
||
|
|
PinBoneName = PinPawn.Mesh.GetBoneName(BoneIdx);
|
||
|
|
|
||
|
|
StuckToActor = none;
|
||
|
|
StuckToBoneIdx = INDEX_None;
|
||
|
|
|
||
|
|
SetBase(none);
|
||
|
|
SetPhysics(PHYS_Falling);
|
||
|
|
|
||
|
|
if (WorldInfo.NetMode != NM_Standalone)
|
||
|
|
{
|
||
|
|
SetLocation(StuckToLocation);
|
||
|
|
SetRotation(StuckToRotation);
|
||
|
|
}
|
||
|
|
|
||
|
|
Velocity = Speed * vector(Rotation);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Attempts to retrieve skeletal mesh from actor */
|
||
|
|
simulated function SkeletalMeshComponent GetActorSkeletalMesh(Actor StickActor)
|
||
|
|
{
|
||
|
|
local Pawn P;
|
||
|
|
local SkeletalMeshActor SM;
|
||
|
|
|
||
|
|
P = Pawn(StickActor);
|
||
|
|
if (P != none)
|
||
|
|
{
|
||
|
|
return P.Mesh;
|
||
|
|
}
|
||
|
|
|
||
|
|
SM = SkeletalMeshActor(StickActor);
|
||
|
|
if (SM != none)
|
||
|
|
{
|
||
|
|
return SM.SkeletalMeshComponent;
|
||
|
|
}
|
||
|
|
|
||
|
|
return none;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Replicates stick to server from client */
|
||
|
|
function ServerStick(Actor StickTo, int BoneIdx, vector StickLoc, rotator StickRot)
|
||
|
|
{
|
||
|
|
bUpdateSimulatedPosition = true;
|
||
|
|
|
||
|
|
StuckToLocation = StickLoc;
|
||
|
|
StuckToRotation = StickRot;
|
||
|
|
bForceNetUpdate = true;
|
||
|
|
|
||
|
|
if (PinPawn != none)
|
||
|
|
{
|
||
|
|
PinPawn = none;
|
||
|
|
}
|
||
|
|
|
||
|
|
ReplicatedStick(StickTo, BoneIdx);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Calls "Stick" with replicated info */
|
||
|
|
simulated function ReplicatedStick(Actor StickTo, int BoneIdx)
|
||
|
|
{
|
||
|
|
StickToActor(StickTo, GetActorSkeletalMesh(StickTo), BoneIdx);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Gets index for passed-in bone name for different kinds of actors that have differently-named skeletalmeshcomponents */
|
||
|
|
simulated function int GetBoneIndexFromActor(Actor HitActor, Name BoneName)
|
||
|
|
{
|
||
|
|
local Pawn P;
|
||
|
|
local SkeletalMeshActor SM;
|
||
|
|
|
||
|
|
P = Pawn(HitActor);
|
||
|
|
if (P != none)
|
||
|
|
{
|
||
|
|
return P.Mesh.MatchRefBone(BoneName);
|
||
|
|
}
|
||
|
|
|
||
|
|
SM = SkeletalMeshActor(HitActor);
|
||
|
|
if (SM != none)
|
||
|
|
{
|
||
|
|
return SM.SkeletalMeshComponent.MatchRefBone(BoneName);
|
||
|
|
}
|
||
|
|
|
||
|
|
return INDEX_NONE;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Resets physics/collision vars to defaults */
|
||
|
|
simulated function UnStick()
|
||
|
|
{
|
||
|
|
PrevStuckToActor = StuckToActor;
|
||
|
|
|
||
|
|
StuckToActor = none;
|
||
|
|
StuckToBoneIdx = INDEX_NONE;
|
||
|
|
|
||
|
|
StuckToLocation = vect(0,0,0);
|
||
|
|
StuckToRotation = rot(0,0,0);
|
||
|
|
|
||
|
|
SetBase(none);
|
||
|
|
SetPhysics(default.Physics);
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function UnPin()
|
||
|
|
{
|
||
|
|
if (PinConstraint != none)
|
||
|
|
{
|
||
|
|
PinConstraint.TermConstraint();
|
||
|
|
}
|
||
|
|
|
||
|
|
PinConstraint = none;
|
||
|
|
PinPawn = none;
|
||
|
|
}
|
||
|
|
|
||
|
|
simulated function Tick(float DeltaTime)
|
||
|
|
{
|
||
|
|
local int i;
|
||
|
|
local Pawn P;
|
||
|
|
local KFFracturedMeshActor FracMesh;
|
||
|
|
local KFDoorActor Door;
|
||
|
|
local KFDestructibleActor Destructible;
|
||
|
|
local Actor StuckTo;
|
||
|
|
|
||
|
|
local vector HitLocation, HitNormal;
|
||
|
|
local TraceHitInfo HitInfo;
|
||
|
|
local Actor HitActor;
|
||
|
|
local float PinRad;
|
||
|
|
local vector VFront;
|
||
|
|
local float StickPct;
|
||
|
|
|
||
|
|
// @todo jdr: REMOVE THESE WHEN WE HAVE A BETTER SYSTEM
|
||
|
|
local float PinRadMagicNumber, StickPctMagicNumber;
|
||
|
|
|
||
|
|
if (PinPawn != none)
|
||
|
|
{
|
||
|
|
// @todo jdr: REMOVE MAGIC NUMBERS FROM COMMON CODE
|
||
|
|
// Ideally, this code retrieves values from the projectile, or we could add tuneables to
|
||
|
|
// the helper than can be set in each instance of the helper
|
||
|
|
|
||
|
|
VFront = Normal(Velocity);
|
||
|
|
StickPct = 1.0;
|
||
|
|
|
||
|
|
PinRadMagicNumber = 3.0;
|
||
|
|
StickPctMagicNumber = 0.3;
|
||
|
|
|
||
|
|
if (IsZero(PinLocation))
|
||
|
|
{
|
||
|
|
PinRad = PinPawn.CylinderComponent.CollisionRadius * PinRadMagicNumber;
|
||
|
|
HitActor = Trace(HitLocation, HitNormal, Location, Location + VFront * PinRad,,, HitInfo, TRACEFLAG_Bullet);
|
||
|
|
if (HitActor != none && HitActor != PinActor && Pawn(HitActor) == none && GetImpactResult(HitActor, HitInfo.HitComponent))
|
||
|
|
{
|
||
|
|
GravityScale = 0.0;
|
||
|
|
PinLocation = HitLocation;
|
||
|
|
PinHitActor = HitActor;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!IsZero(PinLocation))
|
||
|
|
{
|
||
|
|
PinRad = PinPawn.CylinderComponent.CollisionRadius * PinRadMagicNumber;
|
||
|
|
StickPct = VSize(PinLocation - Location) / PinRad;
|
||
|
|
Velocity = VFront * MaxSpeed * StickPct * StickPct;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (WorldInfo.NetMode != NM_DedicatedServer)
|
||
|
|
{
|
||
|
|
PinPawn.Mesh.SetRBLinearVelocity(Velocity);
|
||
|
|
PinPawn.Mesh.SetRBPosition(Location, PinBoneName);
|
||
|
|
|
||
|
|
if (Instigator != none && Instigator.IsLocallyControlled() && StickPct < StickPctMagicNumber)
|
||
|
|
{
|
||
|
|
Stick(PinHitActor, Location, HitNormal, HitInfo);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
StuckTo = StuckToActor;
|
||
|
|
if (StuckTo != none)
|
||
|
|
{
|
||
|
|
// always restart movement if torn off
|
||
|
|
if (StuckTo.bTearOff && PinPawn == none)
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the bone we're stuck to is hidden (just head, probably), detatch
|
||
|
|
P = Pawn(StuckTo);
|
||
|
|
if (P != none)
|
||
|
|
{
|
||
|
|
if (P.Mesh.IsBoneHidden(StuckToBoneIdx))
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the non-pawn actor we're stuck to is going away (could be due to non-relevancy, in which case they will not be torn off), detatch
|
||
|
|
if (StuckTo.bDeleteMe || StuckTo.bPendingDelete)
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the glass we're stuck to is fractured, detatch
|
||
|
|
FracMesh = KFFracturedMeshActor(StuckTo);
|
||
|
|
if (FracMesh != none && FracMesh.bHasLostChunk)
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// if the door we're stuck to is moving, detatch
|
||
|
|
// (we can't set our base to doors because they're world geometry, so we won't follow when they move)
|
||
|
|
Door = KFDoorActor(StuckTo);
|
||
|
|
if (Door != none && (!Door.bDoorMoveCompleted || Door.bIsDestroyed))
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (LastTouchComponent != none)
|
||
|
|
{
|
||
|
|
// if the replicated destructible we're stuck to is destroyed, detatch
|
||
|
|
Destructible = KFDestructibleActor(StuckTo);
|
||
|
|
if (Destructible != none)
|
||
|
|
{
|
||
|
|
for (i = 0; i < Destructible.SubObjects.Length; ++i)
|
||
|
|
{
|
||
|
|
if (Destructible.SubObjects[i].Mesh == LastTouchComponent && Destructible.SubObjects[i].Health <= 0)
|
||
|
|
{
|
||
|
|
UnStick();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|