mirror of
https://github.com/jmarshall23/DoomRTX.git
synced 2026-08-20 04:30:12 +02:00
Switched Doom 3 weapons to native.
This commit is contained in:
Justin Marshall
@@ -0,0 +1,355 @@
|
||||
// Weapon_BFG.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponBFG )
|
||||
END_CLASS
|
||||
|
||||
#define BFG_MINRELEASETIME 0.05
|
||||
#define BFG_FUSE 2.0
|
||||
#define BFG_SHORTFUSE 0.5
|
||||
#define BFG_MAXPOWER 4.0
|
||||
#define BFG_FIRERATE 4
|
||||
#define BFG_FIREDELAY 4
|
||||
#define BFG_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define BFG_IDLE_TO_LOWER 4
|
||||
#define BFG_IDLE_TO_FIRE 4
|
||||
#define BFG_IDLE_TO_RELOAD 4
|
||||
#define BFG_RAISE_TO_IDLE 4
|
||||
#define BFG_FIRE_TO_IDLE 4
|
||||
#define BFG_RELOAD_TO_IDLE 4
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponBFG::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
fuse_start = 0;
|
||||
fuse_end = 0;
|
||||
powerLevel = 0;
|
||||
fire_time = 0;
|
||||
spread = weapon->GetFloat( "spread" );
|
||||
owner->Event_SetGuiFloat( "powerlevel", 0 );
|
||||
owner->Event_SetGuiFloat( "overcharge", 0 );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponBFG::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, BFG_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponBFG::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponBFG::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
|
||||
if( !owner->AmmoInClip() )
|
||||
{
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle_empty" );
|
||||
owner->Event_WeaponOutOfAmmo();
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
owner->Event_WeaponReady();
|
||||
}
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponBFG::Fire( stateParms_t* parms )
|
||||
{
|
||||
float time_held;
|
||||
float power = 0.0f;
|
||||
float intensity;
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_FUSING,
|
||||
FIRE_SHORTFUSE,
|
||||
FIRE_SHORTFUSEWAIT,
|
||||
FIRE_FIRE,
|
||||
FIRE_FIRE_ANIMWAIT,
|
||||
FIRE_FIRE_COOLDOWN,
|
||||
FIRE_DONE
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire_begin", false );
|
||||
fuse_start = gameLocal.time;
|
||||
fuse_end = gameLocal.time + SEC2MS( BFG_FUSE );
|
||||
parms->stage = FIRE_FUSING;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_FUSING:
|
||||
if( !owner->IsFiring() )
|
||||
{
|
||||
parms->stage = FIRE_FIRE;
|
||||
}
|
||||
else if( gameLocal.time > gameLocal.time + SEC2MS( BFG_MINRELEASETIME ) && !owner->IsFiring() )
|
||||
{
|
||||
parms->stage = FIRE_SHORTFUSE;
|
||||
}
|
||||
else if( gameLocal.time >= fuse_end )
|
||||
{
|
||||
parms->stage = FIRE_SHORTFUSE;
|
||||
}
|
||||
else
|
||||
{
|
||||
powerLevel = ( gameLocal.time - fuse_start ) / BFG_FUSE;
|
||||
owner->Event_SetColor( powerLevel, powerLevel, powerLevel );
|
||||
owner->Event_SetGuiFloat( "powerlevel", powerLevel );
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_SHORTFUSE:
|
||||
if( owner->IsFiring() )
|
||||
{
|
||||
fuse_end = gameLocal.time + SEC2MS( BFG_SHORTFUSE );
|
||||
parms->stage = FIRE_SHORTFUSEWAIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
parms->stage = FIRE_FIRE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_SHORTFUSEWAIT:
|
||||
if( !owner->IsFiring() || gameLocal.time >= fuse_end )
|
||||
{
|
||||
powerLevel = ( gameLocal.time - fuse_start ) / BFG_FUSE;
|
||||
owner->Event_SetGuiFloat( "powerlevel", powerLevel );
|
||||
parms->stage = FIRE_FIRE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_FIRE:
|
||||
if( gameLocal.time >= fuse_end )
|
||||
{
|
||||
OverCharge();
|
||||
parms->stage = FIRE_DONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
time_held = gameLocal.time - fuse_start;
|
||||
if( power > BFG_MAXPOWER )
|
||||
{
|
||||
power = BFG_MAXPOWER;
|
||||
}
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
fire_time = gameLocal.time;
|
||||
|
||||
owner->Event_LaunchProjectiles( BFG_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
parms->stage = FIRE_FIRE_ANIMWAIT;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_FIRE_ANIMWAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, BFG_FIRE_TO_IDLE ) )
|
||||
{
|
||||
parms->stage = FIRE_FIRE_COOLDOWN;
|
||||
}
|
||||
else
|
||||
{
|
||||
intensity = 1 - ( ( gameLocal.time - fire_time ) / 0.5 );
|
||||
if( intensity < 0 )
|
||||
{
|
||||
intensity = 0;
|
||||
}
|
||||
owner->Event_SetColor( intensity, intensity, intensity );
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_FIRE_COOLDOWN:
|
||||
if( powerLevel <= 0 )
|
||||
{
|
||||
parms->stage = FIRE_DONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
powerLevel -= SEC2MS( 0.05 ); // TODO: DELTA TIME THIS!!
|
||||
owner->Event_SetGuiFloat( "powerlevel", powerLevel );
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_DONE:
|
||||
owner->Event_SetGuiFloat( "powerlevel", 0 );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::OverCharge
|
||||
===============
|
||||
*/
|
||||
|
||||
void rvmWeaponBFG::OverCharge()
|
||||
{
|
||||
idStr entname;
|
||||
idEntity* explosion;
|
||||
idVec3 forward;
|
||||
idAngles angles;
|
||||
idPlayer* player;
|
||||
|
||||
player = owner->GetOwner();
|
||||
|
||||
owner->Event_AllowDrop( false );
|
||||
owner->Event_UseAmmo( owner->ClipSize() );
|
||||
|
||||
angles = player->viewAngles;
|
||||
forward = angles.ToForward();
|
||||
|
||||
entname = owner->GetKey( "def_overcharge" );
|
||||
//explosion = sys.spawn(entname);
|
||||
{
|
||||
idDict spawnArgs;
|
||||
|
||||
spawnArgs.Set( "classname", entname );
|
||||
gameLocal.SpawnEntityDef( spawnArgs, &explosion );
|
||||
}
|
||||
explosion->Event_SetOrigin( owner->GetOrigin() + forward * 16 );
|
||||
explosion->Event_SetShaderParm( /*SHADERPARM_TIMEOFFSET*/4, -gameLocal.time );
|
||||
gameLocal.DelayRemoveEntity( explosion, 2 );
|
||||
|
||||
owner->Event_StartSound( "snd_explode", SND_CHANNEL_ANY, false );
|
||||
gameLocal.RadiusDamage( owner->GetOrigin(), owner, owner->GetOwner(), nullptr, nullptr, "damage_bfg_overcharge", 1.0 );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponBFG::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponBFG::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
// Weapon_bfg.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponBFG : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponBFG );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void OverCharge();
|
||||
|
||||
float spread;
|
||||
|
||||
float fuse_start;
|
||||
float fuse_end;
|
||||
float powerLevel;
|
||||
float fire_time;
|
||||
};
|
||||
@@ -0,0 +1,324 @@
|
||||
// Weapon_chaingun.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponChainGun )
|
||||
END_CLASS
|
||||
|
||||
#define CHAINGUN_FIRE_SKIPFRAMES 7 // 6 shots per second
|
||||
#define CHAINGUN_LOWAMMO 10
|
||||
#define CHAINGUN_NUMPROJECTILES 1
|
||||
#define CHAINGUN_BARREL_SPEED ( 60 * ( USERCMD_HZ / CHAINGUN_FIRE_SKIPFRAMES ) )
|
||||
#define CHAINGUN_BARREL_ACCEL_TIME 0.4
|
||||
#define CHAINGUN_BARREL_DECCEL_TIME 1.0
|
||||
#define CHAINGUN_BARREL_ACCEL ( CHAINGUN_BARREL_SPEED / CHAINGUN_BARREL_ACCEL_TIME )
|
||||
#define CHAINGUN_BARREL_DECCEL ( CHAINGUN_BARREL_SPEED / CHAINGUN_BARREL_DECCEL_TIME )
|
||||
|
||||
// blend times
|
||||
#define CHAINGUN_IDLE_TO_LOWER 4
|
||||
#define CHAINGUN_IDLE_TO_FIRE 0
|
||||
#define CHAINGUN_IDLE_TO_RELOAD 4
|
||||
#define CHAINGUN_RAISE_TO_IDLE 0
|
||||
#define CHAINGUN_WINDDOWN_TO_IDLE 0
|
||||
#define CHAINGUN_RELOAD_TO_IDLE 0
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponChainGun::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
world_model = ( idAnimatedEntity* )owner->GetWorldModel();
|
||||
world_barrel_joint = owner->GetAnimator()->GetJointHandle( "toob" );
|
||||
barrel_joint = owner->GetAnimator()->GetJointHandle( "spinner" );
|
||||
barrel_angle = 0;
|
||||
current_rate = 0;
|
||||
start_rate = 0;
|
||||
end_rate = 0;
|
||||
spin_start = 0;
|
||||
numSkipFrames = 0;
|
||||
spin_end = 0;
|
||||
spread = weapon->GetFloat( "spread" ); // weapon->GetFloat("spread")
|
||||
snd_windup = FindSound( "snd_windup" );
|
||||
snd_winddown = FindSound( "snd_winddown" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::UpdateBarrel
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponChainGun::UpdateBarrel()
|
||||
{
|
||||
float currentTime;
|
||||
//float t;
|
||||
idAngles ang;
|
||||
|
||||
currentTime = gameLocal.time;
|
||||
//if (currentTime < spin_end) {
|
||||
// t = (currentTime - spin_start) / (spin_end - spin_start);
|
||||
// current_rate = start_rate + t * (end_rate - start_rate);
|
||||
//}
|
||||
//else {
|
||||
current_rate = end_rate;
|
||||
//}
|
||||
|
||||
if( current_rate )
|
||||
{
|
||||
barrel_angle = barrel_angle + current_rate * GAME_FRAMETIME;
|
||||
|
||||
ang.pitch = 0;
|
||||
ang.yaw = 0;
|
||||
ang.roll = barrel_angle;
|
||||
owner->Event_SetJointAngle( barrel_joint, JOINTMOD_LOCAL, ang );
|
||||
|
||||
ang.yaw = barrel_angle;
|
||||
ang.roll = 0;
|
||||
world_model->Event_SetJointAngle( world_barrel_joint, JOINTMOD_LOCAL, ang );
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::SpinUp
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponChainGun::SpinUp()
|
||||
{
|
||||
start_rate = current_rate;
|
||||
end_rate = CHAINGUN_BARREL_SPEED;
|
||||
spin_start = gameLocal.time;
|
||||
spin_end = spin_start + ( end_rate - current_rate ) / CHAINGUN_BARREL_ACCEL;
|
||||
owner->Event_StartSound( "snd_windup", SND_CHANNEL_BODY3, false );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::SpinDown
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponChainGun::SpinDown()
|
||||
{
|
||||
start_rate = current_rate;
|
||||
end_rate = 0;
|
||||
spin_start = gameLocal.time;
|
||||
spin_end = spin_start + ( current_rate - end_rate ) / CHAINGUN_BARREL_DECCEL;
|
||||
owner->Event_StartSound( "snd_winddown", SND_CHANNEL_BODY3, false );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainGun::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, CHAINGUN_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainGun::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainGun::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
|
||||
if( !owner->AmmoInClip() )
|
||||
{
|
||||
owner->Event_WeaponOutOfAmmo();
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_WeaponReady();
|
||||
}
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainGun::Fire( stateParms_t* parms )
|
||||
{
|
||||
float ammoClip;
|
||||
// float currentTime;
|
||||
// float skip;
|
||||
|
||||
ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FireState
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_SPIN1,
|
||||
FIRE_FIRE,
|
||||
FIRE_SKIPFRAMES
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
SpinUp();
|
||||
UpdateBarrel();
|
||||
if( current_rate >= end_rate )
|
||||
{
|
||||
if( ammoClip > 0 )
|
||||
{
|
||||
parms->stage = FIRE_SPIN1;
|
||||
}
|
||||
else
|
||||
{
|
||||
parms->stage = 0;
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_SPIN1:
|
||||
owner->Event_StartSound( "snd_spin", SND_CHANNEL_BODY3, false );
|
||||
parms->stage = FIRE_FIRE;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_FIRE:
|
||||
owner->Event_LaunchProjectiles( CHAINGUN_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
owner->Event_StartSound( "snd_fire", SND_CHANNEL_BODY3, false );
|
||||
if( ammoClip == CHAINGUN_LOWAMMO )
|
||||
{
|
||||
owner->Event_StartSound( "snd_lowammo", SND_CHANNEL_ITEM, false );
|
||||
}
|
||||
numSkipFrames = 0;
|
||||
parms->stage = FIRE_SKIPFRAMES;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_SKIPFRAMES:
|
||||
UpdateBarrel();
|
||||
numSkipFrames++;
|
||||
if( numSkipFrames >= CHAINGUN_FIRE_SKIPFRAMES )
|
||||
{
|
||||
if( owner->IsFiring() )
|
||||
{
|
||||
parms->stage = FIRE_FIRE;
|
||||
numSkipFrames = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
SpinDown();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainGun::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainGun::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,37 @@
|
||||
// Weapon_chaingun.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponChainGun : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponChainGun );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void UpdateBarrel();
|
||||
void SpinUp();
|
||||
void SpinDown();
|
||||
private:
|
||||
idAnimatedEntity* world_model;
|
||||
jointHandle_t world_barrel_joint;
|
||||
jointHandle_t barrel_joint;
|
||||
float barrel_angle;
|
||||
float current_rate;
|
||||
float start_rate;
|
||||
float end_rate;
|
||||
float spin_start;
|
||||
float spin_end;
|
||||
float spread;
|
||||
int numSkipFrames;
|
||||
|
||||
const idSoundShader* snd_windup;
|
||||
const idSoundShader* snd_winddown;
|
||||
};
|
||||
@@ -0,0 +1,225 @@
|
||||
// Weapon_chainsaw.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponChainsaw )
|
||||
END_CLASS
|
||||
|
||||
#define CHAINSAW_FIRERATE 0.1
|
||||
|
||||
// blend times
|
||||
#define CHAINSAW_IDLE_TO_LOWER 4
|
||||
#define CHAINSAW_IDLE_TO_FIRE 4
|
||||
#define CHAINSAW_RAISE_TO_IDLE 4
|
||||
#define CHAINSAW_FIRE_TO_IDLE 4
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponChainsaw::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainsaw::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, CHAINSAW_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainsaw::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainsaw::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainsaw::Reload( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponChainsaw::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponChainsaw::Fire( stateParms_t* parms )
|
||||
{
|
||||
float currentTime;
|
||||
|
||||
if( parms->stage == 0 )
|
||||
{
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "melee_start", false );
|
||||
owner->Event_Melee();
|
||||
owner->Event_StartSound( "snd_startattack", SND_CHANNEL_WEAPON, false );
|
||||
parms->stage = 1;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 1 )
|
||||
{
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 3 ) )
|
||||
{
|
||||
parms->stage = 2;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 2 )
|
||||
{
|
||||
owner->Event_StartSound( "snd_attack", SND_CHANNEL_WEAPON, false );
|
||||
parms->stage = 3;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 3 )
|
||||
{
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
parms->stage = 4;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 4 )
|
||||
{
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "melee_loop" );
|
||||
next_attack = gameLocal.SysScriptTime();
|
||||
|
||||
parms->stage = 5;
|
||||
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 5 )
|
||||
{
|
||||
if( owner->IsFiring() )
|
||||
{
|
||||
currentTime = gameLocal.SysScriptTime();
|
||||
if( currentTime >= next_attack )
|
||||
{
|
||||
owner->Event_Melee();
|
||||
next_attack = currentTime + CHAINSAW_FIRERATE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
parms->stage = 6;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
}
|
||||
|
||||
if( parms->stage == 6 )
|
||||
{
|
||||
owner->Event_StartSound( "snd_stopattack", SND_CHANNEL_WEAPON, false );
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "melee_end", false );
|
||||
parms->stage = 7;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( !owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
// Weapon_chainsaw.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponChainsaw : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponChainsaw );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
bool side;
|
||||
};
|
||||
@@ -0,0 +1,252 @@
|
||||
// Weapon_double_shotgun.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponDoubleShotgun )
|
||||
END_CLASS
|
||||
|
||||
|
||||
//#define SHOTGUN_DOUBLE_FIRERATE 1.333
|
||||
#define SHOTGUN_DOUBLE_FIRERATE 2.2
|
||||
|
||||
#define SHOTGUN_DOUBLE_REQUIRED 2
|
||||
|
||||
// blend times
|
||||
#define SHOTGUN_DOUBLE_IDLE_TO_IDLE 0
|
||||
#define SHOTGUN_DOUBLE_IDLE_TO_LOWER 4
|
||||
#define SHOTGUN_DOUBLE_IDLE_TO_FIRE 0
|
||||
#define SHOTGUN_DOUBLE_IDLE_TO_RELOAD 4
|
||||
#define SHOTGUN_DOUBLE_IDLE_TO_NOAMMO 4
|
||||
#define SHOTGUN_DOUBLE_NOAMMO_TO_RELOAD 4
|
||||
#define SHOTGUN_DOUBLE_NOAMMO_TO_IDLE 4
|
||||
#define SHOTGUN_DOUBLE_RAISE_TO_IDLE 4
|
||||
#define SHOTGUN_DOUBLE_FIRE_TO_IDLE 4
|
||||
#define SHOTGUN_DOUBLE_RELOAD_TO_IDLE 4
|
||||
#define SHOTGUN_DOUBLE_RELOAD_TO_FIRE 4
|
||||
|
||||
|
||||
//Shotgun Projectile Information
|
||||
#define SHOTGUN_CENTER_PROJECTILES 8
|
||||
//#define SHOTGUN_CENTER_PROJECTILES 7
|
||||
#define SHOTGUN_BIG_PROJECTILES 12
|
||||
//#define SHOTGUN_BIG_PROJECTILES 13
|
||||
|
||||
#define SHOTGUN_CENTER_WIDTH 5
|
||||
#define SHOTGUN_CENTER_HEIGHT 10
|
||||
//#define SHOTGUN_CENTER_HEIGHT 12
|
||||
#define SHOTGUN_BIG_WIDTH 22
|
||||
//#define SHOTGUN_BIG_WIDTH 25
|
||||
#define SHOTGUN_BIG_HEIGHT 15
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponDoubleShotgun::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponDoubleShotgun::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, SHOTGUN_DOUBLE_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponDoubleShotgun::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponDoubleShotgun::Idle( stateParms_t* parms )
|
||||
{
|
||||
//float currentTime = 0;
|
||||
float clip_size;
|
||||
|
||||
clip_size = owner->ClipSize();
|
||||
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
if( !owner->AmmoInClip() )
|
||||
{
|
||||
owner->Event_WeaponOutOfAmmo();
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_WeaponReady();
|
||||
}
|
||||
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponDoubleShotgun::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
//if (ammoClip == SHOTGUN_LOWAMMO) {
|
||||
// int length;
|
||||
// owner->StartSoundShader(snd_lowammo, SND_CHANNEL_ITEM, 0, false, &length);
|
||||
//}
|
||||
|
||||
//owner->Event_LaunchProjectiles(SHOTGUN_NUMPROJECTILES, spread, 0, 1, 1);
|
||||
owner->Event_LaunchProjectilesEllipse( SHOTGUN_CENTER_PROJECTILES, SHOTGUN_CENTER_WIDTH, SHOTGUN_CENTER_HEIGHT, 0, 1.0 );
|
||||
owner->Event_LaunchProjectilesEllipse( SHOTGUN_BIG_PROJECTILES, SHOTGUN_BIG_WIDTH, SHOTGUN_BIG_HEIGHT, 0, 1.0 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, SHOTGUN_DOUBLE_FIRE_TO_IDLE ) )
|
||||
{
|
||||
owner->Event_WeaponReloading();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponDoubleShotgun::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload_start", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponDoubleShotgun::EjectBrass
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponDoubleShotgun::EjectBrass( void )
|
||||
{
|
||||
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Weapon_double_shotgun.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponDoubleShotgun : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponDoubleShotgun );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
|
||||
void EjectBrass( void );
|
||||
private:
|
||||
|
||||
};
|
||||
@@ -0,0 +1,185 @@
|
||||
// weapon_fist.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponFist )
|
||||
END_CLASS
|
||||
|
||||
#define RIFLE_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define FISTS_IDLE_TO_LOWER 4
|
||||
#define FISTS_IDLE_TO_PUNCH 0
|
||||
#define FISTS_RAISE_TO_IDLE 4
|
||||
#define FISTS_PUNCH_TO_IDLE 1
|
||||
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Init
|
||||
================
|
||||
*/
|
||||
void rvmWeaponFist::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Raise
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFist::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, FISTS_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Lower
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFist::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Idle
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFist::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Fire
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFist::Fire( stateParms_t* parms )
|
||||
{
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_MELEE,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, GetFireAnim(), false );
|
||||
parms->stage = FIRE_MELEE;
|
||||
parms->Wait( 0.1f );
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_MELEE:
|
||||
owner->Event_Melee();
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
side = !side;
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::Reload
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFist::Reload( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFist::GetFireAnim
|
||||
================
|
||||
*/
|
||||
const char* rvmWeaponFist::GetFireAnim()
|
||||
{
|
||||
if( side )
|
||||
{
|
||||
return "punch_left";
|
||||
}
|
||||
else
|
||||
{
|
||||
return "punch_right";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,21 @@
|
||||
// Weapon_fist.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponFist : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponFist );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
const char* GetFireAnim();
|
||||
bool side;
|
||||
};
|
||||
@@ -0,0 +1,254 @@
|
||||
// Weapon_flashlight.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponFlashlight )
|
||||
END_CLASS
|
||||
|
||||
// blend times
|
||||
#define FLASHLIGHT_IDLE_TO_LOWER 4
|
||||
#define FLASHLIGHT_IDLE_TO_FIRE 2
|
||||
#define FLASHLIGHT_IDLE_TO_RELOAD 4
|
||||
#define FLASHLIGHT_RAISE_TO_IDLE 4
|
||||
#define FLASHLIGHT_FIRE_TO_IDLE 4
|
||||
#define FLASHLIGHT_RELOAD_TO_IDLE 4
|
||||
|
||||
#define FLASHLIGHT_MIN_SKIN_INTENSITY 0.2
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Init
|
||||
================
|
||||
*/
|
||||
void rvmWeaponFlashlight::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
skin_on = owner->GetKey( "skin_on" );
|
||||
skin_on_invis = owner->GetKey( "skin_on_invis" );
|
||||
skin_off = owner->GetKey( "skin_off" );
|
||||
skin_off_invis = owner->GetKey( "skin_off_invis" );
|
||||
|
||||
intensity = 1.0;
|
||||
|
||||
owner->Event_SetLightParm( 3, 1.0 );
|
||||
owner->Event_SetShaderParm( 3, 1.0 );
|
||||
|
||||
on = true;
|
||||
|
||||
UpdateSkin();
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::UpdateLightIntensity
|
||||
================
|
||||
*/
|
||||
void rvmWeaponFlashlight::UpdateLightIntensity( void )
|
||||
{
|
||||
// TODO this has to interact with scripts somehow
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::UpdateSkin
|
||||
================
|
||||
*/
|
||||
void rvmWeaponFlashlight::UpdateSkin( void )
|
||||
{
|
||||
if( on && ( intensity > FLASHLIGHT_MIN_SKIN_INTENSITY ) )
|
||||
{
|
||||
if( !owner->Event_IsInvisible() )
|
||||
{
|
||||
owner->Event_SetSkin( skin_on );
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_SetSkin( skin_on_invis );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( !owner->Event_IsInvisible() )
|
||||
{
|
||||
owner->Event_SetSkin( skin_off );
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_SetSkin( skin_off_invis );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Raise
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFlashlight::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, FLASHLIGHT_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Lower
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFlashlight::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Idle
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFlashlight::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Fire
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFlashlight::Fire( stateParms_t* parms )
|
||||
{
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_MELEE,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_MELEE;
|
||||
parms->Wait( 0.1f );
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_MELEE:
|
||||
owner->Event_Melee();
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, FLASHLIGHT_FIRE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponFlashlight::Reload
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponFlashlight::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_TOGGLEFLASHLIGHT,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_TOGGLEFLASHLIGHT;
|
||||
parms->Wait( 0.2f );
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_TOGGLEFLASHLIGHT:
|
||||
on = !on;
|
||||
UpdateSkin();
|
||||
owner->Event_Flashlight( on );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, FLASHLIGHT_RELOAD_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,28 @@
|
||||
// Weapon_flashlight.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponFlashlight : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponFlashlight );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void UpdateSkin( void );
|
||||
void UpdateLightIntensity( void );
|
||||
|
||||
bool on;
|
||||
float intensity;
|
||||
idStr skin_on;
|
||||
idStr skin_on_invis;
|
||||
idStr skin_off;
|
||||
idStr skin_off_invis;
|
||||
};
|
||||
@@ -0,0 +1,400 @@
|
||||
// Weapon_grabber.cpp
|
||||
//
|
||||
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponGrabber )
|
||||
END_CLASS
|
||||
|
||||
// blend times
|
||||
#define GRABBER_IDLE_TO_LOWER 4
|
||||
#define GRABBER_IDLE_TO_OPEN 4
|
||||
#define GRABBER_IDLE_TO_OPENFIRE 4
|
||||
#define GRABBER_OPEN_TO_CLOSE 4
|
||||
#define GRABBER_OPEN_TO_FIRE 4
|
||||
#define GRABBER_CLOSE_TO_OPEN 4
|
||||
#define GRABBER_CLOSE_TO_IDLE 4
|
||||
#define GRABBER_OPENFIRE_TO_FIRE 2
|
||||
#define GRABBER_FIRE_TO_CLOSE 4
|
||||
#define GRABBER_RAISE_TO_IDLE 4
|
||||
|
||||
#define WARNING_BEEP_1 1.5
|
||||
#define WARNING_BEEP_2 2.25
|
||||
#define WARNING_BEEP_3 2.50
|
||||
#define WARNING_BEEP_4 2.75
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponGrabber::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
|
||||
snd_fireloop = FindSound( "snd_fireloop" );
|
||||
snd_electroloop = FindSound( "snd_electroloop" );
|
||||
snd_mainfire = FindSound( "snd_mainfire" );
|
||||
snd_cangrab = FindSound( "snd_cangrab" );
|
||||
snd_warning = FindSound( "snd_warning" );
|
||||
snd_stopfire = FindSound( "snd_stopfire" );
|
||||
|
||||
owner->Event_Grabber( true );
|
||||
|
||||
grabberState = -1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponGrabber::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, GRABBER_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponGrabber::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::CanFire
|
||||
|
||||
Original grabber logic had this, so we prevent the fire action from going unless grabState is 1 or 2.
|
||||
|
||||
grabState = grabberHasTarget();
|
||||
if ( grabState == 1 || grabState == 2 ) {
|
||||
if(WEAPON_ATTACK) {
|
||||
weaponState( "GrabberOpenFire", GRABBER_IDLE_TO_OPENFIRE );
|
||||
}
|
||||
}
|
||||
===============
|
||||
*/
|
||||
//bool rvmWeaponGrabber::CanFire()
|
||||
//{
|
||||
// int grabState = owner->Event_GrabberHasTarget();
|
||||
// return grabState == 1 || grabState == 2;
|
||||
//}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponGrabber::Idle( stateParms_t* parms )
|
||||
{
|
||||
int grabState = 0;
|
||||
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT,
|
||||
IDLE_GRABBER_OPEN,
|
||||
IDLE_GRABBER_OPEN_WAIT,
|
||||
};
|
||||
|
||||
UpdateGuiLight();
|
||||
|
||||
grabState = owner->Event_GrabberHasTarget();
|
||||
if( grabState == 1 || grabState == 2 )
|
||||
{
|
||||
parms->stage = IDLE_GRABBER_OPEN;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
if( !owner->AmmoInClip() )
|
||||
{
|
||||
owner->Event_WeaponOutOfAmmo();
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_WeaponReady();
|
||||
}
|
||||
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_GRABBER_OPEN:
|
||||
owner->StartSoundShader( snd_fireloop, SND_CHANNEL_BODY3, 0, false, NULL );
|
||||
owner->StartSoundShader( snd_electroloop, SND_CHANNEL_BODY2, 0, false, NULL );
|
||||
owner->StartSoundShader( snd_mainfire, SND_CHANNEL_BODY, 0, false, NULL );
|
||||
|
||||
StartWarningSound();
|
||||
StartActive();
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "open", false );
|
||||
parms->stage = IDLE_GRABBER_OPEN_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_GRABBER_OPEN_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
//owner->WeaponState( WP_FIRE, GRABBER_OPEN_TO_CLOSE );
|
||||
owner->BeginAttack();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
else
|
||||
{
|
||||
grabState = owner->Event_GrabberHasTarget();
|
||||
if( grabState == 3 )
|
||||
{
|
||||
//owner->WeaponState( WP_FIRE, GRABBER_OPEN_TO_CLOSE );
|
||||
owner->BeginAttack();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
}
|
||||
|
||||
UpdateGuiLight();
|
||||
UpdateWarningSound();
|
||||
return SRESULT_WAIT;;
|
||||
}
|
||||
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
rvmWeaponGrabber::StartWarningSound
|
||||
=====================
|
||||
*/
|
||||
void rvmWeaponGrabber::StartWarningSound()
|
||||
{
|
||||
fireStartTime = gameLocal.realClientTime;
|
||||
warningBeep1 = false;
|
||||
warningBeep2 = false;
|
||||
warningBeep3 = false;
|
||||
warningBeep4 = false;
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
rvmWeaponGrabber::StartActive
|
||||
=====================
|
||||
*/
|
||||
void rvmWeaponGrabber::StartActive()
|
||||
{
|
||||
owner->Event_StartWeaponParticle( "barrel_upper" );
|
||||
owner->Event_StartWeaponLight( "light_barrel_upper" );
|
||||
owner->Event_StartWeaponLight( "light_barrel_lower" );
|
||||
owner->Event_StartWeaponLight( "light_side" );
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
rvmWeaponGrabber::StopActive
|
||||
=====================
|
||||
*/
|
||||
void rvmWeaponGrabber::StopActive()
|
||||
{
|
||||
owner->Event_StopWeaponParticle( "barrel_upper" );
|
||||
|
||||
owner->Event_StopWeaponLight( "light_barrel_upper" );
|
||||
owner->Event_StopWeaponLight( "light_barrel_lower" );
|
||||
owner->Event_StopWeaponLight( "light_side" );
|
||||
}
|
||||
|
||||
/*
|
||||
==================== =
|
||||
rvmWeaponGrabber::UpdateGuiLight
|
||||
==================== =
|
||||
*/
|
||||
void rvmWeaponGrabber::UpdateGuiLight()
|
||||
{
|
||||
|
||||
float newState = owner->Event_GrabberHasTarget();
|
||||
if( newState != grabberState )
|
||||
{
|
||||
grabberState = newState;
|
||||
if( grabberState == 0 )
|
||||
{
|
||||
owner->Event_StartWeaponLight( "gLightBlue" );
|
||||
owner->Event_StopWeaponLight( "gLightYellow" );
|
||||
owner->Event_StopWeaponLight( "gLightRed" );
|
||||
}
|
||||
else if( grabberState == 1 )
|
||||
{
|
||||
//startSound("snd_cangrab", SND_CHANNEL_ITEM, false);
|
||||
owner->StartSoundShader( snd_cangrab, SND_CHANNEL_ITEM, 0, false, NULL );
|
||||
owner->Event_StartWeaponLight( "gLightYellow" );
|
||||
owner->Event_StopWeaponLight( "gLightBlue" );
|
||||
owner->Event_StopWeaponLight( "gLightRed" );
|
||||
}
|
||||
else if( grabberState == 2 )
|
||||
{
|
||||
owner->Event_StartWeaponLight( "gLightRed" );
|
||||
owner->Event_StopWeaponLight( "gLightBlue" );
|
||||
owner->Event_StopWeaponLight( "gLightYellow" );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
=====================
|
||||
rvmWeaponGrabber::UpdateWarningSound
|
||||
=====================
|
||||
*/
|
||||
void rvmWeaponGrabber::UpdateWarningSound()
|
||||
{
|
||||
float currentTime;
|
||||
float elapsed;
|
||||
|
||||
currentTime = gameLocal.realClientTime;
|
||||
elapsed = currentTime - fireStartTime;
|
||||
|
||||
if( elapsed > WARNING_BEEP_1 && !warningBeep1 )
|
||||
{
|
||||
owner->StartSoundShader( snd_warning, SND_CHANNEL_ITEM, 0, false, NULL );
|
||||
warningBeep1 = true;
|
||||
}
|
||||
if( elapsed > WARNING_BEEP_2 && !warningBeep2 )
|
||||
{
|
||||
owner->StartSoundShader( snd_warning, SND_CHANNEL_ITEM, 0, false, NULL );
|
||||
warningBeep2 = true;
|
||||
}
|
||||
if( elapsed > WARNING_BEEP_3 && !warningBeep3 )
|
||||
{
|
||||
owner->StartSoundShader( snd_warning, SND_CHANNEL_ITEM, 0, false, NULL );
|
||||
warningBeep3 = true;
|
||||
}
|
||||
if( elapsed > WARNING_BEEP_4 && !warningBeep4 )
|
||||
{
|
||||
owner->StartSoundShader( snd_warning, SND_CHANNEL_ITEM, 0, false, NULL );
|
||||
warningBeep4 = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponGrabber::Fire( stateParms_t* parms )
|
||||
{
|
||||
//int grabState;
|
||||
//
|
||||
//grabState = owner->Event_GrabberHasTarget();
|
||||
//
|
||||
//enum FIRE_State
|
||||
//{
|
||||
// FIRE_NOTSET = 0,
|
||||
// FIRE_WAIT_GRABSTATE,
|
||||
// FIRE_ACTUALLY_FIRE,
|
||||
// FIRE_WAIT
|
||||
//};
|
||||
//
|
||||
//switch( parms->stage )
|
||||
//{
|
||||
// case FIRE_NOTSET:
|
||||
// next_attack = MS2SEC( gameLocal.realClientTime );
|
||||
// owner->Event_PlayAnim( ANIMCHANNEL_ALL, "idleopen", true );
|
||||
// parms->stage = FIRE_WAIT_GRABSTATE;
|
||||
// return SRESULT_WAIT;
|
||||
//
|
||||
// case FIRE_WAIT_GRABSTATE:
|
||||
// if( grabState == 3 || grabState == 0 )
|
||||
// {
|
||||
// parms->stage = FIRE_ACTUALLY_FIRE;
|
||||
// }
|
||||
// return SRESULT_WAIT;
|
||||
//
|
||||
// case FIRE_ACTUALLY_FIRE:
|
||||
// StopActive();
|
||||
//
|
||||
// // Stops fire loop sound
|
||||
// owner->StartSoundShader( snd_stopfire, SND_CHANNEL_BODY3, 0, false, NULL );
|
||||
// owner->StopSound( SND_CHANNEL_BODY2, false );
|
||||
//
|
||||
// owner->Event_StartWeaponSmoke();
|
||||
// owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", true );
|
||||
// break;
|
||||
//
|
||||
// case FIRE_WAIT:
|
||||
// if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
// {
|
||||
// owner->WeaponState( WP_IDLE, GRABBER_CLOSE_TO_IDLE );
|
||||
// firingState = 0;
|
||||
// }
|
||||
// else
|
||||
// {
|
||||
// UpdateGuiLight();
|
||||
// }
|
||||
// break;
|
||||
//}
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponGrabber::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponGrabber::Reload( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
// Weapon_grabber.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponGrabber : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponGrabber );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void StartActive();
|
||||
void StopActive();
|
||||
|
||||
void StartWarningSound();
|
||||
void UpdateWarningSound();
|
||||
|
||||
void UpdateGuiLight();
|
||||
|
||||
const idSoundShader* snd_fireloop;
|
||||
const idSoundShader* snd_electroloop;
|
||||
const idSoundShader* snd_mainfire;
|
||||
const idSoundShader* snd_cangrab;
|
||||
const idSoundShader* snd_warning;
|
||||
const idSoundShader* snd_stopfire;
|
||||
private:
|
||||
float next_attack;
|
||||
|
||||
float fireStartTime;
|
||||
bool warningBeep1;
|
||||
bool warningBeep2;
|
||||
bool warningBeep3;
|
||||
bool warningBeep4;
|
||||
|
||||
float grabberState;
|
||||
};
|
||||
@@ -0,0 +1,384 @@
|
||||
// Weapon_handgrenade.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponHandgrenade )
|
||||
END_CLASS
|
||||
|
||||
#define HANDGRENADE_MINRELEASETIME 0.05
|
||||
#define HANDGRENADE_FUSE 3
|
||||
#define HANDGRENADE_QUICKTHROWTIME .2
|
||||
#define HANDGRENADE_MINPOWER 1.5
|
||||
#define HANDGRENADE_MAXPOWER 6
|
||||
#define HANDGRENADE_QUICKTHROWLAUNCH 0.55
|
||||
#define HANDGRENADE_NORMALTHROWLAUNCH 0.3
|
||||
#define HANDGRENADE_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define HANDGRENADE_IDLE_TO_LOWER 4
|
||||
#define HANDGRENADE_IDLE_TO_FIRE 4
|
||||
#define HANDGRENADE_RAISE_TO_IDLE 4
|
||||
#define HANDGRENADE_FIRE_TO_IDLE 4
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
projectile = NULL;
|
||||
spread = owner->GetFloatKey( "spread" );
|
||||
skin_nade = owner->GetKey( "skin_nade" );
|
||||
skin_nade_invis = owner->GetKey( "skin_nade_invis" );
|
||||
skin_nonade = owner->GetKey( "skin_nonade" );
|
||||
skin_nonade_invis = owner->GetKey( "skin_nonade_invis" );
|
||||
|
||||
GrenadeNade();
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::GrenadeNade
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::GrenadeNade( void )
|
||||
{
|
||||
show_grenade = true;
|
||||
UpdateSkin();
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::GrenadeNoNade
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::GrenadeNoNade( void )
|
||||
{
|
||||
show_grenade = false;
|
||||
UpdateSkin();
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::GrenadeNoNade
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::UpdateSkin()
|
||||
{
|
||||
if( !show_grenade )
|
||||
{
|
||||
if( owner->Event_IsInvisible() )
|
||||
{
|
||||
owner->Event_SetSkin( skin_nonade_invis );
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_SetSkin( skin_nonade );
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if( owner->Event_IsInvisible() )
|
||||
{
|
||||
owner->Event_SetSkin( skin_nade_invis );
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_SetSkin( skin_nade );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponHandgrenade::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, HANDGRENADE_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponHandgrenade::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponHandgrenade::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::OwnerDied
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::OwnerDied( void )
|
||||
{
|
||||
float time_held;
|
||||
|
||||
if( projectile )
|
||||
{
|
||||
time_held = gameLocal.SysScriptTime() - fuse_start;
|
||||
projectile->Show();
|
||||
projectile->Unbind();
|
||||
|
||||
// allow grenade to drop
|
||||
owner->Event_LaunchProjectiles( HANDGRENADE_NUMPROJECTILES, spread, time_held, 0, 1.0 );
|
||||
|
||||
projectile = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponHandgrenade::Fire( stateParms_t* parms )
|
||||
{
|
||||
if( parms->stage == 0 )
|
||||
{
|
||||
projectile = ( idProjectile* )owner->CreateProjectile();
|
||||
|
||||
if( projectile )
|
||||
{
|
||||
projectile->Event_StartSound( "snd_throw", SND_CHANNEL_BODY, true );
|
||||
}
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "throw_start", false );
|
||||
|
||||
current_time = gameLocal.SysScriptTime();
|
||||
fuse_start = current_time;
|
||||
fuse_end = current_time + HANDGRENADE_FUSE;
|
||||
parms->stage = 1;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 1 )
|
||||
{
|
||||
if( current_time < fuse_end )
|
||||
{
|
||||
if( ( current_time > fuse_start + HANDGRENADE_MINRELEASETIME ) )
|
||||
{
|
||||
parms->stage = 2;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
current_time = gameLocal.SysScriptTime();
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
parms->stage = 2;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 2 )
|
||||
{
|
||||
time_held = current_time - fuse_start;
|
||||
power = time_held + HANDGRENADE_MINPOWER;
|
||||
if( power > HANDGRENADE_MAXPOWER )
|
||||
{
|
||||
power = HANDGRENADE_MAXPOWER;
|
||||
}
|
||||
|
||||
if( time_held < HANDGRENADE_QUICKTHROWTIME )
|
||||
{
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "throw_quick", false );
|
||||
parms->Wait( HANDGRENADE_QUICKTHROWLAUNCH );
|
||||
exploded = false;
|
||||
}
|
||||
else if( time_held < HANDGRENADE_FUSE )
|
||||
{
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "throw", false );
|
||||
parms->Wait( HANDGRENADE_NORMALTHROWLAUNCH );
|
||||
exploded = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
// no anim. grenade just blows up
|
||||
ExplodeInHand();
|
||||
exploded = true;
|
||||
}
|
||||
|
||||
parms->stage = 3;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 3 )
|
||||
{
|
||||
if( !exploded )
|
||||
{
|
||||
GrenadeNoNade();
|
||||
current_time = gameLocal.SysScriptTime();
|
||||
if( projectile )
|
||||
{
|
||||
projectile->Show();
|
||||
projectile->Unbind();
|
||||
owner->Event_LaunchProjectiles( HANDGRENADE_NUMPROJECTILES, spread, current_time - fuse_start, power, 1.0 );
|
||||
projectile = NULL;
|
||||
}
|
||||
|
||||
parms->stage = 4;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
parms->stage = 5;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( parms->stage == 4 )
|
||||
{
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, HANDGRENADE_FIRE_TO_IDLE ) )
|
||||
{
|
||||
parms->stage = 5;
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
if( !owner->AmmoAvailable() )
|
||||
{
|
||||
stateThread.Clear();
|
||||
stateThread.SetState( "Holstered" );
|
||||
owner->GetOwner()->NextWeapon();
|
||||
}
|
||||
else
|
||||
{
|
||||
GrenadeNade();
|
||||
}
|
||||
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponHandgrenade::Reload( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponHandgrenade::ExplodeInHand
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponHandgrenade::ExplodeInHand()
|
||||
{
|
||||
idStr entname;
|
||||
idEntity* explosion;
|
||||
idVec3 forward;
|
||||
idAngles angles;
|
||||
idPlayer* owner;
|
||||
|
||||
if( projectile )
|
||||
{
|
||||
projectile->Event_Remove();
|
||||
projectile = NULL;
|
||||
}
|
||||
|
||||
owner = this->owner->GetOwner();
|
||||
|
||||
GrenadeNoNade();
|
||||
this->owner->Event_StartSound( "snd_explode", SND_CHANNEL_ANY, false );
|
||||
|
||||
//if( !common->IsClient() )
|
||||
{
|
||||
this->owner->Event_UseAmmo( HANDGRENADE_NUMPROJECTILES );
|
||||
|
||||
angles = owner->viewAngles;
|
||||
forward = angles.ToForward();
|
||||
|
||||
entname = this->owner->GetKey( "def_explode_inhand" );
|
||||
explosion = gameLocal.Spawn( entname );
|
||||
explosion->SetOrigin( this->owner->GetOrigin() + forward * 16 );
|
||||
explosion->SetShaderParm( SHADERPARM_TIMEOFFSET, -gameLocal.SysScriptTime() );
|
||||
gameLocal.DelayRemoveEntity( explosion, 2 );
|
||||
|
||||
// this should kill us
|
||||
gameLocal.RadiusDamage( this->owner->GetOrigin(), this->owner, owner, NULL, NULL, this->owner->GetKey( "def_damage_inhand" ), 1.0f );
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
// Weapon_handgrenade.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponHandgrenade : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponHandgrenade );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
virtual void OwnerDied( void ) override;
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void GrenadeNade( void );
|
||||
void GrenadeNoNade( void );
|
||||
void UpdateSkin();
|
||||
|
||||
void ExplodeInHand();
|
||||
private:
|
||||
float spread;
|
||||
float fuse_start;
|
||||
idStr skin_nade;
|
||||
idStr skin_nade_invis;
|
||||
idStr skin_nonade;
|
||||
idStr skin_nonade_invis;
|
||||
idProjectile* projectile;
|
||||
|
||||
boolean show_grenade;
|
||||
private:
|
||||
float fuse_end;
|
||||
float current_time;
|
||||
float time_held;
|
||||
float power;
|
||||
boolean exploded;
|
||||
|
||||
|
||||
const idSoundShader* snd_lowammo;
|
||||
};
|
||||
@@ -0,0 +1,205 @@
|
||||
// Weapon_machinegun.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponMachineGun )
|
||||
END_CLASS
|
||||
|
||||
#define MACHINEGUN_FIRERATE 0.1 // ~10 per second
|
||||
#define MACHINEGUN_LOWAMMO 10
|
||||
#define MACHINEGUN_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define MACHINEGUN_IDLE_TO_LOWER 4
|
||||
#define MACHINEGUN_IDLE_TO_FIRE 0
|
||||
#define MACHINEGUN_IDLE_TO_RELOAD 4
|
||||
#define MACHINEGUN_RAISE_TO_IDLE 4
|
||||
#define MACHINEGUN_FIRE_TO_IDLE 0
|
||||
#define MACHINEGUN_RELOAD_TO_IDLE 4
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponMachineGun::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
spread = weapon->GetFloat( "spread" );
|
||||
|
||||
snd_lowammo = FindSound( "snd_lowammo" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponMachineGun::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, MACHINEGUN_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponMachineGun::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponMachineGun::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponMachineGun::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
next_attack = gameLocal.realClientTime + MS2SEC( MACHINEGUN_FIRERATE );
|
||||
owner->Event_LaunchProjectiles( MACHINEGUN_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, MACHINEGUN_FIRE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponMachineGun::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponMachineGun::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Weapon_machinegun.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponMachineGun : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponMachineGun );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
float spread;
|
||||
|
||||
const idSoundShader* snd_lowammo;
|
||||
};
|
||||
@@ -0,0 +1,133 @@
|
||||
// Weapon_pda.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponPDA )
|
||||
END_CLASS
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Init
|
||||
================
|
||||
*/
|
||||
void rvmWeaponPDA::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Raise
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponPDA::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Lower
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponPDA::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Idle
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponPDA::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->GetOwner()->Event_OpenPDA();
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
if( !owner->GetOwner()->objectiveSystemOpen )
|
||||
{
|
||||
//owner->WeaponState( WP_LOWERING, 0 );
|
||||
owner->LowerWeapon();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Fire
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponPDA::Fire( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
/*
|
||||
================
|
||||
rvmWeaponPDA::Reload
|
||||
================
|
||||
*/
|
||||
stateResult_t rvmWeaponPDA::Reload( stateParms_t* parms )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
// Weapon_pda.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponPDA : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponPDA );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
};
|
||||
@@ -0,0 +1,217 @@
|
||||
// Weapon_pistol.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponPistol )
|
||||
END_CLASS
|
||||
|
||||
#define PISTOL_FIRERATE 0.4
|
||||
#define PISTOL_LOWAMMO 4
|
||||
#define PISTOL_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define PISTOL_IDLE_TO_LOWER 2
|
||||
#define PISTOL_IDLE_TO_FIRE 1
|
||||
#define PISTOL_IDLE_TO_RELOAD 3
|
||||
#define PISTOL_RAISE_TO_IDLE 3
|
||||
#define PISTOL_FIRE_TO_IDLE 4
|
||||
#define PISTOL_RELOAD_TO_IDLE 40
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponPistol::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
spread = weapon->GetFloat( "spread" );
|
||||
snd_lowammo = FindSound( "snd_lowammo" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPistol::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, PISTOL_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPistol::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPistol::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
if( !owner->AmmoInClip() )
|
||||
{
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle_empty" );
|
||||
}
|
||||
else
|
||||
{
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
}
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPistol::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
next_attack = gameLocal.realClientTime + SEC2MS( PISTOL_FIRERATE );
|
||||
|
||||
if( ammoClip == PISTOL_LOWAMMO )
|
||||
{
|
||||
int length;
|
||||
owner->StartSoundShader( snd_lowammo, SND_CHANNEL_ITEM, 0, false, &length );
|
||||
}
|
||||
|
||||
owner->Event_LaunchProjectiles( PISTOL_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, PISTOL_FIRE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPistol::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPistol::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Weapon_pistol.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponPistol : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponPistol );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
float spread;
|
||||
|
||||
const idSoundShader* snd_lowammo;
|
||||
};
|
||||
@@ -0,0 +1,205 @@
|
||||
// Weapon_plasmagun.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponPlasmaGun )
|
||||
END_CLASS
|
||||
|
||||
#define PLASMAGUN_FIRERATE 0.125 //changed by Tim
|
||||
#define PLASMAGUN_LOWAMMO 10
|
||||
#define PLASMAGUN_NUMPROJECTILES 1
|
||||
|
||||
// blend times
|
||||
#define PLASMAGUN_IDLE_TO_LOWER 4
|
||||
#define PLASMAGUN_IDLE_TO_FIRE 1
|
||||
#define PLASMAGUN_IDLE_TO_RELOAD 4
|
||||
#define PLASMAGUN_RAISE_TO_IDLE 4
|
||||
#define PLASMAGUN_FIRE_TO_IDLE 4
|
||||
#define PLASMAGUN_RELOAD_TO_IDLE 4
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponPlasmaGun::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
spread = weapon->GetFloat( "spread" );
|
||||
snd_lowammo = FindSound( "snd_lowammo" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPlasmaGun::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, PLASMAGUN_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPlasmaGun::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPlasmaGun::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPlasmaGun::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
next_attack = gameLocal.time + SEC2MS( PLASMAGUN_FIRERATE );
|
||||
owner->Event_LaunchProjectiles( PLASMAGUN_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, PLASMAGUN_FIRE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponPlasmaGun::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponPlasmaGun::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_WeaponReloading();
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, PLASMAGUN_RELOAD_TO_IDLE ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Weapon_plasmagun.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponPlasmaGun : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponPlasmaGun );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
float spread;
|
||||
|
||||
const idSoundShader* snd_lowammo;
|
||||
};
|
||||
@@ -0,0 +1,235 @@
|
||||
// Weapon_rocketlauncher.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponRocketLauncher )
|
||||
END_CLASS
|
||||
|
||||
#define ROCKETLAUNCHER_LOWAMMO 1
|
||||
#define ROCKETLAUNCHER_NUMPROJECTILES 1
|
||||
#define ROCKETLAUNCHER_FIREDELAY 1 // was .75 changed again by Tim to 1
|
||||
|
||||
// blend times
|
||||
#define ROCKETLAUNCHER_IDLE_TO_LOWER 4
|
||||
#define ROCKETLAUNCHER_IDLE_TO_FIRE 0
|
||||
#define ROCKETLAUNCHER_IDLE_TO_RELOAD 4
|
||||
#define ROCKETLAUNCHER_RAISE_TO_IDLE 4
|
||||
#define ROCKETLAUNCHER_FIRE_TO_IDLE 0
|
||||
#define ROCKETLAUNCHER_RELOAD_TO_IDLE 4
|
||||
#define ROCKETLAUNCHER_RELOAD_FRAME 34 // how many frames from the end of "reload" to fill the clip
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponRocketLauncher::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
spread = weapon->GetFloat( "spread" );
|
||||
skin_invisible = weapon->GetKey( "skin_invisible" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::UpdateSkin
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponRocketLauncher::UpdateSkin()
|
||||
{
|
||||
idStr skinname;
|
||||
int ammoClip;
|
||||
|
||||
if( owner->Event_IsInvisible() )
|
||||
{
|
||||
skinname = skin_invisible;
|
||||
}
|
||||
else
|
||||
{
|
||||
ammoClip = owner->AmmoInClip();
|
||||
if( ammoClip > 5 )
|
||||
{
|
||||
// can happen in MP - weapon Raising with slightly out-of-sync ammoClip
|
||||
ammoClip = 5;
|
||||
}
|
||||
if( ammoClip < 0 )
|
||||
{
|
||||
ammoClip = 0;
|
||||
}
|
||||
skinname = va( "skins/models/weapons/%drox.skin", ammoClip );
|
||||
}
|
||||
owner->Event_SetSkin( skinname );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponRocketLauncher::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, ROCKETLAUNCHER_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponRocketLauncher::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponRocketLauncher::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponRocketLauncher::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
next_attack = gameLocal.realClientTime + SEC2MS( ROCKETLAUNCHER_FIREDELAY );
|
||||
owner->Event_LaunchProjectiles( ROCKETLAUNCHER_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, ROCKETLAUNCHER_FIRE_TO_IDLE ) )
|
||||
{
|
||||
UpdateSkin();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponRocketLauncher::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponRocketLauncher::Reload( stateParms_t* parms )
|
||||
{
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
UpdateSkin();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
// Weapon_rocketlauncher.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponRocketLauncher : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponRocketLauncher );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
void UpdateSkin();
|
||||
|
||||
float spread;
|
||||
idStr skin_invisible;
|
||||
};
|
||||
@@ -0,0 +1,245 @@
|
||||
// Weapon_shotgun.cpp
|
||||
//
|
||||
|
||||
#pragma hdrstop
|
||||
#include "precompiled.h"
|
||||
#include "../Game_local.h"
|
||||
|
||||
CLASS_DECLARATION( rvmWeaponObject, rvmWeaponShotgun )
|
||||
END_CLASS
|
||||
|
||||
#define SHOTGUN_FIRERATE 1.333
|
||||
#define SHOTGUN_LOWAMMO 2
|
||||
#define SHOTGUN_RELOADRATE 2
|
||||
#define SHOTGUN_NUMPROJECTILES 13
|
||||
|
||||
// blend times
|
||||
#define SHOTGUN_IDLE_TO_IDLE 0
|
||||
#define SHOTGUN_IDLE_TO_LOWER 4
|
||||
#define SHOTGUN_IDLE_TO_FIRE 1
|
||||
#define SHOTGUN_IDLE_TO_RELOAD 4
|
||||
#define SHOTGUN_IDLE_TO_NOAMMO 4
|
||||
#define SHOTGUN_NOAMMO_TO_RELOAD 4
|
||||
#define SHOTGUN_NOAMMO_TO_IDLE 4
|
||||
#define SHOTGUN_RAISE_TO_IDLE 1
|
||||
#define SHOTGUN_FIRE_TO_IDLE 4
|
||||
#define SHOTGUN_RELOAD_TO_IDLE 4
|
||||
#define SHOTGUN_RELOAD_TO_FIRE 4
|
||||
#define SHOTGUN_RELOAD_TO_LOWER 2
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Init
|
||||
===============
|
||||
*/
|
||||
void rvmWeaponShotgun::Init( idWeapon* weapon )
|
||||
{
|
||||
rvmWeaponObject::Init( weapon );
|
||||
|
||||
next_attack = 0;
|
||||
spread = weapon->GetFloat( "spread" ); // weapon->GetFloat("spread")
|
||||
snd_lowammo = FindSound( "snd_lowammo" );
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Raise
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponShotgun::Raise( stateParms_t* parms )
|
||||
{
|
||||
enum RisingState
|
||||
{
|
||||
RISING_NOTSET = 0,
|
||||
RISING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RISING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "raise", false );
|
||||
parms->stage = RISING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RISING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, SHOTGUN_RAISE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Lower
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponShotgun::Lower( stateParms_t* parms )
|
||||
{
|
||||
enum LoweringState
|
||||
{
|
||||
LOWERING_NOTSET = 0,
|
||||
LOWERING_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case LOWERING_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "putaway", false );
|
||||
parms->stage = LOWERING_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case LOWERING_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
SetState( "Holstered" );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Idle
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponShotgun::Idle( stateParms_t* parms )
|
||||
{
|
||||
enum IdleState
|
||||
{
|
||||
IDLE_NOTSET = 0,
|
||||
IDLE_WAIT
|
||||
};
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case IDLE_NOTSET:
|
||||
owner->Event_WeaponReady();
|
||||
owner->Event_PlayCycle( ANIMCHANNEL_ALL, "idle" );
|
||||
parms->stage = IDLE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case IDLE_WAIT:
|
||||
// Do nothing.
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Fire
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponShotgun::Fire( stateParms_t* parms )
|
||||
{
|
||||
int ammoClip = owner->AmmoInClip();
|
||||
|
||||
enum FIRE_State
|
||||
{
|
||||
FIRE_NOTSET = 0,
|
||||
FIRE_WAIT
|
||||
};
|
||||
|
||||
if( ammoClip == 0 && owner->AmmoAvailable() && parms->stage == 0 )
|
||||
{
|
||||
//owner->WeaponState( WP_RELOAD, PISTOL_IDLE_TO_RELOAD );
|
||||
owner->Reload();
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case FIRE_NOTSET:
|
||||
next_attack = gameLocal.realClientTime + SEC2MS( SHOTGUN_FIRERATE );
|
||||
|
||||
if( ammoClip == SHOTGUN_LOWAMMO )
|
||||
{
|
||||
int length;
|
||||
owner->StartSoundShader( snd_lowammo, SND_CHANNEL_ITEM, 0, false, &length );
|
||||
}
|
||||
|
||||
owner->Event_LaunchProjectiles( SHOTGUN_NUMPROJECTILES, spread, 0, 1, 1 );
|
||||
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "fire", false );
|
||||
parms->stage = FIRE_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case FIRE_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, SHOTGUN_FIRE_TO_IDLE ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
|
||||
/*
|
||||
===============
|
||||
rvmWeaponShotgun::Reload
|
||||
===============
|
||||
*/
|
||||
stateResult_t rvmWeaponShotgun::Reload( stateParms_t* parms )
|
||||
{
|
||||
float ammoClip;
|
||||
float ammoAvail;
|
||||
float clip_size;
|
||||
|
||||
clip_size = owner->ClipSize();
|
||||
|
||||
enum RELOAD_State
|
||||
{
|
||||
RELOAD_NOTSET = 0,
|
||||
RELOAD_WAIT,
|
||||
RELOAD_END
|
||||
};
|
||||
|
||||
ammoAvail = owner->AmmoAvailable();
|
||||
ammoClip = owner->AmmoInClip();
|
||||
|
||||
switch( parms->stage )
|
||||
{
|
||||
case RELOAD_NOTSET:
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload_loop", false );
|
||||
parms->stage = RELOAD_WAIT;
|
||||
return SRESULT_WAIT;
|
||||
|
||||
case RELOAD_WAIT:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
if( ( ammoClip < clip_size ) && ( ammoClip < ammoAvail ) )
|
||||
{
|
||||
parms->stage = RELOAD_NOTSET;
|
||||
owner->Event_AddToClip( SHOTGUN_RELOADRATE );
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
else
|
||||
{
|
||||
parms->stage = RELOAD_END;
|
||||
owner->Event_PlayAnim( ANIMCHANNEL_ALL, "reload_end", false );
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
owner->Event_AddToClip( owner->ClipSize() );
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
case RELOAD_END:
|
||||
if( owner->Event_AnimDone( ANIMCHANNEL_ALL, 0 ) )
|
||||
{
|
||||
return SRESULT_DONE;
|
||||
}
|
||||
return SRESULT_WAIT;
|
||||
}
|
||||
|
||||
|
||||
return SRESULT_ERROR;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
// Weapon_shotgun.h
|
||||
//
|
||||
|
||||
#pragma once
|
||||
|
||||
class rvmWeaponShotgun : public rvmWeaponObject
|
||||
{
|
||||
public:
|
||||
CLASS_PROTOTYPE( rvmWeaponShotgun );
|
||||
|
||||
virtual void Init( idWeapon* weapon );
|
||||
|
||||
stateResult_t Raise( stateParms_t* parms );
|
||||
stateResult_t Lower( stateParms_t* parms );
|
||||
stateResult_t Idle( stateParms_t* parms );
|
||||
stateResult_t Fire( stateParms_t* parms );
|
||||
stateResult_t Reload( stateParms_t* parms );
|
||||
private:
|
||||
float spread;
|
||||
|
||||
const idSoundShader* snd_lowammo;
|
||||
};
|
||||
Reference in New Issue
Block a user