codemp/game/bg_pmove.c File Reference

#include "q_shared.h"
#include "bg_public.h"
#include "bg_local.h"
#include "bg_strap.h"
#include "../ghoul2/G2.h"
#include "../namespace_begin.h"
#include "../namespace_end.h"

Go to the source code of this file.

Defines
#define	MAX_WEAPON_CHARGE_TIME   5000
#define	PM_INLINE   ID_INLINE
#define	FLY_NONE   0
#define	FLY_NORMAL   1
#define	FLY_VEHICLE   2
#define	FLY_HOVER   3
#define	METROID_JUMP   1
#define	JUMP_OFF_WALL_SPEED   200.0f
#define	USE_DELAY   2000
#define	SLOPE_RECALC_INT   100
#define	SLOPERECALCVAR   pm->ps->slopeRecalcTime
#define	MAX_XHAIR_DIST_ACCURACY   20000.0f
#define	BOWCASTER_CHARGE_UNIT   200.0f
#define	BRYAR_CHARGE_UNIT   200.0f
#define	JETPACK_HOVER_HEIGHT   64
Functions
qboolean	BG_FullBodyTauntAnim (int anim)
float	PM_WalkableGroundDistance (void)
qboolean	PM_GroundSlideOkay (float zNormal)
saberInfo_t *	BG_MySaber (int clientNum, int saberNum)
bgEntity_t *	PM_BGEntForNum (int num)
qboolean	BG_SabersOff (playerState_t *ps)
qboolean	BG_KnockDownable (playerState_t *ps)
qboolean PM_INLINE	PM_IsRocketTrooper (void)
int	PM_GetSaberStance (void)
qboolean	PM_DoSlowFall (void)
void	PM_pitch_roll_for_slope (bgEntity_t *forwhom, vec3_t pass_slope, vec3_t storeAngles)
void	PM_SetSpecialMoveValues (void)
void	BG_ExternThisSoICanRecompileInDebug (Vehicle_t *pVeh, playerState_t *riderPS)
void	BG_VehicleTurnRateForSpeed (Vehicle_t *pVeh, float speed, float *mPitchOverride, float *mYawOverride)
void	PM_HoverTrace (void)
void	PM_AddEvent (int newEvent)
void	PM_AddEventWithParm (int newEvent, int parm)
void	PM_AddTouchEnt (int entityNum)
void	PM_ClipVelocity (vec3_t in, vec3_t normal, vec3_t out, float overbounce)
qboolean	PM_ForceJumpingUp (void)
void	PM_SetPMViewAngle (playerState_t *ps, vec3_t angle, usercmd_t *ucmd)
qboolean	PM_AdjustAngleForWallRun (playerState_t *ps, usercmd_t *ucmd, qboolean doMove)
qboolean	PM_AdjustAnglesForWallRunUpFlipAlt (usercmd_t *ucmd)
qboolean	PM_AdjustAngleForWallRunUp (playerState_t *ps, usercmd_t *ucmd, qboolean doMove)
qboolean	PM_AdjustAngleForWallJump (playerState_t *ps, usercmd_t *ucmd, qboolean doMove)
void	PM_SetForceJumpZStart (float value)
void	PM_GrabWallForJump (int anim)
qboolean	PM_CanRollFromSoulCal (playerState_t *ps)
qboolean	PM_CheckDualForwardJumpDuck (void)
void	PM_CheckFixMins (void)
void	PM_Use (void)
qboolean	PM_WalkingAnim (int anim)
qboolean	PM_RunningAnim (int anim)
qboolean	PM_SwimmingAnim (int anim)
qboolean	PM_RollingAnim (int anim)
void	PM_AnglesForSlope (const float yaw, const vec3_t slope, vec3_t angles)
void	PM_FootSlopeTrace (float *pDiff, float *pInterval)
qboolean	BG_InSlopeAnim (int anim)
qboolean	PM_AdjustStandAnimForSlope (void)
int	PM_LegsSlopeBackTransition (int desiredAnim)
void	BG_ClearRocketLock (playerState_t *ps)
void	PM_BeginWeaponChange (int weapon)
void	PM_FinishWeaponChange (void)
void	CG_GetVehicleCamPos (vec3_t camPos)
int	BG_VehTraceFromCamPos (trace_t *camTrace, bgEntity_t *bgEnt, const vec3_t entOrg, const vec3_t shotStart, const vec3_t end, vec3_t newEnd, vec3_t shotDir, float bestDist)
void	PM_RocketLock (float lockDist, qboolean vehicleLock)
int	PM_ItemUsable (playerState_t *ps, int forcedUse)
qboolean	PM_CanSetWeaponAnims (void)
int	PM_irand_timesync (int val1, int val2)
void	PM_VehicleWeaponAnimate (void)
int	PM_KickMoveForConditions (void)
qboolean	BG_UnrestrainedPitchRoll (playerState_t *ps, Vehicle_t *pVeh)
void	PM_UpdateViewAngles (playerState_t *ps, const usercmd_t *cmd)
void	PM_AdjustAttackStates (pmove_t *pm)
void	BG_CmdForRoll (playerState_t *ps, int anim, usercmd_t *pCmd)
qboolean	PM_SaberInTransition (int move)
void	BG_AdjustClientSpeed (playerState_t *ps, usercmd_t *cmd, int svTime)
qboolean	BG_InRollAnim (entityState_t *cent)
qboolean	BG_InKnockDown (int anim)
qboolean	BG_InRollES (entityState_t *ps, int anim)
void	BG_IK_MoveArm (void *ghoul2, int lHandBolt, int time, entityState_t *ent, int basePose, vec3_t desiredPos, qboolean *ikInProgress, vec3_t origin, vec3_t angles, vec3_t scale, int blendTime, qboolean forceHalt)
void	BG_UpdateLookAngles (int lookingDebounceTime, vec3_t lastHeadAngles, int time, vec3_t lookAngles, float lookSpeed, float minPitch, float maxPitch, float minYaw, float maxYaw, float minRoll, float maxRoll)
qboolean	BG_InRoll2 (entityState_t *es)
qboolean	BG_SaberLockBreakAnim (int anim)
void	BG_G2PlayerAngles (void *ghoul2, int motionBolt, entityState_t *cent, int time, vec3_t cent_lerpOrigin, vec3_t cent_lerpAngles, vec3_t legs[3], vec3_t legsAngles, qboolean *tYawing, qboolean *tPitching, qboolean *lYawing, float *tYawAngle, float *tPitchAngle, float *lYawAngle, int frametime, vec3_t turAngles, vec3_t modelScale, int ciLegs, int ciTorso, int *corrTime, vec3_t lookAngles, vec3_t lastHeadAngles, int lookTime, entityState_t *emplaced, int *crazySmoothFactor)
void	BG_G2ATSTAngles (void *ghoul2, int time, vec3_t cent_lerpAngles)
void	PM_VehicleViewAngles (playerState_t *ps, bgEntity_t *veh, usercmd_t *ucmd)
qboolean	PM_WeaponOkOnVehicle (int weapon)
int	PM_GetOkWeaponForVehicle (void)
void	PM_VehForcedTurning (bgEntity_t *veh)
void	PM_VehFaceHyperspacePoint (bgEntity_t *veh)
void	BG_VehicleAdjustBBoxForOrientation (Vehicle_t *veh, vec3_t origin, vec3_t mins, vec3_t maxs, int clientNum, int tracemask, void(*localTrace)(trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask))
void	trap_SnapVector (float *v)
int	BG_EmplacedView (vec3_t baseAngles, vec3_t angles, float *newYaw, float constraint)
qboolean	BG_FighterUpdate (Vehicle_t *pVeh, const usercmd_t *pUcmd, vec3_t trMins, vec3_t trMaxs, float gravity, void(*traceFunc)(trace_t *results, const vec3_t start, const vec3_t lmins, const vec3_t lmaxs, const vec3_t end, int passEntityNum, int contentMask))
void	PM_MoveForKata (usercmd_t *ucmd)
void	PmoveSingle (pmove_t *pmove)
void	Pmove (pmove_t *pmove)
Variables
pmove_t *	pm
pml_t	pml
bgEntity_t *	pm_entSelf = NULL
bgEntity_t *	pm_entVeh = NULL
qboolean	gPMDoSlowFall = qfalse
qboolean	pm_cancelOutZoom = qfalse
float	pm_stopspeed = 100.0f
float	pm_duckScale = 0.50f
float	pm_swimScale = 0.50f
float	pm_wadeScale = 0.70f
float	pm_vehicleaccelerate = 36.0f
float	pm_accelerate = 10.0f
float	pm_airaccelerate = 1.0f
float	pm_wateraccelerate = 4.0f
float	pm_flyaccelerate = 8.0f
float	pm_friction = 6.0f
float	pm_waterfriction = 1.0f
float	pm_flightfriction = 3.0f
float	pm_spectatorfriction = 5.0f
int	c_pmove = 0
float	forceSpeedLevels [4]
int	forcePowerNeeded [NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS]
float	forceJumpHeight [NUM_FORCE_POWER_LEVELS]
float	forceJumpStrength [NUM_FORCE_POWER_LEVELS]
vmCvar_t	cg_paused
float	forceJumpHeightMax [NUM_FORCE_POWER_LEVELS]
int	WeaponReadyLegsAnim [WP_NUM_WEAPONS]
vmCvar_t	bg_fighterAltControl

---

Define Documentation

#define BOWCASTER_CHARGE_UNIT   200.0f

Definition at line 6237 of file bg_pmove.c.

#define BRYAR_CHARGE_UNIT   200.0f

Definition at line 6238 of file bg_pmove.c.

#define FLY_HOVER   3

Definition at line 444 of file bg_pmove.c. Referenced by PM_SetSpecialMoveValues(), and PmoveSingle().

#define FLY_NONE   0

Definition at line 441 of file bg_pmove.c. Referenced by PM_SetSpecialMoveValues().

#define FLY_NORMAL   1

Definition at line 442 of file bg_pmove.c. Referenced by PM_SetSpecialMoveValues(), and PmoveSingle().

#define FLY_VEHICLE   2

Definition at line 443 of file bg_pmove.c. Referenced by PM_SetSpecialMoveValues(), and PmoveSingle().

#define JETPACK_HOVER_HEIGHT   64

Definition at line 10085 of file bg_pmove.c. Referenced by PmoveSingle().

#define JUMP_OFF_WALL_SPEED   200.0f

Definition at line 1600 of file bg_pmove.c. Referenced by PM_AdjustAngleForWallJump().

#define MAX_WEAPON_CHARGE_TIME   5000

Definition at line 16 of file bg_pmove.c.

#define MAX_XHAIR_DIST_ACCURACY   20000.0f

Definition at line 5833 of file bg_pmove.c.

#define METROID_JUMP   1

Definition at line 1264 of file bg_pmove.c.

#define PM_INLINE   ID_INLINE

Definition at line 241 of file bg_pmove.c. Referenced by PM_IsRocketTrooper().

#define SLOPE_RECALC_INT   100

Definition at line 4803 of file bg_pmove.c. Referenced by PM_AdjustStandAnimForSlope().

#define SLOPERECALCVAR   pm->ps->slopeRecalcTime

Referenced by PM_AdjustStandAnimForSlope().

#define USE_DELAY   2000

Definition at line 4558 of file bg_pmove.c. Referenced by PM_Use().

---

Function Documentation

void BG_AdjustClientSpeed (  playerState_t *  ps, usercmd_t *  cmd, int  svTime )

