/*

* OpenBOR - http://www.chronocrash.com

* -----------------------------------------------------------------------

* All rights reserved, see LICENSE in OpenBOR root for details.

*

* Copyright (c) 2004 - 2017 OpenBOR Team

*/

/* This file include all script methods used by openbor engine

Notice: Make sure to null *pretvar when you about to return E_FAIL,

Or the engine might crash.

Notice: Every new ScriptVariant must be initialized when you first alloc it by

ScriptVariant_Init immediately, memset it all to zero should also work by now,

unless VT_EMPTY is changed.

If you want to reset a ScriptVariant to empty, you must use ScriptVariant_Clear instead.

ScriptVariant_Init or memset must be called only ONCE, later you should use ScriptVariant_Clear.

Be sure to call ScriptVariant_Clear if you want to use free to delete those variants.

If you want to copy a ScriptVariant from another, use ScriptVariant_Copy instead of assignment,

not because it is faster, but this method is neccessary for string types.

If you want to change types of an ScriptVariant, use ScriptVariant_ChangeType, don't change vt directly.

*/

#include "config.h"

#include "openbor.h"

#include "soundmix.h"

#include "globals.h"

#include "ImportCache.h"

#include "models.h"

#include "scriptcommon.h"

Varlist global_var_list;

Script *pcurrentscript = NULL; //used by local script functions

List theFunctionList;

static List scriptheap;

static s_spawn_entry spawnentry;

static s_drawmethod drawmethod;

int max_indexed_vars = 0;

int max_entity_vars = 0;

int max_script_vars = 0;

int no_nested_script = 0;

extern int ent_count;

extern int ent_max;

extern int gameOver;

extern int selectScreen;

extern int titleScreen;

extern int hallOfFame;

extern int showComplete;

extern char *currentScene;

extern int enginecreditsScreen;

extern int menuScreen;

extern int optionsMenu;

extern int controloptionsMenu;

extern int videooptionsMenu;

extern int soundoptionsMenu;

extern int systemoptionsMenu;

extern int startgameMenu;

extern int newgameMenu;

extern int loadgameMenu;

extern int num_difficulties;

extern u32 _time;

extern int goto_mainmenu_flag;

extern int _pause;

extern int timeleft;

extern int gfx_x_offset;

extern int gfx_y_offset;

extern int gfx_y_offset_adj;

extern s_lasthit lasthit;

extern int current_set;

extern int current_level;

extern int current_stage;

extern int timevar;

extern float bgtravelled;

extern float vbgtravelled;

extern int traveltime;

extern int texttime;

extern int timetoshow;

extern int is_total_timeover;

extern int showgo;

extern float advancex;

extern float advancey;

extern float scrolldx;

extern float scrolldy;

extern float scrollminz;

extern float scrollmaxz;

extern float blockade;

extern float scrollminx;

extern float scrollmaxx;

extern s_videomodes videomodes;

extern int panel_height;

extern char branch_name[MAX_NAME_LEN + 1];

extern s_set_entry *levelsets;

extern unsigned int models_loaded;

//extern unsigned int models_cached;

extern int viewportx;

extern int viewporty;

extern int viewportw;

extern int viewporth;

extern int nosave;

extern int nopause;

extern int nofadeout;

extern int noscreenshot;

extern int nojoin;

extern s_screen *vscreen;

extern entity *smartbomber;

extern entity *textbox;

extern s_screen *background;

extern int skiptoset;

extern s_slow_motion slowmotion;

extern int shadowcolor;

extern int shadowalpha;

extern int shadowopacity;

extern s_axis_plane_vertical_int light;

extern int max_attack_types;

extern int max_animations;

static void clear_named_var_list(List *list, int level)

{

ScriptVariant *var;

int i, size;

size = List_GetSize(list);

for(i = 0, List_Reset(list); i < size; i++)

{

var = (ScriptVariant *)List_Retrieve(list);

ScriptVariant_Clear(var);

free(var);

List_Remove(list);

}

if(level)

{

List_Clear(list);

}

}

void Varlist_Init(Varlist *varlist, int size)

{

int i;

varlist->magic = varlist_magic;

varlist->list = calloc(1, sizeof(*varlist->list));

List_Init(varlist->list);

varlist->vars = calloc(size + 1, sizeof(*varlist->vars));

for(i = 0; i <= size; i++)

{

ScriptVariant_Init(varlist->vars + i);

ScriptVariant_ChangeType(varlist->vars, VT_INTEGER);

varlist->vars->lVal = (LONG)size;

}

}

