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.

*/

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

#ifndef gamevars_h_

#define gamevars_h_

#include "gamedef.h"

#define MAXGAMEVARS 2048 // must be a power of two

#define MAXVARLABEL 26

// store global game definitions

enum GamevarFlags_t {

    GAMEVAR_PERPLAYER  = 0x00000001, // per-player variable

    GAMEVAR_PERACTOR   = 0x00000002, // per-actor variable

    GAMEVAR_USER_MASK  = (GAMEVAR_PERPLAYER|GAMEVAR_PERACTOR),

    GAMEVAR_RESET      = 0x00000008, // INTERNAL, don't use

    GAMEVAR_DEFAULT    = 0x00000100, // UNUSED, but always cleared for user-defined gamevars

    GAMEVAR_SECRET     = 0x00000200, // don't dump...

    GAMEVAR_NODEFAULT  = 0x00000400, // don't reset on actor spawn

    GAMEVAR_SYSTEM     = 0x00000800, // cannot change mode flags...(only default value)

    GAMEVAR_READONLY   = 0x00001000, // values are read-only (no setvar allowed)

    GAMEVAR_INTPTR     = 0x00002000, // plValues is a pointer to an int32_t

    GAMEVAR_SHORTPTR   = 0x00008000, // plValues is a pointer to a short

    GAMEVAR_CHARPTR    = 0x00010000, // plValues is a pointer to a char

    GAMEVAR_PTR_MASK   = (GAMEVAR_INTPTR|GAMEVAR_SHORTPTR|GAMEVAR_CHARPTR),

    GAMEVAR_NORESET    = 0x00020000, // var values are not reset when restoring map state

    GAMEVAR_SPECIAL    = 0x00040000, // flag for structure member shortcut vars

    GAMEVAR_NOMULTI    = 0x00080000, // don't attach to multiplayer packets

};

#if !defined LUNATIC

// Alignments for per-player and per-actor variables.

#define PLAYER_VAR_ALIGNMENT (sizeof(intptr_t))

#define ACTOR_VAR_ALIGNMENT 16

# define MAXGAMEARRAYS (MAXGAMEVARS>>2) // must be strictly smaller than MAXGAMEVARS

# define MAXARRAYLABEL MAXVARLABEL

enum GamearrayFlags_t {

    GAMEARRAY_READONLY = 0x00001000,

    GAMEARRAY_WARN = 0x00002000,

    GAMEARRAY_NORMAL   = 0x00004000,

    GAMEARRAY_OFCHAR   = 0x00000001,

    GAMEARRAY_OFSHORT  = 0x00000002,

    GAMEARRAY_OFINT    = 0x00000004,

    GAMEARRAY_TYPE_MASK = GAMEARRAY_OFCHAR|GAMEARRAY_OFSHORT|GAMEARRAY_OFINT,

    GAMEARRAY_VARSIZE = 0x00000020,

    GAMEARRAY_RESET    = 0x00000008,

///    GAMEARRAY_NORESET  = 0x00000001,

};

#pragma pack(push,1)

typedef struct {

    union {

        intptr_t lValue;

        intptr_t *plValues;     // array of values when 'per-player', or 'per-actor'

    } val;

    intptr_t lDefault;

    uintptr_t dwFlags;

    char *szLabel;

} gamevar_t;

typedef struct {

    char *szLabel;

    intptr_t *plValues;     // array of values

    intptr_t size;

    intptr_t dwFlags;

} gamearray_t;

#pragma pack(pop)

# define GAR_ELTSZ (sizeof(aGameArrays[0].plValues[0]))

extern gamevar_t aGameVars[MAXGAMEVARS];

extern gamearray_t aGameArrays[MAXGAMEARRAYS];

extern int32_t g_gameVarCount;

extern int32_t g_gameArrayCount;

int32_t __fastcall Gv_GetVar(int32_t id, int32_t iActor, int32_t iPlayer);

void __fastcall Gv_SetVar(int32_t const id, int32_t const lValue, int32_t const iActor, int32_t const iPlayer);

int32_t __fastcall Gv_GetVarX(int32_t id);

void __fastcall Gv_SetVarX(int32_t const id, int32_t const lValue);

int32_t Gv_GetVarByLabel(const char *szGameLabel,int32_t const lDefault,int32_t const iActor,int32_t const iPlayer);

int32_t Gv_NewArray(const char *pszLabel,void *arrayptr,intptr_t asize,uint32_t dwFlags);

int32_t Gv_NewVar(const char *pszLabel,intptr_t lValue,uint32_t dwFlags);

static inline void A_ResetVars(const int32_t iActor)

{

    for (int i = 0; i < g_gameVarCount; i++)

    {

        if ((aGameVars[i].dwFlags & (GAMEVAR_PERACTOR | GAMEVAR_NODEFAULT)) == GAMEVAR_PERACTOR)

            aGameVars[i].val.plValues[iActor] = aGameVars[i].lDefault;

    }

}

void Gv_DumpValues(void);

