WebSVN – eduke32 – Diff – /polymer/eduke32/source/common.c


//
// Common non-engine code/data for EDuke32 and Mapster32
//

#include "compat.h"
#include "build.h"
#include "baselayer.h"

#include "grpscan.h"

#ifdef _WIN32
# include "winbits.h"
# include <shlwapi.h>
# include <winnt.h>
# ifndef KEY_WOW64_32KEY
#  define KEY_WOW64_32KEY 0x0200
# endif
#elif defined __APPLE__
# include "osxbits.h"
#endif

#include "common.h"
#include "common_game.h"

int32_t g_gameType = GAMEFLAG_DUKE;

int32_t g_dependencyCRC = 0;
int32_t g_usingAddon = 0;

// g_gameNamePtr can point to one of: grpfiles[].name (string literal), string
// literal, malloc'd block (XXX: possible leak)
const char *g_gameNamePtr = NULL;

// grp/con handling

static const char *defaultgamegrp[GAMECOUNT] = { "DUKE3D.GRP", "NAM.GRP", "NAPALM.GRP", "WW2GI.GRP" };
static const char *defaultdeffilename[GAMECOUNT] = { "duke3d.def", "nam.def", "napalm.def", "ww2gi.def" };
static const char *defaultconfilename = "GAME.CON";
static const char *defaultgameconfilename[GAMECOUNT] = { "EDUKE.CON", "NAM.CON", "NAPALM.CON", "WW2GI.CON" };

// g_grpNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)
char *g_grpNamePtr = NULL;
// g_scriptNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)
char *g_scriptNamePtr = NULL;

void clearGrpNamePtr(void)
{
    if (g_grpNamePtr != NULL)
        Bfree(g_grpNamePtr);
    // g_grpNamePtr assumed to be assigned to right after
}

void clearScriptNamePtr(void)
{
    if (g_scriptNamePtr != NULL)
        Bfree(g_scriptNamePtr);
    // g_scriptNamePtr assumed to be assigned to right after
}

const char *G_DefaultGrpFile(void)
{
    if (DUKE)
        return defaultgamegrp[GAME_DUKE];
    // order is important for the following three because GAMEFLAG_NAM overlaps all
    else if (NAPALM)
        return defaultgamegrp[GAME_NAPALM];
    else if (WW2GI)
        return defaultgamegrp[GAME_WW2GI];
    else if (NAM)
        return defaultgamegrp[GAME_NAM];

    return defaultgamegrp[0];
}
const char *G_DefaultDefFile(void)
{
    if (DUKE)
        return defaultdeffilename[GAME_DUKE];
    else if (WW2GI)
        return defaultdeffilename[GAME_WW2GI];
    else if (NAPALM)
    {
        if (!testkopen(defaultdeffilename[GAME_NAPALM],0) && testkopen(defaultdeffilename[GAME_NAM],0))
            return defaultdeffilename[GAME_NAM]; // NAM/NAPALM Sharing
        else
            return defaultdeffilename[GAME_NAPALM];
    }
    else if (NAM)
    {
        if (!testkopen(defaultdeffilename[GAME_NAM],0) && testkopen(defaultdeffilename[GAME_NAPALM],0))
            return defaultdeffilename[GAME_NAPALM]; // NAM/NAPALM Sharing
        else
            return defaultdeffilename[GAME_NAM];
    }

    return defaultdeffilename[0];
}
const char *G_DefaultConFile(void)
{
    if (DUKE && testkopen(defaultgameconfilename[GAME_DUKE],0))
        return defaultgameconfilename[GAME_DUKE];
    else if (WW2GI && testkopen(defaultgameconfilename[GAME_WW2GI],0))
        return defaultgameconfilename[GAME_WW2GI];
    else if (NAPALM)
    {
        if (!testkopen(defaultgameconfilename[GAME_NAPALM],0))
        {
            if (testkopen(defaultgameconfilename[GAME_NAM],0))
                return defaultgameconfilename[GAME_NAM]; // NAM/NAPALM Sharing
        }
        else
            return defaultgameconfilename[GAME_NAPALM];
    }
    else if (NAM)
    {
        if (!testkopen(defaultgameconfilename[GAME_NAM],0))
        {
            if (testkopen(defaultgameconfilename[GAME_NAPALM],0))
                return defaultgameconfilename[GAME_NAPALM]; // NAM/NAPALM Sharing
        }
        else
            return defaultgameconfilename[GAME_NAM];
    }

    return defaultconfilename;
}

const char *G_GrpFile(void)
{
    if (g_grpNamePtr == NULL)
        return G_DefaultGrpFile();
    else
        return g_grpNamePtr;
}

const char *G_DefFile(void)
{
    if (g_defNamePtr == NULL)
        return G_DefaultDefFile();
    else
        return g_defNamePtr;
}

const char *G_ConFile(void)
{
    if (g_scriptNamePtr == NULL)
        return G_DefaultConFile();
    else
        return g_scriptNamePtr;
}

//////////

#define NUMPSKYMULTIS 5
EDUKE32_STATIC_ASSERT(NUMPSKYMULTIS <= MAXPSKYMULTIS);
EDUKE32_STATIC_ASSERT(PSKYOFF_MAX <= MAXPSKYTILES);

// Set up new-style multi-psky handling.
void G_InitMultiPsky(int32_t CLOUDYOCEAN__DYN, int32_t MOONSKY1__DYN, int32_t BIGORBIT1__DYN, int32_t LA__DYN)
{
    int32_t i;

    psky_t *defaultsky = &multipsky[0];
    psky_t *oceansky = &multipsky[1];
    psky_t *moonsky = &multipsky[2];
    psky_t *spacesky = &multipsky[3];
    psky_t *citysky = &multipsky[4];

    static int32_t inited;
    if (inited)
        return;
    inited = 1;

    multipskytile[0] = -1;
    multipskytile[1] = CLOUDYOCEAN__DYN;
    multipskytile[2] = MOONSKY1__DYN;
    multipskytile[3] = BIGORBIT1__DYN;
    multipskytile[4] = LA__DYN;

    pskynummultis = NUMPSKYMULTIS;

    // When adding other multi-skies, take care that the tileofs[] values are
    // <= PSKYOFF_MAX. (It can be increased up to MAXPSKYTILES, but should be
    // set as tight as possible.)

    // The default sky properties (all others are implicitly zero):
    defaultsky->lognumtiles = 3;
    defaultsky->horizfrac = 32768;

    // CLOUDYOCEAN
    // Aligns with the drawn scene horizon because it has one itself.
    oceansky->lognumtiles = 3;
    oceansky->horizfrac = 65536;

    // MOONSKY1
    //        earth          mountain   mountain         sun
    moonsky->lognumtiles = 3;
    moonsky->horizfrac = 32768;
    moonsky->tileofs[6] = 1;
    moonsky->tileofs[1] = 2;
    moonsky->tileofs[4] = 2;
    moonsky->tileofs[2] = 3;

    // BIGORBIT1   // orbit
    //       earth1         2           3           moon/sun
    spacesky->lognumtiles = 3;
    spacesky->horizfrac = 32768;
    spacesky->tileofs[5] = 1;
    spacesky->tileofs[6] = 2;
    spacesky->tileofs[7] = 3;
    spacesky->tileofs[2] = 4;

    // LA // la city
    //       earth1         2           3           moon/sun
    citysky->lognumtiles = 3;
    citysky->horizfrac = 16384+1024;
    citysky->tileofs[0] = 1;
    citysky->tileofs[1] = 2;
    citysky->tileofs[2] = 1;
    citysky->tileofs[3] = 3;
    citysky->tileofs[4] = 4;
    citysky->tileofs[5] = 0;
    citysky->tileofs[6] = 2;
    citysky->tileofs[7] = 3;

    for (i=0; i<pskynummultis; ++i)
    {
        int32_t j;
        for (j=0; j<(1<<multipsky[i].lognumtiles); ++j)
            Bassert(multipsky[i].tileofs[j] <= PSKYOFF_MAX);
    }
}

void G_SetupGlobalPsky(void)
{
    int32_t i, mskyidx=0;

    // NOTE: Loop must be running backwards for the same behavior as the game
    // (greatest sector index with matching parallaxed sky takes precedence).
    for (i=numsectors-1; i>=0; i--)
    {
        if (sector[i].ceilingstat & 1)
        {
            mskyidx = getpskyidx(sector[i].ceilingpicnum);
            if (mskyidx > 0)
                break;
        }
    }

    g_pskyidx = mskyidx;
}

//////////

static char g_rootDir[BMAX_PATH];
char g_modDir[BMAX_PATH] = "/";