void Varlist_Clear(Varlist *varlist)

{

int i;

clear_named_var_list(varlist->list, 1);

free(varlist->list);

varlist->list = NULL;

// the first one must be an integer variable, so it's safe to leave it alone

for(i = 1; i <= varlist->vars->lVal; i++)

{

ScriptVariant_Clear(varlist->vars + i);

}

free(varlist->vars);

varlist->vars = NULL;

varlist->magic = 0;

}

void Varlist_Cleanup(Varlist *varlist)

{

int i;

clear_named_var_list(varlist->list, 0);

for(i = 1; i <= varlist->vars->lVal; i++)

{

ScriptVariant_Clear(varlist->vars + i);

}

}

ScriptVariant *Varlist_GetByName(Varlist *varlist, char *theName)

{

if(!theName || !theName[0])

{

return NULL;

}

if(List_FindByName(varlist->list, theName))

{

return (ScriptVariant *)List_Retrieve(varlist->list);

}

return NULL;

}

int Varlist_SetByName(Varlist *varlist, char *theName, ScriptVariant *var)

{

ScriptVariant *v;

if(!theName || !theName[0])

{

return 0;

}

if(List_FindByName(varlist->list, theName))

{

ScriptVariant_Copy((ScriptVariant *)List_Retrieve(varlist->list), var);

}

else

{

v = calloc(1, sizeof(*v));

ScriptVariant_Copy(v, var);

List_InsertAfter(varlist->list, v, theName);

}

return 1;

}

ScriptVariant *Varlist_GetByIndex(Varlist *varlist, int index)

{

if(index < 0 || index >= varlist->vars->lVal)

{

return NULL;

}

return varlist->vars + index + 1;

}

int Varlist_SetByIndex(Varlist *varlist, int index, ScriptVariant *var)

{

if(index < 0)

{

return 0;

}

else if(index >= varlist->vars->lVal)

{

__reallocto(varlist->vars, varlist->vars->lVal + 1, index + 2);

varlist->vars->lVal = index + 1;

}

ScriptVariant_Copy(varlist->vars + index + 1, var);

return 1;

}

// By White Dragon

int Varlist_AddByIndex(Varlist *array, int index, ScriptVariant *var)

{

if(index < 0 || index >= array->vars->lVal+1)

{

return 0;

}

else

{

int i = 0;

int size = array->vars->lVal;

__reallocto(array->vars, size+1, size+2);

size = ++array->vars->lVal;

for ( i = size-1; i > index; i-- )

{

ScriptVariant_Copy(array->vars+1+i, array->vars+1+i-1); // first value of array is his size!

}

ScriptVariant_Copy(array->vars+1+index, var);

//printf("aaa: %s\n", (char*)StrCache_Get(elem->strVal) );

}

return 1;

}

// By White Dragon

int Varlist_DeleteByIndex(Varlist *array, int index)

{

if(index < 0 || index >= array->vars->lVal)

{

return 0;

}

else

{

int i = 0;

int size = array->vars->lVal;

ScriptVariant *elem;

for ( i = index; i < size-1; i++ )

{

ScriptVariant_Copy(array->vars+1+i, array->vars+1+i+1); // first value of array is his size!

}

--array->vars->lVal;

// set last element to NULL

elem = array->vars+1+size-1;

ScriptVariant_ChangeType(elem, VT_EMPTY);

elem->ptrVal = NULL;

//realloc mem

array->vars = realloc((array->vars), sizeof(*(array->vars))*(array->vars->lVal+1));

//printf("aaa: %s\n", (char*)StrCache_Get(elem->strVal) );

}

return 1;

}

// By White Dragon

int Varlist_DeleteByName(Varlist *array, char *theName)

{

if(!theName || !theName[0])

{

return 0;

}

if(List_FindByName(array->list, theName))

{

Node* node;

Node* prev_node;

Node* next_node;

node = array->list->current;

prev_node = node->prev;

next_node = node->next;

if ( prev_node ) prev_node->next = next_node;

if ( next_node ) next_node->prev = prev_node;

if ( array->list->last == node ) array->list->last = prev_node;

if ( array->list->first == node ) array->list->first = next_node;

if ( array->list->first == array->list->last && array->list->first == node ) {

array->list->last = NULL;

array->list->first = NULL;

}

--array->list->size;

free(node);

} else return 0;

return 1;

}

