make infobar height configurable
[divverent/darkplaces.git] / fs.c
diff --git a/fs.c b/fs.c
index 0dfc6ea..a0dd2c8 100644 (file)
--- a/fs.c
+++ b/fs.c
@@ -22,8 +22,6 @@
                Boston, MA  02111-1307, USA
 */
 
-#include "quakedef.h"
-
 #include <limits.h>
 #include <fcntl.h>
 
@@ -37,6 +35,8 @@
 # include <unistd.h>
 #endif
 
+#include "quakedef.h"
+
 #include "fs.h"
 #include "wad.h"
 
@@ -66,7 +66,7 @@
 # define dup _dup
 #endif
 
-/*
+/** \page fs File System
 
 All of Quake's data access is through a hierchal file system, but the contents
 of the file system can be transparently merged from several sources.
@@ -106,6 +106,19 @@ CONSTANTS
 #define ZIP_CDIR_CHUNK_BASE_SIZE       46
 #define ZIP_LOCAL_CHUNK_BASE_SIZE      30
 
+#ifdef LINK_TO_ZLIB
+#include <zlib.h>
+
+#define qz_inflate inflate
+#define qz_inflateEnd inflateEnd
+#define qz_inflateInit2_ inflateInit2_
+#define qz_inflateReset inflateReset
+#define qz_deflateInit2_ deflateInit2_
+#define qz_deflateEnd deflateEnd
+#define qz_deflate deflate
+#define Z_MEMLEVEL_DEFAULT 8
+#else
+
 // Zlib constants (from zlib.h)
 #define Z_SYNC_FLUSH   2
 #define MAX_WBITS              15
@@ -141,67 +154,71 @@ TYPES
 =============================================================================
 */
 
-// Zlib stream (from zlib.h)
-// Warning: some pointers we don't use directly have
-// been cast to "void*" for a matter of simplicity
+/*! Zlib stream (from zlib.h)
+ * \warning: some pointers we don't use directly have
+ * been cast to "void*" for a matter of simplicity
+ */
 typedef struct
 {
-       unsigned char                   *next_in;       // next input byte
-       unsigned int    avail_in;       // number of bytes available at next_in
-       unsigned long   total_in;       // total nb of input bytes read so far
+       unsigned char                   *next_in;       ///< next input byte
+       unsigned int    avail_in;       ///< number of bytes available at next_in
+       unsigned long   total_in;       ///< total nb of input bytes read so far
 
-       unsigned char                   *next_out;      // next output byte should be put there
-       unsigned int    avail_out;      // remaining free space at next_out
-       unsigned long   total_out;      // total nb of bytes output so far
+       unsigned char                   *next_out;      ///< next output byte should be put there
+       unsigned int    avail_out;      ///< remaining free space at next_out
+       unsigned long   total_out;      ///< total nb of bytes output so far
 
-       char                    *msg;           // last error message, NULL if no error
-       void                    *state;         // not visible by applications
+       char                    *msg;           ///< last error message, NULL if no error
+       void                    *state;         ///< not visible by applications
 
-       void                    *zalloc;        // used to allocate the internal state
-       void                    *zfree;         // used to free the internal state
-       void                    *opaque;        // private data object passed to zalloc and zfree
+       void                    *zalloc;        ///< used to allocate the internal state
+       void                    *zfree;         ///< used to free the internal state
+       void                    *opaque;        ///< private data object passed to zalloc and zfree
 
-       int                             data_type;      // best guess about the data type: ascii or binary
-       unsigned long   adler;          // adler32 value of the uncompressed data
-       unsigned long   reserved;       // reserved for future use
+       int                             data_type;      ///< best guess about the data type: ascii or binary
+       unsigned long   adler;          ///< adler32 value of the uncompressed data
+       unsigned long   reserved;       ///< reserved for future use
 } z_stream;
+#endif
 
 
-// inside a package (PAK or PK3)
+/// inside a package (PAK or PK3)
 #define QFILE_FLAG_PACKED (1 << 0)
-// file is compressed using the deflate algorithm (PK3 only)
+/// file is compressed using the deflate algorithm (PK3 only)
 #define QFILE_FLAG_DEFLATED (1 << 1)
-// file is actually already loaded data
+/// file is actually already loaded data
 #define QFILE_FLAG_DATA (1 << 2)
+/// real file will be removed on close
+#define QFILE_FLAG_REMOVE (1 << 3)
 
 #define FILE_BUFF_SIZE 2048
 typedef struct
 {
        z_stream        zstream;
-       size_t          comp_length;                    // length of the compressed file
-       size_t          in_ind, in_len;                 // input buffer current index and length
-       size_t          in_position;                    // position in the compressed file
+       size_t          comp_length;                    ///< length of the compressed file
+       size_t          in_ind, in_len;                 ///< input buffer current index and length
+       size_t          in_position;                    ///< position in the compressed file
        unsigned char           input [FILE_BUFF_SIZE];
 } ztoolkit_t;
 
 struct qfile_s
 {
        int                             flags;
-       int                             handle;                                 // file descriptor
-       fs_offset_t             real_length;                    // uncompressed file size (for files opened in "read" mode)
-       fs_offset_t             position;                               // current position in the file
-       fs_offset_t             offset;                                 // offset into the package (0 if external file)
-       int                             ungetc;                                 // single stored character from ungetc, cleared to EOF when read
+       int                             handle;                                 ///< file descriptor
+       fs_offset_t             real_length;                    ///< uncompressed file size (for files opened in "read" mode)
+       fs_offset_t             position;                               ///< current position in the file
+       fs_offset_t             offset;                                 ///< offset into the package (0 if external file)
+       int                             ungetc;                                 ///< single stored character from ungetc, cleared to EOF when read
 
        // Contents buffer
-       fs_offset_t             buff_ind, buff_len;             // buffer current index and length
+       fs_offset_t             buff_ind, buff_len;             ///< buffer current index and length
        unsigned char                   buff [FILE_BUFF_SIZE];
 
-       // For zipped files
-       ztoolkit_t*             ztk;
+       ztoolkit_t*             ztk;    ///< For zipped files.
 
-       // for data files
-       const unsigned char *data;
+       const unsigned char *data;      ///< For data files.
+
+       const char *filename; ///< Kept around for QFILE_FLAG_REMOVE, unused otherwise
 };
 
 
@@ -213,12 +230,13 @@ typedef struct pk3_endOfCentralDir_s
 {
        unsigned int signature;
        unsigned short disknum;
-       unsigned short cdir_disknum;    // number of the disk with the start of the central directory
-       unsigned short localentries;    // number of entries in the central directory on this disk
-       unsigned short nbentries;               // total number of entries in the central directory on this disk
-       unsigned int cdir_size;                 // size of the central directory
-       unsigned int cdir_offset;               // with respect to the starting disk number
+       unsigned short cdir_disknum;    ///< number of the disk with the start of the central directory
+       unsigned short localentries;    ///< number of entries in the central directory on this disk
+       unsigned short nbentries;               ///< total number of entries in the central directory on this disk
+       unsigned int cdir_size;                 ///< size of the central directory
+       unsigned int cdir_offset;               ///< with respect to the starting disk number
        unsigned short comment_size;
+       fs_offset_t prepended_garbage;
 } pk3_endOfCentralDir_t;
 
 