int32_t kopen4loadfrommod(const char *filename, char searchfirst)
{
    int32_t r=-1;

    if (g_modDir[0]!='/' || g_modDir[1]!=0)
    {
        static char fn[BMAX_PATH];

        Bsnprintf(fn, sizeof(fn), "%s/%s",g_modDir,filename);
        r = kopen4load(fn,searchfirst);
    }

    if (r < 0)
        r = kopen4load(filename,searchfirst);

    return r;
}

int32_t usecwd;
static void G_LoadAddon(void);
int32_t g_groupFileHandle;

void G_ExtPreInit(int32_t argc,const char **argv)
{
    usecwd = G_CheckCmdSwitch(argc, argv, "-usecwd");

#ifdef _WIN32
    GetModuleFileName(NULL,g_rootDir,BMAX_PATH);
    Bcorrectfilename(g_rootDir,1);
    //chdir(g_rootDir);
#else
    getcwd(g_rootDir,BMAX_PATH);
    strcat(g_rootDir,"/");
#endif
}

void G_ExtInit(void)
{
    char cwd[BMAX_PATH];

#ifdef EDUKE32_OSX
    char *appdir = Bgetappdir();
    addsearchpath(appdir);
    Bfree(appdir);
#endif

    if (getcwd(cwd,BMAX_PATH) && Bstrcmp(cwd,"/") != 0)
        addsearchpath(cwd);

    if (CommandPaths)
    {
        int32_t i;
        struct strllist *s;
        while (CommandPaths)
        {
            s = CommandPaths->next;
            i = addsearchpath(CommandPaths->str);
            if (i < 0)
            {
                initprintf("Failed adding %s for game data: %s\n", CommandPaths->str,
                           i==-1 ? "not a directory" : "no such directory");
            }

            Bfree(CommandPaths->str);
            Bfree(CommandPaths);
            CommandPaths = s;
        }
    }

#if defined(_WIN32)
    if (!access("user_profiles_enabled", F_OK))
#else
    if (usecwd == 0 && access("user_profiles_disabled", F_OK))
#endif
    {
        char *homedir;
        int32_t asperr;

        if ((homedir = Bgethomedir()))
        {
            Bsnprintf(cwd,sizeof(cwd),"%s/"
#if defined(_WIN32)
                      "EDuke32 Settings"
#elif defined(GEKKO)
                      "apps/eduke32"
#else
                      ".eduke32"
#endif
                      ,homedir);
            asperr = addsearchpath(cwd);
            if (asperr == -2)
            {
                if (Bmkdir(cwd,S_IRWXU) == 0) asperr = addsearchpath(cwd);
                else asperr = -1;
            }
            if (asperr == 0)
                Bchdir(cwd);
            Bfree(homedir);
        }
    }

    // JBF 20031220: Because it's annoying renaming GRP files whenever I want to test different game data
    if (g_grpNamePtr == NULL)
    {
        const char *cp = getenv("DUKE3DGRP");
        if (cp)
        {
            clearGrpNamePtr();
            g_grpNamePtr = dup_filename(cp);
            initprintf("Using \"%s\" as main GRP file\n", g_grpNamePtr);
        }
    }
}

void G_ScanGroups(void)
{
    ScanGroups();

    // try and identify the 'defaultgamegrp' in the set of GRPs.
    // if it is found, set up the environment accordingly for the game it represents.
    // if it is not found, choose the first GRP from the list
    struct grpfile *fg, *first = NULL;

    for (fg = foundgrps; fg; fg=fg->next)
    {
        struct grpfile *grp;
        for (grp = listgrps; grp; grp=grp->next)
            if (fg->crcval == grp->crcval) break;

        if (grp == NULL)
            continue;

        fg->game = grp->game;
        if (!first) first = fg;
        if (!Bstrcasecmp(fg->name, G_DefaultGrpFile()))
        {
            g_gameType = grp->game;
            g_gameNamePtr = grp->name;
            break;
        }
    }
    if (!fg && first)
    {
        if (g_grpNamePtr == NULL)
        {
            clearGrpNamePtr();
            g_grpNamePtr = dup_filename(first->name);
        }
        g_gameType = first->game;
        g_gameNamePtr = listgrps->name;
    }
    else if (!fg) g_gameNamePtr = NULL;
}

void G_LoadGroups(int32_t autoload)
{
    if (g_modDir[0] != '/')
    {
        char cwd[BMAX_PATH];

        Bstrcat(g_rootDir, g_modDir);
        addsearchpath(g_rootDir);
        //        addsearchpath(mod_dir);

        if (getcwd(cwd, BMAX_PATH))
        {
            Bsprintf(cwd, "%s/%s", cwd, g_modDir);
            if (!Bstrcmp(g_rootDir, cwd))
            {
                if (addsearchpath(cwd) == -2)
                    if (Bmkdir(cwd, S_IRWXU) == 0)
                        addsearchpath(cwd);
            }
        }

#ifdef USE_OPENGL
        Bsprintf(cwd, "%s/%s", g_modDir, TEXCACHEFILE);
        Bstrcpy(TEXCACHEFILE, cwd);
#endif
    }

    if (g_usingAddon)
        G_LoadAddon();

    int32_t i;
    const char *grpfile = G_GrpFile();

    if (g_dependencyCRC)
    {
        struct grpfile *grp = FindGroup(g_dependencyCRC);
        if (grp)
        {
            if ((i = initgroupfile(grp->name)) == -1)
                initprintf("Warning: could not find main data file \"%s\"!\n", grp->name);
            else
                initprintf("Using \"%s\" as main game data file.\n", grp->name);
        }
    }

    if ((i = initgroupfile(grpfile)) == -1)
        initprintf("Warning: could not find main data file \"%s\"!\n", grpfile);
    else
        initprintf("Using \"%s\" as main game data file.\n", grpfile);

    if (autoload)
    {
        G_LoadGroupsInDir("autoload");

        if (i != -1)
            G_DoAutoload(grpfile);
    }

    if (g_modDir[0] != '/')
        G_LoadGroupsInDir(g_modDir);

    if (g_defNamePtr == NULL)
    {
        const char *tmpptr = getenv("DUKE3DDEF");
        if (tmpptr)
        {
            clearDefNamePtr();
            g_defNamePtr = dup_filename(tmpptr);
            initprintf("Using \"%s\" as definitions file\n", g_defNamePtr);
        }
    }

    loaddefinitions_game(G_DefFile(), TRUE);

    struct strllist *s;

    pathsearchmode = 1;
    while (CommandGrps)
    {
        int32_t j;

        s = CommandGrps->next;

        if ((j = initgroupfile(CommandGrps->str)) == -1)
            initprintf("Could not find file \"%s\".\n", CommandGrps->str);
        else
        {
            g_groupFileHandle = j;
            initprintf("Using file \"%s\" as game data.\n", CommandGrps->str);
            if (autoload)
                G_DoAutoload(CommandGrps->str);
        }

        Bfree(CommandGrps->str);
        Bfree(CommandGrps);
        CommandGrps = s;
    }
    pathsearchmode = 0;
}