//this function should be called before all script methods, for once

void Script_Global_Init()

{

memset(&spawnentry, 0, sizeof(spawnentry)); //clear up the spawn entry

drawmethod = plainmethod;

Varlist_Init(&global_var_list, max_indexed_vars);

List_Init(&theFunctionList);

Script_LoadSystemFunctions();

List_Init(&scriptheap);

ImportCache_Init(&theFunctionList);

}

void _freeheapnode(void *ptr)

{

if(((Script *)ptr)->magic == script_magic)

{

Script_Clear((Script *)ptr, 2);

}

else if(((anigif_info *)ptr)->magic == anigif_magic)

{

anigif_close((anigif_info *)ptr);

}

else if(((Varlist *)ptr)->magic == varlist_magic)

{

Varlist_Clear((Varlist *)ptr);

}

else if(((s_sprite *)ptr)->magic == sprite_magic)

{

if(((s_sprite *)ptr)->mask)

{

free(((s_sprite *)ptr)->mask);

}

}

free(ptr);

}

//this function should only be called when the engine is shutting down

void Script_Global_Clear()

{

int i, size;

List_Clear(&theFunctionList);

// dump all un-freed variants

size = List_GetSize(&scriptheap);

if(size > 0)

{

printf("\nWarning: %d script variants are not freed, dumping...\n", size);

}

for(i = 0, List_Reset(&scriptheap); i < size; List_GotoNext(&scriptheap), i++)

{

printf("%s\n", List_GetName(&scriptheap));

_freeheapnode(List_Retrieve(&scriptheap));

}

List_Clear(&scriptheap);

// clear the global list

Varlist_Clear(&global_var_list);

memset(&spawnentry, 0, sizeof(spawnentry));//clear up the spawn entry

for(i = 0; i < numfilestreams; i++)

{

if(filestreams[i].buf)

{

free(filestreams[i].buf);

filestreams[i].buf = NULL;

}

}

if(filestreams)

{

free(filestreams);

}

filestreams = NULL;

numfilestreams = 0;

ImportCache_Clear();

StrCache_Clear();

}

int Script_Save_Local_Variant(Script *cs, char *namelist[])

{

return 0;

}

void Script_Load_Local_Variant(Script *cs, int handle)

{

}

Script *alloc_script()

{

Script *pscript = calloc(1, sizeof(*pscript));

pscript->magic = script_magic;

pscript->varlist = calloc(1, sizeof(*pscript->varlist));

Varlist_Init(pscript->varlist, max_script_vars);

return pscript;

}

void Script_Init(Script *pscript, char *theName, char *comment, int first)

{

if(first)

{

memset(pscript, 0, sizeof(*pscript));

pscript->magic = script_magic;

pscript->varlist = calloc(1, sizeof(*pscript->varlist));

Varlist_Init(pscript->varlist, max_script_vars);

}

if(!theName || !theName[0])

{

return; // if no name specified, only alloc the variants

}

pscript->pinterpreter = malloc(sizeof(*pscript->pinterpreter));

Interpreter_Init(pscript->pinterpreter, theName, &theFunctionList);

pscript->interpreterowner = 1; // this is the owner, important

pscript->initialized = 1;

if(comment)

{

pscript->comment = malloc(sizeof(*pscript->comment) * (strlen(comment) + 1));

strcpy(pscript->comment, comment);

}

}

static void execute_init_method(Script *pdest, int iscopy, int localclear)

{

Script *temp;

ScriptVariant tempvar;

//Execute init method

if(pdest->initialized && pdest->pinterpreter->pInitEntry)

{

temp = pcurrentscript;

pcurrentscript = pdest;

ScriptVariant_Init(&tempvar);

ScriptVariant_ChangeType(&tempvar, VT_INTEGER);

tempvar.lVal = (LONG)iscopy;

Script_Set_Local_Variant(pdest, "iscopy", &tempvar);

tempvar.lVal = (LONG)localclear;

Script_Set_Local_Variant(pdest, "localclear", &tempvar);

Interpreter_Reset(pdest->pinterpreter);

pdest->pinterpreter->pCurrentInstruction = pdest->pinterpreter->pInitEntry;

if(FAILED( Interpreter_EvaluateCall(pdest->pinterpreter)))

{

borShutdown(1, "Fatal: failed to execute 'init' in script %s %s", pdest->pinterpreter->theSymbolTable.name, pdest->comment ? pdest->comment : "");

}

pdest->pinterpreter->bReset = FALSE; // not needed, perhaps

ScriptVariant_Clear(&tempvar);

Script_Set_Local_Variant(pdest, "iscopy", &tempvar);

Script_Set_Local_Variant(pdest, "localclear", &tempvar);

pcurrentscript = temp;

}

}