Definition at line 8332 of file bg_pmove.c. References playerState_s::basespeed, BG_InRoll(), BG_MySaber(), BG_SaberInAttack(), BG_SpinningSaberAnim(), bgEntity_t, BOTH_ROLL_B, BUTTON_WALKING, usercmd_s::buttons, CLASS_VEHICLE, playerState_s::clientNum, pmove_t::cmd, ENTITYNUM_NONE, playerState_s::fd, FORCE_LEVEL_1, FORCE_LEVEL_2, FORCE_LEVEL_3, forcedata_s::forceGripCripple, playerState_s::forceHandExtend, forcedata_s::forcePowersActive, forcedata_s::forceRageRecoveryTime, usercmd_s::forwardmove, FP_GRIP, FP_RAGE, FP_SPEED, playerState_s::groundEntityNum, HANDEXTEND_DODGE, HANDEXTEND_KNOCKDOWN, HANDEXTEND_POSTTHROWN, HANDEXTEND_PRETHROWN, playerState_s::legsAnim, playerState_s::legsTimer, MAX_CLIENTS, saberInfo_t::moveSpeedScale, entityState_s::NPC_class, playerState_t, pm, pm_entSelf, PM_SaberInTransition(), pmove_t::ps, bgEntity_s::s, forcedata_s::saberAnimLevel, playerState_s::saberMove, usercmd_s::serverTime, playerState_s::speed, SS_DUAL, SS_STAFF, usercmd_t, playerState_s::weapon, WP_DISRUPTOR, WP_SABER, playerState_s::zoomLockTime, and playerState_s::zoomMode. Referenced by PmoveSingle(). { saberInfo_t *saber; if (ps->clientNum >= MAX_CLIENTS) { bgEntity_t *bgEnt = pm_entSelf; if (bgEnt && bgEnt->s.NPC_class == CLASS_VEHICLE) { //vehicles manage their own speed return; } } //For prediction, always reset speed back to the last known server base speed //If we didn't do this, under lag we'd eventually dwindle speed down to 0 even though //that would not be the correct predicted value. ps->speed = ps->basespeed; if (ps->forceHandExtend == HANDEXTEND_DODGE) { ps->speed = 0; } if (ps->forceHandExtend == HANDEXTEND_KNOCKDOWN || ps->forceHandExtend == HANDEXTEND_PRETHROWN || ps->forceHandExtend == HANDEXTEND_POSTTHROWN) { ps->speed = 0; } if ( cmd->forwardmove < 0 && !(cmd->buttons&BUTTON_WALKING) && pm->ps->groundEntityNum != ENTITYNUM_NONE ) {//running backwards is slower than running forwards (like SP) ps->speed *= 0.75; } if (ps->fd.forcePowersActive & (1 << FP_GRIP)) { ps->speed *= 0.4; } if (ps->fd.forcePowersActive & (1 << FP_SPEED)) { ps->speed *= 1.7; } else if (ps->fd.forcePowersActive & (1 << FP_RAGE)) { ps->speed *= 1.3; } else if (ps->fd.forceRageRecoveryTime > svTime) { ps->speed *= 0.75; } if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime) { ps->speed *= 0.5f; } if (ps->fd.forceGripCripple) { if (ps->fd.forcePowersActive & (1 << FP_RAGE)) { ps->speed *= 0.9; } else if (ps->fd.forcePowersActive & (1 << FP_SPEED)) { //force speed will help us escape ps->speed *= 0.8; } else { ps->speed *= 0.2; } } if ( BG_SaberInAttack( ps->saberMove ) && cmd->forwardmove < 0 ) {//if running backwards while attacking, don't run as fast. switch( ps->fd.saberAnimLevel ) { case FORCE_LEVEL_1: ps->speed *= 0.75f; break; case FORCE_LEVEL_2: case SS_DUAL: case SS_STAFF: ps->speed *= 0.60f; break; case FORCE_LEVEL_3: ps->speed *= 0.45f; break; default: break; } } else if ( BG_SpinningSaberAnim( ps->legsAnim ) ) { if (ps->fd.saberAnimLevel == FORCE_LEVEL_3) { ps->speed *= 0.3f; } else { ps->speed *= 0.5f; } } else if ( ps->weapon == WP_SABER && BG_SaberInAttack( ps->saberMove ) ) {//if attacking with saber while running, drop your speed switch( ps->fd.saberAnimLevel ) { case FORCE_LEVEL_2: case SS_DUAL: case SS_STAFF: ps->speed *= 0.85f; break; case FORCE_LEVEL_3: ps->speed *= 0.55f; break; default: break; } } else if (ps->weapon == WP_SABER && ps->fd.saberAnimLevel == FORCE_LEVEL_3 && PM_SaberInTransition(ps->saberMove)) { //Now, we want to even slow down in transitions for level 3 (since it has chains and stuff now) if (cmd->forwardmove < 0) { ps->speed *= 0.4f; } else { ps->speed *= 0.6f; } } if ( BG_InRoll( ps, ps->legsAnim ) && ps->speed > 50 ) { //can't roll unless you're able to move normally if ((ps->legsAnim) == BOTH_ROLL_B) { //backwards roll is pretty fast, should also be slower if (ps->legsTimer > 800) { ps->speed = ps->legsTimer/2.5; } else { ps->speed = ps->legsTimer/6.0;//450; } } else { if (ps->legsTimer > 800) { ps->speed = ps->legsTimer/1.5;//450; } else { ps->speed = ps->legsTimer/5.0;//450; } } if (ps->speed > 600) { ps->speed = 600; } //Automatically slow down as the roll ends. } saber = BG_MySaber( ps->clientNum, 0 ); if ( saber && saber->moveSpeedScale != 1.0f ) { ps->speed *= saber->moveSpeedScale; } saber = BG_MySaber( ps->clientNum, 1 ); if ( saber && saber->moveSpeedScale != 1.0f ) { ps->speed *= saber->moveSpeedScale; } }

void BG_ClearRocketLock (  playerState_t *  ps  )

Definition at line 5751 of file bg_pmove.c. References ENTITYNUM_NONE, playerState_t, playerState_s::rocketLastValidTime, playerState_s::rocketLockIndex, playerState_s::rocketLockTime, and playerState_s::rocketTargetTime. Referenced by player_die(), and PM_BeginWeaponChange(). { if ( ps ) { ps->rocketLockIndex = ENTITYNUM_NONE; ps->rocketLastValidTime = 0; ps->rocketLockTime = -1; ps->rocketTargetTime = 0; } }

void BG_CmdForRoll (  playerState_t *  ps, int  anim, usercmd_t *  pCmd )

Definition at line 8202 of file bg_pmove.c. References animNumber_t, BOTH_GETUP_BROLL_B, BOTH_GETUP_BROLL_F, BOTH_GETUP_BROLL_L, BOTH_GETUP_BROLL_R, BOTH_GETUP_FROLL_B, BOTH_GETUP_FROLL_F, BOTH_GETUP_FROLL_L, BOTH_GETUP_FROLL_R, BOTH_ROLL_B, BOTH_ROLL_F, BOTH_ROLL_L, BOTH_ROLL_R, usercmd_s::forwardmove, playerState_s::legsAnim, playerState_s::legsTimer, playerState_t, PM_AnimLength(), usercmd_s::rightmove, playerState_s::torsoTimer, usercmd_s::upmove, and usercmd_t. Referenced by PmoveSingle(). { switch ( (anim) ) { case BOTH_ROLL_F: pCmd->forwardmove = 127; pCmd->rightmove = 0; break; case BOTH_ROLL_B: pCmd->forwardmove = -127; pCmd->rightmove = 0; break; case BOTH_ROLL_R: pCmd->forwardmove = 0; pCmd->rightmove = 127; break; case BOTH_ROLL_L: pCmd->forwardmove = 0; pCmd->rightmove = -127; break; case BOTH_GETUP_BROLL_R: pCmd->forwardmove = 0; pCmd->rightmove = 48; //NOTE: speed is 400 break; case BOTH_GETUP_FROLL_R: if ( ps->legsTimer <= 250 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { pCmd->forwardmove = 0; pCmd->rightmove = 48; //NOTE: speed is 400 } break; case BOTH_GETUP_BROLL_L: pCmd->forwardmove = 0; pCmd->rightmove = -48; //NOTE: speed is 400 break; case BOTH_GETUP_FROLL_L: if ( ps->legsTimer <= 250 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { pCmd->forwardmove = 0; pCmd->rightmove = -48; //NOTE: speed is 400 } break; case BOTH_GETUP_BROLL_B: if ( ps->torsoTimer <= 250 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 350 ) {//beginning of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { //FIXME: ramp down over length of anim pCmd->forwardmove = -64; pCmd->rightmove = 0; //NOTE: speed is 400 } break; case BOTH_GETUP_FROLL_B: if ( ps->torsoTimer <= 100 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 200 ) {//beginning of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { //FIXME: ramp down over length of anim pCmd->forwardmove = -64; pCmd->rightmove = 0; //NOTE: speed is 400 } break; case BOTH_GETUP_BROLL_F: if ( ps->torsoTimer <= 550 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else if ( PM_AnimLength( 0, (animNumber_t)ps->legsAnim ) - ps->torsoTimer < 150 ) {//beginning of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { pCmd->forwardmove = 64; pCmd->rightmove = 0; //NOTE: speed is 400 } break; case BOTH_GETUP_FROLL_F: if ( ps->torsoTimer <= 100 ) {//end of anim pCmd->forwardmove = pCmd->rightmove = 0; } else { //FIXME: ramp down over length of anim pCmd->forwardmove = 64; pCmd->rightmove = 0; //NOTE: speed is 400 } break; } pCmd->upmove = 0; }

int BG_EmplacedView (  vec3_t  baseAngles, vec3_t  angles, float *  newYaw, float  constraint )

Definition at line 2703 of file bg_misc.c. { float dif = AngleSubtract(baseAngles[YAW], angles[YAW]); if (dif > constraint || dif < -constraint) { float amt; if (dif > constraint) { amt = (dif-constraint); dif = constraint; } else if (dif < -constraint) { amt = (dif+constraint); dif = -constraint; } else { amt = 0.0f; } *newYaw = AngleSubtract(angles[YAW], -dif); if (amt > 1.0f || amt < -1.0f) { //significant, force the view return 2; } else { //just a little out of range return 1; } } return 0; }

void BG_ExternThisSoICanRecompileInDebug (  Vehicle_t *  pVeh, playerState_t *  riderPS )

Definition at line 641 of file bg_pmove.c. References playerState_t, and Vehicle_t. { /* float pitchSubtract, pitchDelta, yawDelta; //Com_Printf( S_COLOR_RED"PITCH: %4.2f, YAW: %4.2f, ROLL: %4.2f\n", riderPS->viewangles[0],riderPS->viewangles[1],riderPS->viewangles[2]); yawDelta = AngleSubtract(riderPS->viewangles[YAW],pVeh->m_vPrevRiderViewAngles[YAW]); #ifndef QAGAME if ( !cg_paused.integer ) { //Com_Printf( "%d - yawDelta %4.2f\n", pm->cmd.serverTime, yawDelta ); } #endif yawDelta *= (4.0f*pVeh->m_fTimeModifier); pVeh->m_vOrientation[ROLL] -= yawDelta; pitchDelta = AngleSubtract(riderPS->viewangles[PITCH],pVeh->m_vPrevRiderViewAngles[PITCH]); pitchDelta *= (2.0f*pVeh->m_fTimeModifier); pitchSubtract = pitchDelta * (fabs(pVeh->m_vOrientation[ROLL])/90.0f); pVeh->m_vOrientation[PITCH] += pitchDelta-pitchSubtract; if ( pVeh->m_vOrientation[ROLL] > 0 ) { pVeh->m_vOrientation[YAW] += pitchSubtract; } else { pVeh->m_vOrientation[YAW] -= pitchSubtract; } pVeh->m_vOrientation[PITCH] = AngleNormalize180( pVeh->m_vOrientation[PITCH] ); pVeh->m_vOrientation[YAW] = AngleNormalize360( pVeh->m_vOrientation[YAW] ); pVeh->m_vOrientation[ROLL] = AngleNormalize180( pVeh->m_vOrientation[ROLL] ); VectorCopy( riderPS->viewangles, pVeh->m_vPrevRiderViewAngles ); */ }

qboolean BG_FighterUpdate (  Vehicle_t *  pVeh, const usercmd_t *  pUcmd, vec3_t  trMins, vec3_t  trMaxs, float  gravity, void(*  traceFunc)(trace_t *results, const vec3_t start, const vec3_t lmins, const vec3_t lmaxs, const vec3_t end, int passEntityNum, int contentMask) )

Definition at line 96 of file FighterNPC.c. References Com_Error(), CONTENTS_BODY, EF_DEAD, playerState_s::eFlags, ERR_DROP, vehicleInfo_t::Ghost, playerState_s::gravity, vehicleInfo_t::gravity, vehicleInfo_t::landingHeight, Vehicle_s::m_LandTrace, Vehicle_s::m_pParentEntity, Vehicle_s::m_pPilot, Vehicle_s::m_ppPassengers, Vehicle_s::m_pVehicleInfo, MASK_NPCSOLID, vehicleInfo_t::maxPassengers, vehicleInfo_t::name, entityState_s::number, playerState_s::origin, bgEntity_s::playerState, playerState_t, qboolean, qfalse, bgEntity_s::s, STAT_HEALTH, playerState_s::stats, usercmd_t, vec3_t, VectorCopy, and Vehicle_t. Referenced by PmoveSingle(). { vec3_t bottom; playerState_t *parentPS; qboolean isDead = qfalse; #ifdef QAGAME //don't do this on client int i; // Make sure the riders are not visible or collidable. pVeh->m_pVehicleInfo->Ghost( pVeh, pVeh->m_pPilot ); for ( i = 0; i < pVeh->m_pVehicleInfo->maxPassengers; i++ ) { pVeh->m_pVehicleInfo->Ghost( pVeh, pVeh->m_ppPassengers[i] ); } #endif #ifdef _JK2MP parentPS = pVeh->m_pParentEntity->playerState; #else parentPS = &pVeh->m_pParentEntity->client->ps; #endif if (!parentPS) { Com_Error(ERR_DROP, "NULL PS in BG_FighterUpdate (%s)", pVeh->m_pVehicleInfo->name); return false; } // If we have a pilot, take out gravity (it's a flying craft...). if ( pVeh->m_pPilot ) { parentPS->gravity = 0; #ifndef _JK2MP //don't need this flag in mp, I.. guess pVeh->m_pParentEntity->svFlags |= SVF_CUSTOM_GRAVITY; #endif } else { #ifndef _JK2MP //don't need this flag in mp, I.. guess pVeh->m_pParentEntity->svFlags &= ~SVF_CUSTOM_GRAVITY; #else //in MP set grav back to normal gravity if (pVeh->m_pVehicleInfo->gravity) { parentPS->gravity = pVeh->m_pVehicleInfo->gravity; } else { //it doesn't have gravity specified apparently parentPS->gravity = gravity; } #endif } #ifdef _JK2MP isDead = (qboolean)((parentPS->eFlags&EF_DEAD)!=0); #else isDead = (parentPS->stats[STAT_HEALTH] <= 0 ); #endif /* if ( isDead || (pVeh->m_pVehicleInfo->surfDestruction && pVeh->m_iRemovedSurfaces ) ) {//can't land if dead or spiralling out of control pVeh->m_LandTrace.fraction = 1.0f; pVeh->m_LandTrace.contents = pVeh->m_LandTrace.surfaceFlags = 0; VectorClear( pVeh->m_LandTrace.plane.normal ); pVeh->m_LandTrace.allsolid = qfalse; pVeh->m_LandTrace.startsolid = qfalse; } else { */ //argh, no, I need to have a way to see when they impact the ground while damaged. -rww // Check to see if the fighter has taken off yet (if it's a certain height above ground). VectorCopy( parentPS->origin, bottom ); bottom[2] -= pVeh->m_pVehicleInfo->landingHeight; traceFunc( &pVeh->m_LandTrace, parentPS->origin, trMins, trMaxs, bottom, pVeh->m_pParentEntity->s.number, (MASK_NPCSOLID&~CONTENTS_BODY) ); //} return true; }

qboolean BG_FullBodyTauntAnim (  int  anim  )

Definition at line 1538 of file bg_panimate.c. { switch ( anim ) { case BOTH_GESTURE1: case BOTH_DUAL_TAUNT: case BOTH_STAFF_TAUNT: case BOTH_BOW: case BOTH_MEDITATE: case BOTH_SHOWOFF_FAST: case BOTH_SHOWOFF_MEDIUM: case BOTH_SHOWOFF_STRONG: case BOTH_SHOWOFF_DUAL: case BOTH_SHOWOFF_STAFF: case BOTH_VICTORY_FAST: case BOTH_VICTORY_MEDIUM: case BOTH_VICTORY_STRONG: case BOTH_VICTORY_DUAL: case BOTH_VICTORY_STAFF: return qtrue; break; } return qfalse; }

void BG_G2ATSTAngles (  void *  ghoul2, int  time, vec3_t  cent_lerpAngles )

Definition at line 9460 of file bg_pmove.c. References BONE_ANGLES_POSTMULT, NEGATIVE_Y, NEGATIVE_Z, POSITIVE_X, strap_G2API_SetBoneAngles(), and vec3_t. {// up right fwd strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", cent_lerpAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); }

void BG_G2PlayerAngles (  void *  ghoul2, int  motionBolt, entityState_t *  cent, int  time, vec3_t  cent_lerpOrigin, vec3_t  cent_lerpAngles, vec3_t  legs[3], vec3_t  legsAngles, qboolean *  tYawing, qboolean *  tPitching, qboolean *  lYawing, float *  tYawAngle, float *  tPitchAngle, float *  lYawAngle, int  frametime, vec3_t  turAngles, vec3_t  modelScale, int  ciLegs, int  ciTorso, int *  corrTime, vec3_t  lookAngles, vec3_t  lastHeadAngles, int  lookTime, entityState_t *  emplaced, int *  crazySmoothFactor )

Definition at line 9083 of file bg_pmove.c. References AngleMod(), AngleNormalize180(), entityState_s::angles2, AnglesSubtract(), AnglesToAxis(), AngleSubtract(), BG_InRoll2(), BG_SaberInSpecial(), BG_SaberLockBreakAnim(), BG_UpdateLookAngles(), BONE_ANGLES_POSTMULT, BOTH_STAND1, BOTH_STRAFE_LEFT1, BOTH_STRAFE_RIGHT1, Com_Error(), DotProduct, EF_DEAD, entityState_s::eFlags, ENTITYNUM_NONE, entityState_t, ERR_DROP, entityState_s::forceFrame, entityState_s::groundEntityNum, entityState_s::heldByClient, entityState_s::legsAnim, entityState_s::m_iVehicleNum, MAX_CLIENTS, NEGATIVE_Y, NEGATIVE_Z, entityState_s::number, PITCH, entityState_s::pos, POSITIVE_X, qtrue, ROLL, entityState_s::saberMove, strap_G2API_SetBoneAngles(), entityState_s::torsoAnim, trajectory_t::trBase, trajectory_t::trDelta, vec3_origin, vec3_t, vectoangles(), VectorAdd, VectorClear, VectorCopy, VectorNormalize(), VectorScale, VectorSet, VectorSubtract, entityState_s::weapon, WeaponReadyAnim, WP_EMPLACED_GUN, WP_NONE, WP_SABER, and YAW. { int adddir = 0; static int dir; static int i; static int movementOffsets[8] = { 0, 22, 45, -22, 0, 22, -45, -22 }; float degrees_negative = 0; float degrees_positive = 0; static float dif; static float dest; static float speed; //, speed_dif, speed_desired; static const float lookSpeed = 1.5f; #ifdef BONE_BASED_LEG_ANGLES static float legBoneYaw; #endif static vec3_t eyeAngles; static vec3_t neckAngles; static vec3_t velocity; static vec3_t torsoAngles, headAngles; static vec3_t velPos, velAng; static vec3_t ulAngles, llAngles, viewAngles, angles, thoracicAngles = {0,0,0}; static vec3_t headClampMinAngles = {-25,-55,-10}, headClampMaxAngles = {50,50,10}; if ( cent->m_iVehicleNum || cent->forceFrame || BG_SaberLockBreakAnim(cent->legsAnim) || BG_SaberLockBreakAnim(cent->torsoAnim) ) { //a vehicle or riding a vehicle - in either case we don't need to be in here vec3_t forcedAngles; VectorClear(forcedAngles); forcedAngles[YAW] = cent_lerpAngles[YAW]; forcedAngles[ROLL] = cent_lerpAngles[ROLL]; AnglesToAxis( forcedAngles, legs ); VectorCopy(forcedAngles, legsAngles); if (cent->number < MAX_CLIENTS) { strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); } return; } if ((time+2000) < *corrTime) { *corrTime = 0; } VectorCopy( cent_lerpAngles, headAngles ); headAngles[YAW] = AngleMod( headAngles[YAW] ); VectorClear( legsAngles ); VectorClear( torsoAngles ); // --------- yaw ------------- // allow yaw to drift a bit if ((( cent->legsAnim ) != BOTH_STAND1) || ( cent->torsoAnim ) != WeaponReadyAnim[cent->weapon] ) { // if not standing still, always point all in the same direction //cent->pe.torso.yawing = qtrue; // always center *tYawing = qtrue; //cent->pe.torso.pitching = qtrue; // always center *tPitching = qtrue; //cent->pe.legs.yawing = qtrue; // always center *lYawing = qtrue; } // adjust legs for movement dir if ( cent->eFlags & EF_DEAD ) { // don't let dead bodies twitch dir = 0; } else { dir = cent->angles2[YAW]; if ( dir < 0 || dir > 7 ) { Com_Error( ERR_DROP, "Bad player movement angle (%i)", dir ); } } torsoAngles[YAW] = headAngles[YAW]; //for now, turn torso instantly and let the legs swing to follow *tYawAngle = torsoAngles[YAW]; // --------- pitch ------------- VectorCopy( cent->pos.trDelta, velocity ); if (BG_InRoll2(cent)) { //don't affect angles based on vel then VectorClear(velocity); } else if (cent->weapon == WP_SABER && BG_SaberInSpecial(cent->saberMove)) { VectorClear(velocity); } speed = VectorNormalize( velocity ); if (!speed) { torsoAngles[YAW] = headAngles[YAW]; } // only show a fraction of the pitch angle in the torso if ( headAngles[PITCH] > 180 ) { dest = (-360 + headAngles[PITCH]) * 0.75; } else { dest = headAngles[PITCH] * 0.75; } if (cent->m_iVehicleNum) { //swing instantly on vehicles *tPitchAngle = dest; } else { BG_SwingAngles( dest, 15, 30, 0.1, tPitchAngle, tPitching, frametime ); } torsoAngles[PITCH] = *tPitchAngle; // --------- roll ------------- if ( speed ) { vec3_t axis[3]; float side; speed *= 0.05; AnglesToAxis( legsAngles, axis ); side = speed * DotProduct( velocity, axis[1] ); legsAngles[ROLL] -= side; side = speed * DotProduct( velocity, axis[0] ); legsAngles[PITCH] += side; } //legsAngles[YAW] = headAngles[YAW] + (movementOffsets[ dir ]*speed_dif); //rww - crazy velocity-based leg angle calculation legsAngles[YAW] = headAngles[YAW]; velPos[0] = cent_lerpOrigin[0] + velocity[0]; velPos[1] = cent_lerpOrigin[1] + velocity[1]; velPos[2] = cent_lerpOrigin[2];// + velocity[2]; if ( cent->groundEntityNum == ENTITYNUM_NONE || cent->forceFrame || (cent->weapon == WP_EMPLACED_GUN && emplaced) ) { //off the ground, no direction-based leg angles (same if in saberlock) VectorCopy(cent_lerpOrigin, velPos); } VectorSubtract(cent_lerpOrigin, velPos, velAng); if (!VectorCompare(velAng, vec3_origin)) { vectoangles(velAng, velAng); if (velAng[YAW] <= legsAngles[YAW]) { degrees_negative = (legsAngles[YAW] - velAng[YAW]); degrees_positive = (360 - legsAngles[YAW]) + velAng[YAW]; } else { degrees_negative = legsAngles[YAW] + (360 - velAng[YAW]); degrees_positive = (velAng[YAW] - legsAngles[YAW]); } if ( degrees_negative < degrees_positive ) { dif = degrees_negative; adddir = 0; } else { dif = degrees_positive; adddir = 1; } if (dif > 90) { dif = (180 - dif); } if (dif > 60) { dif = 60; } //Slight hack for when playing is running backward if (dir == 3 || dir == 5) { dif = -dif; } if (adddir) { legsAngles[YAW] -= dif; } else { legsAngles[YAW] += dif; } } if (cent->m_iVehicleNum) { //swing instantly on vehicles *lYawAngle = legsAngles[YAW]; } else { BG_SwingAngles( legsAngles[YAW], /*40*/0, 90, 0.65, lYawAngle, lYawing, frametime ); } legsAngles[YAW] = *lYawAngle; /* // pain twitch CG_AddPainTwitch( cent, torsoAngles ); */ legsAngles[ROLL] = 0; torsoAngles[ROLL] = 0; // VectorCopy(legsAngles, turAngles); // pull the angles back out of the hierarchial chain AnglesSubtract( headAngles, torsoAngles, headAngles ); AnglesSubtract( torsoAngles, legsAngles, torsoAngles ); legsAngles[PITCH] = 0; if (cent->heldByClient) { //keep the base angles clear when doing the IK stuff, it doesn't compensate for it. //rwwFIXMEFIXME: Store leg angles off and add them to all the fed in angles for G2 functions? VectorClear(legsAngles); legsAngles[YAW] = cent_lerpAngles[YAW]; } #ifdef BONE_BASED_LEG_ANGLES legBoneYaw = legsAngles[YAW]; VectorClear(legsAngles); legsAngles[YAW] = cent_lerpAngles[YAW]; #endif VectorCopy(legsAngles, turAngles); AnglesToAxis( legsAngles, legs ); VectorCopy( cent_lerpAngles, viewAngles ); viewAngles[YAW] = viewAngles[ROLL] = 0; viewAngles[PITCH] *= 0.5; VectorSet( angles, 0, legsAngles[1], 0 ); angles[0] = legsAngles[0]; if ( angles[0] > 30 ) { angles[0] = 30; } else if ( angles[0] < -30 ) { angles[0] = -30; } if (cent->weapon == WP_EMPLACED_GUN && emplaced) { //if using an emplaced gun, then we want to make sure we're angled to "hold" it right vec3_t facingAngles; VectorSubtract(emplaced->pos.trBase, cent_lerpOrigin, facingAngles); vectoangles(facingAngles, facingAngles); if (emplaced->weapon == WP_NONE) { //e-web VectorCopy(facingAngles, legsAngles); AnglesToAxis( legsAngles, legs ); } else { //misc emplaced float dif = AngleSubtract(cent_lerpAngles[YAW], facingAngles[YAW]); /* if (emplaced->weapon == WP_NONE) { //offset is a little bit different for the e-web dif -= 16.0f; } */ VectorSet(facingAngles, -16.0f, -dif, 0.0f); if (cent->legsAnim == BOTH_STRAFE_LEFT1 || cent->legsAnim == BOTH_STRAFE_RIGHT1) { //try to adjust so it doesn't look wrong if (crazySmoothFactor) { //want to smooth a lot during this because it chops around and looks like ass *crazySmoothFactor = time + 1000; } BG_G2ClientSpineAngles(ghoul2, motionBolt, cent_lerpOrigin, cent_lerpAngles, cent, time, viewAngles, ciLegs, ciTorso, angles, thoracicAngles, ulAngles, llAngles, modelScale, tPitchAngle, tYawAngle, corrTime); strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", llAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", ulAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); VectorAdd(facingAngles, thoracicAngles, facingAngles); if (cent->legsAnim == BOTH_STRAFE_LEFT1) { //this one needs some further correction facingAngles[YAW] -= 32.0f; } } else { //strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); //strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "cranium", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); } VectorScale(facingAngles, 0.6f, facingAngles); strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); VectorScale(facingAngles, 0.8f, facingAngles); strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); VectorScale(facingAngles, 0.8f, facingAngles); strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); //Now we want the head angled toward where we are facing VectorSet(facingAngles, 0.0f, dif, 0.0f); VectorScale(facingAngles, 0.6f, facingAngles); strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", facingAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); return; //don't have to bother with the rest then } } BG_G2ClientSpineAngles(ghoul2, motionBolt, cent_lerpOrigin, cent_lerpAngles, cent, time, viewAngles, ciLegs, ciTorso, angles, thoracicAngles, ulAngles, llAngles, modelScale, tPitchAngle, tYawAngle, corrTime); VectorCopy(cent_lerpAngles, eyeAngles); for ( i = 0; i < 3; i++ ) { lookAngles[i] = AngleNormalize180( lookAngles[i] ); eyeAngles[i] = AngleNormalize180( eyeAngles[i] ); } AnglesSubtract( lookAngles, eyeAngles, lookAngles ); BG_UpdateLookAngles(lookTime, lastHeadAngles, time, lookAngles, lookSpeed, -50.0f, 50.0f, -70.0f, 70.0f, -30.0f, 30.0f); BG_G2ClientNeckAngles(ghoul2, time, lookAngles, headAngles, neckAngles, thoracicAngles, headClampMinAngles, headClampMaxAngles); #ifdef BONE_BASED_LEG_ANGLES { vec3_t bLAngles; VectorClear(bLAngles); bLAngles[ROLL] = AngleNormalize180((legBoneYaw - cent_lerpAngles[YAW])); strap_G2API_SetBoneAngles(ghoul2, 0, "model_root", bLAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); if (!llAngles[YAW]) { llAngles[YAW] -= bLAngles[ROLL]; } } #endif strap_G2API_SetBoneAngles(ghoul2, 0, "lower_lumbar", llAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "upper_lumbar", ulAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "thoracic", thoracicAngles, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); //strap_G2API_SetBoneAngles(ghoul2, 0, "cervical", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, 0, 0, time); }

void BG_IK_MoveArm (  void *  ghoul2, int  lHandBolt, int  time, entityState_t *  ent, int  basePose, vec3_t  desiredPos, qboolean *  ikInProgress, vec3_t  origin, vec3_t  angles, vec3_t  scale, int  blendTime, qboolean  forceHalt )

Definition at line 8577 of file bg_pmove.c. References sharedSetBoneIKStateParams_t::angles, sharedRagDollUpdateParams_t::angles, bgHumanoidAnimations, sharedSetBoneIKStateParams_t::blendTime, BONE_ANGLES_POSTMULT, sharedIKMoveParams_t::boneName, sharedIKMoveParams_t::desiredOrigin, sharedSetBoneIKStateParams_t::endFrame, entityState_t, animation_s::firstFrame, sharedSetBoneIKStateParams_t::forceAnimOnBone, IKS_DYNAMIC, IKS_NONE, mdxaBone_t::matrix, sharedRagDollUpdateParams_t::me, sharedIKMoveParams_t::movementSpeed, NEGATIVE_Y, NEGATIVE_Z, NULL, entityState_s::number, animation_s::numFrames, sharedSetBoneIKStateParams_t::origin, sharedIKMoveParams_t::origin, sharedSetBoneIKStateParams_t::pcjMaxs, sharedSetBoneIKStateParams_t::pcjMins, sharedSetBoneIKStateParams_t::pcjOverrides, PITCH, sharedRagDollUpdateParams_t::position, POSITIVE_X, qfalse, qtrue, sharedSetBoneIKStateParams_t::radius, ROLL, sharedSetBoneIKStateParams_t::scale, sharedRagDollUpdateParams_t::scale, sharedSetBoneIKStateParams_t::startFrame, strap_G2API_AnimateG2Models(), strap_G2API_GetBoltMatrix(), strap_G2API_GetBoneAnim(), strap_G2API_IKMove(), strap_G2API_SetBoneAngles(), strap_G2API_SetBoneAnim(), strap_G2API_SetBoneIKState(), vec3_origin, vec3_t, VectorClear, VectorCopy, VectorSet, VectorSubtract, and sharedRagDollUpdateParams_t::velocity. { mdxaBone_t lHandMatrix; vec3_t lHand; vec3_t torg; float distToDest; if (!ghoul2) { return; } assert(bgHumanoidAnimations[basePose].firstFrame > 0); if (!*ikInProgress && !forceHalt) { int baseposeAnim = basePose; sharedSetBoneIKStateParams_t ikP; //restrict the shoulder joint //VectorSet(ikP.pcjMins,-50.0f,-80.0f,-15.0f); //VectorSet(ikP.pcjMaxs,15.0f,40.0f,15.0f); //for now, leaving it unrestricted, but restricting elbow joint. //This lets us break the arm however we want in order to fling people //in throws, and doesn't look bad. VectorSet(ikP.pcjMins,0,0,0); VectorSet(ikP.pcjMaxs,0,0,0); //give the info on our entity. ikP.blendTime = blendTime; VectorCopy(origin, ikP.origin); VectorCopy(angles, ikP.angles); ikP.angles[PITCH] = 0; ikP.pcjOverrides = 0; ikP.radius = 10.0f; VectorCopy(scale, ikP.scale); //base pose frames for the limb ikP.startFrame = bgHumanoidAnimations[baseposeAnim].firstFrame + bgHumanoidAnimations[baseposeAnim].numFrames; ikP.endFrame = bgHumanoidAnimations[baseposeAnim].firstFrame + bgHumanoidAnimations[baseposeAnim].numFrames; ikP.forceAnimOnBone = qfalse; //let it use existing anim if it's the same as this one. //we want to call with a null bone name first. This will init all of the //ik system stuff on the g2 instance, because we need ragdoll effectors //in order for our pcj's to know how to angle properly. if (!strap_G2API_SetBoneIKState(ghoul2, time, NULL, IKS_DYNAMIC, &ikP)) { assert(!"Failed to init IK system for g2 instance!"); } //Now, create our IK bone state. if (strap_G2API_SetBoneIKState(ghoul2, time, "lhumerus", IKS_DYNAMIC, &ikP)) { //restrict the elbow joint VectorSet(ikP.pcjMins,-90.0f,-20.0f,-20.0f); VectorSet(ikP.pcjMaxs,30.0f,20.0f,-20.0f); if (strap_G2API_SetBoneIKState(ghoul2, time, "lradius", IKS_DYNAMIC, &ikP)) { //everything went alright. *ikInProgress = qtrue; } } } if (*ikInProgress && !forceHalt) { //actively update our ik state. sharedIKMoveParams_t ikM; sharedRagDollUpdateParams_t tuParms; vec3_t tAngles; //set the argument struct up VectorCopy(desiredPos, ikM.desiredOrigin); //we want the bone to move here.. if possible VectorCopy(angles, tAngles); tAngles[PITCH] = tAngles[ROLL] = 0; strap_G2API_GetBoltMatrix(ghoul2, 0, lHandBolt, &lHandMatrix, tAngles, origin, time, 0, scale); //Get the point position from the matrix. lHand[0] = lHandMatrix.matrix[0][3]; lHand[1] = lHandMatrix.matrix[1][3]; lHand[2] = lHandMatrix.matrix[2][3]; VectorSubtract(lHand, desiredPos, torg); distToDest = VectorLength(torg); //closer we are, more we want to keep updated. //if we're far away we don't want to be too fast or we'll start twitching all over. if (distToDest < 2) { //however if we're this close we want very precise movement ikM.movementSpeed = 0.4f; } else if (distToDest < 16) { ikM.movementSpeed = 0.9f;//8.0f; } else if (distToDest < 32) { ikM.movementSpeed = 0.8f;//4.0f; } else if (distToDest < 64) { ikM.movementSpeed = 0.7f;//2.0f; } else { ikM.movementSpeed = 0.6f; } VectorCopy(origin, ikM.origin); //our position in the world. ikM.boneName[0] = 0; if (strap_G2API_IKMove(ghoul2, time, &ikM)) { //now do the standard model animate stuff with ragdoll update params. VectorCopy(angles, tuParms.angles); tuParms.angles[PITCH] = 0; VectorCopy(origin, tuParms.position); VectorCopy(scale, tuParms.scale); tuParms.me = ent->number; VectorClear(tuParms.velocity); strap_G2API_AnimateG2Models(ghoul2, time, &tuParms); } else { *ikInProgress = qfalse; } } else if (*ikInProgress) { //kill it float cFrame, animSpeed; int sFrame, eFrame, flags; strap_G2API_SetBoneIKState(ghoul2, time, "lhumerus", IKS_NONE, NULL); strap_G2API_SetBoneIKState(ghoul2, time, "lradius", IKS_NONE, NULL); //then reset the angles/anims on these PCJs strap_G2API_SetBoneAngles(ghoul2, 0, "lhumerus", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time); strap_G2API_SetBoneAngles(ghoul2, 0, "lradius", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time); //Get the anim/frames that the pelvis is on exactly, and match the left arm back up with them again. strap_G2API_GetBoneAnim(ghoul2, "pelvis", (const int)time, &cFrame, &sFrame, &eFrame, &flags, &animSpeed, 0, 0); strap_G2API_SetBoneAnim(ghoul2, 0, "lhumerus", sFrame, eFrame, flags, animSpeed, time, sFrame, 300); strap_G2API_SetBoneAnim(ghoul2, 0, "lradius", sFrame, eFrame, flags, animSpeed, time, sFrame, 300); //And finally, get rid of all the ik state effector data by calling with null bone name (similar to how we init it). strap_G2API_SetBoneIKState(ghoul2, time, NULL, IKS_NONE, NULL); *ikInProgress = qfalse; } }

qboolean BG_InKnockDown (  int  anim  )

Definition at line 8526 of file bg_pmove.c. References BOTH_FORCE_GETUP_B1, BOTH_FORCE_GETUP_B2, BOTH_FORCE_GETUP_B3, BOTH_FORCE_GETUP_B4, BOTH_FORCE_GETUP_B5, BOTH_FORCE_GETUP_F1, BOTH_FORCE_GETUP_F2, BOTH_GETUP1, BOTH_GETUP2, BOTH_GETUP3, BOTH_GETUP4, BOTH_GETUP5, BOTH_GETUP_BROLL_B, BOTH_GETUP_BROLL_F, BOTH_GETUP_BROLL_L, BOTH_GETUP_BROLL_R, BOTH_GETUP_FROLL_B, BOTH_GETUP_FROLL_F, BOTH_GETUP_FROLL_L, BOTH_GETUP_FROLL_R, BOTH_KNOCKDOWN1, BOTH_KNOCKDOWN2, BOTH_KNOCKDOWN3, BOTH_KNOCKDOWN4, BOTH_KNOCKDOWN5, qboolean, qfalse, and qtrue. Referenced by ForcePowerUsableOn(), and PM_CheckStabDown(). { switch ( (anim) ) { case BOTH_KNOCKDOWN1: case BOTH_KNOCKDOWN2: case BOTH_KNOCKDOWN3: case BOTH_KNOCKDOWN4: case BOTH_KNOCKDOWN5: return qtrue; break; case BOTH_GETUP1: case BOTH_GETUP2: case BOTH_GETUP3: case BOTH_GETUP4: case BOTH_GETUP5: case BOTH_FORCE_GETUP_F1: case BOTH_FORCE_GETUP_F2: case BOTH_FORCE_GETUP_B1: case BOTH_FORCE_GETUP_B2: case BOTH_FORCE_GETUP_B3: case BOTH_FORCE_GETUP_B4: case BOTH_FORCE_GETUP_B5: case BOTH_GETUP_BROLL_B: case BOTH_GETUP_BROLL_F: case BOTH_GETUP_BROLL_L: case BOTH_GETUP_BROLL_R: case BOTH_GETUP_FROLL_B: case BOTH_GETUP_FROLL_F: case BOTH_GETUP_FROLL_L: case BOTH_GETUP_FROLL_R: return qtrue; break; } return qfalse; }

qboolean BG_InRoll2 (  entityState_t *  es  )

Definition at line 9059 of file bg_pmove.c. References BOTH_GETUP_BROLL_B, BOTH_GETUP_BROLL_F, BOTH_GETUP_BROLL_L, BOTH_GETUP_BROLL_R, BOTH_GETUP_FROLL_B, BOTH_GETUP_FROLL_F, BOTH_GETUP_FROLL_L, BOTH_GETUP_FROLL_R, BOTH_ROLL_B, BOTH_ROLL_F, BOTH_ROLL_L, BOTH_ROLL_R, entityState_t, entityState_s::legsAnim, qboolean, qfalse, and qtrue. Referenced by BG_G2PlayerAngles(). { switch ( (es->legsAnim) ) { case BOTH_GETUP_BROLL_B: case BOTH_GETUP_BROLL_F: case BOTH_GETUP_BROLL_L: case BOTH_GETUP_BROLL_R: case BOTH_GETUP_FROLL_B: case BOTH_GETUP_FROLL_F: case BOTH_GETUP_FROLL_L: case BOTH_GETUP_FROLL_R: case BOTH_ROLL_F: case BOTH_ROLL_B: case BOTH_ROLL_R: case BOTH_ROLL_L: return qtrue; break; } return qfalse; }

qboolean BG_InRollAnim (  entityState_t *  cent  )

Definition at line 8513 of file bg_pmove.c. References BOTH_ROLL_B, BOTH_ROLL_F, BOTH_ROLL_L, BOTH_ROLL_R, entityState_t, entityState_s::legsAnim, qboolean, qfalse, and qtrue. { switch ( (cent->legsAnim) ) { case BOTH_ROLL_F: case BOTH_ROLL_B: case BOTH_ROLL_R: case BOTH_ROLL_L: return qtrue; } return qfalse; }

qboolean BG_InRollES (  entityState_t *  ps, int  anim )

Definition at line 8563 of file bg_pmove.c. References BOTH_ROLL_B, BOTH_ROLL_F, BOTH_ROLL_L, BOTH_ROLL_R, entityState_t, qboolean, qfalse, and qtrue. { switch ( (anim) ) { case BOTH_ROLL_F: case BOTH_ROLL_B: case BOTH_ROLL_R: case BOTH_ROLL_L: return qtrue; break; } return qfalse; }

qboolean BG_InSlopeAnim (  int  anim  )

Definition at line 4743 of file bg_pmove.c. References LEGS_LEFTUP1, LEGS_LEFTUP2, LEGS_LEFTUP3, LEGS_LEFTUP4, LEGS_LEFTUP5, LEGS_RIGHTUP1, LEGS_RIGHTUP2, LEGS_RIGHTUP3, LEGS_RIGHTUP4, LEGS_RIGHTUP5, LEGS_S1_LUP1, LEGS_S1_LUP2, LEGS_S1_LUP3, LEGS_S1_LUP4, LEGS_S1_LUP5, LEGS_S1_RUP1, LEGS_S1_RUP2, LEGS_S1_RUP3, LEGS_S1_RUP4, LEGS_S1_RUP5, LEGS_S3_LUP1, LEGS_S3_LUP2, LEGS_S3_LUP3, LEGS_S3_LUP4, LEGS_S3_LUP5, LEGS_S3_RUP1, LEGS_S3_RUP2, LEGS_S3_RUP3, LEGS_S3_RUP4, LEGS_S3_RUP5, LEGS_S4_LUP1, LEGS_S4_LUP2, LEGS_S4_LUP3, LEGS_S4_LUP4, LEGS_S4_LUP5, LEGS_S4_RUP1, LEGS_S4_RUP2, LEGS_S4_RUP3, LEGS_S4_RUP4, LEGS_S4_RUP5, LEGS_S5_LUP1, LEGS_S5_LUP2, LEGS_S5_LUP3, LEGS_S5_LUP4, LEGS_S5_LUP5, LEGS_S5_RUP1, LEGS_S5_RUP2, LEGS_S5_RUP3, LEGS_S5_RUP4, LEGS_S5_RUP5, qboolean, qfalse, and qtrue. Referenced by PM_SetSaberMove(), and PM_WeaponLightsaber(). { switch ( anim ) { case LEGS_LEFTUP1: //# On a slope with left foot 4 higher than right case LEGS_LEFTUP2: //# On a slope with left foot 8 higher than right case LEGS_LEFTUP3: //# On a slope with left foot 12 higher than right case LEGS_LEFTUP4: //# On a slope with left foot 16 higher than right case LEGS_LEFTUP5: //# On a slope with left foot 20 higher than right case LEGS_RIGHTUP1: //# On a slope with RIGHT foot 4 higher than left case LEGS_RIGHTUP2: //# On a slope with RIGHT foot 8 higher than left case LEGS_RIGHTUP3: //# On a slope with RIGHT foot 12 higher than left case LEGS_RIGHTUP4: //# On a slope with RIGHT foot 16 higher than left case LEGS_RIGHTUP5: //# On a slope with RIGHT foot 20 higher than left case LEGS_S1_LUP1: case LEGS_S1_LUP2: case LEGS_S1_LUP3: case LEGS_S1_LUP4: case LEGS_S1_LUP5: case LEGS_S1_RUP1: case LEGS_S1_RUP2: case LEGS_S1_RUP3: case LEGS_S1_RUP4: case LEGS_S1_RUP5: case LEGS_S3_LUP1: case LEGS_S3_LUP2: case LEGS_S3_LUP3: case LEGS_S3_LUP4: case LEGS_S3_LUP5: case LEGS_S3_RUP1: case LEGS_S3_RUP2: case LEGS_S3_RUP3: case LEGS_S3_RUP4: case LEGS_S3_RUP5: case LEGS_S4_LUP1: case LEGS_S4_LUP2: case LEGS_S4_LUP3: case LEGS_S4_LUP4: case LEGS_S4_LUP5: case LEGS_S4_RUP1: case LEGS_S4_RUP2: case LEGS_S4_RUP3: case LEGS_S4_RUP4: case LEGS_S4_RUP5: case LEGS_S5_LUP1: case LEGS_S5_LUP2: case LEGS_S5_LUP3: case LEGS_S5_LUP4: case LEGS_S5_LUP5: case LEGS_S5_RUP1: case LEGS_S5_RUP2: case LEGS_S5_RUP3: case LEGS_S5_RUP4: case LEGS_S5_RUP5: return qtrue; break; } return qfalse; }

qboolean BG_KnockDownable (  playerState_t *  ps  )

Definition at line 218 of file bg_pmove.c. References playerState_s::emplacedIndex, playerState_s::m_iVehicleNum, playerState_t, qboolean, qfalse, and qtrue. Referenced by ClientCommand(), ClientThink_real(), ForceThrow(), G_Knockdown(), PM_SaberLockBreak(), PM_VehicleImpact(), and Wampa_Slash(). { if (!ps) { //just for safety return qfalse; } if (ps->m_iVehicleNum) { //riding a vehicle, don't knock me down return qfalse; } if (ps->emplacedIndex) { //using emplaced gun or eweb, can't be knocked down return qfalse; } //ok, I guess? return qtrue; }

saberInfo_t* BG_MySaber (  int  clientNum, int  saberNum )

qboolean BG_SaberLockBreakAnim (  int  anim  )

Definition at line 1487 of file bg_panimate.c. References BG_SuperBreakLoseAnim(), BG_SuperBreakWinAnim(), BOTH_BF1BREAK, BOTH_BF2BREAK, BOTH_CCWCIRCLEBREAK, BOTH_CWCIRCLEBREAK, BOTH_LK_DL_DL_S_B_1_L, BOTH_LK_DL_DL_S_B_1_W, BOTH_LK_DL_DL_T_B_1_L, BOTH_LK_DL_DL_T_B_1_W, BOTH_LK_DL_S_S_B_1_L, BOTH_LK_DL_S_S_B_1_W, BOTH_LK_DL_S_T_B_1_L, BOTH_LK_DL_S_T_B_1_W, BOTH_LK_DL_ST_S_B_1_L, BOTH_LK_DL_ST_S_B_1_W, BOTH_LK_DL_ST_T_B_1_L, BOTH_LK_DL_ST_T_B_1_W, BOTH_LK_S_DL_S_B_1_L, BOTH_LK_S_DL_S_B_1_W, BOTH_LK_S_DL_T_B_1_L, BOTH_LK_S_DL_T_B_1_W, BOTH_LK_S_S_S_B_1_L, BOTH_LK_S_S_S_B_1_W, BOTH_LK_S_S_T_B_1_L, BOTH_LK_S_S_T_B_1_W, BOTH_LK_S_ST_S_B_1_L, BOTH_LK_S_ST_S_B_1_W, BOTH_LK_S_ST_T_B_1_L, BOTH_LK_S_ST_T_B_1_W, BOTH_LK_ST_DL_S_B_1_L, BOTH_LK_ST_DL_S_B_1_W, BOTH_LK_ST_DL_T_B_1_L, BOTH_LK_ST_DL_T_B_1_W, BOTH_LK_ST_S_S_B_1_L, BOTH_LK_ST_S_S_B_1_W, BOTH_LK_ST_S_T_B_1_L, BOTH_LK_ST_S_T_B_1_W, BOTH_LK_ST_ST_S_B_1_L, BOTH_LK_ST_ST_S_B_1_W, BOTH_LK_ST_ST_T_B_1_L, BOTH_LK_ST_ST_T_B_1_W, qboolean, and qtrue. Referenced by BG_G2PlayerAngles(), and PmoveSingle(). { switch ( anim ) { case BOTH_BF1BREAK: case BOTH_BF2BREAK: case BOTH_CWCIRCLEBREAK: case BOTH_CCWCIRCLEBREAK: case BOTH_LK_S_DL_S_B_1_L: //normal break I lost case BOTH_LK_S_DL_S_B_1_W: //normal break I won case BOTH_LK_S_DL_T_B_1_L: //normal break I lost case BOTH_LK_S_DL_T_B_1_W: //normal break I won case BOTH_LK_S_ST_S_B_1_L: //normal break I lost case BOTH_LK_S_ST_S_B_1_W: //normal break I won case BOTH_LK_S_ST_T_B_1_L: //normal break I lost case BOTH_LK_S_ST_T_B_1_W: //normal break I won case BOTH_LK_S_S_S_B_1_L: //normal break I lost case BOTH_LK_S_S_S_B_1_W: //normal break I won case BOTH_LK_S_S_T_B_1_L: //normal break I lost case BOTH_LK_S_S_T_B_1_W: //normal break I won case BOTH_LK_DL_DL_S_B_1_L: //normal break I lost case BOTH_LK_DL_DL_S_B_1_W: //normal break I won case BOTH_LK_DL_DL_T_B_1_L: //normal break I lost case BOTH_LK_DL_DL_T_B_1_W: //normal break I won case BOTH_LK_DL_ST_S_B_1_L: //normal break I lost case BOTH_LK_DL_ST_S_B_1_W: //normal break I won case BOTH_LK_DL_ST_T_B_1_L: //normal break I lost case BOTH_LK_DL_ST_T_B_1_W: //normal break I won case BOTH_LK_DL_S_S_B_1_L: //normal break I lost case BOTH_LK_DL_S_S_B_1_W: //normal break I won case BOTH_LK_DL_S_T_B_1_L: //normal break I lost case BOTH_LK_DL_S_T_B_1_W: //normal break I won case BOTH_LK_ST_DL_S_B_1_L: //normal break I lost case BOTH_LK_ST_DL_S_B_1_W: //normal break I won case BOTH_LK_ST_DL_T_B_1_L: //normal break I lost case BOTH_LK_ST_DL_T_B_1_W: //normal break I won case BOTH_LK_ST_ST_S_B_1_L: //normal break I lost case BOTH_LK_ST_ST_S_B_1_W: //normal break I won case BOTH_LK_ST_ST_T_B_1_L: //normal break I lost case BOTH_LK_ST_ST_T_B_1_W: //normal break I won case BOTH_LK_ST_S_S_B_1_L: //normal break I lost case BOTH_LK_ST_S_S_B_1_W: //normal break I won case BOTH_LK_ST_S_T_B_1_L: //normal break I lost case BOTH_LK_ST_S_T_B_1_W: //normal break I won return qtrue; break; } return (BG_SuperBreakLoseAnim(anim)||BG_SuperBreakWinAnim(anim)); }

qboolean BG_SabersOff (  playerState_t *  ps  )

Definition at line 201 of file bg_pmove.c. References playerState_s::fd, playerState_t, qboolean, qfalse, qtrue, forcedata_s::saberAnimLevelBase, playerState_s::saberHolstered, SS_DUAL, and SS_STAFF. Referenced by Jedi_SaberBlockGo(), NPC_BSGrenadier_Attack(), PM_GetSaberStance(), PM_VehicleWeaponAnimate(), PM_WeaponLightsaber(), SaberUpdateSelf(), WP_SaberCanBlock(), WP_SaberPositionUpdate(), WP_SabersIntersect(), and WP_SaberStartMissileBlockCheck(). { if ( !ps->saberHolstered ) { return qfalse; } if ( ps->fd.saberAnimLevelBase == SS_DUAL || ps->fd.saberAnimLevelBase == SS_STAFF ) { if ( ps->saberHolstered < 2 ) { return qfalse; } } return qtrue; }

qboolean BG_UnrestrainedPitchRoll (  playerState_t *  ps, Vehicle_t *  pVeh )

Definition at line 7785 of file bg_pmove.c. References bg_fighterAltControl, playerState_s::clientNum, vmCvar_t::integer, playerState_s::m_iVehicleNum, Vehicle_s::m_pVehicleInfo, MAX_CLIENTS, playerState_t, qboolean, qfalse, qtrue, vehicleInfo_t::type, Vehicle_t, and VH_FIGHTER. Referenced by PM_UpdateViewAngles(), and PM_VehicleViewAngles(). { if ( bg_fighterAltControl.integer && ps->clientNum < MAX_CLIENTS //real client && ps->m_iVehicleNum//in a vehicle && pVeh //valid vehicle data pointer && pVeh->m_pVehicleInfo//valid vehicle info && pVeh->m_pVehicleInfo->type == VH_FIGHTER )//fighter //FIXME: specify per vehicle instead of assuming true for all fighters //FIXME: map/server setting? {//can roll and pitch without limitation! return qtrue; } return qfalse; }

void BG_UpdateLookAngles (  int  lookingDebounceTime, vec3_t  lastHeadAngles, int  time, vec3_t  lookAngles, float  lookSpeed, float  minPitch, float  maxPitch, float  minYaw, float  maxYaw, float  minRoll, float  maxRoll )

Definition at line 8734 of file bg_pmove.c. References AngleNormalize180(), PITCH, ROLL, vec3_t, VectorCopy, VectorSubtract, and YAW. Referenced by BG_G2PlayerAngles(). { static const float fFrameInter = 0.1f; static vec3_t oldLookAngles; static vec3_t lookAnglesDiff; static int ang; if ( lookingDebounceTime > time ) { //clamp so don't get "Exorcist" effect if ( lookAngles[PITCH] > maxPitch ) { lookAngles[PITCH] = maxPitch; } else if ( lookAngles[PITCH] < minPitch ) { lookAngles[PITCH] = minPitch; } if ( lookAngles[YAW] > maxYaw ) { lookAngles[YAW] = maxYaw; } else if ( lookAngles[YAW] < minYaw ) { lookAngles[YAW] = minYaw; } if ( lookAngles[ROLL] > maxRoll ) { lookAngles[ROLL] = maxRoll; } else if ( lookAngles[ROLL] < minRoll ) { lookAngles[ROLL] = minRoll; } //slowly lerp to this new value //Remember last headAngles VectorCopy( lastHeadAngles, oldLookAngles ); VectorSubtract( lookAngles, oldLookAngles, lookAnglesDiff ); for ( ang = 0; ang < 3; ang++ ) { lookAnglesDiff[ang] = AngleNormalize180( lookAnglesDiff[ang] ); } if( VectorLengthSquared( lookAnglesDiff ) ) { lookAngles[PITCH] = AngleNormalize180( oldLookAngles[PITCH]+(lookAnglesDiff[PITCH]*fFrameInter*lookSpeed) ); lookAngles[YAW] = AngleNormalize180( oldLookAngles[YAW]+(lookAnglesDiff[YAW]*fFrameInter*lookSpeed) ); lookAngles[ROLL] = AngleNormalize180( oldLookAngles[ROLL]+(lookAnglesDiff[ROLL]*fFrameInter*lookSpeed) ); } } //Remember current lookAngles next time VectorCopy( lookAngles, lastHeadAngles ); }

void BG_VehicleAdjustBBoxForOrientation (  Vehicle_t *  veh, vec3_t  origin, vec3_t  mins, vec3_t  maxs, int  clientNum, int  tracemask, void(*  localTrace)(trace_t *results, const vec3_t start, const vec3_t mins, const vec3_t maxs, const vec3_t end, int passEntityNum, int contentMask) )

Definition at line 9990 of file bg_pmove.c. References trace_t::allsolid, AnglesToAxis(), DEFAULT_MINS_2, vehicleInfo_t::height, vehicleInfo_t::length, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vOrientation, trace_t::startsolid, vehicleInfo_t::type, vec3_t, VectorCopy, VectorMA, VectorSet, VectorSubtract, Vehicle_t, VH_FIGHTER, VH_FLIER, and vehicleInfo_t::width. Referenced by PmoveSingle(). { if ( !veh || !veh->m_pVehicleInfo->length || !veh->m_pVehicleInfo->width || !veh->m_pVehicleInfo->height ) //|| veh->m_LandTrace.fraction < 1.0f ) { return; } else if ( veh->m_pVehicleInfo->type != VH_FIGHTER //&& veh->m_pVehicleInfo->type != VH_SPEEDER && veh->m_pVehicleInfo->type != VH_FLIER ) {//only those types of vehicles have dynamic bboxes, the rest just use a static bbox VectorSet( maxs, veh->m_pVehicleInfo->width/2.0f, veh->m_pVehicleInfo->width/2.0f, veh->m_pVehicleInfo->height+DEFAULT_MINS_2 ); VectorSet( mins, veh->m_pVehicleInfo->width/-2.0f, veh->m_pVehicleInfo->width/-2.0f, DEFAULT_MINS_2 ); return; } else { vec3_t axis[3], point[8]; vec3_t newMins, newMaxs; int curAxis = 0, i; trace_t trace; AnglesToAxis( veh->m_vOrientation, axis ); VectorMA( origin, veh->m_pVehicleInfo->length/2.0f, axis[0], point[0] ); VectorMA( origin, -veh->m_pVehicleInfo->length/2.0f, axis[0], point[1] ); //extrapolate each side up and down VectorMA( point[0], veh->m_pVehicleInfo->height/2.0f, axis[2], point[0] ); VectorMA( point[0], -veh->m_pVehicleInfo->height, axis[2], point[2] ); VectorMA( point[1], veh->m_pVehicleInfo->height/2.0f, axis[2], point[1] ); VectorMA( point[1], -veh->m_pVehicleInfo->height, axis[2], point[3] ); VectorMA( origin, veh->m_pVehicleInfo->width/2.0f, axis[1], point[4] ); VectorMA( origin, -veh->m_pVehicleInfo->width/2.0f, axis[1], point[5] ); //extrapolate each side up and down VectorMA( point[4], veh->m_pVehicleInfo->height/2.0f, axis[2], point[4] ); VectorMA( point[4], -veh->m_pVehicleInfo->height, axis[2], point[6] ); VectorMA( point[5], veh->m_pVehicleInfo->height/2.0f, axis[2], point[5] ); VectorMA( point[5], -veh->m_pVehicleInfo->height, axis[2], point[7] ); /* VectorMA( origin, veh->m_pVehicleInfo->height/2.0f, axis[2], point[4] ); VectorMA( origin, -veh->m_pVehicleInfo->height/2.0f, axis[2], point[5] ); */ //Now inflate a bbox around these points VectorCopy( origin, newMins ); VectorCopy( origin, newMaxs ); for ( curAxis = 0; curAxis < 3; curAxis++ ) { for ( i = 0; i < 8; i++ ) { if ( point[i][curAxis] > newMaxs[curAxis] ) { newMaxs[curAxis] = point[i][curAxis]; } else if ( point[i][curAxis] < newMins[curAxis] ) { newMins[curAxis] = point[i][curAxis]; } } } VectorSubtract( newMins, origin, newMins ); VectorSubtract( newMaxs, origin, newMaxs ); //now see if that's a valid way to be if (localTrace) { localTrace( &trace, origin, newMins, newMaxs, origin, clientNum, tracemask ); } else { //don't care about solid stuff then trace.startsolid = trace.allsolid = 0; } if ( !trace.startsolid && !trace.allsolid ) {//let's use it! VectorCopy( newMins, mins ); VectorCopy( newMaxs, maxs ); } //else: just use the last one, I guess...? //FIXME: make it as close as possible? Or actually prevent the change in m_vOrientation? Or push away from anything we hit? } }

void BG_VehicleTurnRateForSpeed (  Vehicle_t *  pVeh, float  speed, float *  mPitchOverride, float *  mYawOverride )

Definition at line 676 of file bg_pmove.c. References trace_t::fraction, Vehicle_s::m_LandTrace, Vehicle_s::m_pVehicleInfo, MIN_LANDING_SLOPE, vehicleInfo_t::mousePitch, vehicleInfo_t::mouseYaw, cplane_s::normal, trace_t::plane, vehicleInfo_t::speedDependantTurning, vehicleInfo_t::speedMax, and Vehicle_t. Referenced by CG_DrawActiveFrame(). { if ( pVeh && pVeh->m_pVehicleInfo ) { float speedFrac = 1.0f; if ( pVeh->m_pVehicleInfo->speedDependantTurning ) { if ( pVeh->m_LandTrace.fraction >= 1.0f || pVeh->m_LandTrace.plane.normal[2] < MIN_LANDING_SLOPE ) { speedFrac = (speed/(pVeh->m_pVehicleInfo->speedMax*0.75f)); if ( speedFrac < 0.25f ) { speedFrac = 0.25f; } else if ( speedFrac > 1.0f ) { speedFrac = 1.0f; } } } if ( pVeh->m_pVehicleInfo->mousePitch ) { *mPitchOverride = pVeh->m_pVehicleInfo->mousePitch*speedFrac; } if ( pVeh->m_pVehicleInfo->mouseYaw ) { *mYawOverride = pVeh->m_pVehicleInfo->mouseYaw*speedFrac; } } }

int BG_VehTraceFromCamPos (  trace_t *  camTrace, bgEntity_t *  bgEnt, const vec3_t  entOrg, const vec3_t  shotStart, const vec3_t  end, vec3_t  newEnd, vec3_t  shotDir, float  bestDist )

Definition at line 5834 of file bg_pmove.c. References trace_t::allsolid, bgEntity_t, CG_GetVehicleCamPos(), CONTENTS_BODY, CONTENTS_SOLID, trace_t::endpos, trace_t::entityNum, trace_t::fraction, gentity_t, vehicleInfo_t::length, Vehicle_s::m_pPilot, gentity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, MAX_XHAIR_DIST_ACCURACY, entityState_s::number, pm, gentity_s::s, trace_t::startsolid, pmove_t::trace, trap_Trace(), vec3_origin, vec3_t, VectorCopy, VectorMA, VectorNormalize(), VectorSubtract, and WP_GetVehicleCamPos(). Referenced by PM_RocketLock(), and WP_VehCheckTraceFromCamPos(). { //NOTE: this MUST stay up to date with the method used in CG_ScanForCrosshairEntity (where it checks the doExtraVehTraceFromViewPos bool) vec3_t viewDir2End, extraEnd, camPos; float minAutoAimDist; #ifdef QAGAME WP_GetVehicleCamPos( (gentity_t *)bgEnt, (gentity_t *)bgEnt->m_pVehicle->m_pPilot, camPos ); #else CG_GetVehicleCamPos( camPos ); #endif minAutoAimDist = Distance( entOrg, camPos ) + (bgEnt->m_pVehicle->m_pVehicleInfo->length/2.0f) + 200.0f; VectorCopy( end, newEnd ); VectorSubtract( end, camPos, viewDir2End ); VectorNormalize( viewDir2End ); VectorMA( camPos, MAX_XHAIR_DIST_ACCURACY, viewDir2End, extraEnd ); #ifdef QAGAME trap_Trace( camTrace, camPos, vec3_origin, vec3_origin, extraEnd, bgEnt->s.number, CONTENTS_SOLID|CONTENTS_BODY ); #else pm->trace( camTrace, camPos, vec3_origin, vec3_origin, extraEnd, bgEnt->s.number, CONTENTS_SOLID|CONTENTS_BODY ); #endif if ( !camTrace->allsolid && !camTrace->startsolid && camTrace->fraction < 1.0f && (camTrace->fraction*MAX_XHAIR_DIST_ACCURACY) > minAutoAimDist && ((camTrace->fraction*MAX_XHAIR_DIST_ACCURACY)-Distance( entOrg, camPos )) < bestDist ) {//this trace hit *something* that's closer than the thing the main trace hit, so use this result instead VectorCopy( camTrace->endpos, newEnd ); VectorSubtract( newEnd, shotStart, shotDir ); VectorNormalize( shotDir ); return (camTrace->entityNum+1); } return 0; }

void CG_GetVehicleCamPos (  vec3_t  camPos  )

Definition at line 797 of file cg_view.c. References cg, cg_t::refdef, vec3_t, VectorCopy, and refdef_t::vieworg. Referenced by BG_VehTraceFromCamPos(). { VectorCopy( cg.refdef.vieworg, camPos ); }

void PM_AddEvent (  int  newEvent  )

Definition at line 910 of file bg_pmove.c. References BG_AddPredictableEventToPlayerstate(), pm, and pmove_t::ps. Referenced by BG_EnoughForcePowerForMove(), PM_AdjustAngleForWallRunUp(), PM_AdjustAttackStates(), PM_GrabWallForJump(), PM_MoveForKata(), PM_SaberAttackForMovement(), PM_SaberFlipOverAttackMove(), PM_SaberJumpAttackMove(), PM_SaberLockBreak(), PM_SaberLocked(), PM_SaberLungeAttackMove(), PM_SetSaberMove(), PM_StepSlideMove(), PM_VehicleWeaponAnimate(), and PM_WeaponLightsaber(). { BG_AddPredictableEventToPlayerstate( newEvent, 0, pm->ps ); }

void PM_AddEventWithParm (  int  newEvent, int  parm )

Definition at line 914 of file bg_pmove.c. References BG_AddPredictableEventToPlayerstate(), pm, and pmove_t::ps. Referenced by PM_BeginWeaponChange(), PM_ItemUsable(), and PmoveSingle(). { BG_AddPredictableEventToPlayerstate( newEvent, parm, pm->ps ); }

void PM_AddTouchEnt (  int  entityNum  )

Definition at line 924 of file bg_pmove.c. References ENTITYNUM_WORLD, MAXTOUCH, pmove_t::numtouch, pm, and pmove_t::touchents. Referenced by PM_SlideMove(). { int i; if ( entityNum == ENTITYNUM_WORLD ) { return; } if ( pm->numtouch == MAXTOUCH ) { return; } // see if it is already added for ( i = 0 ; i < pm->numtouch ; i++ ) { if ( pm->touchents[ i ] == entityNum ) { return; } } // add it pm->touchents[pm->numtouch] = entityNum; pm->numtouch++; }

qboolean PM_AdjustAngleForWallJump (  playerState_t *  ps, usercmd_t *  ucmd, qboolean  doMove )

Definition at line 1607 of file bg_pmove.c. References ANGLE2SHORT, usercmd_s::angles, AngleVectors(), BG_ForcePowerDrain(), BG_InReboundHold(), BG_InReboundJump(), BOTH_FORCEJUMP1, BOTH_FORCEWALLHOLD_BACK, BOTH_FORCEWALLHOLD_FORWARD, BOTH_FORCEWALLHOLD_LEFT, BOTH_FORCEWALLHOLD_RIGHT, BOTH_FORCEWALLREBOUND_BACK, BOTH_FORCEWALLREBOUND_FORWARD, BOTH_FORCEWALLREBOUND_LEFT, BOTH_FORCEWALLREBOUND_RIGHT, BOTH_FORCEWALLRELEASE_FORWARD, playerState_s::clientNum, pmove_t::debugMelee, playerState_s::delta_angles, fabs(), playerState_s::fd, forcedata_s::forceJumpSound, forcedata_s::forceJumpZStart, usercmd_s::forwardmove, FP_LEVITATION, trace_t::fraction, JUMP_OFF_WALL_SPEED, playerState_s::legsAnim, playerState_s::legsTimer, MASK_PLAYERSOLID, pmove_t::maxs, pmove_t::mins, cplane_s::normal, NULL, playerState_s::origin, trace_t::plane, playerState_t, pm, playerState_s::pm_flags, PM_SetAnim(), PM_SetPMViewAngle(), playerState_s::pm_time, PMF_JUMP_HELD, PMF_STUCK_TO_WALL, PMF_TIME_KNOCKBACK, pmove_t::ps, qboolean, qfalse, qtrue, usercmd_s::rightmove, playerState_s::saberHolstered, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_RESTART, SETANIM_LEGS, playerState_s::torsoAnim, playerState_s::torsoTimer, pmove_t::trace, ucmd, usercmd_s::upmove, usercmd_t, vec3_t, VectorMA, VectorScale, VectorSet, vectoyaw(), playerState_s::velocity, playerState_s::viewangles, and YAW. Referenced by PmoveSingle(). { if ( ( ( BG_InReboundJump( ps->legsAnim ) || BG_InReboundHold( ps->legsAnim ) ) && ( BG_InReboundJump( ps->torsoAnim ) || BG_InReboundHold( ps->torsoAnim ) ) ) || (pm->ps->pm_flags&PMF_STUCK_TO_WALL) ) {//hugging wall, getting ready to jump off //stick to wall, if there is one vec3_t checkDir, traceTo, mins, maxs, fwdAngles; trace_t trace; float dist = 128.0f, yawAdjust; VectorSet(mins, pm->mins[0],pm->mins[1],0); VectorSet(maxs, pm->maxs[0],pm->maxs[1],24); VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0); switch ( ps->legsAnim ) { case BOTH_FORCEWALLREBOUND_RIGHT: case BOTH_FORCEWALLHOLD_RIGHT: AngleVectors( fwdAngles, NULL, checkDir, NULL ); yawAdjust = -90; break; case BOTH_FORCEWALLREBOUND_LEFT: case BOTH_FORCEWALLHOLD_LEFT: AngleVectors( fwdAngles, NULL, checkDir, NULL ); VectorScale( checkDir, -1, checkDir ); yawAdjust = 90; break; case BOTH_FORCEWALLREBOUND_FORWARD: case BOTH_FORCEWALLHOLD_FORWARD: AngleVectors( fwdAngles, checkDir, NULL, NULL ); yawAdjust = 180; break; case BOTH_FORCEWALLREBOUND_BACK: case BOTH_FORCEWALLHOLD_BACK: AngleVectors( fwdAngles, checkDir, NULL, NULL ); VectorScale( checkDir, -1, checkDir ); yawAdjust = 0; break; default: //WTF??? pm->ps->pm_flags &= ~PMF_STUCK_TO_WALL; return qfalse; break; } if ( pm->debugMelee ) {//uber-skillz if ( ucmd->upmove > 0 ) {//hold on until you let go manually if ( BG_InReboundHold( ps->legsAnim ) ) {//keep holding if ( ps->legsTimer < 150 ) { ps->legsTimer = 150; } } else {//if got to hold part of anim, play hold anim if ( ps->legsTimer <= 300 ) { ps->saberHolstered = 2; PM_SetAnim( SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ps->legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 ); ps->legsTimer = ps->torsoTimer = 150; } } } } VectorMA( ps->origin, dist, checkDir, traceTo ); pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID ); if ( //ucmd->upmove <= 0 && ps->legsTimer > 100 && trace.fraction < 1.0f && fabs(trace.plane.normal[2]) <= 0.2f/*MAX_WALL_GRAB_SLOPE*/ ) {//still a vertical wall there //FIXME: don't pull around 90 turns /* if ( ent->s.number || !player_locked ) { ucmd->forwardmove = 127; } */ if ( ucmd->upmove < 0 ) { ucmd->upmove = 0; } //align me to the wall ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust; PM_SetPMViewAngle(ps, ps->viewangles, ucmd); /* if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD ) {//don't clamp angles when looking through a viewEntity SetClientViewAngle( ent, ent->client->ps.viewangles ); } */ ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW]; //if ( ent->s.number || !player_locked ) if (1) { if ( doMove ) { //pull me toward the wall VectorScale( trace.plane.normal, -128.0f, ps->velocity ); } } ucmd->upmove = 0; ps->pm_flags |= PMF_STUCK_TO_WALL; return qtrue; } else if ( doMove && (ps->pm_flags&PMF_STUCK_TO_WALL)) {//jump off //push off of it! ps->pm_flags &= ~PMF_STUCK_TO_WALL; ps->velocity[0] = ps->velocity[1] = 0; VectorScale( checkDir, -JUMP_OFF_WALL_SPEED, ps->velocity ); ps->velocity[2] = BG_ForceWallJumpStrength(); ps->pm_flags |= PMF_JUMP_HELD;//PMF_JUMPING|PMF_JUMP_HELD; //G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" ); ps->fd.forceJumpSound = 1; //this is a stupid thing, i should fix it. //ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION); if (ps->origin[2] < ps->fd.forceJumpZStart) { ps->fd.forceJumpZStart = ps->origin[2]; } //FIXME do I need this? BG_ForcePowerDrain( ps, FP_LEVITATION, 10 ); //no control for half a second ps->pm_flags |= PMF_TIME_KNOCKBACK; ps->pm_time = 500; ucmd->forwardmove = 0; ucmd->rightmove = 0; ucmd->upmove = 127; if ( BG_InReboundHold( ps->legsAnim ) ) {//if was in hold pose, release now PM_SetAnim( SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ps->legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 ); } else { //PM_JumpForDir(); PM_SetAnim(SETANIM_LEGS,BOTH_FORCEJUMP1,SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD|SETANIM_FLAG_RESTART, 0); } //return qtrue; } } ps->pm_flags &= ~PMF_STUCK_TO_WALL; return qfalse; }

qboolean PM_AdjustAngleForWallRun (  playerState_t *  ps, usercmd_t *  ucmd, qboolean  doMove )

Definition at line 1356 of file bg_pmove.c. References ANGLE2SHORT, usercmd_s::angles, AngleVectors(), BOTH_WALL_RUN_LEFT, BOTH_WALL_RUN_LEFT_STOP, BOTH_WALL_RUN_RIGHT, BOTH_WALL_RUN_RIGHT_STOP, playerState_s::clientNum, playerState_s::delta_angles, DotProduct, usercmd_s::forwardmove, trace_t::fraction, playerState_s::legsAnim, playerState_s::legsTimer, MASK_PLAYERSOLID, cplane_s::normal, NULL, playerState_s::origin, trace_t::plane, playerState_t, pm, PM_SetAnim(), PM_SetPMViewAngle(), pmove_t::ps, qboolean, qfalse, qtrue, usercmd_s::rightmove, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, pmove_t::trace, ucmd, usercmd_s::upmove, usercmd_t, vec3_t, VectorClear, VectorMA, VectorScale, VectorSet, vectoyaw(), playerState_s::velocity, playerState_s::viewangles, and YAW. Referenced by PmoveSingle(). { if (( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT || (ps->legsAnim) == BOTH_WALL_RUN_LEFT ) && ps->legsTimer > 500 ) {//wall-running and not at end of anim //stick to wall, if there is one vec3_t fwd, rt, traceTo, mins, maxs, fwdAngles; trace_t trace; float dist, yawAdjust; VectorSet(mins, -15, -15, 0); VectorSet(maxs, 15, 15, 24); VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0); AngleVectors( fwdAngles, fwd, rt, NULL ); if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT ) { dist = 128; yawAdjust = -90; } else { dist = -128; yawAdjust = 90; } VectorMA( ps->origin, dist, rt, traceTo ); pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID ); if ( trace.fraction < 1.0f && (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= 0.4f) )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE ) { trace_t trace2; vec3_t traceTo2; vec3_t wallRunFwd, wallRunAngles; VectorClear( wallRunAngles ); wallRunAngles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust; AngleVectors( wallRunAngles, wallRunFwd, NULL, NULL ); VectorMA( pm->ps->origin, 32, wallRunFwd, traceTo2 ); pm->trace( &trace2, pm->ps->origin, mins, maxs, traceTo2, pm->ps->clientNum, MASK_PLAYERSOLID ); if ( trace2.fraction < 1.0f && DotProduct( trace2.plane.normal, wallRunFwd ) <= -0.999f ) {//wall we can't run on in front of us trace.fraction = 1.0f;//just a way to get it to kick us off the wall below } } if ( trace.fraction < 1.0f && (trace.plane.normal[2] >= 0.0f&&trace.plane.normal[2] <= 0.4f/*MAX_WALL_RUN_Z_NORMAL*/) ) {//still a wall there if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT ) { ucmd->rightmove = 127; } else { ucmd->rightmove = -127; } if ( ucmd->upmove < 0 ) { ucmd->upmove = 0; } //make me face perpendicular to the wall ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust; PM_SetPMViewAngle(ps, ps->viewangles, ucmd); ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW]; if ( doMove ) { //push me forward float zVel = ps->velocity[2]; if ( ps->legsTimer > 500 ) {//not at end of anim yet float speed = 175; if ( ucmd->forwardmove < 0 ) {//slower speed = 100; } else if ( ucmd->forwardmove > 0 ) { speed = 250;//running speed } VectorScale( fwd, speed, ps->velocity ); } ps->velocity[2] = zVel;//preserve z velocity //pull me toward the wall, too VectorMA( ps->velocity, dist, rt, ps->velocity ); } ucmd->forwardmove = 0; return qtrue; } else if ( doMove ) {//stop it if ( (ps->legsAnim) == BOTH_WALL_RUN_RIGHT ) { PM_SetAnim(SETANIM_BOTH, BOTH_WALL_RUN_RIGHT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0); } else if ( (ps->legsAnim) == BOTH_WALL_RUN_LEFT ) { PM_SetAnim(SETANIM_BOTH, BOTH_WALL_RUN_LEFT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0); } } } return qfalse; }

qboolean PM_AdjustAngleForWallRunUp (  playerState_t *  ps, usercmd_t *  ucmd, qboolean  doMove )

Definition at line 1472 of file bg_pmove.c. References trace_t::allsolid, ANGLE2SHORT, usercmd_s::angles, AngleVectors(), BOTH_FORCEWALLRUNFLIP_ALT, BOTH_FORCEWALLRUNFLIP_END, BOTH_FORCEWALLRUNFLIP_START, playerState_s::clientNum, playerState_s::delta_angles, trace_t::endpos, EV_JUMP, usercmd_s::forwardmove, trace_t::fraction, playerState_s::legsAnim, playerState_s::legsTimer, MASK_PLAYERSOLID, pmove_t::maxs, pmove_t::mins, cplane_s::normal, NULL, playerState_s::origin, trace_t::plane, playerState_t, pm, PM_AddEvent(), playerState_s::pm_flags, PM_SetAnim(), PM_SetPMViewAngle(), PMF_JUMP_HELD, pmove_t::ps, qboolean, qfalse, qtrue, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, trace_t::startsolid, pmove_t::trace, ucmd, usercmd_s::upmove, usercmd_t, vec3_t, VectorCopy, VectorMA, VectorScale, VectorSet, vectoyaw(), playerState_s::velocity, playerState_s::viewangles, and YAW. Referenced by PmoveSingle(). { if ( ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START ) {//wall-running up //stick to wall, if there is one vec3_t fwd, traceTo, mins, maxs, fwdAngles; trace_t trace; float dist = 128; VectorSet(mins, -15,-15,0); VectorSet(maxs, 15,15,24); VectorSet(fwdAngles, 0, pm->ps->viewangles[YAW], 0); AngleVectors( fwdAngles, fwd, NULL, NULL ); VectorMA( ps->origin, dist, fwd, traceTo ); pm->trace( &trace, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID ); if ( trace.fraction > 0.5f ) {//hmm, some room, see if there's a floor right here trace_t trace2; vec3_t top, bottom; VectorCopy( trace.endpos, top ); top[2] += (pm->mins[2]*-1) + 4.0f; VectorCopy( top, bottom ); bottom[2] -= 64.0f; pm->trace( &trace2, top, pm->mins, pm->maxs, bottom, ps->clientNum, MASK_PLAYERSOLID ); if ( !trace2.allsolid && !trace2.startsolid && trace2.fraction < 1.0f && trace2.plane.normal[2] > 0.7f )//slope we can stand on {//cool, do the alt-flip and land on whetever it is we just scaled up VectorScale( fwd, 100, pm->ps->velocity ); pm->ps->velocity[2] += 400; PM_SetAnim(SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_ALT, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0); pm->ps->pm_flags |= PMF_JUMP_HELD; //ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL; //ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION); //G_AddEvent( ent, EV_JUMP, 0 ); PM_AddEvent(EV_JUMP); ucmd->upmove = 0; return qfalse; } } if ( //ucmd->upmove <= 0 && ps->legsTimer > 0 && ucmd->forwardmove > 0 && trace.fraction < 1.0f && (trace.plane.normal[2] >= 0.0f&&trace.plane.normal[2]<=0.4f/*MAX_WALL_RUN_Z_NORMAL*/) ) {//still a vertical wall there //make sure there's not a ceiling above us! trace_t trace2; VectorCopy( ps->origin, traceTo ); traceTo[2] += 64; pm->trace( &trace2, ps->origin, mins, maxs, traceTo, ps->clientNum, MASK_PLAYERSOLID ); if ( trace2.fraction < 1.0f ) {//will hit a ceiling, so force jump-off right now //NOTE: hits any entity or clip brush in the way, too, not just architecture! } else {//all clear, keep going //FIXME: don't pull around 90 turns //FIXME: simulate stepping up steps here, somehow? ucmd->forwardmove = 127; if ( ucmd->upmove < 0 ) { ucmd->upmove = 0; } //make me face the wall ps->viewangles[YAW] = vectoyaw( trace.plane.normal )+180; PM_SetPMViewAngle(ps, ps->viewangles, ucmd); /* if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD ) {//don't clamp angles when looking through a viewEntity SetClientViewAngle( ent, ent->client->ps.viewangles ); } */ ucmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] ) - ps->delta_angles[YAW]; //if ( ent->s.number || !player_locked ) if (1) //aslkfhsakf { if ( doMove ) { //pull me toward the wall VectorScale( trace.plane.normal, -dist*trace.fraction, ps->velocity ); //push me up if ( ps->legsTimer > 200 ) {//not at end of anim yet float speed = 300; /* if ( ucmd->forwardmove < 0 ) {//slower speed = 100; } else if ( ucmd->forwardmove > 0 ) { speed = 250;//running speed } */ ps->velocity[2] = speed;//preserve z velocity } } } ucmd->forwardmove = 0; return qtrue; } } //failed! if ( doMove ) {//stop it VectorScale( fwd, -300.0f, ps->velocity ); ps->velocity[2] += 200; //NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD ); //why?!?#?#@!%$R@$KR#F:Hdl;asfm PM_SetAnim(SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0); ps->pm_flags |= PMF_JUMP_HELD; //ent->client->ps.pm_flags |= PMF_JUMPING|PMF_SLOW_MO_FALL; //FIXME do I need this in mp? //ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION); PM_AddEvent(EV_JUMP); ucmd->upmove = 0; //return qtrue; } } return qfalse; }

qboolean PM_AdjustAnglesForWallRunUpFlipAlt (  usercmd_t *  ucmd  )

Definition at line 1464 of file bg_pmove.c. References pm, PM_SetPMViewAngle(), pmove_t::ps, qboolean, qtrue, ucmd, usercmd_t, and playerState_s::viewangles. Referenced by PmoveSingle(). { // ucmd->angles[PITCH] = ANGLE2SHORT( pm->ps->viewangles[PITCH] ) - pm->ps->delta_angles[PITCH]; // ucmd->angles[YAW] = ANGLE2SHORT( pm->ps->viewangles[YAW] ) - pm->ps->delta_angles[YAW]; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, ucmd); return qtrue; }

void PM_AdjustAttackStates (  pmove_t *  pm  )

Definition at line 8032 of file bg_pmove.c. References playerState_s::ammo, bgEntity_t, BUTTON_ALT_ATTACK, BUTTON_ATTACK, usercmd_s::buttons, CLASS_VEHICLE, pmove_t::cmd, playerState_s::commandTime, EF_ALT_FIRING, EF_FIRING, playerState_s::eFlags, EV_DISRUPTOR_ZOOMSOUND, playerState_s::m_iVehicleNum, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, entityState_s::NPC_class, pm, PM_AddEvent(), PM_DEAD, pm_entSelf, pm_entVeh, playerState_s::pm_flags, PM_INTERMISSION, playerState_s::pm_type, PMF_RESPAWNED, pmove_t::ps, qfalse, qtrue, bgEntity_s::s, usercmd_s::serverTime, vehicleInfo_t::type, VH_FIGHTER, VH_WALKER, playerState_s::weapon, WEAPON_READY, weaponData, playerState_s::weaponstate, playerState_s::weaponTime, WP_DISRUPTOR, WP_SABER, playerState_s::zoomFov, playerState_s::zoomLocked, playerState_s::zoomLockTime, playerState_s::zoomMode, and playerState_s::zoomTime. Referenced by PmoveSingle(). { int amount; if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE &&pm->ps->m_iVehicleNum) { //riding a vehicle bgEntity_t *veh = pm_entVeh; if ( veh && (veh->m_pVehicle && (veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle && veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER)) ) {//riding a walker/fighter //not firing, ever pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING); return; } } // get ammo usage if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) { amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].altEnergyPerShot; } else { amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].energyPerShot; } // disruptor alt-fire should toggle the zoom mode, but only bother doing this for the player? if ( pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_READY ) { if ( !(pm->ps->eFlags & EF_ALT_FIRING) && (pm->cmd.buttons & BUTTON_ALT_ATTACK) /*&& pm->cmd.upmove <= 0 && !pm->cmd.forwardmove && !pm->cmd.rightmove*/) { // We just pressed the alt-fire key if ( !pm->ps->zoomMode && pm->ps->pm_type != PM_DEAD ) { // not already zooming, so do it now pm->ps->zoomMode = 1; pm->ps->zoomLocked = qfalse; pm->ps->zoomFov = 80.0f;//cg_fov.value; pm->ps->zoomLockTime = pm->cmd.serverTime + 50; PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND); } else if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime) { //check for == 1 so we can't turn binoculars off with disruptor alt fire // already zooming, so must be wanting to turn it off pm->ps->zoomMode = 0; pm->ps->zoomTime = pm->ps->commandTime; pm->ps->zoomLocked = qfalse; PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND); pm->ps->weaponTime = 1000; } } else if ( !(pm->cmd.buttons & BUTTON_ALT_ATTACK ) && pm->ps->zoomLockTime < pm->cmd.serverTime) { // Not pressing zoom any more if ( pm->ps->zoomMode ) { if (pm->ps->zoomMode == 1 && !pm->ps->zoomLocked) { //approximate what level the client should be zoomed at based on how long zoom was held pm->ps->zoomFov = ((pm->cmd.serverTime+50) - pm->ps->zoomLockTime) * 0.035f; if (pm->ps->zoomFov > 50) { pm->ps->zoomFov = 50; } if (pm->ps->zoomFov < 1) { pm->ps->zoomFov = 1; } } // were zooming in, so now lock the zoom pm->ps->zoomLocked = qtrue; } } //This seemed like a good idea, but apparently it confuses people. So disabled for now. /* else if (!(pm->ps->eFlags & EF_ALT_FIRING) && (pm->cmd.buttons & BUTTON_ALT_ATTACK) && (pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove)) { //if you try to zoom while moving, just convert it into a primary attack pm->cmd.buttons &= ~BUTTON_ALT_ATTACK; pm->cmd.buttons |= BUTTON_ATTACK; } */ /* if (pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove) { if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime) { //check for == 1 so we can't turn binoculars off with disruptor alt fire pm->ps->zoomMode = 0; pm->ps->zoomTime = pm->ps->commandTime; pm->ps->zoomLocked = qfalse; PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND); } } */ if ( pm->cmd.buttons & BUTTON_ATTACK ) { // If we are zoomed, we should switch the ammo usage to the alt-fire, otherwise, we'll // just use whatever ammo was selected from above if ( pm->ps->zoomMode ) { amount = pm->ps->ammo[weaponData[ pm->ps->weapon ].ammoIndex] - weaponData[pm->ps->weapon].altEnergyPerShot; } } else { // alt-fire button pressing doesn't use any ammo amount = 0; } } /* else if (pm->ps->weapon == WP_DISRUPTOR) //still perform certain checks, even if the weapon is not ready { if (pm->cmd.upmove > 0 || pm->cmd.forwardmove || pm->cmd.rightmove) { if (pm->ps->zoomMode == 1 && pm->ps->zoomLockTime < pm->cmd.serverTime) { //check for == 1 so we can't turn binoculars off with disruptor alt fire pm->ps->zoomMode = 0; pm->ps->zoomTime = pm->ps->commandTime; pm->ps->zoomLocked = qfalse; PM_AddEvent(EV_DISRUPTOR_ZOOMSOUND); } } } */ // set the firing flag for continuous beam weapons, saber will fire even if out of ammo if ( !(pm->ps->pm_flags & PMF_RESPAWNED) && pm->ps->pm_type != PM_INTERMISSION && ( pm->cmd.buttons & (BUTTON_ATTACK|BUTTON_ALT_ATTACK)) && ( amount >= 0 || pm->ps->weapon == WP_SABER )) { if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) { pm->ps->eFlags |= EF_ALT_FIRING; } else { pm->ps->eFlags &= ~EF_ALT_FIRING; } // This flag should always get set, even when alt-firing pm->ps->eFlags |= EF_FIRING; } else { // Clear 'em out pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING); } // disruptor should convert a main fire to an alt-fire if the gun is currently zoomed if ( pm->ps->weapon == WP_DISRUPTOR) { if ( pm->cmd.buttons & BUTTON_ATTACK && pm->ps->zoomMode == 1 && pm->ps->zoomLocked) { // converting the main fire to an alt-fire pm->cmd.buttons |= BUTTON_ALT_ATTACK; pm->ps->eFlags |= EF_ALT_FIRING; } else if ( pm->cmd.buttons & BUTTON_ALT_ATTACK && pm->ps->zoomMode == 1 && pm->ps->zoomLocked) { pm->cmd.buttons &= ~BUTTON_ALT_ATTACK; pm->ps->eFlags &= ~EF_ALT_FIRING; } } }

qboolean PM_AdjustStandAnimForSlope (  void   )

Definition at line 4805 of file bg_pmove.c. References BOTH_CROUCH1, BOTH_CROUCH1IDLE, BOTH_SABERFAST_STANCE, BOTH_SABERSLOW_STANCE, BOTH_STAND1, BOTH_STAND2, BOTH_STAND3, BOTH_STAND4, BOTH_STAND5, BOTH_STAND6, pmove_t::cmd, pmove_t::g2Bolts_LFoot, pmove_t::g2Bolts_RFoot, pmove_t::ghoul2, LEGS_LEFTUP1, LEGS_LEFTUP2, LEGS_LEFTUP3, LEGS_LEFTUP4, LEGS_LEFTUP5, LEGS_RIGHTUP1, LEGS_RIGHTUP2, LEGS_RIGHTUP3, LEGS_RIGHTUP4, LEGS_RIGHTUP5, LEGS_S1_LUP1, LEGS_S1_LUP2, LEGS_S1_LUP3, LEGS_S1_LUP4, LEGS_S1_LUP5, LEGS_S1_RUP1, LEGS_S1_RUP2, LEGS_S1_RUP3, LEGS_S1_RUP4, LEGS_S1_RUP5, LEGS_S3_LUP1, LEGS_S3_LUP2, LEGS_S3_LUP3, LEGS_S3_LUP4, LEGS_S3_LUP5, LEGS_S3_RUP1, LEGS_S3_RUP2, LEGS_S3_RUP3, LEGS_S3_RUP4, LEGS_S3_RUP5, LEGS_S4_LUP1, LEGS_S4_LUP2, LEGS_S4_LUP3, LEGS_S4_LUP4, LEGS_S4_LUP5, LEGS_S4_RUP1, LEGS_S4_RUP2, LEGS_S4_RUP3, LEGS_S4_RUP4, LEGS_S4_RUP5, LEGS_S5_LUP1, LEGS_S5_LUP2, LEGS_S5_LUP3, LEGS_S5_LUP4, LEGS_S5_LUP5, LEGS_S5_RUP1, LEGS_S5_RUP2, LEGS_S5_RUP3, LEGS_S5_RUP4, LEGS_S5_RUP5, playerState_s::legsAnim, pm, PM_ContinueLegsAnim(), PM_FootSlopeTrace(), pmove_t::ps, qboolean, qfalse, qtrue, usercmd_s::serverTime, SLOPE_RECALC_INT, SLOPERECALCVAR, TORSO_WEAPONREADY1, TORSO_WEAPONREADY10, TORSO_WEAPONREADY2, and TORSO_WEAPONREADY3. { float diff; float interval; int destAnim; int legsAnim; #define SLOPERECALCVAR pm->ps->slopeRecalcTime //this is purely convenience if (!pm->ghoul2) { //probably just changed models and not quite in sync yet return qfalse; } if ( pm->g2Bolts_LFoot == -1 || pm->g2Bolts_RFoot == -1 ) {//need these bolts! return qfalse; } //step 1: find the 2 foot tags PM_FootSlopeTrace( &diff, &interval ); //step 4: based on difference, choose one of the left/right slope-match intervals if ( diff >= interval*5 ) { destAnim = LEGS_LEFTUP5; } else if ( diff >= interval*4 ) { destAnim = LEGS_LEFTUP4; } else if ( diff >= interval*3 ) { destAnim = LEGS_LEFTUP3; } else if ( diff >= interval*2 ) { destAnim = LEGS_LEFTUP2; } else if ( diff >= interval ) { destAnim = LEGS_LEFTUP1; } else if ( diff <= interval*-5 ) { destAnim = LEGS_RIGHTUP5; } else if ( diff <= interval*-4 ) { destAnim = LEGS_RIGHTUP4; } else if ( diff <= interval*-3 ) { destAnim = LEGS_RIGHTUP3; } else if ( diff <= interval*-2 ) { destAnim = LEGS_RIGHTUP2; } else if ( diff <= interval*-1 ) { destAnim = LEGS_RIGHTUP1; } else { return qfalse; } legsAnim = pm->ps->legsAnim; //adjust for current legs anim switch ( legsAnim ) { case BOTH_STAND1: case LEGS_S1_LUP1: case LEGS_S1_LUP2: case LEGS_S1_LUP3: case LEGS_S1_LUP4: case LEGS_S1_LUP5: case LEGS_S1_RUP1: case LEGS_S1_RUP2: case LEGS_S1_RUP3: case LEGS_S1_RUP4: case LEGS_S1_RUP5: destAnim = LEGS_S1_LUP1 + (destAnim-LEGS_LEFTUP1); break; case BOTH_STAND2: case BOTH_SABERFAST_STANCE: case BOTH_SABERSLOW_STANCE: case BOTH_CROUCH1IDLE: case BOTH_CROUCH1: case LEGS_LEFTUP1: //# On a slope with left foot 4 higher than right case LEGS_LEFTUP2: //# On a slope with left foot 8 higher than right case LEGS_LEFTUP3: //# On a slope with left foot 12 higher than right case LEGS_LEFTUP4: //# On a slope with left foot 16 higher than right case LEGS_LEFTUP5: //# On a slope with left foot 20 higher than right case LEGS_RIGHTUP1: //# On a slope with RIGHT foot 4 higher than left case LEGS_RIGHTUP2: //# On a slope with RIGHT foot 8 higher than left case LEGS_RIGHTUP3: //# On a slope with RIGHT foot 12 higher than left case LEGS_RIGHTUP4: //# On a slope with RIGHT foot 16 higher than left case LEGS_RIGHTUP5: //# On a slope with RIGHT foot 20 higher than left //fine break; case BOTH_STAND3: case LEGS_S3_LUP1: case LEGS_S3_LUP2: case LEGS_S3_LUP3: case LEGS_S3_LUP4: case LEGS_S3_LUP5: case LEGS_S3_RUP1: case LEGS_S3_RUP2: case LEGS_S3_RUP3: case LEGS_S3_RUP4: case LEGS_S3_RUP5: destAnim = LEGS_S3_LUP1 + (destAnim-LEGS_LEFTUP1); break; case BOTH_STAND4: case LEGS_S4_LUP1: case LEGS_S4_LUP2: case LEGS_S4_LUP3: case LEGS_S4_LUP4: case LEGS_S4_LUP5: case LEGS_S4_RUP1: case LEGS_S4_RUP2: case LEGS_S4_RUP3: case LEGS_S4_RUP4: case LEGS_S4_RUP5: destAnim = LEGS_S4_LUP1 + (destAnim-LEGS_LEFTUP1); break; case BOTH_STAND5: case LEGS_S5_LUP1: case LEGS_S5_LUP2: case LEGS_S5_LUP3: case LEGS_S5_LUP4: case LEGS_S5_LUP5: case LEGS_S5_RUP1: case LEGS_S5_RUP2: case LEGS_S5_RUP3: case LEGS_S5_RUP4: case LEGS_S5_RUP5: destAnim = LEGS_S5_LUP1 + (destAnim-LEGS_LEFTUP1); break; case BOTH_STAND6: default: return qfalse; break; } //step 5: based on the chosen interval and the current legsAnim, pick the correct anim //step 6: increment/decrement to the dest anim, not instant if ( (legsAnim >= LEGS_LEFTUP1 && legsAnim <= LEGS_LEFTUP5) || (legsAnim >= LEGS_S1_LUP1 && legsAnim <= LEGS_S1_LUP5) || (legsAnim >= LEGS_S3_LUP1 && legsAnim <= LEGS_S3_LUP5) || (legsAnim >= LEGS_S4_LUP1 && legsAnim <= LEGS_S4_LUP5) || (legsAnim >= LEGS_S5_LUP1 && legsAnim <= LEGS_S5_LUP5) ) {//already in left-side up if ( destAnim > legsAnim && SLOPERECALCVAR < pm->cmd.serverTime ) { legsAnim++; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim < legsAnim && SLOPERECALCVAR < pm->cmd.serverTime ) { legsAnim--; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else //if (SLOPERECALCVAR < pm->cmd.serverTime) { legsAnim = destAnim; } destAnim = legsAnim; } else if ( (legsAnim >= LEGS_RIGHTUP1 && legsAnim <= LEGS_RIGHTUP5) || (legsAnim >= LEGS_S1_RUP1 && legsAnim <= LEGS_S1_RUP5) || (legsAnim >= LEGS_S3_RUP1 && legsAnim <= LEGS_S3_RUP5) || (legsAnim >= LEGS_S4_RUP1 && legsAnim <= LEGS_S4_RUP5) || (legsAnim >= LEGS_S5_RUP1 && legsAnim <= LEGS_S5_RUP5) ) {//already in right-side up if ( destAnim > legsAnim && SLOPERECALCVAR < pm->cmd.serverTime ) { legsAnim++; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim < legsAnim && SLOPERECALCVAR < pm->cmd.serverTime ) { legsAnim--; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else //if (SLOPERECALCVAR < pm->cmd.serverTime) { legsAnim = destAnim; } destAnim = legsAnim; } else {//in a stand of some sort? switch ( legsAnim ) { case BOTH_STAND1: case TORSO_WEAPONREADY1: case TORSO_WEAPONREADY2: case TORSO_WEAPONREADY3: case TORSO_WEAPONREADY10: if ( destAnim >= LEGS_S1_LUP1 && destAnim <= LEGS_S1_LUP5 ) {//going into left side up destAnim = LEGS_S1_LUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim >= LEGS_S1_RUP1 && destAnim <= LEGS_S1_RUP5 ) {//going into right side up destAnim = LEGS_S1_RUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else {//will never get here return qfalse; } break; case BOTH_STAND2: case BOTH_SABERFAST_STANCE: case BOTH_SABERSLOW_STANCE: case BOTH_CROUCH1IDLE: if ( destAnim >= LEGS_LEFTUP1 && destAnim <= LEGS_LEFTUP5 ) {//going into left side up destAnim = LEGS_LEFTUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim >= LEGS_RIGHTUP1 && destAnim <= LEGS_RIGHTUP5 ) {//going into right side up destAnim = LEGS_RIGHTUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else {//will never get here return qfalse; } break; case BOTH_STAND3: if ( destAnim >= LEGS_S3_LUP1 && destAnim <= LEGS_S3_LUP5 ) {//going into left side up destAnim = LEGS_S3_LUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim >= LEGS_S3_RUP1 && destAnim <= LEGS_S3_RUP5 ) {//going into right side up destAnim = LEGS_S3_RUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else {//will never get here return qfalse; } break; case BOTH_STAND4: if ( destAnim >= LEGS_S4_LUP1 && destAnim <= LEGS_S4_LUP5 ) {//going into left side up destAnim = LEGS_S4_LUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim >= LEGS_S4_RUP1 && destAnim <= LEGS_S4_RUP5 ) {//going into right side up destAnim = LEGS_S4_RUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else {//will never get here return qfalse; } break; case BOTH_STAND5: if ( destAnim >= LEGS_S5_LUP1 && destAnim <= LEGS_S5_LUP5 ) {//going into left side up destAnim = LEGS_S5_LUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else if ( destAnim >= LEGS_S5_RUP1 && destAnim <= LEGS_S5_RUP5 ) {//going into right side up destAnim = LEGS_S5_RUP1; SLOPERECALCVAR = pm->cmd.serverTime + SLOPE_RECALC_INT; } else {//will never get here return qfalse; } break; case BOTH_STAND6: default: return qfalse; break; } } //step 7: set the anim //PM_SetAnim( SETANIM_LEGS, destAnim, SETANIM_FLAG_NORMAL, 100 ); PM_ContinueLegsAnim(destAnim); return qtrue; }

void PM_AnglesForSlope (  const float  yaw, const vec3_t  slope, vec3_t  angles )

Definition at line 4650 of file bg_pmove.c. References AngleVectors(), DotProduct, NULL, PITCH, Q_fabs(), ROLL, vec3_t, vectoangles(), VectorSet, and YAW. { vec3_t nvf, ovf, ovr, new_angles; float pitch, mod, dot; VectorSet( angles, 0, yaw, 0 ); AngleVectors( angles, ovf, ovr, NULL ); vectoangles( slope, new_angles ); pitch = new_angles[PITCH] + 90; new_angles[ROLL] = new_angles[PITCH] = 0; AngleVectors( new_angles, nvf, NULL, NULL ); mod = DotProduct( nvf, ovr ); if ( mod < 0 ) mod = -1; else mod = 1; dot = DotProduct( nvf, ovf ); angles[YAW] = 0; angles[PITCH] = dot * pitch; angles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); }

void PM_BeginWeaponChange (  int  weapon  )

Definition at line 5767 of file bg_pmove.c. References BG_ClearRocketLock(), playerState_s::commandTime, EV_CHANGE_WEAPON, pm, PM_AddEventWithParm(), PM_SetAnim(), pmove_t::ps, SETANIM_FLAG_OVERRIDE, SETANIM_TORSO, STAT_WEAPONS, playerState_s::stats, TORSO_DROPWEAP1, WEAPON_DROPPING, playerState_s::weaponstate, playerState_s::weaponTime, WP_NUM_WEAPONS, playerState_s::zoomMode, and playerState_s::zoomTime. Referenced by PM_WeaponLightsaber(). { if ( weapon <= WP_NONE || weapon >= WP_NUM_WEAPONS ) { return; } if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) { return; } if ( pm->ps->weaponstate == WEAPON_DROPPING ) { return; } // turn of any kind of zooming when weapon switching. if (pm->ps->zoomMode) { pm->ps->zoomMode = 0; pm->ps->zoomTime = pm->ps->commandTime; } PM_AddEventWithParm( EV_CHANGE_WEAPON, weapon ); pm->ps->weaponstate = WEAPON_DROPPING; pm->ps->weaponTime += 200; //PM_StartTorsoAnim( TORSO_DROPWEAP1 ); PM_SetAnim(SETANIM_TORSO, TORSO_DROPWEAP1, SETANIM_FLAG_OVERRIDE, 0); BG_ClearRocketLock( pm->ps ); }

bgEntity_t* PM_BGEntForNum (  int  num  )

Definition at line 172 of file bg_pmove.c. References pmove_t::baseEnt, bgEntity_t, byte, pmove_t::entSize, MAX_GENTITIES, NULL, and pm. Referenced by PM_CanBackstab(), PM_CheckStabDown(), PM_RocketLock(), PM_SaberLocked(), PM_SomeoneInFront(), PM_VehForcedTurning(), PM_VehicleImpact(), PM_WeaponLightsaber(), and PmoveSingle(). { bgEntity_t *ent; if (!pm) { assert(!"You cannot call PM_BGEntForNum outside of pm functions!"); return NULL; } if (!pm->baseEnt) { assert(!"Base entity address not set"); return NULL; } if (!pm->entSize) { assert(!"sizeof(ent) is 0, impossible (not set?)"); return NULL; } assert(num >= 0 && num < MAX_GENTITIES); ent = (bgEntity_t *)((byte *)pm->baseEnt + pm->entSize*(num)); return ent; }

qboolean PM_CanRollFromSoulCal (  playerState_t *  ps  )

Definition at line 1419 of file bg_panimate.c. References BOTH_A7_SOULCAL, playerState_s::legsAnim, playerState_s::legsTimer, playerState_t, qboolean, qfalse, and qtrue. Referenced by PM_MoveForKata(). { if ( ps->legsAnim == BOTH_A7_SOULCAL && ps->legsTimer < 700 && ps->legsTimer > 250 ) { return qtrue; } return qfalse; }

qboolean PM_CanSetWeaponAnims (  void   )

Definition at line 6370 of file bg_pmove.c. References playerState_s::m_iVehicleNum, pm, pmove_t::ps, qboolean, qfalse, and qtrue. { if (pm->ps->m_iVehicleNum) { return qfalse; } return qtrue; }

qboolean PM_CheckDualForwardJumpDuck (  void   )

Definition at line 4323 of file bg_pmove.c. References BOTH_JUMPATTACK6, playerState_s::legsAnim, playerState_s::legsTimer, pmove_t::mins, pm, PM_AnimLength(), playerState_s::pm_flags, PMF_FIX_MINS, pmove_t::ps, qboolean, qfalse, and qtrue. { qboolean resized = qfalse; if ( pm->ps->legsAnim == BOTH_JUMPATTACK6 ) { //dynamically reduce bounding box to let character sail over heads of enemies if ( ( pm->ps->legsTimer >= 1450 && PM_AnimLength( 0, BOTH_JUMPATTACK6 ) - pm->ps->legsTimer >= 400 ) ||(pm->ps->legsTimer >= 400 && PM_AnimLength( 0, BOTH_JUMPATTACK6 ) - pm->ps->legsTimer >= 1100 ) ) {//in a part of the anim that we're pretty much sideways in, raise up the mins pm->mins[2] = 0; pm->ps->pm_flags |= PMF_FIX_MINS; resized = qtrue; } } return resized; }

void PM_CheckFixMins (  void   )

Definition at line 4342 of file bg_pmove.c. References trace_t::allsolid, BOTH_JUMPATTACK6, playerState_s::clientNum, trace_t::fraction, playerState_s::legsAnim, playerState_s::legsTimer, pmove_t::maxs, pmove_t::mins, MINS_Z, playerState_s::origin, pm, playerState_s::pm_flags, PMF_DUCKED, PMF_FIX_MINS, pmove_t::ps, playerState_s::standheight, trace_t::startsolid, playerState_s::torsoTimer, pmove_t::trace, pmove_t::tracemask, vec3_t, and VectorSet. { if ( (pm->ps->pm_flags&PMF_FIX_MINS) )// pm->mins[2] > DEFAULT_MINS_2 ) {//drop the mins back down //do a trace to make sure it's okay trace_t trace; vec3_t end, curMins, curMaxs; VectorSet( end, pm->ps->origin[0], pm->ps->origin[1], pm->ps->origin[2]+MINS_Z ); VectorSet( curMins, pm->mins[0], pm->mins[1], 0 ); VectorSet( curMaxs, pm->maxs[0], pm->maxs[1], pm->ps->standheight ); pm->trace( &trace, pm->ps->origin, curMins, curMaxs, end, pm->ps->clientNum, pm->tracemask ); if ( !trace.allsolid && !trace.startsolid ) {//should never start in solid if ( trace.fraction >= 1.0f ) {//all clear //drop the bottom of my bbox back down pm->mins[2] = MINS_Z; pm->ps->pm_flags &= ~PMF_FIX_MINS; } else {//move me up so the bottom of my bbox will be where the trace ended, at least //need to trace up, too float updist = ((1.0f-trace.fraction) * -MINS_Z); end[2] = pm->ps->origin[2]+updist; pm->trace( &trace, pm->ps->origin, curMins, curMaxs, end, pm->ps->clientNum, pm->tracemask ); if ( !trace.allsolid && !trace.startsolid ) {//should never start in solid if ( trace.fraction >= 1.0f ) {//all clear //move me up pm->ps->origin[2] += updist; //drop the bottom of my bbox back down pm->mins[2] = MINS_Z; pm->ps->pm_flags &= ~PMF_FIX_MINS; } else {//crap, no room to expand, so just crouch us if ( pm->ps->legsAnim != BOTH_JUMPATTACK6 || pm->ps->legsTimer <= 200 ) {//at the end of the anim, and we can't leave ourselves like this //so drop the maxs, put the mins back and move us up pm->maxs[2] += MINS_Z; pm->ps->origin[2] -= MINS_Z; pm->mins[2] = MINS_Z; //this way we'll be in a crouch when we're done if ( pm->ps->legsAnim == BOTH_JUMPATTACK6 ) { pm->ps->legsTimer = pm->ps->torsoTimer = 0; } pm->ps->pm_flags |= PMF_DUCKED; //FIXME: do we need to set a crouch anim here? pm->ps->pm_flags &= ~PMF_FIX_MINS; } } }//crap, stuck } }//crap, stuck! } }

void PM_ClipVelocity (  vec3_t  in, vec3_t  normal, vec3_t  out, float  overbounce )

Definition at line 954 of file bg_pmove.c. References playerState_s::clientNum, DotProduct, ENTITYNUM_NONE, playerState_s::groundEntityNum, MAX_CLIENTS, MIN_WALK_NORMAL, pm, playerState_s::pm_flags, PMF_STUCK_TO_WALL, pmove_t::ps, pmove_t::stepSlideFix, vec3_t, and VectorCopy. Referenced by PM_SlideMove(), and PM_StepSlideMove(). { float backoff; float change; float oldInZ; int i; if ( (pm->ps->pm_flags&PMF_STUCK_TO_WALL) ) {//no sliding! VectorCopy( in, out ); return; } oldInZ = in[2]; backoff = DotProduct (in, normal); if ( backoff < 0 ) { backoff *= overbounce; } else { backoff /= overbounce; } for ( i=0 ; i<3 ; i++ ) { change = normal[i]*backoff; out[i] = in[i] - change; } if ( pm->stepSlideFix ) { if ( pm->ps->clientNum < MAX_CLIENTS//normal player && pm->ps->groundEntityNum != ENTITYNUM_NONE//on the ground && normal[2] < MIN_WALK_NORMAL )//sliding against a steep slope {//if walking on the ground, don't slide up slopes that are too steep to walk on out[2] = oldInZ; } } }

qboolean PM_DoSlowFall (  void   )

Definition at line 321 of file bg_pmove.c. References BOTH_WALL_RUN_LEFT, BOTH_WALL_RUN_RIGHT, playerState_s::legsAnim, playerState_s::legsTimer, pm, pmove_t::ps, qboolean, qfalse, and qtrue. Referenced by PmoveSingle(). { if ( ( (pm->ps->legsAnim) == BOTH_WALL_RUN_RIGHT || (pm->ps->legsAnim) == BOTH_WALL_RUN_LEFT ) && pm->ps->legsTimer > 500 ) { return qtrue; } return qfalse; }

void PM_FinishWeaponChange (  void   )

Definition at line 5802 of file bg_pmove.c. References pmove_t::cmd, LS_DRAW, pm, PM_SetAnim(), PM_SetSaberMove(), pmove_t::ps, SETANIM_FLAG_OVERRIDE, SETANIM_TORSO, STAT_WEAPONS, playerState_s::stats, TORSO_RAISEWEAP1, playerState_s::weapon, usercmd_s::weapon, WEAPON_RAISING, playerState_s::weaponstate, playerState_s::weaponTime, WP_NONE, WP_NUM_WEAPONS, and WP_SABER. Referenced by PM_WeaponLightsaber(). { int weapon; weapon = pm->cmd.weapon; if ( weapon < WP_NONE || weapon >= WP_NUM_WEAPONS ) { weapon = WP_NONE; } if ( !( pm->ps->stats[STAT_WEAPONS] & ( 1 << weapon ) ) ) { weapon = WP_NONE; } if (weapon == WP_SABER) { PM_SetSaberMove(LS_DRAW); } else { //PM_StartTorsoAnim( TORSO_RAISEWEAP1); PM_SetAnim(SETANIM_TORSO, TORSO_RAISEWEAP1, SETANIM_FLAG_OVERRIDE, 0); } pm->ps->weapon = weapon; pm->ps->weaponstate = WEAPON_RAISING; pm->ps->weaponTime += 250; }

void PM_FootSlopeTrace (  float *  pDiff, float *  pInterval )

Definition at line 4678 of file bg_pmove.c. References playerState_s::clientNum, pmove_t::cmd, trace_t::endpos, pmove_t::g2Bolts_LFoot, pmove_t::g2Bolts_RFoot, pmove_t::ghoul2, mdxaBone_t::matrix, pmove_t::mins, pmove_t::modelScale, cplane_s::normal, NULL, playerState_s::origin, trace_t::plane, pm, pmove_t::ps, usercmd_s::serverTime, strap_G2API_GetBoltMatrix(), pmove_t::trace, pmove_t::tracemask, vec3_t, VectorCopy, VectorSet, playerState_s::viewangles, and YAW. Referenced by PM_AdjustStandAnimForSlope(). { vec3_t footLOrg, footROrg, footLBot, footRBot; vec3_t footLPoint, footRPoint; vec3_t footMins, footMaxs; vec3_t footLSlope, footRSlope; trace_t trace; float diff, interval; mdxaBone_t boltMatrix; vec3_t G2Angles; VectorSet(G2Angles, 0, pm->ps->viewangles[YAW], 0); interval = 4;//? strap_G2API_GetBoltMatrix( pm->ghoul2, 0, pm->g2Bolts_LFoot, &boltMatrix, G2Angles, pm->ps->origin, pm->cmd.serverTime, NULL, pm->modelScale ); footLPoint[0] = boltMatrix.matrix[0][3]; footLPoint[1] = boltMatrix.matrix[1][3]; footLPoint[2] = boltMatrix.matrix[2][3]; strap_G2API_GetBoltMatrix( pm->ghoul2, 0, pm->g2Bolts_RFoot, &boltMatrix, G2Angles, pm->ps->origin, pm->cmd.serverTime, NULL, pm->modelScale ); footRPoint[0] = boltMatrix.matrix[0][3]; footRPoint[1] = boltMatrix.matrix[1][3]; footRPoint[2] = boltMatrix.matrix[2][3]; //get these on the cgame and store it, save ourselves a ghoul2 construct skel call VectorCopy( footLPoint, footLOrg ); VectorCopy( footRPoint, footROrg ); //step 2: adjust foot tag z height to bottom of bbox+1 footLOrg[2] = pm->ps->origin[2] + pm->mins[2] + 1; footROrg[2] = pm->ps->origin[2] + pm->mins[2] + 1; VectorSet( footLBot, footLOrg[0], footLOrg[1], footLOrg[2] - interval*10 ); VectorSet( footRBot, footROrg[0], footROrg[1], footROrg[2] - interval*10 ); //step 3: trace down from each, find difference VectorSet( footMins, -3, -3, 0 ); VectorSet( footMaxs, 3, 3, 1 ); pm->trace( &trace, footLOrg, footMins, footMaxs, footLBot, pm->ps->clientNum, pm->tracemask ); VectorCopy( trace.endpos, footLBot ); VectorCopy( trace.plane.normal, footLSlope ); pm->trace( &trace, footROrg, footMins, footMaxs, footRBot, pm->ps->clientNum, pm->tracemask ); VectorCopy( trace.endpos, footRBot ); VectorCopy( trace.plane.normal, footRSlope ); diff = footLBot[2] - footRBot[2]; if ( pDiff != NULL ) { *pDiff = diff; } if ( pInterval != NULL ) { *pInterval = interval; } }

qboolean PM_ForceJumpingUp (  void   )

Definition at line 1266 of file bg_pmove.c. References BG_CanUseFPNow(), BG_HasYsalamiri(), BG_InSpecialJump(), BG_SaberInSpecial(), BG_SaberInSpecialAttack(), pmove_t::cmd, ENTITYNUM_NONE, playerState_s::fd, FORCE_LEVEL_0, forcedata_s::forceJumpCharge, forcedata_s::forcePowerLevel, forcedata_s::forcePowersActive, FP_LEVITATION, pmove_t::gametype, playerState_s::groundEntityNum, playerState_s::legsAnim, pm, playerState_s::pm_flags, PMF_JUMP_HELD, pmove_t::ps, qboolean, qfalse, qtrue, playerState_s::saberMove, usercmd_s::serverTime, and playerState_s::velocity. { if ( !(pm->ps->fd.forcePowersActive&(1<<FP_LEVITATION)) && pm->ps->fd.forceJumpCharge ) {//already jumped and let go return qfalse; } if ( BG_InSpecialJump( pm->ps->legsAnim ) ) { return qfalse; } if (BG_SaberInSpecial(pm->ps->saberMove)) { return qfalse; } if (BG_SaberInSpecialAttack(pm->ps->legsAnim)) { return qfalse; } if (BG_HasYsalamiri(pm->gametype, pm->ps)) { return qfalse; } if (!BG_CanUseFPNow(pm->gametype, pm->ps, pm->cmd.serverTime, FP_LEVITATION)) { return qfalse; } if ( pm->ps->groundEntityNum == ENTITYNUM_NONE && //in air (pm->ps->pm_flags & PMF_JUMP_HELD) && //jumped pm->ps->fd.forcePowerLevel[FP_LEVITATION] > FORCE_LEVEL_0 && //force-jump capable pm->ps->velocity[2] > 0 )//going up { return qtrue; } return qfalse; }

int PM_GetOkWeaponForVehicle (  void   )

Definition at line 9759 of file bg_pmove.c. References pm, PM_WeaponOkOnVehicle(), pmove_t::ps, STAT_WEAPONS, playerState_s::stats, and WP_NUM_WEAPONS. Referenced by PmoveSingle(). { int i = 0; while (i < WP_NUM_WEAPONS) { if ((pm->ps->stats[STAT_WEAPONS] & (1 << i)) && PM_WeaponOkOnVehicle(i)) { //this one's good return i; } i++; } //oh dear! //assert(!"No valid veh weaps"); return -1; }

int PM_GetSaberStance (  void   )

Definition at line 261 of file bg_pmove.c. References BG_MySaber(), BG_SabersOff(), BOTH_SABERDUAL_STANCE, BOTH_SABERFAST_STANCE, BOTH_SABERSLOW_STANCE, BOTH_SABERSTAFF_STANCE, BOTH_STAND1, BOTH_STAND2, playerState_s::clientNum, playerState_s::fd, pm, pmove_t::ps, saberInfo_t::readyAnim, forcedata_s::saberAnimLevel, playerState_s::saberEntityNum, playerState_s::saberHolstered, SS_DESANN, SS_DUAL, SS_FAST, SS_MEDIUM, SS_NONE, SS_STAFF, SS_STRONG, and SS_TAVION. Referenced by PM_SetSaberMove(), and PM_WeaponLightsaber(). { int anim = BOTH_STAND2; saberInfo_t *saber1 = BG_MySaber( pm->ps->clientNum, 0 ); saberInfo_t *saber2 = BG_MySaber( pm->ps->clientNum, 1 ); if (!pm->ps->saberEntityNum) { //lost it return BOTH_STAND1; } if ( BG_SabersOff( pm->ps ) ) { return BOTH_STAND1; } if ( saber1 && saber1->readyAnim != -1 ) { return saber1->readyAnim; } if ( saber2 && saber2->readyAnim != -1 ) { return saber2->readyAnim; } if ( saber1 && saber2 && !pm->ps->saberHolstered ) {//dual sabers, both on return BOTH_SABERDUAL_STANCE; } switch ( pm->ps->fd.saberAnimLevel ) { case SS_DUAL: anim = BOTH_SABERDUAL_STANCE; break; case SS_STAFF: anim = BOTH_SABERSTAFF_STANCE; break; case SS_FAST: case SS_TAVION: anim = BOTH_SABERFAST_STANCE; break; case SS_STRONG: anim = BOTH_SABERSLOW_STANCE; break; case SS_NONE: case SS_MEDIUM: case SS_DESANN: default: anim = BOTH_STAND2; break; } return anim; }

void PM_GrabWallForJump (  int  anim  )

Definition at line 1776 of file bg_pmove.c. References EV_JUMP, pm, PM_AddEvent(), playerState_s::pm_flags, PM_SetAnim(), PMF_STUCK_TO_WALL, pmove_t::ps, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, and SETANIM_FLAG_RESTART. {//NOTE!!! assumes an appropriate anim is being passed in!!! PM_SetAnim( SETANIM_BOTH, anim, SETANIM_FLAG_RESTART|SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 ); PM_AddEvent( EV_JUMP );//make sound for grab pm->ps->pm_flags |= PMF_STUCK_TO_WALL; }

qboolean PM_GroundSlideOkay (  float  zNormal  )

Definition at line 554 of file bg_slidemove.c. References BG_InReboundJump(), BOTH_FORCELONGLEAP_ATTACK, BOTH_FORCELONGLEAP_LAND, BOTH_FORCELONGLEAP_START, BOTH_FORCEWALLRUNFLIP_START, BOTH_WALL_RUN_LEFT, BOTH_WALL_RUN_LEFT_STOP, BOTH_WALL_RUN_RIGHT, BOTH_WALL_RUN_RIGHT_STOP, playerState_s::legsAnim, pm, pmove_t::ps, qboolean, qfalse, qtrue, and playerState_s::velocity. Referenced by PM_SlideMove(). { if ( zNormal > 0 ) { if ( pm->ps->velocity[2] > 0 ) { if ( pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT || pm->ps->legsAnim == BOTH_WALL_RUN_LEFT || pm->ps->legsAnim == BOTH_WALL_RUN_RIGHT_STOP || pm->ps->legsAnim == BOTH_WALL_RUN_LEFT_STOP || pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_START || pm->ps->legsAnim == BOTH_FORCELONGLEAP_START || pm->ps->legsAnim == BOTH_FORCELONGLEAP_ATTACK || pm->ps->legsAnim == BOTH_FORCELONGLEAP_LAND || BG_InReboundJump( pm->ps->legsAnim )) { return qfalse; } } } return qtrue; }

void PM_HoverTrace (  void   )

Definition at line 719 of file bg_pmove.c. References AngleVectors(), bgEntity_t, vehicleInfo_t::bouyancy, CLASS_VEHICLE, playerState_s::clientNum, trace_t::contents, CONTENTS_LAVA, CONTENTS_SLIME, CONTENTS_WATER, trace_t::endpos, EV_PLAY_EFFECT_ID, fabs(), trace_t::fraction, pml_t::frametime, G_AddEvent(), G_PlayEffectID(), gentity_t, pml_t::groundPlane, pml_t::groundTrace, vehicleInfo_t::hoverHeight, vehicleInfo_t::hoverStrength, vehicleInfo_t::iWakeFX, Vehicle_s::m_fTimeModifier, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_ulFlags, Vehicle_s::m_vAngularVelocity, Vehicle_s::m_vOrientation, Vehicle_s::m_vPrevOrientation, pmove_t::maxs, vehicleInfo_t::maxSlope, MIN_WALK_NORMAL, pmove_t::mins, cplane_s::normal, entityState_s::NPC_class, NULL, playerState_s::origin, PITCH, trace_t::plane, pm, pm_entSelf, pml, pmove_t::ps, Q_irand(), qfalse, qtrue, ROLL, bgEntity_s::s, pmove_t::trace, pmove_t::tracemask, vec3_t, VectorCopy, VEH_FLYING, Vehicle_t, playerState_s::velocity, pmove_t::waterlevel, and YAW. Referenced by PmoveSingle(). { Vehicle_t *pVeh; float hoverHeight; vec3_t point, vAng, fxAxis[3]; trace_t *trace; float relativeWaterLevel; bgEntity_t *pEnt = pm_entSelf; if ( !pEnt || pEnt->s.NPC_class != CLASS_VEHICLE ) { return; } pVeh = pEnt->m_pVehicle; hoverHeight = pVeh->m_pVehicleInfo->hoverHeight; trace = &pml.groundTrace; pml.groundPlane = qfalse; //relativeWaterLevel = (pm->ps->waterheight - (pm->ps->origin[2]+pm->mins[2])); relativeWaterLevel = pm->waterlevel; //I.. guess this works if ( pm->waterlevel && relativeWaterLevel >= 0 ) {//in water if ( pVeh->m_pVehicleInfo->bouyancy <= 0.0f ) {//sink like a rock } else {//rise up float floatHeight = (pVeh->m_pVehicleInfo->bouyancy * ((pm->maxs[2]-pm->mins[2])*0.5f)) - (hoverHeight*0.5f);//1.0f should make you float half-in, half-out of water if ( relativeWaterLevel > floatHeight ) {//too low, should rise up pm->ps->velocity[2] += (relativeWaterLevel - floatHeight) * pVeh->m_fTimeModifier; } } //if ( pm->ps->waterheight < pm->ps->origin[2]+pm->maxs[2] ) if (pm->waterlevel <= 1) {//part of us is sticking out of water if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 ) {//moving at a decent speed if ( Q_irand( pml.frametime, 100 ) >= 50 ) {//splash vec3_t wakeOrg; vAng[PITCH] = vAng[ROLL] = 0; vAng[YAW] = pVeh->m_vOrientation[YAW]; AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] ); VectorCopy( pm->ps->origin, wakeOrg ); //wakeOrg[2] = pm->ps->waterheight; if (pm->waterlevel >= 2) { wakeOrg[2] = pm->ps->origin[2]+16; } else { wakeOrg[2] = pm->ps->origin[2]; } #ifdef QAGAME //yeah, this is kind of crappy and makes no use of prediction whatsoever if ( pVeh->m_pVehicleInfo->iWakeFX ) { //G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, wakeOrg, fxAxis[0] ); //tempent use bad! G_AddEvent((gentity_t *)pEnt, EV_PLAY_EFFECT_ID, pVeh->m_pVehicleInfo->iWakeFX); } #endif } } } } else { int traceContents; float minNormal = (float)MIN_WALK_NORMAL; minNormal = pVeh->m_pVehicleInfo->maxSlope; point[0] = pm->ps->origin[0]; point[1] = pm->ps->origin[1]; point[2] = pm->ps->origin[2] - hoverHeight; //FIXME: check for water, too? If over water, go slower and make wave effect // If *in* water, go really slow and use bouyancy stat to determine how far below surface to float //NOTE: if bouyancy is 2.0f or higher, you float over water like it's solid ground. // if it's 1.0f, you sink halfway into water. If it's 0, you sink... traceContents = pm->tracemask; if ( pVeh->m_pVehicleInfo->bouyancy >= 2.0f ) {//sit on water traceContents |= (CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA); } pm->trace( trace, pm->ps->origin, pm->mins, pm->maxs, point, pm->ps->clientNum, traceContents ); if (trace->plane.normal[0] > 0.5f || trace->plane.normal[0] < -0.5f || trace->plane.normal[1] > 0.5f || trace->plane.normal[1] < -0.5f) { //steep slanted hill, don't go up it. float d = fabs(trace->plane.normal[0]); float e = fabs(trace->plane.normal[1]); if (e > d) { d = e; } pm->ps->velocity[2] = -300.0f*d; } else if ( trace->plane.normal[2] >= minNormal ) {//not a steep slope, so push us up if ( trace->fraction < 1.0f ) {//push up off ground float hoverForce = pVeh->m_pVehicleInfo->hoverStrength; if ( trace->fraction > 0.5f ) { pm->ps->velocity[2] += (1.0f-trace->fraction)*hoverForce*pVeh->m_fTimeModifier; } else { pm->ps->velocity[2] += (0.5f-(trace->fraction*trace->fraction))*hoverForce*2.0f*pVeh->m_fTimeModifier; } if ( (trace->contents&(CONTENTS_WATER|CONTENTS_SLIME|CONTENTS_LAVA)) ) {//hovering on water, make a spash if moving if ( fabs(pm->ps->velocity[0]) + fabs(pm->ps->velocity[1]) > 100 ) {//moving at a decent speed if ( Q_irand( pml.frametime, 100 ) >= 50 ) {//splash vAng[PITCH] = vAng[ROLL] = 0; vAng[YAW] = pVeh->m_vOrientation[YAW]; AngleVectors( vAng, fxAxis[2], fxAxis[1], fxAxis[0] ); #ifdef QAGAME if ( pVeh->m_pVehicleInfo->iWakeFX ) { G_PlayEffectID( pVeh->m_pVehicleInfo->iWakeFX, trace->endpos, fxAxis[0] ); } #endif } } } pml.groundPlane = qtrue; } } } if ( pml.groundPlane ) { PM_SetVehicleAngles( pml.groundTrace.plane.normal ); // We're on the ground. pVeh->m_ulFlags &= ~VEH_FLYING; pVeh->m_vAngularVelocity = 0.0f; } else { PM_SetVehicleAngles( NULL ); // We're flying in the air. pVeh->m_ulFlags |= VEH_FLYING; //groundTrace if (pVeh->m_vAngularVelocity==0.0f) { pVeh->m_vAngularVelocity = pVeh->m_vOrientation[YAW] - pVeh->m_vPrevOrientation[YAW]; if (pVeh->m_vAngularVelocity<-15.0f) { pVeh->m_vAngularVelocity = -15.0f; } if (pVeh->m_vAngularVelocity> 15.0f) { pVeh->m_vAngularVelocity = 15.0f; } } //pVeh->m_vAngularVelocity *= 0.95f; // Angular Velocity Decays Over Time if (pVeh->m_vAngularVelocity > 0.0f) { pVeh->m_vAngularVelocity -= pml.frametime; if (pVeh->m_vAngularVelocity < 0.0f) { pVeh->m_vAngularVelocity = 0.0f; } } else if (pVeh->m_vAngularVelocity < 0.0f) { pVeh->m_vAngularVelocity += pml.frametime; if (pVeh->m_vAngularVelocity > 0.0f) { pVeh->m_vAngularVelocity = 0.0f; } } } PM_GroundTraceMissed(); }

int PM_irand_timesync (  int  val1, int  val2 )

Definition at line 10 of file bg_saber.c. References pmove_t::cmd, pm, Q_random(), and usercmd_s::serverTime. Referenced by PM_SaberKataDone(), PM_SaberLockBreak(), PM_SaberLocked(), PM_SetSaberMove(), PM_VehicleWeaponAnimate(), and PM_WeaponLightsaber(). { int i; i = (val1-1) + (Q_random( &pm->cmd.serverTime )*(val2 - val1)) + 1; if (i < val1) { i = val1; } if (i > val2) { i = val2; } return i; }

qboolean PM_INLINE PM_IsRocketTrooper (  void   )

Definition at line 247 of file bg_pmove.c. References PM_INLINE, qboolean, and qfalse. Referenced by PmoveSingle(). { /* if (pm->ps->clientNum < MAX_CLIENTS && pm->gametype == GT_SIEGE && pm->nonHumanoid) { return qtrue; } */ return qfalse; }

int PM_ItemUsable (  playerState_t *  ps, int  forcedUse )

Definition at line 6240 of file bg_pmove.c. References trace_t::allsolid, AngleVectors(), BG_IsItemSelectable(), bg_itemlist, playerState_s::clientNum, playerState_s::duelInProgress, EF_DEAD, EF_SEEKERDRONE, playerState_s::eFlags, trace_t::endpos, trace_t::entityNum, EV_ITEMUSEFAIL, playerState_s::fd, trace_t::fraction, HI_AMMODISP, HI_CLOAK, HI_EWEB, HI_HEALTHDISP, HI_JETPACK, HI_MEDPAC, HI_MEDPAC_BIG, HI_SEEKER, HI_SENTRY_GUN, HI_SHIELD, playerState_s::m_iVehicleNum, MASK_PLAYERSOLID, MASK_SHOT, MASK_SOLID, NULL, playerState_s::origin, PITCH, playerState_t, pm, PM_AddEventWithParm(), playerState_s::pm_flags, PMF_USE_ITEM_HELD, ROLL, SEEKER_ALREADYDEPLOYED, SENTRY_ALREADYPLACED, SENTRY_NOROOM, forcedata_s::sentryDeployed, SHIELD_NOROOM, trace_t::startsolid, STAT_HEALTH, STAT_HOLDABLE_ITEM, STAT_MAX_HEALTH, playerState_s::stats, pmove_t::trace, vec3_t, VectorCopy, VectorMA, VectorSet, playerState_s::viewangles, and YAW. { vec3_t fwd, fwdorg, dest, pos; vec3_t yawonly; vec3_t mins, maxs; vec3_t trtest; trace_t tr; if (ps->m_iVehicleNum) { return 0; } if (ps->pm_flags & PMF_USE_ITEM_HELD) { //force to let go first return 0; } if (ps->duelInProgress) { //not allowed to use holdables while in a private duel. return 0; } if (!forcedUse) { forcedUse = bg_itemlist[ps->stats[STAT_HOLDABLE_ITEM]].giTag; } if (!BG_IsItemSelectable(ps, forcedUse)) { return 0; } switch (forcedUse) { case HI_MEDPAC: case HI_MEDPAC_BIG: if (ps->stats[STAT_HEALTH] >= ps->stats[STAT_MAX_HEALTH]) { return 0; } if (ps->stats[STAT_HEALTH] <= 0 || (ps->eFlags & EF_DEAD)) { return 0; } return 1; case HI_SEEKER: if (ps->eFlags & EF_SEEKERDRONE) { PM_AddEventWithParm(EV_ITEMUSEFAIL, SEEKER_ALREADYDEPLOYED); return 0; } return 1; case HI_SENTRY_GUN: if (ps->fd.sentryDeployed) { PM_AddEventWithParm(EV_ITEMUSEFAIL, SENTRY_ALREADYPLACED); return 0; } yawonly[ROLL] = 0; yawonly[PITCH] = 0; yawonly[YAW] = ps->viewangles[YAW]; VectorSet( mins, -8, -8, 0 ); VectorSet( maxs, 8, 8, 24 ); AngleVectors(yawonly, fwd, NULL, NULL); fwdorg[0] = ps->origin[0] + fwd[0]*64; fwdorg[1] = ps->origin[1] + fwd[1]*64; fwdorg[2] = ps->origin[2] + fwd[2]*64; trtest[0] = fwdorg[0] + fwd[0]*16; trtest[1] = fwdorg[1] + fwd[1]*16; trtest[2] = fwdorg[2] + fwd[2]*16; pm->trace(&tr, ps->origin, mins, maxs, trtest, ps->clientNum, MASK_PLAYERSOLID); if ((tr.fraction != 1 && tr.entityNum != ps->clientNum) || tr.startsolid || tr.allsolid) { PM_AddEventWithParm(EV_ITEMUSEFAIL, SENTRY_NOROOM); return 0; } return 1; case HI_SHIELD: mins[0] = -8; mins[1] = -8; mins[2] = 0; maxs[0] = 8; maxs[1] = 8; maxs[2] = 8; AngleVectors (ps->viewangles, fwd, NULL, NULL); fwd[2] = 0; VectorMA(ps->origin, 64, fwd, dest); pm->trace(&tr, ps->origin, mins, maxs, dest, ps->clientNum, MASK_SHOT ); if (tr.fraction > 0.9 && !tr.startsolid && !tr.allsolid) { VectorCopy(tr.endpos, pos); VectorSet( dest, pos[0], pos[1], pos[2] - 4096 ); pm->trace( &tr, pos, mins, maxs, dest, ps->clientNum, MASK_SOLID ); if ( !tr.startsolid && !tr.allsolid ) { return 1; } } PM_AddEventWithParm(EV_ITEMUSEFAIL, SHIELD_NOROOM); return 0; case HI_JETPACK: //check for stuff here? return 1; case HI_HEALTHDISP: return 1; case HI_AMMODISP: return 1; case HI_EWEB: return 1; case HI_CLOAK: //check for stuff here? return 1; default: return 1; } }

int PM_KickMoveForConditions (  void   )

Definition at line 2617 of file bg_saber.c. References pmove_t::cmd, DIR_BACK, DIR_FRONT, DIR_LEFT, DIR_RIGHT, usercmd_s::forwardmove, LS_KICK_B, LS_KICK_F, LS_KICK_L, LS_KICK_R, LS_KICK_RL, LS_KICK_S, pm, usercmd_s::rightmove, and usercmd_s::upmove. Referenced by PM_WeaponLightsaber(). { int kickMove = -1; //FIXME: only if FP_SABER_OFFENSE >= 3 if ( pm->cmd.rightmove ) {//kick to side if ( pm->cmd.rightmove > 0 ) {//kick right kickMove = LS_KICK_R; } else {//kick left kickMove = LS_KICK_L; } pm->cmd.rightmove = 0; } else if ( pm->cmd.forwardmove ) {//kick front/back if ( pm->cmd.forwardmove > 0 ) {//kick fwd /* if (pm->ps->groundEntityNum != ENTITYNUM_NONE && PM_CheckEnemyPresence( DIR_FRONT, 64.0f )) { kickMove = LS_HILT_BASH; } else */ { kickMove = LS_KICK_F; } } else {//kick back kickMove = LS_KICK_B; } pm->cmd.forwardmove = 0; } else { //if (pm->cmd.buttons & BUTTON_ATTACK) //if (pm->ps->pm_flags & PMF_JUMP_HELD) if (0) { //ok, let's try some fancy kicks //qboolean is actually of type int anyway, but just for safeness. int front = (int)PM_CheckEnemyPresence( DIR_FRONT, 100.0f ); int back = (int)PM_CheckEnemyPresence( DIR_BACK, 100.0f ); int right = (int)PM_CheckEnemyPresence( DIR_RIGHT, 100.0f ); int left = (int)PM_CheckEnemyPresence( DIR_LEFT, 100.0f ); int numEnemy = front+back+right+left; if (numEnemy >= 3 || ((!right || !left) && numEnemy >= 2)) { //> 2 enemies near, or, >= 2 enemies near and they are not to the right and left. kickMove = LS_KICK_S; } else if (right && left) { //enemies on both sides kickMove = LS_KICK_RL; } else { //oh well, just do a forward kick kickMove = LS_KICK_F; } pm->cmd.upmove = 0; } } return kickMove; }

int PM_LegsSlopeBackTransition (  int  desiredAnim  )

Definition at line 5108 of file bg_pmove.c. References pmove_t::cmd, LEGS_LEFTUP2, LEGS_LEFTUP3, LEGS_LEFTUP4, LEGS_LEFTUP5, LEGS_RIGHTUP2, LEGS_RIGHTUP3, LEGS_RIGHTUP4, LEGS_RIGHTUP5, LEGS_S1_LUP2, LEGS_S1_LUP3, LEGS_S1_LUP4, LEGS_S1_LUP5, LEGS_S1_RUP2, LEGS_S1_RUP3, LEGS_S1_RUP4, LEGS_S1_RUP5, LEGS_S3_LUP2, LEGS_S3_LUP3, LEGS_S3_LUP4, LEGS_S3_LUP5, LEGS_S3_RUP2, LEGS_S3_RUP3, LEGS_S3_RUP4, LEGS_S3_RUP5, LEGS_S4_LUP2, LEGS_S4_LUP3, LEGS_S4_LUP4, LEGS_S4_LUP5, LEGS_S4_RUP2, LEGS_S4_RUP3, LEGS_S4_RUP4, LEGS_S4_RUP5, LEGS_S5_LUP2, LEGS_S5_LUP3, LEGS_S5_LUP4, LEGS_S5_LUP5, LEGS_S5_RUP2, LEGS_S5_RUP3, LEGS_S5_RUP4, LEGS_S5_RUP5, playerState_s::legsAnim, pm, pmove_t::ps, usercmd_s::serverTime, playerState_s::slopeRecalcTime, VectorClear, and playerState_s::velocity. { int anim = pm->ps->legsAnim; int resultingAnim = desiredAnim; switch ( anim ) { case LEGS_LEFTUP2: //# On a slope with left foot 8 higher than right case LEGS_LEFTUP3: //# On a slope with left foot 12 higher than right case LEGS_LEFTUP4: //# On a slope with left foot 16 higher than right case LEGS_LEFTUP5: //# On a slope with left foot 20 higher than right case LEGS_RIGHTUP2: //# On a slope with RIGHT foot 8 higher than left case LEGS_RIGHTUP3: //# On a slope with RIGHT foot 12 higher than left case LEGS_RIGHTUP4: //# On a slope with RIGHT foot 16 higher than left case LEGS_RIGHTUP5: //# On a slope with RIGHT foot 20 higher than left case LEGS_S1_LUP2: case LEGS_S1_LUP3: case LEGS_S1_LUP4: case LEGS_S1_LUP5: case LEGS_S1_RUP2: case LEGS_S1_RUP3: case LEGS_S1_RUP4: case LEGS_S1_RUP5: case LEGS_S3_LUP2: case LEGS_S3_LUP3: case LEGS_S3_LUP4: case LEGS_S3_LUP5: case LEGS_S3_RUP2: case LEGS_S3_RUP3: case LEGS_S3_RUP4: case LEGS_S3_RUP5: case LEGS_S4_LUP2: case LEGS_S4_LUP3: case LEGS_S4_LUP4: case LEGS_S4_LUP5: case LEGS_S4_RUP2: case LEGS_S4_RUP3: case LEGS_S4_RUP4: case LEGS_S4_RUP5: case LEGS_S5_LUP2: case LEGS_S5_LUP3: case LEGS_S5_LUP4: case LEGS_S5_LUP5: case LEGS_S5_RUP2: case LEGS_S5_RUP3: case LEGS_S5_RUP4: case LEGS_S5_RUP5: if (pm->ps->slopeRecalcTime < pm->cmd.serverTime) { resultingAnim = anim-1; pm->ps->slopeRecalcTime = pm->cmd.serverTime + 8;//SLOPE_RECALC_INT; } else { resultingAnim = anim; } VectorClear(pm->ps->velocity); break; } return resultingAnim; }

void PM_MoveForKata (  usercmd_t *  ucmd  )

Definition at line 10089 of file bg_pmove.c. References BOTH_A2_SPECIAL, BOTH_A3_SPECIAL, BOTH_A7_SOULCAL, pmove_t::cmd, ENTITYNUM_NONE, EV_JUMP, playerState_s::fd, forcedata_s::forceJumpZStart, usercmd_s::forwardmove, playerState_s::groundEntityNum, playerState_s::legsAnim, playerState_s::legsTimer, LS_STAFF_SOULCAL, playerState_s::origin, pm, PM_AddEvent(), PM_CanRollFromSoulCal(), pmove_t::ps, usercmd_s::rightmove, playerState_s::saberMove, ucmd, usercmd_s::upmove, usercmd_t, and playerState_s::velocity. Referenced by PmoveSingle(). { if ( pm->ps->legsAnim == BOTH_A7_SOULCAL && pm->ps->saberMove == LS_STAFF_SOULCAL ) {//forward spinning staff attack ucmd->upmove = 0; if ( PM_CanRollFromSoulCal( pm->ps ) ) { ucmd->upmove = -127; ucmd->rightmove = 0; if (ucmd->forwardmove < 0) { ucmd->forwardmove = 0; } } else { ucmd->rightmove = 0; //FIXME: don't slide off people/obstacles? if ( pm->ps->legsTimer >= 2750 ) {//not at end //push forward ucmd->forwardmove = 64; } else { ucmd->forwardmove = 0; } } if ( pm->ps->legsTimer >= 2650 && pm->ps->legsTimer < 2850 ) {//the jump if ( pm->ps->groundEntityNum != ENTITYNUM_NONE ) {//still on ground? //jump! pm->ps->velocity[2] = 250; pm->ps->fd.forceJumpZStart = pm->ps->origin[2];//so we don't take damage if we land at same height // pm->ps->pm_flags |= PMF_JUMPING;//|PMF_SLOW_MO_FALL; //FIXME: NPCs yell? PM_AddEvent(EV_JUMP); } } } else if (pm->ps->legsAnim == BOTH_A2_SPECIAL) { //medium kata pm->cmd.rightmove = 0; pm->cmd.upmove = 0; if (pm->ps->legsTimer < 2700 && pm->ps->legsTimer > 2300) { pm->cmd.forwardmove = 127; } else if (pm->ps->legsTimer < 900 && pm->ps->legsTimer > 500) { pm->cmd.forwardmove = 127; } else { pm->cmd.forwardmove = 0; } } else if (pm->ps->legsAnim == BOTH_A3_SPECIAL) { //strong kata pm->cmd.rightmove = 0; pm->cmd.upmove = 0; if (pm->ps->legsTimer < 1700 && pm->ps->legsTimer > 1000) { pm->cmd.forwardmove = 127; } else { pm->cmd.forwardmove = 0; } } else { pm->cmd.forwardmove = 0; pm->cmd.rightmove = 0; pm->cmd.upmove = 0; } }

void PM_pitch_roll_for_slope (  bgEntity_t *  forwhom, vec3_t  pass_slope, vec3_t  storeAngles )

Definition at line 346 of file bg_pmove.c. References AngleVectors(), bgEntity_t, CLASS_VEHICLE, DotProduct, fabs(), trace_t::fraction, bgEntity_s::m_pVehicle, Vehicle_s::m_vOrientation, MASK_SOLID, pmove_t::mins, cplane_s::normal, entityState_s::NPC_class, NULL, entityState_s::number, playerState_s::origin, PITCH, trace_t::plane, pm, pmove_t::ps, Q_fabs(), ROLL, bgEntity_s::s, pmove_t::trace, vec3_origin, vec3_t, vectoangles(), VectorCopy, Vehicle_t, playerState_s::viewangles, and YAW. { vec3_t slope; vec3_t nvf, ovf, ovr, startspot, endspot, new_angles = { 0, 0, 0 }; float pitch, mod, dot; //if we don't have a slope, get one if( !pass_slope || VectorCompare( vec3_origin, pass_slope ) ) { trace_t trace; VectorCopy( pm->ps->origin, startspot ); startspot[2] += pm->mins[2] + 4; VectorCopy( startspot, endspot ); endspot[2] -= 300; pm->trace( &trace, pm->ps->origin, vec3_origin, vec3_origin, endspot, forwhom->s.number, MASK_SOLID ); // if(trace_fraction>0.05&&forwhom.movetype==MOVETYPE_STEP) // forwhom.flags(-)FL_ONGROUND; if ( trace.fraction >= 1.0 ) return; if( !( &trace.plane ) ) return; if ( VectorCompare( vec3_origin, trace.plane.normal ) ) return; VectorCopy( trace.plane.normal, slope ); } else { VectorCopy( pass_slope, slope ); } if ( forwhom->s.NPC_class == CLASS_VEHICLE ) {//special code for vehicles Vehicle_t *pVeh = forwhom->m_pVehicle; vec3_t tempAngles; tempAngles[PITCH] = tempAngles[ROLL] = 0; tempAngles[YAW] = pVeh->m_vOrientation[YAW]; AngleVectors( tempAngles, ovf, ovr, NULL ); } else { AngleVectors( pm->ps->viewangles, ovf, ovr, NULL ); } vectoangles( slope, new_angles ); pitch = new_angles[PITCH] + 90; new_angles[ROLL] = new_angles[PITCH] = 0; AngleVectors( new_angles, nvf, NULL, NULL ); mod = DotProduct( nvf, ovr ); if ( mod<0 ) mod = -1; else mod = 1; dot = DotProduct( nvf, ovf ); if ( storeAngles ) { storeAngles[PITCH] = dot * pitch; storeAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); } else //if ( forwhom->client ) { float oldmins2; pm->ps->viewangles[PITCH] = dot * pitch; pm->ps->viewangles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); oldmins2 = pm->mins[2]; pm->mins[2] = -24 + 12 * fabs(pm->ps->viewangles[PITCH])/180.0f; //FIXME: if it gets bigger, move up if ( oldmins2 > pm->mins[2] ) {//our mins is now lower, need to move up //FIXME: trace? pm->ps->origin[2] += (oldmins2 - pm->mins[2]); //forwhom->currentOrigin[2] = forwhom->client->ps.origin[2]; //gi.linkentity( forwhom ); } } /* else { forwhom->currentAngles[PITCH] = dot * pitch; forwhom->currentAngles[ROLL] = ((1-Q_fabs(dot)) * pitch * mod); } */ }

void PM_RocketLock (  float  lockDist, qboolean  vehicleLock )

Definition at line 5875 of file bg_pmove.c. References AngleVectors(), BG_VehTraceFromCamPos(), bgEntity_t, playerState_s::clientNum, pmove_t::cmd, trace_t::endpos, trace_t::entityNum, ENTITYNUM_NONE, ET_NPC, ET_PLAYER, entityState_s::eType, trace_t::fraction, MASK_PLAYERSOLID, memcpy(), NULL, playerState_s::origin, pm, PM_BGEntForNum(), entityState_s::powerups, pmove_t::ps, PW_CLOAKED, playerState_s::rocketLastValidTime, playerState_s::rocketLockIndex, playerState_s::rocketLockTime, playerState_s::rocketTargetTime, bgEntity_s::s, usercmd_s::serverTime, pmove_t::trace, vec3_t, VectorCopy, VectorMA, playerState_s::viewangles, playerState_s::viewheight, WP_MuzzlePoint, and WP_ROCKET_LAUNCHER. { // Not really a charge weapon, but we still want to delay fire until the button comes up so that we can // implement our alt-fire locking stuff vec3_t ang; trace_t tr; vec3_t muzzleOffPoint, muzzlePoint, forward, right, up; if ( vehicleLock ) { AngleVectors( pm->ps->viewangles, forward, right, up ); VectorCopy( pm->ps->origin, muzzlePoint ); VectorMA( muzzlePoint, lockDist, forward, ang ); } else { AngleVectors( pm->ps->viewangles, forward, right, up ); AngleVectors(pm->ps->viewangles, ang, NULL, NULL); VectorCopy( pm->ps->origin, muzzlePoint ); VectorCopy(WP_MuzzlePoint[WP_ROCKET_LAUNCHER], muzzleOffPoint); VectorMA(muzzlePoint, muzzleOffPoint[0], forward, muzzlePoint); VectorMA(muzzlePoint, muzzleOffPoint[1], right, muzzlePoint); muzzlePoint[2] += pm->ps->viewheight + muzzleOffPoint[2]; ang[0] = muzzlePoint[0] + ang[0]*lockDist; ang[1] = muzzlePoint[1] + ang[1]*lockDist; ang[2] = muzzlePoint[2] + ang[2]*lockDist; } pm->trace(&tr, muzzlePoint, NULL, NULL, ang, pm->ps->clientNum, MASK_PLAYERSOLID); if ( vehicleLock ) {//vehicles also do a trace from the camera point if the main one misses if ( tr.fraction >= 1.0f ) { trace_t camTrace; vec3_t newEnd, shotDir; if ( BG_VehTraceFromCamPos( &camTrace, PM_BGEntForNum(pm->ps->clientNum), pm->ps->origin, muzzlePoint, tr.endpos, newEnd, shotDir, (tr.fraction*lockDist) ) ) { memcpy( &tr, &camTrace, sizeof(tr) ); } } } if (tr.fraction != 1 && tr.entityNum < ENTITYNUM_NONE && tr.entityNum != pm->ps->clientNum) { bgEntity_t *bgEnt = PM_BGEntForNum(tr.entityNum); if ( bgEnt && (bgEnt->s.powerups&PW_CLOAKED) ) { pm->ps->rocketLockIndex = ENTITYNUM_NONE; pm->ps->rocketLockTime = 0; } else if (bgEnt && (bgEnt->s.eType == ET_PLAYER || bgEnt->s.eType == ET_NPC)) { if (pm->ps->rocketLockIndex == ENTITYNUM_NONE) { pm->ps->rocketLockIndex = tr.entityNum; pm->ps->rocketLockTime = pm->cmd.serverTime; } else if (pm->ps->rocketLockIndex != tr.entityNum && pm->ps->rocketTargetTime < pm->cmd.serverTime) { pm->ps->rocketLockIndex = tr.entityNum; pm->ps->rocketLockTime = pm->cmd.serverTime; } else if (pm->ps->rocketLockIndex == tr.entityNum) { if (pm->ps->rocketLockTime == -1) { pm->ps->rocketLockTime = pm->ps->rocketLastValidTime; } } if (pm->ps->rocketLockIndex == tr.entityNum) { pm->ps->rocketTargetTime = pm->cmd.serverTime + 500; } } else if (!vehicleLock) { if (pm->ps->rocketTargetTime < pm->cmd.serverTime) { pm->ps->rocketLockIndex = ENTITYNUM_NONE; pm->ps->rocketLockTime = 0; } } } else if (pm->ps->rocketTargetTime < pm->cmd.serverTime) { pm->ps->rocketLockIndex = ENTITYNUM_NONE; pm->ps->rocketLockTime = 0; } else { if (pm->ps->rocketLockTime != -1) { pm->ps->rocketLastValidTime = pm->ps->rocketLockTime; } pm->ps->rocketLockTime = -1; } }

qboolean PM_RollingAnim (  int  anim  )

Definition at line 4636 of file bg_pmove.c. References BOTH_ROLL_B, BOTH_ROLL_F, BOTH_ROLL_L, BOTH_ROLL_R, qboolean, qfalse, and qtrue. Referenced by Jedi_SaberBusy(), NPC_ChoosePainAnimation(), and WP_ResistForcePush(). { switch ( anim ) { case BOTH_ROLL_F: //# Roll forward case BOTH_ROLL_B: //# Roll backward case BOTH_ROLL_L: //# Roll left case BOTH_ROLL_R: //# Roll right return qtrue; break; } return qfalse; }

qboolean PM_RunningAnim (  int  anim  )

Definition at line 4601 of file bg_pmove.c. References BOTH_RUN1, BOTH_RUN1START, BOTH_RUN1STOP, BOTH_RUN2, BOTH_RUN_DUAL, BOTH_RUN_STAFF, BOTH_RUNBACK1, BOTH_RUNBACK2, BOTH_RUNBACK_DUAL, BOTH_RUNBACK_STAFF, BOTH_RUNSTRAFE_LEFT1, BOTH_RUNSTRAFE_RIGHT1, qboolean, qfalse, and qtrue. Referenced by BG_SetAnimFinal(), G_UpdateClientAnims(), and PM_WeaponLightsaber(). { switch ( (anim) ) { case BOTH_RUN1: case BOTH_RUN2: case BOTH_RUN_STAFF: case BOTH_RUN_DUAL: case BOTH_RUNBACK1: case BOTH_RUNBACK2: case BOTH_RUNBACK_STAFF: case BOTH_RUNBACK_DUAL: case BOTH_RUN1START: //# Start into full run1 case BOTH_RUN1STOP: //# Stop from full run1 case BOTH_RUNSTRAFE_LEFT1: //# Sidestep left: should loop case BOTH_RUNSTRAFE_RIGHT1: //# Sidestep right: should loop return qtrue; break; } return qfalse; }

qboolean PM_SaberInTransition (  int  move  )

Definition at line 1610 of file bg_panimate.c. { if ( move >= LS_T1_BR__R && move <= LS_T1_BL__L ) { return qtrue; } return qfalse; }

void PM_SetForceJumpZStart (  float  value  )

Definition at line 1759 of file bg_pmove.c. References playerState_s::fd, forcedata_s::forceJumpZStart, pm, and pmove_t::ps. Referenced by PM_SaberFlipOverAttackMove(), and PM_SaberJumpAttackMove(). { pm->ps->fd.forceJumpZStart = value; if (!pm->ps->fd.forceJumpZStart) { pm->ps->fd.forceJumpZStart -= 0.1; } }

void PM_SetPMViewAngle (  playerState_t *  ps, vec3_t  angle, usercmd_t *  ucmd )

Definition at line 1342 of file bg_pmove.c. References ANGLE2SHORT, usercmd_s::angles, playerState_s::delta_angles, playerState_t, ucmd, usercmd_t, vec3_t, VectorCopy, and playerState_s::viewangles. Referenced by PM_AdjustAngleForWallJump(), PM_AdjustAngleForWallRun(), PM_AdjustAngleForWallRunUp(), PM_AdjustAnglesForWallRunUpFlipAlt(), PM_VehFaceHyperspacePoint(), PM_VehForcedTurning(), PM_VehicleViewAngles(), and PmoveSingle(). { int i; for (i=0 ; i<3 ; i++) { // set the delta angle int cmdAngle; cmdAngle = ANGLE2SHORT(angle[i]); ps->delta_angles[i] = cmdAngle - ucmd->angles[i]; } VectorCopy (angle, ps->viewangles); }

void PM_SetSpecialMoveValues (  void   )

Definition at line 447 of file bg_pmove.c. References bgEntity_t, CLASS_VEHICLE, playerState_s::clientNum, EF2_FLYING, playerState_s::eFlags2, FLY_HOVER, FLY_NONE, FLY_NORMAL, FLY_VEHICLE, vehicleInfo_t::hoverHeight, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, MAX_CLIENTS, entityState_s::NPC_class, pm, pm_entSelf, pmove_t::ps, bgEntity_s::s, vehicleInfo_t::type, and VH_FIGHTER. Referenced by PmoveSingle(). { bgEntity_t *pEnt; if (pm->ps->clientNum < MAX_CLIENTS) { //we know that real players aren't vehs pm_flying = FLY_NONE; return; } //default until we decide otherwise pm_flying = FLY_NONE; pEnt = pm_entSelf; if ( pEnt ) { if ( (pm->ps->eFlags2&EF2_FLYING) )// pm->gent->client->moveType == MT_FLYSWIM ) { pm_flying = FLY_NORMAL; } else if ( pEnt->s.NPC_class == CLASS_VEHICLE ) { if ( pEnt->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER ) { pm_flying = FLY_VEHICLE; } else if ( pEnt->m_pVehicle->m_pVehicleInfo->hoverHeight > 0 ) { pm_flying = FLY_HOVER; } } } }

qboolean PM_SwimmingAnim (  int  anim  )

Definition at line 4623 of file bg_pmove.c. References BOTH_SWIM_IDLE1, BOTH_SWIMBACKWARD, BOTH_SWIMFORWARD, qboolean, qfalse, and qtrue. Referenced by PM_WeaponLightsaber(). { switch ( anim ) { case BOTH_SWIM_IDLE1: //# Swimming Idle 1 case BOTH_SWIMFORWARD: //# Swim forward loop case BOTH_SWIMBACKWARD: //# Swim backward loop return qtrue; break; } return qfalse; }

void PM_UpdateViewAngles (  playerState_t *  ps, const usercmd_t *  cmd )

Definition at line 7814 of file bg_pmove.c. References ANGLE2SHORT, AngleNormalize180(), usercmd_s::angles, BG_UnrestrainedPitchRoll(), playerState_s::delta_angles, HYPERSPACE_TIME, playerState_s::hyperSpaceTime, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_vPrevRiderViewAngles, PITCH, bgEntity_s::playerState, playerState_t, pm_entVeh, PM_INTERMISSION, PM_SPECTATOR, PM_SPINTERMISSION, playerState_s::pm_type, usercmd_s::serverTime, SHORT2ANGLE, STAT_HEALTH, playerState_s::stats, vehicleInfo_t::type, usercmd_t, VH_FIGHTER, playerState_s::viewangles, and YAW. Referenced by CG_PredictPlayerState(), and PmoveSingle(). { short temp; int i; if ( ps->pm_type == PM_INTERMISSION || ps->pm_type == PM_SPINTERMISSION) { return; // no view changes at all } if ( ps->pm_type != PM_SPECTATOR && ps->stats[STAT_HEALTH] <= 0 ) { return; // no view changes at all } // circularly clamp the angles with deltas for (i=0 ; i<3 ; i++) { temp = cmd->angles[i] + ps->delta_angles[i]; #ifdef VEH_CONTROL_SCHEME_4 if ( pm_entVeh && pm_entVeh->m_pVehicle && pm_entVeh->m_pVehicle->m_pVehicleInfo && pm_entVeh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER && (cmd->serverTime-pm_entVeh->playerState->hyperSpaceTime) >= HYPERSPACE_TIME ) {//in a vehicle and not hyperspacing if ( i == PITCH ) { int pitchClamp = ANGLE2SHORT(AngleNormalize180(pm_entVeh->m_pVehicle->m_vPrevRiderViewAngles[PITCH]+10.0f)); // don't let the player look up or down more than 22.5 degrees if ( temp > pitchClamp ) { ps->delta_angles[i] = pitchClamp - cmd->angles[i]; temp = pitchClamp; } else if ( temp < -pitchClamp ) { ps->delta_angles[i] = -pitchClamp - cmd->angles[i]; temp = -pitchClamp; } } if ( i == YAW ) { int yawClamp = ANGLE2SHORT(AngleNormalize180(pm_entVeh->m_pVehicle->m_vPrevRiderViewAngles[YAW]+10.0f)); // don't let the player look left or right more than 22.5 degrees if ( temp > yawClamp ) { ps->delta_angles[i] = yawClamp - cmd->angles[i]; temp = yawClamp; } else if ( temp < -yawClamp ) { ps->delta_angles[i] = -yawClamp - cmd->angles[i]; temp = -yawClamp; } } } #else //VEH_CONTROL_SCHEME_4 if ( pm_entVeh && BG_UnrestrainedPitchRoll( ps, pm_entVeh->m_pVehicle ) ) {//in a fighter /* if ( i == ROLL ) {//get roll from vehicle ps->viewangles[ROLL] = pm_entVeh->playerState->viewangles[ROLL];//->m_pVehicle->m_vOrientation[ROLL]; continue; } */ } #endif // VEH_CONTROL_SCHEME_4 else { if ( i == PITCH ) { // don't let the player look up or down more than 90 degrees if ( temp > 16000 ) { ps->delta_angles[i] = 16000 - cmd->angles[i]; temp = 16000; } else if ( temp < -16000 ) { ps->delta_angles[i] = -16000 - cmd->angles[i]; temp = -16000; } } } ps->viewangles[i] = SHORT2ANGLE(temp); } }

void PM_Use (  void   )

Definition at line 4560 of file bg_pmove.c. References BUTTON_USE, usercmd_s::buttons, pmove_t::cmd, EV_USE, pm, pmove_t::ps, USE_DELAY, pmove_t::useEvent, and playerState_s::useTime. Referenced by PmoveSingle(). { if ( pm->ps->useTime > 0 ) pm->ps->useTime -= 100;//pm->cmd.msec; if ( pm->ps->useTime > 0 ) { return; } if ( ! (pm->cmd.buttons & BUTTON_USE ) ) { pm->useEvent = 0; pm->ps->useTime = 0; return; } pm->useEvent = EV_USE; pm->ps->useTime = USE_DELAY; }

void PM_VehFaceHyperspacePoint (  bgEntity_t *  veh  )

Definition at line 9913 of file bg_pmove.c. References AngleNormalize180(), AngleNormalize360(), AngleSubtract(), bgEntity_t, pmove_t::cmd, EF2_HYPERSPACE, playerState_s::eFlags2, fabs(), usercmd_s::forwardmove, pml_t::frametime, HYPERSPACE_TELEPORT_FRAC, HYPERSPACE_TIME, playerState_s::hyperSpaceAngles, playerState_s::hyperSpaceTime, bgEntity_s::m_pVehicle, Vehicle_s::m_ucmd, Vehicle_s::m_vOrientation, pml_t::msec, bgEntity_s::playerState, pm, PM_SetPMViewAngle(), pml, pmove_t::ps, usercmd_s::rightmove, usercmd_s::serverTime, usercmd_s::upmove, playerState_s::viewangles, and YAW. Referenced by PmoveSingle(). { if (!veh || !veh->m_pVehicle) { return; } else { float timeFrac = ((float)(pm->cmd.serverTime-veh->playerState->hyperSpaceTime))/HYPERSPACE_TIME; float turnRate, aDelta; int i, matchedAxes = 0; pm->cmd.upmove = veh->m_pVehicle->m_ucmd.upmove = 127; pm->cmd.forwardmove = veh->m_pVehicle->m_ucmd.forwardmove = 0; pm->cmd.rightmove = veh->m_pVehicle->m_ucmd.rightmove = 0; turnRate = (90.0f*pml.frametime); for ( i = 0; i < 3; i++ ) { aDelta = AngleSubtract(veh->playerState->hyperSpaceAngles[i], veh->m_pVehicle->m_vOrientation[i]); if ( fabs( aDelta ) < turnRate ) {//all is good pm->ps->viewangles[i] = veh->playerState->hyperSpaceAngles[i]; matchedAxes++; } else { aDelta = AngleSubtract(veh->playerState->hyperSpaceAngles[i], pm->ps->viewangles[i]); if ( fabs( aDelta ) < turnRate ) { pm->ps->viewangles[i] = veh->playerState->hyperSpaceAngles[i]; } else if ( aDelta > 0 ) { if ( i == YAW ) { pm->ps->viewangles[i] = AngleNormalize360( pm->ps->viewangles[i]+turnRate ); } else { pm->ps->viewangles[i] = AngleNormalize180( pm->ps->viewangles[i]+turnRate ); } } else { if ( i == YAW ) { pm->ps->viewangles[i] = AngleNormalize360( pm->ps->viewangles[i]-turnRate ); } else { pm->ps->viewangles[i] = AngleNormalize180( pm->ps->viewangles[i]-turnRate ); } } } } PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); if ( timeFrac < HYPERSPACE_TELEPORT_FRAC ) {//haven't gone through yet if ( matchedAxes < 3 ) {//not facing the right dir yet //keep hyperspace time up to date veh->playerState->hyperSpaceTime += pml.msec; } else if ( !(veh->playerState->eFlags2&EF2_HYPERSPACE)) {//flag us as ready to hyperspace! veh->playerState->eFlags2 |= EF2_HYPERSPACE; } } } }

void PM_VehForcedTurning (  bgEntity_t *  veh  )

Definition at line 9780 of file bg_pmove.c. References AngleNormalize180(), AngleSubtract(), bgEntity_t, pmove_t::cmd, usercmd_s::forwardmove, pml_t::frametime, bgEntity_s::m_pVehicle, Vehicle_s::m_ucmd, Vehicle_s::m_vPrevRiderViewAngles, playerState_s::origin, entityState_s::origin, PITCH, bgEntity_s::playerState, pm, PM_BGEntForNum(), PM_SetPMViewAngle(), pml, pmove_t::ps, usercmd_s::rightmove, bgEntity_s::s, usercmd_s::upmove, vec3_t, vectoangles(), VectorClear, VectorSubtract, playerState_s::vehTurnaroundIndex, playerState_s::viewangles, and YAW. Referenced by PmoveSingle(). { bgEntity_t *dst = PM_BGEntForNum(veh->playerState->vehTurnaroundIndex); float pitchD, yawD; vec3_t dir; if (!veh || !veh->m_pVehicle) { return; } if (!dst) { //can't find dest ent? return; } pm->cmd.upmove = veh->m_pVehicle->m_ucmd.upmove = 127; pm->cmd.forwardmove = veh->m_pVehicle->m_ucmd.forwardmove = 0; pm->cmd.rightmove = veh->m_pVehicle->m_ucmd.rightmove = 0; VectorSubtract(dst->s.origin, veh->playerState->origin, dir); vectoangles(dir, dir); yawD = AngleSubtract(pm->ps->viewangles[YAW], dir[YAW]); pitchD = AngleSubtract(pm->ps->viewangles[PITCH], dir[PITCH]); yawD *= 0.6f*pml.frametime; pitchD *= 0.6f*pml.frametime; #ifdef VEH_CONTROL_SCHEME_4 veh->playerState->viewangles[YAW] = AngleSubtract(veh->playerState->viewangles[YAW], yawD); veh->playerState->viewangles[PITCH] = AngleSubtract(veh->playerState->viewangles[PITCH], pitchD); pm->ps->viewangles[YAW] = veh->playerState->viewangles[YAW]; pm->ps->viewangles[PITCH] = 0; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); PM_SetPMViewAngle(veh->playerState, veh->playerState->viewangles, &pm->cmd); VectorClear( veh->m_pVehicle->m_vPrevRiderViewAngles ); veh->m_pVehicle->m_vPrevRiderViewAngles[YAW] = AngleNormalize180(pm->ps->viewangles[YAW]); #else //VEH_CONTROL_SCHEME_4 pm->ps->viewangles[YAW] = AngleSubtract(pm->ps->viewangles[YAW], yawD); pm->ps->viewangles[PITCH] = AngleSubtract(pm->ps->viewangles[PITCH], pitchD); PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); #endif //VEH_CONTROL_SCHEME_4 }

void PM_VehicleViewAngles (  playerState_t *  ps, bgEntity_t *  veh, usercmd_t *  ucmd )

Definition at line 9643 of file bg_pmove.c. References BG_UnrestrainedPitchRoll(), bgEntity_t, playerState_s::clientNum, playerState_s::generic1, vehicleInfo_t::lookPitch, Vehicle_s::m_pPilot, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, MAX_VEHICLE_TURRETS, entityState_s::number, turretStats_t::passengerNum, PITCH, turretStats_t::pitchClampDown, turretStats_t::pitchClampUp, playerState_t, PM_SetPMViewAngle(), qboolean, qtrue, ROLL, bgEntity_s::s, vehicleInfo_t::turret, ucmd, usercmd_t, vec3_t, Vehicle_t, playerState_s::viewangles, YAW, turretStats_t::yawClampLeft, and turretStats_t::yawClampRight. Referenced by PmoveSingle(). { Vehicle_t *pVeh = veh->m_pVehicle; qboolean setAngles = qtrue; vec3_t clampMin; vec3_t clampMax; int i; if ( veh->m_pVehicle->m_pPilot && veh->m_pVehicle->m_pPilot->s.number == ps->clientNum ) {//set the pilot's viewangles to the vehicle's viewangles #ifdef VEH_CONTROL_SCHEME_4 if ( 1 ) #else //VEH_CONTROL_SCHEME_4 if ( !BG_UnrestrainedPitchRoll( ps, veh->m_pVehicle ) ) #endif //VEH_CONTROL_SCHEME_4 {//only if not if doing special free-roll/pitch control setAngles = qtrue; clampMin[PITCH] = -pVeh->m_pVehicleInfo->lookPitch; clampMax[PITCH] = pVeh->m_pVehicleInfo->lookPitch; clampMin[YAW] = clampMax[YAW] = 0; clampMin[ROLL] = clampMax[ROLL] = -1; } } else { //NOTE: passengers can look around freely, UNLESS they're controlling a turret! for ( i = 0; i < MAX_VEHICLE_TURRETS; i++ ) { if ( veh->m_pVehicle->m_pVehicleInfo->turret[i].passengerNum == ps->generic1 ) {//this turret is my station setAngles = qtrue; clampMin[PITCH] = veh->m_pVehicle->m_pVehicleInfo->turret[i].pitchClampUp; clampMax[PITCH] = veh->m_pVehicle->m_pVehicleInfo->turret[i].pitchClampDown; clampMin[YAW] = veh->m_pVehicle->m_pVehicleInfo->turret[i].yawClampRight; clampMax[YAW] = veh->m_pVehicle->m_pVehicleInfo->turret[i].yawClampLeft; clampMin[ROLL] = clampMax[ROLL] = 0; break; } } } if ( setAngles ) { for ( i = 0; i < 3; i++ ) {//clamp viewangles if ( clampMin[i] == -1 || clampMax[i] == -1 ) {//no clamp } else if ( !clampMin[i] && !clampMax[i] ) {//no allowance //ps->viewangles[i] = veh->playerState->viewangles[i]; } else {//allowance if (ps->viewangles[i] > clampMax[i]) { ps->viewangles[i] = clampMax[i]; } else if (ps->viewangles[i] < clampMin[i]) { ps->viewangles[i] = clampMin[i]; } } } PM_SetPMViewAngle(ps, ps->viewangles, ucmd); } }

void PM_VehicleWeaponAnimate (  void   )

Definition at line 6382 of file bg_pmove.c. References BG_SabersOff(), bgEntity_t, BOTH_ATTACK3, BOTH_VS_AIR_G, BOTH_VS_ATF_G, BOTH_VS_ATL_G, BOTH_VS_ATL_S, BOTH_VS_ATR_G, BOTH_VS_ATR_S, BOTH_VS_IDLE, BOTH_VS_IDLE_G, BOTH_VS_IDLE_SL, BOTH_VS_IDLE_SR, BOTH_VS_LAND_G, BOTH_VS_LAND_SL, BOTH_VS_LAND_SR, BOTH_VS_REV, BOTH_VT_ATF_G, BOTH_VT_ATL_G, BOTH_VT_ATL_S, BOTH_VT_ATR_G, BOTH_VT_ATR_S, BOTH_VT_IDLE, BOTH_VT_IDLE_G, BOTH_VT_IDLE_S, BOTH_VT_RUN_FWD, BOTH_VT_TURBO, BOTH_VT_WALK_REV, BUTTON_ALT_ATTACK, BUTTON_ATTACK, usercmd_s::buttons, playerState_s::clientNum, pmove_t::cmd, EV_SABER_ATTACK, LS_R_TL2BR, Vehicle_s::m_pPilot, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_ulFlags, bgEntity_s::playerState, pm, PM_AddEvent(), pm_entVeh, PM_irand_timesync(), PM_SetAnim(), pmove_t::ps, usercmd_s::rightmove, playerState_s::saberMove, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_NORMAL, SETANIM_FLAG_OVERRIDE, SETANIM_FLAG_RESTART, playerState_s::speed, vehicleInfo_t::speedMax, playerState_s::torsoAnim, playerState_s::torsoTimer, vehicleInfo_t::type, VEH_CRASHING, Vehicle_t, VH_ANIMAL, VH_FIGHTER, VH_SPEEDER, VH_WALKER, playerState_s::weapon, WP_BLASTER, and WP_SABER. Referenced by PmoveSingle(). { bgEntity_t *veh = pm_entVeh; Vehicle_t *pVeh; int iFlags = 0, iBlend = 0, Anim = -1; if (!veh || !veh->m_pVehicle || !veh->m_pVehicle->m_pPilot || !veh->m_pVehicle->m_pPilot->playerState || pm->ps->clientNum != veh->m_pVehicle->m_pPilot->playerState->clientNum) { //make sure the vehicle exists, and its pilot is this player return; } pVeh = veh->m_pVehicle; if (pVeh->m_pVehicleInfo->type == VH_WALKER || pVeh->m_pVehicleInfo->type == VH_FIGHTER) { //slightly hacky I guess, but whatever. return; } backAgain: // If they're firing, play the right fire animation. if ( pm->cmd.buttons & ( BUTTON_ATTACK | BUTTON_ALT_ATTACK ) ) { iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; iBlend = 200; switch ( pm->ps->weapon ) { case WP_SABER: if ( pm->cmd.buttons & BUTTON_ALT_ATTACK ) { //don't do anything.. I guess. pm->cmd.buttons &= ~BUTTON_ALT_ATTACK; goto backAgain; } // If we're already in an attack animation, leave (let it continue). if (pm->ps->torsoTimer <= 0) { //we'll be starting a new attack PM_AddEvent(EV_SABER_ATTACK); } //just set it to something so we have a proper trail. This is a stupid //hack (much like the rest of this function) pm->ps->saberMove = LS_R_TL2BR; if ( pm->ps->torsoTimer > 0 && (pm->ps->torsoAnim == BOTH_VS_ATR_S || pm->ps->torsoAnim == BOTH_VS_ATL_S) ) { /* //FIXME: no need to even call the PM_SetAnim at all in this case Anim = (animNumber_t)pm->ps->torsoAnim; iFlags = SETANIM_FLAG_NORMAL; break; */ return; } // Start the attack. if ( pm->cmd.rightmove > 0 ) //right side attack { Anim = BOTH_VS_ATR_S; } else if ( pm->cmd.rightmove < 0 ) //left-side attack { Anim = BOTH_VS_ATL_S; } else //random { //FIXME: alternate back and forth or auto-aim? //if ( !Q_irand( 0, 1 ) ) if (!PM_irand_timesync(0, 1)) { Anim = BOTH_VS_ATR_S; } else { Anim = BOTH_VS_ATL_S; } } if (pm->ps->torsoTimer <= 0) { //restart the anim if we are already in it (and finished) iFlags |= SETANIM_FLAG_RESTART; } break; case WP_BLASTER: // Override the shoot anim. if ( pm->ps->torsoAnim == BOTH_ATTACK3 ) { if ( pm->cmd.rightmove > 0 ) //right side attack { Anim = BOTH_VS_ATR_G; } else if ( pm->cmd.rightmove < 0 ) //left side { Anim = BOTH_VS_ATL_G; } else //frontal { Anim = BOTH_VS_ATF_G; } } break; default: Anim = BOTH_VS_IDLE; break; } } else if (veh->playerState && veh->playerState->speed < 0 && pVeh->m_pVehicleInfo->type == VH_ANIMAL) { //tauntaun is going backwards Anim = BOTH_VT_WALK_REV; iBlend = 600; } else if (veh->playerState && veh->playerState->speed < 0 && pVeh->m_pVehicleInfo->type == VH_SPEEDER) { //speeder is going backwards Anim = BOTH_VS_REV; iBlend = 600; } // They're not firing so play the Idle for the weapon. else { iFlags = SETANIM_FLAG_NORMAL; switch ( pm->ps->weapon ) { case WP_SABER: if ( BG_SabersOff( pm->ps ) ) { //saber holstered, normal idle Anim = BOTH_VS_IDLE; } // In the Air. //else if ( pVeh->m_ulFlags & VEH_FLYING ) else if (0) { iBlend = 800; Anim = BOTH_VS_AIR_G; iFlags = SETANIM_FLAG_OVERRIDE; } // Crashing. //else if ( pVeh->m_ulFlags & VEH_CRASHING ) else if (0) { pVeh->m_ulFlags &= ~VEH_CRASHING; // Remove the flag, we are doing the animation. iBlend = 800; Anim = BOTH_VS_LAND_SR; iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; } else { Anim = BOTH_VS_IDLE_SR; } break; case WP_BLASTER: // In the Air. //if ( pVeh->m_ulFlags & VEH_FLYING ) if (0) { iBlend = 800; Anim = BOTH_VS_AIR_G; iFlags = SETANIM_FLAG_OVERRIDE; } // Crashing. //else if ( pVeh->m_ulFlags & VEH_CRASHING ) else if (0) { pVeh->m_ulFlags &= ~VEH_CRASHING; // Remove the flag, we are doing the animation. iBlend = 800; Anim = BOTH_VS_LAND_G; iFlags = SETANIM_FLAG_OVERRIDE | SETANIM_FLAG_HOLD; } else { Anim = BOTH_VS_IDLE_G; } break; default: Anim = BOTH_VS_IDLE; break; } } if (Anim != -1) { //override it if (pVeh->m_pVehicleInfo->type == VH_ANIMAL) { //agh.. remap anims for the tauntaun switch (Anim) { case BOTH_VS_IDLE: if (veh->playerState && veh->playerState->speed > 0) { if (veh->playerState->speed > pVeh->m_pVehicleInfo->speedMax) { //turbo Anim = BOTH_VT_TURBO; } else { Anim = BOTH_VT_RUN_FWD; } } else { Anim = BOTH_VT_IDLE; } break; case BOTH_VS_ATR_S: Anim = BOTH_VT_ATR_S; break; case BOTH_VS_ATL_S: Anim = BOTH_VT_ATL_S; break; case BOTH_VS_ATR_G: Anim = BOTH_VT_ATR_G; break; case BOTH_VS_ATL_G: Anim = BOTH_VT_ATL_G; break; case BOTH_VS_ATF_G: Anim = BOTH_VT_ATF_G; break; case BOTH_VS_IDLE_SL: Anim = BOTH_VT_IDLE_S; break; case BOTH_VS_IDLE_SR: Anim = BOTH_VT_IDLE_S; break; case BOTH_VS_IDLE_G: Anim = BOTH_VT_IDLE_G; break; //should not happen for tauntaun: case BOTH_VS_AIR_G: case BOTH_VS_LAND_SL: case BOTH_VS_LAND_SR: case BOTH_VS_LAND_G: return; default: break; } } PM_SetAnim(SETANIM_BOTH, Anim, iFlags, iBlend); } }

float PM_WalkableGroundDistance (  void   )

Definition at line 2008 of file bg_saber.c. References playerState_s::clientNum, trace_t::endpos, MASK_SOLID, pmove_t::maxs, MIN_WALK_NORMAL, pmove_t::mins, cplane_s::normal, playerState_s::origin, trace_t::plane, pm, pmove_t::ps, pmove_t::trace, vec3_t, VectorCopy, and VectorSubtract. { trace_t tr; vec3_t down; VectorCopy(pm->ps->origin, down); down[2] -= 4096; pm->trace(&tr, pm->ps->origin, pm->mins, pm->maxs, down, pm->ps->clientNum, MASK_SOLID); if ( tr.plane.normal[2] < MIN_WALK_NORMAL ) {//can't stand on this plane return 4096; } VectorSubtract(pm->ps->origin, tr.endpos, down); return VectorLength(down); }

qboolean PM_WalkingAnim (  int  anim  )

Definition at line 4580 of file bg_pmove.c. References BOTH_WALK1, BOTH_WALK2, BOTH_WALK5, BOTH_WALK6, BOTH_WALK7, BOTH_WALK_DUAL, BOTH_WALK_STAFF, BOTH_WALKBACK1, BOTH_WALKBACK2, BOTH_WALKBACK_DUAL, BOTH_WALKBACK_STAFF, qboolean, qfalse, and qtrue. Referenced by BG_SetAnimFinal(), and PM_WeaponLightsaber(). { switch ( anim ) { case BOTH_WALK1: //# Normal walk case BOTH_WALK2: //# Normal walk with saber case BOTH_WALK_STAFF: //# Normal walk with staff case BOTH_WALK_DUAL: //# Normal walk with staff case BOTH_WALK5: //# Tavion taunting Kyle (cin 22) case BOTH_WALK6: //# Slow walk for Luke (cin 12) case BOTH_WALK7: //# Fast walk case BOTH_WALKBACK1: //# Walk1 backwards case BOTH_WALKBACK2: //# Walk2 backwards case BOTH_WALKBACK_STAFF: //# Walk backwards with staff case BOTH_WALKBACK_DUAL: //# Walk backwards with dual return qtrue; break; } return qfalse; }

qboolean PM_WeaponOkOnVehicle (  int  weapon  )

Definition at line 9742 of file bg_pmove.c. References qboolean, qfalse, qtrue, WP_BLASTER, WP_MELEE, and WP_SABER. Referenced by PM_GetOkWeaponForVehicle(), and PmoveSingle(). { //FIXME: check g_vehicleInfo for our vehicle? switch ( weapon ) { //case WP_NONE: case WP_MELEE: case WP_SABER: case WP_BLASTER: //case WP_THERMAL: return qtrue; break; } return qfalse; }

void Pmove (  pmove_t *  pmove  )

Definition at line 11164 of file bg_pmove.c. References usercmd_s::buttons, pmove_t::cmd, playerState_s::commandTime, playerState_s::fallingToDeath, usercmd_s::forwardmove, playerState_s::pm_flags, PMF_JUMP_HELD, pmove_t::pmove_fixed, playerState_s::pmove_framecount, pmove_t::pmove_msec, PmoveSingle(), pmove_t::ps, PS_PMOVEFRAMECOUNTBITS, usercmd_s::rightmove, usercmd_s::serverTime, and usercmd_s::upmove. Referenced by CG_PredictPlayerState(), ClientThink_real(), and SpectatorThink(). { int finalTime; finalTime = pmove->cmd.serverTime; if ( finalTime < pmove->ps->commandTime ) { return; // should not happen } if ( finalTime > pmove->ps->commandTime + 1000 ) { pmove->ps->commandTime = finalTime - 1000; } if (pmove->ps->fallingToDeath) { pmove->cmd.forwardmove = 0; pmove->cmd.rightmove = 0; pmove->cmd.upmove = 0; pmove->cmd.buttons = 0; } pmove->ps->pmove_framecount = (pmove->ps->pmove_framecount+1) & ((1<<PS_PMOVEFRAMECOUNTBITS)-1); // chop the move up if it is too long, to prevent framerate // dependent behavior while ( pmove->ps->commandTime != finalTime ) { int msec; msec = finalTime - pmove->ps->commandTime; if ( pmove->pmove_fixed ) { if ( msec > pmove->pmove_msec ) { msec = pmove->pmove_msec; } } else { if ( msec > 66 ) { msec = 66; } } pmove->cmd.serverTime = pmove->ps->commandTime + msec; PmoveSingle( pmove ); if ( pmove->ps->pm_flags & PMF_JUMP_HELD ) { pmove->cmd.upmove = 20; } } }

void PmoveSingle (  pmove_t *  pmove  )

Definition at line 10171 of file bg_pmove.c. References abs(), AngleVectors(), vehicleInfo_t::Animate, vehicleInfo_t::AttachRiders, BG_AdjustClientSpeed(), BG_CmdForRoll(), BG_FighterUpdate(), BG_FullBodyTauntAnim(), BG_GetItemIndexByTag(), BG_InGrappleMove(), BG_InKataAnim(), BG_InRoll(), BG_KickingAnim(), BG_KickMove(), BG_SaberInKata(), BG_SaberLockBreakAnim(), BG_SpinningSaberAnim(), BG_VehicleAdjustBBoxForOrientation(), bgEntity_t, vehicleInfo_t::Board, BOTH_A2_STABBACK1, BOTH_ATTACK_BACK, BOTH_CROUCHATTACKBACK1, BOTH_FORCELAND1, BOTH_FORCELANDBACK1, BOTH_FORCELANDLEFT1, BOTH_FORCELANDRIGHT1, BOTH_FORCELEAP2_T__B_, BOTH_FORCEWALLRUNFLIP_ALT, BOTH_INAIR1, BOTH_INAIRBACK1, BOTH_INAIRLEFT1, BOTH_INAIRRIGHT1, BOTH_JUMPFLIPSLASHDOWN1, BOTH_JUMPFLIPSTABDOWN, BOTH_MEDITATE, BOTH_MEDITATE_END, BOTH_ROLL_STAB, BUTTON_ALT_ATTACK, BUTTON_ATTACK, BUTTON_FORCE_DRAIN, BUTTON_FORCE_LIGHTNING, BUTTON_FORCEGRIP, BUTTON_FORCEPOWER, BUTTON_TALK, BUTTON_USE_HOLDABLE, BUTTON_WALKING, usercmd_s::buttons, c_pmove, CG_TestLine(), CLASS_RANCOR, CLASS_VEHICLE, gentity_s::client, playerState_s::clientNum, clientPersistant_t::cmd, pmove_t::cmd, playerState_s::commandTime, CONTENTS_BODY, EF_ALT_FIRING, EF_DISINTEGRATION, EF_FIRING, EF_JETPACK_FLAMING, EF_NODRAW, EF_TALK, playerState_s::eFlags, playerState_s::emplacedIndex, ENTITYNUM_NONE, ENTITYNUM_WORLD, ET_NPC, entityState_s::eType, EV_WEAPON_CHARGE, playerState_s::fd, FLY_HOVER, FLY_NORMAL, FLY_VEHICLE, forcedata_s::forceGripCripple, playerState_s::forceHandExtend, playerState_s::forceHandExtendTime, forcedata_s::forceJumpZStart, forcedata_s::forcePowerSelected, forcedata_s::forcePowersKnown, usercmd_s::forcesel, pml_t::forward, usercmd_s::forwardmove, pml_t::frametime, gentity_t, bgEntity_s::ghoul2, gPMDoSlowFall, playerState_s::gravity, playerState_s::groundEntityNum, HANDEXTEND_TAUNT, playerState_s::heldByClient, HYPERSPACE_TIME, playerState_s::hyperSpaceTime, gentity_s::inuse, usercmd_s::invensel, IT_HOLDABLE, JETPACK_HOVER_HEIGHT, playerState_s::legsAnim, playerState_s::legsTimer, LS_A_BACK, LS_A_BACK_CR, LS_A_BACKSTAB, LS_A_FLIP_SLASH, LS_A_FLIP_STAB, LS_A_JUMP_T__B_, LS_A_LUNGE, LS_DUAL_FB, LS_DUAL_LR, LS_PULL_ATTACK_STAB, LS_PULL_ATTACK_SWING, LS_STABDOWN, LS_STABDOWN_DUAL, LS_STABDOWN_STAFF, Vehicle_s::m_fTimeModifier, Vehicle_s::m_iBoarding, Vehicle_s::m_iNumPassengers, playerState_s::m_iVehicleNum, Vehicle_s::m_pPilot, Vehicle_s::m_ppPassengers, bgEntity_s::m_pVehicle, Vehicle_s::m_pVehicleInfo, Vehicle_s::m_ucmd, Vehicle_s::m_ulFlags, Vehicle_s::m_vOrientation, Vehicle_s::m_vPrevOrientation, MAX_CLIENTS, pmove_t::maxs, memset(), pmove_t::mins, playerState_s::moveDir, pml_t::msec, pmove_t::noSpecMove, entityState_s::NPC_class, NULL, entityState_s::number, pmove_t::numtouch, playerState_s::origin, gclient_s::pers, PITCH, bgEntity_s::playerState, pm, PM_AddEventWithParm(), PM_AdjustAngleForWallJump(), PM_AdjustAngleForWallRun(), PM_AdjustAngleForWallRunUp(), PM_AdjustAnglesForWallRunUpFlipAlt(), PM_AdjustAttackStates(), PM_BGEntForNum(), pm_cancelOutZoom, PM_ContinueLegsAnim(), PM_DEAD, PM_DoSlowFall(), pm_entSelf, pm_entVeh, playerState_s::pm_flags, PM_FLOAT, PM_FREEZE, PM_GetOkWeaponForVehicle(), PM_GroundDistance(), PM_HoverTrace(), PM_INTERMISSION, PM_IsRocketTrooper(), PM_JETPACK, PM_MoveForKata(), PM_NOCLIP, PM_SetAnim(), PM_SetPMViewAngle(), PM_SetSpecialMoveValues(), PM_SPECTATOR, PM_SPINTERMISSION, playerState_s::pm_type, PM_UpdateViewAngles(), PM_Use(), PM_VehFaceHyperspacePoint(), PM_VehForcedTurning(), PM_VehicleViewAngles(), PM_VehicleWeaponAnimate(), PM_WeaponOkOnVehicle(), PMF_BACKWARDS_RUN, PMF_JUMP_HELD, PMF_RESPAWNED, PMF_STUCK_TO_WALL, PMF_TIME_WATERJUMP, pml, pml_t::previous_origin, pml_t::previous_velocity, pml_t::previous_waterlevel, vehicleInfo_t::ProcessMoveCommands, vehicleInfo_t::ProcessOrientCommands, gclient_s::ps, pmove_t::ps, Q_irand(), qboolean, qfalse, qtrue, pml_t::right, usercmd_s::rightmove, ROLL, bgEntity_s::s, playerState_s::saberHolstered, playerState_s::saberLockTime, playerState_s::saberMove, usercmd_s::serverTime, SETANIM_BOTH, SETANIM_FLAG_HOLD, SETANIM_FLAG_OVERRIDE, gentity_s::spawnflags, playerState_s::speed, STAT_HEALTH, STAT_HOLDABLE_ITEM, STAT_HOLDABLE_ITEMS, playerState_s::stats, playerState_s::torsoAnim, playerState_s::torsoTimer, pmove_t::trace, pmove_t::tracemask, trap_SnapVector(), vehicleInfo_t::type, pml_t::up, vehicleInfo_t::Update, vehicleInfo_t::UpdateRider, usercmd_s::upmove, vec3_t, VectorCopy, VectorMA, VectorScale, VectorSet, VEH_CRASHING, playerState_s::vehBoarding, playerState_s::vehTurnaroundIndex, playerState_s::vehTurnaroundTime, playerState_s::velocity, VH_ANIMAL, VH_FIGHTER, VH_WALKER, playerState_s::viewangles, pml_t::walking, pmove_t::waterlevel, pmove_t::watertype, usercmd_s::weapon, playerState_s::weapon, WEAPON_CHARGING_ALT, WEAPON_READY, playerState_s::weaponstate, playerState_s::weaponTime, WP_DISRUPTOR, WP_SABER, YAW, playerState_s::zoomLocked, and playerState_s::zoomMode. Referenced by Pmove(). { qboolean stiffenedUp = qfalse; float gDist = 0; qboolean noAnimate = qfalse; int savedGravity = 0; pm = pmove; if (pm->ps->emplacedIndex) { if (pm->cmd.buttons & BUTTON_ALT_ATTACK) { //hackerrific. pm->cmd.buttons &= ~BUTTON_ALT_ATTACK; pm->cmd.buttons |= BUTTON_ATTACK; } } //set up these "global" bg ents pm_entSelf = PM_BGEntForNum(pm->ps->clientNum); if (pm->ps->m_iVehicleNum) { if (pm->ps->clientNum < MAX_CLIENTS) { //player riding vehicle pm_entVeh = PM_BGEntForNum(pm->ps->m_iVehicleNum); } else { //vehicle with player pilot pm_entVeh = PM_BGEntForNum(pm->ps->m_iVehicleNum-1); } } else { //no vehicle ent pm_entVeh = NULL; } gPMDoSlowFall = PM_DoSlowFall(); // this counter lets us debug movement problems with a journal // by setting a conditional breakpoint fot the previous frame c_pmove++; // clear results pm->numtouch = 0; pm->watertype = 0; pm->waterlevel = 0; if (PM_IsRocketTrooper()) { //kind of nasty, don't let them crouch or anything if nonhumanoid (probably a rockettrooper) if (pm->cmd.upmove < 0) { pm->cmd.upmove = 0; } } if (pm->ps->pm_type == PM_FLOAT) { //You get no control over where you go in grip movement stiffenedUp = qtrue; } else if (pm->ps->eFlags & EF_DISINTEGRATION) { stiffenedUp = qtrue; } else if ( BG_SaberLockBreakAnim( pm->ps->legsAnim ) || BG_SaberLockBreakAnim( pm->ps->torsoAnim ) || pm->ps->saberLockTime >= pm->cmd.serverTime ) {//can't move or turn stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } else if ( pm->ps->saberMove == LS_A_BACK || pm->ps->saberMove == LS_A_BACK_CR || pm->ps->saberMove == LS_A_BACKSTAB || pm->ps->saberMove == LS_A_FLIP_STAB || pm->ps->saberMove == LS_A_FLIP_SLASH || pm->ps->saberMove == LS_A_JUMP_T__B_ || pm->ps->saberMove == LS_DUAL_LR || pm->ps->saberMove == LS_DUAL_FB) { if (pm->ps->legsAnim == BOTH_JUMPFLIPSTABDOWN || pm->ps->legsAnim == BOTH_JUMPFLIPSLASHDOWN1) { //flipover medium stance attack if (pm->ps->legsTimer < 1600 && pm->ps->legsTimer > 900) { pm->ps->viewangles[YAW] += pml.frametime*240.0f; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } } stiffenedUp = qtrue; } else if ((pm->ps->legsAnim) == (BOTH_A2_STABBACK1) || (pm->ps->legsAnim) == (BOTH_ATTACK_BACK) || (pm->ps->legsAnim) == (BOTH_CROUCHATTACKBACK1) || (pm->ps->legsAnim) == (BOTH_FORCELEAP2_T__B_) || (pm->ps->legsAnim) == (BOTH_JUMPFLIPSTABDOWN) || (pm->ps->legsAnim) == (BOTH_JUMPFLIPSLASHDOWN1)) { stiffenedUp = qtrue; } else if (pm->ps->legsAnim == BOTH_ROLL_STAB) { stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } else if (pm->ps->heldByClient) { stiffenedUp = qtrue; } else if (BG_KickMove(pm->ps->saberMove) || BG_KickingAnim(pm->ps->legsAnim)) { stiffenedUp = qtrue; } else if (BG_InGrappleMove(pm->ps->torsoAnim)) { stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } else if ( pm->ps->saberMove == LS_STABDOWN_DUAL || pm->ps->saberMove == LS_STABDOWN_STAFF || pm->ps->saberMove == LS_STABDOWN) {//FIXME: need to only move forward until we bump into our target...? if (pm->ps->legsTimer < 800) { //freeze movement near end of anim stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } else { //force forward til then pm->cmd.rightmove = 0; pm->cmd.upmove = 0; pm->cmd.forwardmove = 64; } } else if (pm->ps->saberMove == LS_PULL_ATTACK_STAB || pm->ps->saberMove == LS_PULL_ATTACK_SWING) { stiffenedUp = qtrue; } else if (BG_SaberInKata(pm->ps->saberMove) || BG_InKataAnim(pm->ps->torsoAnim) || BG_InKataAnim(pm->ps->legsAnim)) { PM_MoveForKata(&pm->cmd); } else if ( BG_FullBodyTauntAnim( pm->ps->legsAnim ) && BG_FullBodyTauntAnim( pm->ps->torsoAnim ) ) { if ( (pm->cmd.buttons&BUTTON_ATTACK) || (pm->cmd.buttons&BUTTON_ALT_ATTACK) || (pm->cmd.buttons&BUTTON_FORCEPOWER) || (pm->cmd.buttons&BUTTON_FORCEGRIP) || (pm->cmd.buttons&BUTTON_FORCE_LIGHTNING) || (pm->cmd.buttons&BUTTON_FORCE_DRAIN) || pm->cmd.upmove ) {//stop the anim if ( pm->ps->legsAnim == BOTH_MEDITATE && pm->ps->torsoAnim == BOTH_MEDITATE ) { PM_SetAnim( SETANIM_BOTH, BOTH_MEDITATE_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD, 0 ); } else { pm->ps->legsTimer = pm->ps->torsoTimer = 0; } if ( pm->ps->forceHandExtend == HANDEXTEND_TAUNT ) { pm->ps->forceHandExtend = 0; } } else { if ( pm->ps->legsAnim == BOTH_MEDITATE ) { if ( pm->ps->legsTimer < 100 ) { pm->ps->legsTimer = 100; } } if ( pm->ps->torsoAnim == BOTH_MEDITATE ) { if ( pm->ps->torsoTimer < 100 ) { pm->ps->legsTimer = 100; } pm->ps->forceHandExtend = HANDEXTEND_TAUNT; pm->ps->forceHandExtendTime = pm->cmd.serverTime + 100; } if ( pm->ps->legsTimer > 0 || pm->ps->torsoTimer > 0 ) { stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); pm->cmd.rightmove = 0; pm->cmd.upmove = 0; pm->cmd.forwardmove = 0; pm->cmd.buttons = 0; } } } else if ( pm->ps->legsAnim == BOTH_MEDITATE_END && pm->ps->legsTimer > 0 ) { stiffenedUp = qtrue; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); pm->cmd.rightmove = 0; pm->cmd.upmove = 0; pm->cmd.forwardmove = 0; pm->cmd.buttons = 0; } else if (pm->ps->legsAnim == BOTH_FORCELAND1 || pm->ps->legsAnim == BOTH_FORCELANDBACK1 || pm->ps->legsAnim == BOTH_FORCELANDRIGHT1 || pm->ps->legsAnim == BOTH_FORCELANDLEFT1) { //can't move while in a force land stiffenedUp = qtrue; } if ( pm->ps->saberMove == LS_A_LUNGE ) {//can't move during lunge pm->cmd.rightmove = pm->cmd.upmove = 0; if ( pm->ps->legsTimer > 500 ) { pm->cmd.forwardmove = 127; } else { pm->cmd.forwardmove = 0; } } if ( pm->ps->saberMove == LS_A_JUMP_T__B_ ) {//can't move during leap if ( pm->ps->groundEntityNum != ENTITYNUM_NONE ) {//hit the ground pm->cmd.forwardmove = 0; } pm->cmd.rightmove = pm->cmd.upmove = 0; } #if 0 if ((pm->ps->legsAnim) == BOTH_KISSER1LOOP || (pm->ps->legsAnim) == BOTH_KISSEE1LOOP) { stiffenedUp = qtrue; } #endif if (pm->ps->emplacedIndex) { if (pm->cmd.forwardmove < 0 || PM_GroundDistance() > 32.0f) { pm->ps->emplacedIndex = 0; pm->ps->saberHolstered = 0; } else { stiffenedUp = qtrue; } } /* if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_CHARGING_ALT) { //not allowed to move while charging the disruptor pm->cmd.forwardmove = 0; pm->cmd.rightmove = 0; if (pm->cmd.upmove > 0) { pm->cmd.upmove = 0; } } */ if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->weaponstate == WEAPON_CHARGING_ALT) { //not allowed to move while charging the disruptor if (pm->cmd.forwardmove || pm->cmd.rightmove || pm->cmd.upmove > 0) { //get out pm->ps->weaponstate = WEAPON_READY; pm->ps->weaponTime = 1000; PM_AddEventWithParm(EV_WEAPON_CHARGE, WP_DISRUPTOR); //cut the weapon charge sound pm->cmd.upmove = 0; } } else if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1) { //can't jump if (pm->cmd.upmove > 0) { pm->cmd.upmove = 0; } } if (stiffenedUp) { pm->cmd.forwardmove = 0; pm->cmd.rightmove = 0; pm->cmd.upmove = 0; } if (pm->ps->fd.forceGripCripple) { //don't let attack or alt attack if being gripped I guess pm->cmd.buttons &= ~BUTTON_ATTACK; pm->cmd.buttons &= ~BUTTON_ALT_ATTACK; } if ( BG_InRoll( pm->ps, pm->ps->legsAnim ) ) { //can't roll unless you're able to move normally BG_CmdForRoll( pm->ps, pm->ps->legsAnim, &pm->cmd ); } PM_CmdForSaberMoves(&pm->cmd); BG_AdjustClientSpeed(pm->ps, &pm->cmd, pm->cmd.serverTime); if ( pm->ps->stats[STAT_HEALTH] <= 0 ) { pm->tracemask &= ~CONTENTS_BODY; // corpses can fly through bodies } // make sure walking button is clear if they are running, to avoid // proxy no-footsteps cheats if ( abs( pm->cmd.forwardmove ) > 64 || abs( pm->cmd.rightmove ) > 64 ) { pm->cmd.buttons &= ~BUTTON_WALKING; } // set the talk balloon flag if ( pm->cmd.buttons & BUTTON_TALK ) { pm->ps->eFlags |= EF_TALK; } else { pm->ps->eFlags &= ~EF_TALK; } pm_cancelOutZoom = qfalse; if (pm->ps->weapon == WP_DISRUPTOR && pm->ps->zoomMode == 1) { if ((pm->cmd.buttons & BUTTON_ALT_ATTACK) && !(pm->cmd.buttons & BUTTON_ATTACK) && pm->ps->zoomLocked) { pm_cancelOutZoom = qtrue; } } // In certain situations, we may want to control which attack buttons are pressed and what kind of functionality // is attached to them PM_AdjustAttackStates( pm ); // clear the respawned flag if attack and use are cleared if ( pm->ps->stats[STAT_HEALTH] > 0 && !( pm->cmd.buttons & (BUTTON_ATTACK | BUTTON_USE_HOLDABLE) ) ) { pm->ps->pm_flags &= ~PMF_RESPAWNED; } // if talk button is down, dissallow all other input // this is to prevent any possible intercept proxy from // adding fake talk balloons if ( pmove->cmd.buttons & BUTTON_TALK ) { // keep the talk button set tho for when the cmd.serverTime > 66 msec // and the same cmd is used multiple times in Pmove pmove->cmd.buttons = BUTTON_TALK; pmove->cmd.forwardmove = 0; pmove->cmd.rightmove = 0; pmove->cmd.upmove = 0; } // clear all pmove local vars memset (&pml, 0, sizeof(pml)); // determine the time pml.msec = pmove->cmd.serverTime - pm->ps->commandTime; if ( pml.msec < 1 ) { pml.msec = 1; } else if ( pml.msec > 200 ) { pml.msec = 200; } /* if (pm->ps->clientNum >= MAX_CLIENTS) { #ifdef QAGAME Com_Printf( "^1 SERVER N%i msec %d\n", pm->ps->clientNum, pml.msec ); #else Com_Printf( "^2 CLIENT N%i msec %d\n", pm->ps->clientNum, pml.msec ); #endif } */ pm->ps->commandTime = pmove->cmd.serverTime; // save old org in case we get stuck VectorCopy (pm->ps->origin, pml.previous_origin); // save old velocity for crashlanding VectorCopy (pm->ps->velocity, pml.previous_velocity); pml.frametime = pml.msec * 0.001; if (pm->ps->clientNum >= MAX_CLIENTS && pm_entSelf && pm_entSelf->s.NPC_class == CLASS_VEHICLE) { //we are a vehicle bgEntity_t *veh = pm_entSelf; assert( veh && veh->m_pVehicle); if ( veh && veh->m_pVehicle ) { veh->m_pVehicle->m_fTimeModifier = pml.frametime*60.0f; } } else if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE &&pm->ps->m_iVehicleNum) { bgEntity_t *veh = pm_entVeh; if (veh && veh->playerState && (pm->cmd.serverTime-veh->playerState->hyperSpaceTime) < HYPERSPACE_TIME) { //going into hyperspace, turn to face the right angles PM_VehFaceHyperspacePoint(veh); } else if (veh && veh->playerState && veh->playerState->vehTurnaroundIndex && veh->playerState->vehTurnaroundTime > pm->cmd.serverTime) { //riding this vehicle, turn my view too PM_VehForcedTurning(veh); } } if ( pm->ps->legsAnim == BOTH_FORCEWALLRUNFLIP_ALT && pm->ps->legsTimer > 0 ) { vec3_t vFwd, fwdAng; VectorSet(fwdAng, 0.0f, pm->ps->viewangles[YAW], 0.0f); AngleVectors( fwdAng, vFwd, NULL, NULL ); if ( pm->ps->groundEntityNum == ENTITYNUM_NONE ) { float savZ = pm->ps->velocity[2]; VectorScale( vFwd, 100, pm->ps->velocity ); pm->ps->velocity[2] = savZ; } pm->cmd.forwardmove = pm->cmd.rightmove = pm->cmd.upmove = 0; PM_AdjustAnglesForWallRunUpFlipAlt( &pm->cmd ); } // PM_AdjustAngleForWallRun(pm->ps, &pm->cmd, qtrue); // PM_AdjustAnglesForStabDown( pm->ps, &pm->cmd ); PM_AdjustAngleForWallJump( pm->ps, &pm->cmd, qtrue ); PM_AdjustAngleForWallRunUp( pm->ps, &pm->cmd, qtrue ); PM_AdjustAngleForWallRun( pm->ps, &pm->cmd, qtrue ); if (pm->ps->saberMove == LS_A_JUMP_T__B_ || pm->ps->saberMove == LS_A_LUNGE || pm->ps->saberMove == LS_A_BACK_CR || pm->ps->saberMove == LS_A_BACK || pm->ps->saberMove == LS_A_BACKSTAB) { PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } #if 0 if ((pm->ps->legsAnim) == BOTH_KISSER1LOOP || (pm->ps->legsAnim) == BOTH_KISSEE1LOOP) { pm->ps->viewangles[PITCH] = 0; PM_SetPMViewAngle(pm->ps, pm->ps->viewangles, &pm->cmd); } #endif PM_SetSpecialMoveValues(); // update the viewangles PM_UpdateViewAngles( pm->ps, &pm->cmd ); AngleVectors (pm->ps->viewangles, pml.forward, pml.right, pml.up); if ( pm->cmd.upmove < 10 && !(pm->ps->pm_flags & PMF_STUCK_TO_WALL)) { // not holding jump pm->ps->pm_flags &= ~PMF_JUMP_HELD; } // decide if backpedaling animations should be used if ( pm->cmd.forwardmove < 0 ) { pm->ps->pm_flags |= PMF_BACKWARDS_RUN; } else if ( pm->cmd.forwardmove > 0 || ( pm->cmd.forwardmove == 0 && pm->cmd.rightmove ) ) { pm->ps->pm_flags &= ~PMF_BACKWARDS_RUN; } if ( pm->ps->pm_type >= PM_DEAD ) { pm->cmd.forwardmove = 0; pm->cmd.rightmove = 0; pm->cmd.upmove = 0; } /* if (pm->ps->fd.saberAnimLevel == SS_STAFF && (pm->cmd.buttons & BUTTON_ALT_ATTACK) && pm->cmd.upmove > 0) { //this is how you do kick-for-condition pm->cmd.upmove = 0; pm->ps->pm_flags |= PMF_JUMP_HELD; } */ if (pm->ps->saberLockTime >= pm->cmd.serverTime) { pm->cmd.upmove = 0; pm->cmd.forwardmove = 0;//50; pm->cmd.rightmove = 0;//*= 0.1; } if ( pm->ps->pm_type == PM_SPECTATOR ) { PM_CheckDuck (); if (!pm->noSpecMove) { PM_FlyMove (); } PM_DropTimers (); return; } if ( pm->ps->pm_type == PM_NOCLIP ) { if (pm->ps->clientNum < MAX_CLIENTS) { PM_NoclipMove (); PM_DropTimers (); return; } } if (pm->ps->pm_type == PM_FREEZE) { return; // no movement at all } if ( pm->ps->pm_type == PM_INTERMISSION || pm->ps->pm_type == PM_SPINTERMISSION) { return; // no movement at all } // set watertype, and waterlevel PM_SetWaterLevel(); pml.previous_waterlevel = pmove->waterlevel; // set mins, maxs, and viewheight PM_CheckDuck (); if (pm->ps->pm_type == PM_JETPACK) { gDist = PM_GroundDistance(); savedGravity = pm->ps->gravity; if (gDist < JETPACK_HOVER_HEIGHT+64) { pm->ps->gravity *= 0.1f; } else { pm->ps->gravity *= 0.25f; } } else if (gPMDoSlowFall) { savedGravity = pm->ps->gravity; pm->ps->gravity *= 0.5; } //if we're in jetpack mode then see if we should be jetting around if (pm->ps->pm_type == PM_JETPACK) { if (pm->cmd.rightmove > 0) { PM_ContinueLegsAnim(BOTH_INAIRRIGHT1); } else if (pm->cmd.rightmove < 0) { PM_ContinueLegsAnim(BOTH_INAIRLEFT1); } else if (pm->cmd.forwardmove > 0) { PM_ContinueLegsAnim(BOTH_INAIR1); } else if (pm->cmd.forwardmove < 0) { PM_ContinueLegsAnim(BOTH_INAIRBACK1); } else { PM_ContinueLegsAnim(BOTH_INAIR1); } if (pm->ps->weapon == WP_SABER && BG_SpinningSaberAnim( pm->ps->legsAnim )) { //make him stir around since he shouldn't have any real control when spinning pm->ps->velocity[0] += Q_irand(-100, 100); pm->ps->velocity[1] += Q_irand(-100, 100); } if (pm->cmd.upmove > 0 && pm->ps->velocity[2] < 256) { //cap upward velocity off at 256. Seems reasonable. float addIn = 12.0f; /* //Add based on our distance to the ground if we're already travelling upward if (pm->ps->velocity[2] > 0) { while (gDist > 64) { //subtract 1 for every 64 units off the ground we get addIn--; gDist -= 64; if (addIn <= 0) { //break out if we're not even going to add anything break; } } } */ if (pm->ps->velocity[2] > 0) { addIn = 12.0f - (gDist / 64.0f); } if (addIn > 0.0f) { pm->ps->velocity[2] += addIn; } pm->ps->eFlags |= EF_JETPACK_FLAMING; //going up } else { pm->ps->eFlags &= ~EF_JETPACK_FLAMING; //idling if (pm->ps->velocity[2] < 256) { if (pm->ps->velocity[2] < -100) { pm->ps->velocity[2] = -100; } if (gDist < JETPACK_HOVER_HEIGHT) { //make sure we're always hovering off the ground somewhat while jetpack is active pm->ps->velocity[2] += 2; } } } } if (pm->ps->clientNum >= MAX_CLIENTS && pm_entSelf && pm_entSelf->m_pVehicle) { //Now update our mins/maxs to match our m_vOrientation based on our length, width & height BG_VehicleAdjustBBoxForOrientation( pm_entSelf->m_pVehicle, pm->ps->origin, pm->mins, pm->maxs, pm->ps->clientNum, pm->tracemask, pm->trace ); } // set groundentity PM_GroundTrace(); if ( pm_flying == FLY_HOVER ) {//never stick to the ground PM_HoverTrace(); } if ( pm->ps->groundEntityNum != ENTITYNUM_NONE ) {//on ground pm->ps->fd.forceJumpZStart = 0; } if ( pm->ps->pm_type == PM_DEAD ) { if (pm->ps->clientNum >= MAX_CLIENTS && pm_entSelf && pm_entSelf->s.NPC_class == CLASS_VEHICLE && pm_entSelf->m_pVehicle->m_pVehicleInfo->type != VH_ANIMAL) {//vehicles don't use deadmove } else { PM_DeadMove (); } } PM_DropTimers(); #ifdef _TESTING_VEH_PREDICTION #ifndef QAGAME { vec3_t blah; VectorMA(pm->ps->origin, 128.0f, pm->ps->moveDir, blah); CG_TestLine(pm->ps->origin, blah, 1, 0x0000ff, 1); VectorMA(pm->ps->origin, 1.0f, pm->ps->velocity, blah); CG_TestLine(pm->ps->origin, blah, 1, 0xff0000, 1); } #endif #endif if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE &&pm->ps->m_iVehicleNum) { //a player riding a vehicle bgEntity_t *veh = pm_entVeh; if ( veh && veh->m_pVehicle && (veh->m_pVehicle->m_pVehicleInfo->type == VH_WALKER || veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) ) {//*sigh*, until we get forced weapon-switching working? pm->cmd.buttons &= ~(BUTTON_ATTACK|BUTTON_ALT_ATTACK); pm->ps->eFlags &= ~(EF_FIRING|EF_ALT_FIRING); //pm->cmd.weapon = pm->ps->weapon; } } if (!pm->ps->m_iVehicleNum && pm_entSelf->s.NPC_class!=CLASS_VEHICLE&& pm_entSelf->s.NPC_class!=CLASS_RANCOR&& pm->ps->groundEntityNum < ENTITYNUM_WORLD && pm->ps->groundEntityNum >= MAX_CLIENTS) { //I am a player client, not riding on a vehicle, and potentially standing on an NPC bgEntity_t *pEnt = PM_BGEntForNum(pm->ps->groundEntityNum); if (pEnt && pEnt->s.eType == ET_NPC && pEnt->s.NPC_class != CLASS_VEHICLE) //don't bounce on vehicles { //this is actually an NPC, let's try to bounce of its head to make sure we can't just stand around on top of it. if (pm->ps->velocity[2] < 270) { //try forcing velocity up and also force him to jump pm->ps->velocity[2] = 270; //seems reasonable pm->cmd.upmove = 127; } } #ifdef QAGAME else if ( !pm->ps->zoomMode && pm_entSelf //I exist && pEnt->m_pVehicle )//ent has a vehicle { gentity_t *gEnt = (gentity_t*)pEnt; if ( gEnt->client && !gEnt->client->ps.m_iVehicleNum //vehicle is empty && (gEnt->spawnflags&2) )//SUSPENDED {//it's a vehicle, see if we should get in it //if land on an empty, suspended vehicle, get in it pEnt->m_pVehicle->m_pVehicleInfo->Board( pEnt->m_pVehicle, (bgEntity_t *)pm_entSelf ); } } #endif } if (pm->ps->clientNum >= MAX_CLIENTS && pm_entSelf && pm_entSelf->s.NPC_class == CLASS_VEHICLE) { //we are a vehicle bgEntity_t *veh = pm_entSelf; assert(veh && veh->playerState && veh->m_pVehicle && veh->s.number >= MAX_CLIENTS); if (veh->m_pVehicle->m_pVehicleInfo->type != VH_FIGHTER) { //kind of hacky, don't want to do this for flying vehicles veh->m_pVehicle->m_vOrientation[PITCH] = pm->ps->viewangles[PITCH]; } if (!pm->ps->m_iVehicleNum) { //no one is driving, just update and get out #ifdef QAGAME veh->m_pVehicle->m_pVehicleInfo->Update(veh->m_pVehicle, &pm->cmd); veh->m_pVehicle->m_pVehicleInfo->Animate(veh->m_pVehicle); #endif } else { bgEntity_t *self = pm_entVeh; #ifdef QAGAME int i = 0; #endif assert(self && self->playerState && self->s.number < MAX_CLIENTS); if (pm->ps->pm_type == PM_DEAD && (veh->m_pVehicle->m_ulFlags & VEH_CRASHING)) { veh->m_pVehicle->m_ulFlags &= ~VEH_CRASHING; } if (self->playerState->m_iVehicleNum) { //only do it if they still have a vehicle (didn't get ejected this update or something) PM_VehicleViewAngles(self->playerState, veh, &veh->m_pVehicle->m_ucmd); } #ifdef QAGAME veh->m_pVehicle->m_pVehicleInfo->Update(veh->m_pVehicle, &veh->m_pVehicle->m_ucmd); veh->m_pVehicle->m_pVehicleInfo->Animate(veh->m_pVehicle); veh->m_pVehicle->m_pVehicleInfo->UpdateRider(veh->m_pVehicle, self, &veh->m_pVehicle->m_ucmd); //update the passengers while (i < veh->m_pVehicle->m_iNumPassengers) { if (veh->m_pVehicle->m_ppPassengers[i]) { gentity_t *thePassenger = (gentity_t *)veh->m_pVehicle->m_ppPassengers[i]; //yes, this is, in fact, ass. if (thePassenger->inuse && thePassenger->client) { veh->m_pVehicle->m_pVehicleInfo->UpdateRider(veh->m_pVehicle, veh->m_pVehicle->m_ppPassengers[i], &thePassenger->client->pers.cmd); } } i++; } #else if (!veh->playerState->vehBoarding )//|| veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) { if (veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER) { //client must explicitly call this for prediction BG_FighterUpdate(veh->m_pVehicle, &veh->m_pVehicle->m_ucmd, pm->mins, pm->maxs, self->playerState->gravity, pm->trace); } if (veh->m_pVehicle->m_iBoarding == 0) { vec3_t vRollAng; //make sure we are set as its pilot cgame side veh->m_pVehicle->m_pPilot = self; // Keep track of the old orientation. VectorCopy( veh->m_pVehicle->m_vOrientation, veh->m_pVehicle->m_vPrevOrientation ); veh->m_pVehicle->m_pVehicleInfo->ProcessOrientCommands(veh->m_pVehicle); PM_SetPMViewAngle(veh->playerState, veh->m_pVehicle->m_vOrientation, &veh->m_pVehicle->m_ucmd); veh->m_pVehicle->m_pVehicleInfo->ProcessMoveCommands(veh->m_pVehicle); vRollAng[YAW] = self->playerState->viewangles[YAW]; vRollAng[PITCH] = self->playerState->viewangles[PITCH]; vRollAng[ROLL] = veh->m_pVehicle->m_vOrientation[ROLL]; PM_SetPMViewAngle(self->playerState, vRollAng, &pm->cmd); // Setup the move direction. if ( veh->m_pVehicle->m_pVehicleInfo->type == VH_FIGHTER ) { AngleVectors( veh->m_pVehicle->m_vOrientation, veh->playerState->moveDir, NULL, NULL ); } else { vec3_t vVehAngles; VectorSet(vVehAngles, 0, veh->m_pVehicle->m_vOrientation[YAW], 0); AngleVectors( vVehAngles, veh->playerState->moveDir, NULL, NULL ); } } } /* else { veh->playerState->speed = 0.0f; PM_SetPMViewAngle(self->playerState, veh->playerState->viewangles, &veh->m_pVehicle->m_ucmd); } */ else if (veh->playerState) { veh->playerState->speed = 0.0f; if (veh->m_pVehicle) { PM_SetPMViewAngle(self->playerState, veh->m_pVehicle->m_vOrientation, &pm->cmd); PM_SetPMViewAngle(veh->playerState, veh->m_pVehicle->m_vOrientation, &pm->cmd); } } #endif } noAnimate = qtrue; } if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE &&pm->ps->m_iVehicleNum) {//don't even run physics on a player if he's on a vehicle - he goes where the vehicle goes } else { //don't even run physics on a player if he's on a vehicle - he goes where the vehicle goes if (pm->ps->pm_type == PM_FLOAT ||pm_flying == FLY_NORMAL) { PM_FlyMove (); } else if ( pm_flying == FLY_VEHICLE ) { PM_FlyVehicleMove(); } else { if (pm->ps->pm_flags & PMF_TIME_WATERJUMP) { PM_WaterJumpMove(); } else if ( pm->waterlevel > 1 ) { // swimming PM_WaterMove(); } else if ( pml.walking ) { // walking on ground PM_WalkMove(); } else { // airborne PM_AirMove(); } } } if (!noAnimate) { PM_Animate(); } // set groundentity, watertype, and waterlevel PM_GroundTrace(); if ( pm_flying == FLY_HOVER ) {//never stick to the ground PM_HoverTrace(); } PM_SetWaterLevel(); if (pm->cmd.forcesel != -1 && (pm->ps->fd.forcePowersKnown & (1 << pm->cmd.forcesel))) { pm->ps->fd.forcePowerSelected = pm->cmd.forcesel; } if (pm->cmd.invensel != -1 && (pm->ps->stats[STAT_HOLDABLE_ITEMS] & (1 << pm->cmd.invensel))) { pm->ps->stats[STAT_HOLDABLE_ITEM] = BG_GetItemIndexByTag(pm->cmd.invensel, IT_HOLDABLE); } if (pm->ps->m_iVehicleNum /*&&pm_entSelf->s.NPC_class!=CLASS_VEHICLE*/ && pm->ps->clientNum < MAX_CLIENTS) {//a client riding a vehicle if ( (pm->ps->eFlags&EF_NODRAW) ) {//inside the vehicle, do nothing } else if (!PM_WeaponOkOnVehicle(pm->cmd.weapon) || !PM_WeaponOkOnVehicle(pm->ps->weapon)) { //this weapon is not legal for the vehicle, force to our current one if (!PM_WeaponOkOnVehicle(pm->ps->weapon)) { //uh-oh! int weap = PM_GetOkWeaponForVehicle(); if (weap != -1) { pm->cmd.weapon = weap; pm->ps->weapon = weap; } } else { pm->cmd.weapon = pm->ps->weapon; } } } if (!pm->ps->m_iVehicleNum //not a vehicle and not riding one || pm_entSelf->s.NPC_class==CLASS_VEHICLE //you are a vehicle NPC || (!(pm->ps->eFlags&EF_NODRAW)&&PM_WeaponOkOnVehicle(pm->cmd.weapon)) )//you're not inside the vehicle and the weapon you're holding can be used when riding this vehicle { //only run weapons if a valid weapon is selected // weapons PM_Weapon(); } PM_Use(); if (!pm->ps->m_iVehicleNum && (pm->ps->clientNum < MAX_CLIENTS || !pm_entSelf || pm_entSelf->s.NPC_class != CLASS_VEHICLE)) { //don't do this if we're on a vehicle, or we are one // footstep events / legs animations PM_Footsteps(); } // entering / leaving water splashes PM_WaterEvents(); // snap some parts of playerstate to save network bandwidth trap_SnapVector( pm->ps->velocity ); if (pm->ps->pm_type == PM_JETPACK || gPMDoSlowFall ) { pm->ps->gravity = savedGravity; } if (//pm->ps->m_iVehicleNum && pm->ps->clientNum >= MAX_CLIENTS && pm_entSelf && pm_entSelf->s.NPC_class == CLASS_VEHICLE) { //a vehicle with passengers bgEntity_t *veh; veh = pm_entSelf; assert(veh->m_pVehicle); //this could be kind of "inefficient" because it's called after every passenger pmove too. //Maybe instead of AttachRiders we should have each rider call attach for himself? if (veh->m_pVehicle && veh->ghoul2) { veh->m_pVehicle->m_pVehicleInfo->AttachRiders( veh->m_pVehicle ); } } if (pm_entSelf->s.NPC_class!=CLASS_VEHICLE && pm->ps->m_iVehicleNum) { //riding a vehicle, see if we should do some anim overrides PM_VehicleWeaponAnimate(); } }

void trap_SnapVector (  float *  v  )

Definition at line 579 of file cg_syscalls.c. { syscall( CG_SNAPVECTOR, v ); }

---

Variable Documentation

vmCvar_t bg_fighterAltControl

Definition at line 7784 of file bg_pmove.c.

int c_pmove = 0

Definition at line 57 of file bg_pmove.c. Referenced by PM_StepSlideMove(), and PmoveSingle().

vmCvar_t cg_paused

Definition at line 638 of file bg_pmove.c.

float forceJumpHeight[NUM_FORCE_POWER_LEVELS]

Initial value: { 32, 96, 192, 384 } Definition at line 155 of file bg_pmove.c.

float forceJumpHeightMax[NUM_FORCE_POWER_LEVELS]

Initial value: { 66, 130, 226, 418 } Definition at line 1768 of file bg_pmove.c.

float forceJumpStrength[NUM_FORCE_POWER_LEVELS]

Initial value: { JUMP_VELOCITY, 420, 590, 840 } Definition at line 163 of file bg_pmove.c. Referenced by ForceJump(), ForceJumpCharge(), Jedi_CheckFlipEvasions(), and WPConstantRoutine().

int forcePowerNeeded[NUM_FORCE_POWER_LEVELS][NUM_FORCE_POWERS]

Definition at line 67 of file bg_pmove.c.

float forceSpeedLevels[4]

Initial value: { 1, 1.25, 1.5, 1.75 } Definition at line 59 of file bg_pmove.c.

qboolean gPMDoSlowFall = qfalse

Definition at line 36 of file bg_pmove.c. Referenced by PmoveSingle().

pmove_t* pm

Definition at line 30 of file bg_pmove.c. Referenced by AnimateRiders(), BG_AdjustClientSpeed(), BG_EnoughForcePowerForMove(), BG_VehTraceFromCamPos(), ClientImpacts(), ClientThink_real(), G_SetAnim(), PM_AddEvent(), PM_AddEventWithParm(), PM_AddTouchEnt(), PM_AdjustAngleForWallJump(), PM_AdjustAngleForWallRun(), PM_AdjustAngleForWallRunUp(), PM_AdjustAnglesForWallRunUpFlipAlt(), PM_AdjustAttackStates(), PM_AdjustStandAnimForSlope(), PM_AnimLength(), PM_BeginWeaponChange(), PM_BGEntForNum(), PM_CanBackstab(), PM_CanDoKata(), PM_CanDoRollStab(), PM_CanSetWeaponAnims(), PM_CheckAltKickAttack(), PM_CheckDualForwardJumpDuck(), PM_CheckFixMins(), PM_CheckPullAttack(), PM_CheckStabDown(), PM_ClipVelocity(), PM_ContinueLegsAnim(), PM_DebugLegsAnim(), PM_DoSlowFall(), PM_FinishWeaponChange(), PM_FootSlopeTrace(), PM_ForceJumpingUp(), PM_ForceLegsAnim(), PM_GetOkWeaponForVehicle(), PM_GetSaberStance(), PM_GrabWallForJump(), PM_GroundDistance(), PM_GroundSlideOkay(), PM_HoverTrace(), PM_InSecondaryStyle(), PM_irand_timesync(), PM_ItemUsable(), PM_KickMoveForConditions(), PM_LegsSlopeBackTransition(), PM_MoveForKata(), PM_pitch_roll_for_slope(), PM_RocketLock(), PM_SaberAttackForMovement(), PM_SaberBackflipAttackMove(), PM_SaberDualJumpAttackMove(), PM_SaberFlipOverAttackMove(), PM_SaberJumpAttackMove(), PM_SaberJumpAttackMove2(), PM_SaberKataDone(), PM_SaberLockBreak(), PM_SaberLocked(), PM_SaberLockResultAnim(), PM_SaberLockWinAnim(), PM_SaberLungeAttackMove(), PM_SaberMoveOkayForKata(), PM_SaberPowerCheck(), PM_SetAnim(), PM_SetAnimFinal(), PM_SetForceJumpZStart(), PM_SetLegsAnimTimer(), PM_SetSaberMove(), PM_SetSpecialMoveValues(), PM_SetTorsoAnimTimer(), PM_SlideMove(), PM_SomeoneInFront(), PM_StartTorsoAnim(), PM_StepSlideMove(), PM_Use(), PM_VehFaceHyperspacePoint(), PM_VehForcedTurning(), PM_VehicleImpact(), PM_VehicleWeaponAnimate(), PM_WalkableGroundDistance(), PM_WeaponLightsaber(), PmoveSingle(), ProcessOrientCommands(), qsort(), and SpectatorThink().

float pm_accelerate = 10.0f

Definition at line 47 of file bg_pmove.c.

float pm_airaccelerate = 1.0f

Definition at line 48 of file bg_pmove.c.

qboolean pm_cancelOutZoom = qfalse

Definition at line 38 of file bg_pmove.c. Referenced by PmoveSingle().

float pm_duckScale = 0.50f

Definition at line 42 of file bg_pmove.c.

bgEntity_t* pm_entSelf = NULL

Definition at line 33 of file bg_pmove.c. Referenced by BG_AdjustClientSpeed(), PM_AdjustAttackStates(), PM_HoverTrace(), PM_SetSpecialMoveValues(), PM_SlideMove(), PM_StepSlideMove(), and PmoveSingle().

bgEntity_t* pm_entVeh = NULL

Definition at line 34 of file bg_pmove.c. Referenced by PM_AdjustAttackStates(), PM_UpdateViewAngles(), PM_VehicleWeaponAnimate(), and PmoveSingle().

float pm_flightfriction = 3.0f

Definition at line 54 of file bg_pmove.c.

float pm_flyaccelerate = 8.0f

Definition at line 50 of file bg_pmove.c.

float pm_friction = 6.0f

Definition at line 52 of file bg_pmove.c.

float pm_spectatorfriction = 5.0f

Definition at line 55 of file bg_pmove.c.

float pm_stopspeed = 100.0f

Definition at line 41 of file bg_pmove.c.

float pm_swimScale = 0.50f

Definition at line 43 of file bg_pmove.c.

float pm_vehicleaccelerate = 36.0f

Definition at line 46 of file bg_pmove.c.

float pm_wadeScale = 0.70f

Definition at line 44 of file bg_pmove.c.

float pm_wateraccelerate = 4.0f

Definition at line 49 of file bg_pmove.c.

float pm_waterfriction = 1.0f

Definition at line 53 of file bg_pmove.c.

pml_t pml

Definition at line 31 of file bg_pmove.c. Referenced by PM_HoverTrace(), PM_SlideMove(), PM_VehFaceHyperspacePoint(), PM_VehForcedTurning(), PM_VehicleImpact(), PM_WeaponLightsaber(), and PmoveSingle().

int WeaponReadyLegsAnim[WP_NUM_WEAPONS]

Definition at line 5105 of file bg_pmove.c.