//------------------------------------------------------------------------- /* 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_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_RESET = 0x00000008, GAMEARRAY_TYPE_MASK = GAMEARRAY_OFCHAR | GAMEARRAY_OFSHORT | GAMEARRAY_OFINT, GAMEARRAY_RESTORE = 0x00000010, GAMEARRAY_VARSIZE = 0x00000020, GAMEARRAY_STRIDE2 = 0x00000100, }; #pragma pack(push,1) typedef struct { union { intptr_t nValue; intptr_t *pValues; // array of values when 'per-player', or 'per-actor' }; intptr_t nDefault; uintptr_t nFlags; char * szLabel; } gamevar_t; typedef struct { char * szLabel; intptr_t *pValues; // array of values intptr_t size; intptr_t nFlags; } gamearray_t; #pragma pack(pop) # define GAR_ELTSZ (sizeof(aGameArrays[0].pValues[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_GetGameArrayValue(int const id, int index); int32_t __fastcall Gv_GetVar(int id, int nSprite, int nPlayer); void __fastcall Gv_SetVar(int const id, int32_t const lValue, int const nSprite, int const nPlayer); int32_t __fastcall Gv_GetVarX(int id); void __fastcall Gv_GetManyVars(int const count, int32_t * const rv); void __fastcall Gv_SetVarX(int 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); FORCE_INLINE void A_ResetVars(int const nSprite) { for (int i = 0; i < g_gameVarCount; ++i) { if ((aGameVars[i].nFlags & (GAMEVAR_PERACTOR | GAMEVAR_NODEFAULT)) != GAMEVAR_PERACTOR) continue; aGameVars[i].pValues[nSprite] = aGameVars[i].nDefault; } } 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) \ FORCE_INLINE void __fastcall func(int const id, int32_t const nValue) \ { \ switch (aGameVars[id].nFlags & (GAMEVAR_USER_MASK | GAMEVAR_PTR_MASK)) \ { \ default: aGameVars[id].nValue operator nValue; break; \ case GAMEVAR_PERPLAYER: \ if (EDUKE32_PREDICT_FALSE((unsigned)vm.g_p > MAXPLAYERS - 1)) \ break; \ aGameVars[id].pValues[vm.g_p] operator nValue; \ break; \ case GAMEVAR_PERACTOR: \ if (EDUKE32_PREDICT_FALSE((unsigned)vm.g_i > MAXSPRITES - 1)) \ break; \ aGameVars[id].pValues[vm.g_i] operator nValue; \ break; \ case GAMEVAR_INTPTR: *((int32_t *)aGameVars[id].nValue) operator(int32_t) nValue; break; \ case GAMEVAR_SHORTPTR: *((int16_t *)aGameVars[id].nValue) operator(int16_t) nValue; break; \ case GAMEVAR_CHARPTR: *((uint8_t *)aGameVars[id].nValue) operator(uint8_t) nValue; break; \ } \ } #if defined(__arm__) || defined(LIBDIVIDE_ALWAYS) FORCE_INLINE void __fastcall Gv_DivVar(int const id, int32_t const nValue) { if (EDUKE32_PREDICT_FALSE((aGameVars[id].nFlags & GAMEVAR_PERPLAYER && (unsigned) vm.g_p > MAXPLAYERS - 1) || (aGameVars[id].nFlags & GAMEVAR_PERACTOR && (unsigned) vm.g_i > MAXSPRITES - 1))) return; static libdivide_s32_t sdiv; static int32_t nLastValue; libdivide_s32_t *dptr = ((unsigned) nValue < DIVTABLESIZE) ? (libdivide_s32_t *) &divtable32[nValue] : &sdiv; intptr_t *iptr = &aGameVars[id].nValue; if (nValue == nLastValue || dptr != &sdiv) goto skip; sdiv = libdivide_s32_gen((nLastValue = nValue)); skip: switch (aGameVars[id].nFlags & (GAMEVAR_USER_MASK | GAMEVAR_PTR_MASK)) { case GAMEVAR_PERPLAYER: iptr = &aGameVars[id].pValues[vm.g_p]; default: break; case GAMEVAR_PERACTOR: iptr = &aGameVars[id].pValues[vm.g_i]; break; case GAMEVAR_INTPTR: *((int32_t *)aGameVars[id].nValue) = (int32_t)libdivide_s32_do(*((int32_t *)aGameVars[id].nValue), dptr); return; case GAMEVAR_SHORTPTR: *((int16_t *)aGameVars[id].nValue) = (int16_t)libdivide_s32_do(*((int16_t *)aGameVars[id].nValue), dptr); return; case GAMEVAR_CHARPTR: *((uint8_t *)aGameVars[id].nValue) = (uint8_t)libdivide_s32_do(*((uint8_t *)aGameVars[id].nValue), 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