861 lines
24 KiB
Ucode
861 lines
24 KiB
Ucode
class ZombieExplosivesPoundOS extends KFMonsterOS;
|
|
|
|
var class<Projectile> GunnerProjClass;
|
|
var bool bClientGLing;
|
|
var int GLFireCounter;
|
|
var bool bFireAtWill,bGLing;
|
|
var float LastGLTime;
|
|
var vector TraceHitPos;
|
|
var Emitter mTracer,mMuzzleFlash;
|
|
var() float GLFireRate;
|
|
var() int GLFireBurst;
|
|
var() float GLFireInterval;
|
|
var bool bCharging;
|
|
var float DistBeforeSaw;
|
|
var bool bHasRaged;
|
|
var bool bNerfed;
|
|
|
|
replication
|
|
{
|
|
reliable if( Role==ROLE_Authority )
|
|
TraceHitPos,bGLing,bCharging;
|
|
}
|
|
|
|
function vector ComputeTrajectoryByTime( vector StartPosition, vector EndPosition, float fTimeEnd )
|
|
{
|
|
local vector NewVelocity;
|
|
|
|
NewVelocity = super.ComputeTrajectoryByTime( StartPosition, EndPosition, fTimeEnd );
|
|
|
|
if( PhysicsVolume.IsA( 'KFPhysicsVolume' ) && StartPosition.Z < EndPosition.Z )
|
|
{
|
|
if( PhysicsVolume.Gravity.Z < class'PhysicsVolume'.default.Gravity.Z )
|
|
{
|
|
if( Mass > 900 )
|
|
{
|
|
NewVelocity.Z += 90;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NewVelocity;
|
|
}
|
|
|
|
simulated function PostBeginPlay()
|
|
{
|
|
if( Role < ROLE_Authority )
|
|
return;
|
|
|
|
if (Level.Game != none)
|
|
{
|
|
if(!bNerfed)
|
|
{
|
|
if( Level.Game.GameDifficulty < 2.0 )
|
|
{
|
|
GLFireBurst = default.GLFireBurst * 0.5;
|
|
GLFireRate = default.GLFireRate * 1.66;
|
|
}
|
|
else if( Level.Game.GameDifficulty < 4.0 )
|
|
{
|
|
GLFireBurst = default.GLFireBurst * 1.0;
|
|
GLFireRate = default.GLFireRate * 1.0;
|
|
}
|
|
else if( Level.Game.GameDifficulty < 5.0 )
|
|
{
|
|
GLFireBurst = default.GLFireBurst * 1.5;
|
|
GLFireRate = default.GLFireRate * 0.8;
|
|
}
|
|
else
|
|
{
|
|
GLFireBurst = default.GLFireBurst * 2.0;
|
|
GLFireRate = default.GLFireRate * 0.5;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
GLFireInterval = default.GLFireInterval * 0.6;
|
|
GLFireBurst = default.GLFireBurst * 0.5;
|
|
GLFireRate = default.GLFireRate;
|
|
}
|
|
}
|
|
|
|
super.PostBeginPlay();
|
|
}
|
|
|
|
simulated Function PostNetBeginPlay()
|
|
{
|
|
EnableChannelNotify ( 1,1);
|
|
AnimBlendParams(1, 1.0, 0.0,, 'Bip01 Spine1');
|
|
super.PostNetBeginPlay();
|
|
TraceHitPos = vect(0,0,0);
|
|
bNetNotify = true;
|
|
}
|
|
|
|
simulated function PostNetReceive()
|
|
{
|
|
if (bCharging)
|
|
MovementAnims[0]='PoundRun';
|
|
else if(!(bCrispified && bBurnified))
|
|
MovementAnims[0]=default.MovementAnims[0];
|
|
|
|
if(bClientGLing != bGLing)
|
|
{
|
|
bClientGLing = bGLing;
|
|
|
|
if( bGLing )
|
|
{
|
|
IdleHeavyAnim='RangedFireMG';
|
|
IdleRifleAnim='RangedFireMG';
|
|
IdleCrouchAnim='RangedFireMG';
|
|
IdleWeaponAnim='RangedFireMG';
|
|
IdleRestAnim='RangedFireMG';
|
|
}
|
|
else
|
|
{
|
|
IdleHeavyAnim='RangedIdle';
|
|
IdleRifleAnim='RangedIdle';
|
|
IdleCrouchAnim='RangedIdle';
|
|
IdleWeaponAnim='RangedIdle';
|
|
IdleRestAnim='RangedIdle';
|
|
}
|
|
}
|
|
|
|
if( TraceHitPos!=vect(0,0,0) )
|
|
{
|
|
AddTraceHitFX(TraceHitPos);
|
|
TraceHitPos = vect(0,0,0);
|
|
}
|
|
}
|
|
|
|
// This zed has been taken control of. Boost its health and speed
|
|
function SetMindControlled(bool bNewMindControlled)
|
|
{
|
|
if( bNewMindControlled )
|
|
{
|
|
NumZCDHits++;
|
|
|
|
// if we hit him a couple of times, make him rage!
|
|
if( NumZCDHits > 1 )
|
|
{
|
|
if( !IsInState('ChargeToMarker') )
|
|
{
|
|
GotoState('ChargeToMarker');
|
|
}
|
|
else
|
|
{
|
|
NumZCDHits = 1;
|
|
if( IsInState('ChargeToMarker') )
|
|
{
|
|
GotoState('');
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( IsInState('ChargeToMarker') )
|
|
{
|
|
GotoState('');
|
|
}
|
|
}
|
|
|
|
if( bNewMindControlled != bZedUnderControl )
|
|
{
|
|
SetGroundSpeed(OriginalGroundSpeed * 1.25);
|
|
Health *= 1.25;
|
|
HealthMax *= 1.25;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
NumZCDHits=0;
|
|
}
|
|
|
|
bZedUnderControl = bNewMindControlled;
|
|
}
|
|
|
|
// Handle the zed being commanded to move to a new location
|
|
function GivenNewMarker()
|
|
{
|
|
if( bCharging && NumZCDHits > 1 )
|
|
{
|
|
GotoState('RunningToMarker');
|
|
}
|
|
else
|
|
{
|
|
GotoState('');
|
|
}
|
|
}
|
|
|
|
simulated function SetBurningBehavior()
|
|
{
|
|
if( Role == Role_Authority && IsInState('RunningState') )
|
|
{
|
|
super.SetBurningBehavior();
|
|
GotoState('');
|
|
}
|
|
|
|
super.SetBurningBehavior();
|
|
}
|
|
|
|
function bool FlipOver()
|
|
{
|
|
if( Physics==PHYS_Falling )
|
|
{
|
|
SetPhysics(PHYS_Walking);
|
|
}
|
|
|
|
bShotAnim = true;
|
|
//Explosive Pound has a unique animation for getting stunned
|
|
GoToState('');
|
|
SetAnimAction('StunState');
|
|
HandleWaitForAnim('StunState');
|
|
Acceleration = vect(0, 0, 0);
|
|
Velocity.X = 0;
|
|
Velocity.Y = 0;
|
|
KFMonsterController(Controller).Focus = none;
|
|
KFMonsterController(Controller).FocalPoint = KFMonsterController(Controller).LastSeenPos;
|
|
Controller.GoToState('WaitForAnim');
|
|
KFMonsterController(Controller).bUseFreezeHack = true;
|
|
return true;
|
|
}
|
|
|
|
function StartCharging()
|
|
{
|
|
GoToState('');
|
|
SetAnimAction('PoundRage');
|
|
HandleWaitForAnim('PoundRage');
|
|
Acceleration = vect(0,0,0);
|
|
Velocity.X = 0;
|
|
Velocity.Y = 0;
|
|
bShotAnim = true;
|
|
Controller.GoToState('WaitForAnim');
|
|
KFMonsterController(Controller).bUseFreezeHack = True;
|
|
bHasRaged = true;
|
|
}
|
|
|
|
simulated function bool HitCanInterruptAction()
|
|
{
|
|
if( bShotAnim )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
simulated function Destroyed()
|
|
{
|
|
if( mTracer!=none )
|
|
mTracer.Destroy();
|
|
|
|
if( mMuzzleFlash!=none )
|
|
mMuzzleFlash.Destroy();
|
|
|
|
super.Destroyed();
|
|
}
|
|
|
|
function RangedAttack(Actor A)
|
|
{
|
|
local float Dist;
|
|
|
|
Dist = VSize(Controller.Target.Location-Location);
|
|
|
|
if ( bShotAnim || Physics == PHYS_Swimming)
|
|
return;
|
|
else if ( Dist < (MeleeRange - DistBeforeSaw + CollisionRadius + A.CollisionRadius) && CanAttack(A) )
|
|
{
|
|
bShotAnim = true;
|
|
SetAnimAction('Claw');
|
|
PlaySound(sound'Claw2s', SLOT_Interact);
|
|
}
|
|
|
|
if( !bShotAnim && !bDecapitated )
|
|
{
|
|
if ( float(Health)/HealthMax < 0.5 )
|
|
{
|
|
GoToState('RunningState');
|
|
if(!bHasRaged)
|
|
StartCharging();
|
|
}
|
|
}
|
|
|
|
if ( !bWaitForAnim && !bShotAnim && !bDecapitated && LastGLTime<Level.TimeSeconds && Dist < 5000 && !bCharging)
|
|
{
|
|
LastGLTime = Level.TimeSeconds + GLFireInterval + (FRand() *2.0);
|
|
bShotAnim = true;
|
|
Acceleration = vect(0,0,0);
|
|
SetAnimAction('RangedPreFireMG');
|
|
HandleWaitForAnim('RangedPreFireMG');
|
|
|
|
GLFireCounter = GLFireBurst;
|
|
GoToState('FireGrenades');
|
|
}
|
|
}
|
|
|
|
state RunningState
|
|
{
|
|
//Fixes slow charge for charging zeds
|
|
//Credits:NikC for forum link, aleat0r for the code
|
|
simulated function float GetOriginalGroundSpeed()
|
|
{
|
|
return 3.0 * OriginalGroundSpeed;
|
|
}
|
|
|
|
simulated function SetZappedBehavior()
|
|
{
|
|
Global.SetZappedBehavior();
|
|
GoToState('');
|
|
}
|
|
|
|
function bool CanSpeedAdjust()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
function BeginState()
|
|
{
|
|
if( bZapped )
|
|
{
|
|
GoToState('');
|
|
}
|
|
else
|
|
{
|
|
SetGroundSpeed(OriginalGroundSpeed * 3.0);
|
|
bCharging = true;
|
|
if( Level.NetMode!=NM_DedicatedServer )
|
|
PostNetReceive();
|
|
|
|
OnlineHeadshotOffset.Z = 51;
|
|
OnlineHeadshotOffset.X = 38;
|
|
OnlineHeadshotOffset.Y = -5;
|
|
NetUpdateTime = Level.TimeSeconds - 1;
|
|
}
|
|
}
|
|
|
|
function EndState()
|
|
{
|
|
if( !bZapped )
|
|
{
|
|
SetGroundSpeed(GetOriginalGroundSpeed());
|
|
}
|
|
bCharging = false;
|
|
if( Level.NetMode!=NM_DedicatedServer )
|
|
PostNetReceive();
|
|
OnlineHeadshotOffset = default.OnlineHeadshotOffset;
|
|
}
|
|
|
|
function RemoveHead()
|
|
{
|
|
GoToState('');
|
|
Global.RemoveHead();
|
|
}
|
|
|
|
function RangedAttack(Actor A)
|
|
{
|
|
local float Dist;
|
|
|
|
Dist = VSize(A.Location - Location);
|
|
DistBeforeSaw = 20.0;
|
|
|
|
if ( bShotAnim || Physics == PHYS_Swimming)
|
|
return;
|
|
else if ( Dist < (MeleeRange - DistBeforeSaw + CollisionRadius + A.CollisionRadius) && CanAttack(A) )
|
|
{
|
|
if(FRand() < 0.05 )
|
|
{
|
|
bShotAnim = true;
|
|
Acceleration = vect(0,0,0);
|
|
SetAnimAction('RangedPreFireMG');
|
|
HandleWaitForAnim('RangedPreFireMG');
|
|
|
|
GLFireCounter = 2;
|
|
GoToState('FireGrenades');
|
|
}
|
|
else
|
|
{
|
|
if(Level.Game.GameDifficulty < 5.0)
|
|
SetAnimAction(MeleeAnims[Rand(2)]);
|
|
else
|
|
SetAnimAction(MeleeAnims[1]);
|
|
bShotAnim = true;
|
|
PlaySound(sound'Claw2s', SLOT_Interact);
|
|
GoToState('');
|
|
}
|
|
OnlineHeadshotOffset = default.OnlineHeadshotOffset;
|
|
}
|
|
}
|
|
|
|
function Tick( float Delta )
|
|
{
|
|
if( Role == ROLE_Authority && bShotAnim)
|
|
{
|
|
if( LookTarget!=None )
|
|
{
|
|
Acceleration = 10000 * Normal(LookTarget.Location - Location);
|
|
}
|
|
}
|
|
|
|
global.Tick(Delta);
|
|
}
|
|
}
|
|
|
|
state RunningToMarker extends RunningState{}
|
|
|
|
function TakeDamage( int Damage, Pawn InstigatedBy, Vector Hitlocation, Vector Momentum, class<DamageType> damageType, optional int HitIndex)
|
|
{
|
|
local bool bIsHeadShot;
|
|
bIsHeadShot = IsHeadShot(Hitlocation, normal(Momentum), 1.0);
|
|
|
|
if ( Level.Game.GameDifficulty >= 5.0 && bIsHeadshot && (class<DamTypeCrossbow>(damageType) != none || class<DamTypeCrossbowHeadShot>(damageType) != none) )
|
|
{
|
|
Damage *= 0.5; // Half Damage from Crossbow HS
|
|
}
|
|
|
|
if(DamageType == class 'DamTypeFrag' || DamageType == class 'DamTypePipeBomb' || DamageType == class 'DamTypeM79Grenade' ||
|
|
DamageType == class 'DamTypeM32Grenade' || DamageType == class 'DamTypeM203Grenade' || DamageType == class 'DamTypeSPGrenade' ||
|
|
DamageType == class 'DamTypeSealSquealExplosion' || DamageType == class 'DamTypeSeekerSixRocket')
|
|
|
|
Damage *= 0.5; // Half damage from explosives
|
|
|
|
Super.takeDamage(Damage, instigatedBy, hitLocation, momentum, damageType, HitIndex);
|
|
}
|
|
|
|
simulated function AddTraceHitFX( vector HitPos )
|
|
{
|
|
local vector Start,SpawnVel,SpawnDir;
|
|
local float hitDist;
|
|
|
|
Start = GetBoneCoords('FireBone').Origin;
|
|
if( mTracer==none )
|
|
mTracer = Spawn(class'KFMod.KFNewTracer',,,Start);
|
|
else mTracer.SetLocation(Start);
|
|
|
|
if( mMuzzleFlash==none )
|
|
{
|
|
mMuzzleFlash = Spawn(class'NewMinigunMFlashOS');
|
|
AttachToBone(mMuzzleFlash, 'FireBone');
|
|
}
|
|
else mMuzzleFlash.SpawnParticle(1);
|
|
|
|
hitDist = VSize(HitPos - Start) - 50.f;
|
|
|
|
if( hitDist>10 )
|
|
{
|
|
SpawnDir = Normal(HitPos - Start);
|
|
SpawnVel = SpawnDir * 10000.f;
|
|
mTracer.Emitters[0].StartVelocityRange.X.Min = SpawnVel.X;
|
|
mTracer.Emitters[0].StartVelocityRange.X.Max = SpawnVel.X;
|
|
mTracer.Emitters[0].StartVelocityRange.Y.Min = SpawnVel.Y;
|
|
mTracer.Emitters[0].StartVelocityRange.Y.Max = SpawnVel.Y;
|
|
mTracer.Emitters[0].StartVelocityRange.Z.Min = SpawnVel.Z;
|
|
mTracer.Emitters[0].StartVelocityRange.Z.Max = SpawnVel.Z;
|
|
mTracer.Emitters[0].LifetimeRange.Min = hitDist / 10000.f;
|
|
mTracer.Emitters[0].LifetimeRange.Max = mTracer.Emitters[0].LifetimeRange.Min;
|
|
mTracer.SpawnParticle(1);
|
|
}
|
|
|
|
Instigator = self;
|
|
|
|
if( HitPos != vect(0,0,0) )
|
|
{
|
|
Spawn(class'ROBulletHitEffect',,, HitPos, Rotator(Normal(HitPos - Start)));
|
|
}
|
|
}
|
|
|
|
function FireGLShot()
|
|
{
|
|
local vector X,Y,Z, FireStart;
|
|
local rotator FireRotation;
|
|
local float Dist;
|
|
|
|
//Log spam prevention(?)
|
|
if(Controller.Target != None)
|
|
{
|
|
Controller.Target = Controller.Target;
|
|
}
|
|
|
|
Dist = VSize(Controller.Target.Location-Location);
|
|
|
|
GLFireCounter--;
|
|
|
|
//Randomness in leading target
|
|
if(FRand() > 0.5 && !bNerfed)
|
|
SavedFireProperties.bLeadTarget = true;
|
|
else
|
|
SavedFireProperties.bLeadTarget = false;
|
|
|
|
if( Controller!=none && KFDoorMover(Controller.Target)!=none )
|
|
{
|
|
Controller.Target.TakeDamage(22,self,Location,vect(0,0,0),class'DamTypeVomit');
|
|
return;
|
|
}
|
|
|
|
GetAxes(Rotation,X,Y,Z);
|
|
FireStart = GetBoneCoords('FireBone').Origin;
|
|
|
|
if ( !SavedFireProperties.bInitialized )
|
|
{
|
|
SavedFireProperties.AmmoClass = class'SkaarjAmmo';
|
|
SavedFireProperties.ProjectileClass = GunnerProjClass;
|
|
SavedFireProperties.WarnTargetPct = 1;
|
|
SavedFireProperties.MaxRange = 65535;
|
|
SavedFireProperties.bTossed = false;
|
|
SavedFireProperties.bTrySplash = true;
|
|
SavedFireProperties.bLeadTarget = false;
|
|
SavedFireProperties.bInstantHit = false;
|
|
SavedFireProperties.bInitialized = true;
|
|
}
|
|
|
|
ToggleAuxCollision(false);
|
|
|
|
FireRotation = Controller.AdjustAim(SavedFireProperties,FireStart,600);
|
|
|
|
Spawn(GunnerProjClass,,,FireStart,FireRotation);
|
|
PlaySound(sound'KF_M79Snd.M79_Fire',SLOT_Misc,2,,1400,0.9+FRand()*0.2);
|
|
|
|
ToggleAuxCollision(true);
|
|
}
|
|
|
|
simulated function AnimEnd( int Channel )
|
|
{
|
|
local name Sequence;
|
|
local float Frame, Rate;
|
|
|
|
if( Level.NetMode==NM_Client && bGLing )
|
|
{
|
|
GetAnimParams( Channel, Sequence, Frame, Rate );
|
|
|
|
if( Sequence != 'RangedPreFireMG' && Sequence != 'RangedFireMG' )
|
|
{
|
|
super.AnimEnd(Channel);
|
|
return;
|
|
}
|
|
|
|
PlayAnim('RangedFireMG');
|
|
bWaitForAnim = true;
|
|
bShotAnim = true;
|
|
IdleTime = Level.TimeSeconds;
|
|
}
|
|
else super.AnimEnd(Channel);
|
|
}
|
|
|
|
state FireGrenades
|
|
{
|
|
function RangedAttack(Actor A)
|
|
{
|
|
//Log spam prevention(?)
|
|
if(Controller.Target != None)
|
|
{
|
|
Controller.Target = A;
|
|
Controller.Focus = A;
|
|
}
|
|
}
|
|
|
|
simulated function Tick(float DeltaTime)
|
|
{
|
|
local float Dist;
|
|
local float Speed, Timer, TossZ;
|
|
local float AdditionalSpeed;
|
|
local float TimerDivizor;
|
|
|
|
//Log spam prevention
|
|
if(Controller.Target != None)
|
|
{
|
|
Dist = VSize(Controller.Target.Location-Location);
|
|
TossZ = Controller.Target.Location.Z - Location.Z;
|
|
}
|
|
|
|
AdditionalSpeed = 250;
|
|
TimerDivizor = 1250;
|
|
|
|
Speed = Dist + AdditionalSpeed;
|
|
Timer = Dist / TimerDivizor;
|
|
|
|
if(TossZ >= 200)
|
|
TossZ = 200;
|
|
else if(TossZ <=100)
|
|
TossZ = 100;
|
|
|
|
class'GunnerGLProjectile'.default.Speed = Speed;
|
|
class'GunnerGLProjectile'.default.ExplodeTimer = 1 + (FRand() - 0.5) + Timer;
|
|
class'GunnerGLProjectile'.default.TossZ = TossZ;
|
|
|
|
if(class'GunnerGLProjectile'.default.ExplodeTimer >= 1.75)
|
|
class'GunnerGLProjectile'.default.ExplodeTimer = 1.75;
|
|
|
|
if(bNerfed)
|
|
class'GunnerGLProjectile'.default.ExplodeTimer = 1.5;
|
|
|
|
if(Dist < 500)
|
|
{
|
|
SavedFireProperties.bLeadTarget = true;
|
|
AdditionalSpeed = 700;
|
|
}
|
|
|
|
if(Dist > 3500 )
|
|
AdditionalSpeed = 0;
|
|
|
|
if(float(Health)/HealthMax < 0.5 && !bHasRaged )
|
|
{
|
|
StartCharging();
|
|
}
|
|
|
|
super.Tick(DeltaTime);
|
|
}
|
|
|
|
function EndState()
|
|
{
|
|
TraceHitPos = vect(0,0,0);
|
|
bGLing = false;
|
|
|
|
SoundVolume=default.SoundVolume;
|
|
SoundRadius=default.SoundRadius;
|
|
GLFireCounter=0;
|
|
|
|
LastGLTime = Level.TimeSeconds + GLFireInterval + (FRand() *2.0);
|
|
}
|
|
|
|
function BeginState()
|
|
{
|
|
bFireAtWill = false;
|
|
Acceleration = vect(0,0,0);
|
|
bGLing = true;
|
|
}
|
|
|
|
function AnimEnd( int Channel )
|
|
{
|
|
if( GLFireCounter <= 0 )
|
|
{
|
|
bShotAnim = true;
|
|
Acceleration = vect(0,0,0);
|
|
SetAnimAction('RangedFireMGEnd');
|
|
HandleWaitForAnim('RangedFireMGEnd');
|
|
GoToState('');
|
|
}
|
|
else
|
|
{
|
|
if ( Controller.Enemy != none )
|
|
{
|
|
if ( Controller.LineOfSightTo(Controller.Enemy) && FastTrace(GetBoneCoords('FireBone').Origin,Controller.Enemy.Location))
|
|
{
|
|
Controller.Focus = Controller.Enemy;
|
|
Controller.FocalPoint = Controller.Enemy.Location;
|
|
}
|
|
|
|
Controller.Target = Controller.Enemy;
|
|
}
|
|
|
|
bFireAtWill = true;
|
|
bShotAnim = true;
|
|
Acceleration = vect(0,0,0);
|
|
|
|
SetAnimAction('RangedFireMG');
|
|
bWaitForAnim = true;
|
|
}
|
|
}
|
|
|
|
function bool NeedToTurnFor( rotator targ )
|
|
{
|
|
local int YawErr;
|
|
|
|
targ.Yaw = DesiredRotation.Yaw & 65535;
|
|
YawErr = (targ.Yaw - (Rotation.Yaw & 65535)) & 65535;
|
|
return !((YawErr < 2000) || (YawErr > 64535));
|
|
}
|
|
|
|
Begin:
|
|
While( true )
|
|
{
|
|
Acceleration = vect(0,0,0);
|
|
|
|
if( GLFireCounter <= 0 )
|
|
{
|
|
bShotAnim = true;
|
|
Acceleration = vect(0,0,0);
|
|
SetAnimAction('RangedFireMGEnd');
|
|
HandleWaitForAnim('RangedFireMGEnd');
|
|
GoToState('');
|
|
}
|
|
|
|
if( bFireAtWill )
|
|
FireGLShot();
|
|
Sleep(GLFireRate);
|
|
}
|
|
}
|
|
|
|
simulated function int DoAnimAction( name AnimName )
|
|
{
|
|
if(AnimName=='GoreAttack2' || AnimName=='GoreAttack1' ||AnimName=='RangedHitF' )
|
|
{
|
|
AnimBlendParams(1, 1.0, 0.0,, 'Bip01 Spine1');
|
|
PlayAnim(AnimName,, 0.0, 1);
|
|
return 1;
|
|
}
|
|
return super.DoAnimAction(AnimName);
|
|
}
|
|
|
|
simulated event SetAnimAction(name NewAction)
|
|
{
|
|
local int meleeAnimIndex;
|
|
|
|
if( NewAction=='' )
|
|
return;
|
|
|
|
if(NewAction == 'Claw')
|
|
{
|
|
meleeAnimIndex = Rand(3);
|
|
NewAction = meleeAnims[meleeAnimIndex];
|
|
CurrentDamtype = ZombieDamType[meleeAnimIndex];
|
|
}
|
|
|
|
ExpectingChannel = DoAnimAction(NewAction);
|
|
|
|
if( Controller != none )
|
|
{
|
|
ControllerExplosivePound(Controller).AnimWaitChannel = ExpectingChannel;
|
|
}
|
|
|
|
if( AnimNeedsWait(NewAction) )
|
|
{
|
|
bWaitForAnim = true;
|
|
}
|
|
|
|
if( Level.NetMode!=NM_Client )
|
|
{
|
|
AnimAction = NewAction;
|
|
bResetAnimAct = true;
|
|
ResetAnimActTime = Level.TimeSeconds+0.3;
|
|
}
|
|
}
|
|
|
|
simulated function HandleWaitForAnim( name NewAnim )
|
|
{
|
|
local float RageAnimDur;
|
|
|
|
Controller.GoToState('WaitForAnim');
|
|
RageAnimDur = GetAnimDuration(NewAnim);
|
|
|
|
ControllerExplosivePound(Controller).SetWaitForAnimTimout(RageAnimDur,NewAnim);
|
|
}
|
|
|
|
simulated function bool AnimNeedsWait(name TestAnim)
|
|
{
|
|
if( TestAnim == 'RangedFireMG' || TestAnim == 'RangedPreFireMG' || TestAnim == 'RangedFireMGEnd'
|
|
|| TestAnim == 'StunState' || TestAnim == 'PoundRage')
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static simulated function PreCacheMaterials(LevelInfo myLevel)
|
|
{
|
|
myLevel.AddPrecacheMaterial(Shader'KFOldSchoolZeds_Textures.Fleshpound.PoundBitsShader');
|
|
myLevel.AddPrecacheMaterial(Texture'KFOldSchoolZeds_Textures.GunPound.AutoTurretGunTex');
|
|
myLevel.AddPrecacheMaterial(Texture'KFOldSchoolZeds_Textures.GunPound.GunPoundSkin');
|
|
}
|
|
|
|
function OldPlayHit(float Damage, Pawn InstigatedBy, vector HitLocation, class<DamageType> damageType, vector Momentum, optional int HitIndex)
|
|
{
|
|
if(LastGLTime<Level.TimeSeconds + 1)
|
|
return;
|
|
else
|
|
super.OldPlayHit(Damage,InstigatedBy,HitLocation,damageType,Momentum,HitIndex);
|
|
}
|
|
|
|
defaultproperties
|
|
{
|
|
GunnerProjClass=Class'KFOldSchoolZeds.GunnerGLProjectile'
|
|
GLFireRate=0.750000
|
|
GLFireBurst=2
|
|
GLFireInterval=5.500000
|
|
MeleeAnims(0)="GoreAttack2"
|
|
MeleeAnims(1)="GoreAttack1"
|
|
MeleeAnims(2)="GoreAttack2"
|
|
MoanVoice=SoundGroup'KFOldSchoolZeds_Sounds.Fleshpound.Fleshpound_Speech'
|
|
BleedOutDuration=6.000000
|
|
ZapThreshold=1.250000
|
|
ZappedDamageMod=1.250000
|
|
bHarpoonToBodyStuns=False
|
|
ZombieFlag=1
|
|
MeleeDamage=20
|
|
damageForce=-200000
|
|
bFatAss=True
|
|
KFRagdollName="FleshPoundRag"
|
|
JumpSound=Sound'KFOldSchoolZeds_Sounds.Shared.Male_ZombieJump'
|
|
Intelligence=BRAINS_Mammal
|
|
bUseExtendedCollision=True
|
|
ColOffset=(Z=65.000000)
|
|
ColRadius=27.000000
|
|
ColHeight=25.000000
|
|
PlayerCountHealthScale=0.100000
|
|
BurningWalkFAnims(0)="RangedWalkF"
|
|
BurningWalkFAnims(1)="RangedWalkF"
|
|
BurningWalkFAnims(2)="RangedWalkF"
|
|
BurningWalkAnims(0)="RangedWalkF"
|
|
BurningWalkAnims(1)="RangedWalkF"
|
|
BurningWalkAnims(2)="RangedWalkF"
|
|
OnlineHeadshotOffset=(X=-8.000000,Y=7.000000,Z=77.000000)
|
|
OnlineHeadshotScale=1.200000
|
|
HeadHealth=650.000000
|
|
PlayerNumHeadHealthScale=0.050000
|
|
MotionDetectorThreat=2.000000
|
|
HitSound(0)=SoundGroup'KFOldSchoolZeds_Sounds.Shared.Male_ZombiePain'
|
|
DeathSound(0)=SoundGroup'KFOldSchoolZeds_Sounds.Shared.Male_ZombieDeath'
|
|
AmmunitionClass=Class'KFMod.BZombieAmmo'
|
|
ScoringValue=125
|
|
IdleHeavyAnim="RangedIdle"
|
|
IdleRifleAnim="RangedIdle"
|
|
MeleeRange=65.000000
|
|
GroundSpeed=80.000000
|
|
WaterSpeed=75.000000
|
|
HealthMax=1250.000000
|
|
Health=1250
|
|
HeadRadius=8.750000
|
|
HeadHeight=11.000000
|
|
AmbientSoundScaling=5.000000
|
|
MenuName="Flesh Pound Explosives Gunner"
|
|
ControllerClass=Class'KFOldSchoolZeds.ControllerExplosivePound'
|
|
MovementAnims(0)="RangedWalkF"
|
|
MovementAnims(1)="RangedWalkF"
|
|
MovementAnims(2)="RangedWalkF"
|
|
MovementAnims(3)="RangedWalkF"
|
|
TurnLeftAnim="RangedBossHitF"
|
|
TurnRightAnim="RangedBossHitF"
|
|
WalkAnims(0)="RangedWalkF"
|
|
WalkAnims(1)="RangedWalkF"
|
|
WalkAnims(2)="RangedWalkF"
|
|
WalkAnims(3)="RangedWalkF"
|
|
AirAnims(0)="RangedJumpInAir"
|
|
AirAnims(1)="RangedJumpInAir"
|
|
AirAnims(2)="RangedJumpInAir"
|
|
AirAnims(3)="RangedJumpInAir"
|
|
TakeoffAnims(0)="RangedJumpTakeOff"
|
|
TakeoffAnims(1)="RangedJumpTakeOff"
|
|
TakeoffAnims(2)="RangedJumpTakeOff"
|
|
TakeoffAnims(3)="RangedJumpTakeOff"
|
|
LandAnims(0)="RangedJumpLanded"
|
|
LandAnims(1)="RangedJumpLanded"
|
|
LandAnims(2)="RangedJumpLanded"
|
|
LandAnims(3)="RangedJumpLanded"
|
|
AirStillAnim="RangedJumpInAir"
|
|
TakeoffStillAnim="RangedJumpTakeOff"
|
|
IdleCrouchAnim="RangedIdle"
|
|
IdleWeaponAnim="RangedIdle"
|
|
IdleRestAnim="RangedIdle"
|
|
AmbientSound=Sound'KFOldSchoolZeds_Sounds.Scrake.Saw_Idle'
|
|
Mesh=SkeletalMesh'KFCharacterModelsOldSchool.ExplosivesPound'
|
|
PrePivot=(Z=2.000000)
|
|
Skins(0)=Shader'KFOldSchoolZeds_Textures.Fleshpound.PoundBitsShader'
|
|
Skins(1)=TexOscillator'KillingFloorWeapons.Chainsaw.SAWCHAIN'
|
|
Skins(2)=Texture'KFPatch2.BossGun'
|
|
Skins(3)=Shader'KFPatch2.LaserShader'
|
|
Skins(4)=Shader'KFCharacters.PoundBitsShader'
|
|
Skins(5)=Texture'KFOldSchoolZeds_Textures.clot.ClotSkinVariant2'
|
|
Skins(6)=Texture'KillingFloorWeapons.Chainsaw.ChainSawSkin3PZombie'
|
|
SoundRadius=200.000000
|
|
Mass=400.000000
|
|
RotationRate=(Yaw=45000,Roll=0)
|
|
}
|