778 lines
20 KiB
Ucode
778 lines
20 KiB
Ucode
//=============================================================================
|
|
// KFWeap_HRG_BallisticBouncer
|
|
//=============================================================================
|
|
// Killing Floor 2
|
|
// Copyright (C) 2022 Tripwire Interactive LLC
|
|
//=============================================================================
|
|
class KFWeap_HRG_BallisticBouncer extends KFWeapon;
|
|
|
|
//Props related to charging the weapon
|
|
var float MaxChargeTime;
|
|
var float ValueIncreaseTime;
|
|
var float DmgIncreasePerCharge;
|
|
var float AOEIncreasePerCharge;
|
|
var float IncapIncreasePerCharge;
|
|
var int AmmoIncreasePerCharge;
|
|
|
|
var transient float ChargeTime;
|
|
var transient float ConsumeAmmoTime;
|
|
var transient float MaxChargeLevel;
|
|
|
|
var ParticleSystem ChargedEffect;
|
|
|
|
var transient ParticleSystemComponent FullyChargedPSC;
|
|
var transient bool bIsFullyCharged;
|
|
|
|
var const WeaponFireSndInfo FullyChargedSound;
|
|
|
|
var float FullChargedTimerInterval;
|
|
var float FXScalingFactorByCharge, ChargePercentage;
|
|
var float MinScale, MaxScale;
|
|
|
|
var int MaxDamageByCharge;
|
|
var int MinDamageByCharge;
|
|
|
|
const SecondaryFireAnim = 'Alt_Fire';
|
|
const SecondaryFireIronAnim = 'Alt_Fire_Iron';
|
|
const SecondaryFireAnimEmpty = 'Alt_Fire_Empty';
|
|
const SecondaryFireIronAnimEmpty = 'Alt_Fire_Iron_Empty';
|
|
var bool bHasToLaunchEmptyAnim;
|
|
|
|
var SkelControlSingleBone Control;
|
|
|
|
var bool bBlocked;
|
|
|
|
var() StaticMesh ChargeStaticMesh;
|
|
var transient StaticMeshComponent ChargeAttachment;
|
|
var transient MaterialInstanceConstant ChargeMIC;
|
|
|
|
var float MinProjPlaceholderScale;
|
|
var float MaxProjPlaceHolderScale;
|
|
|
|
Replication
|
|
{
|
|
if(Role == Role_Authority && bNetDirty)
|
|
ChargeTime;
|
|
}
|
|
|
|
static simulated event EFilterTypeUI GetTraderFilter()
|
|
{
|
|
return FT_Projectile;
|
|
}
|
|
|
|
simulated event PostInitAnimTree( SkeletalMeshComponent SkelComp )
|
|
{
|
|
local vector vec;
|
|
local float fPercentage;
|
|
|
|
super.PostInitAnimTree( SkelComp );
|
|
|
|
Control = SkelControlSingleBone( SkelComp.FindSkelControl('AmmoControl') );
|
|
if( Control != none )
|
|
{
|
|
Control.SetSkelControlActive( true );
|
|
}
|
|
|
|
//from 0 to -8
|
|
// If AmmoCount is being replicated, don't allow the client to modify it here
|
|
fPercentage = FMin((float(AmmoCount[0])/(MagazineCapacity[0])), 1);
|
|
vec.X = Control.BoneTranslation.X;
|
|
vec.Y = Control.BoneTranslation.Y;
|
|
vec.Z = Lerp(-8, 0, fPercentage);
|
|
Control.BoneTranslation = vec;
|
|
}
|
|
|
|
/**
|
|
* @see Weapon::ConsumeAmmo
|
|
*/
|
|
simulated function ConsumeAmmo(byte FireModeNum)
|
|
{
|
|
local vector vec;
|
|
local float fPercentage;
|
|
|
|
//from 0 to -8
|
|
// If AmmoCount is being replicated, don't allow the client to modify it here
|
|
if (Role == ROLE_Authority)
|
|
{
|
|
fPercentage = FMin(float(AmmoCount[0])/(MagazineCapacity[0]), 1);
|
|
super.ConsumeAmmo(FireModeNum);
|
|
|
|
if(Control != none)
|
|
{
|
|
vec.X = Control.BoneTranslation.X;
|
|
vec.Y = Control.BoneTranslation.Y;
|
|
vec.Z = Lerp(-8, 0, fPercentage);
|
|
Control.BoneTranslation = vec;
|
|
}
|
|
|
|
//Notify the client about the new percentage as the client is not tracking the ammo
|
|
ClientUpdateVisualAmmo(fPercentage);
|
|
}
|
|
}
|
|
|
|
reliable client function ClientUpdateVisualAmmo(float BoneControlTranslation)
|
|
{
|
|
local vector vec;
|
|
|
|
if ( Role < ROLE_Authority && Control != none )
|
|
{
|
|
vec.X = Control.BoneTranslation.X;
|
|
vec.Y = Control.BoneTranslation.Y;
|
|
vec.Z = Lerp(-8, 0, BoneControlTranslation);
|
|
Control.BoneTranslation = vec;
|
|
}
|
|
}
|
|
|
|
simulated function StartFire(byte FiremodeNum)
|
|
{
|
|
if (IsTimerActive('RefireCheckTimer'))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (bBlocked && AmmoCount[0] == 0 && !IsTimerActive(nameof(RefireCheckTimer)) && !IsTimerActive(nameof(UnlockClientFire)))
|
|
{
|
|
|
|
bBlocked = false;
|
|
}
|
|
|
|
if(Role != Role_Authority && FireModeNum == DEFAULT_FIREMODE && HasAmmo(DEFAULT_FIREMODE))
|
|
{
|
|
bBlocked = true;
|
|
if(IsTimerActive(nameof(UnlockClientFire)))
|
|
{
|
|
ClearTimer(nameof(UnlockClientFire));
|
|
}
|
|
}
|
|
|
|
super.StartFire(FiremodeNum);
|
|
|
|
if ( PendingFire(RELOAD_FIREMODE) && Role != Role_Authority)
|
|
{
|
|
bBlocked = false;
|
|
}
|
|
}
|
|
|
|
simulated function RefireCheckTimer()
|
|
{
|
|
Super.RefireCheckTimer();
|
|
if(bBlocked && Role != Role_Authority)
|
|
{
|
|
SetTimer(0.25f , false, nameof(UnlockClientFire));
|
|
}
|
|
}
|
|
|
|
reliable client function UnlockClientFire()
|
|
{
|
|
bBlocked = false;
|
|
}
|
|
|
|
simulated function OnStartFire()
|
|
{
|
|
local KFPawn PawnInst;
|
|
PawnInst = KFPawn(Instigator);
|
|
|
|
if (PawnInst != none)
|
|
{
|
|
PawnInst.OnStartFire();
|
|
}
|
|
}
|
|
|
|
|
|
simulated function FireAmmunition()
|
|
{
|
|
// Let the accuracy tracking system know that we fired
|
|
HandleWeaponShotTaken(CurrentFireMode);
|
|
|
|
// Handle the different fire types
|
|
switch (WeaponFireTypes[CurrentFireMode])
|
|
{
|
|
case EWFT_InstantHit:
|
|
// Launch a projectile if we are in zed time, and this weapon has a projectile to launch for this mode
|
|
if (`IsInZedTime(self) && WeaponProjectiles[CurrentFireMode] != none )
|
|
{
|
|
ProjectileFire();
|
|
}
|
|
else
|
|
{
|
|
InstantFireClient();
|
|
}
|
|
|
|
break;
|
|
|
|
case EWFT_Projectile:
|
|
ProjectileFire();
|
|
break;
|
|
|
|
case EWFT_Custom:
|
|
CustomFire();
|
|
break;
|
|
}
|
|
|
|
//// If we're firing without charging, still consume one ammo
|
|
if (GetChargeLevel() < 1)
|
|
{
|
|
ConsumeAmmo(CurrentFireMode);
|
|
}
|
|
|
|
NotifyWeaponFired(CurrentFireMode);
|
|
|
|
// Play fire effects now (don't wait for WeaponFired to replicate)
|
|
PlayFireEffects(CurrentFireMode, vect(0, 0, 0));
|
|
}
|
|
|
|
simulated function ANIMNOTIFY_FILLMAG()
|
|
{
|
|
local vector vec;
|
|
|
|
if (Control != none)
|
|
{
|
|
vec.X = Control.BoneTranslation.X;
|
|
vec.Y = Control.BoneTranslation.Y;
|
|
vec.Z = 0;
|
|
Control.BoneTranslation = vec;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @see Weapon::HasAmmo
|
|
*/
|
|
simulated event bool HasAmmo( byte FireModeNum, optional int Amount )
|
|
{
|
|
local KFPerk InstigatorPerk;
|
|
// we can always do a melee attack
|
|
if( FireModeNum == BASH_FIREMODE )
|
|
{
|
|
return TRUE;
|
|
}
|
|
else if ( FireModeNum == RELOAD_FIREMODE )
|
|
{
|
|
return CanReload();
|
|
}
|
|
else if ( FireModeNum == GRENADE_FIREMODE )
|
|
{
|
|
if( KFInventoryManager(InvManager) != none )
|
|
{
|
|
return KFInventoryManager(InvManager).HasGrenadeAmmo(Amount);
|
|
}
|
|
}
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none && InstigatorPerk.GetIsUberAmmoActive( self ) )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// If passed in ammo isn't set, use default ammo cost.
|
|
if( Amount == 0 )
|
|
{
|
|
Amount = AmmoCost[FireModeNum];
|
|
}
|
|
|
|
return AmmoCount[GetAmmoType(FireModeNum)] >= Amount;
|
|
}
|
|
|
|
simulated state MineReconstructorCharge extends WeaponFiring
|
|
{
|
|
//For minimal code purposes, I'll directly call global.FireAmmunition after charging is released
|
|
simulated function FireAmmunition()
|
|
{
|
|
return;
|
|
}
|
|
|
|
//Store start fire time so we don't have to timer this
|
|
simulated event BeginState(Name PreviousStateName)
|
|
{
|
|
local KFPerk InstigatorPerk;
|
|
|
|
super.BeginState(PreviousStateName);
|
|
|
|
InstigatorPerk = GetPerk();
|
|
if( InstigatorPerk != none )
|
|
{
|
|
SetZedTimeResist( InstigatorPerk.GetZedTimeModifier(self) );
|
|
}
|
|
|
|
ChargeTime = 0;
|
|
ConsumeAmmoTime = 0;
|
|
MaxChargeLevel = int(MaxChargeTime / ValueIncreaseTime);
|
|
|
|
if (WorldInfo.NetMode == NM_Client || WorldInfo.NetMode == NM_Standalone)
|
|
{
|
|
if (ChargeAttachment == none)
|
|
{
|
|
ChargeAttachment = new (self) class'StaticMeshComponent';
|
|
|
|
// ChargeAttachment.SetActorCollision(false, false);
|
|
ChargeAttachment.SetStaticMesh(ChargeStaticMesh);
|
|
// ChargeAttachment.SetShadowParent(Mesh);
|
|
|
|
ChargeMIC = ChargeAttachment.CreateAndSetMaterialInstanceConstant(0);
|
|
|
|
MySkelMesh.AttachComponentToSocket(ChargeAttachment, 'MuzzleFlash');
|
|
|
|
ChargeAttachment.SetHidden(true);
|
|
}
|
|
else
|
|
{
|
|
ChargeAttachment.SetStaticMesh(ChargeStaticMesh);
|
|
}
|
|
}
|
|
|
|
bIsFullyCharged = false;
|
|
|
|
global.OnStartFire();
|
|
|
|
ChargeTime = 0;
|
|
FXScalingFactorByCharge = 0;
|
|
}
|
|
|
|
simulated function bool ShouldRefire()
|
|
{
|
|
// ignore how much ammo is left (super/global counts ammo)
|
|
return StillFiring(CurrentFireMode);
|
|
}
|
|
|
|
simulated event Tick(float DeltaTime)
|
|
{
|
|
local float ChargeRTPC;
|
|
local float InstantHitDamageValue;
|
|
local float NewScale;
|
|
|
|
global.Tick(DeltaTime);
|
|
|
|
if (ChargeAttachment != none && ChargeAttachment.StaticMesh == none)
|
|
{
|
|
ChargeAttachment.SetStaticMesh(ChargeStaticMesh);
|
|
}
|
|
|
|
if(bIsFullyCharged) return;
|
|
|
|
// Don't charge unless we're holding down the button
|
|
if (PendingFire(CurrentFireMode))
|
|
{
|
|
ConsumeAmmoTime += DeltaTime;
|
|
}
|
|
|
|
if (bIsFullyCharged)
|
|
{
|
|
if (ConsumeAmmoTime >= FullChargedTimerInterval)
|
|
{
|
|
ConsumeAmmo(DEFAULT_FIREMODE);
|
|
ConsumeAmmoTime -= FullChargedTimerInterval;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
// Don't charge unless we're holding down the button
|
|
if (PendingFire(CurrentFireMode))
|
|
{
|
|
if(Role == Role_Authority && !bIsFullyCharged)
|
|
{
|
|
ChargeTime += DeltaTime;
|
|
bNetDirty = true;
|
|
}
|
|
|
|
ChargePercentage = FMin(ChargeTime / MaxChargeTime, 1);
|
|
|
|
if (ChargeAttachment != none && !bIsFullyCharged)
|
|
{
|
|
FXScalingFactorByCharge = FMin(Lerp(MinScale, MaxScale, ChargeTime / MaxChargeTime), MaxScale);
|
|
|
|
if(ChargePercentage < 0.1f)
|
|
{
|
|
InstantHitDamageValue = Lerp(MinDamageByCharge, MaxDamageByCharge, 0.1f);
|
|
}
|
|
else
|
|
{
|
|
InstantHitDamageValue = Lerp(MinDamageByCharge, MaxDamageByCharge, ChargePercentage);
|
|
}
|
|
InstantHitDamage[DEFAULT_FIREMODE] = InstantHitDamageValue;
|
|
|
|
NewScale = Lerp(MinProjPlaceholderScale, MaxProjPlaceholderScale, ChargePercentage);
|
|
|
|
ChargeAttachment.SetHidden(false);
|
|
ChargeAttachment.SetScale( NewScale );
|
|
|
|
if (ChargeMIC != none)
|
|
{
|
|
// Change Color
|
|
ChargeMIC.SetScalarParameterValue('Charge', ChargePercentage);
|
|
}
|
|
}
|
|
}
|
|
|
|
ChargeRTPC = FMin(ChargeTime / MaxChargeTime, 1.f);
|
|
KFPawn(Instigator).SetWeaponComponentRTPCValue("Weapon_Charge", ChargeRTPC); //For looping component
|
|
Instigator.SetRTPCValue('Weapon_Charge', ChargeRTPC); //For one-shot sounds
|
|
|
|
if (ConsumeAmmoTime >= ValueIncreaseTime && !bIsFullyCharged)
|
|
{
|
|
ConsumeAmmo(DEFAULT_FIREMODE);
|
|
ConsumeAmmoTime -= ValueIncreaseTime;
|
|
}
|
|
|
|
if (ChargeTime >= MaxChargeTime || !HasAmmo(DEFAULT_FIREMODE))
|
|
{
|
|
bIsFullyCharged = true;
|
|
|
|
if(( Instigator.Role != ROLE_Authority ) || WorldInfo.NetMode == NM_Standalone)
|
|
{
|
|
if (FullyChargedPSC == none)
|
|
{
|
|
FullyChargedPSC = new(self) class'ParticleSystemComponent';
|
|
|
|
if(MySkelMesh != none)
|
|
{
|
|
MySkelMesh.AttachComponentToSocket(FullyChargedPSC, 'MuzzleFlash');
|
|
}
|
|
else
|
|
{
|
|
AttachComponent(FullyChargedPSC);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FullyChargedPSC.ActivateSystem();
|
|
}
|
|
|
|
FullyChargedPSC.SetTemplate(ChargedEffect);
|
|
|
|
|
|
KFPawn(Instigator).SetWeaponAmbientSound(FullyChargedSound.DefaultCue, FullyChargedSound.FirstPersonCue);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Now that we're done charging, directly call FireAmmunition. This will handle the actual projectile fire and scaling.
|
|
simulated event EndState(Name NextStateName)
|
|
{
|
|
if(Role == Role_Authority)
|
|
{
|
|
UnlockClientFire();
|
|
}
|
|
|
|
ClearZedTimeResist();
|
|
ClearPendingFire(CurrentFireMode);
|
|
ClearTimer(nameof(RefireCheckTimer));
|
|
|
|
KFPawn(Instigator).bHasStartedFire = false;
|
|
KFPawn(Instigator).bNetDirty = true;
|
|
|
|
if (ChargeAttachment != none)
|
|
{
|
|
ChargeAttachment.SetHidden(true);
|
|
ChargeAttachment.SetScale(MinProjPlaceholderScale);
|
|
}
|
|
|
|
if (FullyChargedPSC != none)
|
|
{
|
|
FullyChargedPSC.DeactivateSystem();
|
|
}
|
|
|
|
KFPawn(Instigator).SetWeaponAmbientSound(none);
|
|
}
|
|
|
|
simulated function HandleFinishedFiring()
|
|
{
|
|
global.FireAmmunition();
|
|
|
|
if (bPlayingLoopingFireAnim)
|
|
{
|
|
StopLoopingFireEffects(CurrentFireMode);
|
|
}
|
|
|
|
SetTimer(0.1f, false, 'Timer_StopFireEffects');
|
|
|
|
NotifyWeaponFinishedFiring(CurrentFireMode);
|
|
|
|
super.HandleFinishedFiring();
|
|
}
|
|
|
|
simulated function PutDownWeapon()
|
|
{
|
|
global.FireAmmunition();
|
|
|
|
if (bPlayingLoopingFireAnim)
|
|
{
|
|
StopLoopingFireEffects(CurrentFireMode);
|
|
}
|
|
|
|
SetTimer(0.1f, false, 'Timer_StopFireEffects');
|
|
|
|
if (ChargeAttachment != none)
|
|
{
|
|
ChargeAttachment.SetHidden(true);
|
|
ChargeAttachment.SetScale(MinProjPlaceholderScale);
|
|
}
|
|
|
|
NotifyWeaponFinishedFiring(CurrentFireMode);
|
|
|
|
if(Role == Role_Authority)
|
|
{
|
|
UnlockClientFire();
|
|
}
|
|
|
|
super.PutDownWeapon();
|
|
}
|
|
}
|
|
|
|
simulated function StopFireEffects(byte FireModeNum)
|
|
{
|
|
Super.StopFireEffects(FireModeNum);
|
|
|
|
if (ChargeAttachment != none)
|
|
{
|
|
ChargeAttachment.SetStaticMesh(none); // if we don't do this it doesn't work ?!, when starting fire it assigns again so no problem..
|
|
|
|
ChargeAttachment.SetHidden(true);
|
|
ChargeAttachment.SetScale(MinProjPlaceholderScale);
|
|
}
|
|
}
|
|
|
|
// Placing the actual Weapon Firing end state here since we need it to happen at the end of the actual firing loop.
|
|
simulated function Timer_StopFireEffects()
|
|
{
|
|
// Simulate weapon firing effects on the local client
|
|
if (WorldInfo.NetMode == NM_Client)
|
|
{
|
|
Instigator.WeaponStoppedFiring(self, false);
|
|
|
|
if (ChargeAttachment != none)
|
|
{
|
|
ChargeAttachment.SetHidden(true);
|
|
}
|
|
|
|
if (FullyChargedPSC != none)
|
|
{
|
|
FullyChargedPSC.DeactivateSystem();
|
|
}
|
|
}
|
|
|
|
ClearFlashCount();
|
|
ClearFlashLocation();
|
|
}
|
|
|
|
simulated state Active
|
|
{
|
|
simulated function BeginState(name PreviousStateName)
|
|
{
|
|
Super.BeginState(PreviousStateName);
|
|
if(Role == Role_Authority)
|
|
{
|
|
UnlockClientFire();
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
simulated function KFProjectile SpawnProjectile(class<KFProjectile> KFProjClass, vector RealStartLoc, vector AimDir)
|
|
{
|
|
local KFProj_HRG_BallisticBouncer BouncingProj;
|
|
|
|
BouncingProj = KFProj_HRG_BallisticBouncer(super.SpawnProjectile(KFProjClass, RealStartLoc, AimDir));
|
|
//Calc and set scaling values
|
|
if (BouncingProj != none)
|
|
{
|
|
ChargePercentage = FMax(0.1, ChargePercentage);
|
|
FXScalingFactorByCharge = FMax(0.1, FXScalingFactorByCharge);
|
|
BouncingProj.SetInheritedScale(FXScalingFactorByCharge, ChargePercentage);
|
|
return BouncingProj;
|
|
}
|
|
|
|
return none;
|
|
}
|
|
|
|
simulated function CauseMuzzleFlash(byte FireModeNum)
|
|
{
|
|
local vector vec;
|
|
|
|
if (MuzzleFlash == None)
|
|
{
|
|
AttachMuzzleFlash();
|
|
}
|
|
|
|
if (MuzzleFlash != none)
|
|
{
|
|
vec.X = ChargePercentage;
|
|
vec.Y = ChargePercentage;
|
|
vec.Z = ChargePercentage;
|
|
|
|
MuzzleFlash.MuzzleFlash.PSC.SetVectorParameter(name("Charge"), vec);
|
|
MuzzleFlash.CauseMuzzleFlash(FireModeNum);
|
|
}
|
|
|
|
super.CauseMuzzleFlash(FireModeNum);
|
|
}
|
|
|
|
simulated function int GetChargeLevel()
|
|
{
|
|
return Min(ChargeTime / ValueIncreaseTime, MaxChargeLevel);
|
|
}
|
|
|
|
/****************************************************************
|
|
|
|
PAWN ADJUST DAMAGE
|
|
|
|
****************************************************************/
|
|
|
|
// increase the instant hit damage based on the charge level
|
|
simulated function int GetModifiedDamage(byte FireModeNum, optional vector RayDir)
|
|
{
|
|
local int ModifiedDamage;
|
|
ModifiedDamage = super.GetModifiedDamage(FireModeNum, RayDir);
|
|
return ModifiedDamage;
|
|
}
|
|
|
|
state WeaponSingleFiring
|
|
{
|
|
/** Get whether we should play the reload anim as well or not */
|
|
simulated function name GetWeaponFireAnim(byte FireModeNum)
|
|
{
|
|
if(bUsingSights)
|
|
{
|
|
return (bHasToLaunchEmptyAnim == false) ? SecondaryFireIronAnim : SecondaryFireIronAnimEmpty;
|
|
}
|
|
else
|
|
{
|
|
return (bHasToLaunchEmptyAnim == false) ? SecondaryFireIronAnim : SecondaryFireIronAnimEmpty;
|
|
}
|
|
}
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
//Gameplay Props
|
|
MaxChargeTime=0.6
|
|
AmmoIncreasePerCharge=1
|
|
ValueIncreaseTime=0.1
|
|
|
|
//FOR LERPING DAMANGE
|
|
MaxDamageByCharge=300
|
|
MinDamageByCharge=15
|
|
// FOV
|
|
Meshfov=80
|
|
MeshIronSightFOV=65 //52
|
|
PlayerIronSightFOV=50 //80
|
|
|
|
// Depth of field
|
|
DOF_FG_FocalRadius=150
|
|
DOF_FG_MaxNearBlurSize=1
|
|
|
|
// Content
|
|
PackageKey="HRG_BallisticBouncer"
|
|
FirstPersonMeshName="wep_1p_hrg_ballisticbouncer_mesh.Wep_1stP_HRG_BallisticBouncer_Rig"
|
|
FirstPersonAnimSetNames(0)="wep_1p_hrg_ballisticbouncer_anim.Wep_1stP_BallisticBouncer_Anim"
|
|
PickupMeshName="wep_3p_hrg_ballisticbouncer_mesh.Wep_3rdP_HRG_BallisticBouncer_Pickup"
|
|
AttachmentArchetypeName="wep_hrg_ballisticbouncer_arch.Wep_HRG_BallisticBouncer_3P"
|
|
MuzzleFlashTemplateName="WEP_HRG_BallisticBouncer_ARCH.Wep_HRG_BallisticBouncer_MuzzleFlash"
|
|
|
|
Begin Object Name=FirstPersonMesh
|
|
// new anim tree with skelcontrol to rotate cylinders
|
|
AnimTreeTemplate=AnimTree'WEP_HRG_BallisticBouncer_ARCH.WEP_1stP_Animtree_HRG_BallisticBouncer'
|
|
End Object
|
|
|
|
// Zooming/Position
|
|
PlayerViewOffset=(X=0.0,Y=12,Z=-1)
|
|
IronSightPosition=(X=0,Y=0,Z=0)
|
|
|
|
// Controls the rotation when Hans(the bastard) grabs you
|
|
QuickWeaponDownRotation=(Pitch=-19192,Yaw=-11500,Roll=16384) // (Pitch=-19192,Yaw=-11000,Roll=16384)
|
|
|
|
// Ammo
|
|
MagazineCapacity[0]=18
|
|
SpareAmmoCapacity[0]=162
|
|
InitialSpareMags[0]=3 //2
|
|
AmmoPickupScale[0]=1.5 //1 //0.75
|
|
bCanBeReloaded=true
|
|
bReloadFromMagazine=true
|
|
|
|
// Recoil
|
|
maxRecoilPitch=180
|
|
minRecoilPitch=140
|
|
maxRecoilYaw=150
|
|
minRecoilYaw=-150
|
|
RecoilRate=0.085
|
|
RecoilMaxYawLimit=500
|
|
RecoilMinYawLimit=65035
|
|
RecoilMaxPitchLimit=900
|
|
RecoilMinPitchLimit=65035
|
|
RecoilISMaxYawLimit=75
|
|
RecoilISMinYawLimit=65460
|
|
RecoilISMaxPitchLimit=375
|
|
RecoilISMinPitchLimit=65460
|
|
RecoilViewRotationScale=0.25
|
|
IronSightMeshFOVCompensationScale=1.5
|
|
HippedRecoilModifier=1.5
|
|
|
|
// Inventory
|
|
InventorySize=5
|
|
GroupPriority=80 //75
|
|
WeaponSelectTexture=Texture2D'wep_ui_hrg_ballisticbouncer_tex.UI_WeaponSelect_HRG_BallisticBouncer'
|
|
|
|
// DEFAULT_FIREMODE
|
|
//FireModeIconPaths(DEFAULT_FIREMODE)=Texture2D'ui_firemodes_tex.UI_FireModeSelect_Grenade' //@TODO: Replace me
|
|
FireModeIconPaths(DEFAULT_FIREMODE)=Texture2D'ui_firemodes_tex.UI_FireModeSelect_ShotgunSingle'
|
|
FiringStatesArray(DEFAULT_FIREMODE)=MineReconstructorCharge
|
|
WeaponFireTypes(DEFAULT_FIREMODE)=EWFT_Projectile
|
|
WeaponProjectiles(DEFAULT_FIREMODE)=class'KFProj_HRG_BallisticBouncer'
|
|
FireInterval(DEFAULT_FIREMODE)=+0.223 //+0.33
|
|
InstantHitDamage(DEFAULT_FIREMODE)=100
|
|
PenetrationPower(DEFAULT_FIREMODE)=0.0;
|
|
InstantHitDamageTypes(DEFAULT_FIREMODE)=class'KFDT_Bludgeon_HRG_BallisticBouncer_Shot'
|
|
FireOffset=(X=39,Y=4.5,Z=-10)
|
|
|
|
// ALT_FIREMODE
|
|
FiringStatesArray(ALTFIRE_FIREMODE)=WeaponFiring
|
|
WeaponFireTypes(ALTFIRE_FIREMODE)=EWFT_None
|
|
|
|
// BASH_FIREMODE
|
|
InstantHitDamageTypes(BASH_FIREMODE)=class'KFDT_Bludgeon_HRG_BallisticBouncer'
|
|
InstantHitDamage(BASH_FIREMODE)=27
|
|
|
|
// Fire Effects
|
|
WeaponFireSnd(DEFAULT_FIREMODE)=(DefaultCue=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_3P_Start', FirstPersonCue=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_1P_Start')
|
|
WeaponFireLoopEndSnd(DEFAULT_FIREMODE)=(DefaultCue=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_3P_Shoot', FirstPersonCue=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_1P_Shoot')
|
|
FullyChargedSound=(DefaultCue = AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_Charged_3P', FirstPersonCue=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_Charged')
|
|
|
|
WeaponDryFireSnd(DEFAULT_FIREMODE)=AkEvent'WW_WEP_HRG_BallisticBouncer.Play_WEP_HRG_BallisticBouncer_DryFire'
|
|
|
|
// Advanced (High RPM) Fire Effects
|
|
bLoopingFireAnim(DEFAULT_FIREMODE)=true
|
|
bLoopingFireSnd(DEFAULT_FIREMODE)=true
|
|
SingleFireSoundIndex=FIREMODE_NONE
|
|
|
|
// Attachments
|
|
bHasIronSights=true
|
|
bHasFlashlight=false
|
|
|
|
AssociatedPerkClasses(0)= class'KFPerk_Support'
|
|
|
|
WeaponFireWaveForm=ForceFeedbackWaveform'FX_ForceFeedback_ARCH.Gunfire.Weak_Recoil'
|
|
|
|
ChargedEffect=ParticleSystem'WEP_HRG_BallisticBouncer_EMIT.FX_Mine_HRG_BallisticBouncer_FullCharge'
|
|
|
|
FullChargedTimerInterval=2.0f
|
|
|
|
// Weapon Upgrade stat boosts
|
|
//WeaponUpgrades[1]=(IncrementDamage=1.1f,IncrementWeight=1)
|
|
|
|
WeaponUpgrades[1]=(Stats=((Stat=EWUS_Damage0, Scale=1.15f), (Stat=EWUS_Weight, Add=1)))
|
|
WeaponUpgrades[2]=(Stats=((Stat=EWUS_Damage0, Scale=1.3f), (Stat=EWUS_Weight, Add=2)))
|
|
|
|
FXScalingFactorByCharge = 0;
|
|
MinScale=0.5
|
|
MaxScale=1.5
|
|
|
|
bBlocked = false;
|
|
|
|
bAllowClientAmmoTracking = false;
|
|
|
|
ChargeStaticMesh = StaticMesh'WEP_HRG_BallisticBouncer_EMIT.HRG_BallisticBouncer_ball_MESH'
|
|
MinProjPlaceholderScale = 2.0f;
|
|
MaxProjPlaceholderScale = 3.0f;
|
|
|
|
UseFixedPhysicalFireLocation=true
|
|
}
|