1140 lines
32 KiB
C++
1140 lines
32 KiB
C++
#ifndef __W_WEAPONS_H
|
|
#define __W_WEAPONS_H
|
|
|
|
#include "w_public.h"
|
|
|
|
#define MASK_PROJ (CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_DEADMONSTER|CONTENTS_SHOT)
|
|
#define MASK_PROJ2 (MASK_PROJ|CONTENTS_WINDOW)
|
|
|
|
typedef struct sharedEdict_s sharedEdict_t;
|
|
typedef struct edict_s edict_t;
|
|
|
|
class clientRICBuf;
|
|
class serverRICBuf;
|
|
|
|
const int MAXWEAPONS = 14;
|
|
const int MAXSELECTABLEWEAPONS = 12;
|
|
const int MAXITEMS = 6;
|
|
const float ITEM_USE_TIME = .4;
|
|
|
|
enum
|
|
{
|
|
WANIM_NORMAL,
|
|
WANIM_RELOAD,
|
|
WANIM_FIRE,
|
|
WANIM_ALTFIRE,
|
|
WANIM_PUTAWAY,
|
|
WANIM_LOSE,
|
|
WANIM_TYPES
|
|
};
|
|
|
|
typedef enum
|
|
{
|
|
PWC_NOCOMMAND,
|
|
PWC_RELOAD,
|
|
PWC_WEAPNEXT,
|
|
PWC_WEAPPREV,
|
|
PWC_WEAPONBEST_SAFE,
|
|
PWC_WEAPONBEST_UNSAFE,
|
|
PWC_LOSE,
|
|
PWC_DROP,
|
|
PWC_WEAPSELECTFIRST,
|
|
PWC_NUMCMDS = PWC_WEAPSELECTFIRST + MAXSELECTABLEWEAPONS,
|
|
} pweapCmds_t;
|
|
|
|
typedef enum
|
|
{
|
|
PEC_NOCOMMAND,
|
|
PEC_ITEMNEXT,
|
|
PEC_ITEMPREV,
|
|
PEC_DROP,
|
|
PEC_USEITEM,
|
|
PEC_USEITEMFIRST,
|
|
PEC_NUMCMDS = PEC_USEITEMFIRST + MAXITEMS,
|
|
} pequipCmds_t;
|
|
|
|
typedef struct attackInfoExtra_s
|
|
{
|
|
int ammoType;
|
|
float noiseRad;
|
|
float waver; // waver should be in terms of degrees per consecutive shot...
|
|
float waverMax;
|
|
float kickAmount;
|
|
attacks_e id;
|
|
}attackInfoExtra_t;
|
|
|
|
typedef struct weaponInfoExtra_s
|
|
{
|
|
char *name;
|
|
int slotsNeeded;
|
|
int clipsize;
|
|
attackInfoExtra_t *a1;
|
|
attackInfoExtra_t *a2;
|
|
} weaponInfoExtra_t;
|
|
|
|
enum
|
|
{
|
|
FIRE_NORMAL = 0,
|
|
FIRE_ALT,
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// weaponInfo_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class weaponInfo_c
|
|
{
|
|
private:
|
|
protected:
|
|
|
|
int clip;
|
|
int slotsNeeded;
|
|
int ammoType[2];
|
|
float noiseRad[2];
|
|
float waver[2];
|
|
float waverMax[2];
|
|
char modelName[128];//hardcodedness...
|
|
GhoulID soundToken;
|
|
float kick[2];
|
|
attacks_e atkID[2];
|
|
IGhoulObj *obj;
|
|
|
|
public:
|
|
|
|
weaponInfo_c(void){soundToken = NULL_GhoulID;obj = 0;}
|
|
weaponInfo_c(weaponInfoExtra_t *w);
|
|
~weaponInfo_c(void){}
|
|
|
|
int getClipSize(void) {return clip;}
|
|
int getSlotsNeeded(void) {return slotsNeeded;}
|
|
int getAmmoType(int mode) {return ammoType[mode];}
|
|
float getWaver(int mode){return waver[mode];}
|
|
float getWaverMax(int mode){return waverMax[mode];}
|
|
float getKick(int mode){return kick[mode];}
|
|
attacks_e getAtkID(int mode){return atkID[mode];}
|
|
|
|
char *getWeaponName(void){return modelName;}
|
|
|
|
virtual char *getFireSeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getAltFireSeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getIdleSeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getReloadSeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getTakeOutSeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getPutAwaySeq(sharedEdict_t &ent){return NULL;}
|
|
virtual char *getDryfireSeq(sharedEdict_t &ent){return NULL;}
|
|
|
|
virtual char *getName(void){return "";}
|
|
virtual GhoulSpeed getFireSpeed(void){return gsOne;}
|
|
|
|
virtual void shutdownWeapon(sharedEdict_t &ent){};
|
|
virtual void noattack(sharedEdict_t &ent){};
|
|
|
|
virtual int handleEOS(sharedEdict_t &ent){return 0;}
|
|
virtual void handleFireLoop(sharedEdict_t &ent){}
|
|
virtual void handleAltfireLoop(sharedEdict_t &ent){}
|
|
virtual void handleSpecialNotes(char *string, sharedEdict_t &ent){}
|
|
|
|
virtual int useAmmo1(sharedEdict_t &ent, int *skipIdle = 0);
|
|
virtual int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
virtual void turnOffAmmoParts(sharedEdict_t &ent,int clipLeft,qboolean forceAll=false){};
|
|
|
|
virtual int canSelectWithNoAmmo(void){return 0;}
|
|
|
|
virtual void setBloody(sharedEdict_t *self){}
|
|
|
|
virtual int testInput(sharedEdict_t &ent){return 0;}
|
|
|
|
void setSoundToken(GhoulID newID){soundToken = newID;}
|
|
GhoulID getSoundToken(void){return soundToken;}
|
|
void setGhoulObj(IGhoulObj *newObj){obj = newObj;}
|
|
IGhoulObj *getGhoulObj(void){return obj;}
|
|
|
|
virtual int atMomentOfFire(sharedEdict_t &ent){return 1;}
|
|
virtual int isSingleReload(void){return 0;}
|
|
|
|
float getNoiseVal(int num){return noiseRad[num];}
|
|
|
|
virtual void handleFall(sharedEdict_t &ent){};
|
|
virtual int testReloadAtInit(sharedEdict_t &ent){return 1;}
|
|
virtual int checkReloadAtEOS(sharedEdict_t &ent);
|
|
|
|
virtual int hasAltFire(void){return 0;}
|
|
virtual int getType(void){return SFW_EMPTYSLOT;}
|
|
virtual int fireFromFlash(void){return 0;}
|
|
virtual qboolean aimAtCrosshair(void){return true;}
|
|
virtual void precacheResources(void);
|
|
|
|
virtual IGhoulInst::EndCondition getLoopType(void){return IGhoulInst::Hold;}
|
|
|
|
// virtual void frameUpdate(sharedEdict_t &ent){};
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// weapon_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class weapon_c
|
|
{
|
|
private:
|
|
|
|
int curClip;
|
|
int type;
|
|
int cannotFire;
|
|
|
|
public:
|
|
|
|
weapon_c(void);
|
|
weapon_c(weaponInfo_c *wInfo);
|
|
~weapon_c(void){};
|
|
|
|
int getType(void){return type;}
|
|
void setType(int newType, int startWithFullClip = 0);
|
|
weaponInfo_c *getWeaponInfo(void);
|
|
int handleAmmo(sharedEdict_t &ent, int mode, int *skipIdle = 0);
|
|
int canSelect(sharedEdict_t &ent,int withNoAmmo=0);
|
|
int getClip(void){return curClip;}
|
|
void setClip(int clip){curClip = clip;}
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// itemSlot_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class itemSlot_c
|
|
{
|
|
private:
|
|
|
|
int itemType;
|
|
int ammo;
|
|
int status;
|
|
float nextupdate;
|
|
|
|
public:
|
|
|
|
itemSlot_c(void);
|
|
~itemSlot_c(void){}
|
|
|
|
void clear(void);
|
|
int getSlotType(void){return itemType;}
|
|
int getSlotCount(void){return ammo;}
|
|
int getSlotStatus(void){return status;}
|
|
float getSlotUpdateTime(void){return nextupdate;}
|
|
|
|
void setSlotType(int newVal){itemType = newVal;}
|
|
void setSlotCount(int newVal){ammo = newVal;}
|
|
void setSlotStatus(int newVal){status = newVal;}
|
|
void setSlotUpdateTime(float newFloat){nextupdate = newFloat;}
|
|
|
|
void useAmmo(sharedEdict_t &ent);
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// item_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class item_c
|
|
{
|
|
private:
|
|
|
|
int curSlotNum;
|
|
int nextCommand;
|
|
int lastUseTime;
|
|
itemSlot_c slots[MAXITEMS];
|
|
|
|
void HandleInput(sharedEdict_t &ent);
|
|
|
|
public:
|
|
|
|
item_c(void);
|
|
~item_c(void){}
|
|
|
|
itemSlot_c *getCurSlot(void){return &slots[curSlotNum];}
|
|
itemSlot_c *getSlot(int i){return &slots[i];}
|
|
int getSlotNumFromName(char *itemName);
|
|
void frameUpdate(sharedEdict_t &ent);
|
|
void deactivate(sharedEdict_t &ent);
|
|
int addItemType(int type, int amount, int maxAmount);
|
|
int hasItemType(int type);
|
|
void setNextCommand(int cmd){nextCommand = cmd;}
|
|
int handleDamage(sharedEdict_t &ent, int initDamage);
|
|
void clearSlot(int slotNum){slots[slotNum].setSlotType(SFE_EMPTYSLOT);slots[slotNum].setSlotCount(0);}
|
|
int getCurType(void){return getCurSlot()->getSlotType();}
|
|
int getCurAmmo(void){return getCurSlot()->getSlotCount();}
|
|
int getNextCommand(void){return nextCommand;}
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// wAnim_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class wAnim_c
|
|
{
|
|
private:
|
|
|
|
int handsOnWeapon;
|
|
int weaponLifted;
|
|
int justTransitioned;
|
|
int bloodyKnife;
|
|
int handSide;
|
|
char curSeqName[MAX_QPATH];
|
|
int fireLoopNum;
|
|
int animType;
|
|
int knifeThrow; // needed because of the split knife throwing anim...
|
|
int isDown;
|
|
int firstShotInSeq; // for damn ingram
|
|
int inZoom;
|
|
int inZoomView;
|
|
int interesting;
|
|
int rezoom;
|
|
int inDisguise;
|
|
float lastShootTime; //can't shoot twice in a frame
|
|
|
|
public:
|
|
|
|
int getJustTransitioned(void){return justTransitioned;}
|
|
void setTransition(int val){assert(val > -1);assert(val < 2);justTransitioned = val;}
|
|
int getHandsInUse(void){return handsOnWeapon;}
|
|
void setHandsInUse(int val){assert(val > 0);assert(val < 3);handsOnWeapon = val;}
|
|
int getWeaponLifted(void){return weaponLifted;}
|
|
void setWeaponLifted(int val){assert(val > -1);assert(val < 2);weaponLifted = val;}
|
|
void setBloody(int state){bloodyKnife = state;}
|
|
int getBloody(void){return bloodyKnife;}
|
|
void setHandSide(int newSide){handSide = newSide;}
|
|
int getHandSide(void){return handSide;}
|
|
void setSeqName(char *name){strncpy(curSeqName, name, MAX_QPATH);}
|
|
char *getSeqName(void){return curSeqName;}//eh?
|
|
int getFireLoop(void){return fireLoopNum;}
|
|
void incFireLoop(void){fireLoopNum++;}
|
|
void clearFireLoop(void){fireLoopNum = 0;}
|
|
int getAnimType(void){return animType;}
|
|
void setAnimType(int val){assert(val < WANIM_TYPES);assert(val > -1);animType = val;}
|
|
int getKnifeStatus(void){return knifeThrow;}
|
|
void setKnifeStatus(int val){knifeThrow = val;}
|
|
int getDown(void){return isDown;}
|
|
void setDown(int val){isDown = val;}
|
|
int firstShot(void){return firstShotInSeq;}
|
|
void setFirstShot(int val){firstShotInSeq = val;}
|
|
int getInZoom(void){return inZoom;}
|
|
void setInZoom(int val){inZoom = val;}
|
|
int getInZoomView(void){return inZoomView;}
|
|
void setInZoomView(int val){inZoomView = val;}
|
|
int getLastWasInteresting(void){return interesting;}
|
|
void setInteresting(int val){(val) ? interesting = 2:interesting--; if(interesting < 0)interesting = 0;}
|
|
int getRezoom(void){return rezoom;}
|
|
void setRezoom(int val){rezoom = val;}
|
|
int disguised(void){return inDisguise;}
|
|
void setDisguise(int val){inDisguise = val;}
|
|
void setlastShootTime(float val){lastShootTime = val;}
|
|
float getlastShootTime(void){return lastShootTime;}
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// inven_c
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class inven_c:public invPub_c
|
|
{
|
|
private:
|
|
|
|
clientRICBuf *clientRICBuffer;
|
|
serverRICBuf *serverRICBuffer;
|
|
|
|
#define INVEN_SAVE_START offsetof(inven_c, nextCommand)
|
|
|
|
int nextCommand;
|
|
int clientOverrideCmd;
|
|
int newInstRxd;
|
|
int nextSelectSlot;
|
|
int curWeaponID;
|
|
int curWeaponType;
|
|
int curWeaponSlot;
|
|
|
|
int readiedWeaponID;
|
|
int readiedWeaponType;
|
|
int readiedWeaponSlot;
|
|
|
|
int droppingSlot;
|
|
weapon_c weapons[MAXWEAPONS];
|
|
qboolean rulesWeaponsUseAmmo;
|
|
qboolean rulesDropWeapons;
|
|
int rulesNonDroppableWeaponTypes;
|
|
qboolean rulesWeaponsReload;
|
|
qboolean rulesReloadEmptiesWeapon;
|
|
qboolean rulesWeaponReloadAutomatic;
|
|
qboolean rulesDropInvenOnDeath;
|
|
qboolean rulesSelectWithNoAmmo;
|
|
char rulesBestWeaponMode[5];
|
|
qboolean rulesFreelySelectWeapon;
|
|
int ammo[MAXAMMOS];
|
|
int canHandleInput;
|
|
IGhoulInst *model;
|
|
|
|
IGhoulInst *readyModel;
|
|
|
|
int selectedWeaponSlot;
|
|
int armor;
|
|
int weaponsOwned;
|
|
int pendingChange;
|
|
int clientPredicting;
|
|
|
|
Matrix4 gunEnd;
|
|
sharedEdict_t *owner;
|
|
|
|
item_c items;
|
|
|
|
wAnim_c wAnim;
|
|
|
|
void handleInput(void);
|
|
void handleModelChange(void);
|
|
int getWeaponNum(int cmd);
|
|
|
|
public:
|
|
|
|
inven_c(void);
|
|
~inven_c(void);
|
|
|
|
// -------------------
|
|
// Inherited functions
|
|
// -------------------
|
|
// These are the interface to the invenory / weapon system and are callable
|
|
// outside the player DLL.
|
|
// -------------------
|
|
|
|
void initNewWeapon(void);
|
|
void clearInv(bool);
|
|
void removeSpecificItem(int type);
|
|
|
|
void handlePlayerDeath(void);
|
|
void frameUpdate(void);
|
|
|
|
int addCommand(char *string,qboolean internal=false);
|
|
void stockWeapons(void);
|
|
|
|
int selectWeapon(int type);
|
|
void selectWeaponSlot(int weaponNum);
|
|
void selectBestWeapon(void);
|
|
void takeOutWeapon(int type);
|
|
void takeOutWeaponSlot(int weaponNum);
|
|
void takeOutBestWeapon(void);
|
|
|
|
int addAmmoByGunType(int type, int amount);
|
|
int stripAmmoFromGun(int type, int amount);
|
|
int addAmmoType(int type, int amount);
|
|
int addWeaponType(int type, int fullClip = 0);
|
|
int getEncumbrance(void);
|
|
int getEncumbranceByType(int weapon);
|
|
int addItem(int type, int amount, int maxAmount = -1);//{return items.addItemType(type, amount, maxAmount);}
|
|
int addArmor(int amount){if((armor==100&&amount>=0)||(armor==0&&amount<=0))return 0;armor += amount;if(armor>100)armor=100;else if(armor<0)armor=0;return armor;} // Biessman sez, "max of 100"
|
|
|
|
int hasWeaponType(int type){return (weaponsOwned & (1<<type));}
|
|
int hasItemType(int type){return items.hasItemType(type);}
|
|
int getCurWeaponType(void){return curWeapon()->getType();}
|
|
|
|
int getReadiedWeaponType(void){return readiedWeapon()->getType();}
|
|
|
|
int getBestWeaponType(void);
|
|
int getCurItemType(void){return items.getCurType();}
|
|
int getCurItemAmount(void){return items.getCurAmmo();}
|
|
int getCurAmmo(void){return ammo[curInfo()->getAmmoType(0)];}
|
|
int getReadiedAmmo(void){return ammo[readiedInfo()->getAmmoType(0)];}
|
|
int getCurClip(void){return curWeapon()->getClip();}
|
|
int getClipMax(void){return curInfo()->getClipSize();}
|
|
int getClipMaxByType(int weapon);
|
|
int adjustDamageByArmor(int initDamage, float penetrate, float absorb);
|
|
int getArmorCount(void){return armor;}
|
|
|
|
int scopeIsActive(void){return wAnim.getInZoomView();}
|
|
void setBloodyWeapon(int isBloody);
|
|
int inDisguise(void){return wAnim.disguised();}
|
|
void becomeDisguised(void);
|
|
|
|
int rulesDoWeaponsUseAmmo(void);
|
|
void rulesSetWeaponsUseAmmo(int useAmmo);
|
|
int rulesCanDropWeapons(void);
|
|
void rulesSetDropWeapons(int dropWeapons);
|
|
int rulesGetNonDroppableWeaponTypes(void);
|
|
void rulesSetNonDroppableWeaponTypes(int nonDropMask);
|
|
int rulesDoWeaponsReload(void);
|
|
void rulesSetWeaponsReload(int weaponsReload);
|
|
int rulesIsWeaponReloadAutomatic(void);
|
|
void rulesSetWeaponReloadAutomatic(int reloadAutomatic);
|
|
int rulesDoReloadEmptiesWeapon(void);
|
|
void rulesSetReloadEmptiesWeapon(int reloadEmptiesWeapon);
|
|
char *rulesGetBestWeaponMode(void);
|
|
void rulesSetBestWeaponMode(char *bestWeaponMode);
|
|
int rulesCanDropInvenOnDeath(void);
|
|
void rulesSetDropInvenOnDeath(int dropInvenOnDeath);
|
|
int rulesCanSelectWithNoAmmo(void);
|
|
void rulesSetSelectWithNoAmmo(int selectWithNoAmmo);
|
|
int rulesCanFreelySelectWeapon(void);
|
|
void rulesSetFreelySelectWeapon(int freelySelectWeapon);
|
|
|
|
int removeCurrentWeapon(void);
|
|
int countWeapons(void);
|
|
void setOwner(void *newOwner){owner = (sharedEdict_t *)newOwner;}
|
|
void dropAllWeapons(void);
|
|
|
|
void handleFall(void){curInfo()->handleFall(*owner);}
|
|
|
|
int extractInvFromMenu(int *weaponsAvailable, int *health);
|
|
void buildInvForMenu(int includeClipAmmo, int health);
|
|
|
|
int extractInvFromString(int *weaponsAvailable,char *invString);
|
|
void buildInvString(char *string,qboolean xtractWeapons,qboolean xtractAmmo,qboolean xtractItems,qboolean xtractArmor);
|
|
|
|
void clientClearRICs(void);
|
|
void clientReadRICs(void);
|
|
void clientProcessRICs(void);
|
|
void serverClearRICs(void);
|
|
void serverWriteRICs(void);
|
|
|
|
void setClientPredicting(int predicting){clientPredicting=predicting;}
|
|
int isClientPredicting(void){return(clientPredicting);}
|
|
|
|
// ---------------
|
|
// Everything else
|
|
// ---------------
|
|
// IMPORTANT! Do not call these functions outside of the player DLL! Doing
|
|
// so will totally screw any chance of the weapon / inventory system being
|
|
// portable to the client.
|
|
// ---------------
|
|
|
|
// general weapon stuff
|
|
|
|
weapon_c *getCurWeapon(void){return curWeapon();}//legacy... sigh...
|
|
int getCurWeaponID(void) {return curWeaponID;}
|
|
|
|
weapon_c *getReadiedWeapon(void){return readiedWeapon();}//legacy... sigh...
|
|
int getReadiedWeaponID(void) {return readiedWeaponID;}
|
|
|
|
item_c *getItems(void) {return &items;}
|
|
void addWeaponToOwnList(int weapon){weaponsOwned |= (1<<weapon);}
|
|
void removeWeaponFromOwnList(int weapon){weaponsOwned &= ~(1<<weapon);}
|
|
void setPendingChange(void){pendingChange = 1;}
|
|
void deactivateCurrentWeapon(void);
|
|
void deactivateInventory(void);
|
|
|
|
sharedEdict_t *getOwner(void){return owner;}
|
|
|
|
// input stuff
|
|
|
|
void setInputStatus(int i){canHandleInput = i;}
|
|
int getInputStatus(void) {return canHandleInput;}
|
|
int checkCommandInput(void);
|
|
int pendingCommand(void){return (nextCommand != PWC_NOCOMMAND);};
|
|
void SelectPendingWeapon(void);
|
|
void readyNextWeapon(void);
|
|
void SelectRediedWeapon(void);
|
|
void selectNULLWeapon(void);
|
|
|
|
// viewmodel stuff
|
|
|
|
IGhoulInst *getViewModel(void){return model;}
|
|
void setViewModel(IGhoulInst *newInst){model = newInst;}
|
|
char *getViewModelName(void){return curWeapon()->getWeaponInfo()->getWeaponName();}
|
|
|
|
IGhoulInst *getReadyModel(void){return readyModel;}
|
|
void setReadyModel(IGhoulInst *newInst){readyModel = newInst;}
|
|
char *getReadyModelName(void){return readiedWeapon()->getWeaponInfo()->getWeaponName();}
|
|
|
|
void setGunEnd(Matrix4 &source){gunEnd = source;}//fixme
|
|
void getGunEnd(vec3_t worldSpot);
|
|
|
|
// ammo stuff
|
|
|
|
int refillCurClip(int curSlot, int ignoreSingle = 0, int noFillForSingle = 1);
|
|
int hasAmmo(int type){ assert(type >= 0); assert(type < MAXAMMOS); return (ammo[type] != 0);}
|
|
int getAmmoAmount(int type){assert(type >= 0); assert(type < MAXAMMOS); return(ammo[type]);}
|
|
void setAmmoAmount(int type, int newVal){assert(type >= 0); assert(type < MAXAMMOS); ammo[type] = newVal;}
|
|
void setCurClip(int val){curWeapon()->setClip(val);}
|
|
|
|
// armor stuff
|
|
|
|
void setArmor(int amount){armor = amount;}
|
|
|
|
// attack funcs
|
|
|
|
int fire(); // return value indicates whether the weapon can actually fire at this point
|
|
int altFire(); // ditto
|
|
int reload();
|
|
int clientReload();
|
|
int putAway();
|
|
int takeOut();
|
|
int idle(void);
|
|
void idleReadied(void);
|
|
int dryfire(void);
|
|
int loseWeapon(void);
|
|
|
|
wAnim_c *getAnimInfo(void){return &wAnim;}
|
|
|
|
weaponInfo_c *curInfo(void);
|
|
void setWInfo(int newType){curWeaponType = newType;}
|
|
weapon_c *curWeapon(void);
|
|
void setCurWeapon(int slot){curWeaponSlot = slot;}
|
|
|
|
weaponInfo_c *readiedInfo(void);
|
|
void setReadiedWInfo(int newType){readiedWeaponType = newType;}
|
|
weapon_c *readiedWeapon(void);
|
|
void setReadiedWeapon(int slot){readiedWeaponSlot = slot;}
|
|
|
|
weapon_c *droppingWeapon(void){if(droppingSlot== -1)return 0; return &weapons[droppingSlot];}
|
|
void setDroppingWeapon(int slot){droppingSlot = slot;}
|
|
int getCurSlot(void){return curWeaponSlot;}
|
|
int getBestSlot(int safe);
|
|
|
|
inven_c(inven_c *orig);
|
|
void Evaluate(inven_c *orig);
|
|
void Write(void);
|
|
void Read(void);
|
|
void NetRead(struct sizebuf_s *net_message_ptr);
|
|
void NetWrite(int clientnum);
|
|
void getServerState(void);
|
|
void setServerState(void);
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// Callback Declarations
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class WeapSoundCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class GunFireCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class AltfireCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class EOSCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class KnifeCleanCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class MinimiReloadCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
class EffectCallBack:public IGhoulCallBack
|
|
{
|
|
public:
|
|
|
|
virtual bool Execute(IGhoulInst *me,void *user,float now,const void *data);
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// External Callbacks
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
extern WeapSoundCallBack theWeapSoundCallback;
|
|
extern GunFireCallBack theGunFireCallback;
|
|
extern AltfireCallBack theAltfireCallback;
|
|
extern EOSCallBack theEOSCallback;
|
|
extern KnifeCleanCallBack theKnifeCleanCallback;
|
|
extern MinimiReloadCallBack theMinimiReloadCallback;
|
|
extern EffectCallBack theEffectCallback;
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// Inherited Weapon Definitions
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
class knifeInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
knifeInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Knife";}
|
|
|
|
int useAmmo1(sharedEdict_t &ent, int *skipIdle = 0){return 1;}
|
|
int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
void handleFireLoop(sharedEdict_t &ent);
|
|
void handleAltfireLoop(sharedEdict_t &ent);
|
|
int checkReloadAtEOS(sharedEdict_t &ent){return 0;}//this is silly. No.
|
|
|
|
void handleSpecialNotes(char *string, sharedEdict_t &ent);
|
|
|
|
char *getSlashLeft(void);
|
|
char *getSlashRight(void);
|
|
|
|
int canSelectWithNoAmmo(void){return 1;}
|
|
|
|
void setBloody(sharedEdict_t *self);
|
|
|
|
int getType(void){return SFW_KNIFE;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
void precacheResources(void);
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
};
|
|
|
|
class pistol2Info : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
pistol2Info(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Desert Eagle";}
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_PISTOL2;}
|
|
|
|
int canSelectWithNoAmmo(void){return 0;}
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class pistol1Info: public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
pistol1Info(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Glock 9mm";}
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
void handleAltfireLoop(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_PISTOL1;}
|
|
|
|
int atMomentOfFire(sharedEdict_t &ent);
|
|
int testInput(sharedEdict_t &ent);
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class machinePistolInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
machinePistolInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Ingram m11";}
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
void handleFireLoop(sharedEdict_t &ent);
|
|
int atMomentOfFire(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_MACHINEPISTOL;}
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
void precacheResources(void);
|
|
|
|
IGhoulInst::EndCondition getLoopType(void){return IGhoulInst::Hold;}
|
|
};
|
|
|
|
class assaultRifleInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
assaultRifleInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "HK53";}
|
|
|
|
int getType(void){return SFW_ASSAULTRIFLE;}
|
|
|
|
int atMomentOfFire(sharedEdict_t &ent);
|
|
|
|
int useAmmo1(sharedEdict_t &ent, int *skipIdle = 0);
|
|
void turnOffAmmoParts(sharedEdict_t &ent,int clipLeft,qboolean forceAll=false);
|
|
|
|
void handleSpecialNotes(char *string, sharedEdict_t &ent);
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
void precacheResources(void);
|
|
|
|
IGhoulInst::EndCondition getLoopType(void){return IGhoulInst::Hold;}
|
|
};
|
|
|
|
class sniperInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
sniperInfo(weaponInfoExtra_t *w);
|
|
|
|
void shutdownWeapon(sharedEdict_t &ent);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Sig2000G";}
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
void handleFireLoop(sharedEdict_t &ent);
|
|
void handleAltfireLoop(sharedEdict_t &ent);
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_SNIPER;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class autoshotgunInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
autoshotgunInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Jackhammer";}
|
|
GhoulSpeed getFireSpeed(void){return gsOne;}
|
|
|
|
int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_AUTOSHOTGUN;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
int fireFromFlash(void){return 1;}
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class shotgunInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
shotgunInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Spas15";}
|
|
int useAmmo1(sharedEdict_t &ent, int *skipIdle =0);
|
|
|
|
int isSingleReload(void){return 1;}
|
|
int handleEOS(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_SHOTGUN;}
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
int testReloadAtInit(sharedEdict_t &ent){return 1;}
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class machinegunInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
machinegunInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Minimi";}
|
|
GhoulSpeed getFireSpeed(void){return gsOne;}
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
int useAmmo1(sharedEdict_t &ent, int *skipIdle = 0);
|
|
int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
void turnOffAmmoParts(sharedEdict_t &ent,int clipLeft,qboolean forceAll=false);
|
|
|
|
void handleSpecialNotes(char *string, sharedEdict_t &ent);
|
|
|
|
void handleFall(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_MACHINEGUN;}
|
|
|
|
int atMomentOfFire(sharedEdict_t &ent);
|
|
int testInput(sharedEdict_t &ent);
|
|
|
|
int hasAltFire(void){return 1;}
|
|
void precacheResources(void);
|
|
|
|
IGhoulInst::EndCondition getLoopType(void){return IGhoulInst::Hold;}
|
|
};
|
|
|
|
class rocketInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
rocketInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "M202A2";}
|
|
|
|
int getType(void){return SFW_ROCKET;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
void handleFireLoop(sharedEdict_t &ent);
|
|
int atMomentOfFire(sharedEdict_t &ent);
|
|
|
|
int fireFromFlash(void){return 1;}
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class microInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
microInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Microwave Pulse";}
|
|
|
|
int getType(void){return SFW_MICROWAVEPULSE;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
|
|
int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
int testInput(sharedEdict_t &ent);
|
|
|
|
int fireFromFlash(void){return 1;}
|
|
qboolean aimAtCrosshair(void){return false;}
|
|
void precacheResources(void);
|
|
};
|
|
|
|
class flamegunInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
flamegunInfo(weaponInfoExtra_t *w);
|
|
|
|
void shutdownWeapon(sharedEdict_t &ent);
|
|
void noattack(sharedEdict_t &ent);
|
|
|
|
char *getFireSeq(sharedEdict_t &ent);
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getAltFireSeq(sharedEdict_t &ent);
|
|
char *getReloadSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getPutAwaySeq(sharedEdict_t &ent);
|
|
char *getDryfireSeq(sharedEdict_t &ent);
|
|
|
|
char *getName(void){return "Flamethrower";}
|
|
|
|
int useAmmo1(sharedEdict_t &ent, int *skipIdle = 0);
|
|
int useAmmo2(sharedEdict_t &ent, int *skipIdle = 0);
|
|
|
|
int handleEOS(sharedEdict_t &ent);
|
|
void handleFireLoop(sharedEdict_t &ent);
|
|
void handleAltfireLoop(sharedEdict_t &ent);
|
|
int checkReloadAtEOS(sharedEdict_t &ent){return 0;}
|
|
|
|
int testInput(sharedEdict_t &ent);
|
|
|
|
int getType(void){return SFW_FLAMEGUN;}
|
|
|
|
int hasAltFire(void){return 1;}
|
|
int fireFromFlash(void){return 1;}
|
|
qboolean aimAtCrosshair(void){return false;}
|
|
void precacheResources(void);
|
|
|
|
// void frameUpdate(sharedEdict_t &ent);
|
|
};
|
|
|
|
|
|
class hurthandInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
hurthandInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getName(void){return "Hurthand";}
|
|
int getType(void){return SFW_HURTHAND;}
|
|
int handleEOS(sharedEdict_t &ent);
|
|
};
|
|
|
|
class throwhandInfo : public weaponInfo_c
|
|
{
|
|
private:
|
|
public:
|
|
|
|
throwhandInfo(weaponInfoExtra_t *w);
|
|
|
|
char *getIdleSeq(sharedEdict_t &ent);
|
|
char *getTakeOutSeq(sharedEdict_t &ent);
|
|
char *getName(void){return "Throwhand";}
|
|
int getType(void){return SFW_THROWHAND;}
|
|
int handleEOS(sharedEdict_t &ent);
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// sharedEdict_s
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
struct sharedEdict_s
|
|
{
|
|
inven_c *inv;
|
|
edict_t *edict;
|
|
int attack;
|
|
int altattack;
|
|
int weap3;
|
|
int weap4;
|
|
int leanLeft;
|
|
int leanRight;
|
|
int cinematicFreeze;
|
|
int rejectSniper;
|
|
float *weaponkick_angles; // Really, a vec3_t.
|
|
float framescale;
|
|
int doReload;
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// Weapon inline access type funcs...
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
_inline inven_c *inven(sharedEdict_t &ent)
|
|
{
|
|
return ent.inv;
|
|
}
|
|
|
|
_inline wAnim_c *wAnim(sharedEdict_t &ent)
|
|
{
|
|
return inven(ent)->getAnimInfo();
|
|
}
|
|
|
|
//------------------------------------------------------------------------
|
|
//
|
|
// Misc
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
void W_PrecacheViewWeaponModels(int types);
|
|
void W_UncacheViewWeaponModels(void);
|
|
|
|
extern weaponInfo_c *weapInfo[SFW_NUM_WEAPONS];
|
|
|
|
#endif // __W_WEAPONS_H
|