Con_Printf("no slot left for weapon definition; increase IN_BESTWEAPON_MAX\n");
return; // sorry
}
- strlcpy(in_bestweapon_info[i].name, name, sizeof(in_bestweapon_info[i].name));
+ dp_strlcpy(in_bestweapon_info[i].name, name, sizeof(in_bestweapon_info[i].name));
in_bestweapon_info[i].impulse = impulse;
if(weaponbit != -1)
in_bestweapon_info[i].weaponbit = weaponbit;
cvar_t in_pitch_max = {CF_CLIENT, "in_pitch_max", "90", "how far you can aim downward (quake used 80)"};
cvar_t m_filter = {CF_CLIENT | CF_ARCHIVE, "m_filter","0", "smoothes mouse movement, less responsive but smoother aiming"};
-cvar_t m_accelerate = {CF_CLIENT | CF_ARCHIVE, "m_accelerate","1", "linear mouse acceleration factor (set to 1 to disable the linear acceleration and use only the power acceleration; set to 0 to disable all acceleration)"};
+cvar_t m_accelerate = {CF_CLIENT | CF_ARCHIVE, "m_accelerate","1", "linear mouse acceleration factor (set to 1 to disable the linear acceleration and use only the power or natural acceleration; set to 0 to disable all acceleration)"};
cvar_t m_accelerate_minspeed = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_minspeed","5000", "below this speed in px/s, no acceleration is done, with a linear slope between (applied only on linear acceleration)"};
cvar_t m_accelerate_maxspeed = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_maxspeed","10000", "above this speed in px/s, full acceleration is done, with a linear slope between (applied only on linear acceleration)"};
cvar_t m_accelerate_filter = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_filter","0", "linear mouse acceleration factor filtering lowpass constant in seconds (set to 0 for no filtering)"};
cvar_t m_accelerate_power = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power","2", "acceleration power (must be above 1 to be useful)"};
cvar_t m_accelerate_power_senscap = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power_senscap", "0", "maximum acceleration factor generated by power acceleration; use 0 for unbounded"};
cvar_t m_accelerate_power_strength = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_power_strength", "0", "strength of the power mouse acceleration effect"};
+cvar_t m_accelerate_natural_strength = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_strength", "0", "How quickly the accelsensitivity approaches the m_accelerate_natural_accelsenscap, values are compressed between 0 and 1 but higher numbers are allowed"};
+cvar_t m_accelerate_natural_accelsenscap = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_accelsenscap", "0", "Horizontal asymptote that sets the maximum value for the natural mouse acceleration curve, value 2, for example, means that the maximum sensitivity is 2 times the base sensitivity"};
+cvar_t m_accelerate_natural_offset = {CF_CLIENT | CF_ARCHIVE, "m_accelerate_natural_offset", "0", "below this speed in px/ms, no natural acceleration is done"};
cvar_t cl_netfps = {CF_CLIENT | CF_ARCHIVE, "cl_netfps","72", "how many input packets to send to server each second"};
cvar_t cl_netrepeatinput = {CF_CLIENT | CF_ARCHIVE, "cl_netrepeatinput", "1", "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), only affects DP7 and later servers (Quake uses 0, QuakeWorld uses 2, and just for comparison Quake3 uses 1)"};
IN_Move ();
// send mouse move to csqc
- if (cl.csqc_loaded && cl_csqc_generatemousemoveevents.integer)
+ if (CLVM_prog->loaded && cl_csqc_generatemousemoveevents.integer)
{
if (cl.csqc_wantsmousemove)
{
static int oldwindowmouse[2];
if (oldwindowmouse[0] != in_windowmouse_x || oldwindowmouse[1] != in_windowmouse_y)
{
- CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.width, in_windowmouse_y * vid_conheight.value / vid.height);
+ CL_VM_InputEvent(3, in_windowmouse_x * vid_conwidth.value / vid.mode.width, in_windowmouse_y * vid_conheight.value / vid.mode.height);
oldwindowmouse[0] = in_windowmouse_x;
oldwindowmouse[1] = in_windowmouse_y;
}
}
}
- // apply m_accelerate if it is on
+ // apply m_accelerate if it is on
if(m_accelerate.value > 0)
{
float mouse_deltadist = sqrtf(in_mouse_x * in_mouse_x + in_mouse_y * in_mouse_y);
static float averagespeed = 0;
float f, mi, ma;
if(m_accelerate_filter.value > 0)
- f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
+ f = bound(0, cl.realframetime / m_accelerate_filter.value, 1);
else
- f = 1;
+ f = 1;
averagespeed = speed * f + averagespeed * (1 - f);
// Note: this check is technically unnecessary, as everything in here cancels out if it is zero.
{
// Then do Quake Live-style power acceleration.
// Note that this behavior REPLACES the usual
- // sensitivity, so we apply it but then dividie by
+ // sensitivity, so we apply it but then divide by
// sensitivity.value so that the later multiplication
// restores it again.
float accelsens = 1.0f;
{
// TODO: How does this interact with sensitivity changes? Is this intended?
// Currently: senscap is in absolute sensitivity units, so if senscap < sensitivity, it overrides.
- accelsens = m_accelerate_power_senscap.value * inv_sensitivity;
+ accelsens = m_accelerate_power_senscap.value * inv_sensitivity;
+ }
+
+ in_mouse_x *= accelsens;
+ in_mouse_y *= accelsens;
+ }
+
+ if (m_accelerate_natural_strength.value > 0.0f && m_accelerate_natural_accelsenscap.value >= 0.0f)
+ {
+ float accelsens = 1.0f;
+ float adjusted_speed_pxms = (averagespeed * 0.001f - m_accelerate_natural_offset.value);
+
+ if (adjusted_speed_pxms > 0 && m_accelerate_natural_accelsenscap.value != 1.0f)
+ {
+ float adjusted_accelsenscap = m_accelerate_natural_accelsenscap.value - 1.0f;
+ // This equation is made to multiply the sensitivity for a factor between 1 and m_accelerate_natural_accelsenscap
+ // this means there is no need to divide it for the sensitivity.value as the whole
+ // expression needs to be multiplied by the sensitivity at the end instead of only having the sens multiplied
+ accelsens += (adjusted_accelsenscap - adjusted_accelsenscap * exp( - ((adjusted_speed_pxms * m_accelerate_natural_strength.value) / fabs(adjusted_accelsenscap) )));
}
in_mouse_x *= accelsens;
// mouse interacting with the scene, mostly stationary view
V_StopPitchDrift();
// update prydon cursor
- cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.width - 1.0;
- cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.height - 1.0;
+ cl.cmd.cursor_screen[0] = in_windowmouse_x * 2.0 / vid.mode.width - 1.0;
+ cl.cmd.cursor_screen[1] = in_windowmouse_y * 2.0 / vid.mode.height - 1.0;
}
if(v_flipped.integer)
else
{
cl.moveflags = 0;
- cl.movevars_ticrate = (cls.demoplayback ? 1.0f : host_timescale.value) / bound(10.0f, cl_netfps.value, 1000.0f);
- cl.movevars_timescale = (cls.demoplayback ? 1.0f : host_timescale.value);
+ cl.movevars_ticrate = 0; // bones_was_here: no guessing, unavailable ticrate triggers better fallbacks
+ cl.movevars_timescale = (cls.demoplayback || host_timescale.value <= 0) ? 1.0f : host_timescale.value;
cl.movevars_gravity = sv_gravity.value;
cl.movevars_stopspeed = cl_movement_stopspeed.value;
cl.movevars_maxspeed = cl_movement_maxspeed.value;
usercmd_t *cmd;
sizebuf_t buf;
unsigned char data[1024];
- float packettime;
- int msecdelta;
+ float packettime, sv_frametime, lag, frames_per_tic;
+ qbool opportune_moment;
qbool quemove;
qbool important;
if (in_button7.state & 3) bits |= 64;
if (in_button8.state & 3) bits |= 128;
if (in_use.state & 3) bits |= 256;
- if (key_dest != key_game || key_consoleactive) bits |= 512;
+ if (key_dest != key_game || key_consoleactive || !vid_activewindow) bits |= 512;
if (cl_prydoncursor.integer > 0) bits |= 1024;
if (in_button9.state & 3) bits |= 2048;
if (in_button10.state & 3) bits |= 4096;
// set viewangles
VectorCopy(cl.viewangles, cl.cmd.viewangles);
- msecdelta = (int)(floor(cl.cmd.time * 1000) - floor(cl.movecmd[1].time * 1000));
- cl.cmd.msec = (unsigned char)bound(0, msecdelta, 255);
+ // bones_was_here: previously cl.cmd.frametime was floored to nearest millisec
+ // this meant the smoothest async movement required integer millisec
+ // client and server frame times (eg 125fps)
+ cl.cmd.frametime = bound(0.0, cl.cmd.time - cl.movecmd[1].time, 0.255);
// ridiculous value rejection (matches qw)
- if (cl.cmd.msec > 250)
- cl.cmd.msec = 100;
- cl.cmd.frametime = cl.cmd.msec * (1.0 / 1000.0);
+ if (cl.cmd.frametime > 0.25)
+ cl.cmd.frametime = 0.1;
+ cl.cmd.msec = (unsigned char)floor(cl.cmd.frametime * 1000);
switch(cls.protocol)
{
break;
case PROTOCOL_DARKPLACES6:
case PROTOCOL_DARKPLACES7:
+ case PROTOCOL_DARKPLACES8:
cl.cmd.predicted = cl_movement.integer != 0;
break;
default:
break;
case PROTOCOL_DARKPLACES6:
case PROTOCOL_DARKPLACES7:
+ case PROTOCOL_DARKPLACES8:
// FIXME: cl.cmd.buttons & 16 is +button5, Nexuiz/Xonotic specific
cl.cmd.crouch = (cl.cmd.buttons & 16) != 0;
break;
if (quemove)
cl.movecmd[0] = cl.cmd;
- // don't predict more than 200fps
- if (cl.timesincepacket >= 0.005)
+ /* Accumulating cl.realframetime to prevent low packet rates,
+ * previously with cl_maxfps == cl_netfps it did not send every frame because
+ * host.realtime - cl.lastpackettime was often well below (or above) cl_packetinterval.
+ */
+ cl.timesincepacket += cl.realframetime;
+
+ // don't predict more than 256fps
+ if (cl.timesincepacket >= 1/256)
cl.movement_replay = true; // redo the prediction
// now decide whether to actually send this move
// don't send too often or else network connections can get clogged by a
// high renderer framerate
packettime = 1.0f / bound(10.0f, cl_netfps.value, 1000.0f);
- if (cl.movevars_timescale && cl.movevars_ticrate)
+ if (cl.movevars_ticrate)
{
- // try to ensure at least 1 packet per server frame
- // and apply soft limit of 2, hard limit < 4 (packettime reduced further below)
- float maxtic = cl.movevars_ticrate / cl.movevars_timescale;
- packettime = bound(maxtic * 0.5f, packettime, maxtic);
+ packettime = bound(cl.movevars_ticrate * 0.5f, packettime, cl.movevars_ticrate);
+ sv_frametime = cl.movevars_ticrate;
}
- // bones_was_here: reduce packettime to (largest multiple of realframetime) <= packettime
- // prevents packet rates lower than cl_netfps or server frame rate
- // eg: cl_netfps 60 and cl_maxfps 250 would otherwise send only 50 netfps
- // with this line that config sends 62.5 netfps
- // (this causes it to emit packets at a steady beat)
- packettime = floor(packettime / (float)cl.realframetime) * (float)cl.realframetime;
+ else // fallback, may be affected by server->client network problems
+ sv_frametime = (cl.mtime[0] - cl.mtime[1]) / cl.movevars_timescale;
// always send if buttons changed or an impulse is pending
// even if it violates the rate limit!
important = (cl.cmd.impulse || (cl_netimmediatebuttons.integer && cl.cmd.buttons != cl.movecmd[1].buttons));
- // don't send too often (cl_netfps), allowing a small margin for float error
- // bones_was_here: accumulate realframetime to prevent low packet rates
- // previously with cl_maxfps == cl_netfps it did not send every frame as
- // host.realtime - cl.lastpackettime was often well below (or above) packettime
- if (!important && cl.timesincepacket < packettime * 0.99999f)
+ lag = cl.mtime[0] - cl.cmd.time;
+ frames_per_tic = sv_frametime / cl.realframetime;
+// opportune_moment = lag <= cl.realframetime * 2; // FAIL: can miss the moment with uncapped fps
+// opportune_moment = lag <= cl.realframetime * frames_per_tic * 0.5; // FAIL: too early at high fps, reducing multi causes misses at moderate fps
+ opportune_moment = lag <= cl.realframetime * (frames_per_tic <= 1 ? 1 : sqrt(frames_per_tic)); // perfect
+
+ // Two methods for deciding when to send
+ if (!important)
{
- cl.timesincepacket += cl.realframetime;
- return;
+ // Traditional time interval, now used as fallback
+ if (sv_frametime <= 0 || lag > sv_frametime || lag < 0) // unknown ticrate || lag/PL || still connecting
+ {
+ if (cl.timesincepacket < packettime * 0.99999f)
+ {
+// Con_Printf("^6moveft %f realft %f lag %f tic %f inputsince %d\n", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update);
+ return;
+ }
+ }
+ // Server-synchronised, for better pings
+ // Sends at least once per server frame
+ else // cl.opt_inputs_since_update is usable
+ {
+ if (!opportune_moment || cl.opt_inputs_since_update >= sv_frametime / packettime)
+ {
+// Con_Printf("^1moveft %f realft %f lag %f tic %f inputsince %d\n", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update);
+ return;
+ }
+ }
}
// don't choke the connection with packets (obey rate limit)
if (!NetConn_CanSend(cls.netcon) && !important)
return;
+// Con_Printf("%smoveft %f realft %f lag %f tic %f inputsince %d important %d\n", (lag < 0.0005 || !opportune_moment) ? "^3" : "^2", cl.cmd.frametime, cl.realframetime, lag, sv_frametime, cl.opt_inputs_since_update, important);
+
+ if (opportune_moment) // this check is needed for optimal timing especially with cl_netimmediatebuttons
+ ++cl.opt_inputs_since_update;
+
// reset the packet timing accumulator
- cl.timesincepacket = cl.realframetime;
+ cl.timesincepacket = 0;
buf.maxsize = sizeof(data);
buf.cursize = 0;
// 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_DARKPLACES8 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 prydon cursor info
MSG_WriteByte (&buf, cl.cmd.impulse);
case PROTOCOL_DARKPLACES6:
case PROTOCOL_DARKPLACES7:
+ case PROTOCOL_DARKPLACES8:
// set the maxusercmds variable to limit how many should be sent
maxusercmds = bound(1, cl_netrepeatinput.integer + 1, min(3, CL_MAX_USERCMDS));
// when movement prediction is off, there's not much point in repeating old input as it will just be ignored
in_impulse = 0;
if (cls.netcon->message.overflowed)
- {
- Con_Print("CL_SendMove: lost server connection\n");
- CL_Disconnect();
- SV_LockThreadMutex();
- SV_Shutdown();
- SV_UnlockThreadMutex();
- }
+ CL_DisconnectEx(true, "Lost connection to server");
}
/*
Cvar_RegisterVariable(&m_accelerate_power_offset);
Cvar_RegisterVariable(&m_accelerate_power_senscap);
Cvar_RegisterVariable(&m_accelerate_power_strength);
+ Cvar_RegisterVariable(&m_accelerate_natural_offset);
+ Cvar_RegisterVariable(&m_accelerate_natural_accelsenscap);
+ Cvar_RegisterVariable(&m_accelerate_natural_strength);
Cvar_RegisterVariable(&cl_netfps);
Cvar_RegisterVariable(&cl_netrepeatinput);
projects / xonotic / darkplaces.git / blobdiff