//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
// All files are optional, but at least one file
// must be found.
// Files with a .wad extension are idlink files
// with multiple lumps.
// Other files are single lumps with the base filename
// for the lump name.
// Lump names can appear multiple times.
// The name searcher looks backwards, so a later file
// does override all earlier ones.
//
void W_InitMultipleFiles (const char** filenames)
{
int size;
if (lumpinfo == NULL)
{
// open all the files, load headers, and count lumps
numlumps = 0;
// will be realloced as lumps are added
lumpinfo = NULL;
// Do the first file (the main WAD) seperately, so only it is affected.
// Find its medikit, stimpack, and beserk lumps so they can be fixed.
if (*filenames) {
W_AddFile (*filenames);
filenames++;
lumpnum_media0 = W_CheckNumForName("MEDIA0");
lumpnum_stima0 = W_CheckNumForName("STIMA0");
lumpnum_pstra0 = W_CheckNumForName("PSTRA0");
}
// Other wads are handled like normal
for ( ; *filenames ; filenames++)
{
W_AddFile (*filenames);
}
if (!numlumps)
I_Error ("W_InitMultipleFiles: no files found");
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = (void**)DoomLib::Z_Malloc(size, PU_STATIC_SHARED, 0 );
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
} else {
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = (void**)DoomLib::Z_Malloc(size, PU_STATIC_SHARED, 0 );
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
}
}
// Merge in a file by name
boolean W_MergeFile(char *filename)
{
int old_numlumps;
old_numlumps = numlumps;
// Load PWAD
if (W_AddFile(filename) == NULL)
return false;
// IWAD is at the start, PWAD was appended to the end
iwad.lumps = lumpinfo;
iwad.numlumps = old_numlumps;
pwad.lumps = lumpinfo + old_numlumps;
pwad.numlumps = numlumps - old_numlumps;
// Setup sprite/flat lists
SetupLists();
// Generate list of sprites to be replaced by the PWAD
GenerateSpriteList();
// Perform the merge
DoMerge();
return true;
}
//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
// All files are optional, but at least one file
// must be found.
// Files with a .wad extension are idlink files
// with multiple lumps.
// Other files are single lumps with the base filename
// for the lump name.
// Lump names can appear multiple times.
// The name searcher looks backwards, so a later file
// does override all earlier ones.
//
void W_InitMultipleFiles (char** filenames)
{
int size;
// open all the files, load headers, and count lumps
numlumps = 0;
// will be realloced as lumps are added
lumpinfo = malloc(1);
for ( ; *filenames ; filenames++)
W_AddFile (*filenames);
if (!numlumps)
I_Error ("W_InitFiles: no files found");
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = malloc (size);
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
}
void W_Init(void) {
// CPhipps - start with nothing
numlumps = 0;
lumpinfo = NULL;
// CPhipps - new wadfiles array used
// open all the files, load headers, and count lumps
for (unsigned int i = 0; i < resource_files->len; i++)
W_AddFile(i);
if (!numlumps)
I_Error("W_Init: No files found");
//jff 1/23/98
// get all the sprites and flats into one marked block each
// killough 1/24/98: change interface to use M_START/M_END explicitly
// killough 4/17/98: Add namespace tags to each entry
// killough 4/4/98: add colormap markers
W_CoalesceMarkedResource("S_START", "S_END", ns_sprites);
W_CoalesceMarkedResource("F_START", "F_END", ns_flats);
W_CoalesceMarkedResource("C_START", "C_END", ns_colormaps);
W_CoalesceMarkedResource("B_START", "B_END", ns_prboom);
r_have_internal_hires = (
0 < W_CoalesceMarkedResource("HI_START", "HI_END", ns_hires)
);
// killough 1/31/98: initialize lump hash table
W_HashLumps();
/* cph 2001/07/07 - separated cache setup */
W_InitCache();
V_FreePlaypal();
}
void W_Init(void)
{
// CPhipps - start with nothing
numlumps = 0; lumpinfo = NULL;
{ // CPhipps - new wadfiles array used
// open all the files, load headers, and count lumps
int i;
for (i=0; (size_t)i<numwadfiles; i++)
W_AddFile(&wadfiles[i]);
}
if (!numlumps)
I_Error ("W_Init: No files found");
//jff 1/23/98
// get all the sprites and flats into one marked block each
// killough 1/24/98: change interface to use M_START/M_END explicitly
// killough 4/17/98: Add namespace tags to each entry
// killough 4/4/98: add colormap markers
W_CoalesceMarkedResource("S_START", "S_END", ns_sprites);
W_CoalesceMarkedResource("F_START", "F_END", ns_flats);
W_CoalesceMarkedResource("C_START", "C_END", ns_colormaps);
W_CoalesceMarkedResource("B_START", "B_END", ns_prboom);
W_CoalesceMarkedResource("HI_START", "HI_END", ns_hires);
// killough 1/31/98: initialize lump hash table
W_HashLumps();
/* cph 2001/07/07 - separated cache setup */
lprintf(LO_INFO,"W_InitCache\n");
W_InitCache();
}
//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
// All files are optional, but at least one file
// must be found.
// Files with a .wad extension are idlink files
// with multiple lumps.
// Other files are single lumps with the base filename
// for the lump name.
// Lump names can appear multiple times.
// The name searcher looks backwards, so a later file
// does override all earlier ones.
//
void W_InitMultipleFiles (char **filenames)
{
int size;
// open all the files, load headers, and count lumps
numlumps = 0;
// will be realloced as lumps are added
lumpinfo = malloc(1);
for (; *filenames; filenames++)
W_AddFile(*filenames);
if (!numlumps)
I_Error("W_InitFiles: no files found");
// merge the sprites and flats namespaces
W_MergeLumps("S_START", "S_END");
W_MergeLumps("F_START", "F_END");
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = malloc(size);
if (!lumpcache)
I_Error("Couldn't allocate lumpcache");
memset(lumpcache, 0, size);
W_InitLumpHash();
}
static boolean D_AddFile(char *filename)
{
wad_file_t *handle;
handle = W_AddFile(filename);
return (handle != NULL);
}
//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
// All files are optional, but at least one file
// must be found.
// Files with a .wad extension are idlink files
// with multiple lumps.
// Other files are single lumps with the base filename
// for the lump name.
// Lump names can appear multiple times.
// The name searcher looks backwards, so a later file
// does override all earlier ones.
//
std::vector<std::string> W_InitMultipleFiles (std::vector<std::string> &filenames)
{
size_t size, i;
// open all the files, load headers, and count lumps
// will be realloced as lumps are added
numlumps = 0;
if(lumpinfo)
{
free(lumpinfo);
lumpinfo = 0;
}
std::vector<std::string> hashes(filenames);
// open each file once, load headers, and count lumps
int j = 0;
std::vector<std::string> loaded;
for(i = 0; i < filenames.size(); i++)
{
if(std::find(loaded.begin(), loaded.end(), filenames[i].c_str()) == loaded.end())
{
hashes[j++] = W_AddFile(filenames[i].c_str());
loaded.push_back(filenames[i].c_str());
}
}
filenames = loaded;
hashes.resize(j);
if (!numlumps)
I_Error ("W_InitFiles: no files found");
// [RH] Set namespace markers to global for everything
for (i = 0; i < numlumps; i++)
lumpinfo[i].namespc = ns_global;
// [RH] Merge sprite and flat groups.
// (We don't need to bother with patches, since
// Doom doesn't use markers to identify them.)
W_MergeLumps ("S_START", "S_END", ns_sprites); // denis - fixme - security
W_MergeLumps ("F_START", "F_END", ns_flats);
W_MergeLumps ("C_START", "C_END", ns_colormaps);
// set up caching
if(lumpcache)
free(lumpcache);
size = numlumps * sizeof(*lumpcache);
lumpcache = (void **)Malloc (size);
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
return hashes;
}
static boolean D_AddFile(char *filename)
{
wad_file_t *handle;
printf(" adding %s\n", filename);
handle = W_AddFile(filename);
return handle != NULL;
}
static boolean D_AddFile(char *filename)
{
wad_file_t *handle;
I_Print(" adding ");
I_Print(filename);
I_Print("\n");
handle = W_AddFile(filename);
return handle != NULL;
}
void W_InitMultipleFiles(char **filenames)
{
char **ptr;
byte loaded[64]; // Enough?
iwadLoaded = false;
// Open all the files, load headers, and count lumps
numlumps = 0;
lumpinfo = malloc(1); // Will be realloced as lumps are added
// This'll force the loader NOT the flag new records Runtime. (?)
loadingForStartup = true;
memset(loaded, 0, sizeof(loaded));
// IWAD(s) must be loaded first. Let's see if one has been specified
// with -iwad or -file options.
for(ptr = filenames; *ptr; ptr++)
{
if(W_IsIWAD(*ptr))
{
loaded[ptr - filenames] = true;
W_AddFile(*ptr, false);
}
}
// Make sure an IWAD gets loaded; if not, display a warning.
W_CheckIWAD();
// Load the rest of the WADs.
for(ptr = filenames; *ptr; ptr++)
if(!loaded[ptr - filenames])
W_AddFile(*ptr, false);
if(!numlumps)
{
Con_Error("W_InitMultipleFiles: no files found");
}
}
void W_NWTDashMerge(char *filename)
{
wad_file_t *wad_file;
int old_numlumps;
int i;
old_numlumps = numlumps;
// Load PWAD
wad_file = W_AddFile(filename);
if (wad_file == NULL)
{
return;
}
// IWAD is at the start, PWAD was appended to the end
iwad.lumps = lumpinfo;
iwad.numlumps = old_numlumps;
pwad.lumps = lumpinfo + old_numlumps;
pwad.numlumps = numlumps - old_numlumps;
// Setup sprite/flat lists
SetupLists();
// Search through the IWAD sprites list.
for (i=0; i<iwad_sprites.numlumps; ++i)
{
if (FindInList(&pwad, iwad_sprites.lumps[i]->name) >= 0)
{
// Replace this entry with an empty string. This is what
// nwt -merge does.
M_StringCopy(iwad_sprites.lumps[i]->name, "", 8);
}
}
// Discard PWAD
// The PWAD must now be added in again with -file.
numlumps = old_numlumps;
W_CloseFile(wad_file);
}
void W_NWTMergeFile(char *filename, int flags)
{
int old_numlumps;
old_numlumps = numlumps;
// Load PWAD
if (W_AddFile(filename) == NULL)
return;
// IWAD is at the start, PWAD was appended to the end
iwad.lumps = lumpinfo;
iwad.numlumps = old_numlumps;
pwad.lumps = lumpinfo + old_numlumps;
pwad.numlumps = numlumps - old_numlumps;
// Setup sprite/flat lists
SetupLists();
// Merge in flats?
if (flags & W_NWT_MERGE_FLATS)
{
W_NWTAddLumps(&iwad_flats);
}
// Sprites?
if (flags & W_NWT_MERGE_SPRITES)
{
W_NWTAddLumps(&iwad_sprites);
}
// Discard the PWAD
numlumps = old_numlumps;
}
static void AddGameDir(const VStr& basedir, const VStr& dir)
{
guard(AddGameDir);
// First add all .pk3 files in that directory.
if (Sys_OpenDir(basedir + "/" + dir))
{
TArray<VStr> ZipFiles;
for (VStr test = Sys_ReadDir(); test.IsNotEmpty(); test = Sys_ReadDir())
{
VStr ext = test.ExtractFileExtension().ToLower();
if (ext == "pk3")
ZipFiles.Append(test);
}
Sys_CloseDir();
qsort(ZipFiles.Ptr(), ZipFiles.Num(), sizeof(VStr), cmpfunc);
for (int i = 0; i < ZipFiles.Num(); i++)
{
AddZipFile(basedir + "/" + dir + "/" + ZipFiles[i]);
}
}
// Then add wad##.wad files.
VStr gwadir;
if (fl_savedir.IsNotEmpty() && basedir != fl_savedir)
{
gwadir = fl_savedir + "/" + dir;
}
for (int i = 0; i < 1024; i++)
{
VStr buf = basedir + "/" + dir + "/wad" + i + ".wad";
if (!Sys_FileExists(buf))
break;
W_AddFile(buf, gwadir, false);
}
// Finally add directory itself.
VFilesDir* info = new VFilesDir(basedir + "/" + dir);
SearchPaths.Append(info);
unguard;
}
//
// W_InitMultipleFiles
// Pass a null terminated list of files to use.
// All files are optional, but at least one file
// must be found.
// Files with a .wad extension are idlink files
// with multiple lumps.
// Other files are single lumps with the base filename
// for the lump name.
// Lump names can appear multiple times.
// The name searcher looks backwards, so a later file
// does override all earlier ones.
//
void W_InitMultipleFiles (const char** filenames)
{
int size;
if (lumpinfo == NULL)
{
// open all the files, load headers, and count lumps
numlumps = 0;
// will be realloced as lumps are added
lumpinfo = NULL;
for ( ; *filenames ; filenames++)
{
W_AddFile (*filenames);
}
if (!numlumps)
I_Error ("W_InitMultipleFiles: no files found");
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = (void**)DoomLib::Z_Malloc(size, PU_STATIC_SHARED, 0 );
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
} else {
// set up caching
size = numlumps * sizeof(*lumpcache);
lumpcache = (void**)DoomLib::Z_Malloc(size, PU_STATIC_SHARED, 0 );
if (!lumpcache)
I_Error ("Couldn't allocate lumpcache");
memset (lumpcache,0, size);
}
}
// The Doom reload hack. The idea here is that if you give a WAD file to -file
// prefixed with the ~ hack, that WAD file will be reloaded each time a new
// level is loaded. This lets you use a level editor in parallel and make
// incremental changes to the level you're working on without having to restart
// the game after every change.
// But: the reload feature is a fragile hack...
void W_Reload(void)
{
char *filename;
lumpindex_t i;
if (reloadname == NULL)
{
return;
}
// We must free any lumps being cached from the PWAD we're about to reload:
for (i = reloadlump; i < numlumps; ++i)
{
if (lumpinfo[i]->cache != NULL)
{
Z_Free(lumpinfo[i]->cache);
}
}
// Reset numlumps to remove the reload WAD file:
numlumps = reloadlump;
// Now reload the WAD file.
filename = reloadname;
W_CloseFile(reloadhandle);
free(reloadlumps);
reloadname = NULL;
reloadlump = -1;
reloadhandle = NULL;
W_AddFile(filename);
free(filename);
// The WAD directory has changed, so we have to regenerate the
// fast lookup hashtable:
W_GenerateHashTable();
}
//===========================================================================
// W_CheckIWAD
// Checks if an IWAD has been loaded. If not, tries to load one of the
// default ones.
//===========================================================================
void W_CheckIWAD(void)
{
extern char *iwadlist[];
int i;
if(iwadLoaded)
return;
// Try one of the default IWADs.
for(i = 0; iwadlist[i]; i++)
{
if(M_FileExists(iwadlist[i]))
W_AddFile(iwadlist[i], false);
// We can leave as soon as an IWAD is found.
if(iwadLoaded)
return;
}
if(!Sys_CriticalMessage
("No IWAD has been specified! "
"Important data might be missing. Are you sure you "
"want to continue?"))
Con_Error("W_CheckIWAD: Init aborted.\n");
}
static void HandleArgs(void)
{
int p;
//!
// @vanilla
//
// Disable monsters.
//
nomonsters = M_ParmExists("-nomonsters");
//!
// @vanilla
//
// Monsters respawn after being killed.
//
respawnparm = M_ParmExists("-respawn");
//!
// @vanilla
// @category net
//
// In deathmatch mode, change a player's class each time the
// player respawns.
//
randomclass = M_ParmExists("-randclass");
//!
// @vanilla
//
// Take screenshots when F1 is pressed.
//
ravpic = M_ParmExists("-ravpic");
//!
// @vanilla
//
// Don't allow artifacts to be used when the run key is held down.
//
artiskip = M_ParmExists("-artiskip");
debugmode = M_ParmExists("-debug");
//!
// @vanilla
// @category net
//
// Start a deathmatch game.
//
deathmatch = M_ParmExists("-deathmatch");
// currently broken or unused:
cmdfrag = M_ParmExists("-cmdfrag");
// Check WAD file command line options
W_ParseCommandLine();
//!
// @vanilla
// @arg <path>
//
// Development option to specify path to level scripts.
//
p = M_CheckParmWithArgs("-scripts", 1);
if (p)
{
sc_FileScripts = true;
sc_ScriptsDir = myargv[p+1];
}
//!
// @arg <skill>
// @vanilla
//
// Set the game skill, 1-5 (1: easiest, 5: hardest). A skill of
// 0 disables all monsters.
//
p = M_CheckParmWithArgs("-skill", 1);
if (p)
{
startskill = myargv[p+1][0] - '1';
autostart = true;
}
//!
// @arg <demo>
// @category demo
// @vanilla
//
// Play back the demo named demo.lmp.
//
p = M_CheckParmWithArgs("-playdemo", 1);
if (!p)
{
//!
// @arg <demo>
// @category demo
// @vanilla
//
// Play back the demo named demo.lmp, determining the framerate
// of the screen.
//
p = M_CheckParmWithArgs("-timedemo", 1);
}
if (p)
{
char *uc_filename;
char file[256];
M_StringCopy(file, myargv[p+1], sizeof(file));
// With Vanilla Hexen you have to specify the file without
// extension, but make that optional.
uc_filename = strdup(myargv[p + 1]);
M_ForceUppercase(uc_filename);
if (!M_StringEndsWith(uc_filename, ".LMP"))
{
M_StringConcat(file, ".lmp", sizeof(file));
}
free(uc_filename);
if (W_AddFile(file) != NULL)
{
M_StringCopy(demolumpname, lumpinfo[numlumps - 1].name,
sizeof(demolumpname));
}
else
{
// The file failed to load, but copy the original arg as a
// demo name to make tricks like -playdemo demo1 possible.
M_StringCopy(demolumpname, myargv[p+1], sizeof(demolumpname));
}
ST_Message("Playing demo %s.\n", myargv[p+1]);
}
if (M_ParmExists("-testcontrols"))
{
autostart = true;
testcontrols = true;
}
}
static void ParseBase(const VStr& name)
{
guard(ParseBase);
TArray<version_t> games;
bool select_game;
VStr UseName;
if (fl_savedir.IsNotEmpty() && Sys_FileExists(fl_savedir + "/" + name))
{
UseName = fl_savedir + "/" + name;
}
else if (Sys_FileExists(fl_basedir + "/" + name))
{
UseName = fl_basedir + "/" + name;
}
else
{
return;
}
select_game = false;
VScriptParser* sc = new VScriptParser(UseName, FL_OpenSysFileRead(UseName));
while (!sc->AtEnd())
{
version_t &dst = games.Alloc();
dst.ParmFound = 0;
dst.FixVoices = false;
sc->Expect("game");
sc->ExpectString();
dst.GameDir = sc->String;
if (sc->Check("iwad"))
{
sc->ExpectString();
dst.MainWad = sc->String;
}
while (sc->Check("addfile"))
{
sc->ExpectString();
dst.AddFiles.Append(sc->String);
}
if (sc->Check("param"))
{
sc->ExpectString();
dst.ParmFound = GArgs.CheckParm(*sc->String);
if (dst.ParmFound)
{
select_game = true;
}
}
if (sc->Check("fixvoices"))
{
dst.FixVoices = true;
}
sc->Expect("end");
}
delete sc;
sc = NULL;
for (int gi = games.Num() - 1; gi >= 0; gi--)
{
version_t& G = games[gi];
if (select_game && !G.ParmFound)
{
continue;
}
if (fl_mainwad.IsNotEmpty())
{
if (G.MainWad.IsEmpty() || G.MainWad == fl_mainwad || select_game)
{
if (!bIwadAdded)
{
IWadIndex = SearchPaths.Num();
VStr MainWadPath = FindMainWad(fl_mainwad);
W_AddFile(MainWadPath, fl_savedir, G.FixVoices);
bIwadAdded = true;
}
for (int j = 0; j < G.AddFiles.Num(); j++)
{
W_AddFile(fl_basedir + "/" + G.AddFiles[j], fl_savedir,
false);
}
SetupGameDir(G.GameDir);
return;
}
continue;
}
if (G.MainWad.IsEmpty())
{
continue;
}
// Look for the main wad file.
VStr MainWadPath = FindMainWad(G.MainWad);
if (MainWadPath.IsNotEmpty())
{
fl_mainwad = G.MainWad;
if (!bIwadAdded)
{
IWadIndex = SearchPaths.Num();
W_AddFile(MainWadPath, fl_savedir, G.FixVoices);
bIwadAdded = true;
}
for (int j = 0; j < G.AddFiles.Num(); j++)
{
VStr FName = FindMainWad(G.AddFiles[j]);
if (FName.IsEmpty())
{
Sys_Error("Required file %s not found", *G.AddFiles[j]);
}
W_AddFile(FName, fl_savedir, false);
}
SetupGameDir(G.GameDir);
return;
}
}
if (select_game)
Sys_Error("Main wad file not found.");
else
Sys_Error("Game mode indeterminate.");
unguard;
}
void FL_Init()
{
guard(FL_Init);
const char* p;
// Set up base directory (main data files).
fl_basedir = ".";
p = GArgs.CheckValue("-basedir");
if (p)
{
fl_basedir = p;
}
// Set up save directory (files written by engine).
p = GArgs.CheckValue("-savedir");
if (p)
{
fl_savedir = p;
}
#if !defined(_WIN32)
else
{
const char* HomeDir = getenv("HOME");
if (HomeDir)
{
fl_savedir = VStr(HomeDir) + "/.vavoom";
}
}
#endif
// Set up additional directories where to look for IWAD files.
int iwp = GArgs.CheckParm("-iwaddir");
if (iwp)
{
while (++iwp != GArgs.Count() && GArgs[iwp][0] != '-' && GArgs[iwp][0] != '+')
{
IWadDirs.Append(GArgs[iwp]);
}
}
AddGameDir("basev/common");
p = GArgs.CheckValue("-iwad");
if (p)
{
fl_mainwad = p;
}
p = GArgs.CheckValue("-devgame");
if (p)
{
fl_devmode = true;
}
else
{
p = GArgs.CheckValue("-game");
}
if (p)
{
SetupGameDir(p);
}
else
{
ParseBase("basev/games.txt");
#ifdef DEVELOPER
// I need progs to be loaded from files
fl_devmode = true;
#endif
}
int fp = GArgs.CheckParm("-file");
if (fp)
{
while (++fp != GArgs.Count() && GArgs[fp][0] != '-' && GArgs[fp][0] != '+')
{
VStr Ext = VStr(GArgs[fp]).ExtractFileExtension().ToLower();
if (Ext == "pk3" || Ext == "zip")
AddZipFile(GArgs[fp]);
else
W_AddFile(GArgs[fp], VStr(), false);
}
}
RenameSprites();
unguard;
}
static void D_AddFile(char *filename)
{
printf(" adding %s\n", filename);
W_AddFile(filename);
}
boolean W_AddFile(const char *filename, boolean allowDuplicate)
{
char alterFileName[256];
wadinfo_t header;
DFILE *handle;
unsigned int length;
filelump_t *fileinfo, singleinfo;
filelump_t *freeFileInfo;
filerecord_t *rec;
const char *extension;
// Filename given?
if(!filename || !filename[0])
return true;
if((handle = F_Open(filename, "rb")) == NULL)
{
// Didn't find file. Try reading from the data path.
R_PrependDataPath(filename, alterFileName);
if((handle = F_Open(alterFileName, "rb")) == NULL)
{
Con_Message("W_AddFile: ERROR: %s not found!\n", filename);
return false;
}
// We'll use this instead.
filename = alterFileName;
}
// Do not read files twice.
if(!allowDuplicate && !M_CheckFileID(filename))
{
F_Close(handle); // The file is not used.
return false;
}
Con_Message("W_AddFile: %s\n", M_Pretty(filename));
// Determine the file name extension.
extension = strrchr(filename, '.');
if(!extension)
extension = "";
else
extension++; // Move to point after the dot.
// Is it a zip/pk3 package?
if(!stricmp(extension, "zip") || !stricmp(extension, "pk3"))
{
return Zip_Open(filename, handle);
}
// Get a new file record.
rec = W_RecordNew();
strcpy(rec->filename, filename);
convertSlashes(rec->filename);
rec->handle = handle;
// If we're not loading for startup, flag the record to be a Runtime one.
if(!loadingForStartup)
rec->flags = FRF_RUNTIME;
if(stricmp(extension, "wad") && stricmp(extension, "gwa"))
{
// Single lump file.
fileinfo = &singleinfo;
freeFileInfo = NULL;
singleinfo.filepos = 0;
singleinfo.size = F_Length(handle);
M_ExtractFileBase(filename, singleinfo.name);
rec->numlumps = 1;
}
else
{
// WAD file.
F_Read(&header, sizeof(header), handle);
if(!strncmp(header.identification, "JWAD", 4))
{
// This is treated like an IWAD, but we won't set the
// iwadLoaded flag.
rec->iwad = true;
}
else if(strncmp(header.identification, "IWAD", 4))
{
if(strncmp(header.identification, "PWAD", 4))
{ // Bad file id
Con_Error("Wad file %s doesn't have IWAD or PWAD id\n",
filename);
}
}
else
{
// Found an IWAD.
iwadLoaded = true;
if(!stricmp(extension, "wad"))
rec->iwad = true;
}
header.numlumps = LONG(header.numlumps);
header.infotableofs = LONG(header.infotableofs);
length = header.numlumps * sizeof(filelump_t);
if(!(fileinfo = malloc(length)))
{
Con_Error("W_AddFile: fileinfo malloc failed\n");
}
freeFileInfo = fileinfo;
F_Seek(handle, header.infotableofs, SEEK_SET);
F_Read(fileinfo, length, handle);
rec->numlumps = header.numlumps;
}
// Insert the lumps to lumpinfo, into their rightful places.
W_InsertLumps(fileinfo, rec);
if(freeFileInfo)
free(freeFileInfo);
PrimaryLumpInfo = lumpinfo;
PrimaryLumpCache = lumpcache;
PrimaryNumLumps = numlumps;
// Print the 'CRC' number of the IWAD, so it can be identified.
if(rec->iwad)
Con_Message(" IWAD identification: %08x\n",
W_CRCNumberForRecord(rec - records));
// glBSP: Also load a possible GWA.
if(!stricmp(extension, "wad"))
{
char buff[256];
strcpy(buff, filename);
strcpy(buff + strlen(buff) - 3, "gwa");
// If GL data exists, load it.
if(F_Access(buff))
{
W_AddFile(buff, allowDuplicate);
}
}
return true;
}
