cvar_t cl_maxfps_alwayssleep = {CF_CLIENT | CF_ARCHIVE, "cl_maxfps_alwayssleep","1", "gives up some processing time to other applications each frame, value in milliseconds, disabled if cl_maxfps is 0"};
cvar_t cl_maxidlefps = {CF_CLIENT | CF_ARCHIVE, "cl_maxidlefps", "20", "maximum fps cap when the game is not the active window (makes cpu time available to other programs"};
+cvar_t cl_areagrid_link_SOLID_NOT = {CF_CLIENT, "cl_areagrid_link_SOLID_NOT", "1", "set to 0 to prevent SOLID_NOT entities from being linked to the area grid, and unlink any that are already linked (in the code paths that would otherwise link them), for better performance"};
+cvar_t cl_gameplayfix_nudgeoutofsolid_separation = {CF_CLIENT, "cl_gameplayfix_nudgeoutofsolid_separation", "0.03125", "keep objects this distance apart to prevent collision issues on seams"};
+
+
client_static_t cls;
client_state_t cl;
}
}
+static void CL_ToggleMenu_Hook(void)
+{
+#ifdef CONFIG_MENU
+ // remove menu
+ if (key_dest == key_menu || key_dest == key_menu_grabbed)
+ MR_ToggleMenu(0);
+#endif
+ key_dest = key_game;
+}
+
extern cvar_t rcon_secure;
/*
This is also called on Host_Error, so it shouldn't cause any errors
=====================
*/
-void CL_Disconnect(void)
+
+void CL_DisconnectEx(qbool kicked, const char *fmt, ... )
{
+ va_list argptr;
+ char reason[512];
+
if (cls.state == ca_dedicated)
return;
+ if(fmt)
+ {
+ va_start(argptr,fmt);
+ dpvsnprintf(reason,sizeof(reason),fmt,argptr);
+ va_end(argptr);
+ }
+ else
+ {
+ dpsnprintf(reason, sizeof(reason), "Disconnect by user");
+ }
+
if (Sys_CheckParm("-profilegameonly"))
Sys_AllowProfiling(false);
Con_DPrintf("CL_Disconnect\n");
- Cvar_SetValueQuick(&csqc_progcrc, -1);
+ Cvar_SetValueQuick(&csqc_progcrc, -1);
Cvar_SetValueQuick(&csqc_progsize, -1);
CL_VM_ShutDown();
-// stop sounds (especially looping!)
- S_StopAllSounds ();
+ // stop sounds (especially looping!)
+ S_StopAllSounds();
+ // prevent dlcache assets from this server from interfering with the next one
+ FS_UnloadPacks_dlcache();
cl.parsingtextexpectingpingforscores = 0; // just in case no reply has come yet
else if (cls.netcon)
{
sizebuf_t buf;
- unsigned char bufdata[8];
+ unsigned char bufdata[520];
if (cls.demorecording)
- CL_Stop_f(&cmd_client);
+ CL_Stop_f(cmd_local);
- // send disconnect message 3 times to improve chances of server
- // receiving it (but it still fails sometimes)
- memset(&buf, 0, sizeof(buf));
- buf.data = bufdata;
- buf.maxsize = sizeof(bufdata);
- if (cls.protocol == PROTOCOL_QUAKEWORLD)
+ if(!kicked)
{
- Con_DPrint("Sending drop command\n");
- MSG_WriteByte(&buf, qw_clc_stringcmd);
- MSG_WriteString(&buf, "drop");
- }
- else
- {
- Con_DPrint("Sending clc_disconnect\n");
- MSG_WriteByte(&buf, clc_disconnect);
+ // send disconnect message 3 times to improve chances of server
+ // receiving it (but it still fails sometimes)
+ memset(&buf, 0, sizeof(buf));
+ buf.data = bufdata;
+ buf.maxsize = sizeof(bufdata);
+ if (cls.protocol == PROTOCOL_QUAKEWORLD)
+ {
+ Con_DPrint("Sending drop command\n");
+ MSG_WriteByte(&buf, qw_clc_stringcmd);
+ MSG_WriteString(&buf, "drop");
+ }
+ else
+ {
+ Con_DPrint("Sending clc_disconnect\n");
+ MSG_WriteByte(&buf, clc_disconnect);
+ if(cls.protocol == PROTOCOL_DARKPLACES8)
+ MSG_WriteString(&buf, reason);
+ }
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
+ NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
}
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
- NetConn_SendUnreliableMessage(cls.netcon, &buf, cls.protocol, 10000, 0, false);
+
NetConn_Close(cls.netcon);
cls.netcon = NULL;
- Con_Printf("Disconnected\n");
+ if(fmt)
+ Con_Printf("Disconnect: %s\n", reason);
+ else
+ Con_Printf("Disconnected\n");
}
cls.state = ca_disconnected;
cl.islocalgame = false;
cls.demoplayback = cls.timedemo = host.restless = false;
cls.signon = 0;
+ Cvar_Callback(&cl_netport);
+
// If we're dropped mid-connection attempt, it won't clear otherwise.
SCR_ClearLoadingScreen(false);
+
+ if(host.hook.SV_Shutdown)
+ host.hook.SV_Shutdown();
+}
+
+void CL_Disconnect(void)
+{
+ CL_DisconnectEx(false, NULL);
}
/*
void CL_Disconnect_f(cmd_state_t *cmd)
{
- CL_Disconnect ();
- if (sv.active)
- SV_Shutdown ();
+ Cmd_Argc(cmd) < 1 ? CL_Disconnect() : CL_DisconnectEx(false, Cmd_Argv(cmd, 1));
}
{
int i;
*cls.connect_userinfo = 0;
- for(i = firstarg; i+2 <= Cmd_Argc(&cmd_client); i += 2)
- InfoString_SetValue(cls.connect_userinfo, sizeof(cls.connect_userinfo), Cmd_Argv(&cmd_client, i), Cmd_Argv(&cmd_client, i+1));
+ for(i = firstarg; i+2 <= Cmd_Argc(cmd_local); i += 2)
+ InfoString_SetValue(cls.connect_userinfo, sizeof(cls.connect_userinfo), Cmd_Argv(cmd_local, i), Cmd_Argv(cmd_local, i+1));
}
else if(firstarg < -1)
{
#ifdef CONFIG_MENU
M_Update_Return_Reason("Trying to connect...");
#endif
+ SCR_BeginLoadingPlaque(false);
}
else
{
CL_EstablishConnection("local:1", -2);
}
+static qbool CL_Intermission(void)
+{
+ return cl.intermission;
+}
+
/*
==============
CL_PrintEntities_f
static void CL_ModelIndexList_f(cmd_state_t *cmd)
{
int i;
- dp_model_t *model;
+ model_t *model;
// Print Header
Con_Printf("%3s: %-30s %-8s %-8s\n", "ID", "Name", "Type", "Triangles");
{
vec3_t org;
vec_t scale;
- dp_model_t *model = ent->model;
+ model_t *model = ent->model;
// update the inverse matrix for the renderer
Matrix4x4_Invert_Simple(&ent->inversematrix, &ent->matrix);
// update the animation blend state
return render;
}
-void CL_Effect(vec3_t org, dp_model_t *model, int startframe, int framecount, float framerate)
+void CL_Effect(vec3_t org, model_t *model, int startframe, int framecount, float framerate)
{
int i;
cl_effect_t *e;
}
entity_t cl_meshentities[NUM_MESHENTITIES];
-dp_model_t cl_meshentitymodels[NUM_MESHENTITIES];
+model_t cl_meshentitymodels[NUM_MESHENTITIES];
const char *cl_meshentitynames[NUM_MESHENTITIES] =
{
"MESH_SCENE",
for (i = 0; i < NUM_MESHENTITIES; i++)
{
ent = cl_meshentities + i;
+ Mod_Mesh_Destroy(ent->render.model);
Mod_Mesh_Create(ent->render.model, cl_meshentitynames[i]);
}
}
-static void CL_MeshEntities_Init(void)
+static void CL_MeshEntities_Start(void)
+{
+ int i;
+ entity_t *ent;
+ for(i = 0; i < NUM_MESHENTITIES; i++)
+ {
+ ent = cl_meshentities + i;
+ Mod_Mesh_Create(ent->render.model, cl_meshentitynames[i]);
+ }
+}
+
+static void CL_MeshEntities_Shutdown(void)
+{
+ int i;
+ entity_t *ent;
+ for(i = 0; i < NUM_MESHENTITIES; i++)
+ {
+ ent = cl_meshentities + i;
+ Mod_Mesh_Destroy(ent->render.model);
+ }
+}
+
+void CL_MeshEntities_Init(void)
{
int i;
entity_t *ent;
CL_UpdateRenderEntity(&ent->render);
}
cl_meshentities[MESH_UI].render.flags = RENDER_NOSELFSHADOW;
- R_RegisterModule("cl_meshentities", CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart);
+ R_RegisterModule("CL_MeshEntities", CL_MeshEntities_Start, CL_MeshEntities_Shutdown, CL_MeshEntities_Restart, CL_MeshEntities_Restart, CL_MeshEntities_Restart);
}
void CL_MeshEntities_Scene_Clear(void)
VectorCopy(ent->render.model->normalmaxs, ent->render.maxs);
}
-static void CL_MeshEntities_Shutdown(void)
-{
-}
-
extern cvar_t r_overheadsprites_pushback;
extern cvar_t r_fullbright_directed_pitch_relative;
extern cvar_t r_fullbright_directed_pitch;
CL_UpdateEntityShading_Entity(r_refdef.scene.entities[i]);
}
+qbool vid_opened = false;
+void CL_StartVideo(void)
+{
+ if (!vid_opened && cls.state != ca_dedicated)
+ {
+ vid_opened = true;
+#ifdef WIN32
+ // make sure we open sockets before opening video because the Windows Firewall "unblock?" dialog can screw up the graphics context on some graphics drivers
+ NetConn_UpdateSockets();
+#endif
+ VID_Start();
+ CDAudio_Startup();
+ }
+}
+
extern cvar_t host_framerate;
extern cvar_t host_speeds;
static double clframetime;
static double cl_timer = 0;
static double time1 = 0, time2 = 0, time3 = 0;
- static double wait;
int pass1, pass2, pass3;
CL_VM_PreventInformationLeaks();
SndSys_SendKeyEvents();
Sys_SendKeyEvents();
+ /*
+ * If the accumulator hasn't become positive, don't
+ * run the frame. Everything that happens before this
+ * point will happen even if we're sleeping this frame.
+ */
if((cl_timer += time) < 0)
return cl_timer;
{
clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxfps.value);
// when running slow, we need to sleep to keep input responsive
- wait = bound(0, cl_maxfps_alwayssleep.value * 1000, 100000);
- if (wait > 0)
- Sys_Sleep((int)wait);
+ if (cl_maxfps_alwayssleep.value > 0)
+ Sys_Sleep((int)bound(0, cl_maxfps_alwayssleep.value * 1000, 100000));
}
else if (!vid_activewindow && cl_maxidlefps.value >= 1 && !cls.timedemo)
clframetime = cl.realframetime = max(cl_timer, 1.0 / cl_maxidlefps.value);
Cvar_RegisterVariable (&cl_maxfps_alwayssleep);
Cvar_RegisterVariable (&cl_maxidlefps);
+ Cvar_RegisterVariable (&cl_areagrid_link_SOLID_NOT);
+ Cvar_RegisterVariable (&cl_gameplayfix_nudgeoutofsolid_separation);
+
CL_Parse_Init();
CL_Particles_Init();
CL_Screen_Init();
- CL_MeshEntities_Init();
CL_Video_Init();
+ Cvar_Callback(&cl_netport);
+
host.hook.ConnectLocal = CL_EstablishConnection_Local;
+ host.hook.Disconnect = CL_DisconnectEx;
+ host.hook.CL_Intermission = CL_Intermission;
+ host.hook.ToggleMenu = CL_ToggleMenu_Hook;
}
}