//safe copy method

void Script_Copy(Script *pdest, Script *psrc, int localclear)

{

if(!psrc->initialized)

{

return;

}

if(pdest->initialized)

{

Script_Clear(pdest, localclear);

}

pdest->pinterpreter = psrc->pinterpreter;

pdest->comment = psrc->comment;

pdest->interpreterowner = 0; // dont own it

pdest->initialized = psrc->initialized; //just copy, it should be 1

execute_init_method(pdest, 1, localclear);

}

void Script_Clear(Script *pscript, int localclear)

{

Script *temp;

Varlist *pvars;

ScriptVariant tempvar;

//Execute clear method

if(pscript->initialized && pscript->pinterpreter->pClearEntry)

{

temp = pcurrentscript;

pcurrentscript = pscript;

ScriptVariant_Init(&tempvar);

ScriptVariant_ChangeType(&tempvar, VT_INTEGER);

tempvar.lVal = (LONG)localclear;

Script_Set_Local_Variant(pscript, "localclear", &tempvar);

Interpreter_Reset(pscript->pinterpreter);

pscript->pinterpreter->pCurrentInstruction = pscript->pinterpreter->pClearEntry;

if(FAILED( Interpreter_EvaluateCall(pscript->pinterpreter)))

{

borShutdown(1, "Fatal: failed to execute 'clear' in script %s %s", pscript->pinterpreter->theSymbolTable.name, pscript->comment ? pscript->comment : "");

}

pscript->pinterpreter->bReset = FALSE; // not needed, perhaps

ScriptVariant_Clear(&tempvar);

Script_Set_Local_Variant(pscript, "localclear", &tempvar);

pcurrentscript = temp;

}

if(localclear && pscript->varlist)

{

if(localclear == 2)

{

Varlist_Clear(pscript->varlist);

free(pscript->varlist);

pscript->varlist = NULL;

}

else

{

Varlist_Cleanup(pscript->varlist);

}

}

if(!pscript->initialized)

{

return;

}

//if it is the owner, free the interpreter

if(pscript->pinterpreter && pscript->interpreterowner)

{

Interpreter_Clear(pscript->pinterpreter);

free(pscript->pinterpreter);

pscript->pinterpreter = NULL;

if(pscript->comment)

{

free(pscript->comment);

}

pscript->comment = NULL;

}

pvars = pscript->varlist; // in game clear(localclear!=2) just keep this value

memset(pscript, 0, sizeof(*pscript));

pscript->varlist = pvars; // copy it back

}

//append part of the script

//Because the script might not be initialized in 1 time.

int Script_AppendText(Script *pscript, char *text, char *path)

{

int success;

//printf(text);

Interpreter_Reset(pscript->pinterpreter);

success = SUCCEEDED(Interpreter_ParseText(pscript->pinterpreter, text, 1, path));

return success;

}

/* Replace string constants with enum constants at compile time to speed up

script execution. */

int Script_MapStringConstants(Instruction *pInstruction)

{

ScriptVariant **params;

int paramCount;

int (*pMapstrings)(ScriptVariant **, int);

if(pInstruction->functionRef)

{

params = (ScriptVariant **)pInstruction->theRefList->solidlist;

paramCount = (int)pInstruction->theRef->lVal;

assert(paramCount <= 32);

// Get the pointer to the correct mapstrings function, if one exists.

pMapstrings = Script_GetStringMapFunction(pInstruction->functionRef);

if(pMapstrings)

{

// Call the mapstrings function.

if(!pMapstrings(params, paramCount))

{

return 0;

}

}

}

return 1;

}

//should be called only once after parsing text

int Script_Compile(Script *pscript)

{

int result;

if(!pscript || !pscript->pinterpreter)

{

return 1;

}

//Interpreter_OutputPCode(pscript->pinterpreter, "code");

result = SUCCEEDED(Interpreter_CompileInstructions(pscript->pinterpreter));

if(!result)

{

borShutdown(1, "Can't compile script '%s' %s\n", pscript->pinterpreter->theSymbolTable.name, pscript->comment ? pscript->comment : "");

}

pscript->pinterpreter->bReset = FALSE;

execute_init_method(pscript, 0, 1);

return result;

}

