mirror of
https://github.com/DrBeef/Doom3Quest.git
synced 2025-02-24 12:51:18 +00:00
15f78d843b
Bringing all the changes done (mostly by baggyg) in the OVRPassToVR branch bringing over the major FP related changes to master. Please refer to that branch for the individual changes that have all been brought over in this single commit. Co-Authored-By: Grant Bagwell <general@grantbagwell.co.uk>
1267 lines
41 KiB
C++
1267 lines
41 KiB
C++
/*
|
|
===========================================================================
|
|
|
|
Doom 3 GPL Source Code
|
|
Copyright (C) 1999-2011 id Software LLC, a ZeniMax Media company.
|
|
|
|
This file is part of the Doom 3 GPL Source Code ("Doom 3 Source Code").
|
|
|
|
Doom 3 Source Code is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
Doom 3 Source Code is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Doom 3 Source Code. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
In addition, the Doom 3 Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 Source Code. If not, please request a copy in writing from id Software at the address below.
|
|
|
|
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
|
|
|
|
===========================================================================
|
|
*/
|
|
|
|
#ifndef __GAME_PLAYER_H__
|
|
#define __GAME_PLAYER_H__
|
|
|
|
#include <idlib/math/Quat.h>
|
|
#include "idlib/math/Interpolate.h"
|
|
|
|
#include "physics/Physics_Player.h"
|
|
#include "Item.h"
|
|
#include "Actor.h"
|
|
#include "Weapon.h"
|
|
#include "Projectile.h"
|
|
#include "PlayerIcon.h"
|
|
#include "GameEdit.h"
|
|
#include "PredictedValue.h"
|
|
#include "Vr.h"
|
|
|
|
class idAI;
|
|
|
|
/*
|
|
===============================================================================
|
|
|
|
Player entity.
|
|
|
|
===============================================================================
|
|
*/
|
|
|
|
extern const idEventDef EV_Player_GetButtons;
|
|
extern const idEventDef EV_Player_GetMove;
|
|
extern const idEventDef EV_Player_GetViewAngles;
|
|
extern const idEventDef EV_Player_EnableWeapon;
|
|
extern const idEventDef EV_Player_DisableWeapon;
|
|
extern const idEventDef EV_Player_ExitTeleporter;
|
|
extern const idEventDef EV_Player_SelectWeapon;
|
|
extern const idEventDef EV_SpectatorTouch;
|
|
|
|
const float THIRD_PERSON_FOCUS_DISTANCE = 512.0f;
|
|
const int LAND_DEFLECT_TIME = 150;
|
|
const int LAND_RETURN_TIME = 300;
|
|
const int FOCUS_TIME = 300;
|
|
const int FOCUS_GUI_TIME = 200; // Koz fixme, only change in VR. Previously 500, reduced to 200 to drop weapon out of guis faster.
|
|
const int NUM_QUICK_SLOTS = 4;
|
|
|
|
const int MAX_WEAPONS = 16;
|
|
|
|
const int weapon_empty_hand = -2; // Carl: todo, maybe a different constant
|
|
|
|
const int DEAD_HEARTRATE = 0; // fall to as you die
|
|
const int LOWHEALTH_HEARTRATE_ADJ = 20; //
|
|
const int DYING_HEARTRATE = 30; // used for volumen calc when dying/dead
|
|
const int BASE_HEARTRATE = 70; // default
|
|
const int ZEROSTAMINA_HEARTRATE = 115; // no stamina
|
|
const int MAX_HEARTRATE = 130; // maximum
|
|
const int ZERO_VOLUME = -40; // volume at zero
|
|
const int DMG_VOLUME = 5; // volume when taking damage
|
|
const int DEATH_VOLUME = 15; // volume at death
|
|
|
|
/*const int WEAPON_FISTS = 0;
|
|
const int WEAPON_PISTOL = 1;
|
|
const int WEAPON_SHOTGUN = 2;
|
|
const int WEAPON_MACHINEGUN = 3;
|
|
const int WEAPON_CHAINGUN = 4;
|
|
const int WEAPON_GREANDE = 5;
|
|
const int WEAPON_PLASMARIFLE = 6;
|
|
const int WEAPON_ROCKETLAUNCHER = 7;
|
|
const int WEAPON_BFG = 8;
|
|
const int WEAPON_SOULCUBE = 9;
|
|
const int WEAPON_CHAINSAW = 10;
|
|
const int WEAPON_FLASHLIGHT = 11;*/
|
|
|
|
const int SAVING_THROW_TIME = 5000; // maximum one "saving throw" every five seconds
|
|
|
|
extern const int ASYNC_PLAYER_INV_AMMO_BITS;
|
|
extern const int ASYNC_PLAYER_INV_CLIP_BITS;
|
|
|
|
struct idItemInfo {
|
|
idStr name;
|
|
idStr icon;
|
|
};
|
|
|
|
struct idObjectiveInfo {
|
|
idStr title;
|
|
idStr text;
|
|
idStr screenshot;
|
|
};
|
|
|
|
struct idLevelTriggerInfo {
|
|
idStr levelName;
|
|
idStr triggerName;
|
|
};
|
|
|
|
// powerups - the "type" in item .def must match
|
|
enum {
|
|
BERSERK = 0,
|
|
INVISIBILITY,
|
|
MEGAHEALTH,
|
|
ADRENALINE,
|
|
MAX_POWERUPS
|
|
};
|
|
|
|
// powerup modifiers
|
|
enum {
|
|
SPEED = 0,
|
|
PROJECTILE_DAMAGE,
|
|
MELEE_DAMAGE,
|
|
MELEE_DISTANCE
|
|
};
|
|
|
|
// influence levels
|
|
enum {
|
|
INFLUENCE_NONE = 0, // none
|
|
INFLUENCE_LEVEL1, // no gun or hud
|
|
INFLUENCE_LEVEL2, // no gun, hud, movement
|
|
INFLUENCE_LEVEL3, // slow player movement
|
|
};
|
|
|
|
enum gameExpansionType_t
|
|
{
|
|
GAME_BASE,
|
|
GAME_D3XP,
|
|
GAME_D3LE,
|
|
GAME_UNKNOWN
|
|
};
|
|
|
|
typedef struct
|
|
{
|
|
int ammo;
|
|
int rechargeTime;
|
|
char ammoName[128];
|
|
} RechargeAmmo_t;
|
|
|
|
typedef struct
|
|
{
|
|
char name[64];
|
|
idList<int> toggleList;
|
|
int lastUsed;
|
|
} WeaponToggle_t;
|
|
|
|
class idInventory {
|
|
public:
|
|
int maxHealth;
|
|
int weapons, duplicateWeapons, foundWeapons;
|
|
int powerups;
|
|
int armor;
|
|
int maxarmor;
|
|
int ammo[ AMMO_NUMTYPES ];
|
|
int clip[ MAX_WEAPONS ];
|
|
int clipDuplicate[ MAX_WEAPONS ];
|
|
int powerupEndTime[ MAX_POWERUPS ];
|
|
|
|
// mp
|
|
int ammoPredictTime;
|
|
|
|
int deplete_armor;
|
|
float deplete_rate;
|
|
int deplete_ammount;
|
|
int nextArmorDepleteTime;
|
|
|
|
int pdasViewed[4]; // 128 bit flags for indicating if a pda has been viewed
|
|
|
|
int selPDA;
|
|
int selEMail;
|
|
int selVideo;
|
|
int selAudio;
|
|
bool pdaOpened;
|
|
bool turkeyScore;
|
|
idList<idDict *> items;
|
|
idStrList pdas;
|
|
idStrList pdaSecurity;
|
|
idStrList videos;
|
|
idStrList emails;
|
|
|
|
bool ammoPulse;
|
|
bool weaponPulse;
|
|
bool armorPulse;
|
|
int lastGiveTime;
|
|
|
|
idList<idLevelTriggerInfo> levelTriggers;
|
|
|
|
idInventory() { Clear(); }
|
|
~idInventory() { Clear(); }
|
|
|
|
// save games
|
|
void Save( idSaveGame *savefile ) const; // archives object for save game file
|
|
void Restore( idRestoreGame *savefile ); // unarchives object from save game file
|
|
|
|
void Clear( void );
|
|
void GivePowerUp( idPlayer *player, int powerup, int msec );
|
|
void ClearPowerUps( void );
|
|
void GetPersistantData( idDict &dict );
|
|
void RestoreInventory( idPlayer *owner, const idDict &dict );
|
|
bool Give( idPlayer *owner, const idDict &spawnArgs, const char *statname, const char *value, int *idealWeapon, bool updateHud );
|
|
void Drop( const idDict &spawnArgs, const char *weapon_classname, int weapon_index );
|
|
ammo_t AmmoIndexForAmmoClass( const char *ammo_classname ) const;
|
|
int MaxAmmoForAmmoClass( idPlayer *owner, const char *ammo_classname ) const;
|
|
int WeaponIndexForAmmoClass( const idDict & spawnArgs, const char *ammo_classname ) const;
|
|
ammo_t AmmoIndexForWeaponClass( const char *weapon_classname, int *ammoRequired );
|
|
const char * AmmoPickupNameForIndex( ammo_t ammonum ) const;
|
|
void AddPickupName( const char *name, const char *icon );
|
|
|
|
int HasAmmo( ammo_t type, int amount );
|
|
bool UseAmmo( ammo_t type, int amount );
|
|
int HasAmmo( const char *weapon_classname ); // looks up the ammo information for the weapon class first
|
|
|
|
void UpdateArmor( void );
|
|
int GetClipAmmoForWeapon( const int weapon, const bool duplicate ) const;
|
|
|
|
bool CanGive( idPlayer* owner, const idDict& spawnArgs, const char* statname, const char* value );
|
|
|
|
int nextItemPickup;
|
|
int nextItemNum;
|
|
int onePickupTime;
|
|
idList<idItemInfo> pickupItemNames;
|
|
idList<idObjectiveInfo> objectiveNames;
|
|
};
|
|
|
|
typedef struct {
|
|
int time;
|
|
idVec3 dir; // scaled larger for running
|
|
} loggedAccel_t;
|
|
|
|
typedef struct {
|
|
int areaNum;
|
|
idVec3 pos;
|
|
} aasLocation_t;
|
|
|
|
enum slotIndex_t
|
|
{
|
|
SLOT_NONE = -1,
|
|
SLOT_PDA_HIP,
|
|
SLOT_WEAPON_HIP,
|
|
SLOT_WEAPON_BACK_BOTTOM,
|
|
SLOT_WEAPON_BACK_TOP,
|
|
SLOT_FLASHLIGHT_SHOULDER,
|
|
SLOT_FLASHLIGHT_HEAD,
|
|
SLOT_COUNT
|
|
};
|
|
|
|
struct slot_t
|
|
{
|
|
idVec3 origin;
|
|
float radiusSq;
|
|
};
|
|
|
|
class idWeaponHolder
|
|
{
|
|
public:
|
|
idPlayer* owner;
|
|
int currentWeapon;
|
|
bool isTheDuplicate; // Carl: Dual wielding, is weapon the duplicate copy or the original? (ie. Which ammo clip does it use?)
|
|
public:
|
|
idWeaponHolder();
|
|
virtual ~idWeaponHolder();
|
|
void Init( idPlayer* player );
|
|
virtual bool isEmpty();
|
|
};
|
|
|
|
class idHolster : public idWeaponHolder
|
|
{
|
|
public:
|
|
slotIndex_t slot;
|
|
idVec3 origin;
|
|
float radiusSq;
|
|
renderEntity_t renderEntity; // used to present a model to the renderer
|
|
qhandle_t modelDefHandle; // handle to static renderer model
|
|
idMat3 holsterAxis;
|
|
public:
|
|
idHolster();
|
|
virtual ~idHolster();
|
|
void Init( idPlayer* player );
|
|
void FreeSlot();
|
|
void HolsterModelByName( const char* modelname, idRenderModel* renderModel = NULL );
|
|
void HolsterPDA();
|
|
void HolsterFlashlight();
|
|
void EmptyHolster();
|
|
void HolsterCurrentWeapon( int stashed, int hand );
|
|
void StashToExtraHolster();
|
|
void RestoreFromExtraHolster();
|
|
void UpdateSlot();
|
|
};
|
|
|
|
class idPlayerHand : public idWeaponHolder {
|
|
public:
|
|
int whichHand;
|
|
|
|
// laser sight - technically every weapon instance could have its own laser sight,
|
|
// but laser sights are only active when in a player's hand, so make it one per hand
|
|
renderEntity_t laserSightRenderEntity; // replace crosshair for 3DTV
|
|
qhandle_t laserSightHandle;
|
|
renderEntity_t crosshairEntity; // Koz add a model to place the crosshair into the world
|
|
qhandle_t crosshairHandle;
|
|
int lastCrosshairMode;
|
|
bool laserSightActive; // Koz allow lasersight toggle
|
|
|
|
// throwing is per hand
|
|
idVec3 throwDirection; // for motion control throwing actions e.g. grenade
|
|
float throwVelocity;
|
|
int frameTime[10];
|
|
idVec3 position[10];
|
|
int frameNum;
|
|
int curTime;
|
|
int timeDelta;
|
|
int startFrameNum;
|
|
|
|
// slots
|
|
idVec3 handOrigin;
|
|
idMat3 handAxis;
|
|
slotIndex_t handSlot;
|
|
|
|
bool grabbingWorld, oldGrabbingWorld; // currently this corresponds more to the state of the grip trigger/button which may actually act as a toggle
|
|
bool virtualGrabDown, oldVirtualGrabDown; // this is the actual virtual grab state, when this goes false you should drop what you're holding
|
|
bool triggerDown, oldTriggerDown, oldFlashlightTriggerDown;
|
|
bool thumbDown, oldThumbDown;
|
|
|
|
idEntityPtr<idWeapon> weapon;
|
|
bool weaponGone; // force stop firing
|
|
|
|
// currentWeapon is inherited from the idWeaponHolder superclass
|
|
int idealWeapon;
|
|
int previousWeapon;
|
|
int weaponSwitchTime;
|
|
|
|
// Weapon positioning
|
|
bool PDAfixed; // Koz has the PDA been fixed in space?
|
|
bool lastPdaFixed;
|
|
idVec3 playerPdaPos; // position player was at when pda fixed in space
|
|
idVec3 motionPosition;
|
|
idQuat motionRotation;// = idQuat_zero;
|
|
bool wasPDA;
|
|
|
|
idStr animPrefix; // player hand anims
|
|
|
|
//-----------------------------------------------------------------
|
|
// controller shake parms
|
|
//-----------------------------------------------------------------
|
|
|
|
const static int MAX_SHAKE_BUFFER = 3;
|
|
float controllerShakeHighMag[MAX_SHAKE_BUFFER]; // magnitude of the high frequency controller shake
|
|
float controllerShakeLowMag[MAX_SHAKE_BUFFER]; // magnitude of the low frequency controller shake
|
|
int controllerShakeHighTime[MAX_SHAKE_BUFFER]; // time the controller shake ends for high frequency.
|
|
int controllerShakeLowTime[MAX_SHAKE_BUFFER]; // time the controller shake ends for low frequency.
|
|
int controllerShakeTimeGroup;
|
|
|
|
public:
|
|
idPlayerHand();
|
|
|
|
virtual ~idPlayerHand();
|
|
|
|
void Init(idPlayer *player, int hand);
|
|
|
|
void TrackWeaponDirection(idVec3 origin);
|
|
|
|
virtual bool holdingFlashlight();
|
|
|
|
virtual bool holdingWeapon(); // physically holding it, not just levitating or using fists
|
|
virtual bool
|
|
floatingWeapon(); // the soul cube and the artifact float next to your hand rather than being held
|
|
virtual bool controllingWeapon(); // holding or floating
|
|
virtual bool holdingPDA();
|
|
|
|
virtual bool holdingPhysics();
|
|
|
|
virtual bool holdingItem();
|
|
|
|
virtual bool holdingSomethingDroppable();
|
|
|
|
bool isOverMountedFlashlight();
|
|
|
|
bool tooFullToInteract();
|
|
|
|
bool
|
|
handExists(); // false if our character is missing a hand or has something mounted on their forearm instead
|
|
|
|
bool contextToggleVirtualGrab();
|
|
|
|
bool startVirtualGrab();
|
|
|
|
bool releaseVirtualGrab(); // will drop whatever you're holding
|
|
|
|
idStr GetCurrentWeaponString();
|
|
|
|
void NextWeapon(int dir = 1);
|
|
|
|
void PrevWeapon();
|
|
|
|
void NextBestWeapon();
|
|
|
|
void SelectWeapon(int num, bool force, bool specific);
|
|
|
|
void DropWeapon(bool died);
|
|
|
|
// Controller Shake
|
|
void
|
|
SetControllerShake(float highMagnitude, int highDuration, float lowMagnitude, int lowDuration);
|
|
|
|
void ResetControllerShake();
|
|
|
|
void GetControllerShake(int &highMagnitude, int &lowMagnitude) const;
|
|
|
|
void debugPrint();
|
|
};
|
|
|
|
class idPlayer : public idActor {
|
|
public:
|
|
enum {
|
|
EVENT_IMPULSE = idEntity::EVENT_MAXEVENTS,
|
|
EVENT_EXIT_TELEPORTER,
|
|
EVENT_ABORT_TELEPORTER,
|
|
EVENT_POWERUP,
|
|
EVENT_SPECTATE,
|
|
EVENT_PICKUPNAME,
|
|
EVENT_FORCE_ORIGIN,
|
|
EVENT_KNOCKBACK,
|
|
EVENT_MAXEVENTS
|
|
};
|
|
|
|
static const int MAX_PLAYER_PDA = 100;
|
|
static const int MAX_PLAYER_VIDEO = 100;
|
|
static const int MAX_PLAYER_AUDIO = 100;
|
|
static const int MAX_PLAYER_AUDIO_ENTRIES = 2;
|
|
|
|
usercmd_t oldCmd;
|
|
usercmd_t usercmd;
|
|
|
|
class idPlayerView playerView; // handles damage kicks and effects
|
|
|
|
idPlayerHand hands[2];
|
|
|
|
renderEntity_t flashlightRenderEntity; // used to present a model to the renderer
|
|
qhandle_t flashlightModelDefHandle; // handle to static renderer model
|
|
|
|
// Koz begin
|
|
renderEntity_t headingBeamEntity; // Koz add a heading indicator pointing the direction the players body is facing.
|
|
qhandle_t headingBeamHandle;
|
|
bool headingBeamActive;
|
|
const idDeclSkin* skinHeadingSolid;
|
|
const idDeclSkin* skinHeadingArrows;
|
|
const idDeclSkin* skinHeadingArrowsScroll;
|
|
|
|
renderEntity_t pdaRenderEntity; // used to present a model to the renderer
|
|
qhandle_t pdaModelDefHandle; // handle to static renderer model
|
|
idMat3 pdaHolsterAxis;
|
|
|
|
renderEntity_t holsterRenderEntity; // used to present a model to the renderer
|
|
qhandle_t holsterModelDefHandle; // handle to static renderer model
|
|
idMat3 holsterAxis;
|
|
int holsteredWeapon, extraHolsteredWeapon;
|
|
const char* extraHolsteredWeaponModel;
|
|
|
|
renderEntity_t hudEntity; // Koz add a model to place the hud into the world
|
|
qhandle_t hudHandle;
|
|
bool hudActive;
|
|
|
|
const idDeclSkin* skinCrosshairDot;
|
|
const idDeclSkin* skinCrosshairCircleDot;
|
|
const idDeclSkin* skinCrosshairCross;
|
|
|
|
const idDeclSkin* skinTelepadCrouch;
|
|
|
|
|
|
idEntityPtr<idAnimatedEntity> teleportTarget;
|
|
idAnimator* teleportTargetAnimator;
|
|
|
|
jointHandle_t teleportBeamJoint[24];
|
|
jointHandle_t teleportPadJoint;
|
|
jointHandle_t teleportCenterPadJoint;
|
|
|
|
idVec3 teleportPoint; // Carl: used for teleporting
|
|
idVec3 teleportAimPoint; // Carl: used for teleporting
|
|
idVec3 teleportDir; // direction of teleport movement - needed for scripts where entities check player movement.
|
|
|
|
float teleportAimPointPitch;
|
|
|
|
bool aimValidForTeleport;
|
|
|
|
bool flashlightPreviouslyInHand;
|
|
|
|
idVec3 PDAorigin; // Koz
|
|
idMat3 PDAaxis; // Koz
|
|
|
|
idMat3 chestPivotCorrectAxis; //made these public so could be accessed by hmdgetorientation;
|
|
idVec3 chestPivotDefaultPos;
|
|
jointHandle_t chestPivotJoint;
|
|
//float independentWeaponPitch; // deltas to provide aim independent of body/view orientation
|
|
//float independentWeaponYaw;
|
|
|
|
|
|
// Koz end
|
|
|
|
bool noclip;
|
|
bool godmode;
|
|
bool warpMove, warpAim;
|
|
idVec3 warpVel, warpDest;
|
|
int warpTime;
|
|
|
|
bool jetMove;
|
|
idVec3 jetMoveVel;
|
|
int jetMoveTime;
|
|
int jetMoveCoolDownTime;
|
|
|
|
bool spawnAnglesSet; // on first usercmd, we must set deltaAngles
|
|
idAngles spawnAngles;
|
|
idAngles viewAngles; // player view angles
|
|
idAngles cmdAngles; // player cmd angles
|
|
|
|
int buttonMask;
|
|
int oldButtons;
|
|
int oldFlags;
|
|
|
|
int lastHitTime; // last time projectile fired by player hit target
|
|
int lastSndHitTime; // MP hit sound - != lastHitTime because we throttle
|
|
int lastSavingThrowTime; // for the "free miss" effect
|
|
|
|
bool pdaHasBeenRead[ MAX_PLAYER_PDA ];
|
|
bool videoHasBeenViewed[ MAX_PLAYER_VIDEO ];
|
|
bool audioHasBeenHeard[ MAX_PLAYER_AUDIO ][ MAX_PLAYER_AUDIO_ENTRIES ];
|
|
|
|
idScriptBool AI_FORWARD;
|
|
idScriptBool AI_BACKWARD;
|
|
idScriptBool AI_STRAFE_LEFT;
|
|
idScriptBool AI_STRAFE_RIGHT;
|
|
idScriptBool AI_ATTACK_HELD;
|
|
idScriptBool AI_WEAPON_FIRED;
|
|
idScriptBool AI_JUMP;
|
|
idScriptBool AI_CROUCH;
|
|
idScriptBool AI_ONGROUND;
|
|
idScriptBool AI_ONLADDER;
|
|
idScriptBool AI_DEAD;
|
|
idScriptBool AI_RUN;
|
|
idScriptBool AI_PAIN;
|
|
idScriptBool AI_HARDLANDING;
|
|
idScriptBool AI_SOFTLANDING;
|
|
idScriptBool AI_RELOAD;
|
|
idScriptBool AI_TELEPORT;
|
|
idScriptBool AI_TURN_LEFT;
|
|
idScriptBool AI_TURN_RIGHT;
|
|
|
|
// inventory
|
|
idInventory inventory;
|
|
|
|
int flashlightBattery;
|
|
idEntityPtr<idWeapon> flashlight;
|
|
|
|
idUserInterface * hud; // MP: is NULL if not local player
|
|
idUserInterface * objectiveSystem;
|
|
bool objectiveSystemOpen;
|
|
int quickSlot[ NUM_QUICK_SLOTS ];
|
|
|
|
vrClientInfo *pVRClientInfo;
|
|
|
|
int weapon_soulcube;
|
|
int weapon_pda;
|
|
int weapon_fists;
|
|
int weapon_flashlight;
|
|
int weapon_chainsaw;
|
|
bool harvest_lock;
|
|
// Koz begin
|
|
int weapon_pistol;
|
|
int weapon_shotgun;
|
|
int weapon_machinegun;
|
|
int weapon_chaingun;
|
|
int weapon_handgrenade;
|
|
int weapon_plasmagun;
|
|
int weapon_rocketlauncher;
|
|
int weapon_bfg;
|
|
int weapon_flashlight_new;
|
|
// Koz end
|
|
int heartRate;
|
|
idInterpolate<float> heartInfo;
|
|
int lastHeartAdjust;
|
|
int lastHeartBeat;
|
|
int lastDmgTime;
|
|
int deathClearContentsTime;
|
|
bool doingDeathSkin;
|
|
int lastArmorPulse; // lastDmgTime if we had armor at time of hit
|
|
float stamina;
|
|
float healthPool; // amount of health to give over time
|
|
int nextHealthPulse;
|
|
bool healthPulse;
|
|
bool healthTake;
|
|
int nextHealthTake;
|
|
|
|
|
|
bool hiddenWeapon; // if the weapon is hidden ( in noWeapons maps )
|
|
idEntityPtr<idProjectile> soulCubeProjectile;
|
|
|
|
// mp stuff
|
|
static idVec3 colorBarTable[ 5 ];
|
|
int spectator;
|
|
idVec3 colorBar; // used for scoreboard and hud display
|
|
int colorBarIndex;
|
|
bool scoreBoardOpen;
|
|
bool forceScoreBoard;
|
|
bool forceRespawn;
|
|
bool spectating;
|
|
int lastSpectateTeleport;
|
|
bool lastHitToggle;
|
|
bool forcedReady;
|
|
bool wantSpectate; // from userInfo
|
|
bool weaponGone; // force stop firing
|
|
bool useInitialSpawns; // toggled by a map restart to be active for the first game spawn
|
|
int latchedTeam; // need to track when team gets changed
|
|
int tourneyRank; // for tourney cycling - the higher, the more likely to play next - server
|
|
int tourneyLine; // client side - our spot in the wait line. 0 means no info.
|
|
int spawnedTime; // when client first enters the game
|
|
|
|
idEntityPtr<idEntity> teleportEntity; // while being teleported, this is set to the entity we'll use for exit
|
|
int teleportKiller; // entity number of an entity killing us at teleporter exit
|
|
bool lastManOver; // can't respawn in last man anymore (srv only)
|
|
bool lastManPlayAgain; // play again when end game delay is cancelled out before expiring (srv only)
|
|
bool lastManPresent; // true when player was in when game started (spectators can't join a running LMS)
|
|
bool isLagged; // replicated from server, true if packets haven't been received from client.
|
|
bool isChatting; // replicated from server, true if the player is chatting.
|
|
|
|
// timers
|
|
int minRespawnTime; // can respawn when time > this, force after g_forcerespawn
|
|
int maxRespawnTime; // force respawn after this time
|
|
|
|
renderEntity_t laserSightRenderEntity;
|
|
qhandle_t laserSightHandle;
|
|
|
|
|
|
// the first person view values are always calculated, even
|
|
// if a third person view is used
|
|
idVec3 firstPersonViewOrigin;
|
|
idMat3 firstPersonViewAxis;
|
|
|
|
idVec3 waistOrigin;
|
|
idMat3 waistAxis;
|
|
|
|
idDragEntity dragEntity;
|
|
|
|
//idFuncMountedObject* mountedObject;
|
|
idEntityPtr<idLight> enviroSuitLight;
|
|
|
|
bool healthRecharge;
|
|
int lastHealthRechargeTime;
|
|
int rechargeSpeed;
|
|
|
|
float new_g_damageScale;
|
|
|
|
bool bloomEnabled;
|
|
float bloomSpeed;
|
|
float bloomIntensity;
|
|
|
|
public:
|
|
CLASS_PROTOTYPE( idPlayer );
|
|
|
|
idPlayer();
|
|
virtual ~idPlayer();
|
|
|
|
void SetVRClientInfo(vrClientInfo *pVRClientInfo);
|
|
vrClientInfo* GetVRClientInfo();
|
|
|
|
void Spawn( void );
|
|
void Think( void );
|
|
|
|
void SetupPDASlot( bool holsterPDA );
|
|
void FreePDASlot();
|
|
void UpdatePDASlot();
|
|
|
|
void SetupHolsterSlot( int hand, int stashed = -1 );
|
|
void FreeHolsterSlot();
|
|
void UpdateHolsterSlot();
|
|
|
|
void UpdateLaserSight( int hand );
|
|
bool GetHandOrHeadPositionWithHacks( int hand, idVec3& origin, idMat3& axis );
|
|
|
|
// Koz begin
|
|
void UpdateTeleportAim();
|
|
bool GetTeleportBeamOrigin( idVec3 &beamOrigin, idMat3 &beamAxis);
|
|
void UpdatePlayerSkinsPoses();
|
|
void SetWeaponHandPose();
|
|
void SetFlashHandPose(); // Set flashlight hand pose
|
|
void ToggleLaserSight();
|
|
void UpdateHeadingBeam();
|
|
void ToggleHeadingBeam();
|
|
void UpdateVrHud();
|
|
void ToggleHud();
|
|
void RecreateCopyJoints();
|
|
void UpdateNeckPose();
|
|
bool IsCrouching()
|
|
{
|
|
return physicsObj.IsCrouching();
|
|
}
|
|
void InitTeleportTarget();
|
|
// Koz end
|
|
//GB Begin
|
|
float GetHudAlpha();
|
|
//GB End
|
|
|
|
// Carl begin
|
|
bool HasHoldableFlashlight();
|
|
// Carl end
|
|
|
|
// save games
|
|
void Save( idSaveGame *savefile ) const; // archives object for save game file
|
|
void Restore( idRestoreGame *savefile ); // unarchives object from save game file
|
|
|
|
virtual void Hide( void );
|
|
virtual void Show( void );
|
|
|
|
void Init( void );
|
|
void InitPlayerBones(); // Koz
|
|
void PrepareForRestart( void );
|
|
virtual void Restart( void );
|
|
void LinkScriptVariables( void );
|
|
void SetupWeaponEntity( void );
|
|
void SelectInitialSpawnPoint( idVec3 &origin, idAngles &angles );
|
|
void SpawnFromSpawnSpot( void );
|
|
void SpawnToPoint( const idVec3 &spawn_origin, const idAngles &spawn_angles );
|
|
void SetClipModel( void ); // spectator mode uses a different bbox size
|
|
|
|
void SavePersistantInfo( void );
|
|
void RestorePersistantInfo( void );
|
|
void SetLevelTrigger( const char *levelName, const char *triggerName );
|
|
|
|
bool UserInfoChanged( bool canModify );
|
|
idDict * GetUserInfo( void );
|
|
bool BalanceTDM( void );
|
|
|
|
void CacheWeapons( void );
|
|
|
|
void EnterCinematic( void );
|
|
void ExitCinematic( void );
|
|
bool HandleESC( void );
|
|
bool SkipCinematic( void );
|
|
|
|
void UpdateConditions( void );
|
|
void SetViewAngles( const idAngles &angles );
|
|
|
|
void ControllerShakeFromDamage( int damage );
|
|
void ControllerShakeFromDamage( int damage, const idVec3 &direction );
|
|
void SetControllerShake( float magnitude, int duration, const idVec3 &direction );
|
|
void ResetControllerShake();
|
|
|
|
// delta view angles to allow movers to rotate the view of the player
|
|
void UpdateDeltaViewAngles( const idAngles &angles );
|
|
|
|
virtual bool Collide( const trace_t &collision, const idVec3 &velocity );
|
|
|
|
// Carl : Teleporting
|
|
int PointReachableAreaNum(const idVec3& pos, const float boundsScale = 2.0f) const;
|
|
bool PathToGoal(aasPath_t& path, int areaNum, const idVec3& origin, int goalAreaNum, const idVec3& goalOrigin) const;
|
|
bool CanReachPosition( const idVec3& pos, idVec3& betterPos );
|
|
|
|
virtual void GetAASLocation( idAAS *aas, idVec3 &pos, int &areaNum ) const;
|
|
virtual void GetAIAimTargets( const idVec3 &lastSightPos, idVec3 &headPos, idVec3 &chestPos );
|
|
virtual void DamageFeedback( idEntity *victim, idEntity *inflictor, int &damage );
|
|
void CalcDamagePoints( idEntity *inflictor, idEntity *attacker, const idDict *damageDef,
|
|
const float damageScale, const int location, int *health, int *armor );
|
|
virtual void Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const char *damageDefName, const float damageScale, const int location );
|
|
|
|
// use exitEntityNum to specify a teleport with private camera view and delayed exit
|
|
virtual void Teleport( const idVec3 &origin, const idAngles &angles, idEntity *destination );
|
|
virtual bool TeleportPathSegment( const idVec3& start, const idVec3& end, idVec3& lastPos );
|
|
virtual void TeleportPath( const idVec3& target );
|
|
virtual bool CheckTeleportPathSegment(const idVec3& start, const idVec3& end, idVec3& lastPos);
|
|
virtual bool CheckTeleportPath(const idVec3& target, int toAreaNum = 0);
|
|
|
|
virtual void SetupFlashlightHolster();
|
|
virtual void UpdateFlashlightHolster();
|
|
virtual void SetupLaserSight();
|
|
//virtual void UpdateLaserSight( );
|
|
|
|
void Kill( bool delayRespawn, bool nodamage );
|
|
virtual void Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );
|
|
void StartFxOnBone(const char *fx, const char *bone);
|
|
|
|
bool ShouldBlink();
|
|
renderView_t * GetRenderView( void );
|
|
void CalculateRenderView( void ); // called every tic by player code
|
|
void CalculateFirstPersonView( void );
|
|
void CalculateWaist();
|
|
void CalculateLeftHand();
|
|
void CalculateRightHand();
|
|
|
|
void DrawHUD( idUserInterface *hud );
|
|
// void DrawHUDVR( idMenuHandler_HUD* hudManager );
|
|
void DrawHUDVR( idUserInterface *hud );
|
|
|
|
void WeaponFireFeedback( int hand, const idDict* weaponDef );
|
|
|
|
float DefaultFov( void ) const;
|
|
float CalcFov( bool honorZoom );
|
|
void CalculateViewWeaponPos( int hand, idVec3& origin, idMat3& axis );
|
|
void CalculateViewWeaponPosVR( int hand, idVec3& origin, idMat3& axis );
|
|
void SetHandIKPos( int hand, idVec3 handOrigin, idMat3 handAxis, idQuat rotation, bool isFlashlight = false );
|
|
|
|
// Koz begin
|
|
void CalculateViewFlashlightPos( idVec3 &origin, idMat3 &axis, idVec3 flashlightOffset ); // Koz aim the flashlight with motion controls
|
|
// Koz end
|
|
|
|
idVec3 GetEyePosition( void ) const;
|
|
void GetViewPos( idVec3 &origin, idMat3 &axis ) const;
|
|
void GetViewPosVR( idVec3& origin, idMat3& axis ) const; // Koz fixme
|
|
|
|
void OffsetThirdPersonView( float angle, float range, float height, bool clip );
|
|
|
|
//bool Give( const char *statname, const char *value );
|
|
bool Give( const char* statname, const char* value, int hand );
|
|
bool GiveItem( idItem *item );
|
|
void GiveItem( const char *name );
|
|
void GiveHealthPool( float amt );
|
|
|
|
bool GiveInventoryItem( idDict *item );
|
|
void RemoveInventoryItem( idDict *item );
|
|
bool GiveInventoryItem( const char *name );
|
|
void RemoveInventoryItem( const char *name );
|
|
idDict * FindInventoryItem( const char *name );
|
|
|
|
void SetQuickSlot( int index, int val );
|
|
int GetQuickSlot( int index );
|
|
|
|
void GivePDA( const char *pdaName, idDict *item, bool toggle );
|
|
void GiveVideo( const char *videoName, idDict *item );
|
|
void GiveEmail( const char *emailName );
|
|
void GiveSecurity( const char *security );
|
|
void GiveObjective( const char *title, const char *text, const char *screenshot );
|
|
void CompleteObjective( const char *title );
|
|
|
|
bool GivePowerUp( int powerup, int time );
|
|
void ClearPowerUps( void );
|
|
bool PowerUpActive( int powerup ) const;
|
|
float PowerUpModifier( int type );
|
|
|
|
bool OtherHandImpulseSlot();
|
|
bool WeaponHandImpulseSlot();
|
|
bool GrabWorld( int hand, bool pressed ); // 0 = right hand, 1 = left hand; true if pressed, false if released; returns true if handled as grab
|
|
bool TriggerClickWorld( int hand, bool pressed ); // 0 = right hand, 1 = left hand; true if pressed, false if released; returns true if handled as trigger
|
|
bool ThumbClickWorld( int hand, bool pressed ); // 0 = right hand, 1 = left hand; true if pressed, false if released; returns true if handled as thumb click
|
|
|
|
int SlotForWeapon( const char *weaponName );
|
|
void Reload( void );
|
|
void NextWeapon( void );
|
|
void NextBestWeapon( void );
|
|
void PrevWeapon( void );
|
|
void SetPreviousWeapon( int num )
|
|
{
|
|
hands[ vr_weaponHand.GetInteger() ].previousWeapon = num;
|
|
}
|
|
void SelectWeapon( int num, bool force, bool specific = false );
|
|
void DropWeapons( bool died ) ;
|
|
void StealWeapon( idPlayer *player );
|
|
void AddProjectilesFired( int count );
|
|
void AddProjectileHits( int count );
|
|
void SetLastHitTime( int time );
|
|
void WeaponLoweringCallback( void );
|
|
void WeaponRisingCallback( void );
|
|
void RemoveWeapon( const char *weap );
|
|
bool CanShowWeaponViewmodel( void ) const;
|
|
// Carl: Dual wielding
|
|
bool CanDualWield( int num ) const;
|
|
idWeapon* GetWeaponInHand( int hand ) const;
|
|
// Carl: when the code needs just one weapon, guess which one is the "main" one
|
|
idWeapon* GetMainWeapon();
|
|
idWeapon* GetPDAWeapon() const;
|
|
idWeapon* GetWeaponWithMountedFlashlight();
|
|
int GetBestWeaponHand();
|
|
int GetBestWeaponHandToSteal( idPlayer* thief );
|
|
// Carl: get the specific weapon used to harvest souls (Soul Cube or Artifact)
|
|
// Returns the required one if you're holding it in a hand, or the other one, or the main weapon
|
|
idWeapon* GetHarvestWeapon( idStr requiredWeapons );
|
|
idStr GetCurrentHarvestWeapon( idStr requiredWeapons );
|
|
virtual int GetAnim( int channel, const char* name );
|
|
// Carl end
|
|
|
|
void AddAIKill( void );
|
|
void SetSoulCubeProjectile( idProjectile *projectile );
|
|
|
|
void AdjustHeartRate( int target, float timeInSecs, float delay, bool force );
|
|
void SetCurrentHeartRate( void );
|
|
int GetBaseHeartRate( void );
|
|
void UpdateAir( void );
|
|
|
|
virtual bool HandleSingleGuiCommand( idEntity *entityGui, idLexer *src );
|
|
bool GuiActive( void ) { return focusGUIent != NULL; }
|
|
bool HandleGuiEvents( const sysEvent_t* ev );
|
|
|
|
void PerformImpulse( int impulse );
|
|
void Spectate( bool spectate );
|
|
void TogglePDA( int hand );
|
|
void ToggleScoreboard( void );
|
|
void RouteGuiMouse( idUserInterface *gui );
|
|
void UpdateHud( void );
|
|
const idDeclPDA * GetPDA( void ) const;
|
|
const idDeclVideo * GetVideo( int index );
|
|
void SetInfluenceFov( float fov );
|
|
void SetInfluenceView( const char *mtr, const char *skinname, float radius, idEntity *ent );
|
|
void SetInfluenceLevel( int level );
|
|
int GetInfluenceLevel( void ) { return influenceActive; };
|
|
|
|
void SetPrivateCameraView( idCamera *camView );
|
|
idCamera * GetPrivateCameraView( void ) const { return privateCameraView; }
|
|
|
|
void StartFxFov( float duration );
|
|
void UpdateHudWeapon( int flashWeaponHand );
|
|
void UpdateHudStats( idUserInterface *hud );
|
|
void UpdateHudAmmo( idUserInterface *hud, int hand );
|
|
void Event_StopAudioLog( void );
|
|
bool IsSoundChannelPlaying( const s_channelType channel = SND_CHANNEL_ANY );
|
|
void StartAudioLog( void );
|
|
void StopAudioLog( void );
|
|
void ShowTip( const char *title, const char *tip, bool autoHide );
|
|
void HideTip( void );
|
|
|
|
bool IsTipVisible( void ) { return tipUp; };
|
|
|
|
void ShowObjective( const char *obj );
|
|
void HideObjective( void );
|
|
|
|
virtual void ClientPredictionThink( void );
|
|
virtual void WriteToSnapshot( idBitMsgDelta &msg ) const;
|
|
virtual void ReadFromSnapshot( const idBitMsgDelta &msg );
|
|
void WritePlayerStateToSnapshot( idBitMsgDelta &msg ) const;
|
|
void ReadPlayerStateFromSnapshot( const idBitMsgDelta &msg );
|
|
|
|
virtual bool ServerReceiveEvent( int event, int time, const idBitMsg &msg );
|
|
|
|
virtual bool GetPhysicsToVisualTransform( idVec3 &origin, idMat3 &axis );
|
|
virtual bool GetPhysicsToSoundTransform( idVec3 &origin, idMat3 &axis );
|
|
|
|
virtual bool ClientReceiveEvent( int event, int time, const idBitMsg &msg );
|
|
bool IsReady( void );
|
|
bool IsRespawning( void );
|
|
bool IsInTeleport( void );
|
|
|
|
idEntity *GetInfluenceEntity( void ) { return influenceEntity; };
|
|
const idMaterial *GetInfluenceMaterial( void ) { return influenceMaterial; };
|
|
float GetInfluenceRadius( void ) { return influenceRadius; };
|
|
|
|
// server side work for in/out of spectate. takes care of spawning it into the world as well
|
|
void ServerSpectate( bool spectate );
|
|
// for very specific usage. != GetPhysics()
|
|
idPhysics *GetPlayerPhysics( void );
|
|
void TeleportDeath( int killer );
|
|
void SetLeader( bool lead );
|
|
bool IsLeader( void );
|
|
|
|
void UpdateSkinSetup();
|
|
|
|
bool OnLadder( void ) const;
|
|
|
|
virtual void UpdatePlayerIcons( void );
|
|
virtual void DrawPlayerIcons( void );
|
|
virtual void HidePlayerIcons( void );
|
|
bool NeedsIcon( void );
|
|
|
|
bool SelfSmooth( void );
|
|
void SetSelfSmooth( bool b );
|
|
idStr GetCurrentWeapon();
|
|
int GetCurrentWeaponId();
|
|
int GetCurrentWeaponSlot()
|
|
{
|
|
return hands[ vr_weaponHand.GetInteger() ].currentWeapon;
|
|
}
|
|
int GetIdealWeapon()
|
|
{
|
|
return hands[ vr_weaponHand.GetInteger() ].idealWeapon;
|
|
}
|
|
idHashTable<WeaponToggle_t> GetWeaponToggles() const
|
|
{
|
|
return weaponToggles;
|
|
}
|
|
|
|
virtual void FreeModelDef();
|
|
|
|
const idAngles& GetViewBobAngles()
|
|
{
|
|
return viewBobAngles;
|
|
}
|
|
const idVec3& GetViewBob()
|
|
{
|
|
return viewBob;
|
|
}
|
|
|
|
bool IsLocallyControlled() const
|
|
{
|
|
return entityNumber == gameLocal.localClientNum;
|
|
}
|
|
|
|
gameExpansionType_t GetExpansionType() const;
|
|
|
|
friend class idWeaponHolder;
|
|
friend class idHolster;
|
|
friend class idPlayerHand;
|
|
|
|
private:
|
|
jointHandle_t hipJoint;
|
|
jointHandle_t chestJoint;
|
|
jointHandle_t headJoint;
|
|
|
|
// Koz begin
|
|
jointHandle_t neckJoint;
|
|
|
|
jointHandle_t ik_hand[2];
|
|
jointHandle_t ik_elbow[2];
|
|
jointHandle_t ik_shoulder[2];
|
|
jointHandle_t ik_handAttacher[2];
|
|
bool handLowered;
|
|
bool handRaised;
|
|
|
|
//idMat3 chestPivotCorrectAxis; //made these public so could be accessed by hmdge
|
|
//idVec3 chestPivotDefaultPos;
|
|
idMat3 ik_elbowCorrectAxis[2];
|
|
idMat3 ik_handCorrectAxis[2][32];
|
|
idVec3 handWeaponAttachertoWristJointOffset[2][32];
|
|
idVec3 handWeaponAttacherToDefaultOffset[2][32];
|
|
|
|
int aasState;
|
|
// Koz end
|
|
|
|
bool blink;
|
|
|
|
idPhysics_Player physicsObj; // player physics
|
|
|
|
idList<aasLocation_t> aasLocation; // for AI tracking the player
|
|
|
|
int bobFoot;
|
|
float bobFrac;
|
|
float bobfracsin;
|
|
int bobCycle; // for view bobbing and footstep generation
|
|
float xyspeed;
|
|
int stepUpTime;
|
|
float stepUpDelta;
|
|
float idealLegsYaw;
|
|
float legsYaw;
|
|
bool legsForward;
|
|
float oldViewYaw;
|
|
idAngles viewBobAngles;
|
|
idVec3 viewBob;
|
|
int landChange;
|
|
int landTime;
|
|
|
|
bool weaponEnabled;
|
|
int risingWeaponHand; // Carl: getWeaponEntity script function assumes there is only one weapon and assigns it during raise
|
|
bool showWeaponViewModel;
|
|
|
|
const idDeclSkin * skin;
|
|
const idDeclSkin * powerUpSkin;
|
|
idStr baseSkinName;
|
|
|
|
int numProjectilesFired; // number of projectiles fired
|
|
int numProjectileHits; // number of hits on mobs
|
|
|
|
bool airless;
|
|
int airTics; // set to pm_airTics at start, drops in vacuum
|
|
int lastAirDamage;
|
|
|
|
bool gibDeath;
|
|
bool gibsLaunched;
|
|
idVec3 gibsDir;
|
|
|
|
idInterpolate<float> zoomFov;
|
|
idInterpolate<float> centerView;
|
|
bool fxFov;
|
|
|
|
float influenceFov;
|
|
int influenceActive; // level of influence.. 1 == no gun or hud .. 2 == 1 + no movement
|
|
idEntity * influenceEntity;
|
|
const idMaterial * influenceMaterial;
|
|
float influenceRadius;
|
|
const idDeclSkin * influenceSkin;
|
|
|
|
idCamera * privateCameraView;
|
|
|
|
static const int NUM_LOGGED_VIEW_ANGLES = 64; // for weapon turning angle offsets
|
|
idAngles loggedViewAngles[NUM_LOGGED_VIEW_ANGLES]; // [gameLocal.framenum&(LOGGED_VIEW_ANGLES-1)]
|
|
static const int NUM_LOGGED_ACCELS = 16; // for weapon turning angle offsets
|
|
loggedAccel_t loggedAccel[NUM_LOGGED_ACCELS]; // [currentLoggedAccel & (NUM_LOGGED_ACCELS-1)]
|
|
int currentLoggedAccel;
|
|
|
|
// if there is a focusGUIent, the attack button will be changed into mouse clicks
|
|
idEntity * focusGUIent;
|
|
idUserInterface * focusUI; // focusGUIent->renderEntity.gui, gui2, or gui3
|
|
idAI * focusCharacter;
|
|
int talkCursor; // show the state of the focusCharacter (0 == can't talk/dead, 1 == ready to talk, 2 == busy talking)
|
|
int focusTime;
|
|
idAFEntity_Vehicle * focusVehicle;
|
|
idUserInterface * cursor;
|
|
|
|
// full screen guis track mouse movements directly
|
|
int oldMouseX;
|
|
int oldMouseY;
|
|
|
|
idStr pdaAudio;
|
|
idStr pdaVideo;
|
|
idStr pdaVideoWave;
|
|
|
|
bool tipUp;
|
|
bool objectiveUp;
|
|
|
|
int lastDamageDef;
|
|
idVec3 lastDamageDir;
|
|
int lastDamageLocation;
|
|
int smoothedFrame;
|
|
bool smoothedOriginUpdated;
|
|
idVec3 smoothedOrigin;
|
|
idAngles smoothedAngles;
|
|
|
|
idHashTable<WeaponToggle_t> weaponToggles;
|
|
|
|
// mp
|
|
bool ready; // from userInfo
|
|
bool respawning; // set to true while in SpawnToPoint for telefrag checks
|
|
bool leader; // for sudden death situations
|
|
int lastSpectateChange;
|
|
int lastTeleFX;
|
|
unsigned int lastSnapshotSequence; // track state hitches on clients
|
|
bool weaponCatchup; // raise up the weapon silently ( state catchups )
|
|
int MPAim; // player num in aim
|
|
int lastMPAim;
|
|
int lastMPAimTime; // last time the aim changed
|
|
int MPAimFadeTime; // for GUI fade
|
|
bool MPAimHighlight;
|
|
bool isTelefragged; // proper obituaries
|
|
|
|
idPlayerIcon playerIcon;
|
|
|
|
bool selfSmooth;
|
|
|
|
void LookAtKiller( idEntity *inflictor, idEntity *attacker );
|
|
|
|
void StopFiring( void );
|
|
void FireWeapon( int hand, idWeapon* weap );
|
|
void Weapon_Combat( void );
|
|
void Weapon_NPC( void );
|
|
void Weapon_GUI( void );
|
|
void UpdateWeapon( void );
|
|
void UpdateFlashlight();
|
|
void FlashlightOn();
|
|
void FlashlightOff();
|
|
void UpdateSpectating( void );
|
|
void SpectateFreeFly( bool force ); // ignore the timeout to force when followed spec is no longer valid
|
|
void SpectateCycle( void );
|
|
idAngles GunTurningOffset( void );
|
|
idVec3 GunAcceleratingOffset( void );
|
|
|
|
|
|
void UseObjects( void );
|
|
void CrashLand( const idVec3 &oldOrigin, const idVec3 &oldVelocity );
|
|
void BobCycle( const idVec3 &pushVelocity );
|
|
void UpdateViewAngles( void );
|
|
void EvaluateControls( void );
|
|
void AdjustSpeed( void );
|
|
void AdjustBodyAngles( void );
|
|
|
|
void SnapBodyToView(); // Koz align body to current view;
|
|
void OrientHMDBody(); // Koz reset hmd/body orientations
|
|
|
|
void SetAAS( bool forceAAS48 = false );
|
|
void InitAASLocation( void );
|
|
void SetAASLocation( void );
|
|
void Move( void );
|
|
void Move_Interpolated( float fraction );
|
|
void UpdatePowerUps( void );
|
|
void UpdateDeathSkin( bool state_hitch );
|
|
void ClearPowerup( int i );
|
|
void SetSpectateOrigin( void );
|
|
|
|
void ClearFocus( void );
|
|
void UpdateFocus( void );
|
|
void SendPDAEvent( const sysEvent_t* sev );
|
|
bool UpdateFocusPDA( void );
|
|
void UpdateLocation( void );
|
|
idUserInterface * ActiveGui( void );
|
|
void UpdatePDAInfo( bool updatePDASel );
|
|
int AddGuiPDAData( const declType_t dataType, const char *listName, const idDeclPDA *src, idUserInterface *gui );
|
|
void ExtractEmailInfo( const idStr &email, const char *scan, idStr &out );
|
|
void UpdateObjectiveInfo( void );
|
|
|
|
bool WeaponAvailable( const char* name );
|
|
|
|
void UseVehicle( void );
|
|
|
|
void Event_GetButtons( void );
|
|
void Event_GetMove( void );
|
|
void Event_GetViewAngles( void );
|
|
void Event_StopFxFov( void );
|
|
void Event_EnableWeapon( void );
|
|
void Event_DisableWeapon( void );
|
|
void Event_GetCurrentWeapon( void );
|
|
void Event_GetPreviousWeapon( void );
|
|
void Event_SelectWeapon( const char *weaponName );
|
|
void Event_GetWeaponEntity( void );
|
|
void Event_OpenPDA( void );
|
|
void Event_PDAAvailable( void );
|
|
void Event_InPDA( void );
|
|
void Event_ExitTeleporter( void );
|
|
void Event_HideTip( void );
|
|
void Event_LevelTrigger( void );
|
|
void Event_Gibbed( void );
|
|
void Event_ForceOrigin( idVec3& origin, idAngles& angles );
|
|
void Event_GetIdealWeapon( void );
|
|
void Event_WeaponAvailable( const char* name );
|
|
void Event_SetPowerupTime( int powerup, int time );
|
|
void Event_IsPowerupActive( int powerup );
|
|
void Event_StartWarp();
|
|
|
|
// Koz
|
|
void Event_GetWeaponHand();
|
|
void Event_GetWeaponHandState();
|
|
void Event_GetFlashHand(); // get flashlight hand
|
|
void Event_GetFlashHandState(); // get flashlight hand state
|
|
void Event_GetFlashState(); // get flashlight state
|
|
};
|
|
|
|
ID_INLINE bool idPlayer::IsReady( void ) {
|
|
return ready || forcedReady;
|
|
}
|
|
|
|
ID_INLINE bool idPlayer::IsRespawning( void ) {
|
|
return respawning;
|
|
}
|
|
|
|
ID_INLINE idPhysics* idPlayer::GetPlayerPhysics( void ) {
|
|
return &physicsObj;
|
|
}
|
|
|
|
ID_INLINE bool idPlayer::IsInTeleport( void ) {
|
|
return ( teleportEntity.GetEntity() != NULL );
|
|
}
|
|
|
|
ID_INLINE void idPlayer::SetLeader( bool lead ) {
|
|
leader = lead;
|
|
}
|
|
|
|
ID_INLINE bool idPlayer::IsLeader( void ) {
|
|
return leader;
|
|
}
|
|
|
|
ID_INLINE bool idPlayer::SelfSmooth( void ) {
|
|
return selfSmooth;
|
|
}
|
|
|
|
ID_INLINE void idPlayer::SetSelfSmooth( bool b ) {
|
|
selfSmooth = b;
|
|
}
|
|
|
|
#endif /* !__GAME_PLAYER_H__ */
|