@@ -237,12 +255,14 @@ typedef struct dpackheader_s
 } dpackheader_t;
 
 
-// Packages in memory
-// the offset in packfile_t is the true contents offset
+/*! \name Packages in memory
+ * @{
+ */
+/// the offset in packfile_t is the true contents offset
 #define PACKFILE_FLAG_TRUEOFFS (1 << 0)
-// file compressed using the deflate algorithm
+/// file compressed using the deflate algorithm
 #define PACKFILE_FLAG_DEFLATED (1 << 1)
-// file is a symbolic link
+/// file is a symbolic link
 #define PACKFILE_FLAG_SYMLINK (1 << 2)
 
 typedef struct packfile_s
@@ -250,8 +270,8 @@ typedef struct packfile_s
        char name [MAX_QPATH];
        int flags;
        fs_offset_t offset;
-       fs_offset_t packsize;   // size in the package
-       fs_offset_t realsize;   // real file size (uncompressed)
+       fs_offset_t packsize;   ///< size in the package
+       fs_offset_t realsize;   ///< real file size (uncompressed)
 } packfile_t;
 
 typedef struct pack_s
@@ -259,13 +279,14 @@ typedef struct pack_s
        char filename [MAX_OSPATH];
        char shortname [MAX_QPATH];
        int handle;
-       int ignorecase;  // PK3 ignores case
+       int ignorecase;  ///< PK3 ignores case
        int numfiles;
+       qboolean vpack;
        packfile_t *files;
 } pack_t;
+//@}
 
