/*
==================
FileList_Add
==================
*/
void FileList_Add (const char *name, filelist_item_t **list)
{
filelist_item_t *item,*cursor,*prev;
// ignore duplicate
for (item = *list; item; item = item->next)
{
if (!Q_strcmp (name, item->name))
return;
}
item = (filelist_item_t *) Z_Malloc(sizeof(filelist_item_t));
q_strlcpy (item->name, name, sizeof(item->name));
// insert each entry in alphabetical order
if (*list == NULL ||
q_strcasecmp(item->name, (*list)->name) < 0) //insert at front
{
item->next = *list;
*list = item;
}
else //insert later
{
prev = *list;
cursor = (*list)->next;
while (cursor && (q_strcasecmp(item->name, cursor->name) > 0))
{
prev = cursor;
cursor = cursor->next;
}
item->next = prev->next;
prev->next = item;
}
}
static void Zone_Display_f(void)
{
int num_args, counter;
FILE *FH;
qboolean write_file;
write_file = false;
FH = NULL;
num_args = Cmd_Argc();
for (counter = 1; counter < num_args; counter++)
{
if (q_strcasecmp(Cmd_Argv(counter),"save") == 0)
write_file = true;
}
if (write_file)
FH = fopen(va("%s/zone.txt", fs_userdir),"w");
MEM_Printf(FH,"-------------------------\n");
MEM_Printf(FH," MAIN ZONE:\n");
MEM_Printf(FH,"-------------------------\n");
Z_Print (mainzone, FH);
MEM_Printf(FH,"-------------------------\n");
MEM_Printf(FH," SECONDARY ZONE: %s", sec_zone == NULL ? "uninitialized\n" : "\n");
MEM_Printf(FH,"-------------------------\n");
if (sec_zone != NULL)
Z_Print (sec_zone, FH);
if (FH)
{
fclose (FH);
Con_Printf ("Wrote to zone.txt\n");
}
}
/*
============
Cmd_ExecuteString
A complete command line has been parsed, so try to execute it
FIXME: lookupnoadd the token to speed search?
============
*/
void Cmd_ExecuteString (const char *text, cmd_source_t src)
{
cmd_function_t *cmd;
cmdalias_t *a;
cmd_source = src;
Cmd_TokenizeString (text);
// execute the command line
if (!Cmd_Argc())
return; // no tokens
// check functions
for (cmd = cmd_functions ; cmd ; cmd = cmd->next)
{
if ( !q_strcasecmp(cmd_argv[0], cmd->name) )
{
#if defined(H2W)
if (!cmd->function)
# ifndef SERVERONLY
Cmd_ForwardToServer ();
# else
Sys_Printf ("FIXME: command %s has NULL handler function\n", cmd->name);
# endif
else
#endif
cmd->function ();
return;
}
}
/*
==================
Host_Restart_f
Restarts the current server for a dead player
==================
*/
static void Host_Restart_f (void)
{
char mapname[MAX_QPATH];
char startspot[MAX_QPATH];
if (cls.demoplayback || !sv.active)
return;
if (cmd_source != src_command)
return;
q_strlcpy (mapname, sv.name, sizeof(mapname)); // mapname gets cleared in spawnserver
q_strlcpy (startspot, sv.startspot, sizeof(startspot));
if (Cmd_Argc() == 2 && q_strcasecmp(Cmd_Argv(1),"restore") == 0)
{
if (LoadGamestate(mapname, startspot, 3) != 0)
{
SV_SpawnServer (mapname, startspot);
if (!sv.active)
Host_Error ("%s: cannot restart map %s", __thisfunc__, mapname);
RestoreClients (0);
}
}
else
{
SV_SpawnServer (mapname, startspot);
if (!sv.active)
Host_Error ("%s: cannot restart map %s", __thisfunc__, mapname);
}
}
static void NET_Stats_f (void)
{
qsocket_t *s;
if (Cmd_Argc () == 1)
{
Con_Printf("unreliable messages sent = %i\n", unreliableMessagesSent);
Con_Printf("unreliable messages recv = %i\n", unreliableMessagesReceived);
Con_Printf("reliable messages sent = %i\n", messagesSent);
Con_Printf("reliable messages received = %i\n", messagesReceived);
Con_Printf("packetsSent = %i\n", packetsSent);
Con_Printf("packetsReSent = %i\n", packetsReSent);
Con_Printf("packetsReceived = %i\n", packetsReceived);
Con_Printf("receivedDuplicateCount = %i\n", receivedDuplicateCount);
Con_Printf("shortPacketCount = %i\n", shortPacketCount);
Con_Printf("droppedDatagrams = %i\n", droppedDatagrams);
}
else if (Q_strcmp(Cmd_Argv(1), "*") == 0)
{
for (s = net_activeSockets; s; s = s->next)
PrintStats(s);
for (s = net_freeSockets; s; s = s->next)
PrintStats(s);
}
else
{
for (s = net_activeSockets; s; s = s->next)
{
if (q_strcasecmp(Cmd_Argv(1), s->address) == 0)
break;
}
if (s == NULL)
{
for (s = net_freeSockets; s; s = s->next)
{
if (q_strcasecmp(Cmd_Argv(1), s->address) == 0)
break;
}
}
if (s == NULL)
return;
PrintStats(s);
}
}
static void MIDI_Loop_f (void)
{
if (Cmd_Argc () == 2)
{
if (q_strcasecmp(Cmd_Argv(1),"on") == 0 || q_strcasecmp(Cmd_Argv(1),"1") == 0)
MIDI_Loop(MIDI_ENABLE_LOOP);
else if (q_strcasecmp(Cmd_Argv(1),"off") == 0 || q_strcasecmp(Cmd_Argv(1),"0") == 0)
MIDI_Loop(MIDI_DISABLE_LOOP);
else if (q_strcasecmp(Cmd_Argv(1),"toggle") == 0)
MIDI_Loop(MIDI_TOGGLE_LOOP);
}
if (bLooped)
Con_Printf("MIDI music will be looped\n");
else
Con_Printf("MIDI music will not be looped\n");
}
static void BGM_Loop_f (void)
{
if (Cmd_Argc() == 2)
{
if (q_strcasecmp(Cmd_Argv(1), "0") == 0 ||
q_strcasecmp(Cmd_Argv(1),"off") == 0)
bgmloop = false;
else if (q_strcasecmp(Cmd_Argv(1), "1") == 0 ||
q_strcasecmp(Cmd_Argv(1),"on") == 0)
bgmloop = true;
else if (q_strcasecmp(Cmd_Argv(1),"toggle") == 0)
bgmloop = !bgmloop;
}
if (bgmloop)
Con_Printf("Music will be looped\n");
else
Con_Printf("Music will not be looped\n");
}
static void Memory_Display_f(void)
{
int num_args, counter;
qboolean all, write_file;
all = true;
write_file = false;
num_args = Cmd_Argc();
for (counter = 1; counter < num_args; counter++)
{
if (q_strcasecmp(Cmd_Argv(counter),"short") == 0)
all = false;
else if (q_strcasecmp(Cmd_Argv(counter),"save") == 0)
write_file = true;
}
Hunk_Print(all, write_file);
}
void BGM_Play (const char *filename)
{
char tmp[MAX_QPATH];
const char *ext;
music_handler_t *handler;
BGM_Stop();
if (music_handlers == NULL)
return;
if (!filename || !*filename)
{
Con_DPrintf("null music file name\n");
return;
}
ext = COM_FileGetExtension(filename);
if (! *ext) /* try all things */
{
BGM_Play_noext(filename, ANY_CODECTYPE);
return;
}
handler = music_handlers;
while (handler)
{
if (handler->is_available &&
!q_strcasecmp(ext, handler->ext))
break;
handler = handler->next;
}
if (!handler)
{
Con_Printf("Unhandled extension for %s\n", filename);
return;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s", handler->dir, filename);
switch (handler->player)
{
case BGM_MIDIDRV:
/* not supported in quake */
break;
case BGM_STREAMER:
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if (bgmstream)
return; /* success */
break;
case BGM_NONE:
default:
break;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
static void NET_Ban_f (void)
{
char addrStr [32];
char maskStr [32];
void (*print_fn)(const char *fmt, ...) FUNCP_PRINTF(1,2);
if (cmd_source == src_command)
{
if (!sv.active)
{
Cmd_ForwardToServer ();
return;
}
print_fn = Con_Printf;
}
else
{
if (pr_global_struct->deathmatch)
return;
print_fn = SV_ClientPrintf;
}
switch (Cmd_Argc ())
{
case 1:
if (banAddr.s_addr != INADDR_ANY)
{
Q_strcpy(addrStr, inet_ntoa(banAddr));
Q_strcpy(maskStr, inet_ntoa(banMask));
print_fn("Banning %s [%s]\n", addrStr, maskStr);
}
else
print_fn("Banning not active\n");
break;
case 2:
if (q_strcasecmp(Cmd_Argv(1), "off") == 0)
banAddr.s_addr = INADDR_ANY;
else
banAddr.s_addr = inet_addr(Cmd_Argv(1));
banMask.s_addr = INADDR_NONE;
break;
case 3:
banAddr.s_addr = inet_addr(Cmd_Argv(1));
banMask.s_addr = inet_addr(Cmd_Argv(2));
break;
default:
print_fn("BAN ip_address [mask]\n");
break;
}
}
void Modlist_Init (void)
{
DIR *dir_p, *mod_dir_p;
struct dirent *dir_t, *mod_dir_t;
char dir_string[MAX_OSPATH], mod_string[MAX_OSPATH];
q_snprintf (dir_string, sizeof(dir_string), "%s/", com_basedir);
dir_p = opendir(dir_string);
if (dir_p == NULL)
return;
while ((dir_t = readdir(dir_p)) != NULL)
{
if (!strcmp(dir_t->d_name, ".") || !strcmp(dir_t->d_name, ".."))
continue;
q_snprintf(mod_string, sizeof(mod_string), "%s%s/", dir_string, dir_t->d_name);
mod_dir_p = opendir(mod_string);
if (mod_dir_p == NULL)
continue;
// find progs.dat and pak file(s)
while ((mod_dir_t = readdir(mod_dir_p)) != NULL)
{
if (!q_strcasecmp(mod_dir_t->d_name, "progs.dat")) {
Modlist_Add(dir_t->d_name);
break;
}
if (!q_strcasecmp(COM_FileGetExtension(mod_dir_t->d_name), "pak")) {
Modlist_Add(dir_t->d_name);
break;
}
}
closedir(mod_dir_p);
}
closedir(dir_p);
}
static void Cache_Display_f(void)
{
int num_args, counter;
qboolean write_file;
write_file = false;
num_args = Cmd_Argc();
for (counter = 1; counter < num_args; counter++)
{
if (q_strcasecmp(Cmd_Argv(counter),"save") == 0)
write_file = true;
}
Cache_Print(write_file);
}
/*
===================
Key_StringToKeynum
Returns a key number to be used to index keybindings[] by looking at
the given string. Single ascii characters return themselves, while
the K_* names are matched up.
===================
*/
static int Key_StringToKeynum (const char *str)
{
keyname_t *kn;
if (!str || !str[0])
return -1;
if (!str[1])
return str[0];
for (kn = keynames; kn->name; kn++)
{
if (!q_strcasecmp(str,kn->name))
return kn->keynum;
}
return -1;
}
static void CD_f (void)
{
const char *command;
int ret;
int n;
if (Cmd_Argc() < 2)
{
Con_Printf("commands:");
Con_Printf("on, off, reset, remap, \n");
Con_Printf("play, stop, loop, pause, resume\n");
Con_Printf("eject, close, info\n");
return;
}
command = Cmd_Argv (1);
if (q_strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (q_strcasecmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
enabled = false;
return;
}
if (q_strcasecmp(command, "reset") == 0)
{
enabled = true;
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc() - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf(" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = atoi(Cmd_Argv (n+1));
return;
}
if (q_strcasecmp(command, "close") == 0)
{
CDAudio_CloseDoor();
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo();
if (!cdValid)
{
Con_Printf("No CD in player.\n");
return;
}
}
if (q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), false);
return;
}
if (q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), true);
return;
}
if (q_strcasecmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (q_strcasecmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (q_strcasecmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
if (q_strcasecmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (q_strcasecmp(command, "info") == 0)
{
Con_Printf("%u tracks\n", maxTrack);
if (playing)
Con_Printf("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
Con_Printf("Volume is %f\n", bgmvolume.value);
return;
}
}
void Host_Tell_f(void)
{
int j;
client_t *client;
client_t *save;
const char *p;
char text[MAXCMDLINE], *p2;
qboolean quoted;
if (cmd_source == src_command)
{
Cmd_ForwardToServer ();
return;
}
if (Cmd_Argc () < 3)
return;
p = Cmd_Args();
// remove quotes if present
quoted = false;
if (*p == '\"')
{
p++;
quoted = true;
}
q_snprintf (text, sizeof(text), "%s: %s", host_client->name, p);
// check length & truncate if necessary
j = (int) strlen(text);
if (j >= (int) sizeof(text) - 1)
{
text[sizeof(text) - 2] = '\n';
text[sizeof(text) - 1] = '\0';
}
else
{
p2 = text + j;
while ((const char *)p2 > (const char *)text &&
(p2[-1] == '\r' || p2[-1] == '\n' || (p2[-1] == '\"' && quoted)) )
{
if (p2[-1] == '\"' && quoted)
quoted = false;
p2[-1] = '\0';
p2--;
}
p2[0] = '\n';
p2[1] = '\0';
}
save = host_client;
for (j = 0, client = svs.clients; j < svs.maxclients; j++, client++)
{
if (!client->active || !client->spawned)
continue;
if (q_strcasecmp(client->name, Cmd_Argv(1)))
continue;
host_client = client;
SV_ClientPrintf("%s", text);
break;
}
host_client = save;
}
/*
==================
SVC_DirectConnect
A connection request that did not come from the master
==================
*/
static void SVC_DirectConnect (void)
{
char userinfo[1024];
static int userid;
netadr_t adr;
int i;
client_t *cl, *newcl;
client_t temp;
edict_t *ent;
int edictnum;
const char *s;
int clients, spectators;
qboolean spectator;
q_strlcpy (userinfo, Cmd_Argv(2), sizeof(userinfo));
// check for password or spectator_password
s = Info_ValueForKey (userinfo, "spectator");
if (s[0] && strcmp(s, "0"))
{
if (spectator_password.string[0] &&
q_strcasecmp(spectator_password.string, "none") &&
strcmp(spectator_password.string, s) )
{ // failed
Con_Printf ("%s:spectator password failed\n", NET_AdrToString (net_from));
Netchan_OutOfBandPrint (net_from, "%c\nrequires a spectator password\n\n", A2C_PRINT);
return;
}
Info_SetValueForStarKey (userinfo, "*spectator", "1", MAX_INFO_STRING);
spectator = true;
Info_RemoveKey (userinfo, "spectator"); // remove passwd
}
else
{
s = Info_ValueForKey (userinfo, "password");
if (password.string[0] &&
q_strcasecmp(password.string, "none") &&
strcmp(password.string, s) )
{
Con_Printf ("%s:password failed\n", NET_AdrToString (net_from));
Netchan_OutOfBandPrint (net_from, "%c\nserver requires a password\n\n", A2C_PRINT);
return;
}
spectator = false;
Info_RemoveKey (userinfo, "password"); // remove passwd
}
adr = net_from;
userid++; // so every client gets a unique id
newcl = &temp;
memset (newcl, 0, sizeof(client_t));
newcl->userid = userid;
newcl->portals = atoi(Cmd_Argv(1));
// works properly
if (!sv_highchars.integer)
{
byte *p, *q;
for (p = (byte *)newcl->userinfo, q = (byte *)userinfo;
*q && p < (byte *)newcl->userinfo + sizeof(newcl->userinfo)-1; q++)
{
if (*q > 31 && *q <= 127)
*p++ = *q;
}
}
else
{
q_strlcpy (newcl->userinfo, userinfo, sizeof(newcl->userinfo));
}
// if there is already a slot for this ip, drop it
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
{
if (cl->state == cs_free)
continue;
if (NET_CompareAdr (adr, cl->netchan.remote_address))
{
Con_Printf ("%s:reconnect\n", NET_AdrToString (adr));
SV_DropClient (cl);
break;
}
}
// count up the clients and spectators
clients = 0;
spectators = 0;
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
{
if (cl->state == cs_free)
continue;
if (cl->spectator)
spectators++;
else
clients++;
}
// if at server limits, refuse connection
if (maxclients.integer > MAX_CLIENTS)
Cvar_SetValue ("maxclients", MAX_CLIENTS);
if (maxspectators.integer > MAX_CLIENTS)
Cvar_SetValue ("maxspectators", MAX_CLIENTS);
if (maxspectators.integer + maxclients.integer > MAX_CLIENTS)
Cvar_SetValue ("maxspectators", MAX_CLIENTS - maxspectators.integer + maxclients.integer);
if ( (spectator && spectators >= maxspectators.integer)
|| (!spectator && clients >= maxclients.integer) )
{
Con_Printf ("%s:full connect\n", NET_AdrToString (adr));
Netchan_OutOfBandPrint (adr, "%c\nserver is full\n\n", A2C_PRINT);
return;
}
// find a client slot
newcl = NULL;
for (i = 0, cl = svs.clients; i < MAX_CLIENTS; i++, cl++)
{
if (cl->state == cs_free)
{
newcl = cl;
break;
}
}
if (!newcl)
{
Con_Printf ("WARNING: miscounted available clients\n");
return;
}
// build a new connection
// accept the new client
// this is the only place a client_t is ever initialized
*newcl = temp;
Netchan_OutOfBandPrint (adr, "%c", S2C_CONNECTION );
edictnum = (newcl-svs.clients)+1;
Netchan_Setup (&newcl->netchan, adr);
newcl->state = cs_connected;
SZ_Init (&newcl->datagram, newcl->datagram_buf, sizeof(newcl->datagram_buf));
newcl->datagram.allowoverflow = true;
// spectator mode can ONLY be set at join time
newcl->spectator = spectator;
ent = EDICT_NUM(edictnum);
newcl->edict = ent;
ED_ClearEdict (ent);
// parse some info from the info strings
SV_ExtractFromUserinfo (newcl);
// JACK: Init the floodprot stuff.
for (i = 0; i < 10; i++)
newcl->whensaid[i] = 0.0;
newcl->whensaidhead = 0;
newcl->lockedtill = 0;
// call the progs to get default spawn parms for the new client
PR_ExecuteProgram (pr_global_struct->SetNewParms);
for (i = 0; i < NUM_SPAWN_PARMS; i++)
newcl->spawn_parms[i] = (&pr_global_struct->parm1)[i];
if (newcl->spectator)
Con_Printf ("Spectator %s connected\n", newcl->name);
else
Con_DPrintf ("Client %s connected\n", newcl->name);
}
/*
=================
SV_ExtractFromUserinfo
Pull specific info from a newly changed userinfo string
into a more C freindly form.
=================
*/
void SV_ExtractFromUserinfo (client_t *cl)
{
const char *val;
char *p, *q;
int i, dupc = 1;
client_t *client;
char newname[80]; // 80 > 32 == sizeof(cl->name) because we
// will be trimming below
// name for C code
val = Info_ValueForKey (cl->userinfo, "name");
// trim user name
q_strlcpy(newname, val, sizeof(newname));
for (p = newname; *p == ' ' && *p; p++)
;
if (p != newname && *p)
{
for (q = newname; *p; *q++ = *p++)
;
*q = 0;
}
for (p = newname + strlen(newname) - 1; p != newname && *p == ' '; p--)
;
p[1] = 0;
if (strcmp(val, newname))
{
Info_SetValueForKey (cl->userinfo, "name", newname, MAX_INFO_STRING);
val = Info_ValueForKey (cl->userinfo, "name");
}
if (!val[0] || !q_strcasecmp(val, "console"))
{
Info_SetValueForKey (cl->userinfo, "name", "unnamed", MAX_INFO_STRING);
val = Info_ValueForKey (cl->userinfo, "name");
}
// check to see if another user by the same name exists
while (1)
{
for (i = 0, client = svs.clients; i < MAX_CLIENTS; i++, client++)
{
if (client->state != cs_spawned || client == cl)
continue;
if (!q_strcasecmp(client->name, val))
break;
}
if (i != MAX_CLIENTS)
{ // dup name
const char *ptr = val;
if (val[0] == '(')
{
if (val[2] == ')')
ptr = val + 3;
else if (val[3] == ')')
ptr = val + 4;
}
// limit to sizeof(cl->name) here to make it fit
q_snprintf(newname, sizeof(cl->name), "(%d)%-.40s", dupc++, ptr);
Info_SetValueForKey (cl->userinfo, "name", newname, MAX_INFO_STRING);
val = Info_ValueForKey (cl->userinfo, "name");
}
else
break;
}
q_strlcpy (cl->name, val, sizeof(cl->name));
// rate command
val = Info_ValueForKey (cl->userinfo, "rate");
if (*val)
{
i = atoi(val);
if (i < 500)
i = 500;
if (i > 10000)
i = 10000;
cl->netchan.rate = 1.0/i;
}
// playerclass command
val = Info_ValueForKey (cl->userinfo, "playerclass");
if (*val)
{
i = atoi(val);
if (i > CLASS_DEMON && dmMode.integer != DM_SIEGE)
i = CLASS_PALADIN;
if (i < 0 || i > MAX_PLAYER_CLASS || (!cl->portals && i == CLASS_DEMON))
{
i = 0;
}
cl->next_playerclass = cl->edict->v.next_playerclass = i;
if (cl->edict->v.health > 0)
{
sprintf(newname,"%d",cl->playerclass);
Info_SetValueForKey (cl->userinfo, "playerclass", newname, MAX_INFO_STRING);
}
}
// msg command
val = Info_ValueForKey (cl->userinfo, "msg");
if (*val)
{
cl->messagelevel = atoi(val);
}
}
static void Test2_f (void)
{
const char *host;
int n;
struct qsockaddr sendaddr;
if (test2InProgress)
return;
host = Strip_Port (Cmd_Argv(1));
if (host && hostCacheCount)
{
for (n = 0; n < hostCacheCount; n++)
{
if (q_strcasecmp (host, hostcache[n].name) == 0)
{
if (hostcache[n].driver != myDriverLevel)
continue;
net_landriverlevel = hostcache[n].ldriver;
Q_memcpy(&sendaddr, &hostcache[n].addr, sizeof(struct qsockaddr));
break;
}
}
if (n < hostCacheCount)
goto JustDoIt;
}
for (net_landriverlevel = 0; net_landriverlevel < net_numlandrivers; net_landriverlevel++)
{
if (!net_landrivers[net_landriverlevel].initialized)
continue;
// see if we can resolve the host name
if (dfunc.GetAddrFromName(host, &sendaddr) != -1)
break;
}
if (net_landriverlevel == net_numlandrivers)
{
Con_Printf("Could not resolve %s\n", host);
return;
}
JustDoIt:
test2Socket = dfunc.Open_Socket(0);
if (test2Socket == INVALID_SOCKET)
return;
test2InProgress = true;
test2Driver = net_landriverlevel;
SZ_Clear(&net_message);
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_RULE_INFO);
MSG_WriteString(&net_message, "");
*((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Write (test2Socket, net_message.data, net_message.cursize, &sendaddr);
SZ_Clear(&net_message);
SchedulePollProcedure(&test2PollProcedure, 0.05);
}
int CDAudio_Init(void)
{
int i, x, sdl_num_drives;
if (safemode || COM_CheckParm("-nocdaudio"))
return -1;
if (SDL_InitSubSystem(SDL_INIT_CDROM) < 0)
{
Con_Printf("Couldn't init SDL cdrom: %s\n", SDL_GetError());
return -1;
}
sdl_num_drives = SDL_CDNumDrives ();
Con_Printf ("SDL detected %d CD-ROM drive%c\n", sdl_num_drives,
sdl_num_drives == 1 ? ' ' : 's');
if (sdl_num_drives < 1)
return -1;
if ((i = COM_CheckParm("-cddev")) != 0 && i < com_argc - 1)
{
for (x = 0; x < sdl_num_drives; x++)
{
if (!q_strcasecmp(SDL_CDName(x), com_argv[i+1]))
{
cd_dev = x;
break;
}
}
if (cd_dev == -1)
{
Con_Printf("SDL couldn't find cdrom device %s\n", com_argv[i+1]);
return -1;
}
}
if (cd_dev == -1)
cd_dev = 0; // default drive
cd_handle = SDL_CDOpen(cd_dev);
if (!cd_handle)
{
Con_Printf ("%s: Unable to open CD-ROM drive %s (%s)\n",
__thisfunc__, SDL_CDName(cd_dev), SDL_GetError());
return -1;
}
for (i = 0; i < 100; i++)
remap[i] = i;
enabled = true;
old_cdvolume = bgmvolume.value;
Con_Printf("CDAudio initialized (SDL, using %s)\n", SDL_CDName(cd_dev));
if (CDAudio_GetAudioDiskInfo())
{
Con_Printf("%s: No CD in drive\n", __thisfunc__);
cdValid = false;
}
Cmd_AddCommand ("cd", CD_f);
// cd hardware volume: no SDL support at present.
hw_vol_works = CD_GetVolume (NULL);
if (hw_vol_works)
hw_vol_works = CDAudio_SetVolume (&bgmvolume);
return 0;
}
static void CD_f (void)
{
const char *command;
int ret, n;
if (Cmd_Argc() < 2)
{
Con_Printf("commands:");
Con_Printf("on, off, reset, remap, \n");
Con_Printf("play, stop, loop, pause, resume\n");
Con_Printf("eject, info\n");
return;
}
command = Cmd_Argv (1);
if (q_strcasecmp(command, "on") == 0)
{
enabled = true;
return;
}
if (q_strcasecmp(command, "off") == 0)
{
if (playing)
CDAudio_Stop();
enabled = false;
return;
}
if (q_strcasecmp(command, "reset") == 0)
{
enabled = true;
if (playing)
CDAudio_Stop();
for (n = 0; n < 100; n++)
remap[n] = n;
CDAudio_GetAudioDiskInfo();
return;
}
if (q_strcasecmp(command, "remap") == 0)
{
ret = Cmd_Argc () - 2;
if (ret <= 0)
{
for (n = 1; n < 100; n++)
if (remap[n] != n)
Con_Printf (" %u -> %u\n", n, remap[n]);
return;
}
for (n = 1; n <= ret; n++)
remap[n] = atoi(Cmd_Argv (n + 1));
return;
}
if (!cdValid)
{
CDAudio_GetAudioDiskInfo ();
if (!cdValid)
{
Con_Printf("No CD in player.\n");
return;
}
}
if (q_strcasecmp(command, "play") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), false);
return;
}
if (q_strcasecmp(command, "loop") == 0)
{
CDAudio_Play((byte)atoi(Cmd_Argv (2)), true);
return;
}
if (q_strcasecmp(command, "stop") == 0)
{
CDAudio_Stop();
return;
}
if (q_strcasecmp(command, "pause") == 0)
{
CDAudio_Pause();
return;
}
if (q_strcasecmp(command, "resume") == 0)
{
CDAudio_Resume();
return;
}
if (q_strcasecmp(command, "eject") == 0)
{
if (playing)
CDAudio_Stop();
CDAudio_Eject();
cdValid = false;
return;
}
if (q_strcasecmp(command, "info") == 0)
{
int current_min, current_sec, current_frame;
int length_min, length_sec, length_frame;
Con_Printf ("%u tracks\n", cd_handle->numtracks);
if (playing)
Con_Printf ("Currently %s track %u\n", playLooping ? "looping" : "playing", playTrack);
else if (wasPlaying)
Con_Printf ("Paused %s track %u\n", playLooping ? "looping" : "playing", playTrack);
if (playing || wasPlaying)
{
SDL_CDStatus(cd_handle);
FRAMES_TO_MSF(cd_handle->cur_frame, ¤t_min, ¤t_sec, ¤t_frame);
FRAMES_TO_MSF(cd_handle->track[playTrack-1].length, &length_min, &length_sec, &length_frame);
Con_Printf ("Current position: %d:%02d.%02d (of %d:%02d.%02d)\n",
current_min, current_sec, current_frame * 60 / CD_FPS,
length_min, length_sec, length_frame * 60 / CD_FPS);
}
Con_Printf ("Volume is %f\n", bgmvolume.value);
return;
}
}
// TODO: Factor out to a general-purpose file searching function
void DemoList_Init (void)
{
#ifdef _WIN32
WIN32_FIND_DATA fdat;
HANDLE fhnd;
#else
DIR *dir_p;
struct dirent *dir_t;
#endif
char filestring[MAX_OSPATH];
char demname[32];
char ignorepakdir[32];
searchpath_t *search;
pack_t *pak;
int i;
// we don't want to list the demos in id1 pakfiles,
// because these are not "add-on" demos
q_snprintf (ignorepakdir, sizeof(ignorepakdir), "/%s/", GAMENAME);
for (search = com_searchpaths; search; search = search->next)
{
if (*search->filename) //directory
{
#ifdef _WIN32
q_snprintf (filestring, sizeof(filestring), "%s/*.dem", search->filename);
fhnd = FindFirstFile(filestring, &fdat);
if (fhnd == INVALID_HANDLE_VALUE)
continue;
do
{
COM_StripExtension(fdat.cFileName, demname, sizeof(demname));
FileList_Add (demname, &demolist);
} while (FindNextFile(fhnd, &fdat));
FindClose(fhnd);
#else
q_snprintf (filestring, sizeof(filestring), "%s/", search->filename);
dir_p = opendir(filestring);
if (dir_p == NULL)
continue;
while ((dir_t = readdir(dir_p)) != NULL)
{
if (q_strcasecmp(COM_FileGetExtension(dir_t->d_name), "dem") != 0)
continue;
COM_StripExtension(dir_t->d_name, demname, sizeof(demname));
FileList_Add (demname, &demolist);
}
closedir(dir_p);
#endif
}
else //pakfile
{
if (!strstr(search->pack->filename, ignorepakdir))
{ //don't list standard id demos
for (i = 0, pak = search->pack; i < pak->numfiles; i++)
{
if (!strcmp(COM_FileGetExtension(pak->files[i].name), "dem"))
{
COM_StripExtension(pak->files[i].name, demname, sizeof(demname));
FileList_Add (demname, &demolist);
}
}
}
}
}
}
/*
=====================
CL_ParseServerMessage
=====================
*/
void CL_ParseServerMessage (void)
{
int cmd;
int i, j, k;
int EntityCount = 0;
int EntitySize = 0;
int before;
static double lasttime;
static qboolean packet_loss = false;
entity_t *ent;
short RemovePlace, OrigPlace, NewPlace, AddedIndex;
int sc1, sc2;
byte test;
float compangles[2][3];
vec3_t deltaangles;
//
// if recording demos, copy the message out
//
if (net_message.cursize > LastServerMessageSize)
{
LastServerMessageSize = net_message.cursize;
}
if (cl_shownet.integer == 1)
{
Con_Printf ("Time: %2.2f Pck: %i ", realtime - lasttime, net_message.cursize);
lasttime = realtime;
}
else if (cl_shownet.integer == 2)
Con_Printf ("------------------\n");
cl.onground = false; // unless the server says otherwise
//
// parse the message
//
MSG_BeginReading ();
while (1)
{
if (msg_badread)
Host_Error ("%s: Bad server message", __thisfunc__);
cmd = MSG_ReadByte ();
if (cmd == -1)
{
if (cl_shownet.integer == 1)
Con_Printf ("Ent: %i (%i bytes)",EntityCount,EntitySize);
SHOWNET("END OF MESSAGE");
return; // end of message
}
// if the high bit of the command byte is set, it is a fast update
if (cmd & 128)
{
before = msg_readcount;
SHOWNET("fast update");
if (packet_loss)
CL_ParseUpdate2 (cmd&127);
else
CL_ParseUpdate (cmd&127);
EntityCount++;
EntitySize += msg_readcount - before + 1;
continue;
}
if (cmd < NUM_SVC_STRINGS) // else, it'll hit the illegible message below
{
SHOWNET(svc_strings[cmd]);
}
// other commands
switch (cmd)
{
default:
// CL_DumpPacket ();
Host_Error ("%s: Illegible server message %d", __thisfunc__, cmd);
break;
case svc_nop:
// Con_Printf ("svc_nop\n");
break;
case svc_time:
cl.mtime[1] = cl.mtime[0];
cl.mtime[0] = MSG_ReadFloat ();
break;
case svc_clientdata:
i = MSG_ReadShort ();
CL_ParseClientdata (i);
break;
case svc_version:
cl_protocol = MSG_ReadLong ();
switch (cl_protocol)
{
case PROTOCOL_RAVEN_111:
case PROTOCOL_RAVEN_112:
case PROTOCOL_UQE_113:
Con_Printf ("Server using protocol %i\n", cl_protocol);
break;
default:
Host_Error ("%s: Server is protocol %i instead of %i or %i",
__thisfunc__, cl_protocol,
PROTOCOL_RAVEN_112, PROTOCOL_UQE_113);
}
break;
case svc_disconnect:
Host_EndGame ("Server disconnected\n");
break;
case svc_print:
if (intro_playing)
MSG_ReadString ();
else
Con_Printf ("%s", MSG_ReadString ());
break;
case svc_centerprint:
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_stufftext:
stufftext_frame = host_framecount; // allow full frame update
// on stuff messages. Pa3PyX
Cbuf_AddText (MSG_ReadString ());
break;
case svc_damage:
V_ParseDamage ();
break;
case svc_serverinfo:
CL_ParseServerInfo ();
vid.recalc_refdef = true; // leave intermission full screen
break;
case svc_setangle:
for (i = 0; i < 3; i++)
cl.viewangles[i] = MSG_ReadAngle ();
break;
case svc_setangle_interpolate:
compangles[0][0] = MSG_ReadAngle();
compangles[0][1] = MSG_ReadAngle();
compangles[0][2] = MSG_ReadAngle();
for (i = 0; i < 3; i++)
{
compangles[1][i] = cl.viewangles[i];
for (j = 0; j < 2; j++)
{//standardize both old and new angles to +-180
if (compangles[j][i] >= 360)
compangles[j][i] -= 360*((int)(compangles[j][i]/360));
else if (compangles[j][i] <= 360)
compangles[j][i] += 360*(1+(int)(-compangles[j][i]/360));
if (compangles[j][i] > 180)
compangles[j][i] = -360 + compangles[j][i];
else if (compangles[j][i] < -180)
compangles[j][i] = 360 + compangles[j][i];
}
//get delta
deltaangles[i] = compangles[0][i] - compangles[1][i];
//cap delta to <=180,>=-180
if (deltaangles[i] > 180)
deltaangles[i] += -360;
else if (deltaangles[i] < -180)
deltaangles[i] += 360;
//add the delta
cl.viewangles[i]+=(deltaangles[i]/8);//8 step interpolation
//cap newangles to +-180
if (cl.viewangles[i] >= 360)
cl.viewangles[i] -= 360*((int)(cl.viewangles[i]/360));
else if (cl.viewangles[i] <= 360)
cl.viewangles[i] += 360*(1+(int)(-cl.viewangles[i]/360));
if (cl.viewangles[i] > 180)
cl.viewangles[i] += -360;
else if (cl.viewangles[i] < -180)
cl.viewangles[i] += 360;
}
break;
case svc_setview:
cl.viewentity = MSG_ReadShort ();
break;
case svc_lightstyle:
i = MSG_ReadByte ();
if (i >= MAX_LIGHTSTYLES)
Sys_Error ("svc_lightstyle > MAX_LIGHTSTYLES");
q_strlcpy (cl_lightstyle[i].map, MSG_ReadString(), MAX_STYLESTRING);
cl_lightstyle[i].length = strlen(cl_lightstyle[i].map);
break;
case svc_sound:
CL_ParseStartSoundPacket();
break;
case svc_sound_update_pos:
{//FIXME: put a field on the entity that lists the channels
//it should update when it moves- if a certain flag
//is on the ent, this update_channels field could
//be set automatically by each sound and stopSound
//called for this ent?
vec3_t pos;
int channel, ent_num;
channel = MSG_ReadShort ();
ent_num = channel >> 3;
channel &= 7;
if (ent_num > MAX_EDICTS)
Host_Error ("svc_sound_update_pos: ent = %i", ent_num);
for (i = 0; i < 3; i++)
pos[i] = MSG_ReadCoord ();
S_UpdateSoundPos (ent_num, channel, pos);
}
break;
case svc_stopsound:
i = MSG_ReadShort();
S_StopSound(i>>3, i&7);
break;
case svc_updatename:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatename > MAX_CLIENTS", __thisfunc__);
q_strlcpy (cl.scores[i].name, MSG_ReadString(), MAX_SCOREBOARDNAME);
break;
case svc_updateclass:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updateclass > MAX_CLIENTS", __thisfunc__);
cl.scores[i].playerclass = (float)MSG_ReadByte();
CL_NewTranslation(i); // update the color
break;
case svc_updatefrags:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatefrags > MAX_CLIENTS", __thisfunc__);
cl.scores[i].frags = MSG_ReadShort ();
break;
case svc_update_kingofhill:
sv_kingofhill = MSG_ReadShort() - 1;
break;
case svc_updatecolors:
Sbar_Changed();
i = MSG_ReadByte ();
if (i >= cl.maxclients)
Host_Error ("%s: svc_updatecolors > MAX_CLIENTS", __thisfunc__);
cl.scores[i].colors = MSG_ReadByte ();
CL_NewTranslation (i);
break;
case svc_particle:
R_ParseParticleEffect ();
break;
case svc_particle2:
R_ParseParticleEffect2 ();
break;
case svc_particle3:
R_ParseParticleEffect3 ();
break;
case svc_particle4:
R_ParseParticleEffect4 ();
break;
case svc_spawnbaseline:
i = MSG_ReadShort ();
// must use CL_EntityNum() to force cl.num_entities up
CL_ParseBaseline (CL_EntityNum(i));
break;
case svc_spawnstatic:
CL_ParseStatic ();
break;
case svc_raineffect:
CL_ParseRainEffect();
break;
case svc_temp_entity:
CL_ParseTEnt ();
break;
case svc_setpause:
cl.paused = MSG_ReadByte ();
if (cl.paused)
{
CDAudio_Pause ();
VID_HandlePause (true);
}
else
{
CDAudio_Resume ();
VID_HandlePause (false);
}
break;
case svc_signonnum:
i = MSG_ReadByte ();
if (i <= cls.signon)
Host_Error ("Received signon %i when at %i", i, cls.signon);
cls.signon = i;
CL_SignonReply ();
break;
case svc_killedmonster:
cl.stats[STAT_MONSTERS]++;
break;
case svc_foundsecret:
cl.stats[STAT_SECRETS]++;
break;
case svc_updatestat:
i = MSG_ReadByte ();
if (i < 0 || i >= MAX_CL_STATS)
Sys_Error ("svc_updatestat: %i is invalid", i);
cl.stats[i] = MSG_ReadLong ();
break;
case svc_spawnstaticsound:
CL_ParseStaticSound ();
break;
case svc_cdtrack:
cl.cdtrack = MSG_ReadByte ();
cl.looptrack = MSG_ReadByte ();
if (q_strcasecmp(bgmtype.string,"cd") == 0)
{
if ( (cls.demoplayback || cls.demorecording) && (cls.forcetrack != -1) )
CDAudio_Play ((byte)cls.forcetrack, true);
else
CDAudio_Play ((byte)cl.cdtrack, true);
}
else
CDAudio_Stop();
break;
case svc_midi_name:
q_strlcpy (cl.midi_name, MSG_ReadString(), sizeof(cl.midi_name));
if (q_strcasecmp(bgmtype.string,"midi") == 0)
MIDI_Play(cl.midi_name);
else
MIDI_Stop();
break;
case svc_toggle_statbar:
break;
case svc_intermission:
cl.intermission = MSG_ReadByte();
if (oem.integer && cl.intermission == 1)
cl.intermission = 9;
// skip intermissions while recording demos in single
// player games, but stop recording at ending scenes.
// skip intermissions when playing demos.
if (cls.demorecording)
{
// 5: finale for the demo version
// 6, 7, 8: eidolon end-1 to end-3
// 9: finale for the bundle version
// 10: praevus ending
if (sv.active && svs.maxclients == 1 &&
(cl.intermission < 5 || cl.intermission > 10))
{
cl.intermission = 0;
demohack = true;
Cbuf_AddText("+attack\n"); // HACK !..
break;
}
CL_Stop_f ();
}
else if (cls.demoplayback)
{
cl.intermission = 0;
break;
}
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
break;
/* case svc_finale:
cl.intermission = 2;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_cutscene:
cl.intermission = 3;
cl.completed_time = cl.time;
vid.recalc_refdef = true; // go to full screen
SCR_CenterPrint (MSG_ReadString ());
break;
case svc_sellscreen:
Cmd_ExecuteString ("help", src_command);
break;
*/
case svc_set_view_flags:
cl.viewent.drawflags |= MSG_ReadByte();
break;
case svc_clear_view_flags:
cl.viewent.drawflags &= ~MSG_ReadByte();
break;
case svc_start_effect:
CL_ParseEffect();
break;
case svc_end_effect:
CL_EndEffect();
break;
case svc_plaque:
CL_Plaque();
break;
case svc_particle_explosion:
CL_ParticleExplosion();
break;
case svc_set_view_tint:
i = MSG_ReadByte();
cl.viewent.colorshade = i;
break;
case svc_reference:
packet_loss = false;
cl.last_frame = cl.current_frame;
cl.last_sequence = cl.current_sequence;
cl.current_frame = MSG_ReadByte();
cl.current_sequence = MSG_ReadByte();
if (cl.need_build == 2)
{
// Con_Printf("CL: NB2 CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
cl.frames[0].count = cl.frames[1].count = cl.frames[2].count = 0;
cl.need_build = 1;
cl.reference_frame = cl.current_frame;
}
else if (cl.last_sequence != cl.current_sequence)
{
// Con_Printf("CL: Sequence CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
if (cl.reference_frame >= 1 && cl.reference_frame <= MAX_FRAMES)
{
RemovePlace = OrigPlace = NewPlace = AddedIndex = 0;
for (i = 0; i < cl.num_entities; i++)
{
if (RemovePlace >= cl.NumToRemove || cl.RemoveList[RemovePlace] != i)
{
if (NewPlace < cl.frames[1].count &&
cl.frames[1].states[NewPlace].index == i)
{
cl.frames[2].states[AddedIndex] = cl.frames[1].states[NewPlace];
AddedIndex++;
cl.frames[2].count++;
}
else if (OrigPlace < cl.frames[0].count &&
cl.frames[0].states[OrigPlace].index == i)
{
cl.frames[2].states[AddedIndex] = cl.frames[0].states[OrigPlace];
AddedIndex++;
cl.frames[2].count++;
}
}
else
RemovePlace++;
if (cl.frames[0].states[OrigPlace].index == i)
OrigPlace++;
if (cl.frames[1].states[NewPlace].index == i)
NewPlace++;
}
cl.frames[0] = cl.frames[2];
}
cl.frames[1].count = cl.frames[2].count = 0;
cl.need_build = 1;
cl.reference_frame = cl.current_frame;
}
else
{
// Con_Printf("CL: Normal CL(%d,%d) R(%d)\n", cl.current_sequence, cl.current_frame,cl.reference_frame);
cl.need_build = 0;
}
for (i = 1, ent = cl_entities+1; i < cl.num_entities; i++, ent++)
{
ent->baseline.flags &= ~BE_ON;
}
for (i = 0; i < cl.frames[0].count; i++)
{
ent = CL_EntityNum (cl.frames[0].states[i].index);
ent->model = cl.model_precache[cl.frames[0].states[i].modelindex];
ent->baseline.flags |= BE_ON;
}
break;
case svc_clear_edicts:
j = MSG_ReadByte();
if (cl.need_build)
{
cl.NumToRemove = j;
}
for (i = 0; i < j; i++)
{
k = MSG_ReadShort();
if (cl.need_build)
cl.RemoveList[i] = k;
ent = CL_EntityNum (k);
ent->baseline.flags &= ~BE_ON;
}
break;
case svc_update_inv:
sc1 = sc2 = 0;
test = MSG_ReadByte();
if (test & 1)
sc1 |= ((int)MSG_ReadByte());
if (test & 2)
sc1 |= ((int)MSG_ReadByte())<<8;
if (test & 4)
sc1 |= ((int)MSG_ReadByte())<<16;
if (test & 8)
sc1 |= ((int)MSG_ReadByte())<<24;
if (test & 16)
sc2 |= ((int)MSG_ReadByte());
if (test & 32)
sc2 |= ((int)MSG_ReadByte())<<8;
if (test & 64)
sc2 |= ((int)MSG_ReadByte())<<16;
if (test & 128)
sc2 |= ((int)MSG_ReadByte())<<24;
if (sc1 & SC1_HEALTH)
cl.v.health = MSG_ReadShort();
if (sc1 & SC1_LEVEL)
cl.v.level = MSG_ReadByte();
if (sc1 & SC1_INTELLIGENCE)
cl.v.intelligence = MSG_ReadByte();
if (sc1 & SC1_WISDOM)
cl.v.wisdom = MSG_ReadByte();
if (sc1 & SC1_STRENGTH)
cl.v.strength = MSG_ReadByte();
if (sc1 & SC1_DEXTERITY)
cl.v.dexterity = MSG_ReadByte();
if (sc1 & SC1_WEAPON)
cl.v.weapon = MSG_ReadByte();
if (sc1 & SC1_BLUEMANA)
cl.v.bluemana = MSG_ReadByte();
if (sc1 & SC1_GREENMANA)
cl.v.greenmana = MSG_ReadByte();
if (sc1 & SC1_EXPERIENCE)
cl.v.experience = MSG_ReadLong();
if (sc1 & SC1_CNT_TORCH)
cl.v.cnt_torch = MSG_ReadByte();
if (sc1 & SC1_CNT_H_BOOST)
cl.v.cnt_h_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_SH_BOOST)
cl.v.cnt_sh_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_MANA_BOOST)
cl.v.cnt_mana_boost = MSG_ReadByte();
if (sc1 & SC1_CNT_TELEPORT)
cl.v.cnt_teleport = MSG_ReadByte();
if (sc1 & SC1_CNT_TOME)
cl.v.cnt_tome = MSG_ReadByte();
if (sc1 & SC1_CNT_SUMMON)
cl.v.cnt_summon = MSG_ReadByte();
if (sc1 & SC1_CNT_INVISIBILITY)
cl.v.cnt_invisibility = MSG_ReadByte();
if (sc1 & SC1_CNT_GLYPH)
cl.v.cnt_glyph = MSG_ReadByte();
if (sc1 & SC1_CNT_HASTE)
cl.v.cnt_haste = MSG_ReadByte();
if (sc1 & SC1_CNT_BLAST)
cl.v.cnt_blast = MSG_ReadByte();
if (sc1 & SC1_CNT_POLYMORPH)
cl.v.cnt_polymorph = MSG_ReadByte();
if (sc1 & SC1_CNT_FLIGHT)
cl.v.cnt_flight = MSG_ReadByte();
if (sc1 & SC1_CNT_CUBEOFFORCE)
cl.v.cnt_cubeofforce = MSG_ReadByte();
if (sc1 & SC1_CNT_INVINCIBILITY)
cl.v.cnt_invincibility = MSG_ReadByte();
if (sc1 & SC1_ARTIFACT_ACTIVE)
cl.v.artifact_active = MSG_ReadFloat();
if (sc1 & SC1_ARTIFACT_LOW)
cl.v.artifact_low = MSG_ReadFloat();
if (sc1 & SC1_MOVETYPE)
cl.v.movetype = MSG_ReadByte();
if (sc1 & SC1_CAMERAMODE)
cl.v.cameramode = MSG_ReadByte();
if (sc1 & SC1_HASTED)
cl.v.hasted = MSG_ReadFloat();
if (sc1 & SC1_INVENTORY)
cl.v.inventory = MSG_ReadByte();
if (sc1 & SC1_RINGS_ACTIVE)
cl.v.rings_active = MSG_ReadFloat();
if (sc2 & SC2_RINGS_LOW)
cl.v.rings_low = MSG_ReadFloat();
if (sc2 & SC2_AMULET)
cl.v.armor_amulet = MSG_ReadByte();
if (sc2 & SC2_BRACER)
cl.v.armor_bracer = MSG_ReadByte();
if (sc2 & SC2_BREASTPLATE)
cl.v.armor_breastplate = MSG_ReadByte();
if (sc2 & SC2_HELMET)
cl.v.armor_helmet = MSG_ReadByte();
if (sc2 & SC2_FLIGHT_T)
cl.v.ring_flight = MSG_ReadByte();
if (sc2 & SC2_WATER_T)
cl.v.ring_water = MSG_ReadByte();
if (sc2 & SC2_TURNING_T)
cl.v.ring_turning = MSG_ReadByte();
if (sc2 & SC2_REGEN_T)
cl.v.ring_regeneration = MSG_ReadByte();
if (sc2 & SC2_HASTE_T)
cl.v.haste_time = MSG_ReadFloat();
if (sc2 & SC2_TOME_T)
cl.v.tome_time = MSG_ReadFloat();
if (sc2 & SC2_PUZZLE1)
q_snprintf(cl.puzzle_pieces[0], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE2)
q_snprintf(cl.puzzle_pieces[1], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE3)
q_snprintf(cl.puzzle_pieces[2], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE4)
q_snprintf(cl.puzzle_pieces[3], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE5)
q_snprintf(cl.puzzle_pieces[4], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE6)
q_snprintf(cl.puzzle_pieces[5], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE7)
q_snprintf(cl.puzzle_pieces[6], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_PUZZLE8)
q_snprintf(cl.puzzle_pieces[7], sizeof(cl.puzzle_pieces[0]), "%.9s", MSG_ReadString());
if (sc2 & SC2_MAXHEALTH)
cl.v.max_health = MSG_ReadShort();
if (sc2 & SC2_MAXMANA)
cl.v.max_mana = MSG_ReadByte();
if (sc2 & SC2_FLAGS)
cl.v.flags = MSG_ReadFloat();
// SC2_OBJ, SC2_OBJ2: mission pack objectives
// With protocol 18 (PROTOCOL_RAVEN_111), these
// bits get set somehow (?!): let's avoid them.
if (cl_protocol > PROTOCOL_RAVEN_111)
{
if (sc2 & SC2_OBJ)
cl.info_mask = MSG_ReadLong();
if (sc2 & SC2_OBJ2)
cl.info_mask2 = MSG_ReadLong();
}
if ((sc1 & SC1_STAT_BAR) || (sc2 & SC2_STAT_BAR))
Sbar_Changed();
if ((sc1 & SC1_INV) || (sc2 & SC2_INV))
SB_InvChanged();
break;
case svc_mod_name:
case svc_skybox:
MSG_ReadString();
Con_DPrintf ("Ignored server msg %d (%s)\n", cmd, svc_strings[cmd]);
break;
}
}
}
void BGM_Play (const char *filename)
{
char tmp[MAX_QPATH];
const char *ext;
music_handler_t *handler;
BGM_Stop();
if (music_handlers == NULL)
return;
if (!filename || !*filename)
{
Con_DPrintf("null music file name\n");
return;
}
ext = COM_FileGetExtension(filename);
if (! *ext) /* try all things */
{
BGM_Play_noext(filename, ANY_CODECTYPE);
return;
}
/* use the filename as is */
handler = music_handlers;
while (handler)
{
if (handler->is_available &&
!q_strcasecmp(ext, handler->ext))
break;
handler = handler->next;
}
if (!handler)
{
Con_Printf("Unhandled extension for %s\n", filename);
return;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s", handler->dir, filename);
switch (handler->player)
{
case BGM_MIDIDRV:
if (BGM_Play_mididrv(tmp) == 0)
return; /* success */
/* BGM_MIDIDRV is followed by CODECTYPE_MID streamer.
* Even if the midi driver failed, we may still have
* a chance with the streamer if it's available... */
if (! (handler->next && handler->next->is_available))
break;
handler = handler->next;
case BGM_STREAMER:
bgmstream = S_CodecOpenStreamType(tmp, handler->type);
if (bgmstream)
return; /* success */
break;
case BGM_NONE:
default:
break;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
/*
==================
SCR_ScreenShot_f -- johnfitz -- rewritten to use Image_WriteTGA
==================
*/
void SCR_ScreenShot_f (void)
{
byte *buffer;
char ext[4];
char imagename[16]; //johnfitz -- was [80]
char checkname[MAX_OSPATH];
int i, quality;
qboolean ok;
Q_strncpy (ext, "png", sizeof(ext));
if (Cmd_Argc () >= 2)
{
const char *requested_ext = Cmd_Argv (1);
if (!q_strcasecmp ("png", requested_ext)
|| !q_strcasecmp ("tga", requested_ext)
|| !q_strcasecmp ("jpg", requested_ext))
Q_strncpy (ext, requested_ext, sizeof(ext));
else
{
SCR_ScreenShot_Usage ();
return;
}
}
// read quality as the 3rd param (only used for JPG)
quality = 90;
if (Cmd_Argc () >= 3)
quality = Q_atoi (Cmd_Argv(2));
if (quality < 1 || quality > 100)
{
SCR_ScreenShot_Usage ();
return;
}
// find a file name to save it to
for (i=0; i<10000; i++)
{
q_snprintf (imagename, sizeof(imagename), "spasm%04i.%s", i, ext); // "fitz%04i.tga"
q_snprintf (checkname, sizeof(checkname), "%s/%s", com_gamedir, imagename);
if (Sys_FileTime(checkname) == -1)
break; // file doesn't exist
}
if (i == 10000)
{
Con_Printf ("SCR_ScreenShot_f: Couldn't find an unused filename\n");
return;
}
//get data
if (!(buffer = (byte *) malloc(glwidth*glheight*3)))
{
Con_Printf ("SCR_ScreenShot_f: Couldn't allocate memory\n");
return;
}
glPixelStorei (GL_PACK_ALIGNMENT, 1);/* for widths that aren't a multiple of 4 */
glReadPixels (glx, gly, glwidth, glheight, GL_RGB, GL_UNSIGNED_BYTE, buffer);
// now write the file
if (!q_strncasecmp (ext, "png", sizeof(ext)))
ok = Image_WritePNG (imagename, buffer, glwidth, glheight, 24, false);
else if (!q_strncasecmp (ext, "tga", sizeof(ext)))
ok = Image_WriteTGA (imagename, buffer, glwidth, glheight, 24, false);
else if (!q_strncasecmp (ext, "jpg", sizeof(ext)))
ok = Image_WriteJPG (imagename, buffer, glwidth, glheight, 24, quality, false);
else
ok = false;
if (ok)
Con_Printf ("Wrote %s\n", imagename);
else
Con_Printf ("SCR_ScreenShot_f: Couldn't create %s\n", imagename);
free (buffer);
}
static void Memory_Stats_f(void)
{
hunk_t *h, *next, *endlow, *starthigh, *endhigh;
int num_args, count, sum, counter;
int GroupCount[NUM_GROUPS+1], GroupSum[NUM_GROUPS+1];
FILE *FH;
qboolean write_file;
write_file = false;
num_args = Cmd_Argc();
for (counter = 1; counter < num_args; counter++)
{
if (q_strcasecmp(Cmd_Argv(counter),"save") == 0)
write_file = true;
}
memset(GroupCount,0,sizeof(GroupCount));
memset(GroupSum,0,sizeof(GroupSum));
h = (hunk_t *)hunk_base;
endlow = (hunk_t *)(hunk_base + hunk_low_used);
starthigh = (hunk_t *)(hunk_base + hunk_size - hunk_high_used);
endhigh = (hunk_t *)(hunk_base + hunk_size);
while (1)
{
if (h == endlow)
{
h = starthigh;
}
//
// if totally done, break
//
if (h == endhigh)
break;
next = (hunk_t *)((byte *)h + h->size);
for (counter = 0; counter < NUM_GROUPS; counter++)
{
if (q_strcasecmp(h->name,MemoryGroups[counter]) == 0)
{
GroupCount[counter]++;
GroupSum[counter] += h->size;
break;
}
}
if (counter >= NUM_GROUPS)
{
GroupCount[NUM_GROUPS]++;
GroupSum[NUM_GROUPS] += h->size;
}
h = next;
}
count = 0;
sum = 0;
FH = NULL;
if (write_file)
FH = fopen(va("%s/stats.txt", fs_userdir),"w");
MEM_Printf(FH,"Group Count Size\n");
MEM_Printf(FH,"--------------- ----- --------\n");
for (counter = 0; counter < NUM_GROUPS+1; counter++)
{
MEM_Printf(FH,"%-15s %-5i %i\n",MemoryGroups[counter],GroupCount[counter],GroupSum[counter]);
count += GroupCount[counter];
sum += GroupSum[counter];
}
MEM_Printf(FH,"--------------- ----- --------\n");
MEM_Printf(FH,"%-15s %-5i %i\n","Total",count,sum);
if (FH)
{
fclose(FH);
Con_Printf ("Wrote to stats.txt\n");
}
}
static void _Datagram_SearchForHosts (qboolean xmit)
{
int ret;
int n;
int i;
struct qsockaddr readaddr;
struct qsockaddr myaddr;
int control;
dfunc.GetSocketAddr (dfunc.controlSock, &myaddr);
if (xmit)
{
SZ_Clear(&net_message);
// save space for the header, filled in later
MSG_WriteLong(&net_message, 0);
MSG_WriteByte(&net_message, CCREQ_SERVER_INFO);
MSG_WriteString(&net_message, "QUAKE");
MSG_WriteByte(&net_message, NET_PROTOCOL_VERSION);
*((int *)net_message.data) = BigLong(NETFLAG_CTL | (net_message.cursize & NETFLAG_LENGTH_MASK));
dfunc.Broadcast(dfunc.controlSock, net_message.data, net_message.cursize);
SZ_Clear(&net_message);
}
while ((ret = dfunc.Read (dfunc.controlSock, net_message.data, net_message.maxsize, &readaddr)) > 0)
{
if (ret < (int) sizeof(int))
continue;
net_message.cursize = ret;
// don't answer our own query
if (dfunc.AddrCompare(&readaddr, &myaddr) >= 0)
continue;
// is the cache full?
if (hostCacheCount == HOSTCACHESIZE)
continue;
MSG_BeginReading ();
control = BigLong(*((int *)net_message.data));
MSG_ReadLong();
if (control == -1)
continue;
if ((control & (~NETFLAG_LENGTH_MASK)) != (int)NETFLAG_CTL)
continue;
if ((control & NETFLAG_LENGTH_MASK) != ret)
continue;
if (MSG_ReadByte() != CCREP_SERVER_INFO)
continue;
dfunc.GetAddrFromName(MSG_ReadString(), &readaddr);
// search the cache for this server
for (n = 0; n < hostCacheCount; n++)
{
if (dfunc.AddrCompare(&readaddr, &hostcache[n].addr) == 0)
break;
}
// is it already there?
if (n < hostCacheCount)
continue;
// add it
hostCacheCount++;
Q_strcpy(hostcache[n].name, MSG_ReadString());
Q_strcpy(hostcache[n].map, MSG_ReadString());
hostcache[n].users = MSG_ReadByte();
hostcache[n].maxusers = MSG_ReadByte();
if (MSG_ReadByte() != NET_PROTOCOL_VERSION)
{
Q_strcpy(hostcache[n].cname, hostcache[n].name);
hostcache[n].cname[14] = 0;
Q_strcpy(hostcache[n].name, "*");
Q_strcat(hostcache[n].name, hostcache[n].cname);
}
Q_memcpy(&hostcache[n].addr, &readaddr, sizeof(struct qsockaddr));
hostcache[n].driver = net_driverlevel;
hostcache[n].ldriver = net_landriverlevel;
Q_strcpy(hostcache[n].cname, dfunc.AddrToString(&readaddr));
// check for a name conflict
for (i = 0; i < hostCacheCount; i++)
{
if (i == n)
continue;
if (q_strcasecmp (hostcache[n].name, hostcache[i].name) == 0)
{
i = Q_strlen(hostcache[n].name);
if (i < 15 && hostcache[n].name[i-1] > '8')
{
hostcache[n].name[i] = '0';
hostcache[n].name[i+1] = 0;
}
else
hostcache[n].name[i-1]++;
i = -1;
}
}
}
}
int COM_StrCompare (const void *arg1, const void *arg2)
{
return q_strcasecmp ( *(char **) arg1, *(char **) arg2);
}