#ifdef _WIN32
const char * G_GetInstallPath(int32_t insttype)
{
    static char spath[NUMINSTPATHS][BMAX_PATH];
    static int32_t success[NUMINSTPATHS] = { -1, -1, -1, -1, -1 };
    int32_t siz = BMAX_PATH;

    if (success[insttype] == -1)
    {
        HKEY HKLM32;
        LONG keygood = RegOpenKeyEx(HKEY_LOCAL_MACHINE, NULL, 0, KEY_READ | KEY_WOW64_32KEY, &HKLM32);
        // KEY_WOW64_32KEY gets us around Wow6432Node on 64-bit builds

        if (keygood == ERROR_SUCCESS)
        {
            switch (insttype)
            {
            case INSTPATH_STEAM_DUKE3D:
                success[insttype] = SHGetValueA(HKLM32, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 225140", "InstallLocation", NULL, spath[insttype], (LPDWORD)&siz);
                break;
            case INSTPATH_GOG_DUKE3D:
                success[insttype] = SHGetValueA(HKLM32, "SOFTWARE\\GOG.com\\GOGDUKE3D", "PATH", NULL, spath[insttype], (LPDWORD)&siz);
                break;
            case INSTPATH_3DR_DUKE3D:
                success[insttype] = SHGetValueA(HKLM32, "SOFTWARE\\3DRealms\\Duke Nukem 3D", NULL, NULL, spath[insttype], (LPDWORD)&siz);
                break;
            case INSTPATH_3DR_ANTH:
                success[insttype] = SHGetValueA(HKLM32, "SOFTWARE\\3DRealms\\Anthology", NULL, NULL, spath[insttype], (LPDWORD)&siz);
                break;
            case INSTPATH_STEAM_NAM:
                success[insttype] = SHGetValueA(HKLM32, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Uninstall\\Steam App 329650", "InstallLocation", NULL, spath[insttype], (LPDWORD)&siz);
                break;
            }

            RegCloseKey(HKLM32);
        }
    }

    if (success[insttype] == ERROR_SUCCESS)
        return spath[insttype];

    return NULL;
}
#endif

static void G_LoadAddon(void)
{
    struct grpfile * grp;
    int32_t crc = 0;  // compiler-happy

    switch (g_usingAddon)
    {
    case ADDON_DUKEDC:
        crc = DUKEDC_CRC;
        break;
    case ADDON_NWINTER:
        crc = DUKENW_CRC;
        break;
    case ADDON_CARIBBEAN:
        crc = DUKECB_CRC;
        break;
    }

    if (!crc) return;

    grp = FindGroup(crc);

    if (grp && FindGroup(DUKE15_CRC))
    {
        clearGrpNamePtr();
        g_grpNamePtr = dup_filename(FindGroup(DUKE15_CRC)->name);

        G_AddGroup(grp->name);

        for (grp = listgrps; grp; grp=grp->next)
            if (crc == grp->crcval) break;

        if (grp != NULL && grp->scriptname)
        {
            clearScriptNamePtr();
            g_scriptNamePtr = dup_filename(grp->scriptname);
        }

        if (grp != NULL && grp->defname)
        {
            clearDefNamePtr();
            g_defNamePtr = dup_filename(grp->defname);
        }
    }
}

#if defined EDUKE32_OSX || defined __linux__ || defined EDUKE32_BSD
static void G_AddSteamPaths(const char *basepath)
{
    char buf[BMAX_PATH];

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot", basepath);
    addsearchpath_user(buf, SEARCHPATH_REMOVE);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/addons/dc", basepath);
    addsearchpath_user(buf, SEARCHPATH_REMOVE);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/addons/nw", basepath);
    addsearchpath_user(buf, SEARCHPATH_REMOVE);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/addons/vacation", basepath);
    addsearchpath_user(buf, SEARCHPATH_REMOVE);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/music", basepath);
    addsearchpath(buf);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/music/nwinter", basepath);
    addsearchpath_user(buf, SEARCHPATH_NWINTER);

    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Duke Nukem 3D/gameroot/music/vacation", basepath);
    addsearchpath(buf);

#if defined EDUKE32_OSX
    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Nam/Nam.app/Contents/Resources/Nam.boxer/C.harddisk/NAM", basepath);
#else
    Bsnprintf(buf, sizeof(buf), "%s/steamapps/common/Nam/NAM", basepath);
#endif
    addsearchpath_user(buf, SEARCHPATH_NAM);
}

// A bare-bones "parser" for Valve's KeyValues VDF format.
// There is no guarantee this will function properly with ill-formed files.
static void KeyValues_SkipWhitespace(char **vdfbuf, char * const vdfbufend)
{
    while (((*vdfbuf)[0] == ' ' || (*vdfbuf)[0] == '\n' || (*vdfbuf)[0] == '\r' || (*vdfbuf)[0] == '\t' || (*vdfbuf)[0] == '\0') && *vdfbuf < vdfbufend)
        (*vdfbuf)++;

    // comments
    if ((*vdfbuf) + 2 < vdfbufend && (*vdfbuf)[0] == '/' && (*vdfbuf)[1] == '/')
    {
        while ((*vdfbuf)[0] != '\n' && (*vdfbuf)[0] != '\r' && *vdfbuf < vdfbufend)
            (*vdfbuf)++;

        KeyValues_SkipWhitespace(vdfbuf, vdfbufend);
    }
}
static void KeyValues_SkipToEndOfQuotedToken(char **vdfbuf, char * const vdfbufend)
{
    (*vdfbuf)++;
    while ((*vdfbuf)[0] != '\"' && (*vdfbuf)[-1] != '\\' && *vdfbuf < vdfbufend)
        (*vdfbuf)++;
}
static void KeyValues_SkipToEndOfUnquotedToken(char **vdfbuf, char * const vdfbufend)
{
    while ((*vdfbuf)[0] != ' ' && (*vdfbuf)[0] != '\n' && (*vdfbuf)[0] != '\r' && (*vdfbuf)[0] != '\t' && (*vdfbuf)[0] != '\0' && *vdfbuf < vdfbufend)
        (*vdfbuf)++;
}
static void KeyValues_SkipNextWhatever(char **vdfbuf, char * const vdfbufend)
{
    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);

    if (*vdfbuf == vdfbufend)
        return;

    if ((*vdfbuf)[0] == '{')
    {
        (*vdfbuf)++;
        do
        {
            KeyValues_SkipNextWhatever(vdfbuf, vdfbufend);
        }
        while ((*vdfbuf)[0] != '}');
        (*vdfbuf)++;
    }
    else if ((*vdfbuf)[0] == '\"')
        KeyValues_SkipToEndOfQuotedToken(vdfbuf, vdfbufend);
    else if ((*vdfbuf)[0] != '}')
        KeyValues_SkipToEndOfUnquotedToken(vdfbuf, vdfbufend);

    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);
}
static char* KeyValues_NormalizeToken(char **vdfbuf, char * const vdfbufend)
{
    char *token = *vdfbuf;

    if ((*vdfbuf)[0] == '\"' && *vdfbuf < vdfbufend)
    {
        token++;

        KeyValues_SkipToEndOfQuotedToken(vdfbuf, vdfbufend);
        (*vdfbuf)[0] = '\0';

        // account for escape sequences
        char *writeseeker = token, *readseeker = token;
        while (readseeker <= *vdfbuf)
        {
            if (readseeker[0] == '\\')
                readseeker++;

            writeseeker[0] = readseeker[0];

            writeseeker++;
            readseeker++;
        }

        return token;
    }

    KeyValues_SkipToEndOfUnquotedToken(vdfbuf, vdfbufend);
    (*vdfbuf)[0] = '\0';

    return token;
}
static void KeyValues_FindKey(char **vdfbuf, char * const vdfbufend, const char *token)
{
    char *ParentKey = KeyValues_NormalizeToken(vdfbuf, vdfbufend);
    if (token != NULL) // pass in NULL to find the next key instead of a specific one
        while (Bstrcmp(ParentKey, token) != 0 && *vdfbuf < vdfbufend)
        {
            KeyValues_SkipNextWhatever(vdfbuf, vdfbufend);
            ParentKey = KeyValues_NormalizeToken(vdfbuf, vdfbufend);
        }

    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);
}
static int32_t KeyValues_FindParentKey(char **vdfbuf, char * const vdfbufend, const char *token)
{
    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);

    // end of scope
    if ((*vdfbuf)[0] == '}')
        return 0;

    KeyValues_FindKey(vdfbuf, vdfbufend, token);

    // ignore the wrong type
    while ((*vdfbuf)[0] != '{' && *vdfbuf < vdfbufend)
    {
        KeyValues_SkipNextWhatever(vdfbuf, vdfbufend);
        KeyValues_FindKey(vdfbuf, vdfbufend, token);
    }

    if (*vdfbuf == vdfbufend)
        return 0;

    return 1;
}
static char* KeyValues_FindKeyValue(char **vdfbuf, char * const vdfbufend, const char *token)
{
    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);

    // end of scope
    if ((*vdfbuf)[0] == '}')
        return NULL;

    KeyValues_FindKey(vdfbuf, vdfbufend, token);

    // ignore the wrong type
    while ((*vdfbuf)[0] == '{' && *vdfbuf < vdfbufend)
    {
        KeyValues_SkipNextWhatever(vdfbuf, vdfbufend);
        KeyValues_FindKey(vdfbuf, vdfbufend, token);
    }

    KeyValues_SkipWhitespace(vdfbuf, vdfbufend);

    if (*vdfbuf == vdfbufend)
        return NULL;

    return KeyValues_NormalizeToken(vdfbuf, vdfbufend);
}

static void G_ParseSteamKeyValuesForPaths(const char *vdf)
{
    int32_t fd = Bopen(vdf, BO_RDONLY);
    int32_t size = Bfilelength(fd);
    char *vdfbufstart, *vdfbuf, *vdfbufend;

    if (size <= 0)
        return;

    vdfbufstart = vdfbuf = (char*)Bmalloc(size);
    size = (int32_t)Bread(fd, vdfbuf, size);
    Bclose(fd);
    vdfbufend = vdfbuf + size;

    if (KeyValues_FindParentKey(&vdfbuf, vdfbufend, "LibraryFolders"))
    {
        char *result;
        vdfbuf++;
        while ((result = KeyValues_FindKeyValue(&vdfbuf, vdfbufend, NULL)) != NULL)
            G_AddSteamPaths(result);
    }

    Bfree(vdfbufstart);
}
#endif