-
-// Search paths for files (including packages)
+/// Search paths for files (including packages)
 typedef struct searchpath_s
 {
        // only one of filename / pack will be used
@@ -304,18 +325,26 @@ VARIABLES
 mempool_t *fs_mempool;
 
 searchpath_t *fs_searchpaths = NULL;
+const char *const fs_checkgamedir_missing = "missing";
 
 #define MAX_FILES_IN_PACK      65536
 
+char fs_userdir[MAX_OSPATH];
 char fs_gamedir[MAX_OSPATH];
 char fs_basedir[MAX_OSPATH];
+static pack_t *fs_selfpack = NULL;
 
 // list of active game directories (empty if not running a mod)
 int fs_numgamedirs = 0;
 char fs_gamedirs[MAX_GAMEDIRS][MAX_QPATH];
 
-cvar_t scr_screenshot_name = {0, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
+// list of all gamedirs with modinfo.txt
+gamedir_t *fs_all_gamedirs = NULL;
+int fs_all_gamedirs_count = 0;
+
+cvar_t scr_screenshot_name = {CVAR_NORESETTODEFAULTS, "scr_screenshot_name","dp", "prefix name for saved screenshots (changes based on -game commandline, as well as which game mode is running; the date is encoded using strftime escapes)"};
 cvar_t fs_empty_files_in_pack_mark_deletions = {0, "fs_empty_files_in_pack_mark_deletions", "0", "if enabled, empty files in a pak/pk3 count as not existing but cancel the search in further packs, effectively allowing patch pak/pk3 files to 'delete' files"};
+cvar_t cvar_fs_gamedir = {CVAR_READONLY | CVAR_NORESETTODEFAULTS, "fs_gamedir", "", "the list of currently selected gamedirs (use the 'gamedir' command to change this)"};
 
 
 /*
@@ -326,6 +355,7 @@ PRIVATE FUNCTIONS - PK3 HANDLING
 =============================================================================
 */
 
+#ifndef LINK_TO_ZLIB
 // Functions exported from zlib
 #if defined(WIN32) && defined(ZLIB_USES_WINAPI)
 # define ZEXPORT WINAPI
@@ -340,12 +370,14 @@ static int (ZEXPORT *qz_inflateReset) (z_stream* strm);
 static int (ZEXPORT *qz_deflateInit2_) (z_stream* strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, int stream_size);
 static int (ZEXPORT *qz_deflateEnd) (z_stream* strm);
 static int (ZEXPORT *qz_deflate) (z_stream* strm, int flush);
+#endif
 
 #define qz_inflateInit2(strm, windowBits) \
         qz_inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
 #define qz_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
         qz_deflateInit2_((strm), (level), (method), (windowBits), (memLevel), (strategy), ZLIB_VERSION, sizeof(z_stream))
 
+#ifndef LINK_TO_ZLIB
 //        qz_deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
 
 static dllfunction_t zlibfuncs[] =
@@ -360,8 +392,9 @@ static dllfunction_t zlibfuncs[] =
        {NULL, NULL}
 };
 
-// Handle for Zlib DLL
+/// Handle for Zlib DLL
 static dllhandle_t zlib_dll = NULL;
+#endif
 
 #ifdef WIN32
 static HRESULT (WINAPI *qSHGetFolderPath) (HWND hwndOwner, int nFolder, HANDLE hToken, DWORD dwFlags, LPTSTR pszPath);
@@ -382,7 +415,9 @@ Unload the Zlib DLL
 */
 void PK3_CloseLibrary (void)
 {
+#ifndef LINK_TO_ZLIB
        Sys_UnloadLibrary (&zlib_dll);
+#endif
 }
 
 
@@ -395,11 +430,12 @@ Try to load the Zlib DLL
 */
 qboolean PK3_OpenLibrary (void)
 {
+#ifdef LINK_TO_ZLIB
+       return true;
+#else
        const char* dllnames [] =
        {
-#if defined(WIN64)
-               "zlib64.dll",
-#elif defined(WIN32)
+#if defined(WIN32)
 # ifdef ZLIB_USES_WINAPI
                "zlibwapi.dll",
                "zlib.dll",
@@ -421,6 +457,7 @@ qboolean PK3_OpenLibrary (void)
 
        // Load the DLL
        return Sys_LoadLibrary (dllnames, &zlib_dll, zlibfuncs);
+#endif
 }
 
 /*
@@ -432,8 +469,12 @@ See if zlib is available
 */
 qboolean FS_HasZlib(void)
 {
+#ifdef LINK_TO_ZLIB
+       return true;
+#else
        PK3_OpenLibrary(); // to be safe
        return (zlib_dll != 0);
+#endif
 }
 
 /*
@@ -492,6 +533,8 @@ qboolean PK3_GetEndOfCentralDir (const char *packfile, int packhandle, pk3_endOf
        eocd->cdir_size = LittleLong (eocd->cdir_size);
        eocd->cdir_offset = LittleLong (eocd->cdir_offset);
        eocd->comment_size = LittleShort (eocd->comment_size);
+       eocd->prepended_garbage = filesize - (ind + ZIP_END_CDIR_SIZE) - eocd->cdir_offset - eocd->cdir_size; // this detects "SFX" zip files
+       eocd->cdir_offset += eocd->prepended_garbage;
 
        Mem_Free (buffer);
 
@@ -515,7 +558,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
        // Load the central directory in memory
        central_dir = (unsigned char *)Mem_Alloc (tempmempool, eocd->cdir_size);
        lseek (pack->handle, eocd->cdir_offset, SEEK_SET);
-       if(read (pack->handle, central_dir, eocd->cdir_size) != (ssize_t) eocd->cdir_size)
+       if(read (pack->handle, central_dir, eocd->cdir_size) != (fs_offset_t) eocd->cdir_size)
        {
                Mem_Free (central_dir);
                return -1;
@@ -585,7 +628,7 @@ int PK3_BuildFileList (pack_t *pack, const pk3_endOfCentralDir_t *eocd)
                                        flags = PACKFILE_FLAG_DEFLATED;
                                else
                                        flags = 0;
-                               offset = BuffLittleLong (&ptr[42]);
+                               offset = BuffLittleLong (&ptr[42]) + eocd->prepended_garbage;
                                packsize = BuffLittleLong (&ptr[20]);
                                realsize = BuffLittleLong (&ptr[24]);
 
@@ -626,24 +669,16 @@ FS_LoadPackPK3
 Create a package entry associated with a PK3 file
 ====================
 */
-pack_t *FS_LoadPackPK3 (const char *packfile)
+pack_t *FS_LoadPackPK3FromFD (const char *packfile, int packhandle, qboolean silent)
 {
-       int packhandle;
        pk3_endOfCentralDir_t eocd;
        pack_t *pack;
        int real_nb_files;
 
-#if _MSC_VER >= 1400
-       _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
-#else
-       packhandle = open (packfile, O_RDONLY | O_BINARY);
-#endif
-       if (packhandle < 0)
-               return NULL;
-
        if (! PK3_GetEndOfCentralDir (packfile, packhandle, &eocd))
        {
-               Con_Printf ("%s is not a PK3 file\n", packfile);
+               if(!silent)
+                       Con_Printf ("%s is not a PK3 file\n", packfile);
                close(packhandle);
                return NULL;
        }
@@ -684,9 +719,21 @@ pack_t *FS_LoadPackPK3 (const char *packfile)
                return NULL;
        }
 
-       Con_Printf("Added packfile %s (%i files)\n", packfile, real_nb_files);
+       Con_DPrintf("Added packfile %s (%i files)\n", packfile, real_nb_files);
        return pack;
 }
+pack_t *FS_LoadPackPK3 (const char *packfile)
+{
+       int packhandle;
+#if _MSC_VER >= 1400
+       _sopen_s(&packhandle, packfile, O_RDONLY | O_BINARY, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+#else
+       packhandle = open (packfile, O_RDONLY | O_BINARY);
+#endif
+       if (packhandle < 0)
+               return NULL;
+       return FS_LoadPackPK3FromFD(packfile, packhandle, false);
+}
 
 
 /*
@@ -823,7 +870,12 @@ void FS_Path_f (void)
        for (s=fs_searchpaths ; s ; s=s->next)
        {
                if (s->pack)
-                       Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
+               {
+                       if(s->pack->vpack)
+                               Con_Printf("%sdir (virtual pack)\n", s->pack->filename);
+                       else
+                               Con_Printf("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
+               }
                else
                        Con_Printf("%s\n", s->filename);
        }
@@ -833,13 +885,12 @@ void FS_Path_f (void)
 /*
 =================
 FS_LoadPackPAK
-
-Takes an explicit (not game tree related) path to a pak file.
-
-Loads the header and directory, adding the files at the beginning
-of the list so they override previous pack files.
 =================
 */
+/*! Takes an explicit (not game tree related) path to a pak file.
+ *Loads the header and directory, adding the files at the beginning
+ *of the list so they override previous pack files.
+ */
 pack_t *FS_LoadPackPAK (const char *packfile)
 {
        dpackheader_t header;
@@ -914,29 +965,52 @@ pack_t *FS_LoadPackPAK (const char *packfile)
 
        Mem_Free(info);
 
-       Con_Printf("Added packfile %s (%i files)\n", packfile, numpackfiles);
+       Con_DPrintf("Added packfile %s (%i files)\n", packfile, numpackfiles);
        return pack;
 }
 
 /*
-================
-FS_AddPack_Fullpath
-
-Adds the given pack to the search path.
-The pack type is autodetected by the file extension.
+====================
+FS_LoadPackVirtual
 
-Returns true if the file was successfully added to the
-search path or if it was already included.
+Create a package entry associated with a directory file
+====================
+*/
+pack_t *FS_LoadPackVirtual (const char *dirname)
+{
+       pack_t *pack;
+       pack = (pack_t *)Mem_Alloc(fs_mempool, sizeof (pack_t));
+       pack->vpack = true;
+       pack->ignorecase = false;
+       strlcpy (pack->filename, dirname, sizeof(pack->filename));
+       pack->handle = -1;
+       pack->numfiles = -1;
+       pack->files = NULL;
+       Con_DPrintf("Added packfile %s (virtual pack)\n", dirname);
+       return pack;
+}
 
-If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
-plain directories.
+/*
+================
+FS_AddPack_Fullpath
 ================
 */
+/*! Adds the given pack to the search path.
+ * The pack type is autodetected by the file extension.
+ *
+ * Returns true if the file was successfully added to the
+ * search path or if it was already included.
+ *
+ * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
+ * plain directories.
+ *
+ */
 static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname, qboolean *already_loaded, qboolean keep_plain_dirs)
 {
        searchpath_t *search;
        pack_t *pak = NULL;
        const char *ext = FS_FileExtension(pakfile);
+       size_t l;
 
        for(search = fs_searchpaths; search; search = search->next)
        {
@@ -951,16 +1025,19 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
        if(already_loaded)
                *already_loaded = false;
 
-       if(!strcasecmp(ext, "pak"))
+       if(!strcasecmp(ext, "pk3dir"))
+               pak = FS_LoadPackVirtual (pakfile);
+       else if(!strcasecmp(ext, "pak"))
                pak = FS_LoadPackPAK (pakfile);
        else if(!strcasecmp(ext, "pk3"))
                pak = FS_LoadPackPK3 (pakfile);
        else
                Con_Printf("\"%s\" does not have a pack extension\n", pakfile);
 
-       if (pak)
+       if(pak)
        {
                strlcpy(pak->shortname, shortname, sizeof(pak->shortname));
+
                //Con_DPrintf("  Registered pack with short name %s\n", shortname);
                if(keep_plain_dirs)
                {
@@ -984,7 +1061,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
                        if(!insertion_point)
                        {
                                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                               search->pack = pak;
                                search->next = fs_searchpaths;
                                fs_searchpaths = search;
                        }
@@ -992,7 +1068,6 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
                        // otherwise we want to append directly after insertion_point.
                        {
                                search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                               search->pack = pak;
                                search->next = insertion_point->next;
                                insertion_point->next = search;
                        }
@@ -1000,10 +1075,24 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
                else
                {
                        search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
-                       search->pack = pak;
                        search->next = fs_searchpaths;
                        fs_searchpaths = search;
                }
+               search->pack = pak;
+               if(pak->vpack)
+               {
+                       dpsnprintf(search->filename, sizeof(search->filename), "%s/", pakfile);
+                       // if shortname ends with "pk3dir", strip that suffix to make it just "pk3"
+                       // same goes for the name inside the pack structure
+                       l = strlen(pak->shortname);
+                       if(l >= 7)
+                               if(!strcasecmp(pak->shortname + l - 7, ".pk3dir"))
+                                       pak->shortname[l - 3] = 0;
+                       l = strlen(pak->filename);
+                       if(l >= 7)
+                               if(!strcasecmp(pak->filename + l - 7, ".pk3dir"))
+                                       pak->filename[l - 3] = 0;
+               }
                return true;
        }
        else
@@ -1017,20 +1106,20 @@ static qboolean FS_AddPack_Fullpath(const char *pakfile, const char *shortname,
 /*
 ================
 FS_AddPack
-
-Adds the given pack to the search path and searches for it in the game path.
-The pack type is autodetected by the file extension.
-
-Returns true if the file was successfully added to the
-search path or if it was already included.
-
-If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
-plain directories.
 ================
 */
+/*! Adds the given pack to the search path and searches for it in the game path.
+ * The pack type is autodetected by the file extension.
+ *
+ * Returns true if the file was successfully added to the
+ * search path or if it was already included.
+ *
+ * If keep_plain_dirs is set, the pack will be added AFTER the first sequence of
+ * plain directories.
+ */
 qboolean FS_AddPack(const char *pakfile, qboolean *already_loaded, qboolean keep_plain_dirs)
 {
-       char fullpath[MAX_QPATH];
+       char fullpath[MAX_OSPATH];
        int index;
        searchpath_t *search;
 
@@ -1083,7 +1172,7 @@ void FS_AddGameDirectory (const char *dir)
        // add any PK3 package in the directory
        for (i = 0;i < list.numstrings;i++)
        {
-               if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3"))
+               if (!strcasecmp(FS_FileExtension(list.strings[i]), "pk3") || !strcasecmp(FS_FileExtension(list.strings[i]), "pk3dir"))
                {
                        FS_AddPack_Fullpath(list.strings[i], list.strings[i] + strlen(dir), NULL, false);
                }
@@ -1107,86 +1196,11 @@ FS_AddGameHierarchy
 */
 void FS_AddGameHierarchy (const char *dir)
 {
-       int i;
-       char userdir[MAX_QPATH];
-#ifdef WIN32
-       TCHAR mydocsdir[MAX_PATH + 1];
-#if _MSC_VER >= 1400
-       size_t homedirlen;
-#endif
-#endif
-       char *homedir;
-
        // Add the common game directory
        FS_AddGameDirectory (va("%s%s/", fs_basedir, dir));
 
-       *userdir = 0;
-
-       // Add the personal game directory
-#ifdef WIN32
-       if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
-       {
-               dpsnprintf(userdir, sizeof(userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
-               Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", userdir);
-       }
-       else
-       {
-               // use the environment
-#if _MSC_VER >= 1400
-               _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
-#else
-               homedir = getenv("USERPROFILE");
-#endif
-
-               if(homedir)
-               {
-                       dpsnprintf(userdir, sizeof(userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
-#if _MSC_VER >= 1400
-                       free(homedir);
-#endif
-                       Con_DPrintf("Obtained personal directory %s from environment\n", userdir);
-               }
-               else
-                       *userdir = 0; // just to make sure it hasn't been written to by SHGetFolderPath returning failure
-       }
-
-       if(!*userdir)
-               Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
-#else
-       homedir = getenv ("HOME");
-       if(homedir)
-               dpsnprintf(userdir, sizeof(userdir), "%s/.%s/", homedir, gameuserdirname);
-
-       if(!*userdir)
-               Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
-#endif
-
-
-#ifdef WIN32
-       if(!COM_CheckParm("-mygames"))
-       {
-#if _MSC_VER >= 1400
-               int fd;
-               _sopen_s(&fd, va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
-#else
-               int fd = open (va("%s%s/config.cfg", fs_basedir, dir), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
-#endif
-               if(fd >= 0)
-               {
-                       close(fd);
-                       *userdir = 0; // we have write access to the game dir, so let's use it
-               }
-       }
-#endif
-
-       if(COM_CheckParm("-nohome"))
-               *userdir = 0;
-
-       if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
-               dpsnprintf(userdir, sizeof(userdir), "%s/", com_argv[i+1]);
-
-       if (*userdir)
-               FS_AddGameDirectory(va("%s%s/", userdir, dir));
+       if (*fs_userdir)
+               FS_AddGameDirectory(va("%s%s/", fs_userdir, dir));
 }
 
 
@@ -1249,19 +1263,34 @@ void FS_ClearSearchPath (void)
        {
                searchpath_t *search = fs_searchpaths;
                fs_searchpaths = search->next;
-               if (search->pack)
+               if (search->pack && search->pack != fs_selfpack)
                {
-                       // close the file
-                       close(search->pack->handle);
-                       // free any memory associated with it
-                       if (search->pack->files)
-                               Mem_Free(search->pack->files);
+                       if(!search->pack->vpack)
+                       {
+                               // close the file
+                               close(search->pack->handle);
+                               // free any memory associated with it
+                               if (search->pack->files)
+                                       Mem_Free(search->pack->files);
+                       }
                        Mem_Free(search->pack);
                }
                Mem_Free(search);
        }
 }
 
+static void FS_AddSelfPack(void)
+{
+       if(fs_selfpack)
+       {
+               searchpath_t *search;
+               search = (searchpath_t *)Mem_Alloc(fs_mempool, sizeof(searchpath_t));
+               search->next = fs_searchpaths;
+               search->pack = fs_selfpack;
+               fs_searchpaths = search;
+       }
+}
+
 
 /*
 ================
@@ -1272,6 +1301,7 @@ void FS_Rescan (void)
 {
        int i;
        qboolean fs_modified = false;
+       char gamedirbuf[MAX_INPUTLINE];
 
        FS_ClearSearchPath();
 
@@ -1293,13 +1323,22 @@ void FS_Rescan (void)
        // Adds basedir/gamedir as an override game
        // LordHavoc: now supports multiple -game directories
        // set the com_modname (reported in server info)
+       *gamedirbuf = 0;
        for (i = 0;i < fs_numgamedirs;i++)
        {
                fs_modified = true;
                FS_AddGameHierarchy (fs_gamedirs[i]);
                // update the com_modname (used server info)
                strlcpy (com_modname, fs_gamedirs[i], sizeof (com_modname));
+               if(i)
+                       strlcat(gamedirbuf, va(" %s", fs_gamedirs[i]), sizeof(gamedirbuf));
+               else
+                       strlcpy(gamedirbuf, fs_gamedirs[i], sizeof(gamedirbuf));
        }
+       Cvar_SetQuick(&cvar_fs_gamedir, gamedirbuf); // so QC or console code can query it
+
+       // add back the selfpack as new first item
+       FS_AddSelfPack();
 
        // set the default screenshot name to either the mod name or the
        // gamemode screenshot name
@@ -1307,24 +1346,40 @@ void FS_Rescan (void)
                Cvar_SetQuick (&scr_screenshot_name, com_modname);
        else
                Cvar_SetQuick (&scr_screenshot_name, gamescreenshotname);
+       
+       if((i = COM_CheckParm("-modname")) && i < com_argc - 1)
+               strlcpy(com_modname, com_argv[i+1], sizeof(com_modname));
 
        // If "-condebug" is in the command line, remove the previous log file
        if (COM_CheckParm ("-condebug") != 0)
                unlink (va("%s/qconsole.log", fs_gamedir));
 
        // look for the pop.lmp file and set registered to true if it is found
-       if ((gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE) && !FS_FileExists("gfx/pop.lmp"))
+       if (FS_FileExists("gfx/pop.lmp"))
+               Cvar_Set ("registered", "1");
+       switch(gamemode)
        {
-               if (fs_modified)
-                       Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+       case GAME_NORMAL:
+       case GAME_HIPNOTIC:
+       case GAME_ROGUE:
+               if (!registered.integer)
+               {
+                       if (fs_modified)
+                               Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+                       else
+                               Con_Print("Playing shareware version.\n");
+               }
                else
-                       Con_Print("Playing shareware version.\n");
-       }
-       else
-       {
-               Cvar_Set ("registered", "1");
-               if (gamemode == GAME_NORMAL || gamemode == GAME_HIPNOTIC || gamemode == GAME_ROGUE)
                        Con_Print("Playing registered version.\n");
+               break;
+       case GAME_STEELSTORM:
+               if (registered.integer)
+                       Con_Print("Playing registered version.\n");
+               else
+                       Con_Print("Playing shareware version.\n");
+               break;
+       default:
+               break;
        }
 
        // unload all wads so that future queries will return the new data
@@ -1346,6 +1401,7 @@ extern void Host_LoadConfig_f (void);
 qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean complain, qboolean failmissing)
 {
        int i;
+       const char *p;
 
        if (fs_numgamedirs == numgamedirs)
        {
@@ -1366,17 +1422,14 @@ qboolean FS_ChangeGameDirs(int numgamedirs, char gamedirs[][MAX_QPATH], qboolean
        for (i = 0;i < numgamedirs;i++)
        {
                // if string is nasty, reject it
-               if(FS_CheckNastyPath(gamedirs[i], true))
+               p = FS_CheckGameDir(gamedirs[i]);
+               if(!p)
                {
                        if (complain)
                                Con_Printf("Nasty gamedir name rejected: %s\n", gamedirs[i]);
                        return false; // nasty gamedirs
                }
-       }
-
-       for (i = 0;i < numgamedirs;i++)
-       {
-               if (!FS_CheckGameDir(gamedirs[i]) && failmissing)
+               if(p == fs_checkgamedir_missing && failmissing)
                {
                        if (complain)
                                Con_Printf("Gamedir missing: %s%s/\n", fs_basedir, gamedirs[i]);
@@ -1448,23 +1501,172 @@ void FS_GameDir_f (void)
        FS_ChangeGameDirs(numgamedirs, gamedirs, true, true);
 }
 
+static const char *FS_SysCheckGameDir(const char *gamedir)
+{
+       static char buf[8192];
+       qboolean success;
+       qfile_t *f;
+       stringlist_t list;
+       fs_offset_t n;
+
+       stringlistinit(&list);
+       listdirectory(&list, gamedir, "");
+       success = list.numstrings > 0;
+       stringlistfreecontents(&list);
+
+       if(success)
+       {
+               f = FS_SysOpen(va("%smodinfo.txt", gamedir), "r", false);
+               if(f)
+               {
+                       n = FS_Read (f, buf, sizeof(buf) - 1);
+                       if(n >= 0)
+                               buf[n] = 0;
+                       else
+                               *buf = 0;
+                       FS_Close(f);
+               }
+               else
+                       *buf = 0;
+               return buf;
+       }
+
+       return NULL;
+}
 
 /*
 ================
 FS_CheckGameDir
 ================
 */
-qboolean FS_CheckGameDir(const char *gamedir)
+const char *FS_CheckGameDir(const char *gamedir)
 {
-       qboolean success;
-       stringlist_t list;
+       const char *ret;
+
+       if (FS_CheckNastyPath(gamedir, true))
+               return NULL;
+
+       ret = FS_SysCheckGameDir(va("%s%s/", fs_userdir, gamedir));
+       if(ret)
+       {
+               if(!*ret)
+               {
+                       // get description from basedir
+                       ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+                       if(ret)
+                               return ret;
+                       return "";
+               }
+               return ret;
+       }
+
+       ret = FS_SysCheckGameDir(va("%s%s/", fs_basedir, gamedir));
+       if(ret)
+               return ret;
+       
+       return fs_checkgamedir_missing;
+}
+
+static void FS_ListGameDirs(void)
+{
+       stringlist_t list, list2;
+       int i, j;
+       const char *info;
+
+       fs_all_gamedirs_count = 0;
+       if(fs_all_gamedirs)
+               Mem_Free(fs_all_gamedirs);
+
        stringlistinit(&list);
-       listdirectory(&list, va("%s%s/", fs_basedir, gamedir), "");
-       success = list.numstrings > 0;
+       listdirectory(&list, va("%s/", fs_basedir), "");
+       listdirectory(&list, va("%s/", fs_userdir), "");
+       stringlistsort(&list);
+
+       stringlistinit(&list2);
+       for(i = 0; i < list.numstrings; ++i)
+       {
+               if(i)
+                       if(!strcmp(list.strings[i-1], list.strings[i]))
+                               continue;
+               info = FS_CheckGameDir(list.strings[i]);
+               if(!info)
+                       continue;
+               if(info == fs_checkgamedir_missing)
+                       continue;
+               if(!*info)
+                       continue;
+               stringlistappend(&list2, list.strings[i]); 
+       }
        stringlistfreecontents(&list);
-       return success;
+
+       fs_all_gamedirs = (gamedir_t *)Mem_Alloc(fs_mempool, list2.numstrings * sizeof(*fs_all_gamedirs));
+       for(i = 0; i < list2.numstrings; ++i)
+       {
+               info = FS_CheckGameDir(list2.strings[i]);
+               // all this cannot happen any more, but better be safe than sorry
+               if(!info)
+                       continue;
+               if(info == fs_checkgamedir_missing)
+                       continue;
+               if(!*info)
+                       continue;
+               strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].name, list2.strings[i], sizeof(fs_all_gamedirs[j].name));
+               strlcpy(fs_all_gamedirs[fs_all_gamedirs_count].description, info, sizeof(fs_all_gamedirs[j].description));
+               ++fs_all_gamedirs_count;
+       }
 }
 
+/*
+================
+FS_Init_SelfPack
+================
+*/
+void FS_Init_SelfPack (void)
+{
+       PK3_OpenLibrary ();
+       fs_mempool = Mem_AllocPool("file management", 0, NULL);
+       if(com_selffd >= 0)
+       {
+               fs_selfpack = FS_LoadPackPK3FromFD(com_argv[0], com_selffd, true);
+               if(fs_selfpack)
+               {
+                       char *buf, *q;
+                       const char *p;
+                       FS_AddSelfPack();
+                       buf = (char *) FS_LoadFile("darkplaces.opt", tempmempool, true, NULL);
+                       if(buf)
+                       {
+                               const char **new_argv;
+                               int i = 0;
+                               int args_left = 256;
+                               new_argv = (const char **)Mem_Alloc(fs_mempool, sizeof(*com_argv) * (com_argc + args_left + 2));
+                               if(com_argc == 0)
+                               {
+                                       new_argv[0] = "dummy";
+                                       com_argc = 1;
+                               }
+                               else
+                               {
+                                       memcpy((char *)(&new_argv[0]), &com_argv[0], sizeof(*com_argv) * com_argc);
+                               }
+                               p = buf;
+                               while(COM_ParseToken_Console(&p))
+                               {
+                                       if(i >= args_left)
+                                               break;
+                                       q = (char *)Mem_Alloc(fs_mempool, strlen(com_token) + 1);
+                                       strlcpy(q, com_token, strlen(com_token) + 1);
+                                       new_argv[com_argc + i] = q;
+                                       ++i;
+                               }
+                               new_argv[i+com_argc] = NULL;
+                               com_argv = new_argv;
+                               com_argc = com_argc + i;
+                       }
+                       Mem_Free(buf);
+               }
+       }
+}
 
 /*
 ================
@@ -1473,7 +1675,15 @@ FS_Init
 */
 void FS_Init (void)
 {
+       const char *p;
        int i;
+#ifdef WIN32
+       TCHAR mydocsdir[MAX_PATH + 1];
+#if _MSC_VER >= 1400
+       size_t homedirlen;
+#endif
+#endif
+       char *homedir;
 
 #ifdef WIN32
        const char* dllnames [] =
@@ -1485,7 +1695,70 @@ void FS_Init (void)
        // don't care for the result; if it fails, %USERPROFILE% will be used instead
 #endif
 
-       fs_mempool = Mem_AllocPool("file management", 0, NULL);
+       // Add the personal game directory
+       if((i = COM_CheckParm("-userdir")) && i < com_argc - 1)
+       {
+               dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/", com_argv[i+1]);
+       }
+       else if(COM_CheckParm("-nohome"))
+       {
+               *fs_userdir = 0;
+       }
+       else
+       {
+#ifdef WIN32
+               if(qSHGetFolderPath && (qSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, 0, mydocsdir) == S_OK))
+               {
+                       dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Games/%s/", mydocsdir, gameuserdirname);
+                       Con_DPrintf("Obtained personal directory %s from SHGetFolderPath\n", fs_userdir);
+               }
+               else
+               {
+                       // use the environment
+#if _MSC_VER >= 1400
+                       _dupenv_s (&homedir, &homedirlen, "USERPROFILE");
+#else
+                       homedir = getenv("USERPROFILE");
+#endif
+
+                       if(homedir)
+                       {
+                               dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/My Documents/My Games/%s/", homedir, gameuserdirname);
+#if _MSC_VER >= 1400
+                               free(homedir);
+#endif
+                               Con_DPrintf("Obtained personal directory %s from environment\n", fs_userdir);
+                       }
+               }
+
+               if(!*fs_userdir)
+                       Con_DPrintf("Could not obtain home directory; not supporting -mygames\n");
+#else
+               homedir = getenv ("HOME");
+               if(homedir)
+                       dpsnprintf(fs_userdir, sizeof(fs_userdir), "%s/.%s/", homedir, gameuserdirname);
+
+               if(!*fs_userdir)
+                       Con_DPrintf("Could not obtain home directory; assuming -nohome\n");
+#endif
+
+#ifdef WIN32
+               if(!COM_CheckParm("-mygames"))
+               {
+#if _MSC_VER >= 1400
+                       int fd;
+                       _sopen_s(&fd, va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, _SH_DENYNO, _S_IREAD | _S_IWRITE); // note: no O_TRUNC here!
+#else
+                       int fd = open (va("%s%s/config.cfg", fs_basedir, gamedirname1), O_WRONLY | O_CREAT, 0666); // note: no O_TRUNC here!
+#endif
+                       if(fd >= 0)
+                       {
+                               close(fd);
+                               *fs_userdir = 0; // we have write access to the game dir, so let's use it
+                       }
+               }
+#endif
+       }
 
        strlcpy(fs_gamedir, "", sizeof(fs_gamedir));
 
@@ -1493,7 +1766,7 @@ void FS_Init (void)
 #ifdef DP_FS_BASEDIR
        strlcpy(fs_basedir, DP_FS_BASEDIR, sizeof(fs_basedir));
 #else
-       strlcpy(fs_basedir, "", sizeof(fs_basedir));
+       *fs_basedir = 0;
 
 #ifdef MACOSX
        // FIXME: is there a better way to find the directory outside the .app?
@@ -1510,8 +1783,6 @@ void FS_Init (void)
 #endif
 #endif
 
-       PK3_OpenLibrary ();
-
        // -basedir <path>
        // Overrides the system supplied base directory (under GAMENAME)
 // COMMANDLINEOPTION: Filesystem: -basedir <path> chooses what base directory the game data is in, inside this there should be a data directory for the game (for example id1)
@@ -1528,11 +1799,18 @@ void FS_Init (void)
        if (fs_basedir[0] && fs_basedir[strlen(fs_basedir) - 1] != '/' && fs_basedir[strlen(fs_basedir) - 1] != '\\')
                strlcat(fs_basedir, "/", sizeof(fs_basedir));
 
-       if (!FS_CheckGameDir(gamedirname1))
+       FS_ListGameDirs();
+
+       p = FS_CheckGameDir(gamedirname1);
+       if(!p || p == fs_checkgamedir_missing)
                Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname1);
 
-       if (gamedirname2 && !FS_CheckGameDir(gamedirname2))
-               Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
+       if(gamedirname2)
+       {
+               p = FS_CheckGameDir(gamedirname2);
+               if(!p || p == fs_checkgamedir_missing)
+                       Con_Printf("WARNING: base gamedir %s%s/ not found!\n", fs_basedir, gamedirname2);
+       }
 
        // -game <gamedir>
        // Adds basedir/gamedir as an override game
@@ -1544,9 +1822,10 @@ void FS_Init (void)
                if (!strcmp (com_argv[i], "-game") && i < com_argc-1)
                {
                        i++;
-                       if (FS_CheckNastyPath(com_argv[i], true))
-                               Sys_Error("-game %s%s/ is a dangerous/non-portable path\n", fs_basedir, com_argv[i]);
-                       if (!FS_CheckGameDir(com_argv[i]))
+                       p = FS_CheckGameDir(com_argv[i]);
+                       if(!p)
+                               Sys_Error("Nasty -game name rejected: %s", com_argv[i]);
+                       if(p == fs_checkgamedir_missing)
                                Con_Printf("WARNING: -game %s%s/ not found!\n", fs_basedir, com_argv[i]);
                        // add the gamedir to the list of active gamedirs
                        strlcpy (fs_gamedirs[fs_numgamedirs], com_argv[i], sizeof(fs_gamedirs[fs_numgamedirs]));
@@ -1562,6 +1841,7 @@ void FS_Init_Commands(void)
 {
        Cvar_RegisterVariable (&scr_screenshot_name);
        Cvar_RegisterVariable (&fs_empty_files_in_pack_mark_deletions);
+       Cvar_RegisterVariable (&cvar_fs_gamedir);
 
        Cmd_AddCommand ("gamedir", FS_GameDir_f, "changes active gamedir list (can take multiple arguments), not including base directory (example usage: gamedir ctf)");
        Cmd_AddCommand ("fs_rescan", FS_Rescan_f, "rescans filesystem for new pack archives and any other changes");
@@ -1589,16 +1869,9 @@ void FS_Shutdown (void)
 #endif
 }
 
-/*
-====================
-FS_SysOpen
-
-Internal function used to create a qfile_t and open the relevant non-packed file on disk
-====================
-*/
-static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
+int FS_SysOpenFD(const char *filepath, const char *mode, qboolean nonblocking)
 {
-       qfile_t* file;
+       int handle;
        int mod, opt;
        unsigned int ind;
 
@@ -1619,7 +1892,7 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean non
                        break;
                default:
                        Con_Printf ("FS_SysOpen(%s, %s): invalid mode\n", filepath, mode);
-                       return NULL;
+                       return -1;
        }
        for (ind = 1; mode[ind] != '\0'; ind++)
        {
@@ -1640,25 +1913,40 @@ static qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean non
        if (nonblocking)
                opt |= O_NONBLOCK;
 
-       file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
-       memset (file, 0, sizeof (*file));
-       file->ungetc = EOF;
-
 #if _MSC_VER >= 1400
-       _sopen_s(&file->handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
+       _sopen_s(&handle, filepath, mod | opt, _SH_DENYNO, _S_IREAD | _S_IWRITE);
 #else
-       file->handle = open (filepath, mod | opt, 0666);
+       handle = open (filepath, mod | opt, 0666);
 #endif
+       return handle;
+}
+
+/*
+====================
+FS_SysOpen
+
+Internal function used to create a qfile_t and open the relevant non-packed file on disk
+====================
+*/
+qfile_t* FS_SysOpen (const char* filepath, const char* mode, qboolean nonblocking)
+{
+       qfile_t* file;
+
+       file = (qfile_t *)Mem_Alloc (fs_mempool, sizeof (*file));
+       file->ungetc = EOF;
+       file->handle = FS_SysOpenFD(filepath, mode, nonblocking);
        if (file->handle < 0)
        {
                Mem_Free (file);
                return NULL;
        }
 
+       file->filename = Mem_strdup(fs_mempool, filepath);
+
        file->real_length = lseek (file->handle, 0, SEEK_END);
 
        // For files opened in append mode, we start at the end of the file
-       if (mod & O_APPEND)
+       if (mode[0] == 'a')
                file->position = file->real_length;
        else
                lseek (file->handle, 0, SEEK_SET);
@@ -1687,6 +1975,7 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                if (!PK3_GetTrueFileOffset (pfile, pack))
                        return NULL;
 
+#ifndef LINK_TO_ZLIB
        // No Zlib DLL = no compressed files
        if (!zlib_dll && (pfile->flags & PACKFILE_FLAG_DEFLATED))
        {
@@ -1695,6 +1984,7 @@ qfile_t *FS_OpenPackedFile (pack_t* pack, int pack_ind)
                                        pfile->name);
                return NULL;
        }
+#endif
 
        // LordHavoc: lseek affects all duplicates of a handle so we do it before
        // the dup() call to avoid having to close the dup_handle on error here
@@ -1847,7 +2137,7 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
        for (search = fs_searchpaths;search;search = search->next)
        {
                // is the element a pak file?
-               if (search->pack)
+               if (search->pack && !search->pack->vpack)
                {
                        int (*strcmp_funct) (const char* str1, const char* str2);
                        int left, right, middle;
@@ -1871,16 +2161,16 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                                        if (fs_empty_files_in_pack_mark_deletions.integer && pak->files[middle].realsize == 0)
                                        {
                                                // yes, but the first one is empty so we treat it as not being there
-                                               if (!quiet && developer.integer >= 10)
-                                                       Con_Printf("FS_FindFile: %s is marked as deleted\n", name);
+                                               if (!quiet && developer_extra.integer)
+                                                       Con_DPrintf("FS_FindFile: %s is marked as deleted\n", name);
 
                                                if (index != NULL)
                                                        *index = -1;
                                                return NULL;
                                        }
 
-                                       if (!quiet && developer.integer >= 10)
-                                               Con_Printf("FS_FindFile: %s in %s\n",
+                                       if (!quiet && developer_extra.integer)
+                                               Con_DPrintf("FS_FindFile: %s in %s\n",
                                                                        pak->files[middle].name, pak->filename);
 
                                        if (index != NULL)
@@ -1901,8 +2191,8 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                        dpsnprintf(netpath, sizeof(netpath), "%s%s", search->filename, name);
                        if (FS_SysFileExists (netpath))
                        {
-                               if (!quiet && developer.integer >= 10)
-                                       Con_Printf("FS_FindFile: %s\n", netpath);
+                               if (!quiet && developer_extra.integer)
+                                       Con_DPrintf("FS_FindFile: %s\n", netpath);
 
                                if (index != NULL)
                                        *index = -1;
@@ -1911,8 +2201,8 @@ static searchpath_t *FS_FindFile (const char *name, int* index, qboolean quiet)
                }
        }
 
-       if (!quiet && developer.integer >= 10)
-               Con_Printf("FS_FindFile: can't find %s\n", name);
+       if (!quiet && developer_extra.integer)
+               Con_DPrintf("FS_FindFile: can't find %s\n", name);
 
        if (index != NULL)
                *index = -1;
@@ -1941,6 +2231,7 @@ qfile_t *FS_OpenReadFile (const char *filename, qboolean quiet, qboolean nonbloc
        // Found in the filesystem?
        if (pack_ind < 0)
        {
+               // this works with vpacks, so we are fine
                char path [MAX_OSPATH];
                dpsnprintf (path, sizeof (path), "%s%s", search->filename, filename);
                return FS_SysOpen (path, "rb", nonblocking);
@@ -2051,7 +2342,7 @@ qfile_t* FS_OpenRealFile (const char* filepath, const char* mode, qboolean quiet
                return NULL;
        }
 
-       dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath);
+       dpsnprintf (real_path, sizeof (real_path), "%s/%s", fs_gamedir, filepath); // this is never a vpack
 
        // If the file is opened in "write", "append", or "read/write" mode,
        // create directories up to the file.
@@ -2117,6 +2408,14 @@ int FS_Close (qfile_t* file)
        if (close (file->handle))
                return EOF;
 
+       if (file->filename)
+       {
+               if (file->flags & QFILE_FLAG_REMOVE)
+                       remove(file->filename);
+
+               Mem_Free((void *) file->filename);
+       }
+
        if (file->ztk)
        {
                qz_inflateEnd (&file->ztk->zstream);
@@ -2127,6 +2426,10 @@ int FS_Close (qfile_t* file)
        return 0;
 }
 
+void FS_RemoveOnClose(qfile_t* file)
+{
+       file->flags |= QFILE_FLAG_REMOVE;
+}
 
 /*
 ====================
@@ -2630,9 +2933,11 @@ FS_WriteFile
 The filename will be prefixed by the current game directory
 ============
 */
-qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
+qboolean FS_WriteFileInBlocks (const char *filename, const void *const *data, const fs_offset_t *len, size_t count)
 {
        qfile_t *file;
+       size_t i;
+       fs_offset_t lentotal;
 
        file = FS_OpenRealFile(filename, "wb", false);
        if (!file)
@@ -2641,12 +2946,21 @@ qboolean FS_WriteFile (const char *filename, void *data, fs_offset_t len)
                return false;
        }
 
-       Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)len);
-       FS_Write (file, data, len);
+       lentotal = 0;
+       for(i = 0; i < count; ++i)
+               lentotal += len[i];
+       Con_DPrintf("FS_WriteFile: %s (%u bytes)\n", filename, (unsigned int)lentotal);
+       for(i = 0; i < count; ++i)
+               FS_Write (file, data[i], len[i]);
        FS_Close (file);
        return true;
 }
 
+qboolean FS_WriteFile (const char *filename, const void *data, fs_offset_t len)
+{
+       return FS_WriteFileInBlocks(filename, &data, &len, 1);
+}
+
 
 /*
 =============================================================================
@@ -2720,13 +3034,13 @@ Look for a file in the packages and in the filesystem
 int FS_FileType (const char *filename)
 {
        searchpath_t *search;
-       char fullpath[MAX_QPATH];
+       char fullpath[MAX_OSPATH];
 
        search = FS_FindFile (filename, NULL, true);
        if(!search)
                return FS_FILETYPE_NONE;
 
-       if(search->pack)
+       if(search->pack && !search->pack->vpack)
                return FS_FILETYPE_FILE; // TODO can't check directories in paks yet, maybe later
 
        dpsnprintf(fullpath, sizeof(fullpath), "%s%s", search->filename, filename);
@@ -2777,6 +3091,9 @@ int FS_SysFileType (const char *path)
        if (stat (path,&buf) == -1)
                return FS_FILETYPE_NONE;
 
+#ifndef S_ISDIR
+#define S_ISDIR(a) (((a) & S_IFMT) == S_IFDIR)
+#endif
        if(S_ISDIR(buf.st_mode))
                return FS_FILETYPE_DIRECTORY;
 
@@ -2844,7 +3161,7 @@ fssearch_t *FS_Search(const char *pattern, int caseinsensitive, int quiet)
        for (searchpath = fs_searchpaths;searchpath;searchpath = searchpath->next)
        {
                // is the element a pak file?
-               if (searchpath->pack)
+               if (searchpath->pack && !searchpath->pack->vpack)
                {
                        // look through all the pak file elements
                        pak = searchpath->pack;
@@ -3120,7 +3437,12 @@ void FS_Which_f(void)
                return;
        }
        if (sp->pack)
-               Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
+       {
+               if(sp->pack->vpack)
+                       Con_Printf("%s is in virtual package %sdir\n", filename, sp->pack->shortname);
+               else
+                       Con_Printf("%s is in package %s\n", filename, sp->pack->shortname);
+       }
        else
                Con_Printf("%s is file %s%s\n", filename, sp->filename, filename);
 }
@@ -3153,7 +3475,8 @@ qboolean FS_IsRegisteredQuakePack(const char *name)
        // search through the path, one element at a time
        for (search = fs_searchpaths;search;search = search->next)
        {
-               if (search->pack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
+               if (search->pack && !search->pack->vpack && !strcasecmp(FS_FileWithoutPath(search->filename), name))
+                       // TODO do we want to support vpacks in here too?
                {
                        int (*strcmp_funct) (const char* str1, const char* str2);
                        int left, right, middle;
@@ -3216,6 +3539,12 @@ unsigned char *FS_Deflate(const unsigned char *data, size_t size, size_t *deflat
        unsigned char *out = NULL;
        unsigned char *tmp;
 
+       *deflated_size = 0;
+#ifndef LINK_TO_ZLIB
+       if(!zlib_dll)
+               return NULL;
+#endif
+
        memset(&strm, 0, sizeof(strm));
        strm.zalloc = Z_NULL;
        strm.zfree = Z_NULL;
@@ -3309,6 +3638,12 @@ unsigned char *FS_Inflate(const unsigned char *data, size_t size, size_t *inflat
        unsigned int have;
        sizebuf_t outbuf;
 
+       *inflated_size = 0;
+#ifndef LINK_TO_ZLIB
+       if(!zlib_dll)
+               return NULL;
+#endif
+
        memset(&outbuf, 0, sizeof(outbuf));
        outbuf.data = (unsigned char *) Mem_Alloc(tempmempool, sizeof(tmp));
        outbuf.maxsize = sizeof(tmp);