int Script_IsInitialized(Script *pscript)

{

//if(pscript && pscript->initialized) pcurrentscript = pscript; //used by local script functions

return pscript->initialized;

}

//execute the script

int Script_Execute(Script *pscript)

{

int result, nested;

extern int no_cmd_compatible;

Script *temp = pcurrentscript;

Interpreter tinter, *pinter;

pcurrentscript = pscript; //used by local script functions

nested = pscript->pinterpreter->bReset;

if(no_nested_script && nested)

{

result = 1;

}

else

{

pinter = pscript->pinterpreter;

if(nested && no_cmd_compatible)

{

tinter = *pinter;

}

Interpreter_Reset(pinter);

result = (int)SUCCEEDED(Interpreter_EvaluateImmediate(pinter));

if(nested && no_cmd_compatible)

{

*pinter = tinter;

}

else if(nested)

{

pinter->bReset = FALSE;

}

}

pcurrentscript = temp;

if(!result)

{

borShutdown(1, "There's an exception while executing script '%s' %s", pscript->pinterpreter->theSymbolTable.name, pscript->comment ? pscript->comment : "");

}

return result;

}

static s_collision_attack attack;

//////////////////////////////////////////////////////////

//////////// system functions

//////////////////////////////////////////////////////////

//isempty(var);

HRESULT system_isempty(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

if(paramCount != 1)

{

*pretvar = NULL;

return E_FAIL;

}

ScriptVariant_ChangeType(*pretvar, VT_INTEGER);

(*pretvar)->lVal = (LONG)( (varlist[0])->vt == VT_EMPTY );

return S_OK;

}

//NULL();

HRESULT system_NULL(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

ScriptVariant_Clear(*pretvar);

return S_OK;

}

HRESULT system_exit(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

*pretvar = NULL;

pcurrentscript->pinterpreter->bReset = FALSE;

return S_OK;

}

HRESULT system_rand(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

ScriptVariant_ChangeType(*pretvar, VT_INTEGER);

(*pretvar)->lVal = (LONG)rand32();

return S_OK;

}

HRESULT system_srand(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

LONG ltemp;

*pretvar = NULL;

if(paramCount != 1)

{

return E_FAIL;

}

if(FAILED(ScriptVariant_IntegerValue(varlist[0], &ltemp)))

{

return E_FAIL;

}

srand32(ltemp);

return S_OK;

}

//getglobalvar(varname);

HRESULT system_getglobalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

LONG ltemp;

ScriptVariant *ptmpvar;

if(paramCount != 1)

{

goto ggv_error;

}

if(varlist[0]->vt == VT_STR)

{

ptmpvar = Varlist_GetByName(&global_var_list, StrCache_Get(varlist[0]->strVal));

}

else if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[0], &ltemp)))

{

ptmpvar = Varlist_GetByIndex(&global_var_list, (LONG)ltemp);

}

else

{

goto ggv_error;

}

if(ptmpvar)

{

ScriptVariant_Copy(*pretvar, ptmpvar);

}

else

{

ScriptVariant_Clear(*pretvar);

}

return S_OK;

ggv_error:

*pretvar = NULL;

return E_FAIL;

}

//setglobalvar(varname, value);

HRESULT system_setglobalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

LONG ltemp;

if(paramCount < 2)

{

goto sgv_error;

}

ScriptVariant_ChangeType(*pretvar, VT_INTEGER);

if(varlist[0]->vt == VT_STR)

{

(*pretvar)->lVal = (LONG)Varlist_SetByName(&global_var_list, StrCache_Get(varlist[0]->strVal), varlist[1]);

}

else if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[0], &ltemp)))

{

(*pretvar)->lVal = (LONG)Varlist_SetByIndex(&global_var_list, (LONG)ltemp, varlist[1]);

}

else

{

goto sgv_error;

}

return S_OK;

sgv_error:

*pretvar = NULL;

return E_FAIL;

}

//getlocalvar(varname);

HRESULT system_getlocalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

LONG ltemp;

ScriptVariant *ptmpvar;

if(paramCount != 1)

{

goto glv_error;

}

if(varlist[0]->vt == VT_STR)