void Gv_InitWeaponPointers(void);

void Gv_RefreshPointers(void);

void Gv_ResetVars(void);

int32_t Gv_ReadSave(int32_t fil,int32_t newbehav);

void Gv_WriteSave(FILE *fil,int32_t newbehav);

#else

extern int32_t g_noResetVars;

extern LUNATIC_CB void (*A_ResetVars)(int32_t iActor);

#endif

void Gv_ResetSystemDefaults(void);

void Gv_Init(void);

void Gv_FinalizeWeaponDefaults(void);

#if !defined LUNATIC

#define VM_GAMEVAR_OPERATOR(func, operator)                                                                            \

    static inline void __fastcall func(const int32_t id, const int32_t lValue)                                         \

    {                                                                                                                  \

        switch (aGameVars[id].dwFlags & (GAMEVAR_USER_MASK | GAMEVAR_PTR_MASK))                                        \

        {                                                                                                              \

            default: aGameVars[id].val.lValue operator lValue; break;                                                  \

            case GAMEVAR_PERPLAYER:                                                                                    \

                if (EDUKE32_PREDICT_FALSE((unsigned)vm.g_p > MAXPLAYERS - 1))                                          \

                    break;                                                                                             \

                aGameVars[id].val.plValues[vm.g_p] operator lValue;                                                    \

                break;                                                                                                 \

            case GAMEVAR_PERACTOR:                                                                                     \

                if (EDUKE32_PREDICT_FALSE((unsigned)vm.g_i > MAXSPRITES - 1))                                          \

                    break;                                                                                             \

                aGameVars[id].val.plValues[vm.g_i] operator lValue;                                                    \

                break;                                                                                                 \

            case GAMEVAR_INTPTR: *((int32_t *)aGameVars[id].val.lValue) operator (int32_t) lValue; break;              \

            case GAMEVAR_SHORTPTR: *((int16_t *)aGameVars[id].val.lValue) operator (int16_t) lValue; break;            \

            case GAMEVAR_CHARPTR: *((uint8_t *)aGameVars[id].val.lValue) operator (uint8_t) lValue; break;             \

        }                                                                                                              \

    }

#if defined(__arm__) || defined(LIBDIVIDE_ALWAYS)

static inline void __fastcall Gv_DivVar(const int32_t id, const int32_t lValue)

{

    static libdivide_s32_t sdiv;

    static int32_t lastlValue;

    libdivide_s32_t *dptr = &sdiv;

    intptr_t *iptr = &aGameVars[id].val.lValue;

    if (EDUKE32_PREDICT_FALSE((aGameVars[id].dwFlags & GAMEVAR_PERPLAYER && (unsigned)vm.g_p > MAXPLAYERS - 1) ||

                              (aGameVars[id].dwFlags & GAMEVAR_PERACTOR && (unsigned)vm.g_i > MAXSPRITES - 1)))

        return;

    if ((unsigned)lValue < DIVTABLESIZE)

        dptr = (libdivide_s32_t *)&divtable32[lValue];

    else if (lValue != lastlValue)

        sdiv = libdivide_s32_gen(lValue), lastlValue = lValue;

    switch (aGameVars[id].dwFlags & (GAMEVAR_USER_MASK | GAMEVAR_PTR_MASK))

    {

        case GAMEVAR_PERPLAYER: iptr = &aGameVars[id].val.plValues[vm.g_p];

        default: break;

        case GAMEVAR_PERACTOR: iptr = &aGameVars[id].val.plValues[vm.g_i]; break;

        case GAMEVAR_INTPTR:

            *((int32_t *)aGameVars[id].val.lValue) =

            (int32_t)libdivide_s32_do(*((int32_t *)aGameVars[id].val.lValue), dptr);

            return;

        case GAMEVAR_SHORTPTR:

            *((int16_t *)aGameVars[id].val.lValue) =

            (int16_t)libdivide_s32_do(*((int16_t *)aGameVars[id].val.lValue), dptr);

            return;

        case GAMEVAR_CHARPTR:

            *((uint8_t *)aGameVars[id].val.lValue) =

            (uint8_t)libdivide_s32_do(*((uint8_t *)aGameVars[id].val.lValue), dptr);

            return;

    }

    *iptr = libdivide_s32_do(*iptr, dptr);

}

#else

VM_GAMEVAR_OPERATOR(Gv_DivVar, /= )

#endif

VM_GAMEVAR_OPERATOR(Gv_AddVar, +=)

VM_GAMEVAR_OPERATOR(Gv_SubVar, -=)

VM_GAMEVAR_OPERATOR(Gv_MulVar, *=)

VM_GAMEVAR_OPERATOR(Gv_ModVar, %=)

VM_GAMEVAR_OPERATOR(Gv_AndVar, &=)

VM_GAMEVAR_OPERATOR(Gv_XorVar, ^=)

VM_GAMEVAR_OPERATOR(Gv_OrVar, |=)

#undef VM_GAMEVAR_OPERATOR

#endif

#endif