Subversion Repositories eduke32

//-------------------------------------------------------------------------

/*

Copyright (C) 2010 EDuke32 developers and contributors

This file is part of EDuke32.

EDuke32 is free software; you can redistribute it and/or

modify it under the terms of the GNU General Public License version 2

as published by the Free Software Foundation.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

//-------------------------------------------------------------------------

#include "duke3d.h"

#include "baselayer.h"

#include "renderlayer.h"

#include "scriplib.h"

#include "file_lib.h"

#include "mathutil.h"

#include "gamedefs.h"

#include "keyboard.h"

#include "mouse.h"  // JBF 20030809

#include "joystick.h"

#include "function.h"

#include "control.h"

#include "fx_man.h"

#include "sounds.h"

#include "config.h"

#include "osd.h"

#include "osdfuncs.h"

#include "osdcmds.h"

#include "scriptfile.h"

#include "grpscan.h"

#include "gamedef.h"

#include "kplib.h"

#include "crc32.h"

#include "hightile.h"

#include "control.h"

#include "lz4.h"

#include "net.h"

#include "premap.h"

#include "gameexec.h"

#include "menus.h"

#include "savegame.h"

#include "anim.h"

#include "demo.h"

#include "common.h"

#include "common_game.h"

#include "input.h"

#include "compat.h"

#ifdef __ANDROID__

#include "android.h"

#endif

#ifdef LUNATIC

# include "lunatic_game.h"

#endif

// Uncomment to prevent anything except mirrors from drawing. It is sensible to

// also uncomment ENGINE_CLEAR_SCREEN in build/src/engine_priv.h.

//#define DEBUG_MIRRORS_ONLY

#if KRANDDEBUG

# define GAME_INLINE

# define GAME_STATIC

#else

# define GAME_INLINE inline

# define GAME_STATIC static

#endif

#ifdef _WIN32

# include "winlayer.h"

# define WIN32_LEAN_AND_MEAN

# include <windows.h>

# include <shellapi.h>

# define UPDATEINTERVAL 604800 // 1w

# include "winbits.h"

#else

# ifndef GEKKO

#  include <sys/ioctl.h>

# endif

#endif /* _WIN32 */

const char* AppProperName = "EDuke32";

const char* AppTechnicalName = "eduke32";

int32_t g_quitDeadline = 0;

#ifdef LUNATIC

camera_t g_camera;

#else

int32_t g_cameraDistance = 0, g_cameraClock = 0;

#endif

static int32_t g_quickExit;

static int32_t g_commandSetup = 0;

int32_t g_noSetup = 0;

static int32_t g_noAutoLoad = 0;

static int32_t g_noSound = 0;

static int32_t g_noMusic = 0;

static const char *CommandMap = NULL;

static const char *CommandName = NULL;

int32_t g_forceWeaponChoice = 0;

int32_t g_fakeMultiMode = 0;

double g_moveActorsTime = 0;  // in ms, smoothed

char boardfilename[BMAX_PATH] = {0}, currentboardfilename[BMAX_PATH] = {0};

int32_t voting = -1;

int32_t vote_map = -1, vote_episode = -1;

static int32_t g_Debug = 0;

static int32_t g_noLogoAnim = 0;

static int32_t g_noLogo = 0;

const char *defaultrtsfilename[GAMECOUNT] = { "DUKE.RTS", "NAM.RTS", "NAPALM.RTS", "WW2GI.RTS" };

// g_rtsNamePtr can point to an argv[] element

const char *g_rtsNamePtr = NULL;

int32_t g_Shareware = 0;

#define MAXUSERQUOTES 6

int32_t quotebot, quotebotgoal;

static int32_t user_quote_time[MAXUSERQUOTES];

static char user_quote[MAXUSERQUOTES][178];

// This was 32 for a while, but I think lowering it to 24 will help things like the Dingoo.

// Ideally, we would look at our memory usage on our most cramped platform and figure out

// how much of that is needed for the underlying OS and things like SDL instead of guessing

#ifndef GEKKO

static int32_t MAXCACHE1DSIZE = (24*1048576);

#else

static int32_t MAXCACHE1DSIZE = (8*1048576);

#endif

int32_t tempwallptr;

static int32_t nonsharedtimer;

int32_t ticrandomseed;

static void G_DrawCameraText(int16_t i);

GAME_STATIC GAME_INLINE int32_t G_MoveLoop(void);

static void G_DoOrderScreen(void);

#define FTAOPAQUETIME 30

