X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=cl_input.c;h=95321d6743f53d37c7b454e063a6a6d3ae6c6791;hp=4755d98a14bd13f6975cc3d8b435d313d9ec6c8c;hb=c205fc63e780877ef0b6b3cfe747e2f9e8228c40;hpb=ff22464f256450e58f11f22392c7deef590f7688 diff --git a/cl_input.c b/cl_input.c index 4755d98a..95321d67 100644 --- a/cl_input.c +++ b/cl_input.c @@ -197,6 +197,57 @@ void IN_JumpUp (void) {KeyUp(&in_jump);} void IN_Impulse (void) {in_impulse=atoi(Cmd_Argv(1));} +int in_bestweapon_info[][5] = +{ + {'1', 1, IT_AXE, STAT_SHELLS, 0}, + {'2', 2, IT_SHOTGUN, STAT_SHELLS, 1}, + {'3', 3, IT_SUPER_SHOTGUN, STAT_SHELLS, 1}, + {'4', 4, IT_NAILGUN, STAT_NAILS, 1}, + {'5', 5, IT_SUPER_NAILGUN, STAT_NAILS, 1}, + {'6', 6, IT_GRENADE_LAUNCHER, STAT_ROCKETS, 1}, + {'7', 7, IT_ROCKET_LAUNCHER, STAT_ROCKETS, 1}, + {'8', 8, IT_LIGHTNING, STAT_CELLS, 1}, + {'9', 9, 128, STAT_CELLS, 1}, // generic energy weapon for mods + {'p', 209, 128, STAT_CELLS, 1}, // dpmod plasma gun + {'w', 210, 8388608, STAT_CELLS, 1}, // dpmod plasma wave cannon + {'l', 225, HIT_LASER_CANNON, STAT_CELLS, 1}, // hipnotic laser cannon + {'h', 226, HIT_MJOLNIR, STAT_CELLS, 0}, // hipnotic mjolnir hammer + {-1, 0, 0, 0, 0} +}; +void IN_BestWeapon (void) +{ + int i, n; + const char *s; + if (Cmd_Argc() != 2) + { + Con_Printf("bestweapon requires 1 parameter\n"); + return; + } + s = Cmd_Argv(1); + for (i = 0;s[i];i++) + { + // figure out which weapon this character refers to + for (n = 0;in_bestweapon_info[n][0] >= 0;n++) + { + if (in_bestweapon_info[n][0] == s[i]) + { + // we found out what weapon this character refers to + // check if the inventory contains the weapon and enough ammo + if ((cl.stats[STAT_ITEMS] & in_bestweapon_info[n][2]) && (cl.stats[in_bestweapon_info[n][3]] >= in_bestweapon_info[n][4])) + { + // we found one of the weapons the player wanted + // send an impulse to switch to it + in_impulse = in_bestweapon_info[n][1]; + return; + } + break; + } + } + // if we couldn't identify the weapon we just ignore it and continue checking for other weapons + } + // if we couldn't find any of the weapons, there's nothing more we can do... +} + /* =============== CL_KeyState @@ -269,15 +320,20 @@ cvar_t cl_pitchspeed = {CVAR_SAVE, "cl_pitchspeed","150","keyboard pitch turning cvar_t cl_anglespeedkey = {CVAR_SAVE, "cl_anglespeedkey","1.5","how much +speed multiplies keyboard turning speed"}; 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_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 or quakeworld 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_waterfriction = {0, "cl_movement_waterfriction", "-1", "how fast you slow down (should match sv_friction), if less than 0 the cl_movement_friction variable is used instead"}; 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_airaccelerate = {0, "cl_movement_airaccelerate", "-1", "how fast you accelerate while in the air (should match sv_airaccelerate), if less than 0 the cl_movement_accelerate variable is used instead"}; +cvar_t cl_movement_wateraccelerate = {0, "cl_movement_wateraccelerate", "-1", "how fast you accelerate while in the air (should match sv_airaccelerate), if less than 0 the cl_movement_accelerate variable is used instead"}; 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_movement_airaccel_qw = {0, "cl_movement_airaccel_qw", "1", "ratio of QW-style air control as opposed to simple acceleration (should match sv_airaccel_qw)"}; +cvar_t cl_movement_airaccel_sideways_friction = {0, "cl_movement_airaccel_sideways_friction", "0", "anti-sideways movement stabilization (should match sv_airaccel_sideways_friction)"}; 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)"}; @@ -287,6 +343,7 @@ cvar_t in_pitch_max = {0, "in_pitch_max", "90", "how far upward you can aim (qua cvar_t m_filter = {CVAR_SAVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"}; cvar_t cl_netinputpacketspersecond = {CVAR_SAVE, "cl_netinputpacketspersecond","50", "how many input packets to send to server each second"}; +cvar_t cl_netinputpacketlosstolerance = {CVAR_SAVE, "cl_netinputpacketlosstolerance", "4", "how many packets in a row can be lost without movement issues when using cl_movement (technically how many input messages to repeat in each packet that have not yet been acknowledged by the server)"}; cvar_t cl_nodelta = {0, "cl_nodelta", "0", "disables delta compression of non-player entities in QW network protocol"}; @@ -304,9 +361,9 @@ void CL_AdjustAngles (void) 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)) { @@ -461,10 +518,9 @@ void CL_Move (void) #include "cl_collision.h" -extern void V_CalcRefdef(void); void CL_UpdatePrydonCursor(void) { - vec3_t temp, scale; + vec3_t temp; if (!cl_prydoncursor.integer) VectorClear(cl.cmd.cursor_screen); @@ -495,103 +551,132 @@ void CL_UpdatePrydonCursor(void) cl.cmd.cursor_screen[1] = bound(-1, cl.cmd.cursor_screen[1], 1); cl.cmd.cursor_screen[2] = 1; - scale[0] = -r_refdef.frustum_x; - scale[1] = -r_refdef.frustum_y; - scale[2] = 1; - - // trace distance - VectorScale(scale, 1000000, scale); - // calculate current view matrix - V_CalcRefdef(); - VectorClear(temp); - Matrix4x4_Transform(&r_refdef.viewentitymatrix, temp, cl.cmd.cursor_start); - 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); + Matrix4x4_OriginFromMatrix(&r_view.matrix, cl.cmd.cursor_start); + // calculate direction vector of cursor in viewspace by using frustum slopes + VectorSet(temp, cl.cmd.cursor_screen[2] * 1000000, cl.cmd.cursor_screen[0] * -r_view.frustum_x * 1000000, cl.cmd.cursor_screen[1] * -r_view.frustum_y * 1000000); + Matrix4x4_Transform(&r_view.matrix, 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, false); + 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); } -void CL_ClientMovement_InputQW(qw_usercmd_t *cmd) +void CL_ClientMovement_Replay(void); + +void CL_ClientMovement_InputQW(void) { int i; int n; + // if time has not advanced, do nothing + if (cl.movecmd[0].time <= cl.movecmd[1].time) + return; // remove stale queue items n = cl.movement_numqueue; cl.movement_numqueue = 0; - if (cl.movement) + for (i = 0;i < n;i++) { - for (i = 0;i < n;i++) - 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++; - } + if (cl.movement_queue[i].sequence > cls.netcon->qw.incoming_sequence) + cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i]; + else if (i == 0) + cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken + } + // add to input queue if there is room + if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0]))) + { + // add to input queue + cl.movement_queue[cl.movement_numqueue].sequence = cls.netcon->qw.outgoing_sequence; + cl.movement_queue[cl.movement_numqueue].time = cl.movecmd[0].time; + cl.movement_queue[cl.movement_numqueue].frametime = cl.cmd.msec / 1000.0; + VectorCopy(cl.cmd.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 = (cl.cmd.buttons & 2) != 0; + cl.movement_queue[cl.movement_numqueue].crouch = false; + cl.movement_numqueue++; } - cl.movement_replay = true; + CL_ClientMovement_Replay(); } void CL_ClientMovement_Input(qboolean buttonjump, qboolean buttoncrouch) { int i; int n; + // if time has not advanced, do nothing + if (cl.movecmd[0].time <= cl.movecmd[1].time) + return; // remove stale queue items n = cl.movement_numqueue; cl.movement_numqueue = 0; - if (cl.movement) + if (cl.servermovesequence) { - 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 + for (i = 0;i < n;i++) { - 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]; + if (cl.movement_queue[i].sequence > cl.servermovesequence) + cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i]; + else if (i == 0) + cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken } - // 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]) + } + else + { + for (i = 0;i < n;i++) { - // 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.movement_queue[i].time >= cl.movecmd[0].time - cl_movement_latency.value / 1000.0 && cl.movement_queue[i].time <= cl.movecmd[0].time) + cl.movement_queue[cl.movement_numqueue++] = cl.movement_queue[i]; + else if (i == 0) + cl.movement_replay_canjump = !cl.movement_queue[i].jump; // FIXME: this logic is quite broken } } - cl.movement_replay = true; + // add to input queue if there is room + if (cl.movement_numqueue < (int)(sizeof(cl.movement_queue)/sizeof(cl.movement_queue[0]))) + { + // add to input queue + cl.movement_queue[cl.movement_numqueue].sequence = cl.movesequence; + cl.movement_queue[cl.movement_numqueue].time = cl.movecmd[0].time; + cl.movement_queue[cl.movement_numqueue].frametime = bound(0, cl.movecmd[0].time - cl.movecmd[1].time, 0.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_ClientMovement_Replay(); } -void CL_ClientMovement_Replay(void) +typedef enum waterlevel_e { - int i; - int bump; - int contents; - int crouch; - int onground; - int canjump; + WATERLEVEL_NONE, + WATERLEVEL_WETFEET, + WATERLEVEL_SWIMMING, + WATERLEVEL_SUBMERGED +} +waterlevel_t; + +typedef struct cl_clientmovement_state_s +{ + // position + vec3_t origin; + vec3_t velocity; + // current bounding box (different if crouched vs standing) + vec3_t mins; + vec3_t maxs; + // currently on the ground + qboolean onground; + // currently crouching + qboolean crouched; + // whether jump button has been released since last jump + qboolean canjump; + // what kind of water (SUPERCONTENTS_LAVA for instance) + int watertype; + // how deep + waterlevel_t waterlevel; + // weird hacks when jumping out of water + // (this is in seconds and counts down to 0) + float waterjumptime; + + // movement parameters for physics code float movevars_gravity; float movevars_stopspeed; float movevars_maxspeed; @@ -606,293 +691,534 @@ void CL_ClientMovement_Replay(void) float movevars_edgefriction; float movevars_maxairspeed; float movevars_stepheight; - double edgefriction; - double frametime; + float movevars_airaccel_qw; + float movevars_airaccel_sideways_friction; + + // user command + client_movementqueue_t q; +} +cl_clientmovement_state_t; + +#define NUMOFFSETS 27 +static vec3_t offsets[NUMOFFSETS] = +{ +// 1 no nudge (just return the original if this test passes) + { 0.000, 0.000, 0.000}, +// 6 simple nudges + { 0.000, 0.000, 0.125}, { 0.000, 0.000, -0.125}, + {-0.125, 0.000, 0.000}, { 0.125, 0.000, 0.000}, + { 0.000, -0.125, 0.000}, { 0.000, 0.125, 0.000}, +// 4 diagonal flat nudges + {-0.125, -0.125, 0.000}, { 0.125, -0.125, 0.000}, + {-0.125, 0.125, 0.000}, { 0.125, 0.125, 0.000}, +// 8 diagonal upward nudges + {-0.125, 0.000, 0.125}, { 0.125, 0.000, 0.125}, + { 0.000, -0.125, 0.125}, { 0.000, 0.125, 0.125}, + {-0.125, -0.125, 0.125}, { 0.125, -0.125, 0.125}, + {-0.125, 0.125, 0.125}, { 0.125, 0.125, 0.125}, +// 8 diagonal downward nudges + {-0.125, 0.000, -0.125}, { 0.125, 0.000, -0.125}, + { 0.000, -0.125, -0.125}, { 0.000, 0.125, -0.125}, + {-0.125, -0.125, -0.125}, { 0.125, -0.125, -0.125}, + {-0.125, 0.125, -0.125}, { 0.125, 0.125, -0.125}, +}; + +qboolean CL_ClientMovement_Unstick(cl_clientmovement_state_t *s) +{ + int i; + vec3_t neworigin; + for (i = 0;i < NUMOFFSETS;i++) + { + VectorAdd(offsets[i], s->origin, neworigin); + if (!CL_TraceBox(neworigin, cl.playercrouchmins, cl.playercrouchmaxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_PLAYERCLIP, true).startsolid) + { + VectorCopy(neworigin, s->origin); + return true; + } + } + // if all offsets failed, give up + return false; +} + +void CL_ClientMovement_UpdateStatus(cl_clientmovement_state_t *s) +{ + vec3_t origin1, origin2; + trace_t trace; + + // make sure player is not stuck + CL_ClientMovement_Unstick(s); + + // set crouched + if (s->q.crouch) + { + // wants to crouch, this always works.. + if (!s->crouched) + s->crouched = true; + } + else + { + // wants to stand, if currently crouching we need to check for a + // low ceiling first + if (s->crouched) + { + trace = CL_TraceBox(s->origin, cl.playerstandmins, cl.playerstandmaxs, s->origin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true); + if (!trace.startsolid) + s->crouched = false; + } + } + if (s->crouched) + { + VectorCopy(cl.playercrouchmins, s->mins); + VectorCopy(cl.playercrouchmaxs, s->maxs); + } + else + { + VectorCopy(cl.playerstandmins, s->mins); + VectorCopy(cl.playerstandmaxs, s->maxs); + } + + // set onground + VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + 1); + VectorSet(origin2, s->origin[0], s->origin[1], s->origin[2] - 2); + trace = CL_TraceBox(origin1, s->mins, s->maxs, origin2, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true); + s->onground = trace.fraction < 1 && trace.plane.normal[2] > 0.7 && s->velocity[2] < cl_gravity.value * s->q.frametime; + + // set watertype/waterlevel + VectorSet(origin1, s->origin[0], s->origin[1], s->origin[2] + s->mins[2] + 1); + s->waterlevel = WATERLEVEL_NONE; + s->watertype = CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK; + if (s->watertype) + { + s->waterlevel = WATERLEVEL_WETFEET; + origin1[2] = s->origin[2] + (s->mins[2] + s->maxs[2]) * 0.5f; + if (CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK) + { + s->waterlevel = WATERLEVEL_SWIMMING; + origin1[2] = s->origin[2] + 22; + if (CL_TraceBox(origin1, vec3_origin, vec3_origin, origin1, true, NULL, 0, false).startsupercontents & SUPERCONTENTS_LIQUIDSMASK) + s->waterlevel = WATERLEVEL_SUBMERGED; + } + } + + // water jump prediction + if (s->onground || s->velocity[2] <= 0 || s->waterjumptime <= 0) + s->waterjumptime = 0; +} + +void CL_ClientMovement_Move(cl_clientmovement_state_t *s) +{ + int bump; double t; + vec_t f; + vec3_t neworigin; + vec3_t currentorigin2; + vec3_t neworigin2; + vec3_t primalvelocity; + trace_t trace; + trace_t trace2; + trace_t trace3; + CL_ClientMovement_UpdateStatus(s); + VectorCopy(s->velocity, primalvelocity); + for (bump = 0, t = s->q.frametime;bump < 8 && VectorLength2(s->velocity) > 0;bump++) + { + VectorMA(s->origin, t, s->velocity, neworigin); + trace = CL_TraceBox(s->origin, s->mins, s->maxs, neworigin, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true); + if (trace.fraction < 1 && trace.plane.normal[2] == 0) + { + // may be a step or wall, try stepping up + // first move forward at a higher level + VectorSet(currentorigin2, s->origin[0], s->origin[1], s->origin[2] + s->movevars_stepheight); + VectorSet(neworigin2, neworigin[0], neworigin[1], s->origin[2] + s->movevars_stepheight); + trace2 = CL_TraceBox(currentorigin2, s->mins, s->maxs, 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], s->origin[2]); + trace3 = CL_TraceBox(currentorigin2, s->mins, s->maxs, 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); + } + } + } + + // check if it moved at all + if (trace.fraction >= 0.001) + VectorCopy(trace.endpos, s->origin); + + // check if it moved all the way + if (trace.fraction == 1) + break; + + //if (trace.plane.normal[2] > 0.7) + // s->onground = true; + + t -= t * trace.fraction; + + f = DotProduct(s->velocity, trace.plane.normal); + VectorMA(s->velocity, -f, trace.plane.normal, s->velocity); + } + if (s->waterjumptime > 0) + VectorCopy(primalvelocity, s->velocity); +} + + +void CL_ClientMovement_Physics_Swim(cl_clientmovement_state_t *s) +{ + vec_t wishspeed; + vec_t f; + vec3_t wishvel; + vec3_t wishdir; + + // water jump only in certain situations + // this mimics quakeworld code + if (s->q.jump && s->waterlevel == 2 && s->velocity[2] >= -180) + { + vec3_t forward; + vec3_t yawangles; + vec3_t spot; + VectorSet(yawangles, 0, s->q.viewangles[1], 0); + AngleVectors(yawangles, forward, NULL, NULL); + VectorMA(s->origin, 24, forward, spot); + spot[2] += 8; + if (CL_TraceBox(spot, vec3_origin, vec3_origin, spot, true, NULL, 0, false).startsolid) + { + spot[2] += 24; + if (!CL_TraceBox(spot, vec3_origin, vec3_origin, spot, true, NULL, 0, false).startsolid) + { + VectorScale(forward, 50, s->velocity); + s->velocity[2] = 310; + s->waterjumptime = 2; + s->onground = false; + s->canjump = false; + } + } + } + + if (!VectorLength2(s->q.move)) + { + // drift towards bottom + VectorSet(wishvel, 0, 0, -60); + } + else + { + // swim + vec3_t forward; + vec3_t right; + vec3_t up; + // calculate movement vector + AngleVectors(s->q.viewangles, forward, right, up); + VectorSet(up, 0, 0, 1); + VectorMAMAM(s->q.move[0], forward, s->q.move[1], right, s->q.move[2], up, wishvel); + } + + // split wishvel into wishspeed and wishdir + wishspeed = VectorLength(wishvel); + if (wishspeed) + VectorScale(wishvel, 1 / wishspeed, wishdir); + else + VectorSet( wishdir, 0.0, 0.0, 0.0 ); + wishspeed = min(wishspeed, s->movevars_maxspeed) * 0.7; + + if (s->crouched) + wishspeed *= 0.5; + + if (s->waterjumptime <= 0) + { + // water friction + f = 1 - s->q.frametime * s->movevars_waterfriction * s->waterlevel; + f = bound(0, f, 1); + VectorScale(s->velocity, f, s->velocity); + + // water acceleration + f = wishspeed - DotProduct(s->velocity, wishdir); + if (f > 0) + { + f = min(s->movevars_wateraccelerate * s->q.frametime * wishspeed, f); + VectorMA(s->velocity, f, wishdir, s->velocity); + } + + // holding jump button swims upward slowly + if (s->q.jump) + { + if (s->watertype & SUPERCONTENTS_LAVA) + s->velocity[2] = 50; + else if (s->watertype & SUPERCONTENTS_SLIME) + s->velocity[2] = 80; + else + { + if (gamemode == GAME_NEXUIZ) + s->velocity[2] = 200; + else + s->velocity[2] = 100; + } + } + } + + CL_ClientMovement_Move(s); +} + +void CL_ClientMovement_Physics_Walk(cl_clientmovement_state_t *s) +{ + vec_t friction; vec_t wishspeed; vec_t addspeed; vec_t accelspeed; vec_t f; - vec_t *playermins; - vec_t *playermaxs; - vec3_t currentorigin; - vec3_t currentvelocity; vec3_t forward; vec3_t right; vec3_t up; vec3_t wishvel; vec3_t wishdir; - vec3_t neworigin; - vec3_t currentorigin2; - vec3_t neworigin2; vec3_t yawangles; trace_t trace; - trace_t trace2; - trace_t trace3; + // jump if on ground with jump button pressed but only if it has been + // released at least once since the last jump + if (s->q.jump && s->onground)// && s->canjump) // FIXME: canjump doesn't work properly + { + s->velocity[2] += s->movevars_jumpvelocity; + s->onground = false; + s->canjump = false; + } - if (!cl.movement_replay) - return; - cl.movement_replay = false; + // calculate movement vector + VectorSet(yawangles, 0, s->q.viewangles[1], 0); + AngleVectors(yawangles, forward, right, up); + VectorMAM(s->q.move[0], forward, s->q.move[1], right, wishvel); - if (cls.protocol == PROTOCOL_QUAKEWORLD) + // split wishvel into wishspeed and wishdir + wishspeed = VectorLength(wishvel); + if (wishspeed) + VectorScale(wishvel, 1 / wishspeed, wishdir); + else + VectorSet( wishdir, 0.0, 0.0, 0.0 ); + wishspeed = min(wishspeed, s->movevars_maxspeed); + if (s->crouched) + wishspeed *= 0.5; + + // check if onground + if (s->onground) { - 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; + // apply edge friction + f = sqrt(s->velocity[0] * s->velocity[0] + s->velocity[1] * s->velocity[1]); + friction = s->movevars_friction; + if (f > 0 && s->movevars_edgefriction != 1) + { + vec3_t neworigin2; + vec3_t neworigin3; + // note: QW uses the full player box for the trace, and yet still + // uses s->origin[2] + s->mins[2], which is clearly an bug, but + // this mimics it for compatibility + VectorSet(neworigin2, s->origin[0] + s->velocity[0]*(16/f), s->origin[1] + s->velocity[1]*(16/f), s->origin[2] + s->mins[2]); + VectorSet(neworigin3, neworigin2[0], neworigin2[1], neworigin2[2] - 34); + if (cls.protocol == PROTOCOL_QUAKEWORLD) + trace = CL_TraceBox(neworigin2, s->mins, s->maxs, neworigin3, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true); + else + trace = CL_TraceBox(neworigin2, vec3_origin, vec3_origin, neworigin3, true, NULL, SUPERCONTENTS_SOLID | SUPERCONTENTS_BODY | SUPERCONTENTS_PLAYERCLIP, true); + if (trace.fraction == 1 && !trace.startsolid) + friction *= s->movevars_edgefriction; + } + // apply ground friction + f = 1 - s->q.frametime * friction * ((f < s->movevars_stopspeed) ? (s->movevars_stopspeed / f) : 1); + f = max(f, 0); + VectorScale(s->velocity, f, s->velocity); + addspeed = wishspeed - DotProduct(s->velocity, wishdir); + if (addspeed > 0) + { + accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed); + VectorMA(s->velocity, accelspeed, wishdir, s->velocity); + } + s->velocity[2] -= cl_gravity.value * s->q.frametime; + if (cls.protocol == PROTOCOL_QUAKEWORLD) + s->velocity[2] = 0; + if (VectorLength2(s->velocity)) + CL_ClientMovement_Move(s); } 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; + if (s->waterjumptime <= 0) + { + vec_t f; + vec_t vel_straight; + vec_t vel_z; + vec3_t vel_perpend; + + // apply air speed limit + wishspeed = min(wishspeed, s->movevars_maxairspeed); + + /* + addspeed = wishspeed - DotProduct(s->velocity, wishdir); + if (addspeed > 0) + { + accelspeed = min(s->movevars_accelerate * s->q.frametime * wishspeed, addspeed); + VectorMA(s->velocity, accelspeed, wishdir, s->velocity); + } + */ + + vel_straight = DotProduct(s->velocity, wishdir); + vel_z = s->velocity[2]; + VectorMA(s->velocity, -vel_straight, wishdir, vel_perpend); + vel_perpend[2] -= vel_z; + + f = wishspeed - vel_straight; + if(f > 0) + vel_straight += min(f, s->movevars_accelerate * s->q.frametime * wishspeed) * s->movevars_airaccel_qw; + if(wishspeed > 0) + vel_straight += min(wishspeed, s->movevars_accelerate * s->q.frametime * wishspeed) * (1 - s->movevars_airaccel_qw); + + VectorM(1 - (s->q.frametime * (wishspeed / s->movevars_maxairspeed) * s->movevars_airaccel_sideways_friction), vel_perpend, vel_perpend); + + VectorMA(vel_perpend, vel_straight, wishdir, s->velocity); + s->velocity[2] += vel_z; + } + s->velocity[2] -= cl_gravity.value * s->q.frametime; + CL_ClientMovement_Move(s); } +} - // fetch current starting values - 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 +void CL_ClientMovement_PlayerMove(cl_clientmovement_state_t *s) +{ + //Con_Printf(" %f", frametime); + if (!s->q.jump) + s->canjump = true; + s->waterjumptime -= s->q.frametime; + CL_ClientMovement_UpdateStatus(s); + if (s->waterlevel >= WATERLEVEL_SWIMMING) + CL_ClientMovement_Physics_Swim(s); + else + CL_ClientMovement_Physics_Walk(s); +} - // check if onground - VectorSet(currentorigin2, currentorigin[0], currentorigin[1], currentorigin[2] + 1); - VectorSet(neworigin2, currentorigin[0], currentorigin[1], currentorigin[2] - 1); - if (cl.movement) +void CL_ClientMovement_Replay(void) +{ + int i; + cl_clientmovement_state_t s; + + // set up starting state for the series of moves + memset(&s, 0, sizeof(s)); + VectorCopy(cl.entities[cl.playerentity].state_current.origin, s.origin); + VectorCopy(cl.mvelocity[0], s.velocity); + s.crouched = true; // will be updated on first move + s.canjump = cl.movement_replay_canjump; + //Con_Printf("movement replay starting org %f %f %f vel %f %f %f\n", s.origin[0], s.origin[1], s.origin[2], s.velocity[0], s.velocity[1], s.velocity[2]); + + // set up movement variables + if (cls.protocol == PROTOCOL_QUAKEWORLD) { - 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]); + s.movevars_gravity = cl.qw_movevars_gravity; + s.movevars_stopspeed = cl.qw_movevars_stopspeed; + s.movevars_maxspeed = cl.qw_movevars_maxspeed; + s.movevars_spectatormaxspeed = cl.qw_movevars_spectatormaxspeed; + s.movevars_accelerate = cl.qw_movevars_accelerate; + s.movevars_airaccelerate = cl.qw_movevars_airaccelerate; + s.movevars_wateraccelerate = cl.qw_movevars_wateraccelerate; + s.movevars_friction = cl.qw_movevars_friction; + s.movevars_waterfriction = cl.qw_movevars_waterfriction; + s.movevars_entgravity = cl.qw_movevars_entgravity; + s.movevars_jumpvelocity = cl_movement_jumpvelocity.value; + s.movevars_edgefriction = cl_movement_edgefriction.value; + s.movevars_maxairspeed = cl_movement_maxairspeed.value; + s.movevars_stepheight = cl_movement_stepheight.value; + s.movevars_airaccel_qw = 1.0; + s.movevars_airaccel_sideways_friction = 0.0; + } + else + { + s.movevars_gravity = sv_gravity.value; + s.movevars_stopspeed = cl_movement_stopspeed.value; + s.movevars_maxspeed = cl_movement_maxspeed.value; + s.movevars_spectatormaxspeed = cl_movement_maxspeed.value; + s.movevars_accelerate = cl_movement_accelerate.value; + s.movevars_airaccelerate = cl_movement_airaccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_airaccelerate.value; + s.movevars_wateraccelerate = cl_movement_wateraccelerate.value < 0 ? cl_movement_accelerate.value : cl_movement_wateraccelerate.value; + s.movevars_friction = cl_movement_friction.value; + s.movevars_waterfriction = cl_movement_waterfriction.value < 0 ? cl_movement_friction.value : cl_movement_waterfriction.value; + s.movevars_entgravity = 1; + s.movevars_jumpvelocity = cl_movement_jumpvelocity.value; + s.movevars_edgefriction = cl_movement_edgefriction.value; + s.movevars_maxairspeed = cl_movement_maxairspeed.value; + s.movevars_stepheight = cl_movement_stepheight.value; + s.movevars_airaccel_qw = cl_movement_airaccel_qw.value; + s.movevars_airaccel_sideways_friction = cl_movement_airaccel_sideways_friction.value; + } + + cl.movement_predicted = (cl_movement.integer && !cls.demoplayback && cls.signon == SIGNONS && cl.stats[STAT_HEALTH] > 0 && !cl.intermission) && ((cls.protocol != PROTOCOL_DARKPLACES6 && cls.protocol != PROTOCOL_DARKPLACES7) || cl.servermovesequence); + if (cl.movement_predicted) + { + //Con_Printf("%f: ", cl.movecmd[0].time); // 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) - { - if (q->crouch) - { - // wants to crouch, this always works... - if (!crouch) - crouch = true; - } - else - { - // 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) - { - 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, movevars_maxspeed) * 0.6; - if (crouch) - wishspeed *= 0.5; - VectorScale(currentvelocity, (1 - frametime * movevars_waterfriction), currentvelocity); - f = wishspeed - DotProduct(currentvelocity, wishdir); - if (f > 0) - { - 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 - { - if (gamemode == GAME_NEXUIZ) - currentvelocity[2] = 200; - else - currentvelocity[2] = 100; - } - } - } - else - { - // 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) - { - accelspeed = min(movevars_accelerate * frametime * wishspeed, addspeed); - VectorMA(currentvelocity, accelspeed, wishdir, currentvelocity); - } - currentvelocity[2] -= cl_gravity.value * frametime; - } - } - //if (i < cl.movement_numqueue - 1 || (cl_movement.integer & 4)) + s.q = cl.movement_queue[i]; + // if a move is more than 50ms, do it as two moves (matching qwsv) + if (s.q.frametime > 0.05) { - 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_BODY | SUPERCONTENTS_PLAYERCLIP, true); - if (trace.fraction < 1 && trace.plane.normal[2] == 0) - { - // 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); - // 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); - } + s.q.frametime *= 0.5; + CL_ClientMovement_PlayerMove(&s); } + CL_ClientMovement_PlayerMove(&s); } - // store replay location - cl.onground = onground; } - 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); + else + { + // get the first movement queue entry to know whether to crouch and such + s.q = cl.movement_queue[0]; + } + CL_ClientMovement_UpdateStatus(&s); + + // store replay location + if (cl.movecmd[0].time > cl.movecmd[1].time) + { + cl.movement_time[1] = cl.movecmd[1].time; + cl.movement_time[0] = cl.movecmd[0].time; + cl.movement_time[2] = cl.timenonlerp; + VectorCopy(cl.movement_origin, cl.movement_oldorigin); + VectorCopy(s.origin, cl.movement_origin); + VectorCopy(s.velocity, cl.movement_velocity); + //VectorCopy(s.origin, cl.entities[cl.playerentity].state_current.origin); + //VectorSet(cl.entities[cl.playerentity].state_current.angles, 0, cl.viewangles[1], 0); + + // update the onground flag if appropriate + // when not predicted, cl.onground is only cleared by cl_parse.c, but can + // be set forcefully here to hide server inconsistencies in the onground + // flag (such as when stepping up stairs, the onground flag tends to turn + // off briefly due to precision errors, particularly at high framerates), + // such inconsistencies can mess up the gun bobbing and stair smoothing, + // so they must be avoided. + if (cl.movement_predicted) + cl.onground = s.onground; + else if (s.onground) + cl.onground = true; + + // react to onground state changes (for gun bob) + if (cl.onground) + { + if (!cl.oldonground) + cl.hitgroundtime = cl.movecmd[0].time; + cl.lastongroundtime = cl.movecmd[0].time; + } + cl.oldonground = cl.onground; + } } -void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t *to) +void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, usercmd_t *from, usercmd_t *to) { int bits; bits = 0; - if (to->angles[0] != from->angles[0]) + if (to->viewangles[0] != from->viewangles[0]) bits |= QW_CM_ANGLE1; - if (to->angles[1] != from->angles[1]) + if (to->viewangles[1] != from->viewangles[1]) bits |= QW_CM_ANGLE2; - if (to->angles[2] != from->angles[2]) + if (to->viewangles[2] != from->viewangles[2]) bits |= QW_CM_ANGLE3; if (to->forwardmove != from->forwardmove) bits |= QW_CM_FORWARD; @@ -907,11 +1233,11 @@ void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t * MSG_WriteByte(buf, bits); if (bits & QW_CM_ANGLE1) - MSG_WriteAngle16i(buf, to->angles[0]); + MSG_WriteAngle16i(buf, to->viewangles[0]); if (bits & QW_CM_ANGLE2) - MSG_WriteAngle16i(buf, to->angles[1]); + MSG_WriteAngle16i(buf, to->viewangles[1]); if (bits & QW_CM_ANGLE3) - MSG_WriteAngle16i(buf, to->angles[2]); + MSG_WriteAngle16i(buf, to->viewangles[2]); if (bits & QW_CM_FORWARD) MSG_WriteShort(buf, to->forwardmove); if (bits & QW_CM_SIDE) @@ -930,172 +1256,160 @@ void QW_MSG_WriteDeltaUsercmd(sizebuf_t *buf, qw_usercmd_t *from, qw_usercmd_t * CL_SendMove ============== */ -extern cvar_t cl_netinputpacketspersecond; +usercmd_t nullcmd; // for delta compression of qw moves void CL_SendMove(void) { - int i; + int i, j, packetloss, maxusercmds; int bits; - int impulse; sizebuf_t buf; - unsigned char data[128]; + unsigned char data[1024]; static double lastsendtime = 0; -#define MOVEAVERAGING 0 -#if MOVEAVERAGING - static float accumforwardmove = 0, accumsidemove = 0, accumupmove = 0, accumtotal = 0; // accumulation -#endif - float forwardmove, sidemove, upmove; + double msectime; + static double oldmsectime; // if playing a demo, do nothing if (!cls.netcon) return; -#if MOVEAVERAGING - // accumulate changes between messages - accumforwardmove += cl.cmd.forwardmove; - accumsidemove += cl.cmd.sidemove; - accumupmove += cl.cmd.upmove; - accumtotal++; -#endif - +#if 0 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 +#endif { - cl.movement = false; - if (realtime < lastsendtime + 1.0 / bound(10, cl_netinputpacketspersecond.value, 100)) + double packettime = 1.0 / bound(10, cl_netinputpacketspersecond.value, 100); + // don't send too often or else network connections can get clogged by a high renderer framerate + if (realtime < lastsendtime + packettime) 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); + lastsendtime = max(lastsendtime + packettime, realtime); } -#if MOVEAVERAGING - // average the accumulated changes - 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; - sidemove = cl.cmd.sidemove; - upmove = cl.cmd.upmove; -#endif - if (cls.signon == SIGNONS) - CL_UpdatePrydonCursor(); + cl.cmd.time = cls.protocol == PROTOCOL_QUAKEWORLD ? realtime : cl.timenonlerp; - buf.maxsize = 128; + buf.maxsize = sizeof(data); buf.cursize = 0; buf.data = data; - // set button bits - // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button - bits = 0; - if (in_attack.state & 3) bits |= 1;in_attack.state &= ~2; - if (in_jump.state & 3) bits |= 2;in_jump.state &= ~2; - if (in_button3.state & 3) bits |= 4;in_button3.state &= ~2; - if (in_button4.state & 3) bits |= 8;in_button4.state &= ~2; - if (in_button5.state & 3) bits |= 16;in_button5.state &= ~2; - if (in_button6.state & 3) bits |= 32;in_button6.state &= ~2; - if (in_button7.state & 3) bits |= 64;in_button7.state &= ~2; - if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2; - 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; - 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; - - impulse = in_impulse; - in_impulse = 0; - - csqc_buttons = bits; - - if (cls.signon == SIGNONS) + // conditions for sending a move: + // if the move advances time or if the game is paused (in which case time + // is not advancing) + if ((cl.cmd.time > cl.movecmd[0].time || cl.mtime[0] == cl.mtime[1]) && 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 per move (can be up to 16 moves) + // PROTOCOL_QUAKEWORLD clc_move = 34 bytes total (typically, but can reach 43 bytes, or even 49 bytes with roll) + + // set button bits + // LordHavoc: added 6 new buttons and use and chat buttons, and prydon cursor active button + bits = 0; + if (in_attack.state & 3) bits |= 1;in_attack.state &= ~2; + if (in_jump.state & 3) bits |= 2;in_jump.state &= ~2; + if (in_button3.state & 3) bits |= 4;in_button3.state &= ~2; + if (in_button4.state & 3) bits |= 8;in_button4.state &= ~2; + if (in_button5.state & 3) bits |= 16;in_button5.state &= ~2; + if (in_button6.state & 3) bits |= 32;in_button6.state &= ~2; + if (in_button7.state & 3) bits |= 64;in_button7.state &= ~2; + if (in_button8.state & 3) bits |= 128;in_button8.state &= ~2; + 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; + 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; + cl.cmd.buttons = bits; + + // set impulse + cl.cmd.impulse = in_impulse; + in_impulse = 0; + + // movement is set by input code (forwardmove/sidemove/upmove) + + // set viewangles + VectorCopy(cl.viewangles, cl.cmd.viewangles); + + msectime = floor(cl.cmd.time * 1000); + cl.cmd.msec = (unsigned char)bound(0, msectime - oldmsectime, 255); + // ridiculous value rejection (matches qw) + if (cl.cmd.msec > 250) + cl.cmd.msec = 100; + oldmsectime = msectime; + + cl.movesequence++; + if (cl_movement.integer) + cl.cmd.sequence = cl.movesequence; + else + cl.cmd.sequence = 0; + + // set prydon cursor info + CL_UpdatePrydonCursor(); + // always dump the first two messages, because they may contain leftover inputs from the last level - if (++cl.movemessages >= 2) + if (cl.movesequence > 2) { - // 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) + // update the cl.movecmd array which holds the most recent moves + for (i = CL_MAX_USERCMDS - 1;i >= 1;i--) + cl.movecmd[i] = cl.movecmd[i-1]; + cl.movecmd[0] = cl.cmd; + + // set the maxusercmds variable to limit how many should be sent + if (cls.protocol == PROTOCOL_QUAKEWORLD) + { + // qw uses exactly 3 moves + maxusercmds = 3; + } + else + { + // configurable number of unacknowledged moves + maxusercmds = bound(1, cl_netinputpacketlosstolerance.integer + 1, CL_MAX_USERCMDS); + // when movement prediction is off, there's not much point in repeating old input as it will just be ignored + if (!cl_movement.integer) + maxusercmds = 1; + } + if (cls.protocol == PROTOCOL_QUAKEWORLD) { 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); + + CL_ClientMovement_InputQW(); 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); + for (j = 0, packetloss = 0;j < 100;j++) + packetloss += cls.netcon->packetlost[j]; + MSG_WriteByte(&buf, packetloss); // 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); + QW_MSG_WriteDeltaUsercmd(&buf, &nullcmd, &cl.movecmd[2]); + QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[2], &cl.movecmd[1]); + QW_MSG_WriteDeltaUsercmd(&buf, &cl.movecmd[1], &cl.movecmd[0]); // 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 @@ -1113,119 +1427,136 @@ void CL_SendMove(void) } else if (cls.protocol == PROTOCOL_QUAKE || cls.protocol == PROTOCOL_QUAKEDP || cls.protocol == PROTOCOL_NEHAHRAMOVIE) { + CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false); + // 5 bytes MSG_WriteByte (&buf, clc_move); - MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times + MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time // 3 bytes for (i = 0;i < 3;i++) - MSG_WriteAngle8i (&buf, cl.viewangles[i]); + MSG_WriteAngle8i (&buf, cl.movecmd[0].viewangles[i]); // 6 bytes - MSG_WriteCoord16i (&buf, forwardmove); - MSG_WriteCoord16i (&buf, sidemove); - MSG_WriteCoord16i (&buf, upmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove); // 2 bytes - MSG_WriteByte (&buf, bits); - MSG_WriteByte (&buf, impulse); - - CL_ClientMovement_Input((bits & 2) != 0, false); + MSG_WriteByte (&buf, cl.movecmd[0].buttons); + MSG_WriteByte (&buf, cl.movecmd[0].impulse); } else if (cls.protocol == PROTOCOL_DARKPLACES2 || cls.protocol == PROTOCOL_DARKPLACES3) { + CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false); + // 5 bytes MSG_WriteByte (&buf, clc_move); - MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times + MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time // 12 bytes for (i = 0;i < 3;i++) - MSG_WriteAngle32f (&buf, cl.viewangles[i]); + MSG_WriteAngle32f (&buf, cl.movecmd[0].viewangles[i]); // 6 bytes - MSG_WriteCoord16i (&buf, forwardmove); - MSG_WriteCoord16i (&buf, sidemove); - MSG_WriteCoord16i (&buf, upmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove); // 2 bytes - MSG_WriteByte (&buf, bits); - MSG_WriteByte (&buf, impulse); - - CL_ClientMovement_Input((bits & 2) != 0, false); + MSG_WriteByte (&buf, cl.movecmd[0].buttons); + MSG_WriteByte (&buf, cl.movecmd[0].impulse); } else if (cls.protocol == PROTOCOL_DARKPLACES1 || cls.protocol == PROTOCOL_DARKPLACES4 || cls.protocol == PROTOCOL_DARKPLACES5) { + CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, false); + // 5 bytes MSG_WriteByte (&buf, clc_move); - MSG_WriteFloat (&buf, cl.mtime[0]); // so server can get ping times + MSG_WriteFloat (&buf, cl.movecmd[0].time); // last server packet time // 6 bytes for (i = 0;i < 3;i++) - MSG_WriteAngle16i (&buf, cl.viewangles[i]); + MSG_WriteAngle16i (&buf, cl.movecmd[0].viewangles[i]); // 6 bytes - MSG_WriteCoord16i (&buf, forwardmove); - MSG_WriteCoord16i (&buf, sidemove); - MSG_WriteCoord16i (&buf, upmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].forwardmove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].sidemove); + MSG_WriteCoord16i (&buf, cl.movecmd[0].upmove); // 2 bytes - MSG_WriteByte (&buf, bits); - MSG_WriteByte (&buf, impulse); - - CL_ClientMovement_Input((bits & 2) != 0, false); + MSG_WriteByte (&buf, cl.movecmd[0].buttons); + MSG_WriteByte (&buf, cl.movecmd[0].impulse); } else { - // 5 bytes - MSG_WriteByte (&buf, clc_move); - if (cls.protocol != PROTOCOL_DARKPLACES6) + usercmd_t *cmd; + // FIXME: cl.movecmd[0].buttons & 16 is +button5, Nexuiz specific + CL_ClientMovement_Input((cl.movecmd[0].buttons & 2) != 0, (cl.movecmd[0].buttons & 16) != 0); + + // send the latest moves in order, the old ones will be + // ignored by the server harmlessly, however if the previous + // packets were lost these moves will be used + // + // this reduces packet loss impact on gameplay. + for (j = 0, cmd = &cl.movecmd[maxusercmds-1];j < maxusercmds;j++, cmd--) { - if (cl_movement.integer) - { - cl.movesequence++; - MSG_WriteLong (&buf, cl.movesequence); - } - else - MSG_WriteLong (&buf, 0); + // don't repeat any stale moves + if (cmd->sequence && cmd->sequence < cl.servermovesequence) + continue; + // 5/9 bytes + MSG_WriteByte (&buf, clc_move); + if (cls.protocol != PROTOCOL_DARKPLACES6) + MSG_WriteLong (&buf, cmd->sequence); + MSG_WriteFloat (&buf, cmd->time); // last server packet time + // 6 bytes + for (i = 0;i < 3;i++) + MSG_WriteAngle16i (&buf, cmd->viewangles[i]); + // 6 bytes + MSG_WriteCoord16i (&buf, cmd->forwardmove); + MSG_WriteCoord16i (&buf, cmd->sidemove); + MSG_WriteCoord16i (&buf, cmd->upmove); + // 5 bytes + MSG_WriteLong (&buf, cmd->buttons); + MSG_WriteByte (&buf, cmd->impulse); + // PRYDON_CLIENTCURSOR + // 30 bytes + MSG_WriteShort (&buf, (short)(cmd->cursor_screen[0] * 32767.0f)); + MSG_WriteShort (&buf, (short)(cmd->cursor_screen[1] * 32767.0f)); + MSG_WriteFloat (&buf, cmd->cursor_start[0]); + MSG_WriteFloat (&buf, cmd->cursor_start[1]); + MSG_WriteFloat (&buf, cmd->cursor_start[2]); + MSG_WriteFloat (&buf, cmd->cursor_impact[0]); + MSG_WriteFloat (&buf, cmd->cursor_impact[1]); + MSG_WriteFloat (&buf, cmd->cursor_impact[2]); + MSG_WriteShort (&buf, cmd->cursor_entitynumber); } - 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, 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); - - // FIXME: bits & 16 is +button5, Nexuiz specific - CL_ClientMovement_Input((bits & 2) != 0, (bits & 16) != 0); } } + } - if (cls.protocol != PROTOCOL_QUAKEWORLD) + if (cls.protocol != PROTOCOL_QUAKEWORLD) + { + // 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++) { - // 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 (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]); - } + 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 - // PROTOCOL_DARKPLACES6 = 67 bytes per packet - // PROTOCOL_DARKPLACES7 = 71 bytes per packet + if (cls.protocol != PROTOCOL_QUAKEWORLD) + { + // acknowledge any recently received data blocks + for (i = 0;i < CL_MAX_DOWNLOADACKS && (cls.dp_downloadack[i].start || cls.dp_downloadack[i].size);i++) + { + MSG_WriteByte(&buf, clc_ackdownloaddata); + MSG_WriteLong(&buf, cls.dp_downloadack[i].start); + MSG_WriteShort(&buf, cls.dp_downloadack[i].size); + cls.dp_downloadack[i].start = 0; + cls.dp_downloadack[i].size = 0; + } } // send the reliable message (forwarded commands) if there is one @@ -1314,6 +1645,9 @@ void CL_InitInput (void) Cmd_AddCommand ("+button16", IN_Button16Down, "activate button16 (behavior depends on mod)"); Cmd_AddCommand ("-button16", IN_Button16Up, "deactivate button16"); + // LordHavoc: added bestweapon command + Cmd_AddCommand ("bestweapon", IN_BestWeapon, "send an impulse number to server to select the first usable weapon out of several (example: 87654321)"); + Cvar_RegisterVariable(&cl_movement); Cvar_RegisterVariable(&cl_movement_latency); Cvar_RegisterVariable(&cl_movement_maxspeed); @@ -1322,8 +1656,11 @@ void CL_InitInput (void) Cvar_RegisterVariable(&cl_movement_friction); Cvar_RegisterVariable(&cl_movement_edgefriction); Cvar_RegisterVariable(&cl_movement_stepheight); + Cvar_RegisterVariable(&cl_movement_airaccelerate); Cvar_RegisterVariable(&cl_movement_accelerate); Cvar_RegisterVariable(&cl_movement_jumpvelocity); + Cvar_RegisterVariable(&cl_movement_airaccel_qw); + Cvar_RegisterVariable(&cl_movement_airaccel_sideways_friction); Cvar_RegisterVariable(&cl_gravity); Cvar_RegisterVariable(&cl_slowmo); @@ -1332,6 +1669,7 @@ void CL_InitInput (void) Cvar_RegisterVariable(&m_filter); Cvar_RegisterVariable(&cl_netinputpacketspersecond); + Cvar_RegisterVariable(&cl_netinputpacketlosstolerance); Cvar_RegisterVariable(&cl_nodelta); }