/*
==================
SCR_ScreenShot_f -- johnfitz -- rewritten to use Image_WriteTGA
==================
*/
void SCR_ScreenShot_f (void)
{
byte *buffer;
char tganame[16]; //johnfitz -- was [80]
char checkname[MAX_OSPATH];
int i;
// find a file name to save it to
for (i=0; i<10000; i++)
{
q_snprintf (tganame, sizeof(tganame), "spasm%04i.tga", i); // "fitz%04i.tga"
q_snprintf (checkname, sizeof(checkname), "%s/%s", com_gamedir, tganame);
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
buffer = (byte *) malloc(glwidth*glheight*3);
glReadPixels (glx, gly, glwidth, glheight, GL_RGB, GL_UNSIGNED_BYTE, buffer);
// now write the file
if (Image_WriteTGA (tganame, buffer, glwidth, glheight, 24, false))
Con_Printf ("Wrote %s\n", tganame);
else
Con_Printf ("SCR_ScreenShot_f: Couldn't create a TGA file\n");
free (buffer);
}
static const char *PR_GlobalString (gofs_t ofs)
{
static char line[128];
const char *s;
def_t *def;
int i;
def = pr_global_defs[ofs];
if (!def)
return PR_GlobalStringNoContents(ofs);
if (def->initialized && def->type->type != ev_function)
{
s = PR_ValueString (def->type->type, &pr_globals[ofs]);
q_snprintf (line, sizeof(line), "%i(%s)", ofs, s);
}
else
q_snprintf (line, sizeof(line), "%i(%s)", ofs, def->name);
i = strlen(line);
for ( ; i < 16; i++)
strcat (line, " ");
strcat (line, " ");
return line;
}
void Modlist_Init (void)
{
WIN32_FIND_DATA fdat, mod_fdat;
HANDLE fhnd, mod_fhnd;
char dir_string[MAX_OSPATH], mod_string[MAX_OSPATH];
q_snprintf (dir_string, sizeof(dir_string), "%s/*", com_basedir);
fhnd = FindFirstFile(dir_string, &fdat);
if (fhnd == INVALID_HANDLE_VALUE)
return;
do
{
if (!strcmp(fdat.cFileName, "."))
continue;
q_snprintf (mod_string, sizeof(mod_string), "%s/%s/progs.dat", com_basedir, fdat.cFileName);
mod_fhnd = FindFirstFile(mod_string, &mod_fdat);
if (mod_fhnd != INVALID_HANDLE_VALUE) {
FindClose(mod_fhnd);
Modlist_Add(fdat.cFileName);
}
else {
q_snprintf (mod_string, sizeof(mod_string), "%s/%s/*.pak", com_basedir, fdat.cFileName);
mod_fhnd = FindFirstFile(mod_string, &mod_fdat);
if (mod_fhnd != INVALID_HANDLE_VALUE) {
FindClose(mod_fhnd);
Modlist_Add(fdat.cFileName);
}
}
} while (FindNextFile(fhnd, &fdat));
FindClose(fhnd);
}
void R_LoadSkys (void)
{
int i, mark;
FILE *f;
char name[64], texname[20];
for (i = 0; i < 6; i++)
{
q_snprintf (name, sizeof(name), "gfx/env/bkgtst%s.tga", suf[i]);
FS_OpenFile (name, &f, false);
if (!f)
{
Con_Printf ("Couldn't load %s\n", name);
continue;
}
mark = Hunk_LowMark();
LoadTGA (f);
// LoadPCX (f);
q_snprintf (texname, sizeof(texname), "skybox%i", i);
sky_tex[i] = GL_LoadTexture(texname, 256, 256, targa_rgba, false, false, 0, true);
Hunk_FreeToLowMark(mark);
glTexParameterf_fp(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_filter_max);
glTexParameterf_fp(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_filter_max);
}
}
void BGM_PlayCDtrack (byte track, qboolean looping)
{
/* instead of searching by the order of music_handlers, do so by
* the order of searchpath priority: the file from the searchpath
* with the highest path_id is most likely from our own gamedir
* itself. This way, if a mod has track02 as a *.mp3 file, which
* is below *.ogg in the music_handler order, the mp3 will still
* have priority over track02.ogg from, say, data1.
*/
char tmp[MAX_QPATH];
const char *ext;
unsigned int path_id, prev_id, type;
music_handler_t *handler;
BGM_Stop();
if (CDAudio_Play(track, looping) == 0)
return; /* success */
if (music_handlers == NULL)
return;
if (no_extmusic || !bgm_extmusic.value)
return;
prev_id = 0;
type = 0;
ext = NULL;
handler = music_handlers;
while (handler)
{
if (! handler->is_available)
goto _next;
if (! CDRIPTYPE(handler->type))
goto _next;
q_snprintf(tmp, sizeof(tmp), "%s/track%02d.%s",
MUSIC_DIRNAME, (int)track, handler->ext);
if (! FS_FileExists(tmp, &path_id))
goto _next;
if (path_id > prev_id)
{
prev_id = path_id;
type = handler->type;
ext = handler->ext;
}
_next:
handler = handler->next;
}
if (ext == NULL)
Con_Printf("Couldn't find a cdrip for track %d\n", (int)track);
else
{
q_snprintf(tmp, sizeof(tmp), "%s/track%02d.%s",
MUSIC_DIRNAME, (int)track, ext);
bgmstream = S_CodecOpenStreamType(tmp, type);
if (! bgmstream)
Con_Printf("Couldn't handle music file %s\n", tmp);
}
}
void IN_StartupJoystick (void)
{
int i;
int nummappings;
char controllerdb[MAX_OSPATH];
SDL_GameController *gamecontroller;
if (COM_CheckParm("-nojoy"))
return;
if (SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER) == -1 )
{
Con_Warning("could not initialize SDL Game Controller\n");
return;
}
// Load additional SDL2 controller definitions from gamecontrollerdb.txt
q_snprintf (controllerdb, sizeof(controllerdb), "%s/gamecontrollerdb.txt", com_basedir);
nummappings = SDL_GameControllerAddMappingsFromFile(controllerdb);
if (nummappings > 0)
Con_Printf("%d mappings loaded from gamecontrollerdb.txt\n", nummappings);
// Also try host_parms->userdir
if (host_parms->userdir != host_parms->basedir)
{
q_snprintf (controllerdb, sizeof(controllerdb), "%s/gamecontrollerdb.txt", host_parms->userdir);
nummappings = SDL_GameControllerAddMappingsFromFile(controllerdb);
if (nummappings > 0)
Con_Printf("%d mappings loaded from gamecontrollerdb.txt\n", nummappings);
}
for (i = 0; i < SDL_NumJoysticks(); i++)
{
const char *joyname = SDL_JoystickNameForIndex(i);
if ( SDL_IsGameController(i) )
{
const char *controllername = SDL_GameControllerNameForIndex(i);
gamecontroller = SDL_GameControllerOpen(i);
if (gamecontroller)
{
Con_Printf("detected controller: %s\n", controllername != NULL ? controllername : "NULL");
joy_active_instaceid = SDL_JoystickInstanceID(SDL_GameControllerGetJoystick(gamecontroller));
joy_active_controller = gamecontroller;
break;
}
else
{
Con_Warning("failed to open controller: %s\n", controllername != NULL ? controllername : "NULL");
}
}
else
{
Con_Warning("joystick missing controller mappings: %s\n", joyname != NULL ? joyname : "NULL" );
}
}
}
void ExtraMaps_Init (void)
{
DIR *dir_p;
struct dirent *dir_t;
char filestring[MAX_OSPATH];
char mapname[32];
char ignorepakdir[32];
searchpath_t *search;
pack_t *pak;
int i;
// we don't want to list the maps in id1 pakfiles,
// because these are not "add-on" levels
q_snprintf (ignorepakdir, sizeof(ignorepakdir), "/%s/", GAMENAME);
for (search = com_searchpaths; search; search = search->next)
{
if (*search->filename) //directory
{
q_snprintf (filestring, sizeof(filestring), "%s/maps/", search->filename);
dir_p = opendir(filestring);
if (dir_p == NULL)
continue;
while ((dir_t = readdir(dir_p)) != NULL)
{
if (!strstr(dir_t->d_name, ".bsp") && !strstr(dir_t->d_name, ".BSP"))
continue;
COM_StripExtension(dir_t->d_name, mapname, sizeof(mapname));
ExtraMaps_Add (mapname);
}
closedir(dir_p);
}
else //pakfile
{
if (!strstr(search->pack->filename, ignorepakdir))
{ //don't list standard id maps
for (i = 0, pak = search->pack; i < pak->numfiles; i++)
{
if (strstr(pak->files[i].name, ".bsp"))
{
if (pak->files[i].filelen > 32*1024)
{ // don't list files under 32k (ammo boxes etc)
COM_StripExtension(pak->files[i].name + 5, mapname, sizeof(mapname));
ExtraMaps_Add (mapname);
}
}
}
}
}
}
}
void Modlist_Init (void)
{
DIR *dir_p, *mod_dir_p;
struct dirent *dir_t, *mod_dir_t;
qboolean progs_found, pak_found;
char dir_string[MAX_OSPATH], mod_dir_string[MAX_OSPATH];
int i;
i = COM_CheckParm ("-basedir");
if (i && i < com_argc-1)
q_snprintf (dir_string, sizeof(dir_string), "%s/", com_argv[i+1]);
else
q_snprintf (dir_string, sizeof(dir_string), "%s/", host_parms->basedir);
dir_p = opendir(dir_string);
if (dir_p == NULL)
return;
while ((dir_t = readdir(dir_p)) != NULL)
{
if ((strcmp(dir_t->d_name, ".") == 0) || (strcmp(dir_t->d_name, "..") == 0))
continue;
q_snprintf(mod_dir_string, sizeof(mod_dir_string), "%s%s/", dir_string, dir_t->d_name);
mod_dir_p = opendir(mod_dir_string);
if (mod_dir_p == NULL)
continue;
progs_found = false;
pak_found = false;
// find progs.dat and pak file(s)
while ((mod_dir_t = readdir(mod_dir_p)) != NULL)
{
if ((strcmp(mod_dir_t->d_name, ".") == 0) || (strcmp(mod_dir_t->d_name, "..") == 0))
continue;
if (Q_strcasecmp(mod_dir_t->d_name, "progs.dat") == 0)
progs_found = true;
if (strstr(mod_dir_t->d_name, ".pak") || strstr(mod_dir_t->d_name, ".PAK"))
pak_found = true;
if (progs_found || pak_found)
break;
}
closedir(mod_dir_p);
if (!progs_found && !pak_found)
continue;
Modlist_Add(dir_t->d_name);
}
closedir(dir_p);
}
/*
============
WriteFiles
Generates files.dat, which contains all of the
data files actually used by the game, to be
processed by qfiles.exe
============
*/
static void WriteFiles (void)
{
FILE *f;
int i;
char filename[1024];
q_snprintf (filename, sizeof(filename), "%sfiles.dat", sourcedir);
f = fopen (filename, "w");
if (!f)
COM_Error ("Couldn't open %s", filename);
fprintf (f, "%i\n", numsounds);
for (i = 0; i < numsounds; i++)
fprintf (f, "%i %s\n", precache_sounds_block[i], precache_sounds[i]);
fprintf (f, "%i\n", nummodels);
for (i = 0; i < nummodels; i++)
fprintf (f, "%i %s\n", precache_models_block[i], precache_models[i]);
fprintf (f, "%i\n", numfiles);
for (i = 0; i < numfiles; i++)
fprintf (f, "%i %s\n", precache_files_block[i], precache_files[i]);
fclose (f);
}
/*
==================
Host_Changelevel_f
Goes to a new map, taking all clients along
==================
*/
static void Host_Changelevel_f (void)
{
char level[MAX_QPATH];
char _startspot[MAX_QPATH];
char *startspot;
if (Cmd_Argc() < 2)
{
Con_Printf ("changelevel <levelname> : continue game on a new level\n");
return;
}
if (!sv.active || cls.demoplayback)
{
Con_Printf ("Only the server may changelevel\n");
return;
}
q_snprintf (level, sizeof(level), "maps/%s.bsp", Cmd_Argv(1));
if (!FS_FileExists(level, NULL))
Host_Error ("%s: cannot find map %s", __thisfunc__, level);
q_strlcpy (level, Cmd_Argv(1), sizeof(level));
if (Cmd_Argc() == 2)
startspot = NULL;
else
{
q_strlcpy (_startspot, Cmd_Argv(2), sizeof(_startspot));
startspot = _startspot;
}
SV_SaveSpawnparms ();
SV_SpawnServer (level, startspot);
if (!sv.active)
Host_Error ("%s: cannot run map %s", __thisfunc__, level);
}
/*
==================
Host_Changelevel_f
Goes to a new map, taking all clients along
==================
*/
void Host_Changelevel_f (void)
{
char level[MAX_QPATH];
if (Cmd_Argc() != 2)
{
Con_Printf ("changelevel <levelname> : continue game on a new level\n");
return;
}
if (!sv.active || cls.demoplayback)
{
Con_Printf ("Only the server may changelevel\n");
return;
}
//johnfitz -- check for client having map before anything else
q_snprintf (level, sizeof(level), "maps/%s.bsp", Cmd_Argv(1));
if (!COM_FileExists(level, NULL))
Host_Error ("cannot find map %s", level);
//johnfitz
if (cls.state != ca_dedicated)
IN_Activate(); // -- S.A.
key_dest = key_game; // remove console or menu
SV_SaveSpawnparms ();
q_strlcpy (level, Cmd_Argv(1), sizeof(level));
SV_SpawnServer (level);
// also issue an error if spawn failed -- O.S.
if (!sv.active)
Host_Error ("cannot run map %s", level);
}
/*
================
VID_SetMode
================
*/
static int VID_SetMode (int width, int height, int bpp, qboolean fullscreen)
{
int temp;
Uint32 flags = DEFAULT_SDL_FLAGS;
char caption[50];
if (fullscreen)
flags |= SDL_FULLSCREEN;
// so Con_Printfs don't mess us up by forcing vid and snd updates
temp = scr_disabled_for_loading;
scr_disabled_for_loading = true;
CDAudio_Pause ();
BGM_Pause ();
//
// swap control (the "before SDL_SetVideoMode" part)
//
gl_swap_control = true;
if (SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, (vid_vsync.value) ? 1 : 0) == -1)
gl_swap_control = false;
bpp = SDL_VideoModeOK(width, height, bpp, flags);
draw_context = SDL_SetVideoMode(width, height, bpp, flags);
if (!draw_context)
Sys_Error ("Couldn't set video mode");
q_snprintf(caption, sizeof(caption), "QuakeSpasm %1.2f.%d", (float)FITZQUAKE_VERSION, QUAKESPASM_VER_PATCH);
SDL_WM_SetCaption(caption, caption);
vid.width = draw_context->w;
vid.height = draw_context->h;
vid.conwidth = vid.width & 0xFFFFFFF8;
vid.conheight = vid.conwidth * vid.height / vid.width;
vid.numpages = 2;
modestate = draw_context->flags & SDL_FULLSCREEN ? MS_FULLSCREEN : MS_WINDOWED;
CDAudio_Resume ();
BGM_Resume ();
scr_disabled_for_loading = temp;
// fix the leftover Alt from any Alt-Tab or the like that switched us away
ClearAllStates ();
Con_SafePrintf ("Video mode %dx%dx%d initialized\n",
draw_context->w,
draw_context->h,
draw_context->format->BitsPerPixel);
vid.recalc_refdef = 1;
// no pending changes
vid_changed = false;
return true;
}
/*
============
Cvar_SetValue
============
*/
void Cvar_SetValue (const char *var_name, const float value)
{
char val[32], *ptr = val;
if (value == (float)((int)value))
q_snprintf (val, sizeof(val), "%i", (int)value);
else
{
q_snprintf (val, sizeof(val), "%f", value);
// no trailing zeroes
while (*ptr)
ptr++;
while (--ptr > val && *ptr == '0' && ptr[-1] != '.')
*ptr = '\0';
}
Cvar_Set (var_name, val);
}
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);
}
/*
============
PR_GlobalString
Returns a string with a description and the contents of a global,
padded to 20 field width
============
*/
static const char *PR_GlobalStringNoContents (gofs_t ofs)
{
static char line[128];
def_t *def;
int i;
def = pr_global_defs[ofs];
if (!def)
// COM_Error ("%s: no def for %i", __thisfunc__, ofs);
q_snprintf (line, sizeof(line), "%i(?)", ofs);
else
q_snprintf (line, sizeof(line), "%i(%s)", ofs, def->name);
i = strlen(line);
for ( ; i < 16; i++)
strcat (line, " ");
strcat (line, " ");
return line;
}
const char *Q_FindFirstFile (const char *path, const char *pattern)
{
if (findhandle != INVALID_HANDLE_VALUE)
COM_Error ("FindFirst without FindClose");
q_snprintf (findstr, sizeof(findstr), "%s/%s", path, pattern);
findhandle = FindFirstFile(findstr, &finddata);
if (findhandle == INVALID_HANDLE_VALUE)
return NULL;
if (finddata.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
return Q_FindNextFile();
return finddata.cFileName;
}
const char *NET_SlistPrintServer (int idx)
{
static char string[64];
if (idx < 0 || idx >= hostCacheCount)
return "";
if (hostcache[idx].maxusers)
{
q_snprintf(string, sizeof(string), "%-15.15s %-15.15s %2u/%2u\n",
hostcache[idx].name, hostcache[idx].map,
hostcache[idx].users, hostcache[idx].maxusers);
}
else
{
q_snprintf(string, sizeof(string), "%-15.15s %-15.15s\n",
hostcache[idx].name, hostcache[idx].map);
}
return string;
}
const char *Q_FindFirstFile (const char *path, const char *pattern)
{
if (findhandle == 0)
COM_Error ("FindFirst without FindClose");
q_snprintf (findstr, sizeof(findstr), "%s/%s", path, pattern);
memset (&finddata, 0, sizeof(finddata));
findhandle = findfirst(findstr, &finddata, FA_ARCH | FA_RDONLY);
if (findhandle == 0)
return finddata.ff_name;
return NULL;
}
/*
================
Draw_PicFromWad
================
*/
qpic_t *Draw_PicFromWad (const char *name)
{
qpic_t *p;
glpic_t gl;
src_offset_t offset; //johnfitz
p = (qpic_t *) W_GetLumpName (name);
if (!p) return pic_nul; //johnfitz
// load little ones into the scrap
if (p->width < 64 && p->height < 64)
{
int x, y;
int i, j, k;
int texnum;
texnum = Scrap_AllocBlock (p->width, p->height, &x, &y);
scrap_dirty = true;
k = 0;
for (i=0 ; i<p->height ; i++)
{
for (j=0 ; j<p->width ; j++, k++)
scrap_texels[texnum][(y+i)*BLOCK_WIDTH + x + j] = p->data[k];
}
gl.gltexture = scrap_textures[texnum]; //johnfitz -- changed to an array
//johnfitz -- no longer go from 0.01 to 0.99
gl.sl = x/(float)BLOCK_WIDTH;
gl.sh = (x+p->width)/(float)BLOCK_WIDTH;
gl.tl = y/(float)BLOCK_WIDTH;
gl.th = (y+p->height)/(float)BLOCK_WIDTH;
}
else
{
char texturename[64]; //johnfitz
q_snprintf (texturename, sizeof(texturename), "%s:%s", WADFILENAME, name); //johnfitz
offset = (src_offset_t)p - (src_offset_t)wad_base + sizeof(int)*2; //johnfitz
gl.gltexture = TexMgr_LoadImage (NULL, texturename, p->width, p->height, SRC_INDEXED, p->data, WADFILENAME,
offset, TEXPREF_ALPHA | TEXPREF_PAD | TEXPREF_NOPICMIP); //johnfitz -- TexMgr
gl.sl = 0;
gl.sh = (float)p->width/(float)TexMgr_PadConditional(p->width); //johnfitz
gl.tl = 0;
gl.th = (float)p->height/(float)TexMgr_PadConditional(p->height); //johnfitz
}
memcpy (p->data, &gl, sizeof(glpic_t));
return p;
}
/*
===============
R_ReadPointFile_f
===============
*/
void R_ReadPointFile_f (void)
{
FILE *f;
vec3_t org;
int r;
int c;
particle_t *p;
char name[MAX_QPATH];
if (cls.state != ca_connected)
return; // need an active map.
q_snprintf (name, sizeof(name), "maps/%s.pts", cl.mapname);
COM_FOpenFile (name, &f, NULL);
if (!f)
{
Con_Printf ("couldn't open %s\n", name);
return;
}
Con_Printf ("Reading %s...\n", name);
c = 0;
for ( ;; )
{
r = fscanf (f,"%f %f %f\n", &org[0], &org[1], &org[2]);
if (r != 3)
break;
c++;
if (!free_particles)
{
Con_Printf ("Not enough free particles\n");
break;
}
p = free_particles;
free_particles = p->next;
p->next = active_particles;
active_particles = p;
p->die = 99999;
p->color = (-c)&15;
p->type = pt_static;
VectorCopy (vec3_origin, p->vel);
VectorCopy (org, p->org);
}
fclose (f);
Con_Printf ("%i points read\n", c);
}
void R_ReadPointFile_f (void)
{
FILE *f;
vec3_t org;
int r;
int c;
particle_t *p;
char name[MAX_QPATH];
byte color;
if (cls.state != ca_connected)
return; // need an active map.
color = (byte)Cvar_VariableValue("leak_color");
q_snprintf (name, sizeof(name), "maps/%s.pts", cl.mapname);
FS_OpenFile (name, &f, NULL);
if (!f)
{
Con_Printf ("couldn't open %s\n", name);
return;
}
Con_Printf ("Reading %s...\n", name);
c = 0;
VectorClear (org); // silence pesky compiler warnings
for ( ;; )
{
r = fscanf (f,"%f %f %f\n", &org[0], &org[1], &org[2]);
if (r != 3)
break;
c++;
p = AllocParticle();
if (!p)
{
Con_Printf ("Not enough free particles\n");
break;
}
p->die = 99999;
p->color = color; // (-c)&15;
p->type = pt_static;
VectorClear (p->vel);
VectorCopy (org, p->org);
}
fclose (f);
Con_Printf ("%i points read\n", c);
}
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);
}
/*
==================
Host_Changelevel2_f
changing levels within a unit
==================
*/
static void Host_Changelevel2_f (void)
{
char level[MAX_QPATH];
char _startspot[MAX_QPATH];
char *startspot;
if (Cmd_Argc() < 2)
{
Con_Printf ("changelevel2 <levelname> : continue game on a new level in the unit\n");
return;
}
if (!sv.active || cls.demoplayback)
{
Con_Printf ("Only the server may changelevel\n");
return;
}
q_snprintf (level, sizeof(level), "maps/%s.bsp", Cmd_Argv(1));
if (!FS_FileExists(level, NULL))
Host_Error ("%s: cannot find map %s", __thisfunc__, level);
q_strlcpy (level, Cmd_Argv(1), sizeof(level));
if (Cmd_Argc() == 2)
startspot = NULL;
else
{
q_strlcpy (_startspot, Cmd_Argv(2), sizeof(_startspot));
startspot = _startspot;
}
SV_SaveSpawnparms ();
// save the current level's state
old_svtime = sv.time;
if (SaveGamestate(false) != 0)
return;
// try to restore the new level
if (LoadGamestate(level, startspot, 0) != 0)
{
SV_SpawnServer (level, startspot);
if (!sv.active)
Host_Error ("%s: cannot run map %s", __thisfunc__, level);
RestoreClients (0);
}
}
snd_stream_t *S_CodecOpenStreamAny (const char *filename)
{
snd_codec_t *codec;
snd_stream_t *stream;
const char *ext;
ext = COM_FileGetExtension(filename);
if (! *ext) /* try all available */
{
char tmp[MAX_QPATH];
codec = codecs;
while (codec)
{
q_snprintf(tmp, sizeof(tmp), "%s.%s", filename, codec->ext);
stream = codec->codec_open(tmp);
if (stream)
{
stream->status = STREAM_PLAY;
return stream;
}
codec = codec->next;
}
return NULL;
}
else /* use the name as is */
{
codec = codecs;
while (codec)
{
if (!Q_strcasecmp(ext, codec->ext))
break;
codec = codec->next;
}
if (!codec)
{
Con_Printf("Unknown extension for %s\n", filename);
return NULL;
}
stream = codec->codec_open(filename);
if (stream)
stream->status = STREAM_PLAY;
return stream;
}
}
static void BGM_Play_noext (const char *filename, unsigned int allowed_types)
{
char tmp[MAX_QPATH];
music_handler_t *handler;
handler = music_handlers;
while (handler)
{
if (! (handler->type & allowed_types))
{
handler = handler->next;
continue;
}
if (!handler->is_available)
{
handler = handler->next;
continue;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s.%s",
handler->dir, filename, handler->ext);
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;
}
handler = handler->next;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
const char *Q_FindFirstFile (const char *path, const char *pattern)
{
ULONG cnt = 1;
APIRET rc;
if (findhandle != HDIR_CREATE)
COM_Error ("FindFirst without FindClose");
q_snprintf (findstr, sizeof(findstr), "%s/%s", path, pattern);
findbuffer.oNextEntryOffset = 0;
rc = DosFindFirst(findstr, &findhandle, FILE_NORMAL, &findbuffer,
sizeof(findbuffer), &cnt, FIL_STANDARD);
if (rc != NO_ERROR) {
findhandle = HDIR_CREATE;
findbuffer.oNextEntryOffset = 0;
return NULL;
}
if (findbuffer.attrFile & FILE_DIRECTORY)
return Q_FindNextFile();
return findbuffer.achName;
}
/*
============
PR_ValueString
Returns a string describing *data in a type specific manner
=============
*/
static const char *PR_ValueString (etype_t type, void *val)
{
static char line[256];
def_t *def;
dfunction_t *f;
switch (type)
{
case ev_string:
q_snprintf (line, sizeof(line), "%s", PR_String(strings + *(int *)val));
break;
case ev_entity:
q_snprintf (line, sizeof(line), "entity %i", *(int *)val);
break;
case ev_function:
f = functions + *(int *)val;
if (!f)
strcpy (line, "undefined function");
else
q_snprintf (line, sizeof(line), "%s()", strings + f->s_name);
break;
case ev_field:
def = PR_DefForFieldOfs ( *(int *)val );
q_snprintf (line, sizeof(line), ".%s", def->name);
break;
case ev_void:
strcpy (line, "void");
break;
case ev_float:
q_snprintf (line, sizeof(line), "%5.1f", *(float *)val);
break;
case ev_vector:
q_snprintf (line, sizeof(line), "'%5.1f %5.1f %5.1f'", ((float *)val)[0], ((float *)val)[1], ((float *)val)[2]);
break;
case ev_pointer:
strcpy (line, "pointer");
break;
default:
q_snprintf (line, sizeof(line), "bad type %i", type);
break;
}
return line;
}
const char *Q_FindNextFile (void)
{
struct stat test;
if (!finddir)
return NULL;
while ((finddata = readdir(finddir)) != NULL)
{
if (!fnmatch (findpattern, finddata->d_name, FNM_PATHNAME))
{
q_snprintf(matchpath, sizeof(matchpath), "%s/%s", findpath, finddata->d_name);
if ( (stat(matchpath, &test) == 0)
&& S_ISREG(test.st_mode))
return finddata->d_name;
}
}
return NULL;
}
static void BGM_Play_noext (const char *filename, unsigned int allowed_types)
{
char tmp[MAX_QPATH];
music_handler_t *handler;
handler = music_handlers;
while (handler)
{
if (! (handler->type & allowed_types))
{
handler = handler->next;
continue;
}
if (!handler->is_available)
{
handler = handler->next;
continue;
}
q_snprintf(tmp, sizeof(tmp), "%s/%s.%s",
handler->dir, filename, handler->ext);
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;
}
handler = handler->next;
}
Con_Printf("Couldn't handle music file %s\n", filename);
}
/*
===============
Host_Savegame_f
===============
*/
void Host_Savegame_f (void)
{
char name[MAX_OSPATH];
FILE *f;
int i;
char comment[SAVEGAME_COMMENT_LENGTH+1];
if (cmd_source != src_command)
return;
if (!sv.active)
{
Con_Printf ("Not playing a local game.\n");
return;
}
if (cl.intermission)
{
Con_Printf ("Can't save in intermission.\n");
return;
}
if (svs.maxclients != 1)
{
Con_Printf ("Can't save multiplayer games.\n");
return;
}
if (Cmd_Argc() != 2)
{
Con_Printf ("save <savename> : save a game\n");
return;
}
if (strstr(Cmd_Argv(1), ".."))
{
Con_Printf ("Relative pathnames are not allowed.\n");
return;
}
for (i=0 ; i<svs.maxclients ; i++)
{
if (svs.clients[i].active && (svs.clients[i].edict->v.health <= 0) )
{
Con_Printf ("Can't savegame with a dead player\n");
return;
}
}
q_snprintf (name, sizeof(name), "%s/%s", com_gamedir, Cmd_Argv(1));
COM_AddExtension (name, ".sav", sizeof(name));
Con_Printf ("Saving game to %s...\n", name);
f = fopen (name, "w");
if (!f)
{
Con_Printf ("ERROR: couldn't open.\n");
return;
}
fprintf (f, "%i\n", SAVEGAME_VERSION);
Host_SavegameComment (comment);
fprintf (f, "%s\n", comment);
for (i = 0; i < NUM_SPAWN_PARMS; i++)
fprintf (f, "%f\n", svs.clients->spawn_parms[i]);
fprintf (f, "%d\n", current_skill);
fprintf (f, "%s\n", sv.name);
fprintf (f, "%f\n",sv.time);
// write the light styles
for (i = 0; i < MAX_LIGHTSTYLES; i++)
{
if (sv.lightstyles[i])
fprintf (f, "%s\n", sv.lightstyles[i]);
else
fprintf (f,"m\n");
}
ED_WriteGlobals (f);
for (i = 0; i < sv.num_edicts; i++)
{
ED_Write (f, EDICT_NUM(i));
fflush (f);
}
fclose (f);
Con_Printf ("done.\n");
}
