-Split prvm_cmds.c into prvm_cmds.c, prvm_cmds.h and mvm_cmds.c (clvm_cmds.c
authorblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Tue, 24 May 2005 22:30:18 +0000 (22:30 +0000)
committerblack <black@d7cf8633-e32d-0410-b094-e92efae38249>
Tue, 24 May 2005 22:30:18 +0000 (22:30 +0000)
 and svm_cmds.c will perhaps be added soon)
-Added another union to prvm_edict_s to have different pointers to the
 edict fields.
-Changed the naming of some fields in prvm_edict_s (longer names instead of
 single letter ones)
-Changed PRVM_LoadProgs to only reset the CMD system if it has be initialized
 before.

git-svn-id: svn://svn.icculus.org/twilight/trunk/darkplaces@5329 d7cf8633-e32d-0410-b094-e92efae38249

mvm_cmds.c [new file with mode: 0644]
progsvm.h
prvm_cmds.c
prvm_cmds.h [new file with mode: 0644]
prvm_edict.c
prvm_execprogram.h

diff --git a/mvm_cmds.c b/mvm_cmds.c
new file mode 100644 (file)
index 0000000..5636ad0
--- /dev/null
@@ -0,0 +1,842 @@
+#include "prvm_cmds.h"
+
+//============================================================================
+// Menu
+
+char *vm_m_extensions =
+"DP_CINEMATIC_DPV";
+
+/*
+=========
+VM_M_setmousetarget
+
+setmousetarget(float target)
+=========
+*/
+void VM_M_setmousetarget(void)
+{
+       VM_SAFEPARMCOUNT(1, VM_M_setmousetarget);
+
+       switch((int)PRVM_G_FLOAT(OFS_PARM0))
+       {
+       case 1:
+               in_client_mouse = false;
+               break;
+       case 2:
+               in_client_mouse = true;
+               break;
+       default:
+               PRVM_ERROR("VM_M_setmousetarget: wrong destination %i !\n",PRVM_G_FLOAT(OFS_PARM0));
+       }
+}
+
+/*
+=========
+VM_M_getmousetarget
+
+float  getmousetarget
+=========
+*/
+void VM_M_getmousetarget(void)
+{
+       VM_SAFEPARMCOUNT(0,VM_M_getmousetarget);
+
+       if(in_client_mouse)
+               PRVM_G_FLOAT(OFS_RETURN) = 2;
+       else
+               PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+
+
+
+/*
+=========
+VM_M_setkeydest
+
+setkeydest(float dest)
+=========
+*/
+void VM_M_setkeydest(void)
+{
+       VM_SAFEPARMCOUNT(1,VM_M_setkeydest);
+
+       switch((int)PRVM_G_FLOAT(OFS_PARM0))
+       {
+       case 0:
+               // key_game
+               key_dest = key_game;
+               break;
+       case 2:
+               // key_menu
+               key_dest = key_menu;
+               break;
+       case 1:
+               // key_message
+               // key_dest = key_message
+               // break;
+       default:
+               PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]);
+       }
+}
+
+/*
+=========
+VM_M_getkeydest
+
+float  getkeydest
+=========
+*/
+void VM_M_getkeydest(void)
+{
+       VM_SAFEPARMCOUNT(0,VM_M_getkeydest);
+
+       // key_game = 0, key_message = 1, key_menu = 2, unknown = 3
+       switch(key_dest)
+       {
+       case key_game:
+               PRVM_G_FLOAT(OFS_RETURN) = 0;
+               break;
+       case key_menu:
+               PRVM_G_FLOAT(OFS_RETURN) = 2;
+               break;
+       case key_message:
+               // not supported
+               // PRVM_G_FLOAT(OFS_RETURN) = 1;
+               // break;
+       default:
+               PRVM_G_FLOAT(OFS_RETURN) = 3;
+       }
+}
+
+/*
+=========
+VM_M_callfunction
+
+       callfunction(...,string function_name)
+Extension: pass
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_M_callfunction(void)
+{
+       mfunction_t *func;
+       const char *s;
+
+       if(prog->argc == 0)
+               PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n");
+
+       s = PRVM_G_STRING(OFS_PARM0 + (prog->argc - 1));
+
+       if(!s)
+               PRVM_ERROR("VM_M_callfunction: null string !\n");
+
+       VM_CheckEmptyString(s);
+
+       func = PRVM_ED_FindFunction(s);
+
+       if(!func)
+               PRVM_ERROR("VM_M_callfunciton: function %s not found !\n", s);
+       else if (func->first_statement < 0)
+       {
+               // negative statements are built in functions
+               int builtinnumber = -func->first_statement;
+               prog->xfunction->builtinsprofile++;
+               if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
+                       prog->builtins[builtinnumber]();
+               else
+                       PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
+       }
+       else if(func > 0)
+       {
+               prog->argc--;
+               PRVM_ExecuteProgram(func - prog->functions,"");
+               prog->argc++;
+       }
+}
+
+/*
+=========
+VM_M_isfunction
+
+float  isfunction(string function_name)
+=========
+*/
+mfunction_t *PRVM_ED_FindFunction (const char *name);
+void VM_M_isfunction(void)
+{
+       mfunction_t *func;
+       const char *s;
+
+       VM_SAFEPARMCOUNT(1, VM_M_isfunction);
+
+       s = PRVM_G_STRING(OFS_PARM0);
+
+       if(!s)
+               PRVM_ERROR("VM_M_isfunction: null string !\n");
+
+       VM_CheckEmptyString(s);
+
+       func = PRVM_ED_FindFunction(s);
+
+       if(!func)
+               PRVM_G_FLOAT(OFS_RETURN) = false;
+       else
+               PRVM_G_FLOAT(OFS_RETURN) = true;
+}
+
+/*
+=========
+VM_M_writetofile
+
+       writetofile(float fhandle, entity ent)
+=========
+*/
+void VM_M_writetofile(void)
+{
+       prvm_edict_t * ent;
+       qfile_t *file;
+
+       VM_SAFEPARMCOUNT(2, VM_M_writetofile);
+
+       file = VM_GetFileHandle( PRVM_G_FLOAT(OFS_PARM0) );
+       if( !file ) {
+               return;
+       }
+       
+       ent = PRVM_G_EDICT(OFS_PARM1);
+       if(ent->priv.required->free)
+       {
+               Con_Printf("VM_M_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_EDICT_NUM(OFS_PARM1));
+               return;
+       }
+
+       PRVM_ED_Write (file, ent);
+}
+
+/*
+=========
+VM_M_getresolution
+
+vector getresolution(float number)
+=========
+*/
+extern unsigned short video_resolutions[][2];
+void VM_M_getresolution(void)
+{
+       int nr;
+       VM_SAFEPARMCOUNT(1, VM_getresolution);
+
+       nr = PRVM_G_FLOAT(OFS_PARM0);
+
+
+       PRVM_G_VECTOR(OFS_RETURN)[0] = video_resolutions[nr][0];
+       PRVM_G_VECTOR(OFS_RETURN)[1] = video_resolutions[nr][1];
+       PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
+}
+
+/*
+=========
+VM_M_keynumtostring
+
+string keynumtostring(float keynum)
+=========
+*/
+void VM_M_keynumtostring(void)
+{
+       int keynum;
+       char *tmp;
+       VM_SAFEPARMCOUNT(1, VM_M_keynumtostring);
+
+       keynum = PRVM_G_FLOAT(OFS_PARM0);
+
+       tmp = VM_GetTempString();
+
+       strcpy(tmp, Key_KeynumToString(keynum));
+
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
+}
+
+/*
+=========
+VM_M_stringtokeynum
+
+float stringtokeynum(string key)
+=========
+*/
+void VM_M_stringtokeynum( void )
+{
+       const char *str;
+       VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring );
+
+       str = PRVM_G_STRING( OFS_PARM0 );
+
+       PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str );
+}
+
+/*
+=========
+VM_M_findkeysforcommand
+
+string findkeysforcommand(string command)
+
+the returned string is an altstring
+=========
+*/
+#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
+
+void M_FindKeysForCommand(const char *command, int *keys);
+void VM_M_findkeysforcommand(void)
+{
+       const char *cmd;
+       char *ret;
+       int keys[NUMKEYS];
+       int i;
+
+       VM_SAFEPARMCOUNT(1, VM_M_findkeysforcommand);
+
+       cmd = PRVM_G_STRING(OFS_PARM0);
+
+       VM_CheckEmptyString(cmd);
+
+       (ret = VM_GetTempString())[0] = 0;
+
+       M_FindKeysForCommand(cmd, keys);
+
+       for(i = 0; i < NUMKEYS; i++)
+               ret = strcat(ret, va(" \'%i\'", keys[i]));
+
+       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(ret);
+}
+
+/*
+=========
+VM_M_getserverliststat
+
+float  getserverliststat(float type)
+=========
+*/
+/*
+       type:
+0      serverlist_viewcount
+1   serverlist_totalcount
+2      masterquerycount
+3      masterreplycount
+4      serverquerycount
+5      serverreplycount
+6      sortfield
+7      sortdescending
+*/
+void VM_M_getserverliststat( void )
+{
+       int type;
+       VM_SAFEPARMCOUNT ( 1, VM_M_getserverliststat );
+
+       PRVM_G_FLOAT( OFS_RETURN ) = 0;
+
+       type = PRVM_G_FLOAT( OFS_PARM0 );
+       switch(type)
+       {
+       case 0:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_viewcount;
+               return;
+       case 1:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_cachecount;
+       case 2:
+               PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
+               return;
+       case 3:
+               PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
+               return;
+       case 4:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
+               return;
+       case 5:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
+               return;
+       case 6:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortbyfield;
+               return;
+       case 7:
+               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortdescending;
+               return;
+       default:
+               Con_Printf( "VM_M_getserverliststat: bad type %i!\n", type );
+       }
+}
+
+/*
+========================
+VM_M_resetserverlistmasks
+
+resetserverlistmasks()
+========================
+*/
+void VM_M_resetserverlistmasks( void )
+{
+       ServerList_ResetMasks();
+}
+
+
+/*
+========================
+VM_M_setserverlistmaskstring
+
+setserverlistmaskstring(float mask, float fld, string str, float op)
+0-511          and
+512 - 1024     or
+========================
+*/
+void VM_M_setserverlistmaskstring( void )
+{
+       const char *str;
+       int masknr;
+       serverlist_mask_t *mask;
+       int field;
+
+       VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmaskstring );
+       str = PRVM_G_STRING( OFS_PARM1 );
+       if( !str )
+               PRVM_ERROR( "VM_M_setserverlistmaskstring: null string passed!" );
+
+       masknr = PRVM_G_FLOAT( OFS_PARM0 );
+       if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
+               mask = &serverlist_andmasks[masknr];
+       else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
+               mask = &serverlist_ormasks[masknr - 512 ];
+       else {
+               Con_Printf( "VM_M_setserverlistmaskstring: invalid mask number %i\n", masknr );
+               return;
+       }
+
+       field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+       switch( field ) {
+               case SLIF_CNAME:
+                       strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
+                       break;
+               case SLIF_NAME:
+                       strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name)  );
+                       break;
+               case SLIF_MAP:
+                       strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map)  );
+                       break;
+               case SLIF_MOD:
+                       strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod)  );
+                       break;
+               case SLIF_GAME:
+                       strncpy( mask->info.game, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.game)  );
+                       break;
+               default:
+                       Con_Printf( "VM_M_setserverlistmaskstring: Bad field number %i passed!\n", field );
+                       return;
+       }
+
+       mask->active = true;
+       mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
+}
+
+/*
+========================
+VM_M_setserverlistmasknumber
+
+setserverlistmasknumber(float mask, float fld, float num, float op)
+
+0-511          and
+512 - 1024     or
+========================
+*/
+void VM_M_setserverlistmasknumber( void )
+{
+       int number;
+       serverlist_mask_t *mask;
+       int     masknr;
+       int field;
+       VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmasknumber );
+
+       masknr = PRVM_G_FLOAT( OFS_PARM0 );
+       if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
+               mask = &serverlist_andmasks[masknr];
+       else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
+               mask = &serverlist_ormasks[masknr - 512 ];
+       else {
+               Con_Printf( "VM_M_setserverlistmasknumber: invalid mask number %i\n", masknr );
+               return;
+       }
+
+       number = PRVM_G_FLOAT( OFS_PARM2 );
+       field = (int) PRVM_G_FLOAT( OFS_PARM1 );
+
+       switch( field ) {
+               case SLIF_MAXPLAYERS:
+                       mask->info.maxplayers = number;
+                       break;
+               case SLIF_NUMPLAYERS:
+                       mask->info.numplayers = number;
+                       break;
+               case SLIF_PING:
+                       mask->info.ping = number;
+                       break;
+               case SLIF_PROTOCOL:
+                       mask->info.protocol = number;
+                       break;
+               default:
+                       Con_Printf( "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field );
+                       return;
+       }
+
+       mask->active = true;
+       mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
+}
+
+
+/*
+========================
+VM_M_resortserverlist
+
+resortserverlist
+========================
+*/
+void VM_M_resortserverlist( void )
+{
+       ServerList_RebuildViewList();
+}
+
+/*
+=========
+VM_M_getserverliststring
+
+string getserverliststring(float field, float hostnr)
+=========
+*/
+void VM_M_getserverliststring(void)
+{
+       serverlist_entry_t *cache;
+       int hostnr;
+
+       VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
+
+       PRVM_G_INT(OFS_RETURN) = 0;
+
+       hostnr = PRVM_G_FLOAT(OFS_PARM1);
+
+       if(hostnr < 0 || hostnr >= serverlist_viewcount)
+       {
+               Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
+               return;
+       }
+       cache = serverlist_viewlist[hostnr];
+       switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+               case SLIF_CNAME:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.cname );
+                       break;
+               case SLIF_NAME:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.name );
+                       break;
+               case SLIF_GAME:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.game );
+                       break;
+               case SLIF_MOD:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.mod );
+                       break;
+               case SLIF_MAP:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.map );
+                       break;
+               // TODO remove this again
+               case 1024:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line1 );
+                       break;
+               case 1025:
+                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line2 );
+                       break;
+               default:
+                       Con_Print("VM_M_getserverliststring: bad field number passed!\n");
+       }
+}
+
+/*
+=========
+VM_M_getserverlistnumber
+
+float  getserverlistnumber(float field, float hostnr)
+=========
+*/
+void VM_M_getserverlistnumber(void)
+{
+       serverlist_entry_t *cache;
+       int hostnr;
+
+       VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
+
+       PRVM_G_INT(OFS_RETURN) = 0;
+
+       hostnr = PRVM_G_FLOAT(OFS_PARM1);
+
+       if(hostnr < 0 || hostnr >= serverlist_viewcount)
+       {
+               Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
+               return;
+       }
+       cache = serverlist_viewlist[hostnr];
+       switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
+               case SLIF_MAXPLAYERS:
+                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers;
+                       break;
+               case SLIF_NUMPLAYERS:
+                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.numplayers;
+                       break;
+               case SLIF_PING:
+                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping;
+                       break;
+               case SLIF_PROTOCOL:
+                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol;
+                       break;
+               default:
+                       Con_Print("VM_M_getserverlistnumber: bad field number passed!\n");
+       }
+}
+
+/*
+========================
+VM_M_setserverlistsort
+
+setserverlistsort(float field, float descending)
+========================
+*/
+void VM_M_setserverlistsort( void )
+{
+       VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort );
+
+       serverlist_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
+       serverlist_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
+}
+
+/*
+========================
+VM_M_refreshserverlist
+
+refreshserverlist()
+========================
+*/
+void VM_M_refreshserverlist( void )
+{
+       VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist );
+       ServerList_QueryList();
+}
+
+/*
+========================
+VM_M_getserverlistindexforkey
+
+float getserverlistindexforkey(string key)
+========================
+*/
+void VM_M_getserverlistindexforkey( void )
+{
+       const char *key;
+       VM_SAFEPARMCOUNT( 1, VM_M_getserverlistindexforkey );
+
+       key = PRVM_G_STRING( OFS_PARM0 );
+       VM_CheckEmptyString( key );
+
+       if( !strcmp( key, "cname" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CNAME;
+       else if( !strcmp( key, "ping" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PING;
+       else if( !strcmp( key, "game" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_GAME;
+       else if( !strcmp( key, "mod" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MOD;
+       else if( !strcmp( key, "map" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAP;
+       else if( !strcmp( key, "name" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NAME;
+       else if( !strcmp( key, "maxplayers" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAXPLAYERS;
+       else if( !strcmp( key, "numplayers" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NUMPLAYERS;
+       else if( !strcmp( key, "protocol" ) )
+               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PROTOCOL;
+       else
+               PRVM_G_FLOAT( OFS_RETURN ) = -1;
+}
+
+/*
+========================
+VM_M_addwantedserverlistkey
+
+addwantedserverlistkey(string key)
+========================
+*/
+void VM_M_addwantedserverlistkey( void )
+{
+       VM_SAFEPARMCOUNT( 1, VM_M_addwantedserverlistkey );
+}
+
+prvm_builtin_t vm_m_builtins[] = {
+       0, // to be consistent with the old vm
+       // common builtings (mostly)
+       VM_checkextension,
+       VM_error,
+       VM_objerror,
+       VM_print,
+       VM_bprint,
+       VM_sprint,
+       VM_centerprint,
+       VM_normalize,
+       VM_vlen,
+       VM_vectoyaw,    // #10
+       VM_vectoangles,
+       VM_random,
+       VM_localcmd,
+       VM_cvar,
+       VM_cvar_set,
+       VM_dprint,
+       VM_ftos,
+       VM_fabs,
+       VM_vtos,
+       VM_etos,                // 20
+       VM_stof,
+       VM_spawn,
+       VM_remove,
+       VM_find,
+       VM_findfloat,
+       VM_findchain,
+       VM_findchainfloat,
+       VM_precache_file,
+       VM_precache_sound,
+       VM_coredump,    // 30
+       VM_traceon,
+       VM_traceoff,
+       VM_eprint,
+       VM_rint,
+       VM_floor,
+       VM_ceil,
+       VM_nextent,
+       VM_sin,
+       VM_cos,
+       VM_sqrt,                // 40
+       VM_randomvec,
+       VM_registercvar,
+       VM_min,
+       VM_max,
+       VM_bound,
+       VM_pow,
+       VM_copyentity,
+       VM_fopen,
+       VM_fclose,
+       VM_fgets,               // 50
+       VM_fputs,
+       VM_strlen,
+       VM_strcat,
+       VM_substring,
+       VM_stov,
+       VM_strzone,
+       VM_strunzone,
+       VM_tokenize,
+       VM_argv,
+       VM_isserver,    // 60
+       VM_clientcount,
+       VM_clientstate,
+       VM_clcommand,
+       VM_changelevel,
+       VM_localsound,
+       VM_getmousepos,
+       VM_gettime,
+       VM_loadfromdata,
+       VM_loadfromfile,
+       VM_modulo,              // 70
+       VM_cvar_string,
+       VM_crash,
+       VM_stackdump,   // 73
+       VM_search_begin,
+       VM_search_end,
+       VM_search_getsize,
+       VM_search_getfilename, // 77
+       VM_chr,
+       VM_itof,
+       VM_ftoi,                // 80
+       VM_itof,                // isString
+       VM_altstr_count,
+       VM_altstr_prepare,
+       VM_altstr_get,
+       VM_altstr_set,
+       VM_altstr_ins,  // 86
+       0,0,0,0,        // 90
+       e10,                    // 100
+       e100,                   // 200
+       e100,                   // 300
+       e100,                   // 400
+       // msg functions
+       VM_WriteByte,
+       VM_WriteChar,
+       VM_WriteShort,
+       VM_WriteLong,
+       VM_WriteAngle,
+       VM_WriteCoord,
+       VM_WriteString,
+       VM_WriteEntity, // 408
+       0,
+       0,                              // 410
+       e10,                    // 420
+       e10,                    // 430
+       e10,                    // 440
+       e10,                    // 450
+       // draw functions
+       VM_iscachedpic,
+       VM_precache_pic,
+       VM_freepic,
+       VM_drawcharacter,
+       VM_drawstring,
+       VM_drawpic,
+       VM_drawfill,
+       VM_drawsetcliparea,
+       VM_drawresetcliparea,
+       VM_getimagesize,// 460
+       VM_cin_open,
+       VM_cin_close,
+       VM_cin_setstate,
+       VM_cin_getstate,
+       VM_cin_restart, // 465
+       0,0,0,0,0,      // 470
+       e10,                    // 480
+       e10,                    // 490
+       e10,                    // 500
+       e100,                   // 600
+       // menu functions
+       VM_M_setkeydest,
+       VM_M_getkeydest,
+       VM_M_setmousetarget,
+       VM_M_getmousetarget,
+       VM_M_callfunction,
+       VM_M_writetofile,
+       VM_M_isfunction,
+       VM_M_getresolution,
+       VM_M_keynumtostring,
+       VM_M_findkeysforcommand,// 610
+       VM_M_getserverliststat,
+       VM_M_getserverliststring,
+       VM_parseentitydata,
+       VM_M_stringtokeynum,
+       VM_M_resetserverlistmasks,
+       VM_M_setserverlistmaskstring,
+       VM_M_setserverlistmasknumber,
+       VM_M_resortserverlist,
+       VM_M_setserverlistsort,
+       VM_M_refreshserverlist,
+       VM_M_getserverlistnumber,
+       VM_M_getserverlistindexforkey,
+       VM_M_addwantedserverlistkey // 623
+};
+
+const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
+
+void VM_M_Cmd_Init(void)
+{
+       VM_Cmd_Init();
+}
+
+void VM_M_Cmd_Reset(void)
+{
+       //VM_Cmd_Init();
+       VM_Cmd_Reset();
+}
index 7893668..4f51861 100644 (file)
--- a/progsvm.h
+++ b/progsvm.h
@@ -172,7 +172,7 @@ typedef struct prvm_edict_s
        //edict_engineprivate_t *e;
        union
        {
        //edict_engineprivate_t *e;
        union
        {
-               prvm_edict_private_t *e;
+               prvm_edict_private_t *required;
                void                             *vp;
                // add other private structs as you desire
                // new structs have to start with the elements of prvm_edit_private_t
                void                             *vp;
                // add other private structs as you desire
                // new structs have to start with the elements of prvm_edit_private_t
@@ -190,10 +190,13 @@ typedef struct prvm_edict_s
                //      vec3_t moved_fromangles;
                //              ... } server_edict_private_t;
                // However, the first one should be preferred.
                //      vec3_t moved_fromangles;
                //              ... } server_edict_private_t;
                // However, the first one should be preferred.
-       } p;
+       } priv;
        // QuakeC fields (stored in dynamically resized array)
        //entvars_t *v;
        // QuakeC fields (stored in dynamically resized array)
        //entvars_t *v;
-       void *v;
+       union 
+       {
+               void *vp;
+       } fields;
 } prvm_edict_t;
 
 #define PRVM_GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (prvm_eval_t *)((qbyte *)ed->v + fieldoffset) : NULL)
 } prvm_edict_t;
 
 #define PRVM_GETEDICTFIELDVALUE(ed, fieldoffset) (fieldoffset ? (prvm_eval_t *)((qbyte *)ed->v + fieldoffset) : NULL)
@@ -436,10 +439,10 @@ prvm_edict_t *PRVM_EDICT_NUM_ERROR(int n, char *filename, int fileline);
 //#define      PRVM_G_FUNCTION(o) (*(func_t *)&prog->globals[o])
 
 // FIXME: make these go away?
 //#define      PRVM_G_FUNCTION(o) (*(func_t *)&prog->globals[o])
 
 // FIXME: make these go away?
-#define        PRVM_E_FLOAT(e,o) (((float*)e->v)[o])
-#define        PRVM_E_INT(e,o) (((int*)e->v)[o])
-//#define      PRVM_E_VECTOR(e,o) (&((float*)e->v)[o])
-#define        PRVM_E_STRING(e,o) (PRVM_GetString(*(string_t *)&((float*)e->v)[o]))
+#define        PRVM_E_FLOAT(e,o) (((float*)e->fields.vp)[o])
+#define        PRVM_E_INT(e,o) (((int*)e->fields.vp)[o])
+//#define      PRVM_E_VECTOR(e,o) (&((float*)e->fields.vp)[o])
+#define        PRVM_E_STRING(e,o) (PRVM_GetString(*(string_t *)&((float*)e->fields.vp)[o]))
 
 extern int             prvm_type_size[8]; // for consistency : I think a goal of this sub-project is to
 // make the new vm mostly independent from the old one, thus if it's necessary, I copy everything
 
 extern int             prvm_type_size[8]; // for consistency : I think a goal of this sub-project is to
 // make the new vm mostly independent from the old one, thus if it's necessary, I copy everything
index 8d1ba1e..55a7584 100644 (file)
@@ -4,195 +4,7 @@
 // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
 // also applies here
 
 // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
 // also applies here
 
-
-/*
-============================================================================
-common cmd list:
-=================
-
-               checkextension(string)
-               error(...[string])
-               objerror(...[string)
-               print(...[strings])
-               bprint(...[string])
-               sprint(float clientnum,...[string])
-               centerprint(...[string])
-vector normalize(vector)
-float  vlen(vector)
-float  vectoyaw(vector)
-vector vectoangles(vector)
-float  random()
-               cmd(string)
-               float cvar (string)
-               cvar_set (string,string)
-               dprint(...[string])
-string ftos(float)
-float  fabs(float)
-string vtos(vector)
-string etos(entity)
-float  stof(...[string])
-entity spawn()
-               remove(entity e)
-entity find(entity start, .string field, string match)
-
-entity findfloat(entity start, .float field, float match)
-entity findentity(entity start, .entity field, entity match)
-
-entity findchain(.string field, string match)
-
-entity findchainfloat(.string field, float match)
-entity findchainentity(.string field, entity match)
-
-string precache_file(string)
-string precache_sound (string sample)
-               coredump()
-               traceon()
-               traceoff()
-               eprint(entity e)
-float  rint(float)
-float  floor(float)
-float  ceil(float)
-entity nextent(entity)
-float  sin(float)
-float  cos(float)
-float  sqrt(float)
-vector randomvec()
-float  registercvar (string name, string value, float flags)
-float  min(float a, float b, ...[float])
-float  max(float a, float b, ...[float])
-float  bound(float min, float value, float max)
-float  pow(float a, float b)
-               copyentity(entity src, entity dst)
-float  fopen(string filename, float mode)
-               fclose(float fhandle)
-string fgets(float fhandle)
-               fputs(float fhandle, string s)
-float  strlen(string s)
-string strcat(string,string,...[string])
-string substring(string s, float start, float length)
-vector stov(string s)
-string strzone(string s)
-               strunzone(string s)
-float  tokenize(string s)
-string argv(float n)
-float  isserver()
-float  clientcount()
-float  clientstate()
-               clientcommand(float client, string s) (for client and menu)
-               changelevel(string map)
-               localsound(string sample)
-vector getmousepos()
-float  gettime()
-               loadfromdata(string data)
-               loadfromfile(string file)
-float  mod(float val, float m)
-const string   str_cvar (string)
-               crash()
-               stackdump()
-
-float  search_begin(string pattern, float caseinsensitive, float quiet)
-void   search_end(float handle)
-float  search_getsize(float handle)
-string search_getfilename(float handle, float num)
-
-string chr(float ascii)
-
-float  itof(intt ent)
-intt   ftoi(float num)
-
-float  altstr_count(string)
-string altstr_prepare(string)
-string altstr_get(string,float)
-string altstr_set(string altstr, float num, string set)
-string altstr_ins(string altstr, float num, string set)
-
-perhaps only : Menu : WriteMsg
-===============================
-
-               WriteByte(float data, float dest, float desto)
-               WriteChar(float data, float dest, float desto)
-               WriteShort(float data, float dest, float desto)
-               WriteLong(float data, float dest, float desto)
-               WriteAngle(float data, float dest, float desto)
-               WriteCoord(float data, float dest, float desto)
-               WriteString(string data, float dest, float desto)
-               WriteEntity(entity data, float dest, float desto)
-
-Client & Menu : draw functions & video functions
-===================================================
-
-float  iscachedpic(string pic)
-string precache_pic(string pic)
-               freepic(string s)
-float  drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
-float  drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
-float  drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
-float  drawfill(vector position, vector size, vector rgb, float alpha, float flag)
-               drawsetcliparea(float x, float y, float width, float height)
-               drawresetcliparea()
-vector getimagesize(string pic)
-
-float  cin_open(string file, string name)
-void   cin_close(string name)
-void   cin_setstate(string name, float type)
-float  cin_getstate(string name)
-void   cin_restart(string name)
-
-==============================================================================
-menu cmd list:
-===============
-
-               setkeydest(float dest)
-float  getkeydest()
-               setmousetarget(float target)
-float  getmousetarget()
-
-               callfunction(...,string function_name)
-               writetofile(float fhandle, entity ent)
-float  isfunction(string function_name)
-vector getresolution(float number)
-string keynumtostring(float keynum)
-string findkeysforcommand(string command)
-float  getserverliststat(float type)
-string getserverliststring(float fld, float hostnr)
-
-               parseentitydata(entity ent, string data)
-
-float  stringtokeynum(string key)
-
-               resetserverlistmasks()
-               setserverlistmaskstring(float mask, float fld, string str)
-               setserverlistmasknumber(float mask, float fld, float num, float op)
-               resortserverlist()
-               setserverlistsort(float field, float descending)
-               refreshserverlist()
-float  getserverlistnumber(float fld, float hostnr)
-float  getserverlistindexforkey(string key)
-               addwantedserverlistkey(string key)
-*/
-
-#include "quakedef.h"
-#include "progdefs.h"
-#include "progsvm.h"
-#include "clprogdefs.h"
-#include "mprogdefs.h"
-
-#include "cl_video.h"
-
-//============================================================================
-// nice helper macros
-
-#ifndef VM_NOPARMCHECK
-#define VM_SAFEPARMCOUNT(p,f)  if(prog->argc != p) PRVM_ERROR(#f " wrong parameter count (" #p " expected ) !\n")
-#else
-#define VM_SAFEPARMCOUNT(p,f)
-#endif
-
-#define        VM_RETURN_EDICT(e)              (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
-
-#define e10 0,0,0,0,0,0,0,0,0,0
-#define e100 e10,e10,e10,e10,e10,e10,e10,e10,e10,e10
-#define e1000 e100,e100,e100,e100,e100,e100,e100,e100,e100,e100
+#include "prvm_cmds.h"
 
 //============================================================================
 // Common
 
 //============================================================================
 // Common
@@ -218,7 +30,7 @@ qfile_t *vm_files[MAX_PRVMFILES];
 
 fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
 
 
 fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
 
-static char *VM_GetTempString(void)
+char *VM_GetTempString(void)
 {
        char *s;
        s = vm_string_temp[vm_string_tempindex];
 {
        char *s;
        s = vm_string_temp[vm_string_tempindex];
@@ -699,17 +511,17 @@ void VM_cvar (void)
 
 /*
 =================
 
 /*
 =================
-VM_str_cvar
+VM_cvar_string
 
 
-const string   str_cvar (string)
+const string   VM_cvar_string (string)
 =================
 */
 =================
 */
-void VM_str_cvar(void)
+void VM_cvar_string(void)
 {
        char *out;
        const char *name;
        const char *cvar_string;
 {
        char *out;
        const char *name;
        const char *cvar_string;
-       VM_SAFEPARMCOUNT(1,VM_str_cvar);
+       VM_SAFEPARMCOUNT(1,VM_cvar_string);
 
        name = PRVM_G_STRING(OFS_PARM0);
 
 
        name = PRVM_G_STRING(OFS_PARM0);
 
@@ -879,7 +691,7 @@ void VM_ftoi(void)
        VM_SAFEPARMCOUNT(1, VM_ftoi);
 
        ent = PRVM_G_FLOAT(OFS_PARM0);
        VM_SAFEPARMCOUNT(1, VM_ftoi);
 
        ent = PRVM_G_FLOAT(OFS_PARM0);
-       if(PRVM_PROG_TO_EDICT(ent)->p.e->free)
+       if(PRVM_PROG_TO_EDICT(ent)->priv.required->free)
                PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!\n", PRVM_NAME, ent);
 
        PRVM_G_INT(OFS_RETURN) = ent;
                PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!\n", PRVM_NAME, ent);
 
        PRVM_G_INT(OFS_RETURN) = ent;
@@ -956,7 +768,7 @@ void VM_find (void)
        {
                prog->xfunction->builtinsprofile++;
                ed = PRVM_EDICT_NUM(e);
        {
                prog->xfunction->builtinsprofile++;
                ed = PRVM_EDICT_NUM(e);
-               if (ed->p.e->free)
+               if (ed->priv.required->free)
                        continue;
                t = PRVM_E_STRING(ed,f);
                if (!t)
                        continue;
                t = PRVM_E_STRING(ed,f);
                if (!t)
@@ -997,7 +809,7 @@ void VM_findfloat (void)
        {
                prog->xfunction->builtinsprofile++;
                ed = PRVM_EDICT_NUM(e);
        {
                prog->xfunction->builtinsprofile++;
                ed = PRVM_EDICT_NUM(e);
-               if (ed->p.e->free)
+               if (ed->priv.required->free)
                        continue;
                if (PRVM_E_FLOAT(ed,f) == s)
                {
                        continue;
                if (PRVM_E_FLOAT(ed,f) == s)
                {
@@ -1049,7 +861,7 @@ void VM_findchain (void)
        for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                prog->xfunction->builtinsprofile++;
        for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                prog->xfunction->builtinsprofile++;
-               if (ent->p.e->free)
+               if (ent->priv.required->free)
                        continue;
                t = PRVM_E_STRING(ent,f);
                if (!t)
                        continue;
                t = PRVM_E_STRING(ent,f);
                if (!t)
@@ -1098,7 +910,7 @@ void VM_findchainfloat (void)
        for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                prog->xfunction->builtinsprofile++;
        for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
        {
                prog->xfunction->builtinsprofile++;
-               if (ent->p.e->free)
+               if (ent->priv.required->free)
                        continue;
                if (PRVM_E_FLOAT(ent,f) != s)
                        continue;
                        continue;
                if (PRVM_E_FLOAT(ent,f) != s)
                        continue;
@@ -1318,7 +1130,7 @@ void VM_nextent (void)
                        return;
                }
                ent = PRVM_EDICT_NUM(i);
                        return;
                }
                ent = PRVM_EDICT_NUM(i);
-               if (!ent->p.e->free)
+               if (!ent->priv.required->free)
                {
                        VM_RETURN_EDICT(ent);
                        return;
                {
                        VM_RETURN_EDICT(ent);
                        return;
@@ -1662,7 +1474,7 @@ void VM_copyentity (void)
        VM_SAFEPARMCOUNT(2,VM_copyentity);
        in = PRVM_G_EDICT(OFS_PARM0);
        out = PRVM_G_EDICT(OFS_PARM1);
        VM_SAFEPARMCOUNT(2,VM_copyentity);
        in = PRVM_G_EDICT(OFS_PARM0);
        out = PRVM_G_EDICT(OFS_PARM1);
-       memcpy(out->v, in->v, prog->progs->entityfields * 4);
+       memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4);
 }
 
 /*
 }
 
 /*
@@ -1718,6 +1530,21 @@ void VM_Files_CloseAll(void)
        memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?)
 }
 
        memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?)
 }
 
+qfile_t *VM_GetFileHandle( int index )
+{
+       if (index < 0 || index >= MAX_VMFILES)
+       {
+               Con_Printf("VM_GetFileHandle: invalid file handle %i used in %s\n", index, PRVM_NAME);
+               return NULL;
+       }
+       if (VM_FILES[index] == NULL)
+       {
+               Con_Printf("VM_GetFileHandle: no such file handle %i (or file has been closed) in %s\n", index, PRVM_NAME);
+               return NULL;
+       }
+       return VM_FILES[index];
+}
+
 /*
 =========
 VM_fopen
 /*
 =========
 VM_fopen
@@ -2276,12 +2103,12 @@ void VM_loadfromdata(void)
 
 /*
 ========================
 
 /*
 ========================
-VM_M_parseentitydata
+VM_parseentitydata
 
 parseentitydata(entity ent, string data)
 ========================
 */
 
 parseentitydata(entity ent, string data)
 ========================
 */
-void VM_M_parseentitydata(void)
+void VM_parseentitydata(void)
 {
        prvm_edict_t *ent;
        const char *data;
 {
        prvm_edict_t *ent;
        const char *data;
@@ -2290,7 +2117,7 @@ void VM_M_parseentitydata(void)
 
     // get edict and test it
        ent = PRVM_G_EDICT(OFS_PARM0);
 
     // get edict and test it
        ent = PRVM_G_EDICT(OFS_PARM0);
-       if (ent->p.e->free)
+       if (ent->priv.required->free)
                PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
 
        data = PRVM_G_STRING(OFS_PARM1);
                PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
 
        data = PRVM_G_STRING(OFS_PARM1);
@@ -3177,890 +3004,4 @@ void VM_Cmd_Reset(void)
        VM_Files_CloseAll();
 }
 
        VM_Files_CloseAll();
 }
 
-//============================================================================
-// Server
-
-char *vm_sv_extensions =
-"";
-
-prvm_builtin_t vm_sv_builtins[] = {
-0  // to be consistent with the old vm
-};
-
-const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t);
-
-void VM_SV_Cmd_Init(void)
-{
-}
-
-void VM_SV_Cmd_Reset(void)
-{
-}
-
-//============================================================================
-// Client
-
-char *vm_cl_extensions =
-"";
-
-prvm_builtin_t vm_cl_builtins[] = {
-0  // to be consistent with the old vm
-};
-
-const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
-
-void VM_CL_Cmd_Init(void)
-{
-}
-
-void VM_CL_Cmd_Reset(void)
-{
-}
-
-//============================================================================
-// Menu
-
-char *vm_m_extensions =
-"DP_CINEMATIC_DPV";
-
-/*
-=========
-VM_M_setmousetarget
-
-setmousetarget(float target)
-=========
-*/
-void VM_M_setmousetarget(void)
-{
-       VM_SAFEPARMCOUNT(1, VM_M_setmousetarget);
-
-       switch((int)PRVM_G_FLOAT(OFS_PARM0))
-       {
-       case 1:
-               in_client_mouse = false;
-               break;
-       case 2:
-               in_client_mouse = true;
-               break;
-       default:
-               PRVM_ERROR("VM_M_setmousetarget: wrong destination %i !\n",PRVM_G_FLOAT(OFS_PARM0));
-       }
-}
-
-/*
-=========
-VM_M_getmousetarget
-
-float  getmousetarget
-=========
-*/
-void VM_M_getmousetarget(void)
-{
-       VM_SAFEPARMCOUNT(0,VM_M_getmousetarget);
-
-       if(in_client_mouse)
-               PRVM_G_FLOAT(OFS_RETURN) = 2;
-       else
-               PRVM_G_FLOAT(OFS_RETURN) = 1;
-}
-
-
-
-/*
-=========
-VM_M_setkeydest
-
-setkeydest(float dest)
-=========
-*/
-void VM_M_setkeydest(void)
-{
-       VM_SAFEPARMCOUNT(1,VM_M_setkeydest);
-
-       switch((int)PRVM_G_FLOAT(OFS_PARM0))
-       {
-       case 0:
-               // key_game
-               key_dest = key_game;
-               break;
-       case 2:
-               // key_menu
-               key_dest = key_menu;
-               break;
-       case 1:
-               // key_message
-               // key_dest = key_message
-               // break;
-       default:
-               PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]);
-       }
-}
-
-/*
-=========
-VM_M_getkeydest
-
-float  getkeydest
-=========
-*/
-void VM_M_getkeydest(void)
-{
-       VM_SAFEPARMCOUNT(0,VM_M_getkeydest);
-
-       // key_game = 0, key_message = 1, key_menu = 2, unknown = 3
-       switch(key_dest)
-       {
-       case key_game:
-               PRVM_G_FLOAT(OFS_RETURN) = 0;
-               break;
-       case key_menu:
-               PRVM_G_FLOAT(OFS_RETURN) = 2;
-               break;
-       case key_message:
-               // not supported
-               // PRVM_G_FLOAT(OFS_RETURN) = 1;
-               // break;
-       default:
-               PRVM_G_FLOAT(OFS_RETURN) = 3;
-       }
-}
-
-/*
-=========
-VM_M_callfunction
-
-       callfunction(...,string function_name)
-Extension: pass
-=========
-*/
-mfunction_t *PRVM_ED_FindFunction (const char *name);
-void VM_M_callfunction(void)
-{
-       mfunction_t *func;
-       const char *s;
-
-       if(prog->argc == 0)
-               PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n");
-
-       s = PRVM_G_STRING(OFS_PARM0 + (prog->argc - 1));
-
-       if(!s)
-               PRVM_ERROR("VM_M_callfunction: null string !\n");
-
-       VM_CheckEmptyString(s);
-
-       func = PRVM_ED_FindFunction(s);
-
-       if(!func)
-               PRVM_ERROR("VM_M_callfunciton: function %s not found !\n", s);
-       else if (func->first_statement < 0)
-       {
-               // negative statements are built in functions
-               int builtinnumber = -func->first_statement;
-               prog->xfunction->builtinsprofile++;
-               if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
-                       prog->builtins[builtinnumber]();
-               else
-                       PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
-       }
-       else if(func > 0)
-       {
-               prog->argc--;
-               PRVM_ExecuteProgram(func - prog->functions,"");
-               prog->argc++;
-       }
-}
-
-/*
-=========
-VM_M_isfunction
-
-float  isfunction(string function_name)
-=========
-*/
-mfunction_t *PRVM_ED_FindFunction (const char *name);
-void VM_M_isfunction(void)
-{
-       mfunction_t *func;
-       const char *s;
-
-       VM_SAFEPARMCOUNT(1, VM_M_isfunction);
-
-       s = PRVM_G_STRING(OFS_PARM0);
-
-       if(!s)
-               PRVM_ERROR("VM_M_isfunction: null string !\n");
-
-       VM_CheckEmptyString(s);
-
-       func = PRVM_ED_FindFunction(s);
-
-       if(!func)
-               PRVM_G_FLOAT(OFS_RETURN) = false;
-       else
-               PRVM_G_FLOAT(OFS_RETURN) = true;
-}
-
-/*
-=========
-VM_M_writetofile
-
-       writetofile(float fhandle, entity ent)
-=========
-*/
-void VM_M_writetofile(void)
-{
-       prvm_edict_t * ent;
-       int filenum;
-
-       VM_SAFEPARMCOUNT(2, VM_M_writetofile);
-
-       filenum = PRVM_G_FLOAT(OFS_PARM0);
-       if (filenum < 0 || filenum >= MAX_VMFILES)
-       {
-               Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
-               return;
-       }
-       if (VM_FILES[filenum] == NULL)
-       {
-               Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
-               return;
-       }
 
 
-       ent = PRVM_G_EDICT(OFS_PARM1);
-       if(ent->p.e->free)
-       {
-               Con_Printf("VM_M_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_EDICT_NUM(OFS_PARM1));
-               return;
-       }
-
-       PRVM_ED_Write (VM_FILES[filenum], ent);
-}
-
-/*
-=========
-VM_M_getresolution
-
-vector getresolution(float number)
-=========
-*/
-extern unsigned short video_resolutions[][2];
-void VM_M_getresolution(void)
-{
-       int nr;
-       VM_SAFEPARMCOUNT(1, VM_getresolution);
-
-       nr = PRVM_G_FLOAT(OFS_PARM0);
-
-
-       PRVM_G_VECTOR(OFS_RETURN)[0] = video_resolutions[nr][0];
-       PRVM_G_VECTOR(OFS_RETURN)[1] = video_resolutions[nr][1];
-       PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
-}
-
-/*
-=========
-VM_M_keynumtostring
-
-string keynumtostring(float keynum)
-=========
-*/
-void VM_M_keynumtostring(void)
-{
-       int keynum;
-       char *tmp;
-       VM_SAFEPARMCOUNT(1, VM_M_keynumtostring);
-
-       keynum = PRVM_G_FLOAT(OFS_PARM0);
-
-       tmp = VM_GetTempString();
-
-       strcpy(tmp, Key_KeynumToString(keynum));
-
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tmp);
-}
-
-/*
-=========
-VM_M_stringtokeynum
-
-float stringtokeynum(string key)
-=========
-*/
-void VM_M_stringtokeynum( void )
-{
-       const char *str;
-       VM_SAFEPARMCOUNT( 1, VM_M_keynumtostring );
-
-       str = PRVM_G_STRING( OFS_PARM0 );
-
-       PRVM_G_INT(OFS_RETURN) = Key_StringToKeynum( str );
-}
-
-/*
-=========
-VM_M_findkeysforcommand
-
-string findkeysforcommand(string command)
-
-the returned string is an altstring
-=========
-*/
-#define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
-
-void M_FindKeysForCommand(const char *command, int *keys);
-void VM_M_findkeysforcommand(void)
-{
-       const char *cmd;
-       char *ret;
-       int keys[NUMKEYS];
-       int i;
-
-       VM_SAFEPARMCOUNT(1, VM_M_findkeysforcommand);
-
-       cmd = PRVM_G_STRING(OFS_PARM0);
-
-       VM_CheckEmptyString(cmd);
-
-       (ret = VM_GetTempString())[0] = 0;
-
-       M_FindKeysForCommand(cmd, keys);
-
-       for(i = 0; i < NUMKEYS; i++)
-               ret = strcat(ret, va(" \'%i\'", keys[i]));
-
-       PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(ret);
-}
-
-/*
-=========
-VM_M_getserverliststat
-
-float  getserverliststat(float type)
-=========
-*/
-/*
-       type:
-0      serverlist_viewcount
-1   serverlist_totalcount
-2      masterquerycount
-3      masterreplycount
-4      serverquerycount
-5      serverreplycount
-6      sortfield
-7      sortdescending
-*/
-void VM_M_getserverliststat( void )
-{
-       int type;
-       VM_SAFEPARMCOUNT ( 1, VM_M_getserverliststat );
-
-       PRVM_G_FLOAT( OFS_RETURN ) = 0;
-
-       type = PRVM_G_FLOAT( OFS_PARM0 );
-       switch(type)
-       {
-       case 0:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_viewcount;
-               return;
-       case 1:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_cachecount;
-       case 2:
-               PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
-               return;
-       case 3:
-               PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
-               return;
-       case 4:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
-               return;
-       case 5:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
-               return;
-       case 6:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortbyfield;
-               return;
-       case 7:
-               PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortdescending;
-               return;
-       default:
-               Con_Printf( "VM_M_getserverliststat: bad type %i!\n", type );
-       }
-}
-
-/*
-========================
-VM_M_resetserverlistmasks
-
-resetserverlistmasks()
-========================
-*/
-void VM_M_resetserverlistmasks( void )
-{
-       ServerList_ResetMasks();
-}
-
-
-/*
-========================
-VM_M_setserverlistmaskstring
-
-setserverlistmaskstring(float mask, float fld, string str, float op)
-0-511          and
-512 - 1024     or
-========================
-*/
-void VM_M_setserverlistmaskstring( void )
-{
-       const char *str;
-       int masknr;
-       serverlist_mask_t *mask;
-       int field;
-
-       VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmaskstring );
-       str = PRVM_G_STRING( OFS_PARM1 );
-       if( !str )
-               PRVM_ERROR( "VM_M_setserverlistmaskstring: null string passed!" );
-
-       masknr = PRVM_G_FLOAT( OFS_PARM0 );
-       if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
-               mask = &serverlist_andmasks[masknr];
-       else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
-               mask = &serverlist_ormasks[masknr - 512 ];
-       else {
-               Con_Printf( "VM_M_setserverlistmaskstring: invalid mask number %i\n", masknr );
-               return;
-       }
-
-       field = (int) PRVM_G_FLOAT( OFS_PARM1 );
-
-       switch( field ) {
-               case SLIF_CNAME:
-                       strncpy( mask->info.cname, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.cname) );
-                       break;
-               case SLIF_NAME:
-                       strncpy( mask->info.name, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.name)  );
-                       break;
-               case SLIF_MAP:
-                       strncpy( mask->info.map, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.map)  );
-                       break;
-               case SLIF_MOD:
-                       strncpy( mask->info.mod, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.mod)  );
-                       break;
-               case SLIF_GAME:
-                       strncpy( mask->info.game, PRVM_G_STRING( OFS_PARM2 ), sizeof(mask->info.game)  );
-                       break;
-               default:
-                       Con_Printf( "VM_M_setserverlistmaskstring: Bad field number %i passed!\n", field );
-                       return;
-       }
-
-       mask->active = true;
-       mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
-}
-
-/*
-========================
-VM_M_setserverlistmasknumber
-
-setserverlistmasknumber(float mask, float fld, float num, float op)
-
-0-511          and
-512 - 1024     or
-========================
-*/
-void VM_M_setserverlistmasknumber( void )
-{
-       int number;
-       serverlist_mask_t *mask;
-       int     masknr;
-       int field;
-       VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmasknumber );
-
-       masknr = PRVM_G_FLOAT( OFS_PARM0 );
-       if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT )
-               mask = &serverlist_andmasks[masknr];
-       else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT )
-               mask = &serverlist_ormasks[masknr - 512 ];
-       else {
-               Con_Printf( "VM_M_setserverlistmasknumber: invalid mask number %i\n", masknr );
-               return;
-       }
-
-       number = PRVM_G_FLOAT( OFS_PARM2 );
-       field = (int) PRVM_G_FLOAT( OFS_PARM1 );
-
-       switch( field ) {
-               case SLIF_MAXPLAYERS:
-                       mask->info.maxplayers = number;
-                       break;
-               case SLIF_NUMPLAYERS:
-                       mask->info.numplayers = number;
-                       break;
-               case SLIF_PING:
-                       mask->info.ping = number;
-                       break;
-               case SLIF_PROTOCOL:
-                       mask->info.protocol = number;
-                       break;
-               default:
-                       Con_Printf( "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field );
-                       return;
-       }
-
-       mask->active = true;
-       mask->tests[field] = (int) PRVM_G_FLOAT( OFS_PARM3 );
-}
-
-
-/*
-========================
-VM_M_resortserverlist
-
-resortserverlist
-========================
-*/
-void VM_M_resortserverlist( void )
-{
-       ServerList_RebuildViewList();
-}
-
-/*
-=========
-VM_M_getserverliststring
-
-string getserverliststring(float field, float hostnr)
-=========
-*/
-void VM_M_getserverliststring(void)
-{
-       serverlist_entry_t *cache;
-       int hostnr;
-
-       VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
-
-       PRVM_G_INT(OFS_RETURN) = 0;
-
-       hostnr = PRVM_G_FLOAT(OFS_PARM1);
-
-       if(hostnr < 0 || hostnr >= serverlist_viewcount)
-       {
-               Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
-               return;
-       }
-       cache = serverlist_viewlist[hostnr];
-       switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
-               case SLIF_CNAME:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.cname );
-                       break;
-               case SLIF_NAME:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.name );
-                       break;
-               case SLIF_GAME:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.game );
-                       break;
-               case SLIF_MOD:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.mod );
-                       break;
-               case SLIF_MAP:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->info.map );
-                       break;
-               // TODO remove this again
-               case 1024:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line1 );
-                       break;
-               case 1025:
-                       PRVM_G_INT( OFS_RETURN ) = PRVM_SetEngineString( cache->line2 );
-                       break;
-               default:
-                       Con_Print("VM_M_getserverliststring: bad field number passed!\n");
-       }
-}
-
-/*
-=========
-VM_M_getserverlistnumber
-
-float  getserverlistnumber(float field, float hostnr)
-=========
-*/
-void VM_M_getserverlistnumber(void)
-{
-       serverlist_entry_t *cache;
-       int hostnr;
-
-       VM_SAFEPARMCOUNT(2, VM_M_getserverliststring);
-
-       PRVM_G_INT(OFS_RETURN) = 0;
-
-       hostnr = PRVM_G_FLOAT(OFS_PARM1);
-
-       if(hostnr < 0 || hostnr >= serverlist_viewcount)
-       {
-               Con_Print("VM_M_getserverliststring: bad hostnr passed!\n");
-               return;
-       }
-       cache = serverlist_viewlist[hostnr];
-       switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) {
-               case SLIF_MAXPLAYERS:
-                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers;
-                       break;
-               case SLIF_NUMPLAYERS:
-                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.numplayers;
-                       break;
-               case SLIF_PING:
-                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping;
-                       break;
-               case SLIF_PROTOCOL:
-                       PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol;
-                       break;
-               default:
-                       Con_Print("VM_M_getserverlistnumber: bad field number passed!\n");
-       }
-}
-
-/*
-========================
-VM_M_setserverlistsort
-
-setserverlistsort(float field, float descending)
-========================
-*/
-void VM_M_setserverlistsort( void )
-{
-       VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort );
-
-       serverlist_sortbyfield = (int) PRVM_G_FLOAT( OFS_PARM0 );
-       serverlist_sortdescending = (qboolean) PRVM_G_FLOAT( OFS_PARM1 );
-}
-
-/*
-========================
-VM_M_refreshserverlist
-
-refreshserverlist()
-========================
-*/
-void VM_M_refreshserverlist( void )
-{
-       VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist );
-       ServerList_QueryList();
-}
-
-/*
-========================
-VM_M_getserverlistindexforkey
-
-float getserverlistindexforkey(string key)
-========================
-*/
-void VM_M_getserverlistindexforkey( void )
-{
-       const char *key;
-       VM_SAFEPARMCOUNT( 1, VM_M_getserverlistindexforkey );
-
-       key = PRVM_G_STRING( OFS_PARM0 );
-       VM_CheckEmptyString( key );
-
-       if( !strcmp( key, "cname" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CNAME;
-       else if( !strcmp( key, "ping" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PING;
-       else if( !strcmp( key, "game" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_GAME;
-       else if( !strcmp( key, "mod" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MOD;
-       else if( !strcmp( key, "map" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAP;
-       else if( !strcmp( key, "name" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NAME;
-       else if( !strcmp( key, "maxplayers" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_MAXPLAYERS;
-       else if( !strcmp( key, "numplayers" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_NUMPLAYERS;
-       else if( !strcmp( key, "protocol" ) )
-               PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PROTOCOL;
-       else
-               PRVM_G_FLOAT( OFS_RETURN ) = -1;
-}
-
-/*
-========================
-VM_M_addwantedserverlistkey
-
-addwantedserverlistkey(string key)
-========================
-*/
-void VM_M_addwantedserverlistkey( void )
-{
-       VM_SAFEPARMCOUNT( 1, VM_M_addwantedserverlistkey );
-}
-
-prvm_builtin_t vm_m_builtins[] = {
-       0, // to be consistent with the old vm
-       // common builtings (mostly)
-       VM_checkextension,
-       VM_error,
-       VM_objerror,
-       VM_print,
-       VM_bprint,
-       VM_sprint,
-       VM_centerprint,
-       VM_normalize,
-       VM_vlen,
-       VM_vectoyaw,    // #10
-       VM_vectoangles,
-       VM_random,
-       VM_localcmd,
-       VM_cvar,
-       VM_cvar_set,
-       VM_dprint,
-       VM_ftos,
-       VM_fabs,
-       VM_vtos,
-       VM_etos,                // 20
-       VM_stof,
-       VM_spawn,
-       VM_remove,
-       VM_find,
-       VM_findfloat,
-       VM_findchain,
-       VM_findchainfloat,
-       VM_precache_file,
-       VM_precache_sound,
-       VM_coredump,    // 30
-       VM_traceon,
-       VM_traceoff,
-       VM_eprint,
-       VM_rint,
-       VM_floor,
-       VM_ceil,
-       VM_nextent,
-       VM_sin,
-       VM_cos,
-       VM_sqrt,                // 40
-       VM_randomvec,
-       VM_registercvar,
-       VM_min,
-       VM_max,
-       VM_bound,
-       VM_pow,
-       VM_copyentity,
-       VM_fopen,
-       VM_fclose,
-       VM_fgets,               // 50
-       VM_fputs,
-       VM_strlen,
-       VM_strcat,
-       VM_substring,
-       VM_stov,
-       VM_strzone,
-       VM_strunzone,
-       VM_tokenize,
-       VM_argv,
-       VM_isserver,    // 60
-       VM_clientcount,
-       VM_clientstate,
-       VM_clcommand,
-       VM_changelevel,
-       VM_localsound,
-       VM_getmousepos,
-       VM_gettime,
-       VM_loadfromdata,
-       VM_loadfromfile,
-       VM_modulo,              // 70
-       VM_str_cvar,
-       VM_crash,
-       VM_stackdump,   // 73
-       VM_search_begin,
-       VM_search_end,
-       VM_search_getsize,
-       VM_search_getfilename, // 77
-       VM_chr,
-       VM_itof,
-       VM_ftoi,                // 80
-       VM_itof,                // isString
-       VM_altstr_count,
-       VM_altstr_prepare,
-       VM_altstr_get,
-       VM_altstr_set,
-       VM_altstr_ins,  // 86
-       0,0,0,0,        // 90
-       e10,                    // 100
-       e100,                   // 200
-       e100,                   // 300
-       e100,                   // 400
-       // msg functions
-       VM_WriteByte,
-       VM_WriteChar,
-       VM_WriteShort,
-       VM_WriteLong,
-       VM_WriteAngle,
-       VM_WriteCoord,
-       VM_WriteString,
-       VM_WriteEntity, // 408
-       0,
-       0,                              // 410
-       e10,                    // 420
-       e10,                    // 430
-       e10,                    // 440
-       e10,                    // 450
-       // draw functions
-       VM_iscachedpic,
-       VM_precache_pic,
-       VM_freepic,
-       VM_drawcharacter,
-       VM_drawstring,
-       VM_drawpic,
-       VM_drawfill,
-       VM_drawsetcliparea,
-       VM_drawresetcliparea,
-       VM_getimagesize,// 460
-       VM_cin_open,
-       VM_cin_close,
-       VM_cin_setstate,
-       VM_cin_getstate,
-       VM_cin_restart, // 465
-       0,0,0,0,0,      // 470
-       e10,                    // 480
-       e10,                    // 490
-       e10,                    // 500
-       e100,                   // 600
-       // menu functions
-       VM_M_setkeydest,
-       VM_M_getkeydest,
-       VM_M_setmousetarget,
-       VM_M_getmousetarget,
-       VM_M_callfunction,
-       VM_M_writetofile,
-       VM_M_isfunction,
-       VM_M_getresolution,
-       VM_M_keynumtostring,
-       VM_M_findkeysforcommand,// 610
-       VM_M_getserverliststat,
-       VM_M_getserverliststring,
-       VM_M_parseentitydata,
-       VM_M_stringtokeynum,
-       VM_M_resetserverlistmasks,
-       VM_M_setserverlistmaskstring,
-       VM_M_setserverlistmasknumber,
-       VM_M_resortserverlist,
-       VM_M_setserverlistsort,
-       VM_M_refreshserverlist,
-       VM_M_getserverlistnumber,
-       VM_M_getserverlistindexforkey,
-       VM_M_addwantedserverlistkey // 623
-};
-
-const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
-
-void VM_M_Cmd_Init(void)
-{
-       VM_Cmd_Init();
-}
-
-void VM_M_Cmd_Reset(void)
-{
-       //VM_Cmd_Init();
-       VM_Cmd_Reset();
-}
diff --git a/prvm_cmds.h b/prvm_cmds.h
new file mode 100644 (file)
index 0000000..9b0e1d4
--- /dev/null
@@ -0,0 +1,336 @@
+// AK
+// Basically every vm builtin cmd should be in here.
+// All 3 builtin and extension lists can be found here
+// cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
+// also applies here
+
+
+/*
+============================================================================
+common cmd list:
+=================
+
+               checkextension(string)
+               error(...[string])
+               objerror(...[string)
+               print(...[strings])
+               bprint(...[string])
+               sprint(float clientnum,...[string])
+               centerprint(...[string])
+vector normalize(vector)
+float  vlen(vector)
+float  vectoyaw(vector)
+vector vectoangles(vector)
+float  random()
+               cmd(string)
+               float cvar (string)
+               cvar_set (string,string)
+               dprint(...[string])
+string ftos(float)
+float  fabs(float)
+string vtos(vector)
+string etos(entity)
+float  stof(...[string])
+entity spawn()
+               remove(entity e)
+entity find(entity start, .string field, string match)
+
+entity findfloat(entity start, .float field, float match)
+entity findentity(entity start, .entity field, entity match)
+
+entity findchain(.string field, string match)
+
+entity findchainfloat(.string field, float match)
+entity findchainentity(.string field, entity match)
+
+string precache_file(string)
+string precache_sound (string sample)
+               coredump()
+               traceon()
+               traceoff()
+               eprint(entity e)
+float  rint(float)
+float  floor(float)
+float  ceil(float)
+entity nextent(entity)
+float  sin(float)
+float  cos(float)
+float  sqrt(float)
+vector randomvec()
+float  registercvar (string name, string value, float flags)
+float  min(float a, float b, ...[float])
+float  max(float a, float b, ...[float])
+float  bound(float min, float value, float max)
+float  pow(float a, float b)
+               copyentity(entity src, entity dst)
+float  fopen(string filename, float mode)
+               fclose(float fhandle)
+string fgets(float fhandle)
+               fputs(float fhandle, string s)
+float  strlen(string s)
+string strcat(string,string,...[string])
+string substring(string s, float start, float length)
+vector stov(string s)
+string strzone(string s)
+               strunzone(string s)
+float  tokenize(string s)
+string argv(float n)
+float  isserver()
+float  clientcount()
+float  clientstate()
+               clientcommand(float client, string s) (for client and menu)
+               changelevel(string map)
+               localsound(string sample)
+vector getmousepos()
+float  gettime()
+               loadfromdata(string data)
+               loadfromfile(string file)
+               parseentitydata(entity ent, string data)
+float  mod(float val, float m)
+const string   cvar_string (string)
+               crash()
+               stackdump()
+
+float  search_begin(string pattern, float caseinsensitive, float quiet)
+void   search_end(float handle)
+float  search_getsize(float handle)
+string search_getfilename(float handle, float num)
+
+string chr(float ascii)
+
+float  itof(intt ent)
+intt   ftoi(float num)
+
+float  altstr_count(string)
+string altstr_prepare(string)
+string altstr_get(string,float)
+string altstr_set(string altstr, float num, string set)
+string altstr_ins(string altstr, float num, string set)
+
+perhaps only : Menu : WriteMsg
+===============================
+
+               WriteByte(float data, float dest, float desto)
+               WriteChar(float data, float dest, float desto)
+               WriteShort(float data, float dest, float desto)
+               WriteLong(float data, float dest, float desto)
+               WriteAngle(float data, float dest, float desto)
+               WriteCoord(float data, float dest, float desto)
+               WriteString(string data, float dest, float desto)
+               WriteEntity(entity data, float dest, float desto)
+
+Client & Menu : draw functions & video functions
+===================================================
+
+float  iscachedpic(string pic)
+string precache_pic(string pic)
+               freepic(string s)
+float  drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
+float  drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
+float  drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
+float  drawfill(vector position, vector size, vector rgb, float alpha, float flag)
+               drawsetcliparea(float x, float y, float width, float height)
+               drawresetcliparea()
+vector getimagesize(string pic)
+
+float  cin_open(string file, string name)
+void   cin_close(string name)
+void   cin_setstate(string name, float type)
+float  cin_getstate(string name)
+void   cin_restart(string name)
+
+==============================================================================
+menu cmd list:
+===============
+
+               setkeydest(float dest)
+float  getkeydest()
+               setmousetarget(float target)
+float  getmousetarget()
+
+               callfunction(...,string function_name)
+               writetofile(float fhandle, entity ent)
+float  isfunction(string function_name)
+vector getresolution(float number)
+string keynumtostring(float keynum)
+string findkeysforcommand(string command)
+float  getserverliststat(float type)
+string getserverliststring(float fld, float hostnr)
+
+float  stringtokeynum(string key)
+
+               resetserverlistmasks()
+               setserverlistmaskstring(float mask, float fld, string str)
+               setserverlistmasknumber(float mask, float fld, float num, float op)
+               resortserverlist()
+               setserverlistsort(float field, float descending)
+               refreshserverlist()
+float  getserverlistnumber(float fld, float hostnr)
+float  getserverlistindexforkey(string key)
+               addwantedserverlistkey(string key)
+*/
+
+#include "quakedef.h"
+#include "progdefs.h"
+#include "progsvm.h"
+#include "clprogdefs.h"
+#include "mprogdefs.h"
+
+#include "cl_video.h"
+
+//============================================================================
+// nice helper macros
+
+#ifndef VM_NOPARMCHECK
+#define VM_SAFEPARMCOUNT(p,f)  if(prog->argc != p) PRVM_ERROR(#f " wrong parameter count (" #p " expected ) !\n")
+#else
+#define VM_SAFEPARMCOUNT(p,f)
+#endif
+
+#define        VM_RETURN_EDICT(e)              (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
+
+#define e10 0,0,0,0,0,0,0,0,0,0
+#define e100 e10,e10,e10,e10,e10,e10,e10,e10,e10,e10
+#define e1000 e100,e100,e100,e100,e100,e100,e100,e100,e100,e100
+
+// builtins and other general functions
+
+char *VM_GetTempString(void);
+void VM_CheckEmptyString (const char *s);
+void VM_VarString(int first, char *out, int outlength);
+
+void VM_checkextension (void);
+void VM_error (void);
+void VM_objerror (void);
+void VM_print (void);
+void VM_bprint (void);
+void VM_sprint (void);
+void VM_centerprint (void);
+void VM_normalize (void);
+void VM_vlen (void);
+void VM_vectoyaw (void);
+void VM_vectoangles (void);
+void VM_random (void);
+void VM_localsound(void);
+void VM_break (void);
+void VM_localcmd (void);
+void VM_cvar (void);
+void VM_cvar_string(void);
+void VM_cvar_set (void);
+void VM_dprint (void);
+void VM_ftos (void);
+void VM_fabs (void);
+void VM_vtos (void);
+void VM_etos (void);
+void VM_stof(void);
+void VM_itof(void);
+void VM_ftoi(void);
+void VM_spawn (void);
+void VM_remove (void);
+void VM_find (void);
+void VM_findfloat (void);
+void VM_findchain (void);
+void VM_findchainfloat (void);
+void VM_precache_file (void);
+void VM_precache_error (void);
+void VM_precache_sound (void);
+void VM_coredump (void);
+
+void VM_stackdump (void);
+void VM_crash(void); // REMOVE IT
+void VM_traceon (void);
+void VM_traceoff (void);
+void VM_eprint (void);
+void VM_rint (void);
+void VM_floor (void);
+void VM_ceil (void);
+void VM_nextent (void);
+
+// REMOVE THESE
+sizebuf_t *VM_WriteDest (void);
+void VM_WriteByte (void);
+void VM_WriteChar (void);
+void VM_WriteShort (void);
+void VM_WriteLong (void);
+void VM_WriteAngle (void);
+void VM_WriteCoord (void);
+void VM_WriteString (void);
+void VM_WriteEntity (void);
+
+void VM_changelevel (void);
+void VM_sin (void);
+void VM_cos (void);
+void VM_sqrt (void);
+void VM_randomvec (void);
+void VM_registercvar (void);
+void VM_min (void);
+void VM_max (void);
+void VM_bound (void);
+void VM_pow (void);
+void VM_copyentity (void);
+
+void VM_Files_Init(void);
+void VM_Files_CloseAll(void);
+
+void VM_fopen(void);
+void VM_fclose(void);
+void VM_fgets(void);
+void VM_fputs(void);
+// used by M_WriteToFile
+// should be only called from a builtin
+qfile_t *VM_GetFileHandle( int index );
+
+void VM_strlen(void);
+void VM_strcat(void);
+void VM_substring(void);
+void VM_stov(void);
+void VM_strzone(void);
+void VM_strunzone(void);
+
+void VM_clcommand (void);
+
+void VM_tokenize (void);
+void VM_argv (void);
+
+void VM_isserver(void);
+void VM_clientcount(void);
+void VM_clientstate(void);
+// not used at the moment -> not included in the common list
+void VM_getostype(void);
+void VM_getmousepos(void);
+void VM_gettime(void);
+void VM_loadfromdata(void);
+void VM_parseentitydata(void);
+void VM_loadfromfile(void);
+void VM_modulo(void);
+
+void VM_search_begin(void);
+void VM_search_end(void);
+void VM_search_getsize(void);
+void VM_search_getfilename(void);
+void VM_chr(void);
+void VM_iscachedpic(void);
+void VM_precache_pic(void);
+void VM_freepic(void);
+void VM_drawcharacter(void);
+void VM_drawstring(void);
+void VM_drawpic(void);
+void VM_drawfill(void);
+void VM_drawsetcliparea(void);
+void VM_drawresetcliparea(void);
+void VM_getimagesize(void);
+
+void VM_cin_open( void );
+void VM_cin_close( void );
+void VM_cin_setstate( void );
+void VM_cin_getstate( void );
+void VM_cin_restart( void );
+
+void VM_altstr_count( void );
+void VM_altstr_prepare( void );
+void VM_altstr_get( void );
+void VM_altstr_set( void );
+void VM_altstr_ins(void);
+
+void VM_Cmd_Init(void);
+void VM_Cmd_Reset(void);
\ No newline at end of file
index 379b099..e38e078 100644 (file)
@@ -71,8 +71,8 @@ void PRVM_MEM_Alloc()
        // set edict pointers
        for(i = 0; i < prog->max_edicts; i++)
        {
        // set edict pointers
        for(i = 0; i < prog->max_edicts; i++)
        {
-               prog->edicts[i].p.e = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
-               prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
+               prog->edicts[i].priv.required = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
+               prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
        }
 }
 
        }
 }
 
@@ -105,8 +105,8 @@ void PRVM_MEM_IncreaseEdicts()
        //set e and v pointers
        for(i = 0; i < prog->max_edicts; i++)
        {
        //set e and v pointers
        for(i = 0; i < prog->max_edicts; i++)
        {
-               prog->edicts[i].p.e = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
-               prog->edicts[i].v = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
+               prog->edicts[i].priv.required  = (prvm_edict_private_t *)((qbyte  *)prog->edictprivate + i * prog->edictprivate_size);
+               prog->edicts[i].fields.vp = (void*)((qbyte *)prog->edictsfields + i * prog->edict_size);
        }
 
        PRVM_GCALL(end_increase_edicts)();
        }
 
        PRVM_GCALL(end_increase_edicts)();
@@ -191,8 +191,8 @@ Sets everything to NULL
 void PRVM_ED_ClearEdict (prvm_edict_t *e)
 {
        int num;
 void PRVM_ED_ClearEdict (prvm_edict_t *e)
 {
        int num;
-       memset (e->v, 0, prog->progs->entityfields * 4);
-       e->p.e->free = false;
+       memset (e->fields.vp, 0, prog->progs->entityfields * 4);
+       e->priv.required->free = false;
        // LordHavoc: for consistency set these here
        num = PRVM_NUM_FOR_EDICT(e) - 1;
 
        // LordHavoc: for consistency set these here
        num = PRVM_NUM_FOR_EDICT(e) - 1;
 
@@ -226,7 +226,7 @@ prvm_edict_t *PRVM_ED_Alloc (void)
                e = PRVM_EDICT_NUM(i);
                // the first couple seconds of server time can involve a lot of
                // freeing and allocating, so relax the replacement policy
                e = PRVM_EDICT_NUM(i);
                // the first couple seconds of server time can involve a lot of
                // freeing and allocating, so relax the replacement policy
-               if (e->p.e->free && ( e->p.e->freetime < 2 || (*prog->time - e->p.e->freetime) > 0.5 ) )
+               if (e->priv.required->free && ( e->priv.required->freetime < 2 || (*prog->time - e->priv.required->freetime) > 0.5 ) )
                {
                        PRVM_ED_ClearEdict (e);
                        return e;
                {
                        PRVM_ED_ClearEdict (e);
                        return e;
@@ -262,8 +262,8 @@ void PRVM_ED_Free (prvm_edict_t *ed)
 
        PRVM_GCALL(free_edict)(ed);
 
 
        PRVM_GCALL(free_edict)(ed);
 
-       ed->p.e->free = true;
-       ed->p.e->freetime = *prog->time;
+       ed->priv.required->free = true;
+       ed->priv.required->freetime = *prog->time;
 }
 
 //===========================================================================
 }
 
 //===========================================================================
@@ -568,7 +568,7 @@ void PRVM_ED_Print(prvm_edict_t *ed)
        int             type;
        char    tempstring[8192], tempstring2[260]; // temporary string buffers
 
        int             type;
        char    tempstring[8192], tempstring2[260]; // temporary string buffers
 
-       if (ed->p.e->free)
+       if (ed->priv.required->free)
        {
                Con_Printf("%s: FREE\n",PRVM_NAME);
                return;
        {
                Con_Printf("%s: FREE\n",PRVM_NAME);
                return;
@@ -583,7 +583,7 @@ void PRVM_ED_Print(prvm_edict_t *ed)
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
-               v = (int *)((char *)ed->v + d->ofs*4);
+               v = (int *)((char *)ed->fields.vp + d->ofs*4);
 
        // if the value is still all 0, skip the field
                type = d->type & ~DEF_SAVEGLOBAL;
 
        // if the value is still all 0, skip the field
                type = d->type & ~DEF_SAVEGLOBAL;
@@ -643,7 +643,7 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
 
        FS_Print(f, "{\n");
 
 
        FS_Print(f, "{\n");
 
-       if (ed->p.e->free)
+       if (ed->priv.required->free)
        {
                FS_Print(f, "}\n");
                return;
        {
                FS_Print(f, "}\n");
                return;
@@ -656,7 +656,7 @@ void PRVM_ED_Write (qfile_t *f, prvm_edict_t *ed)
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
                if (name[strlen(name)-2] == '_')
                        continue;       // skip _x, _y, _z vars
 
-               v = (int *)((char *)ed->v + d->ofs*4);
+               v = (int *)((char *)ed->fields.vp + d->ofs*4);
 
        // if the value is still all 0, skip the field
                type = d->type & ~DEF_SAVEGLOBAL;
 
        // if the value is still all 0, skip the field
                type = d->type & ~DEF_SAVEGLOBAL;
@@ -772,7 +772,7 @@ void PRVM_ED_Count_f (void)
                for (i=0 ; i<prog->num_edicts ; i++)
                {
                        ent = PRVM_EDICT_NUM(i);
                for (i=0 ; i<prog->num_edicts ; i++)
                {
                        ent = PRVM_EDICT_NUM(i);
-                       if (ent->p.e->free)
+                       if (ent->priv.required->free)
                                continue;
                        active++;
                }
                                continue;
                        active++;
                }
@@ -883,7 +883,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
        mfunction_t *func;
 
        if (ent)
        mfunction_t *func;
 
        if (ent)
-               val = (prvm_eval_t *)((int *)ent->v + key->ofs);
+               val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
        else
                val = (prvm_eval_t *)((int *)prog->globals + key->ofs);
        switch (key->type & ~DEF_SAVEGLOBAL)
        else
                val = (prvm_eval_t *)((int *)prog->globals + key->ofs);
        switch (key->type & ~DEF_SAVEGLOBAL)
@@ -941,7 +941,7 @@ qboolean PRVM_ED_ParseEpair(prvm_edict_t *ent, ddef_t *key, const char *s)
                        //SV_IncreaseEdicts();
                // if SV_IncreaseEdicts was called the base pointer needs to be updated
                if (ent)
                        //SV_IncreaseEdicts();
                // if SV_IncreaseEdicts was called the base pointer needs to be updated
                if (ent)
-                       val = (prvm_eval_t *)((int *)ent->v + key->ofs);
+                       val = (prvm_eval_t *)((int *)ent->fields.vp + key->ofs);
                val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i));
                break;
 
                val->edict = PRVM_EDICT_TO_PROG(EDICT_NUM(i));
                break;
 
@@ -1092,7 +1092,7 @@ const char *PRVM_ED_ParseEdict (const char *data, prvm_edict_t *ent)
        }
 
        if (!init)
        }
 
        if (!init)
-               ent->p.e->free = true;
+               ent->priv.required->free = true;
 
        return data;
 }
 
        return data;
 }
@@ -1142,7 +1142,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 
                // clear it
                if (ent != prog->edicts)        // hack
 
                // clear it
                if (ent != prog->edicts)        // hack
-                       memset (ent->v, 0, prog->progs->entityfields * 4);
+                       memset (ent->fields.vp, 0, prog->progs->entityfields * 4);
 
                data = PRVM_ED_ParseEdict (data, ent);
                parsed++;
 
                data = PRVM_ED_ParseEdict (data, ent);
                parsed++;
@@ -1160,7 +1160,7 @@ void PRVM_ED_LoadFromFile (const char *data)
 //
                if(prog->self && prog->flag & PRVM_FE_CLASSNAME)
                {
 //
                if(prog->self && prog->flag & PRVM_FE_CLASSNAME)
                {
-                       string_t handle =  *(string_t*)&((float*)ent->v)[PRVM_ED_FindFieldOffset("classname")];
+                       string_t handle =  *(string_t*)&((float*)ent->fields.vp)[PRVM_ED_FindFieldOffset("classname")];
                        if (!handle)
                        {
                                Con_Print("No classname for:\n");
                        if (!handle)
                        {
                                Con_Print("No classname for:\n");
@@ -1189,7 +1189,7 @@ void PRVM_ED_LoadFromFile (const char *data)
                }
 
                spawned++;
                }
 
                spawned++;
-               if (ent->p.e->free)
+               if (ent->priv.required->free)
                        died++;
        }
 
                        died++;
        }
 
@@ -1472,7 +1472,10 @@ void PRVM_LoadProgs (const char * filename, int numrequiredfunc, char **required
                && prog->flag && prog->self)
                prog->flag |= PRVM_OP_STATE;
 
                && prog->flag && prog->self)
                prog->flag |= PRVM_OP_STATE;
 
-       PRVM_GCALL(reset_cmd)();
+       if( prog->loaded ) {
+               PRVM_GCALL(reset_cmd)();
+       }
+       prog->loaded = TRUE;
        PRVM_GCALL(init_cmd)();
 
        // init mempools
        PRVM_GCALL(init_cmd)();
 
        // init mempools
@@ -1513,7 +1516,7 @@ void PRVM_Fields_f (void)
        for (ednum = 0;ednum < prog->max_edicts;ednum++)
        {
                ed = PRVM_EDICT_NUM(ednum);
        for (ednum = 0;ednum < prog->max_edicts;ednum++)
        {
                ed = PRVM_EDICT_NUM(ednum);
-               if (ed->p.e->free)
+               if (ed->priv.required->free)
                        continue;
                for (i = 1;i < prog->progs->numfielddefs;i++)
                {
                        continue;
                for (i = 1;i < prog->progs->numfielddefs;i++)
                {
@@ -1521,7 +1524,7 @@ void PRVM_Fields_f (void)
                        name = PRVM_GetString(d->s_name);
                        if (name[strlen(name)-2] == '_')
                                continue;       // skip _x, _y, _z vars
                        name = PRVM_GetString(d->s_name);
                        if (name[strlen(name)-2] == '_')
                                continue;       // skip _x, _y, _z vars
-                       v = (int *)((char *)ed->v + d->ofs*4);
+                       v = (int *)((char *)ed->fields.vp + d->ofs*4);
                        // if the value is still all 0, skip the field
                        for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
                        {
                        // if the value is still all 0, skip the field
                        for (j = 0;j < prvm_type_size[d->type & ~DEF_SAVEGLOBAL];j++)
                        {
index 499820c..d147493 100644 (file)
                                        return;
                                }*/
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                        return;
                                }*/
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
-                               OPC->_int = (qbyte *)((int *)ed->v + OPB->_int) - (qbyte *)prog->edictsfields;
+                               OPC->_int = (qbyte *)((int *)ed->fields.vp + OPB->_int) - (qbyte *)prog->edictsfields;
                                break;
 
                        case OP_LOAD_F:
                                break;
 
                        case OP_LOAD_F:
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
-                               OPC->_int = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->_int;
+                               OPC->_int = ((prvm_eval_t *)((int *)ed->fields.vp + OPB->_int))->_int;
                                break;
 
                        case OP_LOAD_V:
                                break;
 
                        case OP_LOAD_V:
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
                                }
 #endif
                                ed = PRVM_PROG_TO_EDICT(OPA->edict);
-                               OPC->vector[0] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[0];
-                               OPC->vector[1] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[1];
-                               OPC->vector[2] = ((prvm_eval_t *)((int *)ed->v + OPB->_int))->vector[2];
+                               OPC->vector[0] = ((prvm_eval_t *)((int *)ed->fields.vp + OPB->_int))->vector[0];
+                               OPC->vector[1] = ((prvm_eval_t *)((int *)ed->fields.vp + OPB->_int))->vector[1];
+                               OPC->vector[2] = ((prvm_eval_t *)((int *)ed->fields.vp + OPB->_int))->vector[2];
                                break;
 
                //==================
                                break;
 
                //==================
                                        ed = PRVM_PROG_TO_EDICT(PRVM_G_INT(prog->self->ofs));
                                        PRVM_E_FLOAT(ed,PRVM_ED_FindFieldOffset ("nextthink")) = *prog->time + 0.1;
                                        PRVM_E_FLOAT(ed,PRVM_ED_FindFieldOffset ("frame")) = OPA->_float;
                                        ed = PRVM_PROG_TO_EDICT(PRVM_G_INT(prog->self->ofs));
                                        PRVM_E_FLOAT(ed,PRVM_ED_FindFieldOffset ("nextthink")) = *prog->time + 0.1;
                                        PRVM_E_FLOAT(ed,PRVM_ED_FindFieldOffset ("frame")) = OPA->_float;
-                                       *(func_t *)((qbyte*)ed->v + PRVM_ED_FindFieldOffset ("think")) = OPB->function;
+                                       *(func_t *)((qbyte*)ed->fields.vp + PRVM_ED_FindFieldOffset ("think")) = OPB->function;
                                }
                                else
                                        PRVM_ERROR("OP_STATE not supported by %s\n", PRVM_NAME);
                                }
                                else
                                        PRVM_ERROR("OP_STATE not supported by %s\n", PRVM_NAME);