/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles( void ) {
float speed;
if ( in_speed.active ) {
speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
} else {
speed = 0.001 * cls.frametime;
}
if ( !in_strafe.active ) {
if ( cl_mYawOverride )
{
cl.viewangles[YAW] -= cl_mYawOverride*5.0f*speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += cl_mYawOverride*5.0f*speed*cl_yawspeed->value*CL_KeyState (&in_left);
}
else
{
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
}
}
if ( cl_mPitchOverride )
{
cl.viewangles[PITCH] -= cl_mPitchOverride*5.0f*speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
cl.viewangles[PITCH] += cl_mPitchOverride*5.0f*speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
}
else
{
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
}
}
/*
================
CL_BaseMove
Send the intended movement message to the server
================
*/
void CL_BaseMove (usercmd_t *cmd)
{
CL_AdjustAngles ();
memset (cmd, 0, sizeof(*cmd));
VectorCopy (cl.viewangles, cmd->angles);
if (in_strafe.state & 1)
{
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
if (! (in_klook.state & 1) )
{
cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
}
//
// adjust for speed key
//
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
}
}
/*
================
CL_BaseMove
Send the intended movement message to the server
================
*/
void CL_BaseMove (usercmd_t *cmd)
{
if (cl.v.cameramode) // stuck in a different camera so don't move
{
memset (cmd, 0, sizeof(*cmd));
return;
}
CL_AdjustAngles ();
memset (cmd, 0, sizeof(*cmd));
VectorCopy (cl.viewangles, cmd->angles);
if (in_strafe.state & 1)
{
// cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
// cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
cmd->sidemove += 225 * CL_KeyState (&in_right);
cmd->sidemove -= 225 * CL_KeyState (&in_left);
}
// cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
// cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
cmd->sidemove += 225 * CL_KeyState (&in_moveright);
cmd->sidemove -= 225 * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
if (! (in_klook.state & 1))
{
// cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
cmd->forwardmove += 200 * CL_KeyState (&in_forward);
// cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
cmd->forwardmove -= 200 * CL_KeyState (&in_back);
}
// adjust for speed key, but not if "always run" has been chosen
// speed key now acts as slow key when always run is chosen - OS
// if ( ( (cl_forwardspeed.value > 200) ||(in_speed.state & 1) || cl.spectator)
if ( (((cl_forwardspeed.value > 200) ^ (in_speed.state & 1)) || cl.spectator)
&& (cl.v.hasted <= 1) )
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
}
// Hasted player?
if (cl.v.hasted)
{
cmd->forwardmove = cmd->forwardmove * cl.v.hasted;
cmd->sidemove = cmd->sidemove * cl.v.hasted;
cmd->upmove = cmd->upmove * cl.v.hasted;
}
cmd->light_level = cl.light_level;
}
/*
================
CL_BaseMove
Send the intended movement message to the server
================
*/
void CL_BaseMove (usercmd_t *cmd)
{
CL_AdjustAngles ();
memset (cmd, 0, sizeof(*cmd));
if (cl.v.cameramode) // Stuck in a different camera so don't move
{
return;
}
VectorCopy (cl.viewangles, cmd->angles);
if (in_strafe.state & 1)
{
// cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
// cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
cmd->sidemove += 225 * CL_KeyState (&in_right);
cmd->sidemove -= 225 * CL_KeyState (&in_left);
}
// cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
// cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
cmd->sidemove += 225 * CL_KeyState (&in_moveright);
cmd->sidemove -= 225 * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
if (! (in_klook.state & 1) )
{
// cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
// cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
cmd->forwardmove += 200 * CL_KeyState (&in_forward);
cmd->forwardmove -= 200 * CL_KeyState (&in_back);
}
//
// adjust for speed key
//
if ((cl.spectator || cl_forwardspeed.value > 200 || in_speed.state & 1) && cl.v.hasted <= 1)
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
}
// Hasted player?
if (cl.v.hasted)
{
cmd->forwardmove = cmd->forwardmove * cl.v.hasted;
cmd->sidemove = cmd->sidemove * cl.v.hasted;
cmd->upmove = cmd->upmove * cl.v.hasted;
}
cmd->light_level = cl.light_level;
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
static void CL_AdjustAngles( void ) {
double speed;
if ( in_speed.active ) {
speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
} else {
speed = 0.001 * cls.frametime;
}
if ( !in_strafe.active ) {
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
}
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_lookup);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_lookdown);
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles( void ) {
float speed;
if ( kb[KB_SPEED].active ) {
speed = 0.001 * cls.frametime * cl_anglespeedkey->value;
} else {
speed = 0.001 * cls.frametime;
}
if ( !kb[KB_STRAFE].active ) {
cl.viewangles[YAW] -= speed * cl_yawspeed->value * CL_KeyState( &kb[KB_RIGHT] );
cl.viewangles[YAW] += speed * cl_yawspeed->value * CL_KeyState( &kb[KB_LEFT] );
}
cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState( &kb[KB_LOOKUP] );
cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState( &kb[KB_LOOKDOWN] );
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles (void)
{
float speed;
float up, down;
if (in_speed.state & 1)
speed = host_frametime * cl_anglespeedkey.value;
else
speed = host_frametime;
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
}
// FIXME: This is a cheap way of doing this, it belongs in V_CalcViewRoll
// but I don't see where I can get the yaw velocity, I have to get on to other things so here it is
if ((CL_KeyState (&in_left)!=0) && (cl.v.movetype==MOVETYPE_FLY))
cl.idealroll=-10;
else if ((CL_KeyState (&in_right)!=0) && (cl.v.movetype==MOVETYPE_FLY))
cl.idealroll=10;
else
cl.idealroll=0;
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
if (up || down)
V_StopPitchDrift ();
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
if (cl.viewangles[ROLL] > 50)
cl.viewangles[ROLL] = 50;
if (cl.viewangles[ROLL] < -50)
cl.viewangles[ROLL] = -50;
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles (void)
{
float speed;
float up, down;
if (in_speed.state & 1)
speed = cls.netFrameTime * cl_anglespeedkey->value;
else
speed = cls.netFrameTime;
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
}
if (in_klook.state & 1)
{
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * down;
}
void Bot_CL_KeyMove( )
{
int forwardmove = 0, sidemove = 0, upmove = 0;
int buttons = 0;
buttons = ( ( self->s.v.button0 ) ? 1 : 0 ) + ( ( self->s.v.button2 ) ? 2 : 0 );
sidemove += self->maxstrafespeed * CL_KeyState( KEY_MOVERIGHT );
sidemove -= self->maxstrafespeed * CL_KeyState( KEY_MOVELEFT );
upmove += 200 * CL_KeyState( KEY_MOVEUP );
upmove -= 200 * CL_KeyState( KEY_MOVEDOWN );
forwardmove += self->maxfbspeed * CL_KeyState( KEY_MOVEFORWARD );
forwardmove -= self->maxfbspeed * CL_KeyState( KEY_MOVEBACK );
if ( self->s.v.v_angle[0] > 80 )
self->s.v.v_angle[0] = 80;
else
{
if ( self->s.v.v_angle[0] < -70 )
self->s.v.v_angle[0] = -70;
}
//self->s.v.v_angle[2] = 0;
self->s.v.v_angle[1] = anglemod( self->s.v.v_angle[1] );
trap_SetBotCMD( NUM_FOR_EDICT( self ), bot_frametime * 1000,
PASSVEC3(self->s.v.v_angle),
forwardmove, sidemove, upmove, buttons, self->s.v.impulse );
}
/*
* CL_AddAnglesFromKeys
*/
static void CL_AddAnglesFromKeys( int frametime )
{
float speed;
if( !frametime )
return;
if( in_speed.state & 1 )
speed = ( (float)frametime * 0.001f ) * cl_anglespeedkey->value;
else
speed = (float)frametime * 0.001f;
if( !( in_strafe.state & 1 ) )
{
cl.viewangles[YAW] -= speed * cl_yawspeed->value * CL_KeyState( &in_right );
cl.viewangles[YAW] += speed * cl_yawspeed->value * CL_KeyState( &in_left );
}
if( in_klook.state & 1 )
{
cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState( &in_forward );
cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState( &in_back );
}
cl.viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState( &in_lookup );
cl.viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState( &in_lookdown );
}
void CL_BaseMove (usercmd_t *cmd)
{
if (cls.signon != SIGNONS)
return;
if (deathcam_active)
CL_AdjustAnglesWhenYoureDead ();
else
CL_AdjustAngles ();
Q_memset (cmd, 0, sizeof(*cmd));
if (in_strafe.state & 1)
{
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
if (! (in_klook.state & 1) )
{
cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
}
// adjust for speed key
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey->value;
cmd->sidemove *= cl_movespeedkey->value;
cmd->upmove *= cl_movespeedkey->value;
}
// react to onground state changes (for gun bob)
if (cl.onground)
{
if (!cl.oldonground)
cl.hitgroundtime = cl.time;
cl.lastongroundtime = cl.time;
}
cl.oldonground = cl.onground;
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles (void)
{
float speed;
float up, down;
if (in_speed.state & 1)
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes start
// speed = host_frametime * cl_anglespeedkey->value;
speed = host_org_frametime * cl_anglespeedkey->value;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes end
else
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes start
// speed = host_frametime;
speed = host_org_frametime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes end
cl.viewangles[ROLL] -= speed*cl_yawspeed->value*CL_KeyState (&in_tiltright);
cl.viewangles[ROLL] += speed*cl_yawspeed->value*CL_KeyState (&in_tiltleft);
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed->value * down;
if (up || down)
V_StopPitchDrift ();
if (cl.viewangles[PITCH] > (int)m_lockdown->value)
cl.viewangles[PITCH] = (int)m_lockdown->value;
if (cl.viewangles[PITCH] < (int)m_lockup->value)
cl.viewangles[PITCH] = (int)m_lockup->value;
}
/*
================
CL_KeyMove
Sets the usercmd_t based on key states
================
*/
void
CL_KeyMove(usercmd_t * cmd)
{
int movespeed;
int forward, side, up;
//
// adjust for speed key / running
// the walking flag is to keep animations consistant
// even during acceleration and develeration
//
if (in_speed.active ^ cl_run->integer)
{
movespeed = 127;
cmd->buttons &= ~BUTTON_WALKING;
}
else
{
cmd->buttons |= BUTTON_WALKING;
movespeed = 64;
}
forward = 0;
side = 0;
up = 0;
if (in_strafe.active)
{
side += movespeed * CL_KeyState(&in_right);
side -= movespeed * CL_KeyState(&in_left);
}
side += movespeed * CL_KeyState(&in_moveright);
side -= movespeed * CL_KeyState(&in_moveleft);
up += movespeed * CL_KeyState(&in_up);
up -= movespeed * CL_KeyState(&in_down);
forward += movespeed * CL_KeyState(&in_forward);
forward -= movespeed * CL_KeyState(&in_back);
cmd->forwardmove = ClampChar(forward);
cmd->rightmove = ClampChar(side);
cmd->upmove = ClampChar(up);
}
// Moves the local angle positions.
void CL_AdjustAngles (void)
{
float basespeed, speed, up, down, frametime;
if (Movie_IsCapturing() && movie_steadycam.value)
frametime = movie_fps.value > 0 ? 1.0 / movie_fps.value : 1 / 30.0;
else
frametime = cls.trueframetime;
basespeed = ((in_speed.state & 1) ? cl_anglespeedkey.value : 1);
if (!(in_strafe.state & 1))
{
speed = basespeed * cl_yawspeed.value;
if ((cl.fpd & FPD_LIMIT_YAW) || allow_scripts.value < 2)
speed = bound(-900, speed, 900);
speed *= frametime;
cl.viewangles[YAW] -= speed * CL_KeyState(&in_right, true);
cl.viewangles[YAW] += speed * CL_KeyState(&in_left, true);
if (cl.viewangles[YAW] < 0)
cl.viewangles[YAW] += 360.0;
else if (cl.viewangles[YAW] > 360)
cl.viewangles[YAW] -= 360.0;
}
speed = basespeed * cl_pitchspeed.value;
if ((cl.fpd & FPD_LIMIT_PITCH) || allow_scripts.value == 0)
speed = bound(-700, speed, 700);
speed *= frametime;
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed * CL_KeyState(&in_forward, true);
cl.viewangles[PITCH] += speed * CL_KeyState(&in_back, true);
}
up = CL_KeyState(&in_lookup, true);
down = CL_KeyState(&in_lookdown, true);
cl.viewangles[PITCH] -= speed * up;
cl.viewangles[PITCH] += speed * down;
if (up || down)
V_StopPitchDrift();
if (cl.viewangles[PITCH] > cl.maxpitch)
cl.viewangles[PITCH] = cl.maxpitch;
if (cl.viewangles[PITCH] < cl.minpitch)
cl.viewangles[PITCH] = cl.minpitch;
//cl.viewangles[PITCH] = bound(cl.min!pitch, cl.viewangles[PITCH], cl.ma!xpitch);
cl.viewangles[ROLL] = bound(-50, cl.viewangles[ROLL], 50);
}
/*
* CL_AddMovementFromKeys
*/
static void CL_AddMovementFromKeys( vec3_t movement )
{
if( in_strafe.state & 1 )
{
movement[0] += ( float )CL_KeyState( &in_right );
movement[0] -= ( float )CL_KeyState( &in_left );
}
movement[0] += ( float )CL_KeyState( &in_moveright );
movement[0] -= ( float )CL_KeyState( &in_moveleft );
movement[2] += ( float )CL_KeyState( &in_up );
movement[2] -= ( float )CL_KeyState( &in_down );
if( !( in_klook.state & 1 ) )
{
movement[1] += ( float )CL_KeyState( &in_forward );
movement[1] -= ( float )CL_KeyState( &in_back );
}
}
/*
================
CL_BaseMove
Send the intended movement message to the server
================
*/
void CL_BaseMove (usercmd_t *cmd)
{
if (cls.signon != SIGNONS)
return;
CL_AdjustAngles ();
Q_memset (cmd, 0, sizeof(*cmd));
if (in_strafe.state & 1)
{
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down);
if (! (in_klook.state & 1) )
{
cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back);
}
//
// adjust for speed key
//
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
}
#ifdef QUAKE2
cmd->lightlevel = cl.light_level;
#endif
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles ( float frametime, float *viewangles )
{
float speed;
float up, down;
if (in_speed.state & 1)
{
speed = frametime * cl_anglespeedkey->value;
}
else
{
speed = frametime;
}
// Ricochet: Don't let them move the mouse when they're in spectator mode
if ( bCanMoveMouse() == FALSE )
return;
if (!(in_strafe.state & 1))
{
viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
viewangles[YAW] = anglemod(viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
viewangles[PITCH] += speed*cl_pitchspeed->value * down;
if (up || down)
V_StopPitchDrift ();
if (viewangles[PITCH] > cl_pitchdown->value)
viewangles[PITCH] = cl_pitchdown->value;
if (viewangles[PITCH] < -cl_pitchup->value)
viewangles[PITCH] = -cl_pitchup->value;
if (viewangles[ROLL] > 50)
viewangles[ROLL] = 50;
if (viewangles[ROLL] < -50)
viewangles[ROLL] = -50;
}
/*
================
CL_BaseMove
Build the intended movement vector
================
*/
static void CL_BaseMove( vec3_t move ) {
if( in_strafe.state & 1 ) {
move[1] += cl_sidespeed->value * CL_KeyState( &in_right );
move[1] -= cl_sidespeed->value * CL_KeyState( &in_left );
}
move[1] += cl_sidespeed->value * CL_KeyState( &in_moveright );
move[1] -= cl_sidespeed->value * CL_KeyState( &in_moveleft );
move[2] += cl_upspeed->value * CL_KeyState( &in_up );
move[2] -= cl_upspeed->value * CL_KeyState( &in_down );
if( !( in_klook.state & 1 ) ) {
move[0] += cl_forwardspeed->value * CL_KeyState( &in_forward );
move[0] -= cl_forwardspeed->value * CL_KeyState( &in_back );
}
// adjust for speed key / running
if( ( in_speed.state & 1 ) ^ cl_run->integer ) {
VectorScale( move, 2, move );
}
}
/*
* CL_AddMovementFromKeys
*/
static void CL_AddMovementFromKeys( short *forwardmove, short *sidemove, short *upmove, int frametime )
{
if( !frametime )
return;
if( in_strafe.state & 1 )
{
*sidemove += frametime * CL_KeyState( &in_right );
*sidemove -= frametime * CL_KeyState( &in_left );
}
*sidemove += frametime * CL_KeyState( &in_moveright );
*sidemove -= frametime * CL_KeyState( &in_moveleft );
*upmove += frametime * CL_KeyState( &in_up );
*upmove -= frametime * CL_KeyState( &in_down );
if( !( in_klook.state & 1 ) )
{
*forwardmove += frametime * CL_KeyState( &in_forward );
*forwardmove -= frametime * CL_KeyState( &in_back );
}
}
================
*/
void CL_AdjustAngles ( float frametime, float *viewangles )
{
float speed;
float up, down;
if (in_speed.state & 1)
{
speed = frametime * cl_anglespeedkey->value;
}
else
{
speed = frametime;
}
if (!(in_strafe.state & 1))
{
viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
viewangles[YAW] = anglemod(viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
viewangles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
viewangles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
viewangles[PITCH] -= speed*cl_pitchspeed->value * up;
viewangles[PITCH] += speed*cl_pitchspeed->value * down;
if (up || down)
V_StopPitchDrift ();
if (viewangles[PITCH] > cl_pitchdown->value)
viewangles[PITCH] = cl_pitchdown->value;
if (viewangles[PITCH] < -cl_pitchup->value)
viewangles[PITCH] = -cl_pitchup->value;
if (viewangles[ROLL] > 50)
viewangles[ROLL] = 50;
if (viewangles[ROLL] < -50)
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles (void)
{
float speed;
float up, down;
if ((cl_forwardspeed.value > 200) ^ (in_speed.state & 1))
speed = host_frametime * cl_anglespeedkey.value;
else
speed = host_frametime;
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
if (up || down)
V_StopPitchDrift ();
//johnfitz -- variable pitch clamping
if (cl.viewangles[PITCH] > cl_maxpitch.value)
cl.viewangles[PITCH] = cl_maxpitch.value;
if (cl.viewangles[PITCH] < cl_minpitch.value)
cl.viewangles[PITCH] = cl_minpitch.value;
//johnfitz
if (cl.viewangles[ROLL] > 50)
cl.viewangles[ROLL] = 50;
if (cl.viewangles[ROLL] < -50)
cl.viewangles[ROLL] = -50;
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles (void)
{
float speed;
float up, down;
if (in_speed.state & 1)
speed = host_frametime * cl_anglespeedkey.value;
else
speed = host_frametime;
if (!(in_strafe.state & 1))
{
cl.viewangles[YAW] -= speed*cl_yawspeed.value*CL_KeyState (&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed.value*CL_KeyState (&in_left);
cl.viewangles[YAW] = anglemod(cl.viewangles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * CL_KeyState (&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
cl.viewangles[PITCH] -= speed*cl_pitchspeed.value * up;
cl.viewangles[PITCH] += speed*cl_pitchspeed.value * down;
if (up || down)
V_StopPitchDrift ();
if (cl.viewangles[PITCH] > 80)
cl.viewangles[PITCH] = 80;
if (cl.viewangles[PITCH] < -70)
cl.viewangles[PITCH] = -70;
if (cl.viewangles[ROLL] > 50)
cl.viewangles[ROLL] = 50;
if (cl.viewangles[ROLL] < -50)
cl.viewangles[ROLL] = -50;
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
static void CL_AdjustAngles( int msec ) {
float speed;
if( in_speed.state & 1 )
speed = msec * cl_anglespeedkey->value * 0.001f;
else
speed = msec * 0.001f;
if( !( in_strafe.state & 1 ) ) {
cl.viewangles[YAW] -= speed*cl_yawspeed->value*CL_KeyState(&in_right);
cl.viewangles[YAW] += speed*cl_yawspeed->value*CL_KeyState(&in_left);
}
if( in_klook.state & 1 ) {
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value*CL_KeyState(&in_forward);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value*CL_KeyState(&in_back);
}
cl.viewangles[PITCH] -= speed*cl_pitchspeed->value*CL_KeyState(&in_lookup);
cl.viewangles[PITCH] += speed*cl_pitchspeed->value*CL_KeyState(&in_lookdown);
}
/*
================
CL_AdjustAngles
Moves the local angle positions
================
*/
void CL_AdjustAngles( float frametime, Vector &viewangles )
{
float speed;
float up, down;
if( in_speed.state & BUTTON_DOWN )
{
speed = frametime * cl_anglespeedkey->value;
}
else
{
speed = frametime;
}
if( !( in_strafe.state & BUTTON_DOWN ))
{
viewangles[YAW] -= speed * cl_yawspeed->value * CL_KeyState( &in_right );
viewangles[YAW] += speed * cl_yawspeed->value * CL_KeyState( &in_left );
viewangles[YAW] = anglemod( viewangles[YAW] );
}
if( in_klook.state & BUTTON_DOWN )
{
V_StopPitchDrift ();
viewangles[PITCH] -= speed * cl_pitchspeed->value * CL_KeyState( &in_forward );
viewangles[PITCH] += speed * cl_pitchspeed->value * CL_KeyState( &in_back );
}
up = CL_KeyState( &in_lookup );
down = CL_KeyState( &in_lookdown );
viewangles[PITCH] -= speed * cl_pitchspeed->value * up;
viewangles[PITCH] += speed * cl_pitchspeed->value * down;
if( up || down )
V_StopPitchDrift ();
viewangles[PITCH] = bound( -cl_pitchup->value, viewangles[PITCH], cl_pitchdown->value );
viewangles[ROLL] = bound( -50, viewangles[ROLL], 50 );
}
// leilei - deathcam hacks suck!
void CL_AdjustAnglesWhenYoureDead (void)
{
float speed;
float up, down;
if (in_speed.state & 1)
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes start
// speed = host_frametime * cl_anglespeedkey->value;
speed = host_org_frametime * cl_anglespeedkey->value;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes end
else
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes start
// speed = host_frametime;
speed = host_org_frametime;
// 2001-10-20 TIMESCALE extension by Tomaz/Maddes end
if (!(in_strafe.state & 1))
{
deathcam_angles[YAW] -= speed*cl_yawspeed->value*CL_KeyState (&in_right);
deathcam_angles[YAW] += speed*cl_yawspeed->value*CL_KeyState (&in_left);
deathcam_angles[YAW] = anglemod(deathcam_angles[YAW]);
}
if (in_klook.state & 1)
{
V_StopPitchDrift ();
deathcam_angles[PITCH] -= speed*cl_pitchspeed->value * CL_KeyState (&in_forward);
deathcam_angles[PITCH] += speed*cl_pitchspeed->value * CL_KeyState (&in_back);
}
up = CL_KeyState (&in_lookup);
down = CL_KeyState(&in_lookdown);
deathcam_angles[PITCH] -= speed*cl_pitchspeed->value * up;
deathcam_angles[PITCH] += speed*cl_pitchspeed->value * down;
if (up || down)
V_StopPitchDrift ();
}
/*
================
CL_KeyMove
Sets the usercmd_t based on key states
================
*/
void CL_KeyMove( usercmd_t *cmd ) {
int movespeed;
int forward, side, up;
// Rafael Kick
int kick;
// done
//
// adjust for speed key / running
// the walking flag is to keep animations consistant
// even during acceleration and develeration
//
if ( kb[KB_SPEED].active ^ cl_run->integer ) {
movespeed = 127;
cmd->buttons &= ~BUTTON_WALKING;
} else {
cmd->buttons |= BUTTON_WALKING;
movespeed = 64;
}
forward = 0;
side = 0;
up = 0;
if ( kb[KB_STRAFE].active ) {
side += movespeed * CL_KeyState( &kb[KB_RIGHT] );
side -= movespeed * CL_KeyState( &kb[KB_LEFT] );
}
side += movespeed * CL_KeyState( &kb[KB_MOVERIGHT] );
side -= movespeed * CL_KeyState( &kb[KB_MOVELEFT] );
//----(SA) added
if ( cmd->buttons & BUTTON_ACTIVATE ) {
if ( side > 0 ) {
cmd->wbuttons |= WBUTTON_LEANRIGHT;
} else if ( side < 0 ) {
cmd->wbuttons |= WBUTTON_LEANLEFT;
}
side = 0; // disallow the strafe when holding 'activate'
}
//----(SA) end
up += movespeed * CL_KeyState( &kb[KB_UP] );
up -= movespeed * CL_KeyState( &kb[KB_DOWN] );
forward += movespeed * CL_KeyState( &kb[KB_FORWARD] );
forward -= movespeed * CL_KeyState( &kb[KB_BACK] );
// Rafael Kick
kick = CL_KeyState( &kb[KB_KICK] );
// done
if ( !( cl.snap.ps.persistant[PERS_HWEAPON_USE] ) ) {
cmd->forwardmove = ClampChar( forward );
cmd->rightmove = ClampChar( side );
cmd->upmove = ClampChar( up );
// Rafael - Kick
cmd->wolfkick = ClampChar( kick );
// done
}
}
// Send the intended movement message to the server.
void CL_BaseMove (usercmd_t *cmd)
{
CL_AdjustAngles ();
memset (cmd, 0, sizeof(*cmd));
VectorCopy (cl.viewangles, cmd->angles);
if (cl_iDrive.integer)
{
float s1, s2;
if (in_strafe.state & 1)
{
s1 = CL_KeyState (&in_right, false);
s2 = CL_KeyState (&in_left, false);
if (s1 && s2)
{
if (in_right.downtime > in_left.downtime)
s2 = 0;
if (in_right.downtime < in_left.downtime)
s1 = 0;
}
cmd->sidemove += cl_sidespeed.value * s1;
cmd->sidemove -= cl_sidespeed.value * s2;
}
s1 = CL_KeyState (&in_moveright, false);
s2 = CL_KeyState (&in_moveleft, false);
if (s1 && s2)
{
if (in_moveright.downtime > in_moveleft.downtime)
s2 = 0;
if (in_moveright.downtime < in_moveleft.downtime)
s1 = 0;
}
cmd->sidemove += cl_sidespeed.value * s1;
cmd->sidemove -= cl_sidespeed.value * s2;
s1 = CL_KeyState (&in_up, false);
s2 = CL_KeyState (&in_down, false);
if (s1 && s2)
{
if (in_up.downtime > in_down.downtime)
s2 = 0;
if (in_up.downtime < in_down.downtime)
s1 = 0;
}
cmd->upmove += cl_upspeed.value * s1;
cmd->upmove -= cl_upspeed.value * s2;
if (!(in_klook.state & 1))
{
s1 = CL_KeyState (&in_forward, false);
s2 = CL_KeyState (&in_back, false);
if (s1 && s2)
{
if (in_forward.downtime > in_back.downtime)
s2 = 0;
if (in_forward.downtime < in_back.downtime)
s1 = 0;
}
cmd->forwardmove += cl_forwardspeed.value * s1;
cmd->forwardmove -= cl_backspeed.value * s2;
}
}
else
{
if (in_strafe.state & 1)
{
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_right, false);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_left, false);
}
cmd->sidemove += cl_sidespeed.value * CL_KeyState (&in_moveright, false);
cmd->sidemove -= cl_sidespeed.value * CL_KeyState (&in_moveleft, false);
cmd->upmove += cl_upspeed.value * CL_KeyState (&in_up, false);
cmd->upmove -= cl_upspeed.value * CL_KeyState (&in_down, false);
if (!(in_klook.state & 1))
{
cmd->forwardmove += cl_forwardspeed.value * CL_KeyState (&in_forward, false);
cmd->forwardmove -= cl_backspeed.value * CL_KeyState (&in_back, false);
}
}
// adjust for speed key
if (in_speed.state & 1)
{
cmd->forwardmove *= cl_movespeedkey.value;
cmd->sidemove *= cl_movespeedkey.value;
cmd->upmove *= cl_movespeedkey.value;
}
#ifdef JSS_CAM
{
static float zoomspeed = 0;
if ((cls.demoplayback || cl.spectator) && Cvar_Value("cam_thirdperson") && !Cvar_Value("cam_lockpos"))
{
zoomspeed -= CL_KeyState(&in_forward, false) * cls.trueframetime * cam_zoomaccel.value;
zoomspeed += CL_KeyState(&in_back, false) * cls.trueframetime * cam_zoomaccel.value;
if (!CL_KeyState(&in_forward, false) && !CL_KeyState(&in_back, false))
{
if (zoomspeed > 0)
{
zoomspeed -= cls.trueframetime * cam_zoomaccel.value;
if (zoomspeed < 0)
zoomspeed = 0;
}
else if (zoomspeed < 0)
{
zoomspeed += cls.trueframetime * cam_zoomaccel.value;
if (zoomspeed > 0)
zoomspeed = 0;
}
}
zoomspeed = bound (-cam_zoomspeed.value, zoomspeed, cam_zoomspeed.value);
if (zoomspeed)
{
float dist = Cvar_Value("cam_dist");
dist += cls.trueframetime * zoomspeed;
if (dist < 0)
dist = 0;
Cvar_SetValue (Cvar_Find("cam_dist"), dist);
}
}
}
#endif // JSS_CAM
}
void CL_DLLEXPORT CAM_Think( void )
{
RecClCamThink();
#ifdef HL_CAMERA
vec3_t origin;
vec3_t ext, pnt, camForward, camRight, camUp;
moveclip_t clip;
float dist;
vec3_t camAngles;
float flSensitivity;
#ifdef LATER
int i;
#endif
vec3_t viewangles;
switch( (int) cam_command->value )
{
case CAM_COMMAND_TOTHIRDPERSON:
CAM_ToThirdPerson();
break;
case CAM_COMMAND_TOFIRSTPERSON:
CAM_ToFirstPerson();
break;
case CAM_COMMAND_NONE:
default:
break;
}
if( !cam_thirdperson )
return;
#ifdef LATER
if ( cam_contain->value )
{
gEngfuncs.GetClientOrigin( origin );
ext[0] = ext[1] = ext[2] = 0.0;
}
#endif
camAngles[ PITCH ] = cam_idealpitch->value;
camAngles[ YAW ] = cam_idealyaw->value;
dist = cam_idealdist->value;
//
//movement of the camera with the mouse
//
if (cam_mousemove)
{
//get windows cursor position
GetCursorPos (&cam_mouse);
//check for X delta values and adjust accordingly
//eventually adjust YAW based on amount of movement
//don't do any movement of the cam using YAW/PITCH if we are zooming in/out the camera
if (!cam_distancemove)
{
//keep the camera within certain limits around the player (ie avoid certain bad viewing angles)
if (cam_mouse.x>gEngfuncs.GetWindowCenterX())
{
//if ((camAngles[YAW]>=225.0)||(camAngles[YAW]<135.0))
if (camAngles[YAW]<c_maxyaw->value)
{
camAngles[ YAW ] += (CAM_ANGLE_MOVE)*((cam_mouse.x-gEngfuncs.GetWindowCenterX())/2);
}
if (camAngles[YAW]>c_maxyaw->value)
{
camAngles[YAW]=c_maxyaw->value;
}
}
else if (cam_mouse.x<gEngfuncs.GetWindowCenterX())
{
//if ((camAngles[YAW]<=135.0)||(camAngles[YAW]>225.0))
if (camAngles[YAW]>c_minyaw->value)
{
camAngles[ YAW ] -= (CAM_ANGLE_MOVE)* ((gEngfuncs.GetWindowCenterX()-cam_mouse.x)/2);
}
if (camAngles[YAW]<c_minyaw->value)
{
camAngles[YAW]=c_minyaw->value;
}
}
//check for y delta values and adjust accordingly
//eventually adjust PITCH based on amount of movement
//also make sure camera is within bounds
if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
{
if(camAngles[PITCH]<c_maxpitch->value)
{
camAngles[PITCH] +=(CAM_ANGLE_MOVE)* ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
}
if (camAngles[PITCH]>c_maxpitch->value)
{
camAngles[PITCH]=c_maxpitch->value;
}
}
else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
{
if (camAngles[PITCH]>c_minpitch->value)
{
camAngles[PITCH] -= (CAM_ANGLE_MOVE)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
}
if (camAngles[PITCH]<c_minpitch->value)
{
camAngles[PITCH]=c_minpitch->value;
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
if ( ( flSensitivity = gHUD.GetSensitivity() ) != 0 )
{
cam_old_mouse_x=cam_mouse.x*flSensitivity;
cam_old_mouse_y=cam_mouse.y*flSensitivity;
}
else
{
cam_old_mouse_x=cam_mouse.x;
cam_old_mouse_y=cam_mouse.y;
}
SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
}
}
//Nathan code here
if( CL_KeyState( &cam_pitchup ) )
camAngles[ PITCH ] += CAM_ANGLE_DELTA;
else if( CL_KeyState( &cam_pitchdown ) )
camAngles[ PITCH ] -= CAM_ANGLE_DELTA;
if( CL_KeyState( &cam_yawleft ) )
camAngles[ YAW ] -= CAM_ANGLE_DELTA;
else if( CL_KeyState( &cam_yawright ) )
camAngles[ YAW ] += CAM_ANGLE_DELTA;
if( CL_KeyState( &cam_in ) )
{
dist -= CAM_DIST_DELTA;
if( dist < CAM_MIN_DIST )
{
// If we go back into first person, reset the angle
camAngles[ PITCH ] = 0;
camAngles[ YAW ] = 0;
dist = CAM_MIN_DIST;
}
}
else if( CL_KeyState( &cam_out ) )
dist += CAM_DIST_DELTA;
if (cam_distancemove)
{
if (cam_mouse.y>gEngfuncs.GetWindowCenterY())
{
if(dist<c_maxdistance->value)
{
dist +=CAM_DIST_DELTA * ((cam_mouse.y-gEngfuncs.GetWindowCenterY())/2);
}
if (dist>c_maxdistance->value)
{
dist=c_maxdistance->value;
}
}
else if (cam_mouse.y<gEngfuncs.GetWindowCenterY())
{
if (dist>c_mindistance->value)
{
dist -= (CAM_DIST_DELTA)*((gEngfuncs.GetWindowCenterY()-cam_mouse.y)/2);
}
if (dist<c_mindistance->value)
{
dist=c_mindistance->value;
}
}
//set old mouse coordinates to current mouse coordinates
//since we are done with the mouse
cam_old_mouse_x=cam_mouse.x*gHUD.GetSensitivity();
cam_old_mouse_y=cam_mouse.y*gHUD.GetSensitivity();
SetCursorPos (gEngfuncs.GetWindowCenterX(), gEngfuncs.GetWindowCenterY());
}
#ifdef LATER
if( cam_contain->value )
{
// check new ideal
VectorCopy( origin, pnt );
AngleVectors( camAngles, camForward, camRight, camUp );
for (i=0 ; i<3 ; i++)
pnt[i] += -dist*camForward[i];
// check line from r_refdef.vieworg to pnt
memset ( &clip, 0, sizeof ( moveclip_t ) );
clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
if( clip.trace.fraction == 1.0 )
{
// update ideal
cam_idealpitch->value = camAngles[ PITCH ];
cam_idealyaw->value = camAngles[ YAW ];
cam_idealdist->value = dist;
}
}
else
#endif
{
// update ideal
cam_idealpitch->value = camAngles[ PITCH ];
cam_idealyaw->value = camAngles[ YAW ];
cam_idealdist->value = dist;
}
// Move towards ideal
VectorCopy( cam_ofs, camAngles );
gEngfuncs.GetViewAngles( (float *)viewangles );
if( cam_snapto->value )
{
camAngles[ YAW ] = cam_idealyaw->value + viewangles[ YAW ];
camAngles[ PITCH ] = cam_idealpitch->value + viewangles[ PITCH ];
camAngles[ 2 ] = cam_idealdist->value;
}
else
{
if( camAngles[ YAW ] - viewangles[ YAW ] != cam_idealyaw->value )
camAngles[ YAW ] = MoveToward( camAngles[ YAW ], cam_idealyaw->value + viewangles[ YAW ], CAM_ANGLE_SPEED );
if( camAngles[ PITCH ] - viewangles[ PITCH ] != cam_idealpitch->value )
camAngles[ PITCH ] = MoveToward( camAngles[ PITCH ], cam_idealpitch->value + viewangles[ PITCH ], CAM_ANGLE_SPEED );
if( abs( camAngles[ 2 ] - cam_idealdist->value ) < 2.0 )
camAngles[ 2 ] = cam_idealdist->value;
else
camAngles[ 2 ] += ( cam_idealdist->value - camAngles[ 2 ] ) / 4.0;
}
#ifdef LATER
if( cam_contain->value )
{
// Test new position
dist = camAngles[ ROLL ];
camAngles[ ROLL ] = 0;
VectorCopy( origin, pnt );
AngleVectors( camAngles, camForward, camRight, camUp );
for (i=0 ; i<3 ; i++)
pnt[i] += -dist*camForward[i];
// check line from r_refdef.vieworg to pnt
memset ( &clip, 0, sizeof ( moveclip_t ) );
ext[0] = ext[1] = ext[2] = 0.0;
clip.trace = SV_ClipMoveToEntity( sv.edicts, r_refdef.vieworg, ext, ext, pnt );
if( clip.trace.fraction != 1.0 )
return;
}
#endif
cam_ofs[ 0 ] = camAngles[ 0 ];
cam_ofs[ 1 ] = camAngles[ 1 ];
cam_ofs[ 2 ] = dist;
// HL_CAMERA
#endif
}
================
*/
void DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active )
{
float spd;
vec3_t viewangles;
static vec3_t oldangles;
if ( active )
{
//memset( viewangles, 0, sizeof( vec3_t ) );
//viewangles[ 0 ] = viewangles[ 1 ] = viewangles[ 2 ] = 0.0;
gEngfuncs.GetViewAngles( (float *)viewangles );
if( !gHUD.m_iPlayerFrozen )
CL_AdjustAngles ( frametime, viewangles );
memset (cmd, 0, sizeof(*cmd));
gEngfuncs.SetViewAngles( (float *)viewangles );
if ( in_strafe.state & 1 )
{
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
if ( !(in_klook.state & 1 ) )
{
cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
}
// adjust for speed key
if ( in_speed.state & 1 )
{
cmd->forwardmove *= cl_movespeedkey->value;
cmd->sidemove *= cl_movespeedkey->value;
cmd->upmove *= cl_movespeedkey->value;
}
// clip to maxspeed
spd = gEngfuncs.GetClientMaxspeed();
if ( spd != 0.0 )
{
// scale the 3 speeds so that the total velocity is not > cl.maxspeed
float fmov = sqrt( (cmd->forwardmove*cmd->forwardmove) + (cmd->sidemove*cmd->sidemove) + (cmd->upmove*cmd->upmove) );
if ( fmov > spd )
{
float fratio = spd / fmov;
cmd->forwardmove *= fratio;
cmd->sidemove *= fratio;
cmd->upmove *= fratio;
}
}
// Allow mice and other controllers to add their inputs
if( !gHUD.m_iPlayerFrozen )
IN_Move ( frametime, cmd );
}
cmd->impulse = in_impulse;
in_impulse = 0;
cmd->weaponselect = g_weaponselect;
g_weaponselect = 0;
//
// set button and flag bits
//
cmd->buttons = CL_ButtonBits( 1 );
// If they're in a modal dialog, ignore the attack button.
// if(GetClientVoiceMgr()->IsInSquelchMode())
// cmd->buttons &= ~IN_ATTACK;
// Using joystick?
if ( in_joystick->value )
{
if ( cmd->forwardmove > 0 )
{
cmd->buttons |= IN_FORWARD;
}
else if ( cmd->forwardmove < 0 )
{
cmd->buttons |= IN_BACK;
}
}
gEngfuncs.GetViewAngles( (float *)viewangles );
// Set current view angles.
if ( g_iAlive && !gHUD.m_iPlayerFrozen )
{
VectorCopy( viewangles, cmd->viewangles );
VectorCopy( viewangles, oldangles );
}
else
{
VectorCopy( oldangles, cmd->viewangles );
}
// buz: in spec tank mode check for bounds
if (gHUD.m_SpecTank_on)
{
// check yaw
float ofs = viewangles[YAW] - gHUD.m_SpecTank_defYaw;
if (ofs > 180) ofs -= 360;
else if (ofs < -180) ofs += 360;
if (ofs < -gHUD.m_SpecTank_coneHor)
viewangles[YAW] = gHUD.m_SpecTank_defYaw - gHUD.m_SpecTank_coneHor;
else if (ofs > gHUD.m_SpecTank_coneHor)
viewangles[YAW] = gHUD.m_SpecTank_defYaw + gHUD.m_SpecTank_coneHor;
// check pitch
if (viewangles[PITCH] > gHUD.m_SpecTank_coneVer)
viewangles[PITCH] = gHUD.m_SpecTank_coneVer;
else if (viewangles[PITCH] < -gHUD.m_SpecTank_coneVer)
viewangles[PITCH] = -gHUD.m_SpecTank_coneVer;
// всем спасибо, все свободны
gEngfuncs.SetViewAngles( (float *)viewangles );
/*
================
CL_CreateMove
Send the intended movement message to the server
if active == 1 then we are 1) not playing back demos ( where our commands are ignored ) and
2 ) we have finished signing on to server
================
*/
void DLLEXPORT CL_CreateMove ( float frametime, struct usercmd_s *cmd, int active )
{
float spd;
vec3_t viewangles;
static vec3_t oldangles;
if ( active )
{
//memset( viewangles, 0, sizeof( vec3_t ) );
//viewangles[ 0 ] = viewangles[ 1 ] = viewangles[ 2 ] = 0.0;
gEngfuncs.GetViewAngles( (float *)viewangles );
CL_AdjustAngles ( frametime, viewangles );
memset (cmd, 0, sizeof(*cmd));
gEngfuncs.SetViewAngles( (float *)viewangles );
if ( in_strafe.state & 1 )
{
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_right);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_left);
}
cmd->sidemove += cl_sidespeed->value * CL_KeyState (&in_moveright);
cmd->sidemove -= cl_sidespeed->value * CL_KeyState (&in_moveleft);
cmd->upmove += cl_upspeed->value * CL_KeyState (&in_up);
cmd->upmove -= cl_upspeed->value * CL_KeyState (&in_down);
if ( !(in_klook.state & 1 ) )
{
cmd->forwardmove += cl_forwardspeed->value * CL_KeyState (&in_forward);
cmd->forwardmove -= cl_backspeed->value * CL_KeyState (&in_back);
}
// adjust for speed key
if ( in_speed.state & 1 )
{
cmd->forwardmove *= cl_movespeedkey->value;
cmd->sidemove *= cl_movespeedkey->value;
cmd->upmove *= cl_movespeedkey->value;
}
// clip to maxspeed
spd = gEngfuncs.GetClientMaxspeed();
if ( spd != 0.0 )
{
// scale the 3 speeds so that the total velocity is not > cl.maxspeed
float fmov = sqrt( (cmd->forwardmove*cmd->forwardmove) + (cmd->sidemove*cmd->sidemove) + (cmd->upmove*cmd->upmove) );
if ( fmov > spd )
{
float fratio = spd / fmov;
cmd->forwardmove *= fratio;
cmd->sidemove *= fratio;
cmd->upmove *= fratio;
}
}
// Allow mice and other controllers to add their inputs
IN_Move ( frametime, cmd );
}
cmd->impulse = in_impulse;
in_impulse = 0;
cmd->weaponselect = g_weaponselect;
g_weaponselect = 0;
//
// set button and flag bits
//
cmd->buttons = CL_ButtonBits( 1 );
// If they're in a modal dialog, ignore the attack button.
if(GetClientVoiceMgr()->IsInSquelchMode())
cmd->buttons &= ~IN_ATTACK;
// Using joystick?
if ( in_joystick->value )
{
if ( cmd->forwardmove > 0 )
{
cmd->buttons |= IN_FORWARD;
}
else if ( cmd->forwardmove < 0 )
{
cmd->buttons |= IN_BACK;
}
}
gEngfuncs.GetViewAngles( (float *)viewangles );
// Set current view angles.
if ( g_iAlive )
{
VectorCopy( viewangles, cmd->viewangles );
VectorCopy( viewangles, oldangles );
}
else
{
VectorCopy( oldangles, cmd->viewangles );
}
}