#define ftapulseshade                                                                                                  \

    ((hud_glowingquotes && (getrendermode() == REND_CLASSIC || ps->fta >= FTAOPAQUETIME)) ?                            \

     (sintable[((uint32_t)ps->fta << 7) & 2047] >> 11) :                                                               \

     (sintable[((uint32_t)FTAOPAQUETIME << 7) & 2047] >> 11))

#define quotepulseshade (sintable[((uint32_t)totalclock<<5)&2047]>>11)

int32_t althud_numbertile = 2930;

int32_t althud_numberpal = 0;

#ifdef EDUKE32_TOUCH_DEVICES

int32_t althud_shadows = 0;

#else

int32_t althud_shadows = 1;

#endif

int32_t althud_flashing = 1;

int32_t hud_glowingquotes = 1;

int32_t hud_showmapname = 1;

int32_t g_levelTextTime = 0;

int32_t r_maxfps = 0;

uint32_t g_frameDelay = 0;

#if defined(RENDERTYPEWIN) && defined(USE_OPENGL)

extern char forcegl;

#endif

void M32RunScript(const char *s) { UNREFERENCED_PARAMETER(s); };  // needed for linking since it's referenced from build/src/osd.c

const char *G_DefaultRtsFile(void)

{

    if (DUKE)

        return defaultrtsfilename[GAME_DUKE];

    else if (WW2GI)

        return defaultrtsfilename[GAME_WW2GI];

    else if (NAPALM)

    {

        if (!testkopen(defaultrtsfilename[GAME_NAPALM],0) && testkopen(defaultrtsfilename[GAME_NAM],0))

            return defaultrtsfilename[GAME_NAM]; // NAM/NAPALM Sharing

        else

            return defaultrtsfilename[GAME_NAPALM];

    }

    else if (NAM)

    {

        if (!testkopen(defaultrtsfilename[GAME_NAM],0) && testkopen(defaultrtsfilename[GAME_NAPALM],0))

            return defaultrtsfilename[GAME_NAPALM]; // NAM/NAPALM Sharing

        else

            return defaultrtsfilename[GAME_NAM];

    }

    return defaultrtsfilename[0];

}

enum gametokens

{

    T_INCLUDE = 0,

    T_INTERFACE = 0,

    T_LOADGRP = 1,

    T_MODE = 1,

    T_CACHESIZE = 2,

    T_ALLOW = 2,

    T_NOAUTOLOAD,

    T_INCLUDEDEFAULT,

    T_MUSIC,

    T_SOUND,

    T_FILE,

    T_CUTSCENE,

    T_ANIMSOUNDS,

    T_NOFLOORPALRANGE,

    T_ID,

    T_DELAY

};

static int32_t sbarsc(int32_t sc)

{

    return scale(sc,ud.statusbarscale,100);

}

static int32_t sbarx(int32_t x)

{

    if (ud.screen_size == 4) return sbarsc(x<<16);

    return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x<<16);

}

static int32_t sbarxr(int32_t x)

{

    if (ud.screen_size == 4) return (320<<16) - sbarsc(x<<16);

    return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x<<16);

}

static int32_t sbary(int32_t y)

{

    if (ud.althud == 2 && ud.screen_size == 4) return sbarsc(y << 16);

    else return (200<<16) - sbarsc(200<<16) + sbarsc(y<<16);

}

static int32_t sbarx16(int32_t x)

{

    if (ud.screen_size == 4) return sbarsc(x);

    return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x);

}

#if 0 // enable if ever needed

static int32_t sbarxr16(int32_t x)

{

    if (ud.screen_size == 4) return (320<<16) - sbarsc(x);

    return (((320<<16) - sbarsc(320<<16)) >> 1) + sbarsc(x);

}

#endif

static int32_t sbary16(int32_t y)

{

    return (200<<16) - sbarsc(200<<16) + sbarsc(y);

}

int32_t textsc(int32_t sc)

{

    // prevent ridiculousness to a degree

    if (xdim <= 320) return sc;

    else if (xdim <= 640) return scale(sc,min(200,ud.textscale),100);

    else if (xdim <= 800) return scale(sc,min(300,ud.textscale),100);

    else if (xdim <= 1024) return scale(sc,min(350,ud.textscale),100);

    return scale(sc,ud.textscale,100);

}

static void G_PatchStatusBar(int32_t x1, int32_t y1, int32_t x2, int32_t y2)

