mirror of
https://github.com/unknownworlds/NS.git
synced 2024-12-11 21:31:41 +00:00
5af879678c
git-svn-id: https://unknownworlds.svn.cloudforge.com/ns1@69 67975925-1194-0748-b3d5-c16f83f1a3a1
1946 lines
55 KiB
C++
1946 lines
55 KiB
C++
//
|
|
// Copyright (c) 1999, Valve LLC. All rights reserved.
|
|
//
|
|
// This product contains software technology licensed from Id
|
|
// Software, Inc. ("Id Technology"). Id Technology (c) 1996 Id Software, Inc.
|
|
// All Rights Reserved.
|
|
//
|
|
// Use, distribution, and modification of this source code and/or resulting
|
|
// object code is restricted to non-commercial enhancements to products from
|
|
// Valve LLC. All other use, distribution, or modification is prohibited
|
|
// without written permission from Valve LLC.
|
|
//
|
|
// ===== weapons.cpp ========================================================
|
|
//
|
|
// functions governing the selection/use of weapons for players
|
|
//
|
|
// $Workfile: weapons.cpp $
|
|
// $Date: 2002/11/22 21:13:52 $
|
|
//
|
|
//-------------------------------------------------------------------------------
|
|
// $Log: weapons.cpp,v $
|
|
// Revision 1.49 2002/11/22 21:13:52 Flayra
|
|
// - mp_consistency changes
|
|
//
|
|
// Revision 1.48 2002/11/12 02:19:43 Flayra
|
|
// - Fixed problem where friendly bulletfire was doing damage
|
|
//
|
|
// Revision 1.47 2002/10/24 21:19:11 Flayra
|
|
// - Reworked jetpack effects
|
|
// - Added a few extra sounds
|
|
//
|
|
// Revision 1.46 2002/10/16 00:41:15 Flayra
|
|
// - Removed unneeds sounds and events
|
|
// - Added distress beacon event
|
|
// - Added general purpose particle event
|
|
//
|
|
// Revision 1.45 2002/09/25 20:40:09 Flayra
|
|
// - Play different sound for aliens when they get weapons
|
|
//
|
|
// Revision 1.44 2002/09/23 22:04:00 Flayra
|
|
// - Regular update
|
|
//
|
|
// Revision 1.43 2002/08/31 18:01:18 Flayra
|
|
// - Work at VALVe
|
|
//
|
|
// Revision 1.42 2002/07/26 23:01:05 Flayra
|
|
// - Precache numerical feedback event
|
|
//
|
|
// Revision 1.41 2002/07/23 16:48:37 Flayra
|
|
// - Added distress beacon
|
|
//
|
|
// Revision 1.40 2002/07/08 16:35:17 Flayra
|
|
// - Added document header, updates for cheat protection, added constants
|
|
//
|
|
//===============================================================================
|
|
#include "util/nowarnings.h"
|
|
#include "extdll.h"
|
|
#include "util.h"
|
|
#include "cbase.h"
|
|
#include "player.h"
|
|
#include "monsters.h"
|
|
#include "weapons.h"
|
|
#include "nodes.h"
|
|
#include "soundent.h"
|
|
#include "decals.h"
|
|
#include "gamerules.h"
|
|
#include "mod/AvHConstants.h"
|
|
#include "mod/AvHMarineEquipmentConstants.h"
|
|
#include "mod/AvHAlienWeaponConstants.h"
|
|
#include "mod/AvHAlienEquipmentConstants.h"
|
|
#include "mod/AvHPlayer.h"
|
|
#include "mod/AvHGamerules.h"
|
|
|
|
extern CGraph WorldGraph;
|
|
extern int gEvilImpulse101;
|
|
|
|
int gJetpackEventID;
|
|
int gStartOverwatchEventID;
|
|
int gEndOverwatchEventID;
|
|
int gTeleportEventID;
|
|
int gBlinkEffectSuccessEventID;
|
|
int gPhaseInEventID;
|
|
int gSiegeHitEventID;
|
|
int gSiegeViewHitEventID;
|
|
int gCommanderPointsAwardedEventID;
|
|
int gAlienSightOnEventID;
|
|
int gAlienSightOffEventID;
|
|
//int gParalysisStartEventID;
|
|
int gRegenerationEventID;
|
|
int gStartCloakEventID;
|
|
int gEndCloakEventID;
|
|
int gSporeCloudEventID;
|
|
int gUmbraCloudEventID;
|
|
int gStopScreamEventID;
|
|
|
|
int gWelderEventID;
|
|
int gWelderConstEventID;
|
|
//int gWallJumpEventID;
|
|
//int gFlightEventID;
|
|
int gEmptySoundEventID;
|
|
int gNumericalInfoEventID;
|
|
int gInvalidActionEventID;
|
|
int gParticleEventID;
|
|
int gDistressBeaconEventID;
|
|
int gWeaponAnimationEventID;
|
|
int gLevelUpEventID;
|
|
int gMetabolizeSuccessEventID;
|
|
|
|
#define NOT_USED 255
|
|
|
|
DLL_GLOBAL short g_sModelIndexLaser;// holds the index for the laser beam
|
|
DLL_GLOBAL const char *g_pModelNameLaser = "sprites/laserbeam.spr";
|
|
DLL_GLOBAL short g_sModelIndexLaserDot;// holds the index for the laser beam dot
|
|
DLL_GLOBAL short g_sModelIndexFireball;// holds the index for the fireball
|
|
DLL_GLOBAL short g_sModelIndexSmoke;// holds the index for the smoke cloud
|
|
DLL_GLOBAL short g_sModelIndexWExplosion;// holds the index for the underwater explosion
|
|
DLL_GLOBAL short g_sModelIndexBubbles;// holds the index for the bubbles model
|
|
DLL_GLOBAL short g_sModelIndexBloodDrop;// holds the sprite index for the initial blood
|
|
DLL_GLOBAL short g_sModelIndexBloodSpray;// holds the sprite index for splattered blood
|
|
|
|
ItemInfo CBasePlayerItem::ItemInfoArray[MAX_WEAPONS];
|
|
AmmoInfo CBasePlayerItem::AmmoInfoArray[MAX_AMMO_SLOTS];
|
|
|
|
extern int gmsgCurWeapon;
|
|
|
|
MULTIDAMAGE gMultiDamage;
|
|
|
|
#define TRACER_FREQ 4 // Tracers fire every fourth bullet
|
|
|
|
|
|
//=========================================================
|
|
// MaxAmmoCarry - pass in a name and this function will tell
|
|
// you the maximum amount of that type of ammunition that a
|
|
// player can carry.
|
|
//=========================================================
|
|
int MaxAmmoCarry( int iszName )
|
|
{
|
|
for ( int i = 0; i < MAX_WEAPONS; i++ )
|
|
{
|
|
if ( CBasePlayerItem::ItemInfoArray[i].pszAmmo1 && !strcmp( STRING(iszName), CBasePlayerItem::ItemInfoArray[i].pszAmmo1 ) )
|
|
return CBasePlayerItem::ItemInfoArray[i].iMaxAmmo1;
|
|
if ( CBasePlayerItem::ItemInfoArray[i].pszAmmo2 && !strcmp( STRING(iszName), CBasePlayerItem::ItemInfoArray[i].pszAmmo2 ) )
|
|
return CBasePlayerItem::ItemInfoArray[i].iMaxAmmo2;
|
|
}
|
|
|
|
ALERT( at_console, "MaxAmmoCarry() doesn't recognize '%s'!\n", STRING( iszName ) );
|
|
return -1;
|
|
}
|
|
|
|
|
|
/*
|
|
==============================================================================
|
|
|
|
MULTI-DAMAGE
|
|
|
|
Collects multiple small damages into a single damage
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
//
|
|
// ClearMultiDamage - resets the global multi damage accumulator
|
|
//
|
|
void ClearMultiDamage(void)
|
|
{
|
|
gMultiDamage.pEntity = NULL;
|
|
gMultiDamage.amount = 0;
|
|
gMultiDamage.type = 0;
|
|
}
|
|
|
|
//
|
|
// ApplyMultiDamage - inflicts contents of global multi damage register on gMultiDamage.pEntity
|
|
//
|
|
// GLOBALS USED:
|
|
// gMultiDamage
|
|
|
|
void ApplyMultiDamage(entvars_t *pevInflictor, entvars_t *pevAttacker )
|
|
{
|
|
Vector vecSpot1;//where blood comes from
|
|
Vector vecDir;//direction blood should go
|
|
TraceResult tr;
|
|
|
|
if ( !gMultiDamage.pEntity )
|
|
return;
|
|
|
|
float theDamage = gMultiDamage.amount;
|
|
gMultiDamage.pEntity->TakeDamage(pevInflictor, pevAttacker, theDamage, gMultiDamage.type );
|
|
}
|
|
|
|
|
|
// GLOBALS USED:
|
|
// gMultiDamage
|
|
|
|
void AddMultiDamage( entvars_t *pevInflictor, CBaseEntity *pEntity, float flDamage, int bitsDamageType)
|
|
{
|
|
if ( !pEntity )
|
|
return;
|
|
|
|
gMultiDamage.type |= bitsDamageType;
|
|
|
|
if ( pEntity != gMultiDamage.pEntity )
|
|
{
|
|
ApplyMultiDamage(pevInflictor,pevInflictor); // UNDONE: wrong attacker!
|
|
gMultiDamage.pEntity = pEntity;
|
|
gMultiDamage.amount = 0;
|
|
}
|
|
|
|
gMultiDamage.amount += flDamage;
|
|
}
|
|
|
|
/*
|
|
================
|
|
SpawnBlood
|
|
================
|
|
*/
|
|
void SpawnBlood(Vector vecSpot, int bloodColor, float flDamage)
|
|
{
|
|
if(flDamage >= 0.0f)
|
|
{
|
|
if(bloodColor == DONT_BLEED)
|
|
{
|
|
UTIL_Sparks(vecSpot);
|
|
}
|
|
else
|
|
{
|
|
UTIL_BloodDrips( vecSpot, g_vecAttackDir, bloodColor, (int)flDamage );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
int DamageDecal( CBaseEntity *pEntity, int bitsDamageType )
|
|
{
|
|
if ( !pEntity )
|
|
return (DECAL_GUNSHOT1 + RANDOM_LONG(0,4));
|
|
|
|
return pEntity->DamageDecal( bitsDamageType );
|
|
}
|
|
|
|
void DecalGunshot( TraceResult *pTrace, int iBulletType )
|
|
{
|
|
// Is the entity valid
|
|
if ( !UTIL_IsValidEntity( pTrace->pHit ) )
|
|
return;
|
|
|
|
if ( VARS(pTrace->pHit)->solid == SOLID_BSP || VARS(pTrace->pHit)->movetype == MOVETYPE_PUSHSTEP )
|
|
{
|
|
CBaseEntity *pEntity = NULL;
|
|
// Decal the wall with a gunshot
|
|
if ( !FNullEnt(pTrace->pHit) )
|
|
pEntity = CBaseEntity::Instance(pTrace->pHit);
|
|
|
|
// switch( iBulletType )
|
|
// {
|
|
// case BULLET_PLAYER_9MM:
|
|
// case BULLET_MONSTER_9MM:
|
|
// case BULLET_PLAYER_MP5:
|
|
// case BULLET_MONSTER_MP5:
|
|
// case BULLET_PLAYER_BUCKSHOT:
|
|
// case BULLET_PLAYER_357:
|
|
// default:
|
|
// smoke and decal
|
|
UTIL_GunshotDecalTrace( pTrace, DamageDecal( pEntity, DMG_BULLET ) );
|
|
// break;
|
|
// case BULLET_MONSTER_12MM:
|
|
// // smoke and decal
|
|
// UTIL_GunshotDecalTrace( pTrace, DamageDecal( pEntity, DMG_BULLET ) );
|
|
// break;
|
|
// case BULLET_PLAYER_CROWBAR:
|
|
// // wall decal
|
|
// UTIL_DecalTrace( pTrace, DamageDecal( pEntity, DMG_CLUB ) );
|
|
// break;
|
|
// }
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// EjectBrass - tosses a brass shell from passed origin at passed velocity
|
|
//
|
|
void EjectBrass ( const Vector &vecOrigin, const Vector &vecVelocity, float rotation, int model, int soundtype )
|
|
{
|
|
// FIX: when the player shoots, their gun isn't in the same position as it is on the model other players see.
|
|
|
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecOrigin );
|
|
WRITE_BYTE( TE_MODEL);
|
|
WRITE_COORD( vecOrigin.x);
|
|
WRITE_COORD( vecOrigin.y);
|
|
WRITE_COORD( vecOrigin.z);
|
|
WRITE_COORD( vecVelocity.x);
|
|
WRITE_COORD( vecVelocity.y);
|
|
WRITE_COORD( vecVelocity.z);
|
|
WRITE_ANGLE( rotation );
|
|
WRITE_SHORT( model );
|
|
WRITE_BYTE ( soundtype);
|
|
WRITE_BYTE ( 25 );// 2.5 seconds
|
|
MESSAGE_END();
|
|
}
|
|
|
|
|
|
#if 0
|
|
// UNDONE: This is no longer used?
|
|
void ExplodeModel( const Vector &vecOrigin, float speed, int model, int count )
|
|
{
|
|
MESSAGE_BEGIN( MSG_PVS, SVC_TEMPENTITY, vecOrigin );
|
|
WRITE_BYTE ( TE_EXPLODEMODEL );
|
|
WRITE_COORD( vecOrigin.x );
|
|
WRITE_COORD( vecOrigin.y );
|
|
WRITE_COORD( vecOrigin.z );
|
|
WRITE_COORD( speed );
|
|
WRITE_SHORT( model );
|
|
WRITE_SHORT( count );
|
|
WRITE_BYTE ( 15 );// 1.5 seconds
|
|
MESSAGE_END();
|
|
}
|
|
#endif
|
|
|
|
|
|
int giAmmoIndex = 0;
|
|
|
|
// Precaches the ammo and queues the ammo info for sending to clients
|
|
void AddAmmoNameToAmmoRegistry( const char *szAmmoname )
|
|
{
|
|
// make sure it's not already in the registry
|
|
for ( int i = 0; i < MAX_AMMO_SLOTS; i++ )
|
|
{
|
|
if ( !CBasePlayerItem::AmmoInfoArray[i].pszName)
|
|
continue;
|
|
|
|
if ( stricmp( CBasePlayerItem::AmmoInfoArray[i].pszName, szAmmoname ) == 0 )
|
|
return; // ammo already in registry, just quite
|
|
}
|
|
|
|
|
|
giAmmoIndex++;
|
|
ASSERT( giAmmoIndex < MAX_AMMO_SLOTS );
|
|
if ( giAmmoIndex >= MAX_AMMO_SLOTS )
|
|
giAmmoIndex = 0;
|
|
|
|
CBasePlayerItem::AmmoInfoArray[giAmmoIndex].pszName = szAmmoname;
|
|
CBasePlayerItem::AmmoInfoArray[giAmmoIndex].iId = giAmmoIndex; // yes, this info is redundant
|
|
}
|
|
|
|
|
|
// Precaches the weapon and queues the weapon info for sending to clients
|
|
void UTIL_PrecacheOtherWeapon( const char *szClassname )
|
|
{
|
|
edict_t *pent;
|
|
|
|
pent = CREATE_NAMED_ENTITY( MAKE_STRING( szClassname ) );
|
|
if ( FNullEnt( pent ) )
|
|
{
|
|
ALERT ( at_console, "NULL Ent in UTIL_PrecacheOtherWeapon\n" );
|
|
return;
|
|
}
|
|
|
|
CBaseEntity *pEntity = CBaseEntity::Instance (VARS( pent ));
|
|
|
|
if (pEntity)
|
|
{
|
|
ItemInfo II;
|
|
pEntity->Precache( );
|
|
memset( &II, 0, sizeof II );
|
|
if ( ((CBasePlayerItem*)pEntity)->GetItemInfo( &II ) )
|
|
{
|
|
CBasePlayerItem::ItemInfoArray[II.iId] = II;
|
|
|
|
if ( II.pszAmmo1 && *II.pszAmmo1 )
|
|
{
|
|
AddAmmoNameToAmmoRegistry( II.pszAmmo1 );
|
|
}
|
|
|
|
if ( II.pszAmmo2 && *II.pszAmmo2 )
|
|
{
|
|
AddAmmoNameToAmmoRegistry( II.pszAmmo2 );
|
|
}
|
|
|
|
memset( &II, 0, sizeof II );
|
|
}
|
|
}
|
|
|
|
REMOVE_ENTITY(pent);
|
|
}
|
|
|
|
// called by worldspawn
|
|
void W_Precache(void)
|
|
{
|
|
memset( CBasePlayerItem::ItemInfoArray, 0, sizeof(CBasePlayerItem::ItemInfoArray) );
|
|
memset( CBasePlayerItem::AmmoInfoArray, 0, sizeof(CBasePlayerItem::AmmoInfoArray) );
|
|
giAmmoIndex = 0;
|
|
|
|
// Marine weapons
|
|
//UTIL_PrecacheOtherWeapon("weapon_9mmhandgun");
|
|
//UTIL_PrecacheOtherWeapon("weapon_glock");
|
|
//UTIL_PrecacheOther("ammo_9mmclip");
|
|
|
|
// Player assets
|
|
PRECACHE_UNMODIFIED_MODEL(kReadyRoomModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kMarineSoldierModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kHeavySoldierModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienLevelOneModel);
|
|
PRECACHE_UNMODIFIED_SOUND(kDistressBeaconSound);
|
|
PRECACHE_UNMODIFIED_SOUND(kLevelUpMarineSound);
|
|
PRECACHE_UNMODIFIED_SOUND(kLevelUpAlienSound);
|
|
PRECACHE_UNMODIFIED_SOUND(kAlienBuildingSound1);
|
|
PRECACHE_UNMODIFIED_SOUND(kAlienBuildingSound2);
|
|
PRECACHE_SOUND(kMyHiveEasterEgg);
|
|
|
|
//PRECACHE_UNMODIFIED_SOUND(kAlienAbilitiesGrantedSound);
|
|
//PRECACHE_UNMODIFIED_SOUND(kAlienAbilitiesLostSound);
|
|
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienLevelTwoModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienLevelThreeModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienLevelFourModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienLevelFiveModel);
|
|
|
|
PRECACHE_UNMODIFIED_MODEL(kMarineCommanderModel);
|
|
PRECACHE_UNMODIFIED_MODEL(kAlienGestateModel);
|
|
|
|
#ifndef AVH_MAPPER_BUILD
|
|
UTIL_PrecacheOtherWeapon(kwsMine);
|
|
UTIL_PrecacheOtherWeapon(kwsKnife);
|
|
UTIL_PrecacheOtherWeapon(kwsMachineGun);
|
|
UTIL_PrecacheOtherWeapon(kwsPistol);
|
|
UTIL_PrecacheOtherWeapon(kwsShotGun);
|
|
UTIL_PrecacheOtherWeapon(kwsHeavyMachineGun);
|
|
UTIL_PrecacheOtherWeapon(kwsGrenadeGun);
|
|
UTIL_PrecacheOtherWeapon(kwsGrenade);
|
|
|
|
// Alien weapons
|
|
UTIL_PrecacheOtherWeapon(kwsSpitGun);
|
|
UTIL_PrecacheOther(kwsSpitProjectile);
|
|
UTIL_PrecacheOther(kwsWebProjectile);
|
|
UTIL_PrecacheOtherWeapon(kwsClaws);
|
|
UTIL_PrecacheOtherWeapon(kwsSwipe);
|
|
UTIL_PrecacheOtherWeapon(kwsSporeGun);
|
|
UTIL_PrecacheOther(kwsSporeProjectile);
|
|
// UTIL_PrecacheOtherWeapon(kwsParalysisGun);
|
|
UTIL_PrecacheOtherWeapon(kwsSpikeGun);
|
|
UTIL_PrecacheOtherWeapon(kwsBiteGun);
|
|
UTIL_PrecacheOtherWeapon(kwsBite2Gun);
|
|
UTIL_PrecacheOtherWeapon(kwsHealingSpray);
|
|
UTIL_PrecacheOtherWeapon(kwsWebSpinner);
|
|
// UTIL_PrecacheOtherWeapon(kwsBabblerGun);
|
|
UTIL_PrecacheOtherWeapon(kwsPrimalScream);
|
|
UTIL_PrecacheOtherWeapon(kwsParasiteGun);
|
|
UTIL_PrecacheOtherWeapon(kwsMetabolize);
|
|
UTIL_PrecacheOtherWeapon(kwsUmbraGun);
|
|
UTIL_PrecacheOtherWeapon(kwsBlinkGun);
|
|
UTIL_PrecacheOtherWeapon(kwsDivineWind);
|
|
UTIL_PrecacheOtherWeapon(kwsBileBombGun);
|
|
UTIL_PrecacheOtherWeapon(kwsAcidRocketGun);
|
|
UTIL_PrecacheOtherWeapon(kwsStomp);
|
|
UTIL_PrecacheOtherWeapon(kwsDevour);
|
|
// UTIL_PrecacheOtherWeapon(kwsAmplify);
|
|
UTIL_PrecacheOther(kwsBileBomb);
|
|
|
|
// Alien abilities
|
|
UTIL_PrecacheOtherWeapon(kwsLeap);
|
|
UTIL_PrecacheOtherWeapon(kwsCharge);
|
|
|
|
// Alien buildings
|
|
UTIL_PrecacheOther(kwsAlienResourceTower);
|
|
UTIL_PrecacheOther(kwsOffenseChamber);
|
|
UTIL_PrecacheOther(kwsDefenseChamber);
|
|
UTIL_PrecacheOther(kwsSensoryChamber);
|
|
UTIL_PrecacheOther(kwsMovementChamber);
|
|
UTIL_PrecacheOther(kesTeamWebStrand);
|
|
|
|
// Equipment
|
|
//UTIL_PrecacheOtherWeapon("weapon_tripmine");
|
|
UTIL_PrecacheOther(kwsScan);
|
|
UTIL_PrecacheOther(kwsPhaseGate);
|
|
//UTIL_PrecacheOther(kwsNuke);
|
|
|
|
// Marine buildings
|
|
UTIL_PrecacheOther(kwsTeamCommand);
|
|
UTIL_PrecacheOther(kwsResourceTower);
|
|
UTIL_PrecacheOther(kwsInfantryPortal);
|
|
UTIL_PrecacheOther(kwsTurretFactory);
|
|
UTIL_PrecacheOther(kwsArmory);
|
|
UTIL_PrecacheOther(kwsAdvancedArmory);
|
|
UTIL_PrecacheOther(kwsArmsLab);
|
|
UTIL_PrecacheOther(kwsPrototypeLab);
|
|
UTIL_PrecacheOther(kwsObservatory);
|
|
//UTIL_PrecacheOther(kwsChemlab);
|
|
//UTIL_PrecacheOther(kwsMedlab);
|
|
//UTIL_PrecacheOther(kwsNukePlant);
|
|
UTIL_PrecacheOther(kwsDeployedTurret);
|
|
UTIL_PrecacheOther(kwsSiegeTurret);
|
|
#endif
|
|
|
|
// container for dropped deathmatch weapons
|
|
UTIL_PrecacheOther("weaponbox");
|
|
|
|
UTIL_PrecacheOtherWeapon(kwsWelder);
|
|
UTIL_PrecacheOther(kwsDeployedMine);
|
|
UTIL_PrecacheOther(kwsHealth);
|
|
UTIL_PrecacheOther(kwsCatalyst);
|
|
UTIL_PrecacheOther(kwsGenericAmmo);
|
|
UTIL_PrecacheOther(kwsHeavyArmor);
|
|
UTIL_PrecacheOther(kwsJetpack);
|
|
UTIL_PrecacheOther(kwsAmmoPack);
|
|
|
|
UTIL_PrecacheOther(kwsDebugEntity);
|
|
|
|
#ifndef AVH_MAPPER_BUILD
|
|
// Precache other events
|
|
gJetpackEventID = PRECACHE_EVENT(1, kJetpackEvent);
|
|
//gStartOverwatchEventID = PRECACHE_EVENT(1, kStartOverwatchEvent);
|
|
//gEndOverwatchEventID = PRECACHE_EVENT(1, kEndOverwatchEvent);
|
|
|
|
// Alien upgrade events
|
|
gRegenerationEventID = PRECACHE_EVENT(1, kRegenerationEvent);
|
|
gStartCloakEventID = PRECACHE_EVENT(1, kStartCloakEvent);
|
|
gEndCloakEventID = PRECACHE_EVENT(1, kEndCloakEvent);
|
|
|
|
// Extra alien weapon events
|
|
//gEnsnareHitEventID = PRECACHE_EVENT(1, kEnsnareHitEventName);
|
|
gSporeCloudEventID = PRECACHE_EVENT(1, kSporeCloudEventName);
|
|
gUmbraCloudEventID = PRECACHE_EVENT(1, kUmbraCloudEventName);
|
|
gStopScreamEventID = PRECACHE_EVENT(1, kStopPrimalScreamSoundEvent);
|
|
|
|
// Extra marine events
|
|
gTeleportEventID = PRECACHE_EVENT(1, kTeleportEvent);
|
|
gBlinkEffectSuccessEventID = PRECACHE_EVENT(1, kBlinkEffectSuccessEventName);
|
|
gPhaseInEventID = PRECACHE_EVENT(1, kPhaseInEvent);
|
|
gSiegeHitEventID = PRECACHE_EVENT(1, kSiegeHitEvent);
|
|
gSiegeViewHitEventID = PRECACHE_EVENT(1, kSiegeViewHitEvent);
|
|
gCommanderPointsAwardedEventID = PRECACHE_EVENT(1, kCommanderPointsAwardedEvent);
|
|
gAlienSightOnEventID = PRECACHE_EVENT(1, kAlienSightOnEvent);
|
|
gAlienSightOffEventID = PRECACHE_EVENT(1, kAlienSightOffEvent);
|
|
// gParalysisStartEventID = PRECACHE_EVENT(1, kParalysisStartEventName);
|
|
|
|
//gWallJumpEventID = PRECACHE_EVENT(1, kWallJumpEvent);
|
|
//gFlightEventID = PRECACHE_EVENT(1, kFlightEvent);
|
|
PRECACHE_UNMODIFIED_SOUND(kConnectSound);
|
|
//PRECACHE_UNMODIFIED_SOUND(kDisconnectSound);
|
|
PRECACHE_UNMODIFIED_MODEL(kNullModel);
|
|
|
|
#endif
|
|
|
|
UTIL_PrecacheOther("monster_sentry");
|
|
|
|
// Allow welder events in mapper build
|
|
gWelderEventID = PRECACHE_EVENT(1, kWelderEventName);
|
|
gWelderConstEventID = PRECACHE_EVENT(1, kWelderConstEventName);
|
|
PRECACHE_EVENT(1, kWelderStartEventName);
|
|
PRECACHE_EVENT(1, kWelderEndEventName);
|
|
|
|
gEmptySoundEventID = PRECACHE_EVENT(1, kEmptySoundEvent);
|
|
gNumericalInfoEventID = PRECACHE_EVENT(1, kNumericalInfoEvent);
|
|
gInvalidActionEventID = PRECACHE_EVENT(1, kInvalidActionEvent);
|
|
gParticleEventID = PRECACHE_EVENT(1, kParticleEvent);
|
|
gDistressBeaconEventID = PRECACHE_EVENT(1, kDistressBeaconEvent);
|
|
gWeaponAnimationEventID= PRECACHE_EVENT(1, kWeaponAnimationEvent);
|
|
gLevelUpEventID = PRECACHE_EVENT(1, kLevelUpEvent);
|
|
gMetabolizeSuccessEventID = PRECACHE_EVENT(1, kMetabolizeSuccessEventName);
|
|
|
|
PRECACHE_UNMODIFIED_SOUND(kPhaseInSound);
|
|
|
|
// Precache reload sound that is hardcoded deep in HL
|
|
PRECACHE_UNMODIFIED_SOUND(kEmptySound);
|
|
PRECACHE_UNMODIFIED_SOUND(kInvalidSound);
|
|
|
|
// Not sure who's using these, but I keep getting errors that they're not precached. Buttons?
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark1.wav");
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark2.wav");
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark3.wav");
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark4.wav");
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark5.wav");
|
|
PRECACHE_UNMODIFIED_SOUND("buttons/spark6.wav");
|
|
|
|
// For grunts. Careful, this uses the same weapon id that the grenade gun uses
|
|
//UTIL_PrecacheOtherWeapon("weapon_9mmAR");
|
|
|
|
// common world objects
|
|
// UTIL_PrecacheOther( "item_suit" );
|
|
// UTIL_PrecacheOther( "item_battery" );
|
|
// UTIL_PrecacheOther( "item_antidote" );
|
|
// UTIL_PrecacheOther( "item_security" );
|
|
// UTIL_PrecacheOther( "item_longjump" );
|
|
|
|
// shotgun
|
|
// UTIL_PrecacheOtherWeapon( "weapon_shotgun" );
|
|
// UTIL_PrecacheOther( "ammo_buckshot" );
|
|
//
|
|
// // crowbar
|
|
// UTIL_PrecacheOtherWeapon( "weapon_rowbar" );
|
|
//
|
|
// // glock
|
|
// UTIL_PrecacheOtherWeapon( "weapon_9mmhandgun" );
|
|
// UTIL_PrecacheOther( "ammo_9mmclip" );
|
|
//
|
|
// // mp5
|
|
// UTIL_PrecacheOtherWeapon( "weapon_9mmAR" );
|
|
// UTIL_PrecacheOther( "ammo_9mmAR" );
|
|
// UTIL_PrecacheOther( "ammo_ARgrenades" );
|
|
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // python
|
|
// UTIL_PrecacheOtherWeapon( "weapon_357" );
|
|
// UTIL_PrecacheOther( "ammo_357" );
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // gauss
|
|
// UTIL_PrecacheOtherWeapon( "weapon_gauss" );
|
|
// UTIL_PrecacheOther( "ammo_gaussclip" );
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // rpg
|
|
// UTIL_PrecacheOtherWeapon( "weapon_rpg" );
|
|
// UTIL_PrecacheOther( "ammo_rpgclip" );
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // crossbow
|
|
// UTIL_PrecacheOtherWeapon( "weapon_crossbow" );
|
|
// UTIL_PrecacheOther( "ammo_crossbow" );
|
|
// UTIL_PrecacheOther( "weaponbox" );// container for dropped deathmatch weapons
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // egon
|
|
// UTIL_PrecacheOtherWeapon( "weapon_egon" );
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // satchel charge
|
|
// UTIL_PrecacheOtherWeapon( "weapon_satchel" );
|
|
//#endif
|
|
//
|
|
// // hand grenade
|
|
// UTIL_PrecacheOtherWeapon("weapon_handgrenade");
|
|
//
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // squeak grenade
|
|
// UTIL_PrecacheOtherWeapon( "weapon_snark" );
|
|
//#endif
|
|
//
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// // hornetgun
|
|
// UTIL_PrecacheOtherWeapon( "weapon_hornetgun" );
|
|
//#endif
|
|
|
|
|
|
//#if !defined( OEM_BUILD ) && !defined( HLDEMO_BUILD )
|
|
// if ( g_pGameRules->IsDeathmatch() )
|
|
// {
|
|
// UTIL_PrecacheOther( "weaponbox" );// container for dropped deathmatch weapons
|
|
// }
|
|
//#endif
|
|
|
|
g_sModelIndexFireball = PRECACHE_UNMODIFIED_MODEL ("sprites/zerogxplode.spr");// fireball
|
|
g_sModelIndexWExplosion = PRECACHE_UNMODIFIED_MODEL ("sprites/WXplo1.spr");// underwater fireball
|
|
g_sModelIndexSmoke = PRECACHE_UNMODIFIED_MODEL ("sprites/steam1.spr");// smoke
|
|
g_sModelIndexBubbles = PRECACHE_UNMODIFIED_MODEL ("sprites/bubble2.spr");//bubbles
|
|
g_sModelIndexBloodSpray = PRECACHE_UNMODIFIED_MODEL ("sprites/bloodspray.spr"); // initial blood
|
|
g_sModelIndexBloodDrop = PRECACHE_UNMODIFIED_MODEL ("sprites/blood.spr"); // splattered blood
|
|
|
|
g_sModelIndexLaser = PRECACHE_UNMODIFIED_MODEL( (char *)g_pModelNameLaser );
|
|
g_sModelIndexLaserDot = PRECACHE_UNMODIFIED_MODEL("sprites/laserdot.spr");
|
|
|
|
|
|
// used by explosions
|
|
PRECACHE_UNMODIFIED_MODEL ("models/grenade.mdl");
|
|
PRECACHE_UNMODIFIED_MODEL ("sprites/explode1.spr");
|
|
|
|
PRECACHE_SOUND ("weapons/debris1.wav");// explosion aftermaths
|
|
PRECACHE_SOUND ("weapons/debris2.wav");// explosion aftermaths
|
|
PRECACHE_SOUND ("weapons/debris3.wav");// explosion aftermaths
|
|
|
|
PRECACHE_UNMODIFIED_SOUND (kGrenadeBounceSound1);
|
|
PRECACHE_UNMODIFIED_SOUND (kGrenadeBounceSound2);
|
|
PRECACHE_UNMODIFIED_SOUND (kGrenadeBounceSound3);
|
|
PRECACHE_UNMODIFIED_SOUND (kGRHitSound);
|
|
|
|
PRECACHE_UNMODIFIED_SOUND ("weapons/bullet_hit1.wav"); // hit by bullet
|
|
PRECACHE_UNMODIFIED_SOUND ("weapons/bullet_hit2.wav"); // hit by bullet
|
|
|
|
PRECACHE_UNMODIFIED_SOUND ("items/weapondrop1.wav");// weapon falls to the ground
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TYPEDESCRIPTION CBasePlayerItem::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CBasePlayerItem, m_pPlayer, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( CBasePlayerItem, m_pNext, FIELD_CLASSPTR ),
|
|
//DEFINE_FIELD( CBasePlayerItem, m_fKnown, FIELD_INTEGER ),Reset to zero on load
|
|
DEFINE_FIELD( CBasePlayerItem, m_iId, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( CBasePlayerItem, m_iIdPrimary, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( CBasePlayerItem, m_iIdSecondary, FIELD_INTEGER ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CBasePlayerItem, CBaseAnimating );
|
|
|
|
|
|
TYPEDESCRIPTION CBasePlayerWeapon::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_flNextPrimaryAttack, FIELD_TIME ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_flNextSecondaryAttack, FIELD_TIME ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_flTimeWeaponIdle, FIELD_TIME ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_iPrimaryAmmoType, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_iSecondaryAmmoType, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_iClip, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CBasePlayerWeapon, m_iDefaultAmmo, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( CBasePlayerWeapon, m_iClientClip, FIELD_INTEGER ) , reset to zero on load so hud gets updated correctly
|
|
// DEFINE_FIELD( CBasePlayerWeapon, m_iClientWeaponState, FIELD_INTEGER ), reset to zero on load so hud gets updated correctly
|
|
};
|
|
|
|
IMPLEMENT_SAVERESTORE( CBasePlayerWeapon, CBasePlayerItem );
|
|
|
|
|
|
void CBasePlayerItem :: SetObjectCollisionBox( void )
|
|
{
|
|
pev->absmin = pev->origin + Vector(-24, -24, 0);
|
|
pev->absmax = pev->origin + Vector(24, 24, 16);
|
|
}
|
|
|
|
BOOL
|
|
CBasePlayerItem::CanDeploy( void )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
// can this weapon be put away right now?
|
|
BOOL CBasePlayerItem::CanHolster( void )
|
|
{
|
|
return TRUE;
|
|
};
|
|
|
|
// returns is deploy was successful
|
|
BOOL CBasePlayerItem::Deploy( )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
CBasePlayerItem::IsUseable( void )
|
|
{
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//=========================================================
|
|
// Sets up movetype, size, solidtype for a new weapon.
|
|
//=========================================================
|
|
void CBasePlayerItem :: FallInit( void )
|
|
{
|
|
pev->movetype = MOVETYPE_TOSS;
|
|
pev->solid = SOLID_BBOX;
|
|
|
|
UTIL_SetOrigin( pev, pev->origin );
|
|
UTIL_SetSize(pev, Vector( 0, 0, 0), Vector(0, 0, 0) );//pointsize until it lands on the ground.
|
|
|
|
SetTouch(&CBasePlayerItem::DefaultTouch );
|
|
SetThink(&CBasePlayerItem::FallThink );
|
|
|
|
pev->nextthink = gpGlobals->time + 0.1;
|
|
}
|
|
|
|
//=========================================================
|
|
// FallThink - Items that have just spawned run this think
|
|
// to catch them when they hit the ground. Once we're sure
|
|
// that the object is grounded, we change its solid type
|
|
// to trigger and set it in a large box that helps the
|
|
// player get it.
|
|
//=========================================================
|
|
void CBasePlayerItem::FallThink ( void )
|
|
{
|
|
pev->nextthink = gpGlobals->time + 0.1;
|
|
|
|
if ( pev->flags & FL_ONGROUND )
|
|
{
|
|
// clatter if we have an owner (i.e., dropped by someone)
|
|
// don't clatter if the gun is waiting to respawn (if it's waiting, it is invisible!)
|
|
if ( !FNullEnt( pev->owner ) )
|
|
{
|
|
int pitch = 95 + RANDOM_LONG(0,29);
|
|
EMIT_SOUND_DYN(ENT(pev), CHAN_VOICE, "items/weapondrop1.wav", 1, ATTN_NORM, 0, pitch);
|
|
}
|
|
|
|
// lie flat
|
|
pev->angles.x = 0;
|
|
pev->angles.z = 0;
|
|
|
|
Materialize();
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// Materialize - make a CBasePlayerItem visible and tangible
|
|
//=========================================================
|
|
void CBasePlayerItem::Materialize( void )
|
|
{
|
|
if ( pev->effects & EF_NODRAW )
|
|
{
|
|
// changing from invisible state to visible.
|
|
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "items/suitchargeok1.wav", 1, ATTN_NORM, 0, 150 );
|
|
pev->effects &= ~EF_NODRAW;
|
|
pev->effects |= EF_MUZZLEFLASH;
|
|
}
|
|
|
|
pev->solid = SOLID_TRIGGER;
|
|
|
|
UTIL_SetOrigin( pev, pev->origin );// link into world.
|
|
SetTouch (&CBasePlayerItem::DefaultTouch);
|
|
SetThink (NULL);
|
|
|
|
this->VirtualMaterialize();
|
|
}
|
|
|
|
//=========================================================
|
|
// AttemptToMaterialize - the item is trying to rematerialize,
|
|
// should it do so now or wait longer?
|
|
//=========================================================
|
|
void CBasePlayerItem::AttemptToMaterialize( void )
|
|
{
|
|
float time = g_pGameRules->FlWeaponTryRespawn( this );
|
|
|
|
if ( time == 0 )
|
|
{
|
|
Materialize();
|
|
return;
|
|
}
|
|
|
|
pev->nextthink = gpGlobals->time + time;
|
|
}
|
|
|
|
//=========================================================
|
|
// CheckRespawn - a player is taking this weapon, should
|
|
// it respawn?
|
|
//=========================================================
|
|
void CBasePlayerItem :: CheckRespawn ( void )
|
|
{
|
|
switch ( g_pGameRules->WeaponShouldRespawn( this ) )
|
|
{
|
|
case GR_WEAPON_RESPAWN_YES:
|
|
Respawn();
|
|
break;
|
|
case GR_WEAPON_RESPAWN_NO:
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// Respawn- this item is already in the world, but it is
|
|
// invisible and intangible. Make it visible and tangible.
|
|
//=========================================================
|
|
CBaseEntity* CBasePlayerItem::Respawn( void )
|
|
{
|
|
// make a copy of this weapon that is invisible and inaccessible to players (no touch function). The weapon spawn/respawn code
|
|
// will decide when to make the weapon visible and touchable.
|
|
CBaseEntity *pNewWeapon = CBaseEntity::Create( (char *)STRING( pev->classname ), g_pGameRules->VecWeaponRespawnSpot( this ), pev->angles, pev->owner );
|
|
|
|
if ( pNewWeapon )
|
|
{
|
|
pNewWeapon->pev->effects |= EF_NODRAW;// invisible for now
|
|
pNewWeapon->SetTouch( NULL );// no touch
|
|
pNewWeapon->SetThink(&CBasePlayerItem::AttemptToMaterialize );
|
|
|
|
DROP_TO_FLOOR ( ENT(pev) );
|
|
|
|
// not a typo! We want to know when the weapon the player just picked up should respawn! This new entity we created is the replacement,
|
|
// but when it should respawn is based on conditions belonging to the weapon that was taken.
|
|
pNewWeapon->pev->nextthink = g_pGameRules->FlWeaponRespawnTime( this );
|
|
}
|
|
else
|
|
{
|
|
ALERT ( at_console, "Respawn failed to create %s!\n", STRING( pev->classname ) );
|
|
}
|
|
|
|
return pNewWeapon;
|
|
}
|
|
|
|
void CBasePlayerItem::DefaultTouch( CBaseEntity *pOther )
|
|
{
|
|
// if it's not a player, ignore
|
|
if ( !pOther->IsPlayer() )
|
|
return;
|
|
|
|
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
|
|
|
|
// can I have this?
|
|
if ( !g_pGameRules->CanHavePlayerItem( pPlayer, this ) )
|
|
{
|
|
if ( gEvilImpulse101 )
|
|
{
|
|
UTIL_Remove( this );
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (pOther->AddPlayerItem( this ))
|
|
{
|
|
AttachToPlayer( pPlayer );
|
|
|
|
AvHPlayer* thePlayer = dynamic_cast<AvHPlayer*>(pPlayer);
|
|
if(thePlayer && thePlayer->GetIsAlien())
|
|
{
|
|
EMIT_SOUND(ENT(pPlayer->pev), CHAN_ITEM, "items/gunpickup2-a.wav", 1, ATTN_NORM);
|
|
}
|
|
else
|
|
{
|
|
EMIT_SOUND(ENT(pPlayer->pev), CHAN_ITEM, "items/gunpickup2.wav", 1, ATTN_NORM);
|
|
}
|
|
}
|
|
|
|
SUB_UseTargets( pOther, USE_TOGGLE, 0 ); // UNDONE: when should this happen?
|
|
}
|
|
|
|
BOOL CanAttack( float attack_time, float curtime, BOOL isPredicted )
|
|
{
|
|
#if defined( CLIENT_WEAPONS )
|
|
if ( !isPredicted )
|
|
#else
|
|
if ( 1 )
|
|
#endif
|
|
{
|
|
return ( attack_time <= curtime ) ? TRUE : FALSE;
|
|
}
|
|
else
|
|
{
|
|
return ( attack_time <= 0.0 ) ? TRUE : FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
void CBasePlayerWeapon::ItemPostFrame( void )
|
|
{
|
|
bool theAttackPressed = (m_pPlayer->pev->button & IN_ATTACK);
|
|
|
|
bool theWeaponPrimes = (this->GetWeaponPrimeTime() > 0.0f);
|
|
bool theWeaponIsPriming = this->GetIsWeaponPriming();
|
|
bool theWeaponIsPrimed = this->GetIsWeaponPrimed();
|
|
|
|
if ((m_fInReload) && ( m_pPlayer->m_flNextAttack <= UTIL_WeaponTimeBase() ) )
|
|
{
|
|
// complete the reload.
|
|
int j = min( iMaxClip() - m_iClip, m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]);
|
|
|
|
// Add them to the clip
|
|
m_iClip += j;
|
|
m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] -= j;
|
|
|
|
m_pPlayer->TabulateAmmo();
|
|
|
|
m_fInReload = FALSE;
|
|
}
|
|
|
|
if ((m_pPlayer->pev->button & IN_ATTACK2) && CanAttack( m_flNextSecondaryAttack, gpGlobals->time, UseDecrement() ) )
|
|
{
|
|
if (m_pPlayer->GetCanUseWeapon())
|
|
{
|
|
|
|
if ( pszAmmo2() && !m_pPlayer->m_rgAmmo[SecondaryAmmoIndex()] )
|
|
{
|
|
m_fFireOnEmpty = TRUE;
|
|
}
|
|
|
|
m_pPlayer->TabulateAmmo();
|
|
SecondaryAttack();
|
|
m_pPlayer->pev->button &= ~IN_ATTACK2;
|
|
}
|
|
}
|
|
else if ( theAttackPressed && CanAttack( m_flNextPrimaryAttack, gpGlobals->time, UseDecrement() ) )
|
|
{
|
|
if (m_pPlayer->GetCanUseWeapon())
|
|
{
|
|
if ( (m_iClip == 0 && pszAmmo1()) || (iMaxClip() == -1 && !m_pPlayer->m_rgAmmo[PrimaryAmmoIndex()] ) )
|
|
{
|
|
m_fFireOnEmpty = TRUE;
|
|
}
|
|
|
|
m_pPlayer->TabulateAmmo();
|
|
PrimaryAttack();
|
|
}
|
|
}
|
|
else if ( m_pPlayer->pev->button & IN_RELOAD && iMaxClip() != WEAPON_NOCLIP && !m_fInReload )
|
|
{
|
|
if (m_pPlayer->GetCanUseWeapon())
|
|
{
|
|
// reload when reload is pressed, or if no buttons are down and weapon is empty.
|
|
Reload();
|
|
}
|
|
}
|
|
else if ( !(m_pPlayer->pev->button & (IN_ATTACK|IN_ATTACK2) ) )
|
|
{
|
|
if (m_pPlayer->GetCanUseWeapon())
|
|
{
|
|
|
|
// no fire buttons down
|
|
|
|
m_fFireOnEmpty = FALSE;
|
|
|
|
if ( !IsUseable() && m_flNextPrimaryAttack < ( UseDecrement() ? 0.0 : gpGlobals->time ) )
|
|
{
|
|
// weapon isn't useable, switch.
|
|
if ( !(iFlags() & ITEM_FLAG_NOAUTOSWITCHEMPTY) && g_pGameRules->GetNextBestWeapon( m_pPlayer, this ) )
|
|
{
|
|
m_flNextPrimaryAttack = ( UseDecrement() ? 0.0 : gpGlobals->time ) + 0.3;
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// weapon is useable. Reload if empty and weapon has waited as long as it has to after firing
|
|
if ( m_iClip == 0 && !(iFlags() & ITEM_FLAG_NOAUTORELOAD) && m_flNextPrimaryAttack < ( UseDecrement() ? 0.0 : gpGlobals->time ) )
|
|
{
|
|
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] > 0)
|
|
{
|
|
Reload();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
WeaponIdle( );
|
|
}
|
|
return;
|
|
}
|
|
|
|
// catch all
|
|
if ( ShouldWeaponIdle() )
|
|
{
|
|
WeaponIdle();
|
|
}
|
|
}
|
|
|
|
void CBasePlayerItem::DestroyItem( void )
|
|
{
|
|
if ( m_pPlayer )
|
|
{
|
|
// if attached to a player, remove.
|
|
m_pPlayer->RemovePlayerItem( this );
|
|
}
|
|
Kill( );
|
|
}
|
|
|
|
void CBasePlayerItem::VirtualDestroyItem( void )
|
|
{
|
|
if ( m_pPlayer )
|
|
{
|
|
// if attached to a player, remove.
|
|
m_pPlayer->RemovePlayerItem( this );
|
|
}
|
|
|
|
Kill( );
|
|
}
|
|
|
|
int CBasePlayerItem::AddToPlayer( CBasePlayer *pPlayer )
|
|
{
|
|
m_pPlayer = pPlayer;
|
|
pPlayer->m_iHideHUD &= ~HIDEHUD_WEAPONS;
|
|
return TRUE;
|
|
}
|
|
|
|
void CBasePlayerItem::Drop( void )
|
|
{
|
|
SetTouch( NULL );
|
|
SetThink(&CBasePlayerItem::SUB_Remove);
|
|
pev->nextthink = gpGlobals->time + .1;
|
|
}
|
|
|
|
void CBasePlayerItem::Kill( void )
|
|
{
|
|
SetTouch( NULL );
|
|
SetThink(&CBasePlayerItem::SUB_Remove);
|
|
pev->nextthink = gpGlobals->time + .1;
|
|
}
|
|
|
|
void CBasePlayerItem::Holster( int skiplocal /* = 0 */ )
|
|
{
|
|
m_pPlayer->pev->viewmodel = 0;
|
|
m_pPlayer->pev->weaponmodel = 0;
|
|
}
|
|
|
|
void CBasePlayerItem::AttachToPlayer ( CBasePlayer *pPlayer )
|
|
{
|
|
pev->movetype = MOVETYPE_FOLLOW;
|
|
pev->solid = SOLID_NOT;
|
|
pev->aiment = pPlayer->edict();
|
|
pev->effects = EF_NODRAW; // ??
|
|
pev->modelindex = 0;// server won't send down to clients if modelindex == 0
|
|
pev->model = iStringNull;
|
|
pev->owner = pPlayer->edict();
|
|
pev->nextthink = gpGlobals->time + .1;
|
|
SetTouch( NULL );
|
|
}
|
|
|
|
void CBasePlayerItem::Spawn()
|
|
{
|
|
CBaseAnimating::Spawn();
|
|
}
|
|
|
|
// CALLED THROUGH the newly-touched weapon's instance. The existing player weapon is pOriginal
|
|
int CBasePlayerWeapon::AddDuplicate( CBasePlayerItem *pOriginal )
|
|
{
|
|
if ( m_iDefaultAmmo )
|
|
{
|
|
return ExtractAmmo( (CBasePlayerWeapon *)pOriginal );
|
|
}
|
|
else
|
|
{
|
|
// a dead player dropped this.
|
|
return ExtractClipAmmo( (CBasePlayerWeapon *)pOriginal );
|
|
}
|
|
}
|
|
|
|
|
|
int CBasePlayerWeapon::AddToPlayer( CBasePlayer *pPlayer )
|
|
{
|
|
int bResult = CBasePlayerItem::AddToPlayer( pPlayer );
|
|
|
|
pPlayer->pev->weapons |= (1<<m_iId);
|
|
|
|
if ( !m_iPrimaryAmmoType )
|
|
{
|
|
m_iPrimaryAmmoType = pPlayer->GetAmmoIndex( pszAmmo1() );
|
|
m_iSecondaryAmmoType = pPlayer->GetAmmoIndex( pszAmmo2() );
|
|
}
|
|
|
|
|
|
if (bResult)
|
|
return AddWeapon( );
|
|
return FALSE;
|
|
}
|
|
|
|
int CBasePlayerWeapon::UpdateClientData( CBasePlayer *pPlayer )
|
|
{
|
|
BOOL bSend = FALSE;
|
|
int state = 0;
|
|
|
|
if ( pPlayer->m_pActiveItem == this )
|
|
{
|
|
if ( pPlayer->m_fOnTarget )
|
|
state = WEAPON_IS_ONTARGET;
|
|
else
|
|
state = 1;
|
|
}
|
|
|
|
// If weapon is disabled, set state to 0 (for disabling alien weapons when there aren't hives anymore)
|
|
if(this->m_flNextSecondaryAttack == -1)
|
|
{
|
|
state = 0;
|
|
}
|
|
|
|
// Forcing send of all data!
|
|
if ( !pPlayer->m_fWeapon )
|
|
{
|
|
bSend = TRUE;
|
|
}
|
|
|
|
// This is the current or last weapon, so the state will need to be updated
|
|
if ( this == pPlayer->m_pActiveItem ||
|
|
this == pPlayer->m_pClientActiveItem )
|
|
{
|
|
if ( pPlayer->m_pActiveItem != pPlayer->m_pClientActiveItem )
|
|
{
|
|
bSend = TRUE;
|
|
}
|
|
}
|
|
|
|
// If the ammo, state, or fov has changed, update the weapon
|
|
// puzl: 497 - send if enabled state has changed
|
|
if ( m_iClip != m_iClientClip ||
|
|
state != m_iClientWeaponState ||
|
|
m_iEnabled != m_iClientEnableState ||
|
|
pPlayer->m_iFOV != pPlayer->m_iClientFOV )
|
|
{
|
|
bSend = TRUE;
|
|
}
|
|
|
|
if ( bSend )
|
|
{
|
|
MESSAGE_BEGIN( MSG_ONE, gmsgCurWeapon, NULL, pPlayer->pev );
|
|
WRITE_BYTE( state );
|
|
WRITE_BYTE( m_iId );
|
|
WRITE_BYTE( m_iClip );
|
|
// puzl: 497 - enabled state
|
|
WRITE_BYTE( m_iEnabled );
|
|
MESSAGE_END();
|
|
|
|
m_iClientClip = m_iClip;
|
|
m_iClientWeaponState = state;
|
|
// puzl: 497 - remember the old enabled state
|
|
m_iClientEnableState = m_iEnabled;
|
|
pPlayer->m_fWeapon = TRUE;
|
|
|
|
}
|
|
|
|
if ( m_pNext )
|
|
m_pNext->UpdateClientData( pPlayer );
|
|
|
|
return 1;
|
|
}
|
|
|
|
void CBasePlayerWeapon::SendWeaponAnim( int iAnim, int skiplocal, int body )
|
|
{
|
|
if(iAnim >= 0)
|
|
{
|
|
if ( UseDecrement() )
|
|
skiplocal = 1;
|
|
else
|
|
skiplocal = 0;
|
|
|
|
m_pPlayer->pev->weaponanim = iAnim;
|
|
|
|
#if defined( CLIENT_WEAPONS )
|
|
if ( skiplocal && ENGINE_CANSKIP( m_pPlayer->edict() ) )
|
|
return;
|
|
#endif
|
|
|
|
MESSAGE_BEGIN( MSG_ONE, SVC_WEAPONANIM, NULL, m_pPlayer->pev );
|
|
WRITE_BYTE( iAnim ); // sequence number
|
|
WRITE_BYTE( pev->body ); // weaponmodel bodygroup.
|
|
MESSAGE_END();
|
|
}
|
|
}
|
|
|
|
BOOL CBasePlayerWeapon :: AddPrimaryAmmo( int iCount, char *szName, int iMaxClip, int iMaxCarry )
|
|
{
|
|
int iIdAmmo;
|
|
|
|
if (iMaxClip < 1)
|
|
{
|
|
m_iClip = -1;
|
|
iIdAmmo = m_pPlayer->GiveAmmo( iCount, szName, iMaxCarry );
|
|
}
|
|
else if (m_iClip == 0)
|
|
{
|
|
int i;
|
|
i = min( m_iClip + iCount, iMaxClip ) - m_iClip;
|
|
m_iClip += i;
|
|
iIdAmmo = m_pPlayer->GiveAmmo( iCount - i, szName, iMaxCarry );
|
|
}
|
|
else
|
|
{
|
|
iIdAmmo = m_pPlayer->GiveAmmo( iCount, szName, iMaxCarry );
|
|
}
|
|
|
|
// m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] = iMaxCarry; // hack for testing
|
|
|
|
if (iIdAmmo > 0)
|
|
{
|
|
m_iPrimaryAmmoType = iIdAmmo;
|
|
if (m_pPlayer->HasPlayerItem( this ) )
|
|
{
|
|
// play the "got ammo" sound only if we gave some ammo to a player that already had this gun.
|
|
// if the player is just getting this gun for the first time, DefaultTouch will play the "picked up gun" sound for us.
|
|
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
|
|
}
|
|
}
|
|
|
|
return iIdAmmo > 0 ? TRUE : FALSE;
|
|
}
|
|
|
|
|
|
BOOL CBasePlayerWeapon :: AddSecondaryAmmo( int iCount, char *szName, int iMax )
|
|
{
|
|
int iIdAmmo;
|
|
|
|
iIdAmmo = m_pPlayer->GiveAmmo( iCount, szName, iMax );
|
|
|
|
//m_pPlayer->m_rgAmmo[m_iSecondaryAmmoType] = iMax; // hack for testing
|
|
|
|
if (iIdAmmo > 0)
|
|
{
|
|
m_iSecondaryAmmoType = iIdAmmo;
|
|
EMIT_SOUND(ENT(pev), CHAN_ITEM, "items/9mmclip1.wav", 1, ATTN_NORM);
|
|
}
|
|
return iIdAmmo > 0 ? TRUE : FALSE;
|
|
}
|
|
|
|
//=========================================================
|
|
// IsUseable - this function determines whether or not a
|
|
// weapon is useable by the player in its current state.
|
|
// (does it have ammo loaded? do I have any ammo for the
|
|
// weapon?, etc)
|
|
//=========================================================
|
|
BOOL CBasePlayerWeapon :: IsUseable( void )
|
|
{
|
|
if ( m_iClip <= 0 )
|
|
{
|
|
// This looks like a nasty bug Valve didn't notice
|
|
ASSERT(PrimaryAmmoIndex() >= 0);
|
|
|
|
if ( m_pPlayer->m_rgAmmo[ PrimaryAmmoIndex() ] <= 0 && iMaxAmmo1() != -1 )
|
|
{
|
|
// clip is empty (or nonexistant) and the player has no more ammo of this type.
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CBasePlayerWeapon :: CanDeploy( void )
|
|
{
|
|
BOOL bHasAmmo = 0;
|
|
|
|
// All weapons can always deploy. Once fire is hit, it checks if it's out of ammo. If so, the weapon switches.
|
|
// This is needed so ammo packs function correctly, and it also feels more responsive.
|
|
|
|
// if ( !pszAmmo1() )
|
|
// {
|
|
// // this weapon doesn't use ammo, can always deploy.
|
|
// return TRUE;
|
|
// }
|
|
//
|
|
// if ( pszAmmo1() )
|
|
// {
|
|
// bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] != 0);
|
|
// }
|
|
// if ( pszAmmo2() )
|
|
// {
|
|
// bHasAmmo |= (m_pPlayer->m_rgAmmo[m_iSecondaryAmmoType] != 0);
|
|
// }
|
|
// if (m_iClip > 0)
|
|
// {
|
|
// bHasAmmo |= 1;
|
|
// }
|
|
// if (!bHasAmmo)
|
|
// {
|
|
// return FALSE;
|
|
// }
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CBasePlayerWeapon :: DefaultDeploy( char *szViewModel, char *szWeaponModel, int iAnim, char *szAnimExt, int skiplocal, int body)
|
|
{
|
|
if (!CanDeploy( ))
|
|
return FALSE;
|
|
|
|
m_pPlayer->TabulateAmmo();
|
|
m_pPlayer->pev->viewmodel = MAKE_STRING(szViewModel);
|
|
m_pPlayer->pev->weaponmodel = MAKE_STRING(szWeaponModel);
|
|
strcpy( m_pPlayer->m_szAnimExtention, szAnimExt );
|
|
SendWeaponAnim( iAnim, skiplocal, body );
|
|
|
|
// Set the player animation as well
|
|
//this->m_pPlayer->SetAnimation(PLAYER_ANIM(iAnim));
|
|
|
|
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + this->GetDeployTime();
|
|
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + this->GetDeployTime() + kDeployIdleInterval;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL CBasePlayerWeapon :: DefaultReload( int iClipSize, int iAnim, float fDelay, int body)
|
|
{
|
|
if (m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType] <= 0)
|
|
return FALSE;
|
|
|
|
int j = min(iClipSize - m_iClip, m_pPlayer->m_rgAmmo[m_iPrimaryAmmoType]);
|
|
|
|
if (j == 0)
|
|
return FALSE;
|
|
|
|
m_pPlayer->m_flNextAttack = UTIL_WeaponTimeBase() + fDelay;
|
|
|
|
//!!UNDONE -- reload sound goes here !!!
|
|
//SendWeaponAnim( iAnim, UseDecrement() ? 1 : 0 );
|
|
|
|
m_fInReload = TRUE;
|
|
|
|
m_flTimeWeaponIdle = UTIL_WeaponTimeBase() + kDeployIdleInterval;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL CBasePlayerWeapon :: PlayEmptySound( void )
|
|
{
|
|
if (m_iPlayEmptySound)
|
|
{
|
|
// EMIT_SOUND(ENT(m_pPlayer->pev), CHAN_WEAPON, "weapons/357_cock1.wav", 0.8, ATTN_NORM);
|
|
|
|
int flags;
|
|
#if defined( CLIENT_WEAPONS )
|
|
flags = FEV_NOTHOST;
|
|
#else
|
|
flags = 0;
|
|
#endif
|
|
|
|
PLAYBACK_EVENT_FULL( flags, m_pPlayer->edict(), gEmptySoundEventID, 0.0, (float *)&(m_pPlayer->pev->origin), (float *)&g_vecZero, 0.0, 0.0, 0, 0, 0, 0 );
|
|
|
|
m_iPlayEmptySound = 0;
|
|
return 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CBasePlayerWeapon :: ResetEmptySound( void )
|
|
{
|
|
m_iPlayEmptySound = 1;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
int CBasePlayerWeapon::PrimaryAmmoIndex( void )
|
|
{
|
|
return m_iPrimaryAmmoType;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
int CBasePlayerWeapon::SecondaryAmmoIndex( void )
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
void CBasePlayerWeapon::Holster( int skiplocal /* = 0 */ )
|
|
{
|
|
m_fInReload = FALSE; // cancel any reload in progress.
|
|
m_pPlayer->pev->viewmodel = 0;
|
|
m_pPlayer->pev->weaponmodel = 0;
|
|
}
|
|
|
|
void CBasePlayerAmmo::Spawn( void )
|
|
{
|
|
pev->movetype = MOVETYPE_TOSS;
|
|
pev->solid = SOLID_TRIGGER;
|
|
UTIL_SetSize(pev, Vector(-16, -16, 0), Vector(16, 16, 16));
|
|
UTIL_SetOrigin( pev, pev->origin );
|
|
|
|
SetTouch(&CBasePlayerAmmo::DefaultTouch );
|
|
}
|
|
|
|
CBaseEntity* CBasePlayerAmmo::Respawn( void )
|
|
{
|
|
pev->effects |= EF_NODRAW;
|
|
SetTouch( NULL );
|
|
|
|
UTIL_SetOrigin( pev, g_pGameRules->VecAmmoRespawnSpot( this ) );// move to wherever I'm supposed to repawn.
|
|
|
|
SetThink(&CBasePlayerAmmo::Materialize );
|
|
pev->nextthink = g_pGameRules->FlAmmoRespawnTime( this );
|
|
|
|
return this;
|
|
}
|
|
|
|
void CBasePlayerAmmo::Materialize( void )
|
|
{
|
|
if ( pev->effects & EF_NODRAW )
|
|
{
|
|
// changing from invisible state to visible.
|
|
EMIT_SOUND_DYN( ENT(pev), CHAN_WEAPON, "items/suitchargeok1.wav", 1, ATTN_NORM, 0, 150 );
|
|
pev->effects &= ~EF_NODRAW;
|
|
pev->effects |= EF_MUZZLEFLASH;
|
|
}
|
|
|
|
SetTouch(&CBasePlayerAmmo::DefaultTouch );
|
|
}
|
|
|
|
void CBasePlayerAmmo :: DefaultTouch( CBaseEntity *pOther )
|
|
{
|
|
if ( !pOther->IsPlayer() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (AddAmmo( pOther ))
|
|
{
|
|
if ( g_pGameRules->AmmoShouldRespawn( this ) == GR_AMMO_RESPAWN_YES )
|
|
{
|
|
Respawn();
|
|
}
|
|
else
|
|
{
|
|
SetTouch( NULL );
|
|
SetThink(&CBasePlayerAmmo::SUB_Remove);
|
|
pev->nextthink = gpGlobals->time + .1;
|
|
}
|
|
}
|
|
else if (gEvilImpulse101)
|
|
{
|
|
// evil impulse 101 hack, kill always
|
|
SetTouch( NULL );
|
|
SetThink(&CBasePlayerAmmo::SUB_Remove);
|
|
pev->nextthink = gpGlobals->time + .1;
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// called by the new item with the existing item as parameter
|
|
//
|
|
// if we call ExtractAmmo(), it's because the player is picking up this type of weapon for
|
|
// the first time. If it is spawned by the world, m_iDefaultAmmo will have a default ammo amount in it.
|
|
// if this is a weapon dropped by a dying player, has 0 m_iDefaultAmmo, which means only the ammo in
|
|
// the weapon clip comes along.
|
|
//=========================================================
|
|
int CBasePlayerWeapon::ExtractAmmo( CBasePlayerWeapon *pWeapon )
|
|
{
|
|
int iReturn;
|
|
|
|
if ( pszAmmo1() != NULL )
|
|
{
|
|
// blindly call with m_iDefaultAmmo. It's either going to be a value or zero. If it is zero,
|
|
// we only get the ammo in the weapon's clip, which is what we want.
|
|
iReturn = pWeapon->AddPrimaryAmmo( m_iDefaultAmmo, (char *)pszAmmo1(), iMaxClip(), iMaxAmmo1() );
|
|
m_iDefaultAmmo = 0;
|
|
}
|
|
|
|
if ( pszAmmo2() != NULL )
|
|
{
|
|
iReturn = pWeapon->AddSecondaryAmmo( 0, (char *)pszAmmo2(), iMaxAmmo2() );
|
|
}
|
|
|
|
return iReturn;
|
|
}
|
|
|
|
//=========================================================
|
|
// called by the new item's class with the existing item as parameter
|
|
//=========================================================
|
|
int CBasePlayerWeapon::ExtractClipAmmo( CBasePlayerWeapon *pWeapon )
|
|
{
|
|
int iAmmo;
|
|
|
|
if ( m_iClip == WEAPON_NOCLIP )
|
|
{
|
|
iAmmo = 0;// guns with no clips always come empty if they are second-hand
|
|
}
|
|
else
|
|
{
|
|
iAmmo = m_iClip;
|
|
}
|
|
|
|
return pWeapon->m_pPlayer->GiveAmmo( iAmmo, (char *)pszAmmo1(), iMaxAmmo1() ); // , &m_iPrimaryAmmoType
|
|
}
|
|
|
|
//=========================================================
|
|
// RetireWeapon - no more ammo for this gun, put it away.
|
|
//=========================================================
|
|
void CBasePlayerWeapon::RetireWeapon( void )
|
|
{
|
|
// first, no viewmodel at all.
|
|
m_pPlayer->pev->viewmodel = iStringNull;
|
|
m_pPlayer->pev->weaponmodel = iStringNull;
|
|
//m_pPlayer->pev->viewmodelindex = NULL;
|
|
|
|
g_pGameRules->GetNextBestWeapon( m_pPlayer, this );
|
|
}
|
|
|
|
//*********************************************************
|
|
// weaponbox code:
|
|
//*********************************************************
|
|
|
|
LINK_ENTITY_TO_CLASS( weaponbox, CWeaponBox );
|
|
|
|
TYPEDESCRIPTION CWeaponBox::m_SaveData[] =
|
|
{
|
|
DEFINE_ARRAY( CWeaponBox, m_rgAmmo, FIELD_INTEGER, MAX_AMMO_SLOTS ),
|
|
DEFINE_ARRAY( CWeaponBox, m_rgiszAmmo, FIELD_STRING, MAX_AMMO_SLOTS ),
|
|
DEFINE_ARRAY( CWeaponBox, m_rgpPlayerItems, FIELD_CLASSPTR, MAX_ITEM_TYPES ),
|
|
DEFINE_FIELD( CWeaponBox, m_cAmmoTypes, FIELD_INTEGER ),
|
|
};
|
|
|
|
IMPLEMENT_SAVERESTORE( CWeaponBox, CBaseEntity );
|
|
|
|
//=========================================================
|
|
//
|
|
//=========================================================
|
|
void CWeaponBox::Precache( void )
|
|
{
|
|
PRECACHE_UNMODIFIED_MODEL("models/w_weaponbox.mdl");
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CWeaponBox :: KeyValue( KeyValueData *pkvd )
|
|
{
|
|
if ( m_cAmmoTypes < MAX_AMMO_SLOTS )
|
|
{
|
|
PackAmmo( ALLOC_STRING(pkvd->szKeyName), atoi(pkvd->szValue) );
|
|
m_cAmmoTypes++;// count this new ammo type.
|
|
|
|
pkvd->fHandled = TRUE;
|
|
}
|
|
else
|
|
{
|
|
ALERT ( at_console, "WeaponBox too full! only %d ammotypes allowed\n", MAX_AMMO_SLOTS );
|
|
}
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - Spawn
|
|
//=========================================================
|
|
void CWeaponBox::Spawn( void )
|
|
{
|
|
Precache( );
|
|
|
|
pev->movetype = MOVETYPE_TOSS;
|
|
pev->solid = SOLID_TRIGGER;
|
|
|
|
UTIL_SetSize( pev, g_vecZero, g_vecZero );
|
|
|
|
SET_MODEL( ENT(pev), "models/w_weaponbox.mdl");
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - Kill - the think function that removes the
|
|
// box from the world.
|
|
//=========================================================
|
|
void CWeaponBox::Kill( void )
|
|
{
|
|
CBasePlayerItem *pWeapon;
|
|
int i;
|
|
|
|
// destroy the weapons
|
|
for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ )
|
|
{
|
|
pWeapon = m_rgpPlayerItems[ i ];
|
|
|
|
while ( pWeapon )
|
|
{
|
|
pWeapon->SetThink(&CWeaponBox::SUB_Remove);
|
|
pWeapon->pev->nextthink = gpGlobals->time + 0.1;
|
|
pWeapon = pWeapon->m_pNext;
|
|
}
|
|
}
|
|
|
|
// remove the box
|
|
UTIL_Remove( this );
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - Touch: try to add my contents to the toucher
|
|
// if the toucher is a player.
|
|
//=========================================================
|
|
void CWeaponBox::Touch( CBaseEntity *pOther )
|
|
{
|
|
if ( !(pev->flags & FL_ONGROUND ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if ( !pOther->IsPlayer() )
|
|
{
|
|
// only players may touch a weaponbox.
|
|
return;
|
|
}
|
|
|
|
if ( !pOther->IsAlive() )
|
|
{
|
|
// no dead guys.
|
|
return;
|
|
}
|
|
|
|
CBasePlayer *pPlayer = (CBasePlayer *)pOther;
|
|
int i;
|
|
|
|
// dole out ammo
|
|
for ( i = 0 ; i < MAX_AMMO_SLOTS ; i++ )
|
|
{
|
|
if ( !FStringNull( m_rgiszAmmo[ i ] ) )
|
|
{
|
|
// there's some ammo of this type.
|
|
pPlayer->GiveAmmo( m_rgAmmo[ i ], (char *)STRING( m_rgiszAmmo[ i ] ), MaxAmmoCarry( m_rgiszAmmo[ i ] ) );
|
|
|
|
//ALERT ( at_console, "Gave %d rounds of %s\n", m_rgAmmo[i], STRING(m_rgiszAmmo[i]) );
|
|
|
|
// now empty the ammo from the weaponbox since we just gave it to the player
|
|
m_rgiszAmmo[ i ] = iStringNull;
|
|
m_rgAmmo[ i ] = 0;
|
|
}
|
|
}
|
|
|
|
// go through my weapons and try to give the usable ones to the player.
|
|
// it's important the the player be given ammo first, so the weapons code doesn't refuse
|
|
// to deploy a better weapon that the player may pick up because he has no ammo for it.
|
|
for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ )
|
|
{
|
|
if ( m_rgpPlayerItems[ i ] )
|
|
{
|
|
CBasePlayerItem *pItem;
|
|
|
|
// have at least one weapon in this slot
|
|
while ( m_rgpPlayerItems[ i ] )
|
|
{
|
|
//ALERT ( at_console, "trying to give %s\n", STRING( m_rgpPlayerItems[ i ]->pev->classname ) );
|
|
|
|
pItem = m_rgpPlayerItems[ i ];
|
|
m_rgpPlayerItems[ i ] = m_rgpPlayerItems[ i ]->m_pNext;// unlink this weapon from the box
|
|
|
|
if ( pPlayer->AddPlayerItem( pItem ) )
|
|
{
|
|
pItem->AttachToPlayer( pPlayer );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
EMIT_SOUND( pOther->edict(), CHAN_ITEM, "items/gunpickup2.wav", 1, ATTN_NORM );
|
|
SetTouch(NULL);
|
|
UTIL_Remove(this);
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - PackWeapon: Add this weapon to the box
|
|
//=========================================================
|
|
BOOL CWeaponBox::PackWeapon( CBasePlayerItem *pWeapon )
|
|
{
|
|
// is one of these weapons already packed in this box?
|
|
if ( HasWeapon( pWeapon ) )
|
|
{
|
|
return FALSE;// box can only hold one of each weapon type
|
|
}
|
|
|
|
if ( pWeapon->m_pPlayer )
|
|
{
|
|
if ( !pWeapon->m_pPlayer->RemovePlayerItem( pWeapon ) )
|
|
{
|
|
// failed to unhook the weapon from the player!
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
int iWeaponSlot = pWeapon->iItemSlot();
|
|
|
|
if ( m_rgpPlayerItems[ iWeaponSlot ] )
|
|
{
|
|
// there's already one weapon in this slot, so link this into the slot's column
|
|
pWeapon->m_pNext = m_rgpPlayerItems[ iWeaponSlot ];
|
|
m_rgpPlayerItems[ iWeaponSlot ] = pWeapon;
|
|
}
|
|
else
|
|
{
|
|
// first weapon we have for this slot
|
|
m_rgpPlayerItems[ iWeaponSlot ] = pWeapon;
|
|
pWeapon->m_pNext = NULL;
|
|
}
|
|
|
|
pWeapon->pev->spawnflags |= SF_NORESPAWN;// never respawn
|
|
pWeapon->pev->movetype = MOVETYPE_NONE;
|
|
pWeapon->pev->solid = SOLID_NOT;
|
|
pWeapon->pev->effects = EF_NODRAW;
|
|
pWeapon->pev->modelindex = 0;
|
|
pWeapon->pev->model = iStringNull;
|
|
pWeapon->pev->owner = edict();
|
|
pWeapon->SetThink( NULL );// crowbar may be trying to swing again, etc.
|
|
pWeapon->SetTouch( NULL );
|
|
pWeapon->m_pPlayer = NULL;
|
|
|
|
//ALERT ( at_console, "packed %s\n", STRING(pWeapon->pev->classname) );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - PackAmmo
|
|
//=========================================================
|
|
BOOL CWeaponBox::PackAmmo( int iszName, int iCount )
|
|
{
|
|
int iMaxCarry;
|
|
|
|
if ( FStringNull( iszName ) )
|
|
{
|
|
// error here
|
|
ALERT ( at_console, "NULL String in PackAmmo!\n" );
|
|
return FALSE;
|
|
}
|
|
|
|
iMaxCarry = MaxAmmoCarry( iszName );
|
|
|
|
if ( iMaxCarry != -1 && iCount > 0 )
|
|
{
|
|
//ALERT ( at_console, "Packed %d rounds of %s\n", iCount, STRING(iszName) );
|
|
GiveAmmo( iCount, (char *)STRING( iszName ), iMaxCarry );
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox - GiveAmmo
|
|
//=========================================================
|
|
int CWeaponBox::GiveAmmo( int iCount, char *szName, int iMax, int *pIndex/* = NULL*/ )
|
|
{
|
|
int i;
|
|
|
|
for (i = 1; i < MAX_AMMO_SLOTS && !FStringNull( m_rgiszAmmo[i] ); i++)
|
|
{
|
|
if (stricmp( szName, STRING( m_rgiszAmmo[i])) == 0)
|
|
{
|
|
if (pIndex)
|
|
*pIndex = i;
|
|
|
|
int iAdd = min( iCount, iMax - m_rgAmmo[i]);
|
|
if (iCount == 0 || iAdd > 0)
|
|
{
|
|
m_rgAmmo[i] += iAdd;
|
|
|
|
return i;
|
|
}
|
|
return -1;
|
|
}
|
|
}
|
|
if (i < MAX_AMMO_SLOTS)
|
|
{
|
|
if (pIndex)
|
|
*pIndex = i;
|
|
|
|
m_rgiszAmmo[i] = MAKE_STRING( szName );
|
|
m_rgAmmo[i] = iCount;
|
|
|
|
return i;
|
|
}
|
|
ALERT( at_console, "out of named ammo slots\n");
|
|
return i;
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox::HasWeapon - is a weapon of this type already
|
|
// packed in this box?
|
|
//=========================================================
|
|
BOOL CWeaponBox::HasWeapon( CBasePlayerItem *pCheckItem )
|
|
{
|
|
CBasePlayerItem *pItem = m_rgpPlayerItems[pCheckItem->iItemSlot()];
|
|
|
|
while (pItem)
|
|
{
|
|
if (FClassnameIs( pItem->pev, STRING( pCheckItem->pev->classname) ))
|
|
{
|
|
return TRUE;
|
|
}
|
|
pItem = pItem->m_pNext;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//=========================================================
|
|
// CWeaponBox::IsEmpty - is there anything in this box?
|
|
//=========================================================
|
|
BOOL CWeaponBox::IsEmpty( void )
|
|
{
|
|
int i;
|
|
|
|
for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ )
|
|
{
|
|
if ( m_rgpPlayerItems[ i ] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
for ( i = 0 ; i < MAX_AMMO_SLOTS ; i++ )
|
|
{
|
|
if ( !FStringNull( m_rgiszAmmo[ i ] ) )
|
|
{
|
|
// still have a bit of this type of ammo
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//=========================================================
|
|
//=========================================================
|
|
void CWeaponBox::SetObjectCollisionBox( void )
|
|
{
|
|
pev->absmin = pev->origin + Vector(-16, -16, 0);
|
|
pev->absmax = pev->origin + Vector(16, 16, 16);
|
|
}
|
|
|
|
|
|
void CBasePlayerWeapon::PrintState( void )
|
|
{
|
|
ALERT( at_console, "primary: %f\n", m_flNextPrimaryAttack );
|
|
ALERT( at_console, "idle : %f\n", m_flTimeWeaponIdle );
|
|
|
|
// ALERT( at_console, "nextrl : %f\n", m_flNextReload );
|
|
// ALERT( at_console, "nextpum: %f\n", m_flPumpTime );
|
|
|
|
// ALERT( at_console, "m_frt : %f\n", m_fReloadTime );
|
|
ALERT( at_console, "m_finre: %i\n", m_fInReload );
|
|
// ALERT( at_console, "m_finsr: %i\n", m_fInSpecialReload );
|
|
|
|
ALERT( at_console, "m_iclip: %i\n", m_iClip );
|
|
}
|
|
|
|
|
|
TYPEDESCRIPTION CRpg::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CRpg, m_fSpotActive, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CRpg, m_cActiveRockets, FIELD_INTEGER ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CRpg, CBasePlayerWeapon );
|
|
|
|
TYPEDESCRIPTION CRpgRocket::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CRpgRocket, m_flIgniteTime, FIELD_TIME ),
|
|
DEFINE_FIELD( CRpgRocket, m_pLauncher, FIELD_CLASSPTR ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CRpgRocket, CGrenade );
|
|
|
|
TYPEDESCRIPTION CShotgun::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CShotgun, m_flNextReload, FIELD_TIME ),
|
|
DEFINE_FIELD( CShotgun, m_fInSpecialReload, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CShotgun, m_flNextReload, FIELD_TIME ),
|
|
// DEFINE_FIELD( CShotgun, m_iShell, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CShotgun, m_flPumpTime, FIELD_TIME ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CShotgun, CBasePlayerWeapon );
|
|
|
|
TYPEDESCRIPTION CGauss::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CGauss, m_fInAttack, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( CGauss, m_flStartCharge, FIELD_TIME ),
|
|
// DEFINE_FIELD( CGauss, m_flPlayAftershock, FIELD_TIME ),
|
|
// DEFINE_FIELD( CGauss, m_flNextAmmoBurn, FIELD_TIME ),
|
|
DEFINE_FIELD( CGauss, m_fPrimaryFire, FIELD_BOOLEAN ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CGauss, CBasePlayerWeapon );
|
|
|
|
TYPEDESCRIPTION CEgon::m_SaveData[] =
|
|
{
|
|
// DEFINE_FIELD( CEgon, m_pBeam, FIELD_CLASSPTR ),
|
|
// DEFINE_FIELD( CEgon, m_pNoise, FIELD_CLASSPTR ),
|
|
// DEFINE_FIELD( CEgon, m_pSprite, FIELD_CLASSPTR ),
|
|
DEFINE_FIELD( CEgon, m_shootTime, FIELD_TIME ),
|
|
DEFINE_FIELD( CEgon, m_fireState, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CEgon, m_fireMode, FIELD_INTEGER ),
|
|
DEFINE_FIELD( CEgon, m_shakeTime, FIELD_TIME ),
|
|
DEFINE_FIELD( CEgon, m_flAmmoUseTime, FIELD_TIME ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CEgon, CBasePlayerWeapon );
|
|
|
|
TYPEDESCRIPTION CSatchel::m_SaveData[] =
|
|
{
|
|
DEFINE_FIELD( CSatchel, m_chargeReady, FIELD_INTEGER ),
|
|
};
|
|
IMPLEMENT_SAVERESTORE( CSatchel, CBasePlayerWeapon );
|
|
|