{

ptmpvar = Varlist_GetByName(pcurrentscript->varlist, StrCache_Get(varlist[0]->strVal));

}

else if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[0], &ltemp)))

{

ptmpvar = Varlist_GetByIndex(pcurrentscript->varlist, (LONG)ltemp);

}

else

{

goto glv_error;

}

if(ptmpvar)

{

ScriptVariant_Copy(*pretvar, ptmpvar);

}

else

{

ScriptVariant_Clear(*pretvar);

}

return S_OK;

glv_error:

*pretvar = NULL;

return E_FAIL;

}

//setlocalvar(varname, value);

HRESULT system_setlocalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

LONG ltemp;

if(paramCount < 2)

{

goto slv_error;

}

ScriptVariant_ChangeType(*pretvar, VT_INTEGER);

if(varlist[0]->vt == VT_STR)

{

(*pretvar)->lVal = (LONG)Varlist_SetByName(pcurrentscript->varlist, StrCache_Get(varlist[0]->strVal), varlist[1]);

}

else if(SUCCEEDED(ScriptVariant_IntegerValue(varlist[0], &ltemp)))

{

(*pretvar)->lVal = (LONG)Varlist_SetByIndex(pcurrentscript->varlist, (LONG)ltemp, varlist[1]);

}

else

{

goto slv_error;

}

return S_OK;

slv_error:

*pretvar = NULL;

return E_FAIL;

}

//clearlocalvar();

HRESULT system_clearlocalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

*pretvar = NULL;

Varlist_Cleanup(pcurrentscript->varlist);

return S_OK;

}

//clearglobalvar();

HRESULT system_clearglobalvar(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

*pretvar = NULL;

Varlist_Cleanup(&global_var_list);

return S_OK;

}

//free();

HRESULT system_free(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

*pretvar = NULL;

if(paramCount < 1)

{

return E_FAIL;

}

if(List_Includes(&scriptheap, varlist[0]->ptrVal))

{

_freeheapnode(List_Retrieve(&scriptheap));

// a script's ondestroy() may free something else and change the list

// position, so set the position to this variant again

List_Includes(&scriptheap, varlist[0]->ptrVal);

List_Remove(&scriptheap);

return S_OK;

}

return E_FAIL;

}

//typeof(v);

HRESULT system_typeof(ScriptVariant **varlist , ScriptVariant **pretvar, int paramCount)

{

if(paramCount < 1)

{

*pretvar = NULL;

return E_FAIL;

}

ScriptVariant_ChangeType(*pretvar, VT_INTEGER);

(*pretvar)->lVal = (LONG)varlist[0]->vt;

return S_OK;

}

//////////////////////////////////////////////////////////

//////////// openbor functions

//////////////////////////////////////////////////////////

//check openborscript.h for systemvariant_enum

// arranged list, for searching

static const char *svlist[] =

{

"background",

"blockade",

"bossescount",

"branchname",

"cheats",

"count_enemies",

"count_entities",

"count_npcs",

"count_players",

"current_branch",

"current_level",

"current_palette",

"current_scene",

"current_set",

"current_stage",

"effectvol",

"elapsed_time",

"ent_max",

"fps",

"freeram",

"game_paused",

"game_speed",

"game_time",

"gfx_x_offset",

"gfx_y_offset",

"gfx_y_offset_adj",

"hresolution",

"in_cheat_options",

"in_control_options",

"in_enginecreditsscreen",

"in_gameoverscreen",

"in_halloffamescreen",

"in_level",

"in_load_game",

"in_menuscreen",

"in_new_game",

"in_options",

"in_selectscreen",

"in_showcomplete",

"in_sound_options",

"in_start_game",

"in_system_options",

"in_titlescreen",

"in_video_options",

"lasthita",

"lasthitc",

"lasthitt",

"lasthitx",

"lasthity",

"lasthitz",

"levelheight",

"levelpos",

"levelwidth",

"lightx",

"lightz",

"maxanimations",

"maxattacktypes",

"maxentityvars",

"maxglobalvars",

"maxindexedvars",

"maxplayers",

"maxscriptvars",

"maxsoundchannels",

"models_cached",

"models_loaded",

"musicvol",

"nofadeout",

"nogameover",

"nohof",

"nojoin",

"nopause",

"nosave",

"noscreenshot",

"noshowcomplete",

"numbasemaps",

"numbosses",