{

    int32_t scl = sbarsc(65536);

    int32_t tx = sbarx16((160<<16) - (tilesiz[BOTTOMSTATUSBAR].x<<15)); // centered

    int32_t ty = sbary(200-tilesiz[BOTTOMSTATUSBAR].y);

    int32_t clx1 = sbarsc(scale(x1,xdim,320)), cly1 = sbarsc(scale(y1,ydim,200));

    int32_t clx2 = sbarsc(scale(x2,xdim,320)), cly2 = sbarsc(scale(y2,ydim,200));

    int32_t clofx = (xdim - sbarsc(xdim)) >> 1, clofy = (ydim - sbarsc(ydim));

    rotatesprite(tx,ty,scl,0,BOTTOMSTATUSBAR,4,0,10+16+64,clx1+clofx,cly1+clofy,clx2+clofx-1,cly2+clofy-1);

}

void P_SetGamePalette(DukePlayer_t *player, uint8_t palid, int32_t set)

{

    if (palid >= BASEPALCOUNT)

        palid = BASEPAL;

    player->palette = palid;

    if (player != g_player[screenpeek].ps)

        return;

    setbrightness(ud.brightness>>2, palid, set);

}

// get the string length until the next '\n'

int32_t G_GetStringLineLength(const char *text, const char *end, const int32_t iter)

{

    int32_t length = 0;

    while (*text != '\n' && text != end)

    {

        ++length;

        text += iter;

    }

    return length;

}

int32_t G_GetStringNumLines(const char *text, const char *end, const int32_t iter)

{

    int32_t count = 1;

    while (text != end)

    {

        if (*text == '\n')

            ++count;

        text += iter;

    }

    return count;

}

// Note: Neither of these care about TEXT_LINEWRAP. This is intended.

// This function requires you to Bfree() the returned char*.

char* G_GetSubString(const char *text, const char *end, const int32_t iter, const int32_t length)

{

    char *line = (char*)Xmalloc((length+1) * sizeof(char));

    int32_t counter = 0;

    while (counter < length && text != end)

    {

        line[counter] = *text;

        text += iter;

        ++counter;

    }

    line[counter] = '\0';

    return line;

}

// assign the character's tilenum

int32_t G_GetStringTile(int32_t font, char *t, int32_t f)

{

    if (f & TEXT_DIGITALNUMBER)

        return *t - '0' + font; // copied from digitalnumber

    else if (f & (TEXT_BIGALPHANUM|TEXT_GRAYFONT))

    {

        int32_t offset = (f & TEXT_GRAYFONT) ? 26 : 0;

        if (*t >= '0' && *t <= '9')

            return *t - '0' + font + ((f & TEXT_GRAYFONT) ? 26 : -10);

        else if (*t >= 'a' && *t <= 'z')

            return *t - 'a' + font + ((f & TEXT_GRAYFONT) ? -26 : 26);

        else if (*t >= 'A' && *t <= 'Z')

            return *t - 'A' + font;

        else switch (*t)

        {

            case '_':

            case '-':

                return font - (11 + offset);

                break;

            case '.':

                return font + (BIGPERIOD - (BIGALPHANUM + offset));

                break;

            case ',':

                return font + (BIGCOMMA - (BIGALPHANUM + offset));

                break;

            case '!':

                return font + (BIGX_ - (BIGALPHANUM + offset));

                break;

            case '?':

                return font + (BIGQ - (BIGALPHANUM + offset));

                break;

            case ';':

                return font + (BIGSEMI - (BIGALPHANUM + offset));

                break;

            case ':':

                return font + (BIGCOLIN - (BIGALPHANUM + offset));

                break;

            case '\\':

            case '/':

                return font + (68 - offset); // 3008-2940

                break;

            case '%':

                return font + (69 - offset); // 3009-2940

                break;

            case '`':

            case '\"': // could be better hacked in

            case '\'':

                return font + (BIGAPPOS - (BIGALPHANUM + offset));

                break;

            default: // unknown character

                *t = ' '; // whitespace-ize

            case '\n':

                return font;

                break;

        }

    }

    else

        return *t - '!' + font; // uses ASCII order

}

#define NUMHACKACTIVE ((f & TEXT_GAMETEXTNUMHACK) && t >= '0' && t <= '9')

// qstrdim

vec2_t G_ScreenTextSize(const int32_t font,

                        int32_t x, int32_t y, const int32_t z, const int32_t blockangle,

                        const char *str, const int32_t o,

                        int32_t xspace, int32_t yline, int32_t xbetween, int32_t ybetween,

                        const int32_t f,

                        int32_t x1, int32_t y1, int32_t x2, int32_t y2)

