X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=mvm_cmds.c;h=00759e0985882206aca3712fa60ffbf63bd53aa8;hp=e9cc68a986177b5ffc1609f6a51acc9ee4f1596d;hb=HEAD;hpb=0f80ff51ff9f369233d17b3377d3a0d34b4c8e5a diff --git a/mvm_cmds.c b/mvm_cmds.c index e9cc68a9..812930fd 100644 --- a/mvm_cmds.c +++ b/mvm_cmds.c @@ -3,46 +3,61 @@ #include "prvm_cmds.h" #include "clvm_cmds.h" #include "menu.h" +#include "csprogs.h" // TODO check which strings really should be engine strings //============================================================================ // Menu -const char *vm_m_extensions = -"BX_WAL_SUPPORT " -"DP_CINEMATIC_DPV " -"DP_CSQC_BINDMAPS " -"DP_GFX_FONTS " -"DP_GFX_FONTS_FREETYPE " -"DP_UTF8 " -"DP_FONT_VARIABLEWIDTH " -"DP_GECKO_SUPPORT " -"DP_MENU_EXTRESPONSEPACKET " -"DP_QC_ASINACOSATANATAN2TAN " -"DP_QC_AUTOCVARS " -"DP_QC_CMD " -"DP_QC_CRC16 " -"DP_QC_CVAR_TYPE " -"DP_QC_CVAR_DESCRIPTION " -"DP_QC_FINDCHAIN_TOFIELD " -"DP_QC_LOG " -"DP_QC_RENDER_SCENE " -"DP_QC_SPRINTF " -"DP_QC_STRFTIME " -"DP_QC_STRINGBUFFERS " -"DP_QC_STRINGBUFFERS_CVARLIST " -"DP_QC_STRINGCOLORFUNCTIONS " -"DP_QC_STRING_CASE_FUNCTIONS " -"DP_QC_STRREPLACE " -"DP_QC_TOKENIZEBYSEPARATOR " -"DP_QC_TOKENIZE_CONSOLE " -"DP_QC_UNLIMITEDTEMPSTRINGS " -"DP_QC_URI_ESCAPE " -"DP_QC_URI_GET " -"DP_QC_WHICHPACK " -"FTE_STRINGS " -; +const char *vm_m_extensions[] = { +"BX_WAL_SUPPORT", +"DP_CINEMATIC_DPV", +"DP_COVERAGE", +"DP_CRYPTO", +"DP_CSQC_BINDMAPS", +"DP_GFX_FONTS", +"DP_GFX_FONTS_FREETYPE", +"DP_UTF8", +"DP_FONT_VARIABLEWIDTH", +"DP_MENU_EXTRESPONSEPACKET", +"DP_QC_ASINACOSATANATAN2TAN", +"DP_QC_AUTOCVARS", +"DP_QC_CMD", +"DP_QC_CRC16", +"DP_QC_CVAR_TYPE", +"DP_QC_CVAR_DESCRIPTION", +"DP_QC_DIGEST", +"DP_QC_DIGEST_SHA256", +"DP_QC_FINDCHAIN_TOFIELD", +"DP_QC_I18N", +"DP_QC_LOG", +"DP_QC_RENDER_SCENE", +"DP_QC_SPRINTF", +"DP_QC_STRFTIME", +"DP_QC_STRINGBUFFERS", +"DP_QC_STRINGBUFFERS_CVARLIST", +"DP_QC_STRINGBUFFERS_EXT_WIP", +"DP_QC_STRINGCOLORFUNCTIONS", +"DP_QC_STRING_CASE_FUNCTIONS", +"DP_QC_STRREPLACE", +"DP_QC_TOKENIZEBYSEPARATOR", +"DP_QC_TOKENIZE_CONSOLE", +"DP_QC_UNLIMITEDTEMPSTRINGS", +"DP_QC_URI_ESCAPE", +"DP_QC_URI_GET", +"DP_QC_URI_POST", +"DP_QC_WHICHPACK", +"FTE_STRINGS", +"DP_QC_FS_SEARCH_PACKFILE", +NULL +}; + +qbool MP_ConsoleCommand(const char *text, size_t textlen) +{ + prvm_prog_t *prog = MVM_prog; + return PRVM_ConsoleCommand(prog, text, textlen, &prog->funcoffsets.GameCommand, false, -1, 0, "QC function GameCommand is missing"); +} /* ========= @@ -51,7 +66,7 @@ VM_M_setmousetarget setmousetarget(float target) ========= */ -void VM_M_setmousetarget(void) +static void VM_M_setmousetarget(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_setmousetarget); @@ -64,7 +79,7 @@ void VM_M_setmousetarget(void) in_client_mouse = true; break; default: - PRVM_ERROR("VM_M_setmousetarget: wrong destination %f !",PRVM_G_FLOAT(OFS_PARM0)); + prog->error_cmd("VM_M_setmousetarget: wrong destination %f !",PRVM_G_FLOAT(OFS_PARM0)); } } @@ -75,7 +90,7 @@ VM_M_getmousetarget float getmousetarget ========= */ -void VM_M_getmousetarget(void) +static void VM_M_getmousetarget(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(0,VM_M_getmousetarget); @@ -94,7 +109,7 @@ VM_M_setkeydest setkeydest(float dest) ========= */ -void VM_M_setkeydest(void) +static void VM_M_setkeydest(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1,VM_M_setkeydest); @@ -117,7 +132,7 @@ void VM_M_setkeydest(void) // key_dest = key_message // break; default: - PRVM_ERROR("VM_M_setkeydest: wrong destination %f !", PRVM_G_FLOAT(OFS_PARM0)); + prog->error_cmd("VM_M_setkeydest: wrong destination %f !", PRVM_G_FLOAT(OFS_PARM0)); } } @@ -128,7 +143,7 @@ VM_M_getkeydest float getkeydest ========= */ -void VM_M_getkeydest(void) +static void VM_M_getkeydest(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(0,VM_M_getkeydest); @@ -161,21 +176,28 @@ VM_M_getresolution vector getresolution(float number) ========= */ -void VM_M_getresolution(void) +static void VM_M_getresolution(prvm_prog_t *prog) { int nr, fs; - VM_SAFEPARMCOUNTRANGE(1, 2, VM_getresolution); + VM_SAFEPARMCOUNTRANGE(1, 2, VM_M_getresolution); nr = (int)PRVM_G_FLOAT(OFS_PARM0); fs = ((prog->argc <= 1) || ((int)PRVM_G_FLOAT(OFS_PARM1))); - if(nr < 0 || nr >= (fs ? video_resolutions_count : video_resolutions_hardcoded_count)) + if(nr < -1 || nr >= (fs ? video_resolutions_count : video_resolutions_hardcoded_count)) { PRVM_G_VECTOR(OFS_RETURN)[0] = 0; PRVM_G_VECTOR(OFS_RETURN)[1] = 0; PRVM_G_VECTOR(OFS_RETURN)[2] = 0; } + else if(nr == -1) + { + vid_mode_t m = VID_GetDesktopMode(); + PRVM_G_VECTOR(OFS_RETURN)[0] = m.width; + PRVM_G_VECTOR(OFS_RETURN)[1] = m.height; + PRVM_G_VECTOR(OFS_RETURN)[2] = m.pixelheight_num / (prvm_vec_t) m.pixelheight_denom; + } else { video_resolution_t *r = &((fs ? video_resolutions : video_resolutions_hardcoded)[nr]); @@ -185,7 +207,7 @@ void VM_M_getresolution(void) } } -void VM_M_getgamedirinfo(void) +static void VM_M_getgamedirinfo(prvm_prog_t *prog) { int nr, item; VM_SAFEPARMCOUNT(2, VM_getgamedirinfo); @@ -198,9 +220,9 @@ void VM_M_getgamedirinfo(void) if(nr >= 0 && nr < fs_all_gamedirs_count) { if(item == 0) - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( fs_all_gamedirs[nr].name ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, fs_all_gamedirs[nr].name, strlen(fs_all_gamedirs[nr].name)); else if(item == 1) - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( fs_all_gamedirs[nr].description ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, fs_all_gamedirs[nr].description, strlen(fs_all_gamedirs[nr].description)); } } @@ -222,7 +244,7 @@ float getserverliststat(float type) 6 sortfield 7 sortflags */ -void VM_M_getserverliststat( void ) +static void VM_M_getserverliststat(prvm_prog_t *prog) { int type; VM_SAFEPARMCOUNT ( 1, VM_M_getserverliststat ); @@ -257,7 +279,7 @@ void VM_M_getserverliststat( void ) PRVM_G_FLOAT ( OFS_RETURN ) = serverlist_sortflags; return; default: - VM_Warning( "VM_M_getserverliststat: bad type %i!\n", type ); + VM_Warning(prog, "VM_M_getserverliststat: bad type %i!\n", type ); } } @@ -268,7 +290,7 @@ VM_M_resetserverlistmasks resetserverlistmasks() ======================== */ -void VM_M_resetserverlistmasks( void ) +static void VM_M_resetserverlistmasks(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(0, VM_M_resetserverlistmasks); ServerList_ResetMasks(); @@ -284,7 +306,7 @@ setserverlistmaskstring(float mask, float fld, string str, float op) 512 - 1024 or ======================== */ -void VM_M_setserverlistmaskstring( void ) +static void VM_M_setserverlistmaskstring(prvm_prog_t *prog) { const char *str; int masknr; @@ -295,13 +317,13 @@ void VM_M_setserverlistmaskstring( void ) str = PRVM_G_STRING( OFS_PARM2 ); masknr = (int)PRVM_G_FLOAT( OFS_PARM0 ); - if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT ) + if( masknr >= 0 && masknr < SERVERLIST_ANDMASKCOUNT ) mask = &serverlist_andmasks[masknr]; - else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT ) + else if( masknr >= 512 && masknr - 512 < SERVERLIST_ORMASKCOUNT ) mask = &serverlist_ormasks[masknr - 512 ]; else { - VM_Warning( "VM_M_setserverlistmaskstring: invalid mask number %i\n", masknr ); + VM_Warning(prog, "VM_M_setserverlistmaskstring: invalid mask number %i\n", masknr ); return; } @@ -309,28 +331,28 @@ void VM_M_setserverlistmaskstring( void ) switch( field ) { case SLIF_CNAME: - strlcpy( mask->info.cname, str, sizeof(mask->info.cname) ); + mask->info.cname_len = dp_strlcpy(mask->info.cname, str, sizeof(mask->info.cname)); break; case SLIF_NAME: - strlcpy( mask->info.name, str, sizeof(mask->info.name) ); + mask->info.name_len = dp_strlcpy(mask->info.name, str, sizeof(mask->info.name)); break; case SLIF_QCSTATUS: - strlcpy( mask->info.qcstatus, str, sizeof(mask->info.qcstatus) ); + mask->info.qcstatus_len = dp_strlcpy(mask->info.qcstatus, str, sizeof(mask->info.qcstatus)); break; case SLIF_PLAYERS: - strlcpy( mask->info.players, str, sizeof(mask->info.players) ); + mask->info.players_len = dp_strlcpy(mask->info.players, str, sizeof(mask->info.players)); break; case SLIF_MAP: - strlcpy( mask->info.map, str, sizeof(mask->info.map) ); + mask->info.map_len = dp_strlcpy(mask->info.map, str, sizeof(mask->info.map)); break; case SLIF_MOD: - strlcpy( mask->info.mod, str, sizeof(mask->info.mod) ); + mask->info.mod_len = dp_strlcpy(mask->info.mod, str, sizeof(mask->info.mod)); break; case SLIF_GAME: - strlcpy( mask->info.game, str, sizeof(mask->info.game) ); + mask->info.game_len = dp_strlcpy(mask->info.game, str, sizeof(mask->info.game)); break; default: - VM_Warning( "VM_M_setserverlistmaskstring: Bad field number %i passed!\n", field ); + VM_Warning(prog, "VM_M_setserverlistmaskstring: Bad field number %i passed!\n", field ); return; } @@ -348,7 +370,7 @@ setserverlistmasknumber(float mask, float fld, float num, float op) 512 - 1024 or ======================== */ -void VM_M_setserverlistmasknumber( void ) +static void VM_M_setserverlistmasknumber(prvm_prog_t *prog) { int number; serverlist_mask_t *mask; @@ -357,13 +379,13 @@ void VM_M_setserverlistmasknumber( void ) VM_SAFEPARMCOUNT( 4, VM_M_setserverlistmasknumber ); masknr = (int)PRVM_G_FLOAT( OFS_PARM0 ); - if( masknr >= 0 && masknr <= SERVERLIST_ANDMASKCOUNT ) + if( masknr >= 0 && masknr < SERVERLIST_ANDMASKCOUNT ) mask = &serverlist_andmasks[masknr]; - else if( masknr >= 512 && masknr - 512 <= SERVERLIST_ORMASKCOUNT ) + else if( masknr >= 512 && masknr - 512 < SERVERLIST_ORMASKCOUNT ) mask = &serverlist_ormasks[masknr - 512 ]; else { - VM_Warning( "VM_M_setserverlistmasknumber: invalid mask number %i\n", masknr ); + VM_Warning(prog, "VM_M_setserverlistmasknumber: invalid mask number %i\n", masknr ); return; } @@ -392,11 +414,14 @@ void VM_M_setserverlistmasknumber( void ) case SLIF_FREESLOTS: mask->info.freeslots = number; break; + case SLIF_CATEGORY: + mask->info.category = number; + break; case SLIF_ISFAVORITE: mask->info.isfavorite = number != 0; break; default: - VM_Warning( "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field ); + VM_Warning(prog, "VM_M_setserverlistmasknumber: Bad field number %i passed!\n", field ); return; } @@ -412,10 +437,10 @@ VM_M_resortserverlist resortserverlist ======================== */ -void VM_M_resortserverlist( void ) +static void VM_M_resortserverlist(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(0, VM_M_resortserverlist); - ServerList_RebuildViewList(); + ServerList_RebuildViewList(NULL); } /* @@ -425,9 +450,9 @@ VM_M_getserverliststring string getserverliststring(float field, float hostnr) ========= */ -void VM_M_getserverliststring(void) +static void VM_M_getserverliststring(prvm_prog_t *prog) { - serverlist_entry_t *cache; + const serverlist_entry_t *cache; int hostnr; VM_SAFEPARMCOUNT(2, VM_M_getserverliststring); @@ -436,40 +461,47 @@ void VM_M_getserverliststring(void) hostnr = (int)PRVM_G_FLOAT(OFS_PARM1); - if(hostnr < 0 || hostnr >= serverlist_viewcount) + if(hostnr == -1 && serverlist_callbackentry) { - Con_Print("VM_M_getserverliststring: bad hostnr passed!\n"); - return; + cache = serverlist_callbackentry; + } + else + { + if(hostnr < 0 || (unsigned)hostnr >= serverlist_viewcount) + { + Con_Print("VM_M_getserverliststring: bad hostnr passed!\n"); + return; + } + cache = ServerList_GetViewEntry(hostnr); } - cache = ServerList_GetViewEntry(hostnr); switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) { case SLIF_CNAME: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->info.cname ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.cname, cache->info.cname_len); break; case SLIF_NAME: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->info.name ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.name, cache->info.name_len); break; case SLIF_QCSTATUS: - PRVM_G_INT (OFS_RETURN ) = PRVM_SetTempString (cache->info.qcstatus ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.qcstatus, cache->info.qcstatus_len); break; case SLIF_PLAYERS: - PRVM_G_INT (OFS_RETURN ) = PRVM_SetTempString (cache->info.players ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.players, cache->info.players_len); break; case SLIF_GAME: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->info.game ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.game, cache->info.game_len); break; case SLIF_MOD: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->info.mod ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.mod, cache->info.mod_len); break; case SLIF_MAP: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->info.map ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->info.map, cache->info.map_len); break; // TODO remove this again case 1024: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->line1 ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->line1, cache->line1_len); break; case 1025: - PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( cache->line2 ); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, cache->line2, cache->line2_len); break; default: Con_Print("VM_M_getserverliststring: bad field number passed!\n"); @@ -483,23 +515,30 @@ VM_M_getserverlistnumber float getserverlistnumber(float field, float hostnr) ========= */ -void VM_M_getserverlistnumber(void) +static void VM_M_getserverlistnumber(prvm_prog_t *prog) { - serverlist_entry_t *cache; + const serverlist_entry_t *cache; int hostnr; - VM_SAFEPARMCOUNT(2, VM_M_getserverliststring); + VM_SAFEPARMCOUNT(2, VM_M_getserverlistnumber); PRVM_G_INT(OFS_RETURN) = OFS_NULL; hostnr = (int)PRVM_G_FLOAT(OFS_PARM1); - if(hostnr < 0 || hostnr >= serverlist_viewcount) + if(hostnr == -1 && serverlist_callbackentry) { - Con_Print("VM_M_getserverliststring: bad hostnr passed!\n"); - return; + cache = serverlist_callbackentry; + } + else + { + if(hostnr < 0 || (unsigned)hostnr >= serverlist_viewcount) + { + Con_Print("VM_M_getserverliststring: bad hostnr passed!\n"); + return; + } + cache = ServerList_GetViewEntry(hostnr); } - cache = ServerList_GetViewEntry(hostnr); switch( (int) PRVM_G_FLOAT(OFS_PARM0) ) { case SLIF_MAXPLAYERS: PRVM_G_FLOAT( OFS_RETURN ) = cache->info.maxplayers; @@ -517,11 +556,15 @@ void VM_M_getserverlistnumber(void) PRVM_G_FLOAT( OFS_RETURN ) = cache->info.freeslots; break; case SLIF_PING: - PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping; + // display inf when a listed server times out and net_slist_pause blocks its removal + PRVM_G_FLOAT( OFS_RETURN ) = cache->info.ping ? cache->info.ping : INFINITY; break; case SLIF_PROTOCOL: PRVM_G_FLOAT( OFS_RETURN ) = cache->info.protocol; break; + case SLIF_CATEGORY: + PRVM_G_FLOAT( OFS_RETURN ) = cache->info.category; + break; case SLIF_ISFAVORITE: PRVM_G_FLOAT( OFS_RETURN ) = cache->info.isfavorite; break; @@ -537,7 +580,7 @@ VM_M_setserverlistsort setserverlistsort(float field, float flags) ======================== */ -void VM_M_setserverlistsort( void ) +static void VM_M_setserverlistsort(prvm_prog_t *prog) { VM_SAFEPARMCOUNT( 2, VM_M_setserverlistsort ); @@ -552,10 +595,13 @@ VM_M_refreshserverlist refreshserverlist() ======================== */ -void VM_M_refreshserverlist( void ) +static void VM_M_refreshserverlist(prvm_prog_t *prog) { - VM_SAFEPARMCOUNT( 0, VM_M_refreshserverlist ); - ServerList_QueryList(false, true, false, false); + qbool do_reset = false; + VM_SAFEPARMCOUNTRANGE( 0, 1, VM_M_refreshserverlist ); + if (prog->argc >= 1 && PRVM_G_FLOAT(OFS_PARM0)) + do_reset = true; + ServerList_QueryList(do_reset, true, false, false); } /* @@ -565,13 +611,13 @@ VM_M_getserverlistindexforkey float getserverlistindexforkey(string key) ======================== */ -void VM_M_getserverlistindexforkey( void ) +static void VM_M_getserverlistindexforkey(prvm_prog_t *prog) { const char *key; VM_SAFEPARMCOUNT( 1, VM_M_getserverlistindexforkey ); key = PRVM_G_STRING( OFS_PARM0 ); - VM_CheckEmptyString( key ); + VM_CheckEmptyString( prog, key ); if( !strcmp( key, "cname" ) ) PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CNAME; @@ -601,6 +647,8 @@ void VM_M_getserverlistindexforkey( void ) PRVM_G_FLOAT( OFS_RETURN ) = SLIF_FREESLOTS; else if( !strcmp( key, "protocol" ) ) PRVM_G_FLOAT( OFS_RETURN ) = SLIF_PROTOCOL; + else if( !strcmp( key, "category" ) ) + PRVM_G_FLOAT( OFS_RETURN ) = SLIF_CATEGORY; else if( !strcmp( key, "isfavorite" ) ) PRVM_G_FLOAT( OFS_RETURN ) = SLIF_ISFAVORITE; else @@ -614,7 +662,7 @@ VM_M_addwantedserverlistkey addwantedserverlistkey(string key) ======================== */ -void VM_M_addwantedserverlistkey( void ) +static void VM_M_addwantedserverlistkey(prvm_prog_t *prog) { VM_SAFEPARMCOUNT( 1, VM_M_addwantedserverlistkey ); } @@ -636,13 +684,13 @@ Write*(* data, float type, float to) #define MSG_ALL 2 // reliable to all #define MSG_INIT 3 // write to the init string -sizebuf_t *VM_M_WriteDest (void) +static sizebuf_t *VM_M_WriteDest (prvm_prog_t *prog) { int dest; int destclient; if(!sv.active) - PRVM_ERROR("VM_M_WriteDest: game is not server (%s)", PRVM_NAME); + prog->error_cmd("VM_M_WriteDest: game is not server (%s)", prog->name); dest = (int)PRVM_G_FLOAT(OFS_PARM1); switch (dest) @@ -653,7 +701,7 @@ sizebuf_t *VM_M_WriteDest (void) case MSG_ONE: destclient = (int) PRVM_G_FLOAT(OFS_PARM2); if (destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active || !svs.clients[destclient].netconnection) - PRVM_ERROR("VM_clientcommand: %s: invalid client !", PRVM_NAME); + prog->error_cmd("VM_clientcommand: %s: invalid client !", prog->name); return &svs.clients[destclient].netconnection->message; @@ -664,59 +712,59 @@ sizebuf_t *VM_M_WriteDest (void) return &sv.signon; default: - PRVM_ERROR ("WriteDest: bad destination"); + prog->error_cmd("WriteDest: bad destination"); break; } return NULL; } -void VM_M_WriteByte (void) +static void VM_M_WriteByte (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteByte); - MSG_WriteByte (VM_M_WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM0)); + MSG_WriteByte (VM_M_WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM0)); } -void VM_M_WriteChar (void) +static void VM_M_WriteChar (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteChar); - MSG_WriteChar (VM_M_WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM0)); + MSG_WriteChar (VM_M_WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM0)); } -void VM_M_WriteShort (void) +static void VM_M_WriteShort (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteShort); - MSG_WriteShort (VM_M_WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM0)); + MSG_WriteShort (VM_M_WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM0)); } -void VM_M_WriteLong (void) +static void VM_M_WriteLong (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteLong); - MSG_WriteLong (VM_M_WriteDest(), (int)PRVM_G_FLOAT(OFS_PARM0)); + MSG_WriteLong (VM_M_WriteDest(prog), (int)PRVM_G_FLOAT(OFS_PARM0)); } -void VM_M_WriteAngle (void) +static void VM_M_WriteAngle (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteAngle); - MSG_WriteAngle (VM_M_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); + MSG_WriteAngle (VM_M_WriteDest(prog), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); } -void VM_M_WriteCoord (void) +static void VM_M_WriteCoord (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteCoord); - MSG_WriteCoord (VM_M_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); + MSG_WriteCoord (VM_M_WriteDest(prog), PRVM_G_FLOAT(OFS_PARM0), sv.protocol); } -void VM_M_WriteString (void) +static void VM_M_WriteString (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteString); - MSG_WriteString (VM_M_WriteDest(), PRVM_G_STRING(OFS_PARM0)); + MSG_WriteString (VM_M_WriteDest(prog), PRVM_G_STRING(OFS_PARM0)); } -void VM_M_WriteEntity (void) +static void VM_M_WriteEntity (prvm_prog_t *prog) { VM_SAFEPARMCOUNT(1, VM_M_WriteEntity); - MSG_WriteShort (VM_M_WriteDest(), PRVM_G_EDICTNUM(OFS_PARM0)); + MSG_WriteShort (VM_M_WriteDest(prog), PRVM_G_EDICTNUM(OFS_PARM0)); } /* @@ -728,26 +776,289 @@ copies data from one entity to another copyentity(entity src, entity dst) ================= */ -static void VM_M_copyentity (void) +static void VM_M_copyentity (prvm_prog_t *prog) { prvm_edict_t *in, *out; VM_SAFEPARMCOUNT(2,VM_M_copyentity); in = PRVM_G_EDICT(OFS_PARM0); out = PRVM_G_EDICT(OFS_PARM1); - memcpy(out->fields.vp, in->fields.vp, prog->progs->entityfields * 4); + memcpy(out->fields.fp, in->fields.fp, prog->entityfields * sizeof(prvm_vec_t)); } //#66 vector() getmousepos (EXT_CSQC) -static void VM_M_getmousepos(void) +static void VM_M_getmousepos(prvm_prog_t *prog) { VM_SAFEPARMCOUNT(0,VM_M_getmousepos); if (key_consoleactive || (key_dest != key_menu && key_dest != key_menu_grabbed)) VectorSet(PRVM_G_VECTOR(OFS_RETURN), 0, 0, 0); else if (in_client_mouse) - VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.width, in_windowmouse_y * vid_conheight.integer / vid.height, 0); + VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_windowmouse_x * vid_conwidth.integer / vid.mode.width, in_windowmouse_y * vid_conheight.integer / vid.mode.height, 0); + else + VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.mode.width, in_mouse_y * vid_conheight.integer / vid.mode.height, 0); +} + +static void VM_M_crypto_getkeyfp(prvm_prog_t *prog) +{ + lhnetaddress_t addr; + const char *s; + char keyfp[FP64_SIZE + 1]; + + VM_SAFEPARMCOUNT(1,VM_M_crypto_getkeyfp); + + s = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( prog, s ); + + if(LHNETADDRESS_FromString(&addr, s, 26000) && Crypto_RetrieveHostKey(&addr, NULL, keyfp, sizeof(keyfp), NULL, 0, NULL, NULL)) + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, keyfp, strlen(keyfp)); + else + PRVM_G_INT( OFS_RETURN ) = OFS_NULL; +} +static void VM_M_crypto_getidfp(prvm_prog_t *prog) +{ + lhnetaddress_t addr; + const char *s; + char idfp[FP64_SIZE + 1]; + + VM_SAFEPARMCOUNT(1,VM_M_crypto_getidfp); + + s = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( prog, s ); + + if(LHNETADDRESS_FromString(&addr, s, 26000) && Crypto_RetrieveHostKey(&addr, NULL, NULL, 0, idfp, sizeof(idfp), NULL, NULL)) + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString( prog, idfp, strlen(idfp)); + else + PRVM_G_INT( OFS_RETURN ) = OFS_NULL; +} +static void VM_M_crypto_getidstatus(prvm_prog_t *prog) +{ + lhnetaddress_t addr; + const char *s; + qbool issigned; + + VM_SAFEPARMCOUNT(1,VM_M_crypto_getidstatus); + + s = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( prog, s ); + + if(LHNETADDRESS_FromString(&addr, s, 26000) && Crypto_RetrieveHostKey(&addr, NULL, NULL, 0, NULL, 0, NULL, &issigned)) + PRVM_G_FLOAT( OFS_RETURN ) = issigned ? 2 : 1; + else + PRVM_G_FLOAT( OFS_RETURN ) = 0; +} +static void VM_M_crypto_getencryptlevel(prvm_prog_t *prog) +{ + lhnetaddress_t addr; + const char *s; + int aeslevel; + char vabuf[1024]; + + VM_SAFEPARMCOUNT(1,VM_M_crypto_getencryptlevel); + + s = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString( prog, s ); + + if(LHNETADDRESS_FromString(&addr, s, 26000) && Crypto_RetrieveHostKey(&addr, NULL, NULL, 0, NULL, 0, &aeslevel, NULL)) + { + if (aeslevel) + { + size_t vabuf_len = dpsnprintf(vabuf, sizeof(vabuf), "%d AES128", aeslevel); + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, vabuf, vabuf_len); + } + else + PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(prog, "0", 1); + } else - VectorSet(PRVM_G_VECTOR(OFS_RETURN), in_mouse_x * vid_conwidth.integer / vid.width, in_mouse_y * vid_conheight.integer / vid.height, 0); + PRVM_G_INT( OFS_RETURN ) = OFS_NULL; +} +static void VM_M_crypto_getmykeyfp(prvm_prog_t *prog) +{ + int i; + char keyfp[FP64_SIZE + 1]; + + VM_SAFEPARMCOUNT(1, VM_M_crypto_getmykeyfp); + + i = PRVM_G_FLOAT( OFS_PARM0 ); + switch(Crypto_RetrieveLocalKey(i, keyfp, sizeof(keyfp), NULL, 0, NULL)) + { + case -1: + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, "", 0); + break; + case 0: + PRVM_G_INT( OFS_RETURN ) = OFS_NULL; + break; + default: + case 1: + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, keyfp, strlen(keyfp)); + break; + } +} +static void VM_M_crypto_getmyidfp(prvm_prog_t *prog) +{ + int i; + char idfp[FP64_SIZE + 1]; + + VM_SAFEPARMCOUNT(1, VM_M_crypto_getmyidfp); + + i = PRVM_G_FLOAT( OFS_PARM0 ); + switch(Crypto_RetrieveLocalKey(i, NULL, 0, idfp, sizeof(idfp), NULL)) + { + case -1: + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, "", 0); + break; + case 0: + PRVM_G_INT( OFS_RETURN ) = OFS_NULL; + break; + default: + case 1: + PRVM_G_INT( OFS_RETURN ) = PRVM_SetTempString(prog, idfp, strlen(idfp)); + break; + } +} +static void VM_M_crypto_getmyidstatus(prvm_prog_t *prog) +{ + int i; + qbool issigned; + + VM_SAFEPARMCOUNT(1, VM_M_crypto_getmyidstatus); + + i = PRVM_G_FLOAT( OFS_PARM0 ); + switch(Crypto_RetrieveLocalKey(i, NULL, 0, NULL, 0, &issigned)) + { + case -1: + PRVM_G_FLOAT( OFS_RETURN ) = 0; // have no ID there + break; + case 0: + PRVM_G_FLOAT( OFS_RETURN ) = -1; // out of range + break; + default: + case 1: + PRVM_G_FLOAT( OFS_RETURN ) = issigned ? 2 : 1; + break; + } +} + +// CL_Video interface functions + +/* +======================== +VM_cin_open + +float cin_open(string file, string name) +======================== +*/ +void VM_cin_open(prvm_prog_t *prog) +{ + const char *file; + const char *name; + + VM_SAFEPARMCOUNT( 2, VM_cin_open ); + + file = PRVM_G_STRING( OFS_PARM0 ); + name = PRVM_G_STRING( OFS_PARM1 ); + + VM_CheckEmptyString(prog, file ); + VM_CheckEmptyString(prog, name ); + + if( CL_OpenVideo( file, name, MENUOWNER, "" ) ) + PRVM_G_FLOAT( OFS_RETURN ) = 1; + else + PRVM_G_FLOAT( OFS_RETURN ) = 0; +} + +/* +======================== +VM_cin_close + +void cin_close(string name) +======================== +*/ +void VM_cin_close(prvm_prog_t *prog) +{ + const char *name; + + VM_SAFEPARMCOUNT( 1, VM_cin_close ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString(prog, name ); + + CL_CloseVideo( CL_GetVideoByName( name ) ); +} + +/* +======================== +VM_cin_setstate +void cin_setstate(string name, float type) +======================== +*/ +void VM_cin_setstate(prvm_prog_t *prog) +{ + const char *name; + clvideostate_t state; + clvideo_t *video; + + VM_SAFEPARMCOUNT( 2, VM_cin_setstate ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString(prog, name ); + + state = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 )); + + video = CL_GetVideoByName( name ); + if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT ) + CL_SetVideoState( video, state ); +} + +/* +======================== +VM_cin_getstate + +float cin_getstate(string name) +======================== +*/ +void VM_cin_getstate(prvm_prog_t *prog) +{ + const char *name; + clvideo_t *video; + + VM_SAFEPARMCOUNT( 1, VM_cin_getstate ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString(prog, name ); + + video = CL_GetVideoByName( name ); + if( video ) + PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state; + else + PRVM_G_FLOAT( OFS_RETURN ) = 0; +} + +/* +======================== +VM_cin_restart + +void cin_restart(string name) +======================== +*/ +void VM_cin_restart(prvm_prog_t *prog) +{ + const char *name; + clvideo_t *video; + + VM_SAFEPARMCOUNT( 1, VM_cin_restart ); + + name = PRVM_G_STRING( OFS_PARM0 ); + VM_CheckEmptyString(prog, name ); + + video = CL_GetVideoByName( name ); + if( video ) + CL_RestartVideo( video ); +} + +static void VM_M_registercommand(prvm_prog_t *prog) +{ + VM_SAFEPARMCOUNT(1, VM_M_registercommand); + Cmd_AddCommand(CF_CLIENT, PRVM_G_STRING(OFS_PARM0), NULL, "console command created by QuakeC"); } prvm_builtin_t vm_m_builtins[] = { @@ -814,7 +1125,7 @@ VM_argv, // #59 VM_isserver, // #60 VM_clientcount, // #61 VM_clientstate, // #62 -VM_clcommand, // #63 +NULL, // #63 FIXME VM_changelevel, // #64 VM_localsound, // #65 VM_M_getmousepos, // #66 @@ -1130,8 +1441,8 @@ NULL, // #348 VM_CL_isdemo, // #349 NULL, // #350 NULL, // #351 -NULL, // #352 -NULL, // #353 +VM_M_registercommand, // #352 void(string cmdname) +VM_wasfreed, // #353 float(entity ent) wasfreed NULL, // #354 VM_CL_videoplaying, // #355 VM_findfont, // #356 float(string fontname) loadfont (DP_GFX_FONTS) @@ -1274,11 +1585,11 @@ VM_gecko_resize, // #492 void gecko_resize( string name, float w, float h ) VM_gecko_get_texture_extent, // #493 vector gecko_get_texture_extent( string name ) VM_crc16, // #494 float(float caseinsensitive, string s, ...) crc16 = #494 (DP_QC_CRC16) VM_cvar_type, // #495 float(string name) cvar_type = #495; (DP_QC_CVAR_TYPE) -NULL, // #496 -NULL, // #497 -NULL, // #498 -NULL, // #499 -NULL, // #500 +VM_numentityfields, // #496 float() numentityfields = #496; (QP_QC_ENTITYDATA) +VM_entityfieldname, // #497 string(float fieldnum) entityfieldname = #497; (DP_QC_ENTITYDATA) +VM_entityfieldtype, // #498 float(float fieldnum) entityfieldtype = #498; (DP_QC_ENTITYDATA) +VM_getentityfieldstring, // #499 string(float fieldnum, entity ent) getentityfieldstring = #499; (DP_QC_ENTITYDATA) +VM_putentityfieldstring, // #500 float(float fieldnum, entity ent, string s) putentityfieldstring = #500; (DP_QC_ENTITYDATA) NULL, // #501 NULL, // #502 VM_whichpack, // #503 string(string) whichpack = #503; @@ -1291,7 +1602,7 @@ NULL, // #509 VM_uri_escape, // #510 string(string in) uri_escape = #510; VM_uri_unescape, // #511 string(string in) uri_unescape = #511; VM_etof, // #512 float(entity ent) num_for_edict = #512 (DP_QC_NUM_FOR_EDICT) -VM_uri_get, // #513 float(string uril, float id) uri_get = #513; (DP_QC_URI_GET) +VM_uri_get, // #513 float(string uri, float id, [string post_contenttype, string post_delim, [float buf]]) uri_get = #513; (DP_QC_URI_GET, DP_QC_URI_POST) VM_tokenize_console, // #514 float(string str) tokenize_console = #514; (DP_QC_TOKENIZE_CONSOLE) VM_argv_start_index, // #515 float(float idx) argv_start_index = #515; (DP_QC_TOKENIZE_CONSOLE) VM_argv_end_index, // #516 float(float idx) argv_end_index = #516; (DP_QC_TOKENIZE_CONSOLE) @@ -1313,10 +1624,10 @@ NULL, // #531 VM_log, // #532 VM_getsoundtime, // #533 float(entity e, float channel) getsoundtime = #533; (DP_SND_GETSOUNDTIME) VM_soundlength, // #534 float(string sample) soundlength = #534; (DP_SND_GETSOUNDTIME) -NULL, // #535 -NULL, // #536 -NULL, // #537 -NULL, // #538 +VM_buf_loadfile, // #535 float(string filename, float bufhandle) buf_loadfile (DP_QC_STRINGBUFFERS_EXT_WIP) +VM_buf_writefile, // #536 float(float filehandle, float bufhandle, float startpos, float numstrings) buf_writefile (DP_QC_STRINGBUFFERS_EXT_WIP) +VM_bufstr_find, // #537 float(float bufhandle, string match, float matchrule, float startpos) bufstr_find (DP_QC_STRINGBUFFERS_EXT_WIP) +VM_matchpattern, // #538 float(string s, string pattern, float matchrule) matchpattern (DP_QC_STRINGBUFFERS_EXT_WIP) NULL, // #539 NULL, // #540 NULL, // #541 @@ -1411,17 +1722,29 @@ NULL, // #629 VM_setkeybind, // #630 float(float key, string bind[, float bindmap]) setkeybind VM_getbindmaps, // #631 vector(void) getbindmap VM_setbindmaps, // #632 float(vector bm) setbindmap +VM_M_crypto_getkeyfp, // #633 string(string addr) crypto_getkeyfp +VM_M_crypto_getidfp, // #634 string(string addr) crypto_getidfp +VM_M_crypto_getencryptlevel, // #635 string(string addr) crypto_getencryptlevel +VM_M_crypto_getmykeyfp, // #636 string(float addr) crypto_getmykeyfp +VM_M_crypto_getmyidfp, // #637 string(float addr) crypto_getmyidfp +NULL, // #638 +VM_digest_hex, // #639 +NULL, // #640 +VM_M_crypto_getmyidstatus, // #641 float(float i) crypto_getmyidstatus +VM_coverage, // #642 +VM_M_crypto_getidstatus, // #643 float(string addr) crypto_getidstatus NULL }; const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t); -void VM_M_Cmd_Init(void) +void MVM_init_cmd(prvm_prog_t *prog) { r_refdef_scene_t *scene; - VM_Cmd_Init(); - VM_Polygons_Reset(); + VM_Cmd_Init(prog); + prog->polygonbegin_model = NULL; + prog->polygonbegin_guess2d = 0; scene = R_GetScenePointer( RST_MENU ); @@ -1433,14 +1756,16 @@ void VM_M_Cmd_Init(void) scene->maxentities = MAX_EDICTS + 256 + 512; scene->entities = (entity_render_t **)Mem_Alloc(prog->progs_mempool, sizeof(entity_render_t *) * scene->maxentities); - scene->ambient = 32.0f; + // LadyHavoc: what is this for? + scene->ambientintensity = 32.0f; } -void VM_M_Cmd_Reset(void) +void MVM_reset_cmd(prvm_prog_t *prog) { // note: the menu's render entities are automatically freed when the prog's pool is freed //VM_Cmd_Init(); - VM_Cmd_Reset(); - VM_Polygons_Reset(); + VM_Cmd_Reset(prog); + prog->polygonbegin_model = NULL; + prog->polygonbegin_guess2d = 0; }