void G_AddSearchPaths(void)
{
#if defined __linux__ || defined EDUKE32_BSD
    char buf[BMAX_PATH];
    char *homepath = Bgethomedir();

    Bsnprintf(buf, sizeof(buf), "%s/.steam/steam", homepath);
    G_AddSteamPaths(buf);

    Bsnprintf(buf, sizeof(buf), "%s/.steam/steam/steamapps/libraryfolders.vdf", homepath);
    G_ParseSteamKeyValuesForPaths(buf);

    Bfree(homepath);

    addsearchpath("/usr/share/games/jfduke3d");
    addsearchpath("/usr/local/share/games/jfduke3d");
    addsearchpath("/usr/share/games/eduke32");
    addsearchpath("/usr/local/share/games/eduke32");
#elif defined EDUKE32_OSX
    char buf[BMAX_PATH];
    int32_t i;
    char *applications[] = { osx_getapplicationsdir(0), osx_getapplicationsdir(1) };
    char *support[] = { osx_getsupportdir(0), osx_getsupportdir(1) };

    for (i = 0; i < 2; i++)
    {
        Bsnprintf(buf, sizeof(buf), "%s/Steam", support[i]);
        G_AddSteamPaths(buf);

        Bsnprintf(buf, sizeof(buf), "%s/Steam/steamapps/libraryfolders.vdf", support[i]);
        G_ParseSteamKeyValuesForPaths(buf);

        Bsnprintf(buf, sizeof(buf), "%s/Duke Nukem 3D.app/Contents/Resources/Duke Nukem 3D.boxer/C.harddisk", applications[i]);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);
    }

    for (i = 0; i < 2; i++)
    {
        Bsnprintf(buf, sizeof(buf), "%s/JFDuke3D", support[i]);
        addsearchpath(buf);
        Bsnprintf(buf, sizeof(buf), "%s/EDuke32", support[i]);
        addsearchpath(buf);
    }

    for (i = 0; i < 2; i++)
    {
        Bfree(applications[i]);
        Bfree(support[i]);
    }
#elif defined (_WIN32)
    char buf[BMAX_PATH];
    const char* instpath;

    if ((instpath = G_GetInstallPath(INSTPATH_STEAM_DUKE3D)))
    {
        Bsnprintf(buf, sizeof(buf), "%s/gameroot", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/addons/dc", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/addons/nw", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/addons/vacation", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/music", instpath);
        addsearchpath(buf);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/music/nwinter", instpath);
        addsearchpath_user(buf, SEARCHPATH_NWINTER);

        Bsnprintf(buf, sizeof(buf), "%s/gameroot/music/vacation", instpath);
        addsearchpath(buf);
    }

    if ((instpath = G_GetInstallPath(INSTPATH_GOG_DUKE3D)))
        addsearchpath_user(instpath, SEARCHPATH_REMOVE);

    if ((instpath = G_GetInstallPath(INSTPATH_3DR_DUKE3D)))
    {
        Bsnprintf(buf, sizeof(buf), "%s/Duke Nukem 3D", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);
    }

    if ((instpath = G_GetInstallPath(INSTPATH_3DR_ANTH)))
    {
        Bsnprintf(buf, sizeof(buf), "%s/Duke Nukem 3D", instpath);
        addsearchpath_user(buf, SEARCHPATH_REMOVE);
    }

    if ((instpath = G_GetInstallPath(INSTPATH_STEAM_NAM)))
    {
        Bsnprintf(buf, sizeof(buf), "%s/NAM", instpath);
        addsearchpath_user(buf, SEARCHPATH_NAM);
    }
#endif
}

void G_CleanupSearchPaths(void)
{
    removesearchpaths_withuser(SEARCHPATH_REMOVE);

    if (!(NAM || NAPALM))
        removesearchpaths_withuser(SEARCHPATH_NAM);

    if (!(NWINTER))
        removesearchpaths_withuser(SEARCHPATH_NWINTER);
}

//////////

struct strllist *CommandPaths, *CommandGrps;

char **g_scriptModules = NULL;
int32_t g_scriptModulesNum = 0;

void G_AddGroup(const char *buffer)
{
    char buf[BMAX_PATH];

    struct strllist *s = (struct strllist *)Xcalloc(1,sizeof(struct strllist));

    Bstrcpy(buf, buffer);

    if (Bstrchr(buf,'.') == 0)
        Bstrcat(buf,".grp");

    s->str = Xstrdup(buf);

    if (CommandGrps)
    {
        struct strllist *t;
        for (t = CommandGrps; t->next; t=t->next) ;
        t->next = s;
        return;
    }
    CommandGrps = s;
}

void G_AddPath(const char *buffer)
{
    struct strllist *s = (struct strllist *)Xcalloc(1,sizeof(struct strllist));
    s->str = Xstrdup(buffer);

    if (CommandPaths)
    {
        struct strllist *t;
        for (t = CommandPaths; t->next; t=t->next) ;
        t->next = s;
        return;
    }
    CommandPaths = s;
}

void G_AddCon(const char *buffer)
{
    clearScriptNamePtr();
    g_scriptNamePtr = dup_filename(buffer);
    initprintf("Using CON file \"%s\".\n",g_scriptNamePtr);
}

void G_AddConModule(const char *buffer)
{
    g_scriptModules = (char **) Xrealloc (g_scriptModules, (g_scriptModulesNum+1) * sizeof(char *));
    g_scriptModules[g_scriptModulesNum] = Xstrdup(buffer);
    ++g_scriptModulesNum;
}

//////////

// loads all group (grp, zip, pk3/4) files in the given directory
void G_LoadGroupsInDir(const char *dirname)
{
    static const char *extensions[4] = { "*.grp", "*.zip", "*.pk3", "*.pk4" };

    char buf[BMAX_PATH];
    int32_t i;

    fnlist_t fnlist = FNLIST_INITIALIZER;

    for (i=0; i<4; i++)
    {
        CACHE1D_FIND_REC *rec;

        fnlist_getnames(&fnlist, dirname, extensions[i], -1, 0);

        for (rec=fnlist.findfiles; rec; rec=rec->next)
        {
            Bsnprintf(buf, sizeof(buf), "%s/%s", dirname, rec->name);
            initprintf("Using group file \"%s\".\n", buf);
            initgroupfile(buf);
        }

        fnlist_clearnames(&fnlist);
    }
}

void G_DoAutoload(const char *dirname)
{
    char buf[BMAX_PATH];

    Bsnprintf(buf, sizeof(buf), "autoload/%s", dirname);
    G_LoadGroupsInDir(buf);
}

//////////

static uint8_t water_pal[768], slime_pal[768], title_pal[768], dre_alms[768], ending_pal[768];

uint8_t *basepaltable[BASEPALCOUNT] = {
    palette, water_pal, slime_pal,
    dre_alms, title_pal, ending_pal,
    NULL /*anim_pal*/
};

int32_t G_LoadLookups(void)
{
    int32_t fp, j;

    if ((fp=kopen4loadfrommod("lookup.dat",0)) == -1)
    {
        if ((fp=kopen4loadfrommod("lookup.dat",1)) == -1)
        {
            initprintf("ERROR: File \"lookup.dat\" not found.\n");
            return 1;
        }
    }

    j = loadlookups(fp);

    if (j < 0)
    {
        if (j == -1)
            initprintf("ERROR loading \"lookup.dat\": failed reading enough data.\n");
        return 1;
    }

    for (j=1; j<=5; j++)
    {
        // Account for TITLE and REALMS swap between basepal number and on-disk order.
        // XXX: this reordering is better off as an argument to us.
        int32_t basepalnum = (j == 3 || j == 4) ? 4+3-j : j;

        if (kread(fp, basepaltable[basepalnum], 768) != 768)
            return -1;
    }

    kclose(fp);

    generatefogpals();

    fillemptylookups();

    return 0;
}

#if defined HAVE_FLAC || defined HAVE_VORBIS
int32_t S_UpgradeFormat(const char *fn, char searchfirst)
{
    char *testfn, *extension;
    int32_t fp = -1;

    testfn = (char *)Xmalloc(Bstrlen(fn) + 6);
    Bstrcpy(testfn, fn);
    extension = Bstrrchr(testfn, '.');

    if (extension)
    {
#ifdef HAVE_FLAC
        Bstrcpy(extension, ".flac");
        fp = kopen4loadfrommod(testfn, searchfirst);
        if (fp >= 0)
        {
            Bfree(testfn);
            return fp;
        }
#endif

#ifdef HAVE_VORBIS
        Bstrcpy(extension, ".ogg");
        fp = kopen4loadfrommod(testfn, searchfirst);
        if (fp >= 0)
        {
            Bfree(testfn);
            return fp;
        }
#endif
    }

    Bfree(testfn);
    return -1;
}
#endif
 