{

    vec2_t size = { 0, 0, }; // eventually the return value

    vec2_t pos = { 0, 0, }; // holds the coordinate position as we draw each character tile of the string

    vec2_t extent = { 0, 0, }; // holds the x-width of each character and the greatest y-height of each line

    vec2_t offset = { 0, 0, }; // temporary; holds the last movement made in both directions

    int32_t tile;

    char t;

    // set the start and end points depending on direction

    int32_t iter = (f & TEXT_BACKWARDS) ? -1 : 1; // iteration direction

    const char *end;

    const char *text;

    if (str == NULL)

        return size;

    end = (f & TEXT_BACKWARDS) ? str-1 : Bstrchr(str,'\0');

    text = (f & TEXT_BACKWARDS) ? Bstrchr(str,'\0')-1 : str;

    // optimization: justification in both directions

    if ((f & TEXT_XJUSTIFY) && (f & TEXT_YJUSTIFY))

    {

        size.x = xbetween;

        size.y = ybetween;

        return size;

    }

    // for best results, we promote 320x200 coordinates to full precision before any math

    if (!(o & ROTATESPRITE_FULL16))

    {

        x <<= 16;

        y <<= 16;

        xspace <<= 16;

        yline <<= 16;

        xbetween <<= 16;

        ybetween <<= 16;

    }

    // coordinate values should be shifted left by 16

    // handle zooming where applicable

    xspace = scale(xspace, z, 65536);

    yline = scale(yline, z, 65536);

    xbetween = scale(xbetween, z, 65536);

    ybetween = scale(ybetween, z, 65536);

    // size/width/height/spacing/offset values should be multiplied or scaled by $z, zoom (since 100% is 65536, the same as 1<<16)

    // loop through the string

    while ((t = *text) && text != end)

    {

        // handle escape sequences

        if (t == '^' && Bisdigit(*(text+iter)) && !(f & TEXT_LITERALESCAPE))

        {

            text += iter + iter;

            if (Bisdigit(*text))

                text += iter;

            continue;

        }

        // handle case bits

        if (f & TEXT_UPPERCASE)

        {

            if (f & TEXT_INVERTCASE) // optimization...?

            { // v^ important that these two ifs remain separate due to the else below

                if (Bisupper(t))

                    t = Btolower(t);

            }

            else if (Bislower(t))

                t = Btoupper(t);

        }

        else if (f & TEXT_INVERTCASE)

        {

            if (Bisupper(t))

                t = Btolower(t);

            else if (Bislower(t))

                t = Btoupper(t);

        }

        // translate the character to a tilenum

        tile = G_GetStringTile(font, &t, f);

        // reset this here because we haven't printed anything yet this loop

        extent.x = 0;

        // reset this here because the act of printing something on this line means that we include the margin above in the total size

        offset.y = 0;

        // handle each character itself in the context of screen drawing

        switch (t)

        {

            case '\t':

            case ' ':

                // width

                extent.x = xspace;

                if (f & (TEXT_INTERNALSPACE|TEXT_TILESPACE))

                {

                    char space = '.'; // this is subject to change as an implementation detail

                    if (f & TEXT_TILESPACE)

                        space = '\x7F'; // tile after '~'

                    tile = G_GetStringTile(font, &space, f);

                    extent.x += (tilesiz[tile].x * z);

                }

                // prepare the height // near-CODEDUP the other two near-CODEDUPs for this section

                {

                    int32_t tempyextent = yline;

                    if (f & (TEXT_INTERNALLINE|TEXT_TILELINE))

                    {

                        char line = 'A'; // this is subject to change as an implementation detail

                        if (f & TEXT_TILELINE)

                            line = '\x7F'; // tile after '~'

                        tile = G_GetStringTile(font, &line, f);

                        tempyextent += tilesiz[tile].y * z;

                    }

                    SetIfGreater(&extent.y, tempyextent);

                }

                if (t == '\t')

                    extent.x <<= 2; // *= 4

                break;

            case '\n': // near-CODEDUP "if (wrap)"

                extent.x = 0;

                // save the position

                if (!(f & TEXT_XOFFSETZERO)) // we want the entire offset to count as the character width

                    pos.x -= offset.x;

                SetIfGreater(&size.x, pos.x);

                // reset the position

                pos.x = 0;

                // prepare the height

                {

                    int32_t tempyextent = yline;

                    if (f & (TEXT_INTERNALLINE|TEXT_TILELINE))

                    {

                        char line = 'A'; // this is subject to change as an implementation detail

                        if (f & TEXT_TILELINE)

                            line = '\x7F'; // tile after '~'

                        tile = G_GetStringTile(font, &line, f);

                        tempyextent += tilesiz[tile].y * z;

                    }

                    SetIfGreater(&extent.y, tempyextent);

                }

                // move down the line height

                if (!(f & TEXT_YOFFSETZERO))

                    pos.y += extent.y;

                // reset the current height

                extent.y = 0;

                // line spacing

                offset.y = (f & TEXT_YJUSTIFY) ? 0 : ybetween; // ternary to prevent overflow

                pos.y += offset.y;

                break;

            default:

                // width

                extent.x = tilesiz[tile].x * z;

                // obnoxious hardcoded functionality from gametext

                if (NUMHACKACTIVE)

                {

                    char numeral = '0'; // this is subject to change as an implementation detail

                    extent.x = (tilesiz[G_GetStringTile(font, &numeral, f)].x-1) * z;

                }

                // height

                SetIfGreater(&extent.y, (tilesiz[tile].y * z));

                break;

        }

        // incrementing the coordinate counters

        offset.x = 0;

        // advance the x coordinate

        if (!(f & TEXT_XOFFSETZERO) || NUMHACKACTIVE)

            offset.x += extent.x;

        // account for text spacing

        if (!NUMHACKACTIVE // this "if" line ONLY == replicating hardcoded stuff

            && t != '\n'

            && !(f & TEXT_XJUSTIFY)) // to prevent overflow

            offset.x += xbetween;

        // line wrapping

        if ((f & TEXT_LINEWRAP) && !(f & TEXT_XRIGHT) && !(f & TEXT_XCENTER) && blockangle % 512 == 0)

        {

            int32_t wrap = 0;

            const int32_t ang = blockangle % 2048;

            // this is the only place in qstrdim where angle actually affects direction, but only in the wrapping measurement

            switch (ang)

            {

                case 0:

                    wrap = (x + (pos.x + offset.x) > ((o & 2) ? (320<<16) : ((x2 - USERQUOTE_RIGHTOFFSET)<<16)));

                    break;

                case 512:

                    wrap = (y + (pos.x + offset.x) > ((o & 2) ? (200<<16) : ((y2 - USERQUOTE_RIGHTOFFSET)<<16)));

                    break;

                case 1024:

                    wrap = (x - (pos.x + offset.x) < ((o & 2) ? 0 : ((x1 + USERQUOTE_RIGHTOFFSET)<<16)));

                    break;

                case 1536:

                    wrap = (y - (pos.x + offset.x) < ((o & 2) ? 0 : ((y1 + USERQUOTE_RIGHTOFFSET)<<16)));

                    break;

            }

            if (wrap) // near-CODEDUP "case '\n':"

            {

                // save the position

                SetIfGreater(&size.x, pos.x);

                // reset the position

                pos.x = 0;

                // prepare the height

                {

                    int32_t tempyextent = yline;

                    if (f & (TEXT_INTERNALLINE|TEXT_TILELINE))

                    {

                        char line = 'A'; // this is subject to change as an implementation detail

                        if (f & TEXT_TILELINE)

                            line = '\x7F'; // tile after '~'

                        tile = G_GetStringTile(font, &line, f);

                        tempyextent += tilesiz[tile].y * z;

                    }

                    SetIfGreater(&extent.y, tempyextent);

                }

                // move down the line height

                if (!(f & TEXT_YOFFSETZERO))

                    pos.y += extent.y;

                // reset the current height

                extent.y = 0;

                // line spacing

                offset.y = (f & TEXT_YJUSTIFY) ? 0 : ybetween; // ternary to prevent overflow

                pos.y += offset.y;

            }

            else

                pos.x += offset.x;

        }

        else

            pos.x += offset.x;

        // save some trouble with calculation in case the line breaks

        if (!(f & TEXT_XOFFSETZERO) || NUMHACKACTIVE)

            offset.x -= extent.x;

        // iterate to the next character in the string

        text += iter;

    }

    // calculate final size

    if (!(f & TEXT_XOFFSETZERO))

        pos.x -= offset.x;

    if (!(f & TEXT_YOFFSETZERO))

    {

        pos.y -= offset.y;

        pos.y += extent.y;

    }

    else

        pos.y += ybetween;

    SetIfGreater(&size.x, pos.x);

    SetIfGreater(&size.y, pos.y);

    // justification where only one of the two directions is set, so we have to iterate

    if (f & TEXT_XJUSTIFY)

        size.x = xbetween;

    if (f & TEXT_YJUSTIFY)

        size.y = ybetween;

    // return values in the same manner we receive them

    if (!(o & ROTATESPRITE_FULL16))

    {

        size.x >>= 16;

        size.y >>= 16;

    }

    return size;

}

void G_AddCoordsFromRotation(vec2_t *coords, const vec2_t *unitDirection, const int32_t magnitude)

{

    coords->x += scale(magnitude, unitDirection->x, 16384);

    coords->y += scale(magnitude, unitDirection->y, 16384);

}