cvar_t sv_gameplayfix_stepwhilejumping = {0, "sv_gameplayfix_stepwhilejumping", "1"};
cvar_t sv_gameplayfix_swiminbmodels = {0, "sv_gameplayfix_swiminbmodels", "1"};
cvar_t sv_gameplayfix_setmodelrealbox = {0, "sv_gameplayfix_setmodelrealbox", "1"};
+cvar_t sv_gameplayfix_blowupfallenzombies = {0, "sv_gameplayfix_blowupfallenzombies", "1"};
+cvar_t sv_gameplayfix_findradiusdistancetobox = {0, "sv_gameplayfix_findradiusdistancetobox", "1"};
+
+cvar_t sv_progs = {0, "sv_progs", "progs.dat" };
server_t sv;
server_static_t svs;
-mempool_t *sv_edicts_mempool = NULL;
+mempool_t *sv_mempool = NULL;
//============================================================================
Cvar_RegisterVariable (&sv_gameplayfix_stepwhilejumping);
Cvar_RegisterVariable (&sv_gameplayfix_swiminbmodels);
Cvar_RegisterVariable (&sv_gameplayfix_setmodelrealbox);
+ Cvar_RegisterVariable (&sv_gameplayfix_blowupfallenzombies);
+ Cvar_RegisterVariable (&sv_gameplayfix_findradiusdistancetobox);
Cvar_RegisterVariable (&sv_protocolname);
Cvar_RegisterVariable (&sv_ratelimitlocalplayer);
Cvar_RegisterVariable (&sv_maxrate);
+ Cvar_RegisterVariable (&sv_progs);
SV_Phys_Init();
SV_World_Init();
- sv_edicts_mempool = Mem_AllocPool("server edicts", 0, NULL);
+ sv_mempool = Mem_AllocPool("server", 0, NULL);
}
static void SV_SaveEntFile_f(void)
EntityFrame5_FreeDatabase(client->entitydatabase5);
if (sv.protocol == PROTOCOL_DARKPLACES1 || sv.protocol == PROTOCOL_DARKPLACES2 || sv.protocol == PROTOCOL_DARKPLACES3)
- client->entitydatabase = EntityFrame_AllocDatabase(sv_clients_mempool);
+ client->entitydatabase = EntityFrame_AllocDatabase(sv_mempool);
if (sv.protocol == PROTOCOL_DARKPLACES4)
- client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_clients_mempool);
+ client->entitydatabase4 = EntityFrame4_AllocDatabase(sv_mempool);
if (sv.protocol == PROTOCOL_DARKPLACES5 || sv.protocol == PROTOCOL_DARKPLACES6)
- client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_clients_mempool);
+ client->entitydatabase5 = EntityFrame5_AllocDatabase(sv_mempool);
MSG_WriteByte (&client->message, svc_print);
- snprintf (message, sizeof (message), "\002\nServer: %s build %s (progs %i crc)", gamename, buildstring, pr_crc);
+ dpsnprintf (message, sizeof (message), "\002\nServer: %s build %s (progs %i crc)", gamename, buildstring, pr_crc);
MSG_WriteString (&client->message,message);
MSG_WriteByte (&client->message, svc_serverinfo);
int e, i;
float f;
edict_t *ent;
+ eval_t *val;
entity_state_t cs;
// send all entities that touch the pvs
numsendentities = 0;
VectorCopy(ent->v->origin, cs.origin);
VectorCopy(ent->v->angles, cs.angles);
cs.flags = 0;
- cs.effects = (int)ent->v->effects;
- cs.colormap = (qbyte)ent->v->colormap;
- cs.skin = (qbyte)ent->v->skin;
- cs.frame = (qbyte)ent->v->frame;
+ cs.effects = (unsigned)ent->v->effects;
+ cs.colormap = (unsigned)ent->v->colormap;
+ cs.skin = (unsigned)ent->v->skin;
+ cs.frame = (unsigned)ent->v->frame;
cs.viewmodelforclient = GETEDICTFIELDVALUE(ent, eval_viewmodelforclient)->edict;
cs.exteriormodelforclient = GETEDICTFIELDVALUE(ent, eval_exteriormodeltoclient)->edict;
cs.nodrawtoclient = GETEDICTFIELDVALUE(ent, eval_nodrawtoclient)->edict;
if (GETEDICTFIELDVALUE(ent, eval_glow_trail)->_float)
cs.flags |= RENDER_GLOWTRAIL;
+ // don't need to init cs.colormod because the defaultstate did that for us
+ //cs.colormod[0] = cs.colormod[1] = cs.colormod[2] = 32;
+ val = GETEDICTFIELDVALUE(ent, eval_colormod);
+ if (val->vector[0] || val->vector[1] || val->vector[2])
+ {
+ i = val->vector[0] * 32.0f;cs.colormod[0] = bound(0, i, 255);
+ i = val->vector[1] * 32.0f;cs.colormod[1] = bound(0, i, 255);
+ i = val->vector[2] * 32.0f;cs.colormod[2] = bound(0, i, 255);
+ }
+
cs.modelindex = 0;
i = (int)ent->v->modelindex;
if (i >= 1 && i < MAX_MODELS && *PR_GetString(ent->v->model))
sententities[s->number] = sententitiesmark;
}
-entity_state_t sendstates[MAX_EDICTS];
+entity_state_t sendstates[MAX_EDICTS];
void SV_WriteEntitiesToClient(client_t *client, edict_t *clent, sizebuf_t *msg, int *stats)
{
}
// NEXUIZ_PLAYERMODEL
- model = PR_GetString(host_client->edict->v->playermodel);
- if (model == NULL)
- model = "";
- // always point the string back at host_client->name to keep it safe
- strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
- host_client->edict->v->playermodel = PR_SetString(host_client->playermodel);
+ if( eval_playermodel ) {
+ model = PR_GetString(GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string);
+ if (model == NULL)
+ model = "";
+ // always point the string back at host_client->name to keep it safe
+ strlcpy (host_client->playermodel, model, sizeof (host_client->playermodel));
+ GETEDICTFIELDVALUE(host_client->edict, eval_playermodel)->string = PR_SetString(host_client->playermodel);
+ }
// NEXUIZ_PLAYERSKIN
- skin = PR_GetString(host_client->edict->v->playerskin);
- if (skin == NULL)
- skin = "";
- // always point the string back at host_client->name to keep it safe
- strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
- host_client->edict->v->playerskin = PR_SetString(host_client->playerskin);
+ if( eval_playerskin ) {
+ skin = PR_GetString(GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string);
+ if (skin == NULL)
+ skin = "";
+ // always point the string back at host_client->name to keep it safe
+ strlcpy (host_client->playerskin, skin, sizeof (host_client->playerskin));
+ GETEDICTFIELDVALUE(host_client->edict, eval_playerskin)->string = PR_SetString(host_client->playerskin);
+ }
// frags
host_client->frags = (int)host_client->edict->v->frags;
Con_Printf("SV_ModelIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
strlcpy(sv.model_precache[i], filename, sizeof(sv.model_precache[i]));
sv.models[i] = Mod_ForName (sv.model_precache[i], true, false, false);
- if (sv.protocol == PROTOCOL_DARKPLACES6)
+ if (sv.protocol == PROTOCOL_DARKPLACES6 && sv.state != ss_loading)
{
MSG_WriteByte(&sv.reliable_datagram, svc_precache);
- MSG_WriteShort(&sv.reliable_datagram, i + 32768);
+ MSG_WriteShort(&sv.reliable_datagram, i);
MSG_WriteString(&sv.reliable_datagram, filename);
}
return i;
if (precachemode == 1)
Con_Printf("SV_SoundIndex(\"%s\"): not precached (fix your code), precaching anyway\n", filename);
strlcpy(sv.sound_precache[i], filename, sizeof(sv.sound_precache[i]));
- if (sv.protocol == PROTOCOL_DARKPLACES6)
+ if (sv.protocol == PROTOCOL_DARKPLACES6 && sv.state != ss_loading)
{
MSG_WriteByte(&sv.reliable_datagram, svc_precache);
MSG_WriteShort(&sv.reliable_datagram, i + 32768);
SV_ClearWorld();
sv.max_edicts = min(sv.max_edicts + 256, MAX_EDICTS);
- sv.edictsengineprivate = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * sizeof(edict_engineprivate_t));
- sv.edictsfields = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * pr_edict_size);
- sv.moved_edicts = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * sizeof(edict_t *));
+ sv.edictsengineprivate = PR_Alloc(sv.max_edicts * sizeof(edict_engineprivate_t));
+ sv.edictsfields = PR_Alloc(sv.max_edicts * pr_edict_size);
+ sv.moved_edicts = PR_Alloc(sv.max_edicts * sizeof(edict_t *));
memcpy(sv.edictsengineprivate, oldedictsengineprivate, oldmax_edicts * sizeof(edict_engineprivate_t));
memcpy(sv.edictsfields, oldedictsfields, oldmax_edicts * pr_edict_size);
SV_LinkEdict(ent, false);
}
- Mem_Free(oldedictsengineprivate);
- Mem_Free(oldedictsfields);
- Mem_Free(oldmoved_edicts);
+ PR_Free(oldedictsengineprivate);
+ PR_Free(oldedictsfields);
+ PR_Free(oldmoved_edicts);
}
/*
Con_DPrintf("SpawnServer: %s\n", server);
- snprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
+ if (cls.state != ca_dedicated)
+ SCR_BeginLoadingPlaque();
+
+ dpsnprintf (modelname, sizeof(modelname), "maps/%s.bsp", server);
worldmodel = Mod_ForName(modelname, false, true, true);
if (!worldmodel || !worldmodel->TraceBox)
{
//
if (coop.integer)
Cvar_SetValue ("deathmatch", 0);
- current_skill = bound(0, (int)(skill.value + 0.5), 3);
-
- Cvar_SetValue ("skill", (float)current_skill);
+ // LordHavoc: it can be useful to have skills outside the range 0-3...
+ //current_skill = bound(0, (int)(skill.value + 0.5), 3);
+ //Cvar_SetValue ("skill", (float)current_skill);
+ current_skill = (int)(skill.value + 0.5);
//
// set up the new server
}
// load progs to get entity field count
- PR_LoadProgs ();
+ PR_LoadProgs ( sv_progs.string );
// allocate server memory
// start out with just enough room for clients and a reasonable estimate of entities
sv.max_edicts = max(svs.maxclients + 1, 512);
sv.max_edicts = min(sv.max_edicts, MAX_EDICTS);
- // clear the edict memory pool
- Mem_EmptyPool(sv_edicts_mempool);
// edict_t structures (hidden from progs)
- sv.edicts = Mem_Alloc(sv_edicts_mempool, MAX_EDICTS * sizeof(edict_t));
+ sv.edicts = PR_Alloc(MAX_EDICTS * sizeof(edict_t));
// engine private structures (hidden from progs)
- sv.edictsengineprivate = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * sizeof(edict_engineprivate_t));
+ sv.edictsengineprivate = PR_Alloc(sv.max_edicts * sizeof(edict_engineprivate_t));
// progs fields, often accessed by server
- sv.edictsfields = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * pr_edict_size);
+ sv.edictsfields = PR_Alloc(sv.max_edicts * pr_edict_size);
// used by PushMove to move back pushed entities
- sv.moved_edicts = Mem_Alloc(sv_edicts_mempool, sv.max_edicts * sizeof(edict_t *));
+ sv.moved_edicts = PR_Alloc(sv.max_edicts * sizeof(edict_t *));
for (i = 0;i < sv.max_edicts;i++)
{
ent = sv.edicts + i;
strlcpy(sv.model_precache[1], sv.modelname, sizeof(sv.model_precache[1]));
for (i = 1;i < sv.worldmodel->brush.numsubmodels;i++)
{
- snprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
+ dpsnprintf(sv.model_precache[i+1], sizeof(sv.model_precache[i+1]), "*%i", i);
sv.models[i+1] = Mod_ForName (sv.model_precache[i+1], false, false, false);
}