// rights reserved.
#include "quakedef.h"
+#include "csprogs.h"
/*
===============================================================================
kbutton_t in_up, in_down;
// LordHavoc: added 6 new buttons
kbutton_t in_button3, in_button4, in_button5, in_button6, in_button7, in_button8;
+//even more
+kbutton_t in_button9, in_button10, in_button11, in_button12, in_button13, in_button14, in_button15, in_button16;
int in_impulse;
+
void KeyDown (kbutton_t *b)
{
int k;
void IN_Button8Down(void) {KeyDown(&in_button8);}
void IN_Button8Up(void) {KeyUp(&in_button8);}
+void IN_Button9Down(void) {KeyDown(&in_button9);}
+void IN_Button9Up(void) {KeyUp(&in_button9);}
+void IN_Button10Down(void) {KeyDown(&in_button10);}
+void IN_Button10Up(void) {KeyUp(&in_button10);}
+void IN_Button11Down(void) {KeyDown(&in_button11);}
+void IN_Button11Up(void) {KeyUp(&in_button11);}
+void IN_Button12Down(void) {KeyDown(&in_button12);}
+void IN_Button12Up(void) {KeyUp(&in_button12);}
+void IN_Button13Down(void) {KeyDown(&in_button13);}
+void IN_Button13Up(void) {KeyUp(&in_button13);}
+void IN_Button14Down(void) {KeyDown(&in_button14);}
+void IN_Button14Up(void) {KeyUp(&in_button14);}
+void IN_Button15Down(void) {KeyDown(&in_button15);}
+void IN_Button15Up(void) {KeyUp(&in_button15);}
+void IN_Button16Down(void) {KeyDown(&in_button16);}
+void IN_Button16Up(void) {KeyUp(&in_button16);}
+
void IN_JumpDown (void) {KeyDown(&in_jump);}
void IN_JumpUp (void) {KeyUp(&in_jump);}
//==========================================================================
-cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400"};
-cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400"};
-cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400"};
-cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350"};
+cvar_t cl_upspeed = {CVAR_SAVE, "cl_upspeed","400","vertical movement speed (while swimming or flying)"};
+cvar_t cl_forwardspeed = {CVAR_SAVE, "cl_forwardspeed","400","forward movement speed"};
+cvar_t cl_backspeed = {CVAR_SAVE, "cl_backspeed","400","backward movement speed"};
+cvar_t cl_sidespeed = {CVAR_SAVE, "cl_sidespeed","350","strafe movement speed"};
+
+cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0","how much +speed multiplies keyboard movement speed"};
-cvar_t cl_movespeedkey = {CVAR_SAVE, "cl_movespeedkey","2.0"};
+cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140","keyboard yaw turning speed"};
+cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning speed"};
-cvar_t cl_yawspeed = {CVAR_SAVE, "cl_yawspeed","140"};
-cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150"};
+cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"};
-cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5"};
+cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0", "enables clientside prediction of your player movement"};
+cvar_t cl_movement_latency = {0, "cl_movement_latency", "0", "compensates for this much latency (ping time) on quake servers which do not really support prediction, no effect on darkplaces7 protocol servers"};
+cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320", "how fast you can move (should match sv_maxspeed)"};
+cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30", "how fast you can move while in the air (should match sv_maxairspeed)"};
+cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100", "speed below which you will be slowed rapidly to a stop rather than sliding endlessly (should match sv_stopspeed)"};
+cvar_t cl_movement_friction = {0, "cl_movement_friction", "4", "how fast you slow down (should match sv_friction)"};
+cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2", "how much to slow down when you may be about to fall off a ledge (should match edgefriction)"};
+cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18", "how tall a step you can step in one instant (should match sv_stepheight)"};
+cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10", "how fast you accelerate (should match sv_accelerate)"};
+cvar_t cl_movement_jumpvelocity = {0, "cl_movement_jumpvelocity", "270", "how fast you move upward when you begin a jump (should match the quakec code)"};
+cvar_t cl_gravity = {0, "cl_gravity", "800", "how much gravity to apply in client physics (should match sv_gravity)"};
+cvar_t cl_slowmo = {0, "cl_slowmo", "1", "speed of game time (should match slowmo)"};
-cvar_t cl_movement = {CVAR_SAVE, "cl_movement", "0"};
-cvar_t cl_movement_latency = {0, "cl_movement_latency", "0"};
-cvar_t cl_movement_maxspeed = {0, "cl_movement_maxspeed", "320"};
-cvar_t cl_movement_maxairspeed = {0, "cl_movement_maxairspeed", "30"};
-cvar_t cl_movement_stopspeed = {0, "cl_movement_stopspeed", "100"};
-cvar_t cl_movement_friction = {0, "cl_movement_friction", "4"};
-cvar_t cl_movement_edgefriction = {0, "cl_movement_edgefriction", "2"};
-cvar_t cl_movement_stepheight = {0, "cl_movement_stepheight", "18"};
-cvar_t cl_movement_accelerate = {0, "cl_movement_accelerate", "10"};
-cvar_t cl_movement_jumpvelocity = {0, "cl_movement_jumpvelocity", "270"};
-cvar_t cl_gravity = {0, "cl_gravity", "800"};
-cvar_t cl_slowmo = {0, "cl_slowmo", "1"};
+cvar_t in_pitch_min = {0, "in_pitch_min", "-90", "how far downward you can aim (quake used -70"}; // quake used -70
+cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (quake used 80"}; // quake used 80
-cvar_t in_pitch_min = {0, "in_pitch_min", "-90"}; // quake used -70
-cvar_t in_pitch_max = {0, "in_pitch_max", "90"}; // quake used 80
+cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
-cvar_t m_filter = {CVAR_SAVE, "m_filter","0"};
+cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"};
+
+cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"};
/*
float up, down;
if (in_speed.state & 1)
- speed = host_realframetime * cl_anglespeedkey.value;
+ speed = cl.realframetime * cl_anglespeedkey.value;
else
- speed = host_realframetime;
+ speed = cl.realframetime;
if (!(in_strafe.state & 1))
{
*/
void CL_Move (void)
{
- vec3_t temp;
float mx, my;
static float old_mouse_x = 0, old_mouse_y = 0;
// clamp before the move to prevent starting with bad angles
CL_AdjustAngles ();
- // get basic movement from keyboard
- // PRYDON_CLIENTCURSOR needs to survive basemove resets
- VectorCopy (cl.cmd.cursor_screen, temp);
- memset (&cl.cmd, 0, sizeof(cl.cmd));
- VectorCopy (temp, cl.cmd.cursor_screen);
+ // reset some of the command fields
+ cl.cmd.forwardmove = 0;
+ cl.cmd.sidemove = 0;
+ cl.cmd.upmove = 0;
+ // get basic movement from keyboard
if (in_strafe.state & 1)
{
cl.cmd.sidemove += cl_sidespeed.value * CL_KeyState (&in_right);
old_mouse_y = my;
// if not in menu, apply mouse move to viewangles/movement
- if (in_client_mouse)
+ if (!cl.csqc_wantsmousemove && in_client_mouse)
{
if (cl_prydoncursor.integer)
{
VectorSet(temp, cl.cmd.cursor_screen[2] * scale[2], cl.cmd.cursor_screen[0] * scale[0], cl.cmd.cursor_screen[1] * scale[1]);
Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_end);
// trace from view origin to the cursor
- cl.cmd.cursor_fraction = CL_SelectTraceLine(cl.cmd.cursor_start, cl.cmd.cursor_end, cl.cmd.cursor_impact, cl.cmd.cursor_normal, &cl.cmd.cursor_entitynumber, (chase_active.integer || cl.intermission) ? &cl_entities[cl.playerentity].render : NULL);
- // makes sparks where cursor is
- //CL_SparkShower(cl.cmd.cursor_impact, cl.cmd.cursor_normal, 5, 0);
+ cl.cmd.cursor_fraction = CL_SelectTraceLine(cl.cmd.cursor_start, cl.cmd.cursor_end, cl.cmd.cursor_impact, cl.cmd.cursor_normal, &cl.cmd.cursor_entitynumber, (chase_active.integer || cl.intermission) ? &cl.entities[cl.playerentity].render : NULL, false);
}
-void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
+void CL_ClientMovement_InputQW(qw_usercmd_t *cmd)
{
int i;
int n;
// remove stale queue items
n = cl.movement_numqueue;
cl.movement_numqueue = 0;
- if (cl.servermovesequence)
- {
- for (i = 0;i < n;i++)
- if (cl.movement_queue[i].sequence > cl.servermovesequence)
- cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
- }
- else
+ if (cl.movement)
{
- double simulatedtime = cl.mtime[0] + cl_movement_latency.value / 1000.0;
for (i = 0;i < n;i++)
- if (cl.movement_queue[i].time >= cl.mtime[0] && cl.movement_queue[i].time <= simulatedtime)
+ if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence)
cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+ // add to input queue if there is room
+ if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
+ {
+ // add to input queue
+ cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence;
+ cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
+ cl.movement_queue[cl.movement_numqueue].frametime = cmd->msec * 0.001;
+ VectorCopy(cmd->angles, cl.movement_queue[cl.movement_numqueue].viewangles);
+ cl.movement_queue[cl.movement_numqueue].move[0] = cmd->forwardmove;
+ cl.movement_queue[cl.movement_numqueue].move[1] = cmd->sidemove;
+ cl.movement_queue[cl.movement_numqueue].move[2] = cmd->upmove;
+ cl.movement_queue[cl.movement_numqueue].jump = (cmd->buttons & 2) != 0;
+ cl.movement_queue[cl.movement_numqueue].crouch = false;
+ cl.movement_numqueue++;
+ }
}
- // add to input queue if there is room
- if (cl_movement.integer && cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
+ cl.movement_replay = true;
+}
+
+void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch)
+{
+ int i;
+ int n;
+ // remove stale queue items
+ n = cl.movement_numqueue;
+ cl.movement_numqueue = 0;
+ if (cl.movement)
{
- // add to input queue
- cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
- cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
- cl.movement_queue[cl.movement_numqueue].frametime = cl.mtime[0] - cl.mtime[1];
- VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
- cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
- cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
- cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
- cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
- cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
- cl.movement_numqueue++;
+ if (cl.servermovesequence)
+ {
+ for (i = 0;i < n;i++)
+ if (cl.movement_queue[i].sequence > cl.servermovesequence)
+ cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+ }
+ else
+ {
+ double simulatedtime = cl.mtime[0] + cl_movement_latency.value / 1000.0;
+ for (i = 0;i < n;i++)
+ if (cl.movement_queue[i].time >= cl.mtime[0] && cl.movement_queue[i].time <= simulatedtime)
+ cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i];
+ }
+ // add to input queue if there is room
+ if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0])) && cl.mtime[0] > cl.mtime[1])
+ {
+ // add to input queue
+ cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence;
+ cl.movement_queue[cl.movement_numqueue].time = cl.mtime[0] + cl_movement_latency.value / 1000.0;
+ cl.movement_queue[cl.movement_numqueue].frametime = cl.mtime[0] - cl.mtime[1];
+ VectorCopy(cl.viewangles, cl.movement_queue[cl.movement_numqueue].viewangles);
+ cl.movement_queue[cl.movement_numqueue].move[0] = cl.cmd.forwardmove;
+ cl.movement_queue[cl.movement_numqueue].move[1] = cl.cmd.sidemove;
+ cl.movement_queue[cl.movement_numqueue].move[2] = cl.cmd.upmove;
+ cl.movement_queue[cl.movement_numqueue].jump = buttonjump;
+ cl.movement_queue[cl.movement_numqueue].crouch = buttoncrouch;
+ cl.movement_numqueue++;
+ }
}
- cl.movement = cl_movement.integer && cl.stats[STAT_HEALTH] > 0 && !cls.demoplayback && !cl.intermission;
- // clear queue if client movement is disabled
- if (!cl.movement)
- cl.movement_numqueue = 0;
cl.movement_replay = true;
}
int contents;
int crouch;
int onground;
+ int canjump;
+ float movevars_gravity;
+ float movevars_stopspeed;
+ float movevars_maxspeed;
+ float movevars_spectatormaxspeed;
+ float movevars_accelerate;
+ float movevars_airaccelerate;
+ float movevars_wateraccelerate;
+ float movevars_friction;
+ float movevars_waterfriction;
+ float movevars_entgravity;
+ float movevars_jumpvelocity;
+ float movevars_edgefriction;
+ float movevars_maxairspeed;
+ float movevars_stepheight;
double edgefriction;
double frametime;
double t;
trace_t trace;
trace_t trace2;
trace_t trace3;
+
+
if (!cl.movement_replay)
return;
cl.movement_replay = false;
+ if (cls.protocol == PROTOCOL_QUAKEWORLD)
+ {
+ movevars_gravity = cl.qw_movevars_gravity;
+ movevars_stopspeed = cl.qw_movevars_stopspeed;
+ movevars_maxspeed = cl.qw_movevars_maxspeed;
+ movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed;
+ movevars_accelerate = cl.qw_movevars_accelerate;
+ movevars_airaccelerate = cl.qw_movevars_airaccelerate;
+ movevars_wateraccelerate = cl.qw_movevars_wateraccelerate;
+ movevars_friction = cl.qw_movevars_friction;
+ movevars_waterfriction = cl.qw_movevars_waterfriction;
+ movevars_entgravity = cl.qw_movevars_entgravity;
+ movevars_jumpvelocity = cl_movement_jumpvelocity.value;
+ movevars_edgefriction = cl_movement_edgefriction.value;
+ movevars_maxairspeed = cl_movement_maxairspeed.value;
+ movevars_stepheight = cl_movement_stepheight.value;
+ }
+ else
+ {
+ movevars_gravity = sv_gravity.value;
+ movevars_stopspeed = cl_movement_stopspeed.value;
+ movevars_maxspeed = cl_movement_maxspeed.value;
+ movevars_spectatormaxspeed = cl_movement_maxspeed.value;
+ movevars_accelerate = cl_movement_accelerate.value;
+ movevars_airaccelerate = cl_movement_accelerate.value;
+ movevars_wateraccelerate = cl_movement_accelerate.value;
+ movevars_friction = cl_movement_friction.value;
+ movevars_waterfriction = cl_movement_friction.value;
+ movevars_entgravity = 1;
+ movevars_jumpvelocity = cl_movement_jumpvelocity.value;
+ movevars_edgefriction = cl_movement_edgefriction.value;
+ movevars_maxairspeed = cl_movement_maxairspeed.value;
+ movevars_stepheight = cl_movement_stepheight.value;
+ }
+
// fetch current starting values
- VectorCopy(cl_entities[cl.playerentity].state_current.origin, currentorigin);
+ VectorCopy(cl.entities[cl.playerentity].state_current.origin, currentorigin);
VectorCopy(cl.mvelocity[0], currentvelocity);
// FIXME: try minor nudges in various directions if startsolid to find a
// safe place to start the walk (due to network compression in some
// protocols this starts in solid)
//currentorigin[2] += (1.0 / 32.0); // slight nudge to get out of the floor
- crouch = false; // this will be updated on first move
// check if onground
VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1);
VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1);
- trace = CL_TraceBox(currentorigin2, cl_playercrouchmins, cl_playercrouchmaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
- //Con_Printf("%f: ", cl.mtime[0]);
+ if (cl.movement)
+ {
+ trace = CL_TraceBox(currentorigin2, cl.playercrouchmins, cl.playercrouchmaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7;
+ crouch = false; // this will be updated on first move
+ canjump = true;
+ //Con_Printf("%f: ", cl.mtime[0]);
- // replay the input queue to predict current location
- // note: this relies on the fact there's always one queue item at the end
+ // replay the input queue to predict current location
+ // note: this relies on the fact there's always one queue item at the end
- for (i = 0;i < cl.movement_numqueue;i++)
- {
- client_movementqueue_t *q = cl.movement_queue + bound(0, i, cl.movement_numqueue - 1);
- frametime = q->frametime;
- //Con_Printf(" %f", frametime);
- //if (frametime > 0)
+ for (i = 0;i < cl.movement_numqueue;i++)
{
- if (q->crouch)
- {
- // wants to crouch, this always works...
- if (!crouch)
- crouch = true;
- }
- else
+ client_movementqueue_t *q = cl.movement_queue + bound(0, i, cl.movement_numqueue - 1);
+ frametime = q->frametime;
+ //Con_Printf(" %f", frametime);
+ //if (frametime > 0)
{
- // wants to stand, if currently crouching we need to check for a
- // low ceiling first
- if (crouch)
+ if (q->crouch)
{
- trace = CL_TraceBox(currentorigin, cl_playerstandmins, cl_playerstandmaxs, currentorigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- if (!trace.startsolid)
- crouch = false;
+ // wants to crouch, this always works...
+ if (!crouch)
+ crouch = true;
}
- }
- if (crouch)
- {
- playermins = cl_playercrouchmins;
- playermaxs = cl_playercrouchmaxs;
- }
- else
- {
- playermins = cl_playerstandmins;
- playermaxs = cl_playerstandmaxs;
- }
- // change velocity according to q->viewangles and q->move
- contents = CL_PointSuperContents(currentorigin);
- if (contents & SUPERCONTENTS_LIQUIDSMASK)
- {
- // swim
- AngleVectors(q->viewangles, forward, right, up);
- VectorSet(up, 0, 0, 1);
- VectorMAMAM(q->move[0], forward, q->move[1], right, q->move[2], up, wishvel);
- wishspeed = VectorLength(wishvel);
- if (wishspeed)
- VectorScale(wishvel, 1 / wishspeed, wishdir);
else
- VectorSet( wishdir, 0.0, 0.0, 0.0 );
- wishspeed = min(wishspeed, cl_movement_maxspeed.value);
+ {
+ // wants to stand, if currently crouching we need to check for a
+ // low ceiling first
+ if (crouch)
+ {
+ trace = CL_TraceBox(currentorigin, cl.playerstandmins, cl.playerstandmaxs, currentorigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ if (!trace.startsolid)
+ crouch = false;
+ }
+ }
if (crouch)
- wishspeed *= 0.5;
- wishspeed *= 0.6;
- VectorScale(currentvelocity, (1 - frametime * cl_movement_friction.value), currentvelocity);
- f = wishspeed - DotProduct(currentvelocity, wishdir);
- if (f > 0)
{
- f = min(f, cl_movement_accelerate.value * frametime * wishspeed);
- VectorMA(currentvelocity, f, wishdir, currentvelocity);
+ playermins = cl.playercrouchmins;
+ playermaxs = cl.playercrouchmaxs;
+ }
+ else
+ {
+ playermins = cl.playerstandmins;
+ playermaxs = cl.playerstandmaxs;
}
- if (q->jump)
+ // change velocity according to q->viewangles and q->move
+ contents = CL_PointSuperContents(currentorigin);
+ if (contents & SUPERCONTENTS_LIQUIDSMASK)
{
- if (contents & SUPERCONTENTS_LAVA)
- currentvelocity[2] = 50;
- else if (contents & SUPERCONTENTS_SLIME)
- currentvelocity[2] = 80;
+ // swim
+ AngleVectors(q->viewangles, forward, right, up);
+ VectorSet(up, 0, 0, 1);
+ VectorMAMAM(q->move[0], forward, q->move[1], right, q->move[2], up, wishvel);
+ wishspeed = VectorLength(wishvel);
+ if (wishspeed)
+ VectorScale(wishvel, 1 / wishspeed, wishdir);
else
+ VectorSet( wishdir, 0.0, 0.0, 0.0 );
+ wishspeed = min(wishspeed, movevars_maxspeed) * 0.6;
+ if (crouch)
+ wishspeed *= 0.5;
+ VectorScale(currentvelocity, (1 - frametime * movevars_waterfriction), currentvelocity);
+ f = wishspeed - DotProduct(currentvelocity, wishdir);
+ if (f > 0)
{
- if (gamemode == GAME_NEXUIZ)
- currentvelocity[2] = 200;
+ f = min(f, movevars_wateraccelerate * frametime * wishspeed);
+ VectorMA(currentvelocity, f, wishdir, currentvelocity);
+ }
+ if (q->jump)
+ {
+ if (contents & SUPERCONTENTS_LAVA)
+ currentvelocity[2] = 50;
+ else if (contents & SUPERCONTENTS_SLIME)
+ currentvelocity[2] = 80;
else
- currentvelocity[2] = 100;
+ {
+ if (gamemode == GAME_NEXUIZ)
+ currentvelocity[2] = 200;
+ else
+ currentvelocity[2] = 100;
+ }
}
}
- }
- else
- {
- // walk
- if (onground && q->jump)
- {
- currentvelocity[2] += cl_movement_jumpvelocity.value;
- onground = false;
- }
- VectorSet(yawangles, 0, q->viewangles[1], 0);
- AngleVectors(yawangles, forward, right, up);
- VectorMAM(q->move[0], forward, q->move[1], right, wishvel);
- wishspeed = VectorLength(wishvel);
- if (wishspeed)
- VectorScale(wishvel, 1 / wishspeed, wishdir);
else
- VectorSet( wishdir, 0.0, 0.0, 0.0 );
- wishspeed = min(wishspeed, cl_movement_maxspeed.value);
- if (crouch)
- wishspeed *= 0.5;
- // check if onground
- if (onground)
{
- // apply ground friction
- f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
- edgefriction = 1;
- if (f > 0)
+ // walk
+ if (onground && q->jump && canjump)
+ {
+ currentvelocity[2] += movevars_jumpvelocity;
+ onground = false;
+ canjump = false;
+ }
+ if (!q->jump)
+ canjump = true;
+ VectorSet(yawangles, 0, q->viewangles[1], 0);
+ AngleVectors(yawangles, forward, right, up);
+ VectorMAM(q->move[0], forward, q->move[1], right, wishvel);
+ wishspeed = VectorLength(wishvel);
+ if (wishspeed)
+ VectorScale(wishvel, 1 / wishspeed, wishdir);
+ else
+ VectorSet( wishdir, 0.0, 0.0, 0.0 );
+ wishspeed = min(wishspeed, movevars_maxspeed);
+ if (crouch)
+ wishspeed *= 0.5;
+ // check if onground
+ if (onground)
+ {
+ // apply ground friction
+ f = sqrt(currentvelocity[0] * currentvelocity[0] + currentvelocity[1] * currentvelocity[1]);
+ edgefriction = 1;
+ if (f > 0)
+ {
+ VectorSet(currentorigin2, currentorigin[0] + currentvelocity[0]*(16/f), currentorigin[1] + currentvelocity[1]*(16/f), currentorigin[2] + playermins[2]);
+ VectorSet(neworigin2, currentorigin2[0], currentorigin2[1], currentorigin2[2] - 34);
+ trace = CL_TraceBox(currentorigin2, vec3_origin, vec3_origin, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ if (trace.fraction == 1)
+ edgefriction = movevars_edgefriction;
+ }
+ // apply friction
+ f = 1 - frametime * edgefriction * ((f < movevars_stopspeed) ? (movevars_stopspeed / f) : 1) * movevars_friction;
+ f = max(f, 0);
+ VectorScale(currentvelocity, f, currentvelocity);
+ }
+ else
+ {
+ // apply air speed limit
+ wishspeed = min(wishspeed, movevars_maxairspeed);
+ }
+ if (gamemode == GAME_NEXUIZ)
+ addspeed = wishspeed;
+ else
+ addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
+ if (addspeed > 0)
{
- VectorSet(currentorigin2, currentorigin[0] + currentvelocity[0]*(16/f), currentorigin[1] + currentvelocity[1]*(16/f), currentorigin[2] + playermins[2]);
- VectorSet(neworigin2, currentorigin2[0], currentorigin2[1], currentorigin2[2] - 34);
- trace = CL_TraceBox(currentorigin2, vec3_origin, vec3_origin, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- if (trace.fraction == 1)
- edgefriction = cl_movement_edgefriction.value;
+ accelspeed = min(movevars_accelerate * frametime * wishspeed, addspeed);
+ VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
}
- // apply friction
- f = 1 - frametime * edgefriction * ((f < cl_movement_stopspeed.value) ? (cl_movement_stopspeed.value / f) : 1) * cl_movement_friction.value;
- f = max(f, 0);
- VectorScale(currentvelocity, f, currentvelocity);
+ currentvelocity[2] -= cl_gravity.value * frametime;
}
- else
+ }
+ //if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4))
+ {
+ if (crouch)
{
- // apply air speed limit
- wishspeed = min(wishspeed, cl_movement_maxairspeed.value);
+ playermins = cl.playercrouchmins;
+ playermaxs = cl.playercrouchmaxs;
}
- if (gamemode == GAME_NEXUIZ)
- addspeed = wishspeed;
else
- addspeed = wishspeed - DotProduct(currentvelocity, wishdir);
- if (addspeed > 0)
{
- accelspeed = min(cl_movement_accelerate.value * frametime * wishspeed, addspeed);
- VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity);
+ playermins = cl.playerstandmins;
+ playermaxs = cl.playerstandmaxs;
}
- currentvelocity[2] -= cl_gravity.value * frametime;
- }
- }
- //if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4))
- {
- if (crouch)
- {
- playermins = cl_playercrouchmins;
- playermaxs = cl_playercrouchmaxs;
- }
- else
- {
- playermins = cl_playerstandmins;
- playermaxs = cl_playerstandmaxs;
- }
- onground = false;
- for (bump = 0, t = frametime;bump < 8 && VectorLength2(currentvelocity) > 0;bump++)
- {
- VectorMA(currentorigin, t, currentvelocity, neworigin);
- trace = CL_TraceBox(currentorigin, playermins, playermaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- if (trace.fraction < 1 && trace.plane.normal[2] == 0)
+ onground = false;
+ for (bump = 0, t = frametime;bump < 8 && VectorLength2(currentvelocity) > 0;bump++)
{
- // may be a step or wall, try stepping up
- // first move forward at a higher level
- VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + cl_movement_stepheight.value);
- VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + cl_movement_stepheight.value);
- trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- // then move down from there
- VectorCopy(trace2.endpos, currentorigin2);
- VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], currentorigin[2]);
- trace3 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true);
- //Con_Printf("%f %f %f %f : %f %f %f %f : %f %f %f %f\n", trace.fraction, trace.endpos[0], trace.endpos[1], trace.endpos[2], trace2.fraction, trace2.endpos[0], trace2.endpos[1], trace2.endpos[2], trace3.fraction, trace3.endpos[0], trace3.endpos[1], trace3.endpos[2]);
- // accept the new trace if it made some progress
- if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
+ VectorMA(currentorigin, t, currentvelocity, neworigin);
+ trace = CL_TraceBox(currentorigin, playermins, playermaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ if (trace.fraction < 1 && trace.plane.normal[2] == 0)
{
- trace = trace2;
- VectorCopy(trace3.endpos, trace.endpos);
+ // may be a step or wall, try stepping up
+ // first move forward at a higher level
+ VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + movevars_stepheight);
+ VectorSet(neworigin2, neworigin[0], neworigin[1], currentorigin[2] + movevars_stepheight);
+ trace2 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ if (!trace2.startsolid)
+ {
+ // then move down from there
+ VectorCopy(trace2.endpos, currentorigin2);
+ VectorSet(neworigin2, trace2.endpos[0], trace2.endpos[1], currentorigin[2]);
+ trace3 = CL_TraceBox(currentorigin2, playermins, playermaxs, neworigin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true);
+ //Con_Printf("%f %f %f %f : %f %f %f %f : %f %f %f %f\n", trace.fraction, trace.endpos[0], trace.endpos[1], trace.endpos[2], trace2.fraction, trace2.endpos[0], trace2.endpos[1], trace2.endpos[2], trace3.fraction, trace3.endpos[0], trace3.endpos[1], trace3.endpos[2]);
+ // accept the new trace if it made some progress
+ if (fabs(trace3.endpos[0] - trace.endpos[0]) >= 0.03125 || fabs(trace3.endpos[1] - trace.endpos[1]) >= 0.03125)
+ {
+ trace = trace2;
+ VectorCopy(trace3.endpos, trace.endpos);
+ }
+ }
}
+ if (trace.fraction == 1)
+ {
+ VectorCopy(trace.endpos, currentorigin);
+ break;
+ }
+ if (trace.plane.normal[2] > 0.7)
+ onground = true;
+ t *= 1 - trace.fraction;
+ if (trace.fraction >= 0.001)
+ VectorCopy(trace.endpos, currentorigin);
+ f = DotProduct(currentvelocity, trace.plane.normal);
+ VectorMA(currentvelocity, -f, trace.plane.normal, currentvelocity);
}
- if (trace.fraction == 1)
- {
- VectorCopy(trace.endpos, currentorigin);
- break;
- }
- if (trace.plane.normal[2] > 0.7)
- onground = true;
- t *= 1 - trace.fraction;
- if (trace.fraction >= 0.001)
- VectorCopy(trace.endpos, currentorigin);
- f = DotProduct(currentvelocity, trace.plane.normal);
- VectorMA(currentvelocity, -f, trace.plane.normal, currentvelocity);
}
}
+ // store replay location
+ cl.onground = onground;
}
- // store replay location
VectorCopy(cl.movement_origin, cl.movement_oldorigin);
VectorCopy(currentorigin, cl.movement_origin);
VectorCopy(currentvelocity, cl.movement_velocity);
- //VectorCopy(currentorigin, cl_entities[cl.playerentity].state_current.origin);
- //VectorSet(cl_entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
+ //VectorCopy(currentorigin, cl.entities[cl.playerentity].state_current.origin);
+ //VectorSet(cl.entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0);
+}
+
+void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t *to)
+{
+ int bits;
+
+ bits = 0;
+ if (to->angles[0] != from->angles[0])
+ bits |= QW_CM_ANGLE1;
+ if (to->angles[1] != from->angles[1])
+ bits |= QW_CM_ANGLE2;
+ if (to->angles[2] != from->angles[2])
+ bits |= QW_CM_ANGLE3;
+ if (to->forwardmove != from->forwardmove)
+ bits |= QW_CM_FORWARD;
+ if (to->sidemove != from->sidemove)
+ bits |= QW_CM_SIDE;
+ if (to->upmove != from->upmove)
+ bits |= QW_CM_UP;
+ if (to->buttons != from->buttons)
+ bits |= QW_CM_BUTTONS;
+ if (to->impulse != from->impulse)
+ bits |= QW_CM_IMPULSE;
+
+ MSG_WriteByte(buf, bits);
+ if (bits & QW_CM_ANGLE1)
+ MSG_WriteAngle16i(buf, to->angles[0]);
+ if (bits & QW_CM_ANGLE2)
+ MSG_WriteAngle16i(buf, to->angles[1]);
+ if (bits & QW_CM_ANGLE3)
+ MSG_WriteAngle16i(buf, to->angles[2]);
+ if (bits & QW_CM_FORWARD)
+ MSG_WriteShort(buf, to->forwardmove);
+ if (bits & QW_CM_SIDE)
+ MSG_WriteShort(buf, to->sidemove);
+ if (bits & QW_CM_UP)
+ MSG_WriteShort(buf, to->upmove);
+ if (bits & QW_CM_BUTTONS)
+ MSG_WriteByte(buf, to->buttons);
+ if (bits & QW_CM_IMPULSE)
+ MSG_WriteByte(buf, to->impulse);
+ MSG_WriteByte(buf, to->msec);
}
/*
CL_SendMove
==============
*/
+extern cvar_t cl_netinputpacketspersecond;
void CL_SendMove(void)
{
int i;
int bits;
+ int impulse;
sizebuf_t buf;
unsigned char data[128];
+ static double lastsendtime = 0;
#define MOVEAVERAGING 0
#if MOVEAVERAGING
- static float forwardmove, sidemove, upmove, total; // accumulation
-#else
- float forwardmove, sidemove, upmove;
+ static float accumforwardmove = 0, accumsidemove = 0, accumupmove = 0, accumtotal = 0; // accumulation
#endif
+ float forwardmove, sidemove, upmove;
+
+ // if playing a demo, do nothing
+ if (!cls.netcon)
+ return;
#if MOVEAVERAGING
// accumulate changes between messages
- forwardmove += cl.cmd.forwardmove;
- sidemove += cl.cmd.sidemove;
- upmove += cl.cmd.upmove;
- total++;
+ accumforwardmove += cl.cmd.forwardmove;
+ accumsidemove += cl.cmd.sidemove;
+ accumupmove += cl.cmd.upmove;
+ accumtotal++;
#endif
- if (cls.signon != SIGNONS)
- return;
+
+ if (cl_movement.integer && cls.signon == SIGNONS && cls.protocol != PROTOCOL_QUAKEWORLD)
+ {
+ if (!cl.movement_needupdate)
+ return;
+ cl.movement_needupdate = false;
+ cl.movement = cl.stats[STAT_HEALTH] > 0 && !cl.intermission;
+ }
+ else
+ {
+ cl.movement = false;
+ if (realtime < lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100))
+ return;
+ // don't let it fall behind if CL_SendMove hasn't been called recently
+ // (such is the case when framerate is too low for instance)
+ lastsendtime = max(lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100), realtime);
+ }
#if MOVEAVERAGING
// average the accumulated changes
- total = 1.0f / total;
- forwardmove *= total;
- sidemove *= total;
- upmove *= total;
- total = 0;
+ accumtotal = 1.0f / accumtotal;
+ forwardmove = accumforwardmove * accumtotal;
+ sidemove = accumsidemove * accumtotal;
+ upmove = accumupmove * accumtotal;
+ accumforwardmove = 0;
+ accumsidemove = 0;
+ accumupmove = 0;
+ accumtotal = 0;
#else
// use the latest values
forwardmove = cl.cmd.forwardmove;
upmove = cl.cmd.upmove;
#endif
- CL_UpdatePrydonCursor();
+ if (cls.signon == SIGNONS)
+ CL_UpdatePrydonCursor();
buf.maxsize = 128;
buf.cursize = 0;
if (in_use.state & 3) bits |= 256;in_use.state &= ~2;
if (key_dest != key_game || key_consoleactive) bits |= 512;
if (cl_prydoncursor.integer) bits |= 1024;
- // button bits 11-31 unused currently
+ if (in_button9.state & 3) bits |= 2048;in_button9.state &= ~2;
+ if (in_button10.state & 3) bits |= 4096;in_button10.state &= ~2;
+ if (in_button11.state & 3) bits |= 8192;in_button11.state &= ~2;
+ if (in_button12.state & 3) bits |= 16384;in_button12.state &= ~2;
+ if (in_button13.state & 3) bits |= 32768;in_button13.state &= ~2;
+ if (in_button14.state & 3) bits |= 65536;in_button14.state &= ~2;
+ if (in_button15.state & 3) bits |= 131072;in_button15.state &= ~2;
+ if (in_button16.state & 3) bits |= 262144;in_button16.state &= ~2;
+ // button bits 19-31 unused currently
// rotate/zoom view serverside if PRYDON_CLIENTCURSOR cursor is at edge of screen
if (cl.cmd.cursor_screen[0] <= -1) bits |= 8;
if (cl.cmd.cursor_screen[0] >= 1) bits |= 16;
if (cl.cmd.cursor_screen[1] <= -1) bits |= 32;
if (cl.cmd.cursor_screen[1] >= 1) bits |= 64;
- // always dump the first two messages, because they may contain leftover inputs from the last level
- if (++cl.movemessages >= 2)
+ impulse = in_impulse;
+ in_impulse = 0;
+
+ csqc_buttons = bits;
+
+ if (cls.signon == SIGNONS)
{
- // send the movement message
- // PROTOCOL_QUAKE clc_move = 16 bytes total
- // PROTOCOL_QUAKEDP clc_move = 16 bytes total
- // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
- // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
- // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
- // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
- // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
- // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
- // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
- // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total
- if (cl.protocol == PROTOCOL_QUAKE || cl.protocol == PROTOCOL_QUAKEDP || cl.protocol == PROTOCOL_NEHAHRAMOVIE)
+ // always dump the first two messages, because they may contain leftover inputs from the last level
+ if (++cl.movemessages >= 2)
{
- // 5 bytes
- MSG_WriteByte (&buf, clc_move);
- MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
- // 3 bytes
- for (i = 0;i < 3;i++)
- MSG_WriteAngle8i (&buf, cl.viewangles[i]);
- // 6 bytes
- MSG_WriteCoord16i (&buf, forwardmove);
- MSG_WriteCoord16i (&buf, sidemove);
- MSG_WriteCoord16i (&buf, upmove);
- // 2 bytes
- MSG_WriteByte (&buf, bits);
- MSG_WriteByte (&buf, in_impulse);
- }
- else if (cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3)
- {
- // 5 bytes
- MSG_WriteByte (&buf, clc_move);
- MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
- // 12 bytes
- for (i = 0;i < 3;i++)
- MSG_WriteAngle32f (&buf, cl.viewangles[i]);
- // 6 bytes
- MSG_WriteCoord16i (&buf, forwardmove);
- MSG_WriteCoord16i (&buf, sidemove);
- MSG_WriteCoord16i (&buf, upmove);
- // 2 bytes
- MSG_WriteByte (&buf, bits);
- MSG_WriteByte (&buf, in_impulse);
- }
- else if (cl.protocol == PROTOCOL_DARKPLACES1 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5)
- {
- // 5 bytes
- MSG_WriteByte (&buf, clc_move);
- MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
- // 6 bytes
- for (i = 0;i < 3;i++)
- MSG_WriteAngle16i (&buf, cl.viewangles[i]);
- // 6 bytes
- MSG_WriteCoord16i (&buf, forwardmove);
- MSG_WriteCoord16i (&buf, sidemove);
- MSG_WriteCoord16i (&buf, upmove);
- // 2 bytes
- MSG_WriteByte (&buf, bits);
- MSG_WriteByte (&buf, in_impulse);
- }
- else
- {
- // 5 bytes
- MSG_WriteByte (&buf, clc_move);
- if (cl.protocol != PROTOCOL_DARKPLACES6)
+ // send the movement message
+ // PROTOCOL_QUAKE clc_move = 16 bytes total
+ // PROTOCOL_QUAKEDP clc_move = 16 bytes total
+ // PROTOCOL_NEHAHRAMOVIE clc_move = 16 bytes total
+ // PROTOCOL_DARKPLACES1 clc_move = 19 bytes total
+ // PROTOCOL_DARKPLACES2 clc_move = 25 bytes total
+ // PROTOCOL_DARKPLACES3 clc_move = 25 bytes total
+ // PROTOCOL_DARKPLACES4 clc_move = 19 bytes total
+ // PROTOCOL_DARKPLACES5 clc_move = 19 bytes total
+ // PROTOCOL_DARKPLACES6 clc_move = 52 bytes total
+ // PROTOCOL_DARKPLACES7 clc_move = 56 bytes total
+ // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll)
+ if (cls.protocol == PROTOCOL_QUAKEWORLD)
{
- if (cl_movement.integer)
+ int checksumindex;
+ double msectime;
+ static double oldmsectime;
+ qw_usercmd_t *cmd, *oldcmd;
+ qw_usercmd_t nullcmd;
+
+ //Con_Printf("code qw_clc_move\n");
+
+ i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
+ cmd = &cl.qw_moves[i];
+ memset(&nullcmd, 0, sizeof(nullcmd));
+ memset(cmd, 0, sizeof(*cmd));
+ cmd->buttons = bits;
+ cmd->impulse = impulse;
+ cmd->forwardmove = (short)bound(-32768, forwardmove, 32767);
+ cmd->sidemove = (short)bound(-32768, sidemove, 32767);
+ cmd->upmove = (short)bound(-32768, upmove, 32767);
+ VectorCopy(cl.viewangles, cmd->angles);
+ msectime = realtime * 1000;
+ cmd->msec = (unsigned char)bound(0, msectime - oldmsectime, 255);
+ // ridiculous value rejection (matches qw)
+ if (cmd->msec > 250)
+ cmd->msec = 100;
+ oldmsectime = msectime;
+
+ CL_ClientMovement_InputQW(cmd);
+
+ MSG_WriteByte(&buf, qw_clc_move);
+ // save the position for a checksum byte
+ checksumindex = buf.cursize;
+ MSG_WriteByte(&buf, 0);
+ // packet loss percentage
+ // FIXME: netgraph stuff
+ MSG_WriteByte(&buf, 0);
+ // write most recent 3 moves
+ i = (cls.netcon->qw.outgoing_sequence-2) & QW_UPDATE_MASK;
+ cmd = &cl.qw_moves[i];
+ QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, cmd);
+ oldcmd = cmd;
+ i = (cls.netcon->qw.outgoing_sequence-1) & QW_UPDATE_MASK;
+ cmd = &cl.qw_moves[i];
+ QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
+ oldcmd = cmd;
+ i = cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK;
+ cmd = &cl.qw_moves[i];
+ QW_MSG_WriteDeltaUsercmd(&buf, oldcmd, cmd);
+ // calculate the checksum
+ buf.data[checksumindex] = COM_BlockSequenceCRCByteQW(buf.data + checksumindex + 1, buf.cursize - checksumindex - 1, cls.netcon->qw.outgoing_sequence);
+ // if delta compression history overflows, request no delta
+ if (cls.netcon->qw.outgoing_sequence - cl.qw_validsequence >= QW_UPDATE_BACKUP-1)
+ cl.qw_validsequence = 0;
+ // request delta compression if appropriate
+ if (cl.qw_validsequence && !cl_nodelta.integer && cls.state == ca_connected && !cls.demorecording)
{
- cl.movesequence++;
- MSG_WriteLong (&buf, cl.movesequence);
+ cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = cl.qw_validsequence;
+ MSG_WriteByte(&buf, qw_clc_delta);
+ MSG_WriteByte(&buf, cl.qw_validsequence & 255);
}
else
- MSG_WriteLong (&buf, 0);
+ cl.qw_deltasequence[cls.netcon->qw.outgoing_sequence & QW_UPDATE_MASK] = -1;
+ }
+ else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE)
+ {
+ // 5 bytes
+ MSG_WriteByte (&buf, clc_move);
+ MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
+ // 3 bytes
+ for (i = 0;i < 3;i++)
+ MSG_WriteAngle8i (&buf, cl.viewangles[i]);
+ // 6 bytes
+ MSG_WriteCoord16i (&buf, forwardmove);
+ MSG_WriteCoord16i (&buf, sidemove);
+ MSG_WriteCoord16i (&buf, upmove);
+ // 2 bytes
+ MSG_WriteByte (&buf, bits);
+ MSG_WriteByte (&buf, impulse);
+
+ CL_ClientMovement_Input((bits & 2) != 0, false);
+ }
+ else if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3)
+ {
+ // 5 bytes
+ MSG_WriteByte (&buf, clc_move);
+ MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
+ // 12 bytes
+ for (i = 0;i < 3;i++)
+ MSG_WriteAngle32f (&buf, cl.viewangles[i]);
+ // 6 bytes
+ MSG_WriteCoord16i (&buf, forwardmove);
+ MSG_WriteCoord16i (&buf, sidemove);
+ MSG_WriteCoord16i (&buf, upmove);
+ // 2 bytes
+ MSG_WriteByte (&buf, bits);
+ MSG_WriteByte (&buf, impulse);
+
+ CL_ClientMovement_Input((bits & 2) != 0, false);
+ }
+ else if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5)
+ {
+ // 5 bytes
+ MSG_WriteByte (&buf, clc_move);
+ MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
+ // 6 bytes
+ for (i = 0;i < 3;i++)
+ MSG_WriteAngle16i (&buf, cl.viewangles[i]);
+ // 6 bytes
+ MSG_WriteCoord16i (&buf, forwardmove);
+ MSG_WriteCoord16i (&buf, sidemove);
+ MSG_WriteCoord16i (&buf, upmove);
+ // 2 bytes
+ MSG_WriteByte (&buf, bits);
+ MSG_WriteByte (&buf, impulse);
+
+ CL_ClientMovement_Input((bits & 2) != 0, false);
+ }
+ else
+ {
+ // 5 bytes
+ MSG_WriteByte (&buf, clc_move);
+ if (cls.protocol != PROTOCOL_DARKPLACES6)
+ {
+ if (cl_movement.integer)
+ {
+ cl.movesequence++;
+ MSG_WriteLong (&buf, cl.movesequence);
+ }
+ else
+ MSG_WriteLong (&buf, 0);
+ }
+ MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
+ // 6 bytes
+ for (i = 0;i < 3;i++)
+ MSG_WriteAngle16i (&buf, cl.viewangles[i]);
+ // 6 bytes
+ MSG_WriteCoord16i (&buf, forwardmove);
+ MSG_WriteCoord16i (&buf, sidemove);
+ MSG_WriteCoord16i (&buf, upmove);
+ // 5 bytes
+ MSG_WriteLong (&buf, bits);
+ MSG_WriteByte (&buf, impulse);
+ // PRYDON_CLIENTCURSOR
+ // 30 bytes
+ MSG_WriteShort (&buf, (short)(cl.cmd.cursor_screen[0] * 32767.0f));
+ MSG_WriteShort (&buf, (short)(cl.cmd.cursor_screen[1] * 32767.0f));
+ MSG_WriteFloat (&buf, cl.cmd.cursor_start[0]);
+ MSG_WriteFloat (&buf, cl.cmd.cursor_start[1]);
+ MSG_WriteFloat (&buf, cl.cmd.cursor_start[2]);
+ MSG_WriteFloat (&buf, cl.cmd.cursor_impact[0]);
+ MSG_WriteFloat (&buf, cl.cmd.cursor_impact[1]);
+ MSG_WriteFloat (&buf, cl.cmd.cursor_impact[2]);
+ MSG_WriteShort (&buf, cl.cmd.cursor_entitynumber);
+
+ // FIXME: bits & 16 is +button5, Nexuiz specific
+ CL_ClientMovement_Input((bits & 2) != 0, (bits & 16) != 0);
}
- MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times
- // 6 bytes
- for (i = 0;i < 3;i++)
- MSG_WriteAngle16i (&buf, cl.viewangles[i]);
- // 6 bytes
- MSG_WriteCoord16i (&buf, forwardmove);
- MSG_WriteCoord16i (&buf, sidemove);
- MSG_WriteCoord16i (&buf, upmove);
- // 5 bytes
- MSG_WriteLong (&buf, bits);
- MSG_WriteByte (&buf, in_impulse);
- // PRYDON_CLIENTCURSOR
- // 30 bytes
- MSG_WriteShort (&buf, cl.cmd.cursor_screen[0] * 32767.0f);
- MSG_WriteShort (&buf, cl.cmd.cursor_screen[1] * 32767.0f);
- MSG_WriteFloat (&buf, cl.cmd.cursor_start[0]);
- MSG_WriteFloat (&buf, cl.cmd.cursor_start[1]);
- MSG_WriteFloat (&buf, cl.cmd.cursor_start[2]);
- MSG_WriteFloat (&buf, cl.cmd.cursor_impact[0]);
- MSG_WriteFloat (&buf, cl.cmd.cursor_impact[1]);
- MSG_WriteFloat (&buf, cl.cmd.cursor_impact[2]);
- MSG_WriteShort (&buf, cl.cmd.cursor_entitynumber);
}
- }
-
-#if MOVEAVERAGING
- forwardmove = sidemove = upmove = 0;
-#endif
- in_impulse = 0;
- // ack the last few frame numbers
- // (redundent to improve handling of client->server packet loss)
- // for LATESTFRAMENUMS == 3 case this is 15 bytes
- for (i = 0;i < LATESTFRAMENUMS;i++)
- {
- if (cl.latestframenums[i] > 0)
+ if (cls.protocol != PROTOCOL_QUAKEWORLD)
{
- if (developer_networkentities.integer >= 1)
- Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
- MSG_WriteByte(&buf, clc_ackframe);
- MSG_WriteLong(&buf, cl.latestframenums[i]);
+ // ack the last few frame numbers
+ // (redundent to improve handling of client->server packet loss)
+ // for LATESTFRAMENUMS == 3 case this is 15 bytes
+ for (i = 0;i < LATESTFRAMENUMS;i++)
+ {
+ if (cl.latestframenums[i] > 0)
+ {
+ if (developer_networkentities.integer >= 1)
+ Con_Printf("send clc_ackframe %i\n", cl.latestframenums[i]);
+ MSG_WriteByte(&buf, clc_ackframe);
+ MSG_WriteLong(&buf, cl.latestframenums[i]);
+ }
+ }
}
- }
- // PROTOCOL_DARKPLACES6 = 67 bytes per packet
- // PROTOCOL_DARKPLACES7 = 71 bytes per packet
-
- // deliver the message
- if (cls.demoplayback)
- return;
- // nothing to send
- if (!buf.cursize)
- return;
+ // PROTOCOL_DARKPLACES6 = 67 bytes per packet
+ // PROTOCOL_DARKPLACES7 = 71 bytes per packet
+ }
- // FIXME: bits & 16 is +button5, Nexuiz specific
- CL_ClientMovement_Input((bits & 2) != 0, (bits & 16) != 0);
+ // send the reliable message (forwarded commands) if there is one
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol);
- if (NetConn_SendUnreliableMessage(cls.netcon, &buf) == -1)
+ if (cls.netcon->message.overflowed)
{
Con_Print("CL_SendMove: lost server connection\n");
CL_Disconnect();
- Host_ShutdownServer(false);
+ Host_ShutdownServer();
}
}
*/
void CL_InitInput (void)
{
- Cmd_AddCommand ("+moveup",IN_UpDown);
- Cmd_AddCommand ("-moveup",IN_UpUp);
- Cmd_AddCommand ("+movedown",IN_DownDown);
- Cmd_AddCommand ("-movedown",IN_DownUp);
- Cmd_AddCommand ("+left",IN_LeftDown);
- Cmd_AddCommand ("-left",IN_LeftUp);
- Cmd_AddCommand ("+right",IN_RightDown);
- Cmd_AddCommand ("-right",IN_RightUp);
- Cmd_AddCommand ("+forward",IN_ForwardDown);
- Cmd_AddCommand ("-forward",IN_ForwardUp);
- Cmd_AddCommand ("+back",IN_BackDown);
- Cmd_AddCommand ("-back",IN_BackUp);
- Cmd_AddCommand ("+lookup", IN_LookupDown);
- Cmd_AddCommand ("-lookup", IN_LookupUp);
- Cmd_AddCommand ("+lookdown", IN_LookdownDown);
- Cmd_AddCommand ("-lookdown", IN_LookdownUp);
- Cmd_AddCommand ("+strafe", IN_StrafeDown);
- Cmd_AddCommand ("-strafe", IN_StrafeUp);
- Cmd_AddCommand ("+moveleft", IN_MoveleftDown);
- Cmd_AddCommand ("-moveleft", IN_MoveleftUp);
- Cmd_AddCommand ("+moveright", IN_MoverightDown);
- Cmd_AddCommand ("-moveright", IN_MoverightUp);
- Cmd_AddCommand ("+speed", IN_SpeedDown);
- Cmd_AddCommand ("-speed", IN_SpeedUp);
- Cmd_AddCommand ("+attack", IN_AttackDown);
- Cmd_AddCommand ("-attack", IN_AttackUp);
- Cmd_AddCommand ("+jump", IN_JumpDown);
- Cmd_AddCommand ("-jump", IN_JumpUp);
- Cmd_AddCommand ("impulse", IN_Impulse);
- Cmd_AddCommand ("+klook", IN_KLookDown);
- Cmd_AddCommand ("-klook", IN_KLookUp);
- Cmd_AddCommand ("+mlook", IN_MLookDown);
- Cmd_AddCommand ("-mlook", IN_MLookUp);
+ Cmd_AddCommand ("+moveup",IN_UpDown, "swim upward");
+ Cmd_AddCommand ("-moveup",IN_UpUp, "stop swimming upward");
+ Cmd_AddCommand ("+movedown",IN_DownDown, "swim downward");
+ Cmd_AddCommand ("-movedown",IN_DownUp, "stop swimming downward");
+ Cmd_AddCommand ("+left",IN_LeftDown, "turn left");
+ Cmd_AddCommand ("-left",IN_LeftUp, "stop turning left");
+ Cmd_AddCommand ("+right",IN_RightDown, "turn right");
+ Cmd_AddCommand ("-right",IN_RightUp, "stop turning right");
+ Cmd_AddCommand ("+forward",IN_ForwardDown, "move forward");
+ Cmd_AddCommand ("-forward",IN_ForwardUp, "stop moving forward");
+ Cmd_AddCommand ("+back",IN_BackDown, "move backward");
+ Cmd_AddCommand ("-back",IN_BackUp, "stop moving backward");
+ Cmd_AddCommand ("+lookup", IN_LookupDown, "look upward");
+ Cmd_AddCommand ("-lookup", IN_LookupUp, "stop looking upward");
+ Cmd_AddCommand ("+lookdown", IN_LookdownDown, "look downward");
+ Cmd_AddCommand ("-lookdown", IN_LookdownUp, "stop looking downward");
+ Cmd_AddCommand ("+strafe", IN_StrafeDown, "activate strafing mode (move instead of turn)\n");
+ Cmd_AddCommand ("-strafe", IN_StrafeUp, "deactivate strafing mode");
+ Cmd_AddCommand ("+moveleft", IN_MoveleftDown, "strafe left");
+ Cmd_AddCommand ("-moveleft", IN_MoveleftUp, "stop strafing left");
+ Cmd_AddCommand ("+moveright", IN_MoverightDown, "strafe right");
+ Cmd_AddCommand ("-moveright", IN_MoverightUp, "stop strafing right");
+ Cmd_AddCommand ("+speed", IN_SpeedDown, "activate run mode (faster movement and turning)");
+ Cmd_AddCommand ("-speed", IN_SpeedUp, "deactivate run mode");
+ Cmd_AddCommand ("+attack", IN_AttackDown, "begin firing");
+ Cmd_AddCommand ("-attack", IN_AttackUp, "stop firing");
+ Cmd_AddCommand ("+jump", IN_JumpDown, "jump");
+ Cmd_AddCommand ("-jump", IN_JumpUp, "end jump (so you can jump again)");
+ Cmd_AddCommand ("impulse", IN_Impulse, "send an impulse number to server (select weapon, use item, etc)");
+ Cmd_AddCommand ("+klook", IN_KLookDown, "activate keyboard looking mode, do not recenter view");
+ Cmd_AddCommand ("-klook", IN_KLookUp, "deactivate keyboard looking mode");
+ Cmd_AddCommand ("+mlook", IN_MLookDown, "activate mouse looking mode, do not recenter view");
+ Cmd_AddCommand ("-mlook", IN_MLookUp, "deactivate mouse looking mode");
// LordHavoc: added use button
- Cmd_AddCommand ("+use", IN_UseDown);
- Cmd_AddCommand ("-use", IN_UseUp);
+ Cmd_AddCommand ("+use", IN_UseDown, "use something (may be used by some mods)");
+ Cmd_AddCommand ("-use", IN_UseUp, "stop using something");
// LordHavoc: added 6 new buttons
- Cmd_AddCommand ("+button3", IN_Button3Down);
- Cmd_AddCommand ("-button3", IN_Button3Up);
- Cmd_AddCommand ("+button4", IN_Button4Down);
- Cmd_AddCommand ("-button4", IN_Button4Up);
- Cmd_AddCommand ("+button5", IN_Button5Down);
- Cmd_AddCommand ("-button5", IN_Button5Up);
- Cmd_AddCommand ("+button6", IN_Button6Down);
- Cmd_AddCommand ("-button6", IN_Button6Up);
- Cmd_AddCommand ("+button7", IN_Button7Down);
- Cmd_AddCommand ("-button7", IN_Button7Up);
- Cmd_AddCommand ("+button8", IN_Button8Down);
- Cmd_AddCommand ("-button8", IN_Button8Up);
+ Cmd_AddCommand ("+button3", IN_Button3Down, "activate button3 (behavior depends on mod)");
+ Cmd_AddCommand ("-button3", IN_Button3Up, "deactivate button3");
+ Cmd_AddCommand ("+button4", IN_Button4Down, "activate button4 (behavior depends on mod)");
+ Cmd_AddCommand ("-button4", IN_Button4Up, "deactivate button4");
+ Cmd_AddCommand ("+button5", IN_Button5Down, "activate button5 (behavior depends on mod)");
+ Cmd_AddCommand ("-button5", IN_Button5Up, "deactivate button5");
+ Cmd_AddCommand ("+button6", IN_Button6Down, "activate button6 (behavior depends on mod)");
+ Cmd_AddCommand ("-button6", IN_Button6Up, "deactivate button6");
+ Cmd_AddCommand ("+button7", IN_Button7Down, "activate button7 (behavior depends on mod)");
+ Cmd_AddCommand ("-button7", IN_Button7Up, "deactivate button7");
+ Cmd_AddCommand ("+button8", IN_Button8Down, "activate button8 (behavior depends on mod)");
+ Cmd_AddCommand ("-button8", IN_Button8Up, "deactivate button8");
+ Cmd_AddCommand ("+button9", IN_Button9Down, "activate button9 (behavior depends on mod)");
+ Cmd_AddCommand ("-button9", IN_Button9Up, "deactivate button9");
+ Cmd_AddCommand ("+button10", IN_Button10Down, "activate button10 (behavior depends on mod)");
+ Cmd_AddCommand ("-button10", IN_Button10Up, "deactivate button10");
+ Cmd_AddCommand ("+button11", IN_Button11Down, "activate button11 (behavior depends on mod)");
+ Cmd_AddCommand ("-button11", IN_Button11Up, "deactivate button11");
+ Cmd_AddCommand ("+button12", IN_Button12Down, "activate button12 (behavior depends on mod)");
+ Cmd_AddCommand ("-button12", IN_Button12Up, "deactivate button12");
+ Cmd_AddCommand ("+button13", IN_Button13Down, "activate button13 (behavior depends on mod)");
+ Cmd_AddCommand ("-button13", IN_Button13Up, "deactivate button13");
+ Cmd_AddCommand ("+button14", IN_Button14Down, "activate button14 (behavior depends on mod)");
+ Cmd_AddCommand ("-button14", IN_Button14Up, "deactivate button14");
+ Cmd_AddCommand ("+button15", IN_Button15Down, "activate button15 (behavior depends on mod)");
+ Cmd_AddCommand ("-button15", IN_Button15Up, "deactivate button15");
+ Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)");
+ Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16");
Cvar_RegisterVariable(&cl_movement);
Cvar_RegisterVariable(&cl_movement_latency);
Cvar_RegisterVariable(&in_pitch_min);
Cvar_RegisterVariable(&in_pitch_max);
Cvar_RegisterVariable(&m_filter);
+
+ Cvar_RegisterVariable(&cl_netinputpacketspersecond);
+
+ Cvar_RegisterVariable(&cl_nodelta);
}