ioquake/jedi-academy
0
0
Fork 0
mirror of https://github.com/ioquake/jedi-academy.git synced 2024-11-26 14:11:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
jedi-academy/code/game/bg_pangles.cpp

1842 lines
60 KiB
C++
Raw Normal View History

ditch dos style newlines
2013-04-19 02:52:48 +00:00
// this include must remain at the top of every bg_xxxx CPP file
#include "common_headers.h"
// define GAME_INCLUDE so that g_public.h does not define the
// short, server-visible gclient_t and gentity_t structures,
// because we define the full size ones in this file
#define GAME_INCLUDE
#include "q_shared.h"
#include "g_shared.h"
#include "bg_local.h"
#include "anims.h"
#include "wp_saber.h"
#include "g_vehicles.h"
#include "../ghoul2/ghoul2_gore.h"
extern void CG_SetClientViewAngles( vec3_t angles, qboolean overrideViewEnt );
extern qboolean PM_InAnimForSaberMove( int anim, int saberMove );
extern qboolean PM_InForceGetUp( playerState_t *ps );
extern qboolean PM_InKnockDown( playerState_t *ps );
extern qboolean PM_InReboundJump( int anim );
extern qboolean PM_StabDownAnim( int anim );
extern qboolean PM_DodgeAnim( int anim );
extern qboolean PM_DodgeHoldAnim( int anim );
extern qboolean PM_InReboundHold( int anim );
extern qboolean PM_InKnockDownNoGetup( playerState_t *ps );
extern qboolean PM_InGetUpNoRoll( playerState_t *ps );
extern Vehicle_t *G_IsRidingVehicle( gentity_t *ent );
extern void WP_ForcePowerDrain( gentity_t *self, forcePowers_t forcePower, int overrideAmt );
extern qboolean G_ControlledByPlayer( gentity_t *self );
extern qboolean cg_usingInFrontOf;
extern qboolean player_locked;
extern pmove_t *pm;
extern pml_t pml;
extern cvar_t *g_debugMelee;
void BG_IK_MoveLimb( CGhoul2Info_v &ghoul2, int boltIndex, char *animBone, char *firstBone, char *secondBone,
int time, entityState_t *ent, int animFileIndex, int basePose,
vec3_t desiredPos, qboolean *ikInProgress, vec3_t origin,
vec3_t angles, vec3_t scale, int blendTime, qboolean forceHalt )
{
mdxaBone_t holdPointMatrix;
vec3_t holdPoint;
vec3_t torg;
float distToDest;
animation_t *anim = &level.knownAnimFileSets[animFileIndex].animations[basePose];
assert( ghoul2.size() );
assert( anim->firstFrame > 0 );//FIXME: umm...?
if ( !*ikInProgress && !forceHalt )
{
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 = anim->firstFrame + anim->numFrames;
ikP.endFrame = anim->firstFrame + anim->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 ( !gi.G2API_SetBoneIKState( ghoul2, time, NULL, IKS_DYNAMIC, &ikP ) )
{
assert( !"Failed to init IK system for g2 instance!" );
}
//Now, create our IK bone state.
if ( gi.G2API_SetBoneIKState( ghoul2, time, "lower_lumbar", 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 ( gi.G2API_SetBoneIKState( ghoul2, time, "upper_lumbar", 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 ( gi.G2API_SetBoneIKState( ghoul2, time, "thoracic", 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 ( gi.G2API_SetBoneIKState( ghoul2, time, secondBone, 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 ( gi.G2API_SetBoneIKState( ghoul2, time, firstBone, IKS_DYNAMIC, &ikP ) )
{ //everything went alright.
*ikInProgress = qtrue;
}
}
}
}
}
}
if ( *ikInProgress && !forceHalt )
{ //actively update our ik state.
sharedIKMoveParams_t ikM;
CRagDollUpdateParams 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;
gi.G2API_GetBoltMatrix( ghoul2, 0, boltIndex, &holdPointMatrix, tAngles, origin, time, 0, scale );
//Get the point position from the matrix.
holdPoint[0] = holdPointMatrix.matrix[0][3];
holdPoint[1] = holdPointMatrix.matrix[1][3];
holdPoint[2] = holdPointMatrix.matrix[2][3];
VectorSubtract( holdPoint, 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 ( gi.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 );
gi.G2API_AnimateG2Models( ghoul2, time, &tuParms );
}
else
{
*ikInProgress = qfalse;
}
}
else if ( *ikInProgress )
{ //kill it
float cFrame, animSpeed;
int sFrame, eFrame, flags;
gi.G2API_SetBoneIKState( ghoul2, time, "lower_lumbar", IKS_NONE, NULL );
gi.G2API_SetBoneIKState( ghoul2, time, "upper_lumbar", IKS_NONE, NULL );
gi.G2API_SetBoneIKState( ghoul2, time, "thoracic", IKS_NONE, NULL );
gi.G2API_SetBoneIKState( ghoul2, time, secondBone, IKS_NONE, NULL );
gi.G2API_SetBoneIKState( ghoul2, time, firstBone, IKS_NONE, NULL );
//then reset the angles/anims on these PCJs
gi.G2API_SetBoneAngles( &ghoul2[0], "lower_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
gi.G2API_SetBoneAngles( &ghoul2[0], "upper_lumbar", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
gi.G2API_SetBoneAngles( &ghoul2[0], "thoracic", vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
gi.G2API_SetBoneAngles( &ghoul2[0], secondBone, vec3_origin, BONE_ANGLES_POSTMULT, POSITIVE_X, NEGATIVE_Y, NEGATIVE_Z, NULL, 0, time );
gi.G2API_SetBoneAngles( &ghoul2[0], firstBone, 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.
gi.G2API_GetBoneAnim( &ghoul2[0], animBone, (const int)time, &cFrame, &sFrame, &eFrame, &flags, &animSpeed, 0 );
gi.G2API_SetBoneAnim( &ghoul2[0], "lower_lumbar", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
gi.G2API_SetBoneAnim( &ghoul2[0], "upper_lumbar", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
gi.G2API_SetBoneAnim( &ghoul2[0], "thoracic", sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
gi.G2API_SetBoneAnim( &ghoul2[0], secondBone, sFrame, eFrame, flags, animSpeed, time, sFrame, 300 );
gi.G2API_SetBoneAnim( &ghoul2[0], firstBone, 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).
gi.G2API_SetBoneIKState( ghoul2, time, NULL, IKS_NONE, NULL );
*ikInProgress = qfalse;
}
}
void PM_IKUpdate( gentity_t *ent )
{
//The bone we're holding them by and the next bone after that
char *animBone = "lower_lumbar";
char *firstBone = "lradius";
char *secondBone = "lhumerus";
char *defaultBoltName = "*r_hand";
if ( !ent->client )
{
return;
}
if ( ent->client->ps.heldByClient <= ENTITYNUM_WORLD )
{ //then put our arm in this client's hand
gentity_t *holder = &g_entities[ent->client->ps.heldByClient];
if ( holder && holder->inuse && holder->client && holder->ghoul2.size())
{
if ( !ent->client->ps.heldByBolt )
{//bolt wan't set
ent->client->ps.heldByBolt = gi.G2API_AddBolt( &holder->ghoul2[0], defaultBoltName );
}
}
else
{ //they're gone, stop holding me
ent->client->ps.heldByClient = 0;
return;
}
if ( ent->client->ps.heldByBolt )
{
mdxaBone_t boltMatrix;
vec3_t boltOrg;
vec3_t tAngles;
VectorCopy( holder->client->ps.viewangles, tAngles );
tAngles[PITCH] = tAngles[ROLL] = 0;
gi.G2API_GetBoltMatrix( holder->ghoul2, 0, ent->client->ps.heldByBolt, &boltMatrix, tAngles, holder->client->ps.origin, level.time, 0, holder->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, boltOrg );
int grabbedByBolt = gi.G2API_AddBolt( &ent->ghoul2[0], firstBone );
if ( grabbedByBolt )
{
//point the limb
BG_IK_MoveLimb( ent->ghoul2, grabbedByBolt, animBone, firstBone, secondBone,
level.time, &ent->s, ent->client->clientInfo.animFileIndex,
ent->client->ps.torsoAnim/*BOTH_DEAD1*/, boltOrg, &ent->client->ps.ikStatus,
ent->client->ps.origin, ent->client->ps.viewangles, ent->s.modelScale,
500, qfalse );
//now see if we need to be turned and/or pulled
vec3_t grabDiff, grabbedByOrg;
VectorCopy( ent->client->ps.viewangles, tAngles );
tAngles[PITCH] = tAngles[ROLL] = 0;
gi.G2API_GetBoltMatrix( ent->ghoul2, 0, grabbedByBolt, &boltMatrix, tAngles, ent->client->ps.origin, level.time, 0, ent->s.modelScale );
gi.G2API_GiveMeVectorFromMatrix( boltMatrix, ORIGIN, grabbedByOrg );
//check for turn
vec3_t org2Targ, org2Bolt;
VectorSubtract( boltOrg, ent->currentOrigin, org2Targ );
float org2TargYaw = vectoyaw( org2Targ );
VectorSubtract( grabbedByOrg, ent->currentOrigin, org2Bolt );
float org2BoltYaw = vectoyaw( org2Bolt );
if ( org2TargYaw-1.0f > org2BoltYaw )
{
ent->currentAngles[YAW]++;
G_SetAngles( ent, ent->currentAngles );
}
else if ( org2TargYaw+1.0f < org2BoltYaw )
{
ent->currentAngles[YAW]--;
G_SetAngles( ent, ent->currentAngles );
}
//check for pull
VectorSubtract( boltOrg, grabbedByOrg, grabDiff );
if ( VectorLength( grabDiff ) > 128.0f )
{//too far, release me
ent->client->ps.heldByClient = holder->client->ps.heldClient = ENTITYNUM_NONE;
}
else if ( 1 )
{//pull me along
trace_t trace;
vec3_t destOrg;
VectorAdd( ent->currentOrigin, grabDiff, destOrg );
gi.trace( &trace, ent->currentOrigin, ent->mins, ent->maxs, destOrg, ent->s.number, (ent->clipmask&~holder->contents) );
G_SetOrigin( ent, trace.endpos );
//FIXME: better yet: do an actual slidemove to the new pos?
//FIXME: if I'm alive, just tell me to walk some?
}
//FIXME: if I need to turn to keep my bone facing him, do so...
}
//don't let us fall?
VectorClear( ent->client->ps.velocity );
//FIXME: also make the holder point his holding limb at you?
}
}
else if ( ent->client->ps.ikStatus )
{ //make sure we aren't IKing if we don't have anyone to hold onto us.
if ( ent && ent->inuse && ent->client && ent->ghoul2.size() )
{
if ( !ent->client->ps.heldByBolt )
{
ent->client->ps.heldByBolt = gi.G2API_AddBolt( &ent->ghoul2[0], defaultBoltName );
}
}
else
{ //This shouldn't happen, but just in case it does, we'll have a failsafe.
ent->client->ps.heldByBolt = 0;
ent->client->ps.ikStatus = qfalse;
}
if ( ent->client->ps.heldByBolt )
{
BG_IK_MoveLimb( ent->ghoul2, ent->client->ps.heldByBolt, animBone, firstBone, secondBone,
level.time, &ent->s, ent->client->clientInfo.animFileIndex,
ent->client->ps.torsoAnim/*BOTH_DEAD1*/, (float *)vec3_origin,
&ent->client->ps.ikStatus, ent->client->ps.origin,
ent->client->ps.viewangles, ent->s.modelScale, 500, qtrue );
}
}
}
void BG_G2SetBoneAngles( centity_t *cent, gentity_t *gent, int boneIndex, const vec3_t angles, const int flags,
const Eorientations up, const Eorientations right, const Eorientations forward, qhandle_t *modelList )
{
if (boneIndex!=-1)
{
gi.G2API_SetBoneAnglesIndex( &cent->gent->ghoul2[0], boneIndex, angles, flags, up, right, forward, modelList );
}
}
#define MAX_YAWSPEED_X_WING 1
#define MAX_PITCHSPEED_X_WING 1
void PM_ScaleUcmd( playerState_t *ps, usercmd_t *cmd, gentity_t *gent )
{
if ( G_IsRidingVehicle( gent ) )
{//driving a vehicle
//clamp the turn rate
int maxPitchSpeed = MAX_PITCHSPEED_X_WING;//switch, eventually? Or read from file?
int diff = AngleNormalize180(SHORT2ANGLE((cmd->angles[PITCH]+ps->delta_angles[PITCH]))) - floor(ps->viewangles[PITCH]);
if ( diff > maxPitchSpeed )
{
cmd->angles[PITCH] = ANGLE2SHORT( ps->viewangles[PITCH] + maxPitchSpeed ) - ps->delta_angles[PITCH];
}
else if ( diff < -maxPitchSpeed )
{
cmd->angles[PITCH] = ANGLE2SHORT( ps->viewangles[PITCH] - maxPitchSpeed ) - ps->delta_angles[PITCH];
}
//Um, WTF? When I turn in a certain direction, I start going backwards? Or strafing?
int maxYawSpeed = MAX_YAWSPEED_X_WING;//switch, eventually? Or read from file?
diff = AngleNormalize180(SHORT2ANGLE(cmd->angles[YAW]+ps->delta_angles[YAW]) - floor(ps->viewangles[YAW]));
//clamp the turn rate
if ( diff > maxYawSpeed )
{
cmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] + maxYawSpeed ) - ps->delta_angles[YAW];
}
else if ( diff < -maxYawSpeed )
{
cmd->angles[YAW] = ANGLE2SHORT( ps->viewangles[YAW] - maxYawSpeed ) - ps->delta_angles[YAW];
}
}
}
extern void SetClientViewAngle( gentity_t *ent, vec3_t angle );
qboolean PM_LockAngles( gentity_t *ent, usercmd_t *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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAnglesToGripper( gentity_t *ent, usercmd_t *ucmd )
{//FIXME: make this more generic and have it actually *tell* the client what cmd angles it should be locked at?
if ( ((ent->client->ps.eFlags&EF_FORCE_GRIPPED)||(ent->client->ps.eFlags&EF_FORCE_DRAINED)) && ent->enemy )
{
vec3_t dir, angles;
VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, dir );
vectoangles( dir, angles );
angles[PITCH] = AngleNormalize180( angles[PITCH] );
angles[YAW] = AngleNormalize180( angles[YAW] );
if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( ent, angles );
}
ucmd->angles[PITCH] = ANGLE2SHORT(angles[PITCH]) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT(angles[YAW]) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
return qfalse;
}
qboolean PM_AdjustAnglesToPuller( gentity_t *ent, gentity_t *puller, usercmd_t *ucmd, qboolean faceAway )
{//FIXME: make this more generic and have it actually *tell* the client what cmd angles it should be locked at?
vec3_t dir, angles;
VectorSubtract( puller->currentOrigin, ent->currentOrigin, dir );
vectoangles( dir, angles );
angles[PITCH] = AngleNormalize180( angles[PITCH] );
if ( faceAway )
{
angles[YAW] += 180;
}
angles[YAW] = AngleNormalize180( angles[YAW] );
if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( ent, angles );
}
ucmd->angles[PITCH] = ANGLE2SHORT(angles[PITCH]) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT(angles[YAW]) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAngleForWallRun( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
{
if (( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT || ent->client->ps.legsAnim == BOTH_WALL_RUN_LEFT ) && ent->client->ps.legsAnimTimer > 500 )
{//wall-running and not at end of anim
//stick to wall, if there is one
vec3_t fwd, rt, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};
trace_t trace;
float dist, yawAdjust=0.0f;
AngleVectors( fwdAngles, fwd, rt, NULL );
if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
{
dist = 128;
yawAdjust = -90;
}
else
{
dist = -128;
yawAdjust = 90;
}
VectorMA( ent->currentOrigin, dist, rt, traceTo );
gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
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 = {0};
wallRunAngles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
AngleVectors( wallRunAngles, wallRunFwd, NULL, NULL );
VectorMA( ent->currentOrigin, 32, wallRunFwd, traceTo2 );
gi.trace( &trace2, ent->currentOrigin, mins, maxs, traceTo2, ent->s.number, ent->clipmask );
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) )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//still a vertical wall there
//FIXME: don't pull around 90 turns
//FIXME: simulate stepping up steps here, somehow?
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
{
ucmd->rightmove = 127;
}
else
{
ucmd->rightmove = -127;
}
}
if ( ucmd->upmove < 0 )
{
ucmd->upmove = 0;
}
if ( ent->NPC )
{//invalid now
VectorClear( ent->client->ps.moveDir );
}
//make me face perpendicular to the wall
ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
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( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
if ( (ent->s.number&&!G_ControlledByPlayer(ent)) || !player_locked )
{
if ( doMove )
{
//push me forward
float zVel = ent->client->ps.velocity[2];
if ( zVel > forceJumpStrength[FORCE_LEVEL_2]/2.0f )
{
zVel = forceJumpStrength[FORCE_LEVEL_2]/2.0f;
}
//pull me toward the wall
VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
if ( ent->client->ps.legsAnimTimer > 500 )
{//not at end of anim yet, pushing forward
//FIXME: or MA?
float speed = 175;
if ( ucmd->forwardmove < 0 )
{//slower
speed = 100;
}
else if ( ucmd->forwardmove > 0 )
{
speed = 250;//running speed
}
VectorMA( ent->client->ps.velocity, speed, fwd, ent->client->ps.velocity );
}
ent->client->ps.velocity[2] = zVel;//preserve z velocity
//VectorMA( ent->client->ps.velocity, -128, trace.plane.normal, ent->client->ps.velocity );
//pull me toward the wall, too
//VectorMA( ent->client->ps.velocity, dist, rt, ent->client->ps.velocity );
}
}
ucmd->forwardmove = 0;
return qtrue;
}
else if ( doMove )
{//stop it
if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_RIGHT )
{
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_WALL_RUN_RIGHT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
else if ( ent->client->ps.legsAnim == BOTH_WALL_RUN_LEFT )
{
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_WALL_RUN_LEFT_STOP, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
}
}
return qfalse;
}
extern int PM_AnimLength( int index, animNumber_t anim );
qboolean PM_AdjustAnglesForSpinningFlip( gentity_t *ent, usercmd_t *ucmd, qboolean anglesOnly )
{
vec3_t newAngles;
float animLength, spinStart, spinEnd, spinAmt, spinLength;
animNumber_t spinAnim;
if ( ent->client->ps.legsAnim == BOTH_JUMPFLIPSTABDOWN )
{
spinAnim = BOTH_JUMPFLIPSTABDOWN;
spinStart = 300.0f;//700.0f;
spinEnd = 1400.0f;
spinAmt = 180.0f;
}
else if ( ent->client->ps.legsAnim == BOTH_JUMPFLIPSLASHDOWN1 )
{
spinAnim = BOTH_JUMPFLIPSLASHDOWN1;
spinStart = 300.0f;//700.0f;//1500.0f;
spinEnd = 1400.0f;//2300.0f;
spinAmt = 180.0f;
}
else
{
if ( !anglesOnly )
{
if ( (ent->s.number<MAX_CLIENTS||G_ControlledByPlayer(ent)) )
{
cg.overrides.active &= ~CG_OVERRIDE_3RD_PERSON_VOF;
cg.overrides.thirdPersonVertOffset = 0;
}
}
return qfalse;
}
animLength = PM_AnimLength( ent->client->clientInfo.animFileIndex, spinAnim );
float elapsedTime = (float)(animLength-ent->client->ps.legsAnimTimer);
//face me
if ( elapsedTime >= spinStart && elapsedTime <= spinEnd )
{
spinLength = spinEnd - spinStart;
VectorCopy( ent->client->ps.viewangles, newAngles );
newAngles[YAW] = ent->angle + (spinAmt * (elapsedTime-spinStart) / spinLength);
if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( ent, newAngles );
}
ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
if ( anglesOnly )
{
return qtrue;
}
}
else if ( anglesOnly )
{
return qfalse;
}
//push me
if ( ent->client->ps.legsAnimTimer > 300 )//&& ent->client->ps.groundEntityNum == ENTITYNUM_NONE )
{//haven't landed or reached end of anim yet
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
vec3_t pushDir, pushAngles = {0,ent->angle,0};
AngleVectors( pushAngles, pushDir, NULL, NULL );
if ( DotProduct( ent->client->ps.velocity, pushDir ) < 100 )
{
VectorMA( ent->client->ps.velocity, 10, pushDir, ent->client->ps.velocity );
}
}
}
//do a dip in the view
if ( (ent->s.number<MAX_CLIENTS||G_ControlledByPlayer(ent)) )
{
float viewDip = 0;
if ( elapsedTime < animLength/2.0f )
{//starting anim
viewDip = (elapsedTime/animLength)*-120.0f;
}
else
{//ending anim
viewDip = ((animLength-elapsedTime)/animLength)*-120.0f;
}
cg.overrides.active |= CG_OVERRIDE_3RD_PERSON_VOF;
cg.overrides.thirdPersonVertOffset = cg_thirdPersonVertOffset.value+viewDip;
//pm->ps->viewheight = standheight + viewDip;
}
return qtrue;
}
qboolean PM_AdjustAnglesForBackAttack( gentity_t *ent, usercmd_t *ucmd )
{
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
{
return qfalse;
}
if ( ( ent->client->ps.saberMove == LS_A_BACK || ent->client->ps.saberMove == LS_A_BACK_CR || ent->client->ps.saberMove == LS_A_BACKSTAB )
&& PM_InAnimForSaberMove( ent->client->ps.torsoAnim, ent->client->ps.saberMove ) )
{
if ( ent->client->ps.saberMove != LS_A_BACKSTAB || !ent->enemy || (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
{
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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
}
else
{//keep player facing away from their enemy
vec3_t enemyBehindDir;
VectorSubtract( ent->currentOrigin, ent->enemy->currentOrigin, enemyBehindDir );
float enemyBehindYaw = AngleNormalize180( vectoyaw( enemyBehindDir ) );
float yawError = AngleNormalize180( enemyBehindYaw - AngleNormalize180( ent->client->ps.viewangles[YAW] ) );
if ( yawError > 1 )
{
yawError = 1;
}
else if ( yawError < -1 )
{
yawError = -1;
}
ucmd->angles[YAW] = ANGLE2SHORT( AngleNormalize180( ent->client->ps.viewangles[YAW] + yawError ) ) - ent->client->ps.delta_angles[YAW];
ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
}
return qtrue;
}
return qfalse;
}
qboolean PM_AdjustAnglesForSaberLock( gentity_t *ent, usercmd_t *ucmd )
{
if ( ent->client->ps.saberLockTime > level.time )
{
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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
return qfalse;
}
int G_MinGetUpTime( gentity_t *ent )
{
if ( ent
&& ent->client
&& ( ent->client->ps.legsAnim == BOTH_PLAYER_PA_3_FLY
|| ent->client->ps.legsAnim == BOTH_LK_DL_ST_T_SB_1_L
|| ent->client->ps.legsAnim == BOTH_RELEASED ) )
{//special cases
return 200;
}
else if ( ent && ent->client && ent->client->NPC_class == CLASS_ALORA )
{//alora springs up very quickly from knockdowns!
return 1000;
}
else if ( (ent->s.clientNum < MAX_CLIENTS||G_ControlledByPlayer(ent)) )
{//player can get up faster based on his/her force jump skill
int getUpTime = PLAYER_KNOCKDOWN_HOLD_EXTRA_TIME;
if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] >= FORCE_LEVEL_3 )
{
return (getUpTime+400);//750
}
else if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] == FORCE_LEVEL_2 )
{
return (getUpTime+200);//500
}
else if ( ent->client->ps.forcePowerLevel[FP_LEVITATION] == FORCE_LEVEL_1 )
{
return (getUpTime+100);//250
}
else
{
return getUpTime;
}
}
return 200;
}
qboolean PM_AdjustAnglesForKnockdown( gentity_t *ent, usercmd_t *ucmd, qboolean angleClampOnly )
{
if ( PM_InKnockDown( &ent->client->ps ) )
{//being knocked down or getting up, can't do anything!
if ( !angleClampOnly )
{
if ( ent->client->ps.legsAnimTimer > G_MinGetUpTime( ent )
|| (ent->s.number >= MAX_CLIENTS&&!G_ControlledByPlayer(ent)) )
{//can't get up yet
ucmd->forwardmove = 0;
ucmd->rightmove = 0;
}
if ( ent->NPC )
{
VectorClear( ent->client->ps.moveDir );
}
//you can jump up out of a knockdown and you get get up into a crouch from a knockdown
//ucmd->upmove = 0;
//if ( !PM_InForceGetUp( &ent->client->ps ) || ent->client->ps.torsoAnimTimer > 800 || ent->s.weapon != WP_SABER )
if ( ent->health > 0 )
{//can only attack if you've started a force-getup and are using the saber
ucmd->buttons = 0;
}
}
if ( !PM_InForceGetUp( &ent->client->ps ) )
{//can't turn unless in a force getup
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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
}
return qfalse;
}
qboolean PM_AdjustAnglesForDualJumpAttack( gentity_t *ent, usercmd_t *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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAnglesForLongJump( gentity_t *ent, usercmd_t *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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAnglesForGrapple( gentity_t *ent, usercmd_t *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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAngleForWallRunUp( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
{
if ( ent->client->ps.legsAnim == BOTH_FORCEWALLRUNFLIP_START )
{//wall-running up
//stick to wall, if there is one
vec3_t fwd, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};
trace_t trace;
float dist = 128;
AngleVectors( fwdAngles, fwd, NULL, NULL );
VectorMA( ent->currentOrigin, dist, fwd, traceTo );
gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
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] += (ent->mins[2]*-1) + 4.0f;
VectorCopy( top, bottom );
bottom[2] -= 64.0f;//was 32.0f
gi.trace( &trace2, top, ent->mins, ent->maxs, bottom, ent->s.number, ent->clipmask );
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, ent->client->ps.velocity );
ent->client->ps.velocity[2] += 200;
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_ALT, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
ent->client->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 );
ucmd->upmove = 0;
return qfalse;
}
}
if ( //ucmd->upmove <= 0 &&
ent->client->ps.legsAnimTimer > 0
&& ucmd->forwardmove > 0
&& trace.fraction < 1.0f
&& (trace.plane.normal[2] >= 0.0f && trace.plane.normal[2] <= MAX_WALL_RUN_Z_NORMAL) )
{//still a vertical wall there
//make sure there's not a ceiling above us!
trace_t trace2;
VectorCopy( ent->currentOrigin, traceTo );
traceTo[2] += 64;
gi.trace( &trace2, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
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?
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
ucmd->forwardmove = 127;
}
if ( ucmd->upmove < 0 )
{
ucmd->upmove = 0;
}
if ( ent->NPC )
{//invalid now
VectorClear( ent->client->ps.moveDir );
}
//make me face the wall
ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+180;
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( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
if ( doMove )
{
//pull me toward the wall
VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
//push me up
if ( ent->client->ps.legsAnimTimer > 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
}
*/
ent->client->ps.velocity[2] = speed;//preserve z velocity
}
//pull me toward the wall
//VectorMA( ent->client->ps.velocity, -128, trace.plane.normal, ent->client->ps.velocity );
}
}
ucmd->forwardmove = 0;
return qtrue;
}
}
//failed!
if ( doMove )
{//stop it
VectorScale( fwd, WALL_RUN_UP_BACKFLIP_SPEED, ent->client->ps.velocity );
ent->client->ps.velocity[2] += 200;
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRUNFLIP_END, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
ent->client->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 );
ucmd->upmove = 0;
//return qtrue;
}
}
return qfalse;
}
float G_ForceWallJumpStrength( void )
{
return (forceJumpStrength[FORCE_LEVEL_3]/2.5f);
}
qboolean PM_AdjustAngleForWallJump( gentity_t *ent, usercmd_t *ucmd, qboolean doMove )
{
if ( PM_InReboundJump( ent->client->ps.legsAnim )
|| PM_InReboundHold( ent->client->ps.legsAnim ) )
{//hugging wall, getting ready to jump off
//stick to wall, if there is one
vec3_t checkDir, traceTo, mins = {ent->mins[0],ent->mins[1],0}, maxs = {ent->maxs[0],ent->maxs[1],24}, fwdAngles = {0, ent->client->ps.viewangles[YAW], 0};
trace_t trace;
float dist = 128, yawAdjust;
switch ( ent->client->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???
return qfalse;
break;
}
if ( g_debugMelee->integer )
{//uber-skillz
if ( ucmd->upmove > 0 )
{//hold on until you let go manually
if ( PM_InReboundHold( ent->client->ps.legsAnim ) )
{//keep holding
if ( ent->client->ps.legsAnimTimer < 150 )
{
ent->client->ps.legsAnimTimer = 150;
}
}
else
{//if got to hold part of anim, play hold anim
if ( ent->client->ps.legsAnimTimer <= 300 )
{
ent->client->ps.SaberDeactivate();
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ent->client->ps.legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
ent->client->ps.legsAnimTimer = ent->client->ps.torsoAnimTimer = 150;
}
}
}
}
VectorMA( ent->currentOrigin, dist, checkDir, traceTo );
gi.trace( &trace, ent->currentOrigin, mins, maxs, traceTo, ent->s.number, ent->clipmask );
if ( //ucmd->upmove <= 0 &&
ent->client->ps.legsAnimTimer > 100 &&
trace.fraction < 1.0f && fabs(trace.plane.normal[2]) <= MAX_WALL_GRAB_SLOPE )
{//still a vertical wall there
//FIXME: don't pull around 90 turns
/*
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
ucmd->forwardmove = 127;
}
*/
if ( ucmd->upmove < 0 )
{
ucmd->upmove = 0;
}
if ( ent->NPC )
{//invalid now
VectorClear( ent->client->ps.moveDir );
}
//align me to the wall
ent->client->ps.viewangles[YAW] = vectoyaw( trace.plane.normal )+yawAdjust;
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( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
if ( (ent->s.number>=MAX_CLIENTS&&!G_ControlledByPlayer(ent)) || !player_locked )
{
if ( doMove )
{
//pull me toward the wall
VectorScale( trace.plane.normal, -128, ent->client->ps.velocity );
}
}
ucmd->upmove = 0;
ent->client->ps.pm_flags |= PMF_STUCK_TO_WALL;
return qtrue;
}
else if ( doMove
&& (ent->client->ps.pm_flags&PMF_STUCK_TO_WALL))
{//jump off
//push off of it!
ent->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
ent->client->ps.velocity[0] = ent->client->ps.velocity[1] = 0;
VectorScale( checkDir, -JUMP_OFF_WALL_SPEED, ent->client->ps.velocity );
ent->client->ps.velocity[2] = G_ForceWallJumpStrength();
ent->client->ps.pm_flags |= PMF_JUMPING|PMF_JUMP_HELD;
G_SoundOnEnt( ent, CHAN_BODY, "sound/weapons/force/jump.wav" );
ent->client->ps.forcePowersActive |= (1<<FP_LEVITATION);
WP_ForcePowerDrain( ent, FP_LEVITATION, 10 );
if ( PM_InReboundHold( ent->client->ps.legsAnim ) )
{//if was in hold pose, release now
NPC_SetAnim( ent, SETANIM_BOTH, BOTH_FORCEWALLRELEASE_FORWARD+(ent->client->ps.legsAnim-BOTH_FORCEWALLHOLD_FORWARD), SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
//no control for half a second
ent->client->ps.pm_flags |= PMF_TIME_KNOCKBACK;
ent->client->ps.pm_time = 500;
ucmd->forwardmove = 0;
ucmd->rightmove = 0;
ucmd->upmove = 0;
//return qtrue;
}
}
ent->client->ps.pm_flags &= ~PMF_STUCK_TO_WALL;
return qfalse;
}
qboolean PM_AdjustAnglesForBFKick( gentity_t *self, usercmd_t *ucmd, vec3_t fwdAngs, qboolean aimFront )
{
//Auto-aim the player at the ent in front/back of them
//FIXME: camera angle should always be in front/behind me for the 2 kicks
// (to hide how far away the two entities really are)
//FIXME: don't let the people we're auto-aiming at move?
gentity_t *ent;
gentity_t *entityList[MAX_GENTITIES];
vec3_t mins, maxs;
int i, e;
int radius = ((self->maxs[0]*1.5f)+(self->maxs[0]*1.5f)+STAFF_KICK_RANGE+24.0f);//a little wide on purpose
vec3_t center, vec2Ent, v_fwd;
float distToEnt, bestDist = Q3_INFINITE;
float dot, bestDot = -1.1f;
float bestYaw = Q3_INFINITE;
AngleVectors( fwdAngs, v_fwd, NULL, NULL );
VectorCopy( self->currentOrigin, center );
for ( i = 0 ; i < 3 ; i++ )
{
mins[i] = center[i] - radius;
maxs[i] = center[i] + radius;
}
int numListedEntities = gi.EntitiesInBox( mins, maxs, entityList, MAX_GENTITIES );
for ( e = 0 ; e < numListedEntities ; e++ )
{
ent = entityList[ e ];
if (ent == self)
continue;
if (ent->owner == self)
continue;
if ( !(ent->inuse) )
continue;
//not a client?
if ( !ent->client )
continue;
//ally?
if ( ent->client->playerTeam == self->client->playerTeam )
continue;
//on the ground
if ( PM_InKnockDown( &ent->client->ps ) )
continue;
//dead?
if ( ent->health <= 0 )
{
if ( level.time - ent->s.time > 2000 )
{//died more than 2 seconds ago, forget him
continue;
}
}
//too far?
VectorSubtract( ent->currentOrigin, center, vec2Ent );
distToEnt = VectorNormalize( vec2Ent );
if ( distToEnt > radius )
continue;
if ( !aimFront )
{//aim away from them
VectorScale( vec2Ent, -1, vec2Ent );
}
dot = DotProduct( vec2Ent, v_fwd );
if ( dot < 0.0f )
{//never turn all the way around
continue;
}
if ( dot > bestDot || ((bestDot-dot<0.25f)&&distToEnt-bestDist>8.0f) )
{//more in front... OR: still relatively close to in front and significantly closer
bestDot = dot;
bestDist = distToEnt;
bestYaw = vectoyaw( vec2Ent );
}
}
if ( bestYaw != Q3_INFINITE && bestYaw != fwdAngs[YAW] )
{//aim us at them
AngleNormalize180( bestYaw );
AngleNormalize180( fwdAngs[YAW] );
float angDiff = AngleSubtract( bestYaw, fwdAngs[YAW] );
AngleNormalize180( angDiff );
if ( fabs(angDiff) <= 3.0f )
{
self->client->ps.viewangles[YAW] = bestYaw;
}
else if ( angDiff > 0.0f )
{//more than 3 degrees higher
self->client->ps.viewangles[YAW] += 3.0f;
}
else
{//must be more than 3 less than
self->client->ps.viewangles[YAW] -= 3.0f;
}
if ( self->client->ps.viewEntity <= 0 || self->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( self, self->client->ps.viewangles );
}
ucmd->angles[YAW] = ANGLE2SHORT( self->client->ps.viewangles[YAW] ) - self->client->ps.delta_angles[YAW];
return qtrue;
}
else
{//lock these angles
if ( self->client->ps.viewEntity <= 0 || self->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( self, self->client->ps.viewangles );
}
ucmd->angles[YAW] = ANGLE2SHORT( self->client->ps.viewangles[YAW] ) - self->client->ps.delta_angles[YAW];
}
return qtrue;
}
qboolean PM_AdjustAnglesForStabDown( gentity_t *ent, usercmd_t *ucmd )
{
if ( PM_StabDownAnim( ent->client->ps.torsoAnim )
&& ent->client->ps.torsoAnimTimer )
{//lock our angles
ucmd->forwardmove = ucmd->rightmove = ucmd->upmove = 0;
float elapsedTime = PM_AnimLength( ent->client->clientInfo.animFileIndex, (animNumber_t)ent->client->ps.torsoAnim ) - ent->client->ps.torsoAnimTimer;
//FIXME: scale forwardmove by dist from enemy - none if right next to him (so we don't slide off!)
if ( ent->enemy )
{
float dist2Enemy = DistanceHorizontal( ent->enemy->currentOrigin, ent->currentOrigin );
if ( dist2Enemy > (ent->enemy->maxs[0]*1.5f)+(ent->maxs[0]*1.5f) )
{
ent->client->ps.speed = dist2Enemy*2.0f;
}
else
{
ent->client->ps.speed = 0;
}
}
else
{
ent->client->ps.speed = 150;
}
switch ( ent->client->ps.legsAnim )
{
case BOTH_STABDOWN:
if ( elapsedTime >= 300 && elapsedTime < 900 )
{//push forward?
//FIXME: speed!
ucmd->forwardmove = 127;
}
break;
case BOTH_STABDOWN_STAFF:
if ( elapsedTime > 400 && elapsedTime < 950 )
{//push forward?
//FIXME: speed!
ucmd->forwardmove = 127;
}
break;
case BOTH_STABDOWN_DUAL:
if ( elapsedTime >= 300 && elapsedTime < 900 )
{//push forward?
//FIXME: speed!
ucmd->forwardmove = 127;
}
break;
}
VectorClear( ent->client->ps.moveDir );
if ( ent->enemy//still have a valid enemy
&& ent->enemy->client//who is a client
&& (PM_InKnockDownNoGetup( &ent->enemy->client->ps ) //enemy still on ground
|| PM_InGetUpNoRoll( &ent->enemy->client->ps ) ) )//or getting straight up
{//aim at the enemy
vec3_t enemyDir;
VectorSubtract( ent->enemy->currentOrigin, ent->currentOrigin, enemyDir );
float enemyYaw = AngleNormalize180( vectoyaw( enemyDir ) );
float yawError = AngleNormalize180( enemyYaw - AngleNormalize180( ent->client->ps.viewangles[YAW] ) );
if ( yawError > 1 )
{
yawError = 1;
}
else if ( yawError < -1 )
{
yawError = -1;
}
ucmd->angles[YAW] = ANGLE2SHORT( AngleNormalize180( ent->client->ps.viewangles[YAW] + yawError ) ) - ent->client->ps.delta_angles[YAW];
ucmd->angles[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
}
else
{//can't turn
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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
}
return qtrue;
}
return qfalse;
}
qboolean PM_AdjustAnglesForSpinProtect( gentity_t *ent, usercmd_t *ucmd )
{
if ( ent->client->ps.torsoAnim == BOTH_A6_SABERPROTECT )
{//in the dual spin thing
if ( ent->client->ps.torsoAnimTimer )
{//flatten and lock our angles, pull back camera
//FIXME: lerp this
ent->client->ps.viewangles[PITCH] = 0;
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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
}
return qfalse;
}
qboolean PM_AdjustAnglesForWallRunUpFlipAlt( gentity_t *ent, usercmd_t *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[PITCH] = ANGLE2SHORT( ent->client->ps.viewangles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( ent->client->ps.viewangles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean PM_AdjustAnglesForHeldByMonster( gentity_t *ent, gentity_t *monster, usercmd_t *ucmd )
{
vec3_t newViewAngles;
if ( !monster || !monster->client )
{
return qfalse;
}
VectorScale( monster->client->ps.viewangles, -1, newViewAngles );
if ( ent->client->ps.viewEntity <= 0 || ent->client->ps.viewEntity >= ENTITYNUM_WORLD )
{//don't clamp angles when looking through a viewEntity
SetClientViewAngle( ent, newViewAngles );
}
ucmd->angles[PITCH] = ANGLE2SHORT( newViewAngles[PITCH] ) - ent->client->ps.delta_angles[PITCH];
ucmd->angles[YAW] = ANGLE2SHORT( newViewAngles[YAW] ) - ent->client->ps.delta_angles[YAW];
return qtrue;
}
qboolean G_OkayToLean( playerState_t *ps, usercmd_t *cmd, qboolean interruptOkay )
{
if ( (ps->clientNum < MAX_CLIENTS||G_ControlledByPlayer(&g_entities[ps->clientNum]))//player
&& ps->groundEntityNum != ENTITYNUM_NONE//on ground
&& ( (interruptOkay//okay to interrupt a lean
&& PM_DodgeAnim( ps->torsoAnim ) )//already leaning
||
(!ps->weaponTime//not attacking or being prevented from attacking
&& !ps->legsAnimTimer//not in any held legs anim
&& !ps->torsoAnimTimer) //not in any held torso anim
)
&& !(cmd->buttons&(BUTTON_ATTACK|BUTTON_ALT_ATTACK|BUTTON_FORCE_LIGHTNING|BUTTON_USE_FORCE|BUTTON_FORCE_DRAIN|BUTTON_FORCEGRIP))//not trying to attack
//&& (ps->forcePowersActive&(1<<FP_SPEED))
&& VectorCompare( ps->velocity, vec3_origin )//not moving
&& !cg_usingInFrontOf )//use button wouldn't be used for anything else
{
return qtrue;
}
return qfalse;
}
/*
================
PM_UpdateViewAngles
This can be used as another entry point when only the viewangles
are being updated isntead of a full move
//FIXME: Now that they pmove twice per think, they snap-look really fast
================
*/
void PM_UpdateViewAngles( playerState_t *ps, usercmd_t *cmd, gentity_t *gent )
{
short temp;
float rootPitch = 0, pitchMin=-75, pitchMax=75, yawMin=0, yawMax=0, lockedYawValue = 0; //just to shut up warnings
int i;
vec3_t start, end, tmins, tmaxs, right;
trace_t trace;
qboolean lockedYaw = qfalse, clamped = qfalse;
if ( ps->pm_type == PM_INTERMISSION )
{
return; // no view changes at all
}
//TEMP
#if 0 //rww 12/23/02 - I'm disabling this for now, I'm going to try to make it work with my new rag stuff
if ( gent != NULL )
{
PM_IKUpdate( gent );
}
#endif
if ( ps->pm_type != PM_SPECTATOR && ps->stats[STAT_HEALTH] <= 0 )
{
return; // no view changes at all
}
// if ( player_locked )
// {//can't turn
// return;
// }
if ( ps->clientNum != 0 && gent != NULL && gent->client != NULL )
{
if(gent->client->renderInfo.renderFlags & RF_LOCKEDANGLE)
{
pitchMin = 0 - gent->client->renderInfo.headPitchRangeUp - gent->client->renderInfo.torsoPitchRangeUp;
pitchMax = gent->client->renderInfo.headPitchRangeDown + gent->client->renderInfo.torsoPitchRangeDown;
yawMin = 0 - gent->client->renderInfo.headYawRangeLeft - gent->client->renderInfo.torsoYawRangeLeft;
yawMax = gent->client->renderInfo.headYawRangeRight + gent->client->renderInfo.torsoYawRangeRight;
lockedYaw = qtrue;
lockedYawValue = gent->client->renderInfo.lockYaw;
}
else
{
pitchMin = -gent->client->renderInfo.headPitchRangeUp-gent->client->renderInfo.torsoPitchRangeUp;
pitchMax = gent->client->renderInfo.headPitchRangeDown+gent->client->renderInfo.torsoPitchRangeDown;
}
}
if ( ps->eFlags & EF_LOCKED_TO_WEAPON )
{
// Emplaced guns have different pitch capabilities
if ( gent && gent->owner && gent->owner->e_UseFunc == useF_eweb_use )
{
pitchMin = -15;
pitchMax = 10;
/*
lockedYawValue = gent->owner->s.angles[YAW];
yawMax = gent->owner->s.origin2[0];
yawMin = yawMax *-1;
lockedYaw = qtrue;
*/
}
else
{
pitchMin = -35;
pitchMax = 30;
}
}
Vehicle_t *pVeh = NULL;
// If we're a vehicle, or we're riding a vehicle...?
if ( gent && gent->client && gent->client->NPC_class == CLASS_VEHICLE && gent->m_pVehicle)
{
pVeh = gent->m_pVehicle;
// If we're a vehicle...
if (pVeh->m_pVehicleInfo->Inhabited(pVeh) || pVeh->m_iBoarding!=0 || pVeh->m_pVehicleInfo->type!=VH_ANIMAL)
{
lockedYawValue = pVeh->m_vOrientation[YAW];
yawMax = yawMin = 0;
rootPitch = pVeh->m_vOrientation[PITCH];//??? what if goes over 90 when add the min/max?
pitchMax = 0.0f;//pVeh->m_pVehicleInfo->pitchLimit;
pitchMin = 0.0f;//-pitchMax;
lockedYaw = qtrue;
}
// If we're riding a vehicle...
else if ( (pVeh = G_IsRidingVehicle( gent ) ) != NULL )
{
if ( pVeh->m_pVehicleInfo->type != VH_ANIMAL )
{//animals just turn normally, no clamping
lockedYawValue = 0;//gent->owner->client->ps.vehicleAngles[YAW];
lockedYaw = qtrue;
yawMax = pVeh->m_pVehicleInfo->lookYaw;
yawMin = -yawMax;
if ( pVeh->m_pVehicleInfo->type == VH_FIGHTER )
{
rootPitch = pVeh->m_vOrientation[PITCH];//gent->owner->client->ps.vehicleAngles[PITCH];//??? what if goes over 90 when add the min/max?
pitchMax = pVeh->m_pVehicleInfo->pitchLimit;
pitchMin = -pitchMax;
}
else
{
rootPitch = 0;//gent->owner->client->ps.vehicleAngles[PITCH];//??? what if goes over 90 when add the min/max?
pitchMax = pVeh->m_pVehicleInfo->lookPitch;
pitchMin = -pitchMax;
}
}
}
/*if ( vehIndex != -1 )
{
//FIXME: read from NPCs.cfg or vehicles.cfg?
lockedYaw = qtrue;
}*/
}
const short pitchClampMin = ANGLE2SHORT(rootPitch+pitchMin);
const short pitchClampMax = ANGLE2SHORT(rootPitch+pitchMax);
const short yawClampMin = ANGLE2SHORT(lockedYawValue+yawMin);
const short yawClampMax = ANGLE2SHORT(lockedYawValue+yawMax);
// circularly clamp the angles with deltas
for (i=0 ; i<3 ; i++)
{
temp = cmd->angles[i] + ps->delta_angles[i];
if ( i == PITCH )
{
//FIXME get this limit from the NPCs stats?
// don't let the player look up or down more than 90 degrees
if ( temp > pitchClampMax )
{
ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff; //& clamp to short
temp = pitchClampMax;
clamped = qtrue;
}
else if ( temp < pitchClampMin )
{
ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff; //& clamp to short
temp = pitchClampMin;
clamped = qtrue;
}
}
/*
if ( i == ROLL && ps->vehicleIndex != VEHICLE_NONE )
{
if ( temp > pitchClampMax )
{
ps->delta_angles[i] = (pitchClampMax - cmd->angles[i]) & 0xffff;
temp = pitchClampMax;
}
else if ( temp < pitchClampMin )
{
ps->delta_angles[i] = (pitchClampMin - cmd->angles[i]) & 0xffff;
temp = pitchClampMin;
}
}
*/
//FIXME: Are we losing precision here? Is this why it jitters?
/*
if ( i == YAW && lockedYaw )
{
float multiplier = 1.0f;
float newYaw = SHORT2ANGLE(temp);
lockedYawValue = AngleNormalize180( lockedYawValue );
float yawDiff = AngleNormalize180( newYaw ) - lockedYawValue;
if ( yawDiff > 180 )
{
multiplier = -1.0f;
yawDiff = 360 - yawDiff;
}
else if ( yawDiff < -180 )
{
//multiplier = -1.0f;
yawDiff = 360 + yawDiff;
}
// don't let the player look left or right more than the clamp, if any
if ( yawDiff > yawMax )
{
clamped = qtrue;
ps->viewangles[i] = AngleNormalize180( lockedYawValue+((yawMax-2)*multiplier) );
}
else if ( yawDiff < yawMin )
{
clamped = qtrue;
ps->viewangles[i] = AngleNormalize180( lockedYawValue+((yawMin+2)*multiplier) );
}
else
{
ps->viewangles[i] = newYaw;
}
}
*/
if ( i == YAW && lockedYaw )
{
//FIXME get this limit from the NPCs stats?
// don't let the player look up or down more than 90 degrees
if ( temp > yawClampMax )
{
ps->delta_angles[i] = (yawClampMax - cmd->angles[i]) & 0xffff; //& clamp to short
temp = yawClampMax;
clamped = qtrue;
}
else if ( temp < yawClampMin )
{
ps->delta_angles[i] = (yawClampMin - cmd->angles[i]) & 0xffff; //& clamp to short
temp = yawClampMin;
clamped = qtrue;
}
ps->viewangles[i] = SHORT2ANGLE(temp);
}
else
{
ps->viewangles[i] = SHORT2ANGLE(temp);
}
}
if ( gent )
{ //only in the real pmove
if ( (cmd->buttons & BUTTON_USE) )
{//check leaning
if ( cg.renderingThirdPerson )
{//third person lean
if ( G_OkayToLean( ps, cmd, qtrue )
&& (cmd->rightmove || (cmd->forwardmove && g_debugMelee->integer ) ) )//pushing a direction
{
int anim = -1;
if ( cmd->rightmove > 0 )
{//lean right
if ( cmd->forwardmove > 0 )
{//lean forward right
if ( ps->torsoAnim == BOTH_DODGE_HOLD_FR )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_FR;
}
}
else if ( cmd->forwardmove < 0 )
{//lean backward right
if ( ps->torsoAnim == BOTH_DODGE_HOLD_BR )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_BR;
}
}
else
{//lean right
if ( ps->torsoAnim == BOTH_DODGE_HOLD_R )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_R;
}
}
}
else if ( cmd->rightmove < 0 )
{//lean left
if ( cmd->forwardmove > 0 )
{//lean forward left
if ( ps->torsoAnim == BOTH_DODGE_HOLD_FL )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_FL;
}
}
else if ( cmd->forwardmove < 0 )
{//lean backward left
if ( ps->torsoAnim == BOTH_DODGE_HOLD_BL )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_BL;
}
}
else
{//lean left
if ( ps->torsoAnim == BOTH_DODGE_HOLD_L )
{
anim = ps->torsoAnim;
}
else
{
anim = BOTH_DODGE_L;
}
}
}
else
{//not pressing either side
if ( cmd->forwardmove > 0 )
{//lean forward
if ( PM_DodgeAnim( ps->torsoAnim ) )
{
anim = ps->torsoAnim;
}
else if ( Q_irand( 0, 1 ) )
{
anim = BOTH_DODGE_FL;
}
else
{
anim = BOTH_DODGE_FR;
}
}
else if ( cmd->forwardmove < 0 )
{//lean backward
if ( PM_DodgeAnim( ps->torsoAnim ) )
{
anim = ps->torsoAnim;
}
else if ( Q_irand( 0, 1 ) )
{
anim = BOTH_DODGE_BL;
}
else
{
anim = BOTH_DODGE_BR;
}
}
}
if ( anim != -1 )
{
int extraHoldTime = 0;
if ( PM_DodgeAnim( ps->torsoAnim )
&& !PM_DodgeHoldAnim( ps->torsoAnim ) )
{//already in a dodge
//use the hold pose, don't start it all over again
anim = BOTH_DODGE_HOLD_FL+(anim-BOTH_DODGE_FL);
extraHoldTime = 200;
}
if ( anim == pm->ps->torsoAnim )
{
if ( pm->ps->torsoAnimTimer < 100 )
{
pm->ps->torsoAnimTimer = 100;
}
}
else
{
NPC_SetAnim( gent, SETANIM_TORSO, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
}
if ( extraHoldTime && ps->torsoAnimTimer < extraHoldTime )
{
ps->torsoAnimTimer += extraHoldTime;
}
if ( ps->groundEntityNum != ENTITYNUM_NONE
&& !cmd->upmove )
{
NPC_SetAnim( gent, SETANIM_LEGS, anim, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD );
ps->legsAnimTimer = ps->torsoAnimTimer;
}
else
{
NPC_SetAnim( gent, SETANIM_LEGS, anim, SETANIM_FLAG_NORMAL );
}
ps->weaponTime = ps->torsoAnimTimer;
ps->leanStopDebounceTime = ceil((float)ps->torsoAnimTimer/50.0f);//20;
}
}
}
else if ( (!cg.renderingThirdPerson||cg.zoomMode) && cmd->rightmove != 0 && !cmd->forwardmove && cmd->upmove <= 0 )
{//Only lean if holding use button, strafing and not moving forward or back and not jumping
int leanofs = 0;
vec3_t viewangles;
if ( cmd->rightmove > 0 )
{
/*
if( pm->ps->legsAnim != LEGS_LEAN_RIGHT1)
{
PM_SetAnim(pm, SETANIM_LEGS, LEGS_LEAN_RIGHT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
}
pm->ps->legsAnimTimer = 500;//Force it to hold the anim for at least half a sec
*/
if ( ps->leanofs <= 28 )
{
leanofs = ps->leanofs + 4;
}
else
{
leanofs = 32;
}
}
else
{
/*
if ( pm->ps->legsAnim != LEGS_LEAN_LEFT1 )
{
PM_SetAnim(pm, SETANIM_LEGS, LEGS_LEAN_LEFT1, SETANIM_FLAG_OVERRIDE|SETANIM_FLAG_HOLD);
}
pm->ps->legsAnimTimer = 500;//Force it to hold the anim for at least half a sec
*/
if ( ps->leanofs >= -28 )
{
leanofs = ps->leanofs - 4;
}
else
{
leanofs = -32;
}
}
VectorCopy( ps->origin, start );
start[2] += ps->viewheight;
VectorCopy( ps->viewangles, viewangles );
viewangles[ROLL] = 0;
AngleVectors( ps->viewangles, NULL, right, NULL );
VectorNormalize( right );
right[2] = (leanofs<0)?0.25:-0.25;
VectorMA( start, leanofs, right, end );
VectorSet( tmins, -8, -8, -4 );
VectorSet( tmaxs, 8, 8, 4 );
//if we don't trace EVERY frame, can TURN while leaning and
//end up leaning into solid architecture (sigh)
gi.trace( &trace, start, tmins, tmaxs, end, gent->s.number, MASK_PLAYERSOLID );
ps->leanofs = floor((float)leanofs * trace.fraction);
ps->leanStopDebounceTime = 20;
}
else
{
if ( (cmd->forwardmove || cmd->upmove > 0) )
{
if( ( pm->ps->legsAnim == LEGS_LEAN_RIGHT1) ||
( pm->ps->legsAnim == LEGS_LEAN_LEFT1) )
{
pm->ps->legsAnimTimer = 0;//Force it to stop the anim
}
if ( ps->leanofs > 0 )
{
ps->leanofs-=4;
if ( ps->leanofs < 0 )
{
ps->leanofs = 0;
}
}
else if ( ps->leanofs < 0 )
{
ps->leanofs+=4;
if ( ps->leanofs > 0 )
{
ps->leanofs = 0;
}
}
}
}
}
else//BUTTON_USE
{
if ( ps->leanofs > 0 )
{
ps->leanofs-=4;
if ( ps->leanofs < 0 )
{
ps->leanofs = 0;
}
}
else if ( ps->leanofs < 0 )
{
ps->leanofs+=4;
if ( ps->leanofs > 0 )
{
ps->leanofs = 0;
}
}
}
}
if ( ps->leanStopDebounceTime )
{
ps->leanStopDebounceTime -= 1;
cmd->rightmove = 0;
cmd->buttons &= ~BUTTON_USE;
}
Jedi Academy Release
2013-04-04 22:35:38 +00:00
}
Reference in a new issue Copy permalink