Rev 5005	Rev 5037
1	//	1	//
2	// Common non-engine code/data for EDuke32 and Mapster32	2	// Common non-engine code/data for EDuke32 and Mapster32
3	//	3	//
4		4
5	#include "compat.h"	5	#include "compat.h"
6	#include "build.h"	6	#include "build.h"
7	#include "baselayer.h"	7	#include "baselayer.h"
8		8
9	#include "grpscan.h"	9	#include "grpscan.h"
10		10
11	#ifdef _WIN32	11	#ifdef _WIN32
12	# include "winbits.h"	12	# include "winbits.h"
13	# include <shlwapi.h>	13	# include <shlwapi.h>
14	# include <winnt.h>	14	# include <winnt.h>
15	# ifndef KEY_WOW64_32KEY	15	# ifndef KEY_WOW64_32KEY
16	# define KEY_WOW64_32KEY 0x0200	16	# define KEY_WOW64_32KEY 0x0200
17	# endif	17	# endif
18	#elif defined __APPLE__	18	#elif defined __APPLE__
19	# include "osxbits.h"	19	# include "osxbits.h"
20	#endif	20	#endif
21		21
22	#include "common.h"	22	#include "common.h"
23	#include "common_game.h"	23	#include "common_game.h"
24		24
25	int32_t g_gameType = GAMEFLAG_DUKE;	25	int32_t g_gameType = GAMEFLAG_DUKE;
26		26
27	int32_t g_dependencyCRC = 0;	27	int32_t g_dependencyCRC = 0;
28	int32_t g_usingAddon = 0;	28	int32_t g_usingAddon = 0;
29		29
30	// g_gameNamePtr can point to one of: grpfiles[].name (string literal), string	30	// g_gameNamePtr can point to one of: grpfiles[].name (string literal), string
31	// literal, malloc'd block (XXX: possible leak)	31	// literal, malloc'd block (XXX: possible leak)
32	const char *g_gameNamePtr = NULL;	32	const char *g_gameNamePtr = NULL;
33		33
34	// grp/con handling	34	// grp/con handling
35		35
36	static const char *defaultgamegrp[GAMECOUNT] = { "DUKE3D.GRP", "NAM.GRP", "NAPALM.GRP", "WW2GI.GRP" };	36	static const char *defaultgamegrp[GAMECOUNT] = { "DUKE3D.GRP", "NAM.GRP", "NAPALM.GRP", "WW2GI.GRP" };
37	static const char *defaultdeffilename[GAMECOUNT] = { "duke3d.def", "nam.def", "napalm.def", "ww2gi.def" };	37	static const char *defaultdeffilename[GAMECOUNT] = { "duke3d.def", "nam.def", "napalm.def", "ww2gi.def" };
38	static const char *defaultconfilename = "GAME.CON";	38	static const char *defaultconfilename = "GAME.CON";
39	static const char *defaultgameconfilename[GAMECOUNT] = { "EDUKE.CON", "NAM.CON", "NAPALM.CON", "WW2GI.CON" };	39	static const char *defaultgameconfilename[GAMECOUNT] = { "EDUKE.CON", "NAM.CON", "NAPALM.CON", "WW2GI.CON" };
40		40
41	// g_grpNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)	41	// g_grpNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)
42	char *g_grpNamePtr = NULL;	42	char *g_grpNamePtr = NULL;
43	// g_scriptNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)	43	// g_scriptNamePtr can ONLY point to a malloc'd block (length BMAX_PATH)
44	char *g_scriptNamePtr = NULL;	44	char *g_scriptNamePtr = NULL;
45		45
46	void clearGrpNamePtr(void)	46	void clearGrpNamePtr(void)
47	{	47	{
48	if (g_grpNamePtr != NULL)	48	if (g_grpNamePtr != NULL)
49	Bfree(g_grpNamePtr);	49	Bfree(g_grpNamePtr);
50	// g_grpNamePtr assumed to be assigned to right after	50	// g_grpNamePtr assumed to be assigned to right after
51	}	51	}
52		52
53	void clearScriptNamePtr(void)	53	void clearScriptNamePtr(void)
54	{	54	{
55	if (g_scriptNamePtr != NULL)	55	if (g_scriptNamePtr != NULL)
56	Bfree(g_scriptNamePtr);	56	Bfree(g_scriptNamePtr);
57	// g_scriptNamePtr assumed to be assigned to right after	57	// g_scriptNamePtr assumed to be assigned to right after
58	}	58	}
59		59
60	const char *G_DefaultGrpFile(void)	60	const char *G_DefaultGrpFile(void)
61	{	61	{
62	if (DUKE)	62	if (DUKE)
63	return defaultgamegrp[GAME_DUKE];	63	return defaultgamegrp[GAME_DUKE];
64	// order is important for the following three because GAMEFLAG_NAM overlaps all	64	// order is important for the following three because GAMEFLAG_NAM overlaps all
65	else if (NAPALM)	65	else if (NAPALM)
66	return defaultgamegrp[GAME_NAPALM];	66	return defaultgamegrp[GAME_NAPALM];
67	else if (WW2GI)	67	else if (WW2GI)
68	return defaultgamegrp[GAME_WW2GI];	68	return defaultgamegrp[GAME_WW2GI];
69	else if (NAM)	69	else if (NAM)
70	return defaultgamegrp[GAME_NAM];	70	return defaultgamegrp[GAME_NAM];
71		71
72	return defaultgamegrp[0];	72	return defaultgamegrp[0];
73	}	73	}
74	const char *G_DefaultDefFile(void)	74	const char *G_DefaultDefFile(void)
75	{	75	{
76	if (DUKE)	76	if (DUKE)
77	return defaultdeffilename[GAME_DUKE];	77	return defaultdeffilename[GAME_DUKE];
78	else if (WW2GI)	78	else if (WW2GI)
79	return defaultdeffilename[GAME_WW2GI];	79	return defaultdeffilename[GAME_WW2GI];
80	else if (NAPALM)	80	else if (NAPALM)
81	{	81	{
82	if (!testkopen(defaultdeffilename[GAME_NAPALM],0) && testkopen(defaultdeffilename[GAME_NAM],0))	82	if (!testkopen(defaultdeffilename[GAME_NAPALM],0) && testkopen(defaultdeffilename[GAME_NAM],0))
83	return defaultdeffilename[GAME_NAM]; // NAM/NAPALM Sharing	83	return defaultdeffilename[GAME_NAM]; // NAM/NAPALM Sharing
84	else	84	else
85	return defaultdeffilename[GAME_NAPALM];	85	return defaultdeffilename[GAME_NAPALM];
86	}	86	}
87	else if (NAM)	87	else if (NAM)
88	{	88	{
89	if (!testkopen(defaultdeffilename[GAME_NAM],0) && testkopen(defaultdeffilename[GAME_NAPALM],0))	89	if (!testkopen(defaultdeffilename[GAME_NAM],0) && testkopen(defaultdeffilename[GAME_NAPALM],0))
90	return defaultdeffilename[GAME_NAPALM]; // NAM/NAPALM Sharing	90	return defaultdeffilename[GAME_NAPALM]; // NAM/NAPALM Sharing
91	else	91	else
92	return defaultdeffilename[GAME_NAM];	92	return defaultdeffilename[GAME_NAM];
93	}	93	}
94		94
95	return defaultdeffilename[0];	95	return defaultdeffilename[0];
96	}	96	}
97	const char *G_DefaultConFile(void)	97	const char *G_DefaultConFile(void)
98	{	98	{
99	if (DUKE && testkopen(defaultgameconfilename[GAME_DUKE],0))	99	if (DUKE && testkopen(defaultgameconfilename[GAME_DUKE],0))
100	return defaultgameconfilename[GAME_DUKE];	100	return defaultgameconfilename[GAME_DUKE];
101	else if (WW2GI && testkopen(defaultgameconfilename[GAME_WW2GI],0))	101	else if (WW2GI && testkopen(defaultgameconfilename[GAME_WW2GI],0))
102	return defaultgameconfilename[GAME_WW2GI];	102	return defaultgameconfilename[GAME_WW2GI];
103	else if (NAPALM)	103	else if (NAPALM)
104	{	104	{
105	if (!testkopen(defaultgameconfilename[GAME_NAPALM],0))	105	if (!testkopen(defaultgameconfilename[GAME_NAPALM],0))
106	{	106	{
107	if (testkopen(defaultgameconfilename[GAME_NAM],0))	107	if (testkopen(defaultgameconfilename[GAME_NAM],0))
108	return defaultgameconfilename[GAME_NAM]; // NAM/NAPALM Sharing	108	return defaultgameconfilename[GAME_NAM]; // NAM/NAPALM Sharing
109	}	109	}
110	else	110	else
111	return defaultgameconfilename[GAME_NAPALM];	111	return defaultgameconfilename[GAME_NAPALM];
112	}	112	}
113	else if (NAM)	113	else if (NAM)
114	{	114	{
115	if (!testkopen(defaultgameconfilename[GAME_NAM],0))	115	if (!testkopen(defaultgameconfilename[GAME_NAM],0))
116	{	116	{
117	if (testkopen(defaultgameconfilename[GAME_NAPALM],0))	117	if (testkopen(defaultgameconfilename[GAME_NAPALM],0))
118	return defaultgameconfilename[GAME_NAPALM]; // NAM/NAPALM Sharing	118	return defaultgameconfilename[GAME_NAPALM]; // NAM/NAPALM Sharing
119	}	119	}
120	else	120	else
121	return defaultgameconfilename[GAME_NAM];	121	return defaultgameconfilename[GAME_NAM];
122	}	122	}
123		123
124	return defaultconfilename;	124	return defaultconfilename;
125	}	125	}
126		126
127	const char *G_GrpFile(void)	127	const char *G_GrpFile(void)
128	{	128	{
129	if (g_grpNamePtr == NULL)	129	if (g_grpNamePtr == NULL)
130	return G_DefaultGrpFile();	130	return G_DefaultGrpFile();
131	else	131	else
132	return g_grpNamePtr;	132	return g_grpNamePtr;
133	}	133	}
134		134
135	const char *G_DefFile(void)	135	const char *G_DefFile(void)
136	{	136	{
137	if (g_defNamePtr == NULL)	137	if (g_defNamePtr == NULL)
138	return G_DefaultDefFile();	138	return G_DefaultDefFile();
139	else	139	else
140	return g_defNamePtr;	140	return g_defNamePtr;
141	}	141	}
142		142
143	const char *G_ConFile(void)	143	const char *G_ConFile(void)
144	{	144	{
145	if (g_scriptNamePtr == NULL)	145	if (g_scriptNamePtr == NULL)
146	return G_DefaultConFile();	146	return G_DefaultConFile();
147	else	147	else
148	return g_scriptNamePtr;	148	return g_scriptNamePtr;
149	}	149	}
150		150
151	//////////	151	//////////
152		152
153	#define NUMPSKYMULTIS 5	153	#define NUMPSKYMULTIS 5
154	EDUKE32_STATIC_ASSERT(NUMPSKYMULTIS <= MAXPSKYMULTIS);	154	EDUKE32_STATIC_ASSERT(NUMPSKYMULTIS <= MAXPSKYMULTIS);
155	EDUKE32_STATIC_ASSERT(PSKYOFF_MAX <= MAXPSKYTILES);	155	EDUKE32_STATIC_ASSERT(PSKYOFF_MAX <= MAXPSKYTILES);
156		156
157	// Set up new-style multi-psky handling.	157	// Set up new-style multi-psky handling.
158	void G_InitMultiPsky(int32_t CLOUDYOCEAN__DYN, int32_t MOONSKY1__DYN, int32_t BIGORBIT1__DYN, int32_t LA__DYN)	158	void G_InitMultiPsky(int32_t CLOUDYOCEAN__DYN, int32_t MOONSKY1__DYN, int32_t BIGORBIT1__DYN, int32_t LA__DYN)
159	{	159	{
160	int32_t i;	160	int32_t i;
161		161
162	psky_t *defaultsky = &multipsky[0];	162	psky_t *defaultsky = &multipsky[0];
163	psky_t *oceansky = &multipsky[1];	163	psky_t *oceansky = &multipsky[1];
164	psky_t *moonsky = &multipsky[2];	164	psky_t *moonsky = &multipsky[2];
165	psky_t *spacesky = &multipsky[3];	165	psky_t *spacesky = &multipsky[3];
166	psky_t *citysky = &multipsky[4];	166	psky_t *citysky = &multipsky[4];
167		167
168	static int32_t inited;	168	static int32_t inited;
169	if (inited)	169	if (inited)
170	return;	170	return;
171	inited = 1;	171	inited = 1;
172		172
173	multipskytile[0] = -1;	173	multipskytile[0] = -1;
174	multipskytile[1] = CLOUDYOCEAN__DYN;	174	multipskytile[1] = CLOUDYOCEAN__DYN;
175	multipskytile[2] = MOONSKY1__DYN;	175	multipskytile[2] = MOONSKY1__DYN;
176	multipskytile[3] = BIGORBIT1__DYN;	176	multipskytile[3] = BIGORBIT1__DYN;
177	multipskytile[4] = LA__DYN;	177	multipskytile[4] = LA__DYN;
178		178
179	pskynummultis = NUMPSKYMULTIS;	179	pskynummultis = NUMPSKYMULTIS;
180		180
181	// When adding other multi-skies, take care that the tileofs[] values are	181	// When adding other multi-skies, take care that the tileofs[] values are
182	// <= PSKYOFF_MAX. (It can be increased up to MAXPSKYTILES, but should be	182	// <= PSKYOFF_MAX. (It can be increased up to MAXPSKYTILES, but should be
183	// set as tight as possible.)	183	// set as tight as possible.)
184		184
185	// The default sky properties (all others are implicitly zero):	185	// The default sky properties (all others are implicitly zero):
186	defaultsky->lognumtiles = 3;	186	defaultsky->lognumtiles = 3;
187	defaultsky->horizfrac = 32768;	187	defaultsky->horizfrac = 32768;
188		188
189	// CLOUDYOCEAN	189	// CLOUDYOCEAN
190	// Aligns with the drawn scene horizon because it has one itself.	190	// Aligns with the drawn scene horizon because it has one itself.
191	oceansky->lognumtiles = 3;	191	oceansky->lognumtiles = 3;
192	oceansky->horizfrac = 65536;	192	oceansky->horizfrac = 65536;
193		193
194	// MOONSKY1	194	// MOONSKY1
195	// earth mountain mountain sun	195	// earth mountain mountain sun
196	moonsky->lognumtiles = 3;	196	moonsky->lognumtiles = 3;
197	moonsky->horizfrac = 32768;	197	moonsky->horizfrac = 32768;
198	moonsky->tileofs[6] = 1;	198	moonsky->tileofs[6] = 1;
199	moonsky->tileofs[1] = 2;	199	moonsky->tileofs[1] = 2;
200	moonsky->tileofs[4] = 2;	200	moonsky->tileofs[4] = 2;
201	moonsky->tileofs[2] = 3;	201	moonsky->tileofs[2] = 3;
202		202
203	// BIGORBIT1 // orbit	203	// BIGORBIT1 // orbit
204	// earth1 2 3 moon/sun	204	// earth1 2 3 moon/sun
205	spacesky->lognumtiles = 3;	205	spacesky->lognumtiles = 3;
206	spacesky->horizfrac = 32768;	206	spacesky->horizfrac = 32768;
207	spacesky->tileofs[5] = 1;	207	spacesky->tileofs[5] = 1;
208	spacesky->tileofs[6] = 2;	208	spacesky->tileofs[6] = 2;
209	spacesky->tileofs[7] = 3;	209	spacesky->tileofs[7] = 3;
210	spacesky->tileofs[2] = 4;	210	spacesky->tileofs[2] = 4;
211		211
212	// LA // la city	212	// LA // la city
213	// earth1 2 3 moon/sun	213	// earth1 2 3 moon/sun
214	citysky->lognumtiles = 3;	214	citysky->lognumtiles = 3;
215	citysky->horizfrac = 16384+1024;	215	citysky->horizfrac = 16384+1024;
216	citysky->tileofs[0] = 1;	216	citysky->tileofs[0] = 1;
217	citysky->tileofs[1] = 2;	217	citysky->tileofs[1] = 2;
218	citysky->tileofs[2] = 1;	218	citysky->tileofs[2] = 1;
219	citysky->tileofs[3] = 3;	219	citysky->tileofs[3] = 3;
220	citysky->tileofs[4] = 4;	220	citysky->tileofs[4] = 4;
221	citysky->tileofs[5] = 0;	221	citysky->tileofs[5] = 0;
222	citysky->tileofs[6] = 2;	222	citysky->tileofs[6] = 2;
223	citysky->tileofs[7] = 3;	223	citysky->tileofs[7] = 3;
224		224
225	for (i=0; i<pskynummultis; ++i)	225	for (i=0; i<pskynummultis; ++i)
226	{	226	{
227	int32_t j;	227	int32_t j;
228	for (j=0; j<(1<<multipsky[i].lognumtiles); ++j)	228	for (j=0; j<(1<<multipsky[i].lognumtiles); ++j)
229	Bassert(multipsky[i].tileofs[j] <= PSKYOFF_MAX);	229	Bassert(multipsky[i].tileofs[j] <= PSKYOFF_MAX);
230	}	230	}
231	}	231	}
232		232
233	void G_SetupGlobalPsky(void)	233	void G_SetupGlobalPsky(void)
234	{	234	{
235	int32_t i, mskyidx=0;	235	int32_t i, mskyidx=0;
236		236
237	// NOTE: Loop must be running backwards for the same behavior as the game	237	// NOTE: Loop must be running backwards for the same behavior as the game
238	// (greatest sector index with matching parallaxed sky takes precedence).	238	// (greatest sector index with matching parallaxed sky takes precedence).
239	for (i=numsectors-1; i>=0; i--)	239	for (i=numsectors-1; i>=0; i--)
240	{	240	{
241	if (sector[i].ceilingstat & 1)	241	if (sector[i].ceilingstat & 1)
242	{	242	{
243	mskyidx = getpskyidx(sector[i].ceilingpicnum);	243	mskyidx = getpskyidx(sector[i].ceilingpicnum);
244	if (mskyidx > 0)	244	if (mskyidx > 0)
245	break;	245	break;
246	}	246	}
247	}	247	}
248		248
249	g_pskyidx = mskyidx;	249	g_pskyidx = mskyidx;
250	}	250	}
251		251
252	//////////	252	//////////
253		253
254	static char g_rootDir[BMAX_PATH];	254	static char g_rootDir[BMAX_PATH];
255	char g_modDir[BMAX_PATH] = "/";	255	char g_modDir[BMAX_PATH] = "/";
256		256
257	int32_t kopen4loadfrommod(const char *filename, char searchfirst)	257	int32_t kopen4loadfrommod(const char *filename, char searchfirst)
258	{	258	{
259	int32_t r=-1;	259	int32_t r=-1;
260		260
261	if (g_modDir[0]!='/' \|\| g_modDir[1]!=0)	261	if (g_modDir[0]!='/' \|\| g_modDir[1]!=0)
262	{	262	{
263	static char fn[BMAX_PATH];	263	static char fn[BMAX_PATH];
264		264
265	Bsnprintf(fn, sizeof(fn), "%s/%s",g_modDir,filename);	265	Bsnprintf(fn, sizeof(fn), "%s/%s",g_modDir,filename);
266	r = kopen4load(fn,searchfirst);	266	r = kopen4load(fn,searchfirst);
267	}	267	}
268		268
269	if (r < 0)	269	if (r < 0)
270	r = kopen4load(filename,searchfirst);	270	r = kopen4load(filename,searchfirst);
271		271
272	return r;	272	return r;
273	}	273	}
274		274
275	int32_t usecwd;	275	int32_t usecwd;
276	static void G_LoadAddon(void);	276	static void G_LoadAddon(void);
277	int32_t g_groupFileHandle;	277	int32_t g_groupFileHandle;
278		278
279	void G_ExtPreInit(int32_t argc,const char **argv)	279	void G_ExtPreInit(int32_t argc,const char **argv)
280	{	280	{
281	usecwd = G_CheckCmdSwitch(argc, argv, "-usecwd");	281	usecwd = G_CheckCmdSwitch(argc, argv, "-usecwd");
282		282
283	#ifdef _WIN32	283	#ifdef _WIN32
284	GetModuleFileName(NULL,g_rootDir,BMAX_PATH);	284	GetModuleFileName(NULL,g_rootDir,BMAX_PATH);
285	Bcorrectfilename(g_rootDir,1);	285	Bcorrectfilename(g_rootDir,1);
286	//chdir(g_rootDir);	286	//chdir(g_rootDir);
287	#else	287	#else
288	getcwd(g_rootDir,BMAX_PATH);	288	getcwd(g_rootDir,BMAX_PATH);
289	strcat(g_rootDir,"/");	289	strcat(g_rootDir,"/");
290	#endif	290	#endif
291	}	291	}
292		292
293	void G_ExtInit(void)	293	void G_ExtInit(void)
294	{	294	{
295	char cwd[BMAX_PATH];	295	char cwd[BMAX_PATH];
296		296
297	#ifdef EDUKE32_OSX	297	#ifdef EDUKE32_OSX
298	char *appdir = Bgetappdir();	298	char *appdir = Bgetappdir();
299	addsearchpath(appdir);	299	addsearchpath(appdir);
300	Bfree(appdir);	300	Bfree(appdir);
301	#endif	301	#endif
302		302
303	if (getcwd(cwd,BMAX_PATH) && Bstrcmp(cwd,"/") != 0)	303	if (getcwd(cwd,BMAX_PATH) && Bstrcmp(cwd,"/") != 0)
304	addsearchpath(cwd);	304	addsearchpath(cwd);
305		305
306	if (CommandPaths)	306	if (CommandPaths)
307	{	307	{
308	int32_t i;	308	int32_t i;
309	struct strllist *s;	309	struct strllist *s;
310	while (CommandPaths)	310	while (CommandPaths)
311	{	311	{
312	s = CommandPaths->next;	312	s = CommandPaths->next;
313	i = addsearchpath(CommandPaths->str);	313	i = addsearchpath(CommandPaths->str);
314	if (i < 0)	314	if (i < 0)
315	{	315	{
316	initprintf("Failed adding %s for game data: %s\n", CommandPaths->str,	316	initprintf("Failed adding %s for game data: %s\n", CommandPaths->str,
317	i==-1 ? "not a directory" : "no such directory");	317	i==-1 ? "not a directory" : "no such directory");
318	}	318	}
319		319
320	Bfree(CommandPaths->str);	320	Bfree(CommandPaths->str);
321	Bfree(CommandPaths);	321	Bfree(CommandPaths);
322	CommandPaths = s;	322	CommandPaths = s;
323	}	323	}
324	}	324	}
325		325
326	#if defined(_WIN32)	326	#if defined(_WIN32)
327	if (!access("user_profiles_enabled", F_OK))	327	if (!access("user_profiles_enabled", F_OK))
328	#else	328	#else
329	if (usecwd == 0 && access("user_profiles_disabled", F_OK))	329	if (usecwd == 0 && access("user_profiles_disabled", F_OK))
330	#endif	330	#endif
331	{	331	{
332	char *homedir;	332	char *homedir;
333	int32_t asperr;	333	int32_t asperr;
334		334
335	if ((homedir = Bgethomedir()))	335	if ((homedir = Bgethomedir()))
336	{	336	{
337	Bsnprintf(cwd,sizeof(cwd),"%s/"	337	Bsnprintf(cwd,sizeof(cwd),"%s/"
338	#if defined(_WIN32)	338	#if defined(_WIN32)
339	"EDuke32 Settings"	339	"EDuke32 Settings"
340	#elif defined(GEKKO)	340	#elif defined(GEKKO)
341	"apps/eduke32"	341	"apps/eduke32"
342	#else	342	#else
343	".eduke32"	343	".eduke32"
344	#endif	344	#endif
345	,homedir);	345	,homedir);
346	asperr = addsearchpath(cwd);	346	asperr = addsearchpath(cwd);
347	if (asperr == -2)	347	if (asperr == -2)
348	{	348	{
349	if (Bmkdir(cwd,S_IRWXU) == 0) asperr = addsearchpath(cwd);	349	if (Bmkdir(cwd,S_IRWXU) == 0) asperr = addsearchpath(cwd);
350	else asperr = -1;	350	else asperr = -1;
351	}	351	}
352	if (asperr == 0)	352	if (asperr == 0)
353	Bchdir(cwd);	353	Bchdir(cwd);
354	Bfree(homedir);	354	Bfree(homedir);
355	}	355	}
356	}	356	}
357		357
358	// JBF 20031220: Because it's annoying renaming GRP files whenever I want to test different game data	358	// JBF 20031220: Because it's annoying renaming GRP files whenever I want to test different game data
359	if (g_grpNamePtr == NULL)	359	if (g_grpNamePtr == NULL)
360	{	360	{
361	const char *cp = getenv("DUKE3DGRP");	361	const char *cp = getenv("DUKE3DGRP");
362	if (cp)	362	if (cp)
363	{	363	{
364	clearGrpNamePtr();	364	clearGrpNamePtr();
365	g_grpNamePtr = dup_filename(cp);	365	g_grpNamePtr = dup_filename(cp);
366	initprintf("Using \"%s\" as main GRP file\n", g_grpNamePtr);	366	initprintf("Using \"%s\" as main GRP file\n", g_grpNamePtr);
367	}	367	}
368	}	368	}
369	}	369	}
370		370
371	void G_ScanGroups(void)	371	void G_ScanGroups(void)
372	{	372	{
373	ScanGroups();	373	ScanGroups();
374		374
375	// try and identify the 'defaultgamegrp' in the set of GRPs.	375	// try and identify the 'defaultgamegrp' in the set of GRPs.
376	// if it is found, set up the environment accordingly for the game it represents.	376	// if it is found, set up the environment accordingly for the game it represents.
377	// if it is not found, choose the first GRP from the list	377	// if it is not found, choose the first GRP from the list
378	struct grpfile fg, first = NULL;	378	struct grpfile fg, first = NULL;
379		379
380	for (fg = foundgrps; fg; fg=fg->next)	380	for (fg = foundgrps; fg; fg=fg->next)
381	{	381	{
382	struct grpfile *grp;	382	struct grpfile *grp;
383	for (grp = listgrps; grp; grp=grp->next)	383	for (grp = listgrps; grp; grp=grp->next)
384	if (fg->crcval == grp->crcval) break;	384	if (fg->crcval == grp->crcval) break;
385		385
386	if (grp == NULL)	386	if (grp == NULL)
387	continue;	387	continue;
388		388
389	fg->game = grp->game;	389	fg->game = grp->game;
390	if (!first) first = fg;	390	if (!first) first = fg;
391	if (!Bstrcasecmp(fg->name, G_DefaultGrpFile()))	391	if (!Bstrcasecmp(fg->name, G_DefaultGrpFile()))
392	{	392	{
393	g_gameType = grp->game;	393	g_gameType = grp->game;
394	g_gameNamePtr = grp->name;	394	g_gameNamePtr = grp->name;
395	break;	395	break;
396	}	396	}
397	}	397	}
398	if (!fg && first)	398	if (!fg && first)
399	{	399	{
400	if (g_grpNamePtr == NULL)	400	if (g_grpNamePtr == NULL)
401	{	401	{
402	clearGrpNamePtr();	402	clearGrpNamePtr();
403	g_grpNamePtr = dup_filename(first->name);	403	g_grpNamePtr = dup_filename(first->name);
404	}	404	}
405	g_gameType = first->game;	405	g_gameType = first->game;
406	g_gameNamePtr = listgrps->name;	406	g_gameNamePtr = listgrps->name;
407	}	407	}
408	else if (!fg) g_gameNamePtr = NULL;	408	else if (!fg) g_gameNamePtr = NULL;
409	}	409	}
410		410
411	void G_LoadGroups(int32_t autoload)	411	void G_LoadGroups(int32_t autoload)
412	{	412	{
413	if (g_modDir[0] != '/')	413	if (g_modDir[0] != '/')
414	{	414	{
415	char cwd[BMAX_PATH];	415	char cwd[BMAX_PATH];
416		416
417	Bstrcat(g_rootDir, g_modDir);	417	Bstrcat(g_rootDir, g_modDir);
418	addsearchpath(g_rootDir);	418	addsearchpath(g_rootDir);
419	// addsearchpath(mod_dir);	419	// addsearchpath(mod_dir);
420		420
421	if (getcwd(cwd, BMAX_PATH))	421	if (getcwd(cwd, BMAX_PATH))
422	{	422	{
423	Bsprintf(cwd, "%s/%s", cwd, g_modDir);	423	Bsprintf(cwd, "%s/%s", cwd, g_modDir);
424	if (!Bstrcmp(g_rootDir, cwd))	424	if (!Bstrcmp(g_rootDir, cwd))
425	{	425	{
426	if (addsearchpath(cwd) == -2)	426	if (addsearchpath(cwd) == -2)
427	if (Bmkdir(cwd, S_IRWXU) == 0)	427	if (Bmkdir(cwd, S_IRWXU) == 0)
428	addsearchpath(cwd);	428	addsearchpath(cwd);
429	}	429	}
430	}	430	}
431		431
432	#ifdef USE_OPENGL	432	#ifdef USE_OPENGL
433	Bsprintf(cwd, "%s/%s", g_modDir, TEXCACHEFILE);	433	Bsprintf(cwd, "%s/%s", g_modDir, TEXCACHEFILE);
434	Bstrcpy(TEXCACHEFILE, cwd);	434	Bstrcpy(TEXCACHEFILE, cwd);
435	#endif	435	#endif
436	}	436	}
437		437
438	if (g_usingAddon)	438	if (g_usingAddon)
439	G_LoadAddon();	439	G_LoadAddon();
440		440
441	int32_t i;	441	int32_t i;
442	const char *grpfile = G_GrpFile();	442	const char *grpfile = G_GrpFile();
443		443
444	if (g_dependencyCRC)	444	if (g_dependencyCRC)
445	{	445	{
446	struct grpfile *grp = FindGroup(g_dependencyCRC);	446	struct grpfile *grp = FindGroup(g_dependencyCRC);
447	if (grp)	447	if (grp)
448	{	448	{
449	if ((i = initgroupfile(grp->name)) == -1)	449	if ((i = initgroupfile(grp->name)) == -1)
450	initprintf("Warning: could not find main data file \"%s\"!\n", grp->name);	450	initprintf("Warning: could not find main data file \"%s\"!\n", grp->name);
451	else	451	else
452	initprintf("Using \"%s\" as main game data file.\n", grp->name);	452	initprintf("Using \"%s\" as main game data file.\n", grp->name);
453	}	453	}
454	}	454	}
455		455
456	if ((i = initgroupfile(grpfile)) == -1)	456	if ((i = initgroupfile(grpfile)) == -1)
457	initprintf("Warning: could not find main data file \"%s\"!\n", grpfile);	457	initprintf("Warning: could not find main data file \"%s\"!\n", grpfile);
458	else	458	else
459	initprintf("Using \"%s\" as main game data file.\n", grpfile);	459	initprintf("Using \"%s\" as main game data file.\n", grpfile);
460		460
461	if (autoload)	461	if (autoload)
462	{	462	{
463	G_LoadGroupsInDir("autoload");	463	G_LoadGroupsInDir("autoload");
464		464
465	if (i != -1)	465	if (i != -1)
466	G_DoAutoload(grpfile);	466	G_DoAutoload(grpfile);
467	}	467	}
468		468
469	if (g_modDir[0] != '/')	469	if (g_modDir[0] != '/')
470	G_LoadGroupsInDir(g_modDir);	470	G_LoadGroupsInDir(g_modDir);
471		471
472	if (g_defNamePtr == NULL)	472	if (g_defNamePtr == NULL)
473	{	473	{
474	const char *tmpptr = getenv("DUKE3DDEF");	474	const char *tmpptr = getenv("DUKE3DDEF");
475	if (tmpptr)	475	if (tmpptr)
476	{	476	{
477	clearDefNamePtr();	477	clearDefNamePtr();
478	g_defNamePtr = dup_filename(tmpptr);	478	g_defNamePtr = dup_filename(tmpptr);
479	initprintf("Using \"%s\" as definitions file\n", g_defNamePtr);	479	initprintf("Using \"%s\" as definitions file\n", g_defNamePtr);
480	}	480	}
481	}	481	}
482		482
483	loaddefinitions_game(G_DefFile(), TRUE);	483	loaddefinitions_game(G_DefFile(), TRUE);
484		484
485	struct strllist *s;	485	struct strllist *s;
486		486
487	pathsearchmode = 1;	487	pathsearchmode = 1;
488	while (CommandGrps)	488	while (CommandGrps)
489	{	489	{
490	int32_t j;	490	int32_t j;
491		491
492	s = CommandGrps->next;	492	s = CommandGrps->next;
493		493
494	if ((j = initgroupfile(CommandGrps->str)) == -1)	494	if ((j = initgroupfile(CommandGrps->str)) == -1)
495	initprintf("Could not find file \"%s\".\n", CommandGrps->str);	495	initprintf("Could not find file \"%s\".\n", CommandGrps->str);
496	else	496	else
497	{	497	{
498	g_groupFileHandle = j;	498	g_groupFileHandle = j;
499	initprintf("Using file \"%s\" as game data.\n", CommandGrps->str);	499	initprintf("Using file \"%s\" as game data.\n", CommandGrps->str);
500	if (autoload)	500	if (autoload)

Subversion Repositories eduke32

(root)/polymer/eduke32/source/common.c @ 5062 – Rev 5005 → 5037