1391 lines
41 KiB
Ucode
1391 lines
41 KiB
Ucode
//=============================================================================
|
|
// KFWeap_MeleeBase
|
|
//=============================================================================
|
|
// Base class used for weapons where melee is the primary firemode
|
|
//=============================================================================
|
|
// Killing Floor 2
|
|
// Copyright (C) 2015 Tripwire Interactive LLC
|
|
// - Andrew "Strago" Ladenberger
|
|
//=============================================================================
|
|
class KFWeap_MeleeBase extends KFWeapon
|
|
abstract
|
|
native;
|
|
|
|
/************************************************************************************
|
|
* @name Firing / Timing / States
|
|
***********************************************************************************/
|
|
|
|
/** These override the base firemodes of the same ID (for readability) */
|
|
const BLOCK_FIREMODE = 1; // ALTFIRE_FIREMODE
|
|
const HEAVY_ATK_FIREMODE = 5; // NEW - IronSights Key
|
|
|
|
/** Set when blood material value is high */
|
|
var bool bIsBloody;
|
|
|
|
/** Maximum number of attacks that can be played without releasing fire */
|
|
var byte MaxChainAtkCount;
|
|
|
|
/** Minimum amount of time to go to the MeleeSustained state for */
|
|
var float MinMeleeSustainedTime;
|
|
/** Minimum amount of time to wait before dealing damage in the MeleeSustained state */
|
|
var() float MeleeSustainedWarmupTime;
|
|
/** Amount of time required between cancelling attacks with reload*/
|
|
var private const float ReloadCancelTimeLimit;
|
|
|
|
/** Whether this can be interrupted by another attack/reload/etc. */
|
|
var bool StartFireDisabled;
|
|
|
|
/** Special flag in order to make weapons like the frost shotgun axe (frostfang) have the access to perk skills */
|
|
var bool bHasToBeConsideredAsRangedWeaponForPerks;
|
|
|
|
/*********************************************************************************************
|
|
* @name Defensive Abilities
|
|
*********************************************************************************************/
|
|
|
|
struct native BlockEffectInfo
|
|
{
|
|
var class<DamageType> DmgType;
|
|
|
|
/** If != None, overrides the class default FX */
|
|
var AkEvent BlockSound;
|
|
var AkEvent ParrySound;
|
|
var ParticleSystem BlockParticleSys;
|
|
var ParticleSystem ParryParticleSys;
|
|
};
|
|
|
|
var array<BlockEffectInfo> BlockTypes;
|
|
|
|
/** Damage while blocking will be mitigated by this percentage */
|
|
var() float BlockDamageMitigation;
|
|
|
|
/** Parry damage will be mitigated by this percentage */
|
|
var() float ParryDamageMitigationPercent;
|
|
/** Hit reaction strength to bypass pawn's ParryStumbleResist */
|
|
var() byte ParryStrength;
|
|
|
|
/** If true, owning pawn moves at a slower (iron sight) walking speed */
|
|
var bool bMoveAtWalkingSpeed;
|
|
|
|
/** Time between block hit reaction anims */
|
|
var() protected float BlockHitAnimCooldownTime;
|
|
|
|
/** The last time we played a block hit reaction anim */
|
|
var transient protected float LastBlockHitAnimTime;
|
|
|
|
/*********************************************************************************************
|
|
* @name Animation
|
|
*********************************************************************************************/
|
|
|
|
/** 4-way directional melee attack animation names */
|
|
const MeleeAttackAnim_F = 'Atk_F';
|
|
const MeleeAttackAnim_B = 'Atk_B';
|
|
const MeleeAttackAnim_L = 'Atk_L';
|
|
const MeleeAttackAnim_R = 'Atk_R';
|
|
|
|
/** 4-way directional heavy attack animation names */
|
|
const MeleeHeavyAttackAnim_F = 'Atk_H_F';
|
|
const MeleeHeavyAttackAnim_B = 'Atk_H_B';
|
|
const MeleeHeavyAttackAnim_L = 'Atk_H_L';
|
|
const MeleeHeavyAttackAnim_R = 'Atk_H_R';
|
|
|
|
/** 8-way directional combo chain animation names */
|
|
const MeleeComboChainAnim_F = 'Combo_F';
|
|
const MeleeComboChainAnim_FL = 'Combo_FL';
|
|
const MeleeComboChainAnim_FR = 'Combo_FR';
|
|
const MeleeComboChainAnim_B = 'Combo_B';
|
|
const MeleeComboChainAnim_BL = 'Combo_BL';
|
|
const MeleeComboChainAnim_BR = 'Combo_BR';
|
|
const MeleeComboChainAnim_L = 'Combo_L';
|
|
const MeleeComboChainAnim_R = 'Combo_R';
|
|
|
|
/** Special ability attacks */
|
|
const MeleeDrawStrikeAnim = 'Atk_Draw';
|
|
|
|
/** Defensive stance animation names */
|
|
const MeleeBlockStartAnim = 'Brace_in';
|
|
const MeleeBlockLoopAnim = 'Brace_loop';
|
|
const MeleeBlockEndAnim = 'Brace_out';
|
|
|
|
/** Weapon wear/cleaning */
|
|
const CleanBloodyAnim = 'Clean_Blood';
|
|
const CleanNonBloodyAnim = 'Clean_NoBlood';
|
|
|
|
/** MeleeSustained default anims - To modify this in a subclass override GetLoopingFireAnim, etc... */
|
|
const MeleeSustainedLoopAnim = 'Atk_F_Loop';
|
|
const MeleeSustainedStartAnim = 'Atk_F_In';
|
|
const MeleeSUstainedEndAnim = 'Atk_F_Out';
|
|
|
|
/** Settle animations played after an attack */
|
|
var array<name> MeleeAttackSettleAnims;
|
|
|
|
/** Animations played on successful block */
|
|
var array<name> MeleeBlockHitAnims;
|
|
|
|
/*********************************************************************************************
|
|
* @name Effects
|
|
********************************************************************************************* */
|
|
|
|
/** (deprecated) particle system templates for trail notifies */
|
|
var ParticleSystem DistortTrailParticle;
|
|
var ParticleSystem WhiteTrailParticle;
|
|
var ParticleSystem BlueTrailParticle;
|
|
var ParticleSystem RedTrailParticle;
|
|
|
|
/** Block / Parry */
|
|
var AkBaseSoundObject BlockSound;
|
|
var AKBaseSoundObject ParrySound;
|
|
var ParticleSystem BlockParticleSystem;
|
|
var ParticleSystem ParryParticleSystem;
|
|
var name BlockEffectsSocketName;
|
|
|
|
/*********************************************************************************************
|
|
* @name Trader
|
|
********************************************************************************************* */
|
|
|
|
/** Estimated attack rate for this weapon, taking chaining, etc. into account.
|
|
* Basically, just eyeball the animations and take an average.
|
|
*/
|
|
var() byte EstimatedFireRate;
|
|
|
|
cpptext
|
|
{
|
|
// custom trail overrides
|
|
virtual class UParticleSystem* GetAnimTrailParticleSystem(const class UAnimNotify_Trails* AnimNotifyData) const;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* @name Instigator Movement Speed
|
|
********************************************************************************************* */
|
|
|
|
/** If TRUE, Instigator/Owner moves at walking speed when this weapon is equipped */
|
|
simulated function bool ShouldOwnerWalk()
|
|
{
|
|
return bMoveAtWalkingSpeed;
|
|
}
|
|
|
|
/** Used to toggle bMoveAtWalkingSpeed */
|
|
simulated function SetSlowMovement(bool bEnabled)
|
|
{
|
|
if ( Instigator.IsLocallyControlled() )
|
|
{
|
|
bMoveAtWalkingSpeed = bEnabled;
|
|
|
|
if ( Role < ROLE_Authority )
|
|
{
|
|
ServerSetSlowMovement(bEnabled);
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Called by local player to synchronize movement the same way ServerZoomIn/ServerZoomOut does */
|
|
reliable server function ServerSetSlowMovement(bool bEnabled)
|
|
{
|
|
bMoveAtWalkingSpeed = bEnabled;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* @name Firing / Projectile
|
|
********************************************************************************************* */
|
|
|
|
/**
|
|
* @see Weapon::StartFire
|
|
*/
|
|
simulated function StartFire(byte FireModeNum)
|
|
{
|
|
// can't start fire because it's in an uninterruptible state
|
|
if (StartFireDisabled)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// if the weapon is currently attacking
|
|
if (CurrentFireMode == DEFAULT_FIREMODE || CurrentFireMode == ALTFIRE_FIREMODE || CurrentFireMode == BASH_FIREMODE)
|
|
{
|
|
// and the player tries to cancel with a reload action
|
|
if(FireModeNum == RELOAD_FIREMODE)
|
|
{
|
|
// stop them from reload cancelling if it has already happened too recently
|
|
if (IsTimerActive(nameof(Timer_FireCancel)))
|
|
{
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
SetTimer(ReloadCancelTimeLimit, false, nameof(Timer_FireCancel));
|
|
}
|
|
}
|
|
}
|
|
// Get attack type and send to server
|
|
if( FireModeNum == DEFAULT_FIREMODE || FireModeNum == HEAVY_ATK_FIREMODE )
|
|
{
|
|
StartMeleeFire(FireModeNum, MeleeAttackHelper.ChooseAttackDir(), ATK_Normal);
|
|
return;
|
|
}
|
|
|
|
// If we're going to pretend bash is primary (see SendToFiringState) need to init directional melee
|
|
if( FireModeNum == BASH_FIREMODE && WeaponFireTypes[FireModeNum] == EWFT_None )
|
|
{
|
|
StartMeleeFire(FireModeNum, MeleeAttackHelper.ChooseAttackDir(), ATK_Normal);
|
|
return;
|
|
}
|
|
|
|
Super.StartFire(FireModeNum);
|
|
}
|
|
|
|
simulated function Timer_FireCancel() {}
|
|
|
|
/**
|
|
* Like StartFire, but replicates a attack type
|
|
* Network: LocalPlayer
|
|
*/
|
|
simulated function StartMeleeFire(byte FireModeNum, EPawnOctant AttackDir, EMeleeAttackType AtkType)
|
|
{
|
|
MeleeAttackHelper.InitAttackSequence(AttackDir, AtkType);
|
|
|
|
// derived from StartFire()
|
|
if( Instigator == None || !Instigator.bNoWeaponFiring )
|
|
{
|
|
if( Role < Role_Authority )
|
|
{
|
|
// if we're a client, synchronize server
|
|
ServerStartMeleeFire(FireModeNum, AttackDir, AtkType);
|
|
}
|
|
|
|
// Start fire locally
|
|
BeginFire(FireModeNum);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the desired attack type for an incoming melee fire mode
|
|
* Network: Dedicated Server only, or Listen Server for remote clients.
|
|
*/
|
|
reliable server private function ServerStartMeleeFire(byte FireModeNum, EPawnOctant AttackDir, EMeleeAttackType AtkType)
|
|
{
|
|
MeleeAttackHelper.InitAttackSequence(AttackDir, AtkType);
|
|
Super.ServerStartFire(FireModeNum);
|
|
}
|
|
|
|
/** Instead of switch fire mode use as immediate alt fire */
|
|
simulated function AltFireMode()
|
|
{
|
|
if ( !Instigator.IsLocallyControlled() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// StartFire - StopFire called from KFPlayerInput
|
|
StartFire(BLOCK_FIREMODE);
|
|
}
|
|
|
|
/** Route ironsight player input to heavy attack */
|
|
simulated function SetIronSights(bool bNewIronSights)
|
|
{
|
|
if ( !Instigator.IsLocallyControlled() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( bNewIronSights )
|
|
{
|
|
StartFire(HEAVY_ATK_FIREMODE);
|
|
}
|
|
else
|
|
{
|
|
StopFire(HEAVY_ATK_FIREMODE);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Send weapon to proper firing state
|
|
*/
|
|
simulated function SendToFiringState(byte FireModeNum)
|
|
{
|
|
// If we don't have anything assigned to BASH_FIREMODE (V) route to primary attack (LMB)
|
|
if( FireModeNum == BASH_FIREMODE && WeaponFireTypes[FireModeNum] == EWFT_None )
|
|
{
|
|
Super.SendToFiringState(DEFAULT_FIREMODE);
|
|
ClearPendingFire(BASH_FIREMODE);
|
|
}
|
|
|
|
Super.SendToFiringState(FireModeNum);
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* @name Damage
|
|
********************************************************************************************* */
|
|
|
|
/** process local player impact for clientside hit detection */
|
|
event RecieveClientImpact(byte FiringMode, const out ImpactInfo Impact, optional out float PenetrationValue, optional int ImpactNum)
|
|
{
|
|
MeleeAttackHelper.ProcessMeleeHit(FiringMode, Impact);
|
|
}
|
|
|
|
/** returns the damage amount for this attack */
|
|
simulated function int GetMeleeDamage(byte FireModeNum, optional vector RayDir)
|
|
{
|
|
local int Damage;
|
|
local KFPerk InstigatorPerk;
|
|
|
|
Damage = GetModifiedDamage(FireModeNum, RayDir);
|
|
// decode damage scale (see GetDamageScaleByAngle) from the RayDir
|
|
if ( !IsZero(RayDir) )
|
|
{
|
|
Damage = Round(float(Damage) * FMin(VSize(RayDir), 1.f));
|
|
}
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none )
|
|
{
|
|
if( IsHeavyAttack( FireModeNum ) )
|
|
{
|
|
InstigatorPerk.ModifyHardAttackDamage( Damage );
|
|
}
|
|
else if( IsLightAttack(FireModeNum) )
|
|
{
|
|
InstigatorPerk.ModifyLightAttackDamage( Damage );
|
|
}
|
|
}
|
|
|
|
return Damage;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* @name Blood/Wear Effects
|
|
*********************************************************************************************/
|
|
|
|
/** Increment bloody material parameter --- Network: Local Player */
|
|
simulated function AddBlood(float MinAmount, float MaxAmount)
|
|
{
|
|
Super.AddBlood(MinAmount, MaxAmount);
|
|
|
|
if ( !bIsBloody )
|
|
{
|
|
bIsBloody = true;
|
|
ServerSetBloody(true);
|
|
}
|
|
}
|
|
|
|
/** Syncronize this with the server for reloading state */
|
|
reliable server private function ServerSetBloody(bool bNewIsBloody)
|
|
{
|
|
bIsBloody = bNewIsBloody;
|
|
}
|
|
|
|
/** Remove blood material parameter from this weapon */
|
|
simulated function ANIMNOTIFY_CleanBlood()
|
|
{
|
|
local int i;
|
|
|
|
bIsBloody = false;
|
|
|
|
if ( WorldInfo.NetMode != NM_DedicatedServer && WeaponMICs.Length > 0 )
|
|
{
|
|
BloodParamValue = 0.f;
|
|
|
|
for( i = 0; i < WeaponMICs.Length; ++i )
|
|
{
|
|
if( WeaponMICs[i] != none )
|
|
{
|
|
WeaponMICs[i].SetScalarParameterValue( BloodParamName, BloodParamValue );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* @name Animation
|
|
********************************************************************************************* */
|
|
|
|
/** Overriden to use WeaponAnimNodeSeq */
|
|
simulated function PlayWeaponAnimation(name Sequence, float fDesiredDuration, optional bool bLoop, optional SkeletalMeshComponent SkelMesh)
|
|
{
|
|
Super.PlayWeaponAnimation(Sequence, fDesiredDuration, bLoop, SkelMesh);
|
|
|
|
// Reset CameraAnim following
|
|
bFollowAnimSeqCamera = default.bFollowAnimSeqCamera;
|
|
}
|
|
|
|
/** Called from the MeleeHelper class to allow for the weapon to override settings */
|
|
simulated function PlayMeleeAnimation(name AnimName, out float out_Rate, float BlendTime)
|
|
{
|
|
Super.PlayMeleeAnimation(AnimName, out_Rate, BlendTime);
|
|
|
|
// Enable CameraAnim following
|
|
bFollowAnimSeqCamera = true;
|
|
|
|
`DialogManager.PlayMeleeAttackDialog( KFPawn(Instigator), IsHeavyAttack(CurrentFireMode) );
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State WeaponUpkeep
|
|
* A firemode that replaces reload where the user cleans or sharpens the weapon
|
|
*********************************************************************************************/
|
|
|
|
simulated function UpkeepComplete();
|
|
|
|
/** Returns true if weapon can potentially be reloaded */
|
|
simulated function bool CanReload(optional byte FireModeNum)
|
|
{
|
|
if ( FiringStatesArray[RELOAD_FIREMODE] == 'WeaponUpkeep' )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return Super.CanReload(FireModeNum);
|
|
}
|
|
|
|
simulated state WeaponUpkeep
|
|
{
|
|
simulated function byte GetWeaponStateId()
|
|
{
|
|
return WEP_Cleaning;
|
|
}
|
|
|
|
simulated function BeginState(name PreviousStateName)
|
|
{
|
|
local name AnimName;
|
|
local float Duration;
|
|
|
|
// Calc Reload Duration
|
|
AnimName = (bIsBloody) ? CleanBloodyAnim : CleanNonBloodyAnim;
|
|
Duration = MySkelMesh.GetAnimInterruptTime(AnimName);
|
|
|
|
if ( Duration > 0.f )
|
|
{
|
|
if ( Instigator.IsFirstPerson() )
|
|
{
|
|
PlayAnimation(AnimName);
|
|
}
|
|
|
|
SetTimer(Duration, FALSE, nameof(UpkeepComplete));
|
|
}
|
|
else
|
|
{
|
|
`warn("Duration is zero!!!"@AnimName);
|
|
SetTimer(0.001, FALSE, nameof(UpkeepComplete));
|
|
}
|
|
|
|
NotifyBeginState();
|
|
}
|
|
|
|
// Allow for players to skip cleaning the weapon and go right into attacking.
|
|
simulated function BeginFire(byte FireModeNum)
|
|
{
|
|
Global.BeginFire(FireModeNum);
|
|
|
|
// handle reload interrupts
|
|
if ( FireModeNum != RELOAD_FIREMODE )
|
|
{
|
|
// if able, immediately interupt/abort the reload state
|
|
if( PendingFire(FireModeNum) && HasAmmo(FireModeNum) )
|
|
{
|
|
ClearPendingFire(RELOAD_FIREMODE);
|
|
GotoState('Active');
|
|
}
|
|
}
|
|
}
|
|
|
|
simulated event EndState(Name NextStateName)
|
|
{
|
|
NotifyEndState();
|
|
}
|
|
|
|
/** Cleanup state */
|
|
simulated function UpkeepComplete()
|
|
{
|
|
// we're done, leave state and go back to active
|
|
GotoState('Active');
|
|
}
|
|
}
|
|
|
|
simulated function bool CanOverrideMagReload(byte FireModeNum)
|
|
{
|
|
return Super.CanOverrideMagReload(FireModeNum) || FireModeNum == GRENADE_FIREMODE;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State MeleeChainAttacking
|
|
* A melee firemode that chains together a sequence of attacks
|
|
*********************************************************************************************/
|
|
|
|
simulated function bool IsLightAttack( byte FireMode );
|
|
|
|
simulated state MeleeChainAttacking extends MeleeAttackBasic
|
|
{
|
|
simulated function BeginState(Name PrevStateName)
|
|
{
|
|
super.BeginState( PrevStateName );
|
|
}
|
|
|
|
simulated function byte GetWeaponStateId()
|
|
{
|
|
switch (MeleeAttackHelper.CurrentAttackDir)
|
|
{
|
|
case DIR_Forward: return WEP_Melee_F;
|
|
case DIR_ForwardLeft: return WEP_Melee_F;
|
|
case DIR_ForwardRight: return WEP_Melee_F;
|
|
case DIR_Backward: return WEP_Melee_B;
|
|
case DIR_BackwardLeft: return WEP_Melee_B;
|
|
case DIR_BackwardRight: return WEP_Melee_B;
|
|
case DIR_Left: return WEP_Melee_L;
|
|
case DIR_Right: return WEP_Melee_R;
|
|
}
|
|
|
|
return WEP_MeleeChain;
|
|
}
|
|
|
|
/** Called when primary fire is let go, or when ShouldContinueMelee returns false */
|
|
simulated function EndState(Name NextStateName)
|
|
{
|
|
Super.EndState(NextStateName);
|
|
|
|
PlayMeleeSettleAnim();
|
|
|
|
// If both melee attacks are pressed, give priority to heavy attack. Need
|
|
// to do this because BeginFire is called in numeric order.
|
|
if ( PendingFire(DEFAULT_FIREMODE) && PendingFire(HEAVY_ATK_FIREMODE) )
|
|
{
|
|
ClearPendingFire(DEFAULT_FIREMODE);
|
|
}
|
|
}
|
|
|
|
/** Checks to see if we can perform another melee strike without changing states */
|
|
simulated function bool ShouldContinueMelee(optional int ChainCount)
|
|
{
|
|
// If next attack is of a different fire mode we want leave the attacking state so
|
|
// that the FiringState and FiringMode are properly updated for the new attack.
|
|
if ( PendingFire(HEAVY_ATK_FIREMODE) )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// normal weapon path (pending fire, etc...)
|
|
if ( !ShouldRefire() )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// make sure our firemode handler supports chain attacks
|
|
if ( !MeleeAttackHelper.bHasChainAttacks )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return (ChainCount + 1) < MaxChainAtkCount;
|
|
}
|
|
|
|
/** Get name of the animation to play for PlayFireEffects */
|
|
simulated function name GetMeleeAnimName(EPawnOctant AtkDir, EMeleeAttackType AtkType)
|
|
{
|
|
// Update our animation rate before changing weapon state to stay synced
|
|
UpdateWeaponAttachmentAnimRate( GetThirdPersonAnimRate() );
|
|
|
|
// update state id to match new attack direction
|
|
KFPawn(Instigator).WeaponStateChanged(GetWeaponStateId());
|
|
|
|
// primary / normal strikes and chain attacks
|
|
if ( AtkType == ATK_Combo )
|
|
{
|
|
switch (AtkDir)
|
|
{
|
|
case DIR_Forward: return MeleeComboChainAnim_F;
|
|
case DIR_ForwardLeft: return MeleeComboChainAnim_FL;
|
|
case DIR_ForwardRight: return MeleeComboChainAnim_FR;
|
|
case DIR_Backward: return FRand() < 0.5f ? MeleeComboChainAnim_BL : MeleeComboChainAnim_BR;
|
|
case DIR_BackwardLeft: return MeleeComboChainAnim_BL;
|
|
case DIR_BackwardRight: return MeleeComboChainAnim_BR;
|
|
case DIR_Left: return MeleeComboChainAnim_L;
|
|
case DIR_Right: return MeleeComboChainAnim_R;
|
|
}
|
|
}
|
|
|
|
switch (AtkDir)
|
|
{
|
|
case DIR_Forward: return MeleeAttackAnim_F;
|
|
case DIR_ForwardLeft: return MeleeAttackAnim_F;
|
|
case DIR_ForwardRight: return MeleeAttackAnim_F;
|
|
case DIR_Backward: return MeleeAttackAnim_B;
|
|
case DIR_BackwardLeft: return MeleeAttackAnim_B;
|
|
case DIR_BackwardRight: return MeleeAttackAnim_B;
|
|
case DIR_Left: return MeleeAttackAnim_L;
|
|
case DIR_Right: return MeleeAttackAnim_R;
|
|
}
|
|
}
|
|
|
|
simulated function bool IsLightAttack( byte FireMode )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
/** Gets the current animation rate, scaled or not */
|
|
simulated function float GetThirdPersonAnimRate()
|
|
{
|
|
local float ScaledRate;
|
|
|
|
ScaledRate = EvalInterpCurveFloat( MeleeAttackHelper.FatigueCurve, MeleeAttackHelper.NumChainedAttacks );
|
|
ModifyMeleeAttackSpeed(ScaledRate, CurrentFireMode);
|
|
|
|
return 1.f / ScaledRate;
|
|
}
|
|
}
|
|
|
|
/** Plays a 'settle' animation after a melee attack is finished */
|
|
simulated function PlayMeleeSettleAnim()
|
|
{
|
|
local int AnimIdx;
|
|
|
|
if( MeleeAttackSettleAnims.Length > 0 )
|
|
{
|
|
AnimIdx = Rand(MeleeAttackSettleAnims.Length);
|
|
PlayAnimation(MeleeAttackSettleAnims[AnimIdx], 0.0, false, 0.1);
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State MeleeHeavyAttacking
|
|
* This is the alt-fire Melee State.
|
|
*********************************************************************************************/
|
|
|
|
simulated function bool IsHeavyAttack(byte FireMode);
|
|
|
|
simulated state MeleeHeavyAttacking extends MeleeAttackBasic
|
|
{
|
|
simulated function byte GetWeaponStateId()
|
|
{
|
|
switch (MeleeAttackHelper.CurrentAttackDir)
|
|
{
|
|
case DIR_Forward: return WEP_MeleeHeavy_F;
|
|
case DIR_ForwardLeft: return WEP_MeleeHeavy_F;
|
|
case DIR_ForwardRight: return WEP_MeleeHeavy_F;
|
|
case DIR_Backward: return WEP_MeleeHeavy_B;
|
|
case DIR_BackwardLeft: return WEP_MeleeHeavy_B;
|
|
case DIR_BackwardRight: return WEP_MeleeHeavy_B;
|
|
case DIR_Left: return WEP_MeleeHeavy_L;
|
|
case DIR_Right: return WEP_MeleeHeavy_R;
|
|
}
|
|
|
|
return WEP_Idle;
|
|
}
|
|
|
|
simulated function BeginState(name PreviousStateName)
|
|
{
|
|
Super.BeginState(PreviousStateName);
|
|
|
|
// freeze the player for a short time for heavy damage strikes
|
|
if ( Instigator.IsLocallyControlled() )
|
|
{
|
|
KFPlayerController(Instigator.Controller).PauseMoveInput(0.1f);
|
|
}
|
|
}
|
|
|
|
simulated function EndState(Name NextStateName)
|
|
{
|
|
Super.EndState(NextStateName);
|
|
PlayMeleeSettleAnim();
|
|
}
|
|
|
|
/** heavy damage attack anims */
|
|
simulated function name GetMeleeAnimName(EPawnOctant AtkDir, EMeleeAttackType AtkType)
|
|
{
|
|
// heavy damage attacks
|
|
if ( AtkType == ATK_DrawStrike )
|
|
{
|
|
return MeleeDrawStrikeAnim;
|
|
}
|
|
|
|
switch (AtkDir)
|
|
{
|
|
case DIR_Forward: return MeleeHeavyAttackAnim_F;
|
|
case DIR_ForwardLeft: return MeleeHeavyAttackAnim_F;
|
|
case DIR_ForwardRight: return MeleeHeavyAttackAnim_F;
|
|
case DIR_Backward: return MeleeHeavyAttackAnim_B;
|
|
case DIR_BackwardLeft: return MeleeHeavyAttackAnim_B;
|
|
case DIR_BackwardRight: return MeleeHeavyAttackAnim_B;
|
|
case DIR_Left: return MeleeHeavyAttackAnim_L;
|
|
case DIR_Right: return MeleeHeavyAttackAnim_R;
|
|
}
|
|
}
|
|
|
|
simulated function bool IsHeavyAttack(byte FireMode)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State MeleeSustained
|
|
* A special melee state used for chainsaw like weapons. Extends WeaponFiring which is a
|
|
* bit odd, but it shares more in common with it than it does with MeleeAttackBasic
|
|
*********************************************************************************************/
|
|
|
|
// Global declarations for this state
|
|
function SustainedMinFireTimer();
|
|
function SustainedWarmupEndTimer();
|
|
|
|
simulated state MeleeSustained extends WeaponFiring
|
|
{
|
|
ignores AllowSprinting, AllowIronSights;
|
|
|
|
simulated function bool IsMeleeing()
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
simulated function BeginState(Name PreviousStateName)
|
|
{
|
|
// @note: No super because we don't want to FireAmmunition() right away
|
|
local KFPerk InstigatorPerk;
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none )
|
|
{
|
|
SetZedTimeResist( InstigatorPerk.GetZedTimeModifier(self) );
|
|
}
|
|
|
|
if ( MeleeSustainedWarmupTime > 0.f )
|
|
{
|
|
SetTimer(MeleeSustainedWarmupTime, false, nameof(SustainedWarmupEndTimer));
|
|
}
|
|
else
|
|
{
|
|
SustainedWarmupEndTimer();
|
|
}
|
|
|
|
StartLoopingFireEffects(CurrentFireMode, true);
|
|
NotifyBeginState();
|
|
}
|
|
|
|
simulated function EndState(Name NextStateName)
|
|
{
|
|
Super.EndState(NextStateName);
|
|
NotifyEndState();
|
|
}
|
|
|
|
/** Handle MinMeleeSustainedTime */
|
|
simulated function bool StillFiring(byte FireMode)
|
|
{
|
|
if ( Global.StillFiring(FireMode) || IsTimerActive(nameof(SustainedMinFireTimer)) )
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/** Called after warmup when weapon is ready to fire */
|
|
simulated function SustainedWarmupEndTimer()
|
|
{
|
|
// Do the first damage right away, we've already waited for the warmup time
|
|
FireAmmunition();
|
|
TimeWeaponFiring(CurrentFireMode);
|
|
|
|
if ( MinMeleeSustainedTime > 0.f )
|
|
{
|
|
SetTimer(MinMeleeSustainedTime, false, nameof(SustainedMinFireTimer));
|
|
}
|
|
}
|
|
|
|
/** Performs melee hit detection and does damage */
|
|
simulated function FireAmmunition()
|
|
{
|
|
HandleWeaponShotTaken( CurrentFireMode );
|
|
MeleeAttackHelper.bHitEnemyThisAttack = false;
|
|
MeleeAttackHelper.MeleeAttackImpact();
|
|
|
|
// Use ammunition to fire
|
|
ConsumeAmmo( CurrentFireMode );
|
|
}
|
|
|
|
/** Get name of the animation to play for PlayFireEffects */
|
|
simulated function name GetLoopingFireAnim(byte FireModeNum)
|
|
{
|
|
return MeleeSustainedLoopAnim;
|
|
}
|
|
|
|
/** Get name of the animation to play for PlayFireEffects */
|
|
simulated function name GetLoopStartFireAnim(byte FireModeNum)
|
|
{
|
|
return MeleeSustainedStartAnim;
|
|
}
|
|
|
|
/** Get name of the animation to play for PlayFireEffects */
|
|
simulated function name GetLoopEndFireAnim(byte FireModeNum)
|
|
{
|
|
return MeleeSustainedEndAnim;
|
|
}
|
|
|
|
simulated function byte GetWeaponStateId()
|
|
{
|
|
return WEP_MeleeSustained;
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State MeleeBlocking
|
|
* This is the default Blocking State. It's performed on both the client and the server.
|
|
*********************************************************************************************/
|
|
|
|
// Global declarations for blocking state
|
|
simulated function BlockLoopTimer();
|
|
simulated function ParryCheckTimer();
|
|
|
|
/** Called on the server when successfully block/parry an attack */
|
|
unreliable client function ClientPlayBlockEffects(optional byte BlockTypeIndex=255)
|
|
{
|
|
local AkBaseSoundObject Sound;
|
|
local ParticleSystem PSTemplate;
|
|
|
|
GetBlockEffects(BlockTypeIndex, Sound, PSTemplate);
|
|
PlayLocalBlockEffects(Sound, PSTemplate);
|
|
}
|
|
|
|
/** Called on the server when successfully block/parry an attack */
|
|
reliable client function ClientPlayParryEffects(optional byte BlockTypeIndex=255)
|
|
{
|
|
local AkBaseSoundObject Sound;
|
|
local ParticleSystem PSTemplate;
|
|
local KFPerk InstigatorPerk;
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none )
|
|
{
|
|
InstigatorPerk.SetSuccessfullParry();
|
|
}
|
|
|
|
GetParryEffects(BlockTypeIndex, Sound, PSTemplate);
|
|
PlayLocalBlockEffects(Sound, PSTemplate);
|
|
}
|
|
|
|
simulated function NotifyAttackParried();
|
|
simulated function NotifyAttackBlocked();
|
|
|
|
simulated state MeleeBlocking
|
|
{
|
|
ignores ForceReload, ShouldAutoReload;
|
|
|
|
simulated function byte GetWeaponStateId()
|
|
{
|
|
return WEP_MeleeBlock;
|
|
}
|
|
|
|
simulated function BeginState(name PreviousStateName)
|
|
{
|
|
local float ParryDuration;
|
|
|
|
ParryDuration = PlayBlockStart();
|
|
|
|
// Set the duration of the window to parry incoming attacks
|
|
if ( ParryDuration > 0.f )
|
|
{
|
|
SetTimer( ParryDuration, false, nameof(ParryCheckTimer) );
|
|
}
|
|
|
|
NotifyBeginState();
|
|
}
|
|
|
|
simulated function EndState(Name NextStateName)
|
|
{
|
|
if ( Instigator.IsLocallyControlled() )
|
|
{
|
|
PlayAnimation(MeleeBlockEndAnim);
|
|
}
|
|
|
|
//SetSlowMovement(false);
|
|
NotifyEndState();
|
|
}
|
|
|
|
/** Return to active state if we're done blocking */
|
|
simulated function EndFire(byte FireModeNum)
|
|
{
|
|
Global.EndFire(FireModeNum);
|
|
|
|
// Wait until parry is finished, then check PendingFire to stop blocking
|
|
if ( !StillFiring(CurrentFireMode) && !IsTimerActive(nameof(ParryCheckTimer)) )
|
|
{
|
|
GotoState('BlockingCooldown');
|
|
}
|
|
}
|
|
|
|
/** After the parry window is finished, check PendingFire to see if we're still blocking */
|
|
simulated function ParryCheckTimer()
|
|
{
|
|
// Check PendingFire to stop blocking
|
|
if ( !StillFiring(CurrentFireMode) )
|
|
{
|
|
GotoState('BlockingCooldown');
|
|
}
|
|
}
|
|
|
|
/** Grab/Grapple attacks can be parried */
|
|
function bool IsGrappleBlocked(Pawn InstigatedBy)
|
|
{
|
|
local float FacingDot;
|
|
local vector Dir2d;
|
|
|
|
// zero Z to give us a 2d dot product
|
|
Dir2d = Normal2d(InstigatedBy.Location - Instigator.Location);
|
|
FacingDot = vector(Instigator.Rotation) dot (Dir2d);
|
|
|
|
// Cos(85)
|
|
if ( FacingDot > 0.087f )
|
|
{
|
|
if ( IsTimerActive(nameof(ParryCheckTimer)) )
|
|
{
|
|
KFPawn(InstigatedBy).NotifyAttackParried(Instigator, 255);
|
|
ClientPlayParryEffects();
|
|
NotifyAttackParried();
|
|
}
|
|
else
|
|
{
|
|
ClientPlayBlockEffects();
|
|
NotifyAttackBlocked();
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/** While holding a melee weapon reduce some incoming damage */
|
|
function AdjustDamage(out int InDamage, class<DamageType> DamageType, Actor DamageCauser)
|
|
{
|
|
local float FacingDot;
|
|
local vector Dir2d;
|
|
local KFPerk InstigatorPerk;
|
|
local byte BlockTypeIndex;
|
|
|
|
// don't apply block/parry effects for teammates
|
|
if (Instigator.IsSameTeam(DamageCauser.Instigator))
|
|
{
|
|
return;
|
|
}
|
|
|
|
// zero Z to give us a 2d dot product
|
|
Dir2d = Normal2d(DamageCauser.Location - Instigator.Location);
|
|
FacingDot = vector(Instigator.Rotation) dot (Dir2d);
|
|
|
|
// Cos(85)
|
|
if ( FacingDot > 0.087f && CanBlockDamageType(DamageType, BlockTypeIndex) )
|
|
{
|
|
InstigatorPerk = GetPerk();
|
|
|
|
if ( IsTimerActive(nameof(ParryCheckTimer)) )
|
|
{
|
|
InDamage *= GetUpgradedParryDamageMitigation(CurrentWeaponUpgradeIndex);
|
|
// Notify attacking pawn for effects / animations
|
|
if ( KFPawn(DamageCauser) != None )
|
|
{
|
|
KFPawn(DamageCauser).NotifyAttackParried(Instigator, ParryStrength);
|
|
}
|
|
|
|
// @NOTE: This is now always true per discussion with AndrewL on KFII-29686. Since we always
|
|
// do the damage mitigation, we should always play the effect regardless of whether the
|
|
// zed was stumbled or knocked down. -MattF
|
|
ClientPlayParryEffects(BlockTypeIndex);
|
|
|
|
NotifyAttackParried();
|
|
|
|
if( InstigatorPerk != none )
|
|
{
|
|
InstigatorPerk.SetSuccessfullParry();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
InDamage *= GetUpgradedBlockDamageMitigation(CurrentWeaponUpgradeIndex);
|
|
ClientPlayBlockEffects(BlockTypeIndex);
|
|
|
|
NotifyAttackBlocked();
|
|
|
|
if( InstigatorPerk != none )
|
|
{
|
|
InstigatorPerk.SetSuccessfullBlock();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
simulated function BlockLoopTimer()
|
|
{
|
|
if( Instigator.IsLocallyControlled() )
|
|
{
|
|
PlayAnimation(MeleeBlockLoopAnim, , true);
|
|
}
|
|
}
|
|
|
|
/** State override for Block_Hit animations */
|
|
unreliable client function ClientPlayBlockEffects(optional byte BlockTypeIndex=255)
|
|
{
|
|
local int AnimIdx;
|
|
local float Duration;
|
|
local KFPerk InstigatorPerk;
|
|
|
|
Global.ClientPlayBlockEffects(BlockTypeIndex);
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none )
|
|
{
|
|
InstigatorPerk.SetSuccessfullBlock();
|
|
}
|
|
|
|
if( MeleeBlockHitAnims.Length > 0 && `TimeSince(LastBlockHitAnimTime) > BlockHitAnimCooldownTime && !IsTimerActive(nameof(ParryCheckTimer)) )
|
|
{
|
|
AnimIdx = Rand(MeleeBlockHitAnims.Length);
|
|
Duration = MySkelMesh.GetAnimLength(MeleeBlockHitAnims[AnimIdx]);
|
|
|
|
if ( Duration > 0 )
|
|
{
|
|
LastBlockHitAnimTime = WorldInfo.TimeSeconds;
|
|
PlayAnimation(MeleeBlockHitAnims[AnimIdx]);
|
|
SetTimer(Duration, false, nameof(BlockLoopTimer));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
simulated function float PlayBlockStart()
|
|
{
|
|
local float AnimDuration;
|
|
|
|
if( Instigator.IsLocallyControlled() )
|
|
{
|
|
PlayAnimation(MeleeBlockStartAnim);
|
|
}
|
|
|
|
// set when to start playing the looping anim
|
|
AnimDuration = MySkelMesh.GetAnimLength(MeleeBlockStartAnim);
|
|
if ( AnimDuration > 0.f )
|
|
{
|
|
SetTimer(AnimDuration, false, nameof(BlockLoopTimer));
|
|
}
|
|
else
|
|
{
|
|
BlockLoopTimer();
|
|
}
|
|
|
|
// set the parry duration to the same as the block start anim
|
|
return AnimDuration;
|
|
}
|
|
|
|
/** Called on the client when successfully block/parry an attack */
|
|
simulated function PlayLocalBlockEffects(AKBaseSoundObject Sound, ParticleSystem PSTemplate)
|
|
{
|
|
local vector Loc;
|
|
local rotator Rot;
|
|
local ParticleSystemComponent PSC;
|
|
|
|
if ( Sound != None )
|
|
{
|
|
PlaySoundBase(Sound, true);
|
|
}
|
|
|
|
if ( PSTemplate != None )
|
|
{
|
|
if ( MySkelMesh.GetSocketWorldLocationAndRotation(BlockEffectsSocketName, Loc, Rot) )
|
|
{
|
|
PSC = WorldInfo.MyEmitterPool.SpawnEmitter(PSTemplate, Loc, Rot);
|
|
PSC.SetDepthPriorityGroup(SDPG_Foreground);
|
|
}
|
|
else
|
|
{
|
|
`log(self@GetFuncName()@"missing BlockEffects Socket!");
|
|
}
|
|
}
|
|
}
|
|
|
|
/** If true, this damage type can be blocked by the MeleeBlocking state */
|
|
function bool CanBlockDamageType(class<DamageType> DamageType, optional out byte out_Idx)
|
|
{
|
|
local int Idx;
|
|
|
|
// Check if this damage should be ignored completely
|
|
for (Idx = 0; Idx < BlockTypes.length; ++Idx)
|
|
{
|
|
if ( ClassIsChildOf(DamageType, BlockTypes[Idx].DmgType) )
|
|
{
|
|
out_Idx = Idx;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
out_Idx = INDEX_NONE;
|
|
return false;
|
|
}
|
|
|
|
/** Returns sound and particle system overrides using index into BlockTypes array */
|
|
simulated function GetBlockEffects(byte BlockIndex, out AKBaseSoundObject outSound, out ParticleSystem outParticleSys)
|
|
{
|
|
outSound = BlockSound;
|
|
outParticleSys = BlockParticleSystem;
|
|
|
|
if ( BlockIndex != 255 )
|
|
{
|
|
if ( BlockTypes[BlockIndex].BlockSound != None )
|
|
{
|
|
outSound = BlockTypes[BlockIndex].BlockSound;
|
|
}
|
|
if ( BlockTypes[BlockIndex].BlockParticleSys != None )
|
|
{
|
|
outParticleSys = BlockTypes[BlockIndex].BlockParticleSys;
|
|
}
|
|
}
|
|
}
|
|
|
|
/** Returns sound and particle system overrides using index into BlockTypes array */
|
|
simulated function GetParryEffects(byte BlockIndex, out AKBaseSoundObject outSound, out ParticleSystem outParticleSys)
|
|
{
|
|
outSound = ParrySound;
|
|
outParticleSys = ParryParticleSystem;
|
|
|
|
if ( BlockIndex != 255 )
|
|
{
|
|
if ( BlockTypes[BlockIndex].ParrySound != None )
|
|
{
|
|
outSound = BlockTypes[BlockIndex].ParrySound;
|
|
}
|
|
if ( BlockTypes[BlockIndex].ParryParticleSys != None )
|
|
{
|
|
outParticleSys = BlockTypes[BlockIndex].ParryParticleSys;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State BlockingCooldown
|
|
* A short cooldown state to prevent spamming block while still allowing pendingfire to be set
|
|
*********************************************************************************************/
|
|
|
|
// Global declarations for this state
|
|
simulated function BlockCooldownTimer();
|
|
|
|
simulated state BlockingCooldown extends Active
|
|
{
|
|
ignores AllowSprinting;
|
|
|
|
/** Set cooldown duration */
|
|
simulated function BeginState( Name PreviousStateName )
|
|
{
|
|
SetTimer(0.5, false, nameof(BlockCooldownTimer));
|
|
Super.BeginState(PreviousStateName);
|
|
}
|
|
|
|
// prevent going to block/parry state
|
|
simulated function bool HasAmmo( byte FireModeNum, optional int Amount )
|
|
{
|
|
if ( FireModeNum == BLOCK_FIREMODE )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return Global.HasAmmo(FireModeNum, Amount);
|
|
}
|
|
|
|
// prevent HasAmmo (above) from causing an auto reload
|
|
simulated function bool ShouldAutoReload(byte FireModeNum)
|
|
{
|
|
if ( FireModeNum == BLOCK_FIREMODE )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return Global.ShouldAutoReload(FireModeNum);
|
|
}
|
|
|
|
simulated function BlockCooldownTimer()
|
|
{
|
|
GotoState('Active');
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* State WeaponEquipping
|
|
* Overridden for DrawStrike ability
|
|
*********************************************************************************************/
|
|
|
|
/** Perform a special attack animation while equipping */
|
|
simulated function ANIMNOTIFY_DrawAtk();
|
|
simulated function AttemptDrawStrike();
|
|
|
|
simulated state WeaponEquipping
|
|
{
|
|
/** Override BeginFire so that it will enter the firing state right away. */
|
|
simulated function ANIMNOTIFY_DrawAtk()
|
|
{
|
|
// wait a short time because we can't call SetAnim during a notify
|
|
SetTimer(0.001f, false, nameof(AttemptDrawStrike));
|
|
}
|
|
|
|
/** If melee attack fire modes are pending, perform draw strike */
|
|
simulated function AttemptDrawStrike()
|
|
{
|
|
// if either of the fire modes are pending, perform them
|
|
if ( PendingFire(DEFAULT_FIREMODE) || PendingFire(HEAVY_ATK_FIREMODE) )
|
|
{
|
|
MeleeAttackHelper.InitAttackSequence(DIR_Right, ATK_DrawStrike);
|
|
SendToFiringState(HEAVY_ATK_FIREMODE);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* Trader
|
|
********************************************************************************************/
|
|
|
|
/** Allows weapon to set its own trader stats (can set number of stats, names and values of stats) */
|
|
static simulated event SetTraderWeaponStats( out array<STraderItemWeaponStats> WeaponStats )
|
|
{
|
|
super.SetTraderWeaponStats( WeaponStats );
|
|
|
|
WeaponStats.Length = WeaponStats.Length + 1;
|
|
WeaponStats[WeaponStats.Length-1].StatType = TWS_Block;
|
|
WeaponStats[WeaponStats.Length-1].StatValue = GetUpgradedBlockDamageMitigation(0);
|
|
|
|
WeaponStats.Length = WeaponStats.Length + 1;
|
|
WeaponStats[WeaponStats.Length-1].StatType = TWS_Parry;
|
|
WeaponStats[WeaponStats.Length-1].StatValue = GetUpgradedParryDamageMitigation(0);
|
|
}
|
|
|
|
/** Allows weapon to calculate its own damage for display in trader
|
|
* In general, melee weapons should use heavy attack to determine damage
|
|
*/
|
|
static simulated function float CalculateTraderWeaponStatDamage()
|
|
{
|
|
local float CalculatedDamage;
|
|
local class<KFDamageType> DamageType;
|
|
|
|
CalculatedDamage = default.InstantHitDamage[HEAVY_ATK_FIREMODE];
|
|
|
|
DamageType = class<KFDamageType>(default.InstantHitDamageTypes[HEAVY_ATK_FIREMODE]);
|
|
if( DamageType != none && DamageType.default.DoT_Type != DOT_None )
|
|
{
|
|
CalculatedDamage += (DamageType.default.DoT_Duration / DamageType.default.DoT_Interval) * (CalculatedDamage * DamageType.default.DoT_DamageScale);
|
|
}
|
|
|
|
return CalculatedDamage;
|
|
}
|
|
|
|
/** Allows weapon to calculate its own fire rate for display in trader.
|
|
* Overridden to use estimated fire rate.
|
|
*/
|
|
static simulated function float CalculateTraderWeaponStatFireRate()
|
|
{
|
|
// attack interval in anim-based, so there's no way to compute it programatically from the editor, where
|
|
// this function is called from.
|
|
|
|
return default.EstimatedFireRate;
|
|
}
|
|
|
|
/** Returns trader filter index based on weapon type */
|
|
static simulated event EFilterTypeUI GetTraderFilter()
|
|
{
|
|
return FT_Melee;
|
|
}
|
|
|
|
/*********************************************************************************************
|
|
* Upgrades
|
|
********************************************************************************************/
|
|
|
|
static simulated function float GetUpgradedBlockDamageMitigation(int UpgradeIndex)
|
|
{
|
|
return GetUpgradedStatValue(default.BlockDamageMitigation, EWUS_BlockDmgMitigation, UpgradeIndex);
|
|
}
|
|
|
|
static simulated function float GetUpgradedParryDamageMitigation(int UpgradeIndex)
|
|
{
|
|
return GetUpgradedStatValue(default.ParryDamageMitigationPercent, EWUS_ParryDmgMitigation, UpgradeIndex);
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
InventoryGroup=IG_Melee
|
|
bMeleeWeapon=true
|
|
|
|
Begin Object Name=FirstPersonMesh
|
|
// Set MinTickTimeStep to ensure a high enough tickrate for melee hitbox collision
|
|
MinTickTimeStep=0.025f // 40fps
|
|
End Object
|
|
|
|
// DEFAULT_FIREMODE
|
|
FireModeIconPaths(DEFAULT_FIREMODE)=Texture2D'ui_firemodes_tex.UI_FireModeSelect_Melee'
|
|
FiringStatesArray(DEFAULT_FIREMODE)=MeleeChainAttacking
|
|
WeaponFireTypes(DEFAULT_FIREMODE)=EWFT_Custom
|
|
InstantHitDamageTypes(DEFAULT_FIREMODE)=class'KFDT_Slashing'
|
|
InstantHitDamage(DEFAULT_FIREMODE)=20
|
|
AmmoCost(DEFAULT_FIREMODE)=0
|
|
|
|
// ALT_FIREMODE
|
|
FireModeIconPaths(HEAVY_ATK_FIREMODE)=Texture2D'ui_firemodes_tex.UI_FireModeSelect_Melee'
|
|
FiringStatesArray(HEAVY_ATK_FIREMODE)=MeleeHeavyAttacking
|
|
WeaponFireTypes(HEAVY_ATK_FIREMODE)=EWFT_Custom
|
|
InstantHitDamageTypes(HEAVY_ATK_FIREMODE)=class'KFDT_Slashing'
|
|
InstantHitDamage(HEAVY_ATK_FIREMODE)=50
|
|
InstantHitMomentum(HEAVY_ATK_FIREMODE)=1.f
|
|
AmmoCost(HEAVY_ATK_FIREMODE)=0
|
|
|
|
// RELOAD_FIREMODE
|
|
FiringStatesArray(RELOAD_FIREMODE)=WeaponUpkeep
|
|
|
|
// MELEE_BLOCK_FIREMODE
|
|
FiringStatesArray(BLOCK_FIREMODE)=MeleeBlocking
|
|
WeaponFireTypes(BLOCK_FIREMODE)=EWFT_Custom
|
|
FireInterval(BLOCK_FIREMODE)=1.f
|
|
AmmoCost(BLOCK_FIREMODE)=0
|
|
|
|
Begin Object Name=MeleeHelper_0
|
|
bUseDirectionalMelee=true
|
|
bHasChainAttacks=true
|
|
bUseMeleeHitTimer=false
|
|
MaxHitRange=150
|
|
End Object
|
|
|
|
// default MIC param names
|
|
BlockEffectsSocketName=BlockEffect
|
|
|
|
// Attachments
|
|
bHasIronSights=false
|
|
bHasFlashlight=false
|
|
|
|
// Aim Assist
|
|
AimCorrectionSize=0.f
|
|
bTargetAdhesionEnabled=false
|
|
|
|
//--------------------------------
|
|
// Defensive
|
|
BlockDamageMitigation=0.50f
|
|
ParryDamageMitigationPercent=0.2
|
|
ParryStrength=4
|
|
BlockHitAnimCooldownTime=0.5f
|
|
BlockTypes.Add((DmgType=class'KFDT_Bludgeon'))
|
|
BlockTypes.Add((DmgType=class'KFDT_Slashing'))
|
|
|
|
BlockSound=none
|
|
ParrySound=none
|
|
BlockParticleSystem=ParticleSystem'FX_Impacts_EMIT.FX_Block_melee_01'
|
|
ParryParticleSystem=ParticleSystem'FX_Impacts_EMIT.FX_Parry_melee_01'
|
|
MeleeBlockHitAnims=(Block_Hit_V1, Block_Hit_V2, Block_Hit_V3);
|
|
|
|
DistortTrailParticle = ParticleSystem'FX_Gameplay_EMIT_THREE.Trails.FX_Trail_Distort_R_01'
|
|
WhiteTrailParticle = ParticleSystem'FX_Gameplay_EMIT_THREE.Trails.FX_Trail_White_R_01'
|
|
BlueTrailParticle = ParticleSystem'FX_Gameplay_EMIT_THREE.Trails.FX_Trail_Blue_R_01'
|
|
RedTrailParticle = ParticleSystem'FX_Gameplay_EMIT_THREE.Trails.FX_Trail_Red_R_01'
|
|
|
|
//--------------------------------
|
|
// Animations
|
|
MaxChainAtkCount = 3
|
|
MeleeAttackSettleAnims.Add(Settle_V1)
|
|
MinMeleeSustainedTime = 0.5f
|
|
MeleeSustainedWarmupTime = 0.25f
|
|
|
|
// Trader
|
|
EstimatedFireRate = 100
|
|
|
|
// Upgrades
|
|
UpgradeFireModes(BLOCK_FIREMODE) = 0
|
|
UpgradeFireModes(HEAVY_ATK_FIREMODE) = 1
|
|
UpgradeFireModes(CUSTOM_FIREMODE) = 1
|
|
|
|
ReloadCancelTimeLimit = 0.5f;
|
|
|
|
bHasToBeConsideredAsRangedWeaponForPerks=false;
|
|
}
|