// cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
// also applies here
+#include "quakedef.h"
+
#include "prvm_cmds.h"
#include <time.h>
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
}
+/*
+=========
+VM_strreplace
+
+string(string search, string replace, string subject) strreplace = #484;
+=========
+*/
+// replaces all occurrences of search with replace in the string subject, and returns the result
+void VM_strreplace(void)
+{
+ int i, j, si;
+ const char *search, *replace, *subject;
+ char string[VM_STRINGTEMP_LENGTH];
+ int search_len, replace_len, subject_len;
+
+ VM_SAFEPARMCOUNT(3,VM_strreplace);
+
+ search = PRVM_G_STRING(OFS_PARM0);
+ replace = PRVM_G_STRING(OFS_PARM1);
+ subject = PRVM_G_STRING(OFS_PARM2);
+
+ search_len = (int)strlen(search);
+ replace_len = (int)strlen(replace);
+ subject_len = (int)strlen(subject);
+
+ si = 0;
+ for (i = 0; i < subject_len; i++)
+ {
+ for (j = 0; j < search_len && i+j < subject_len; j++)
+ if (subject[i+j] != search[j])
+ break;
+ if (j == search_len || i+j == subject_len)
+ {
+ // found it at offset 'i'
+ for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
+ string[si++] = replace[j];
+ i += search_len - 1;
+ }
+ else
+ {
+ // not found
+ if (si < (int)sizeof(string) - 1)
+ string[si++] = subject[i];
+ }
+ }
+ string[si] = '\0';
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+}
+
+/*
+=========
+VM_strireplace
+
+string(string search, string replace, string subject) strireplace = #485;
+=========
+*/
+// case-insensitive version of strreplace
+void VM_strireplace(void)
+{
+ int i, j, si;
+ const char *search, *replace, *subject;
+ char string[VM_STRINGTEMP_LENGTH];
+ int search_len, replace_len, subject_len;
+
+ VM_SAFEPARMCOUNT(3,VM_strreplace);
+
+ search = PRVM_G_STRING(OFS_PARM0);
+ replace = PRVM_G_STRING(OFS_PARM1);
+ subject = PRVM_G_STRING(OFS_PARM2);
+
+ search_len = (int)strlen(search);
+ replace_len = (int)strlen(replace);
+ subject_len = (int)strlen(subject);
+
+ si = 0;
+ for (i = 0; i < subject_len; i++)
+ {
+ for (j = 0; j < search_len && i+j < subject_len; j++)
+ if (tolower(subject[i+j]) != tolower(search[j]))
+ break;
+ if (j == search_len || i+j == subject_len)
+ {
+ // found it at offset 'i'
+ for (j = 0; j < replace_len && si < (int)sizeof(string) - 1; j++)
+ string[si++] = replace[j];
+ i += search_len - 1;
+ }
+ else
+ {
+ // not found
+ if (si < (int)sizeof(string) - 1)
+ string[si++] = subject[i];
+ }
+ }
+ string[si] = '\0';
+
+ PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(string);
+}
+
/*
=========
VM_stov
void VM_tokenize (void)
{
const char *p;
+ static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNT(1,VM_tokenize);
- p = PRVM_G_STRING(OFS_PARM0);
+ strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
+ p = string;
num_tokens = 0;
while(COM_ParseToken_VM_Tokenize(&p, false))
const char *p;
const char *token;
char tokentext[MAX_INPUTLINE];
+ static char string[VM_STRINGTEMP_LENGTH]; // static, because it's big
VM_SAFEPARMCOUNTRANGE(2, 8,VM_tokenizebyseparator);
- p = PRVM_G_STRING(OFS_PARM0);
+ strlcpy(string, PRVM_G_STRING(OFS_PARM0), sizeof(string));
+ p = string;
numseparators = 0;;
for (j = 1;j < prog->argc;j++)
data = PRVM_G_STRING(OFS_PARM1);
// parse the opening brace
- if (!COM_ParseToken_Simple(&data, false) || com_token[0] != '{' )
+ if (!COM_ParseToken_Simple(&data, false, false) || com_token[0] != '{' )
PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
PRVM_ED_ParseEdict (data, ent);
Draw_FreePic(s);
}
+dp_font_t *getdrawfont()
+{
+ if(prog->globaloffsets.drawfont >= 0)
+ {
+ int f = PRVM_G_FLOAT(prog->globaloffsets.drawfont);
+ if(f < 0 || f >= MAX_FONTS)
+ return FONT_DEFAULT;
+ return &dp_fonts[f];
+ }
+ else
+ return FONT_DEFAULT;
+}
+
/*
=========
VM_drawcharacter
return;
}
- DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
if(pos[2] || scale[2])
Con_Printf("VM_drawstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
- DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true);
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag, NULL, true, getdrawfont());
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
+
+/*
+=========
+VM_drawcolorcodedstring
+
+float drawcolorcodedstring(vector position, string text, vector scale, float alpha, float flag)
+=========
+*/
+void VM_drawcolorcodedstring(void)
+{
+ float *pos,*scale;
+ const char *string;
+ int flag,color;
+ VM_SAFEPARMCOUNT(5,VM_drawstring);
+
+ string = PRVM_G_STRING(OFS_PARM1);
+ pos = PRVM_G_VECTOR(OFS_PARM0);
+ scale = PRVM_G_VECTOR(OFS_PARM2);
+ flag = (int)PRVM_G_FLOAT(OFS_PARM5);
+
+ if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawcolorcodedstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+ return;
+ }
+
+ if(!scale[0] || !scale[1])
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawcolorcodedstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
+ return;
+ }
+
+ if(pos[2] || scale[2])
+ Con_Printf("VM_drawcolorcodedstring: z value%s from %s discarded\n",(pos[2] && scale[2]) ? "s" : " ",((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale")));
+
+ color = -1;
+ DrawQ_String_Font(pos[0], pos[1], string, 0, scale[0], scale[1], 1, 1, 1, PRVM_G_FLOAT(OFS_PARM3), flag, NULL, false, getdrawfont());
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
/*
=========
+VM_stringwidth
+
+float stringwidth(string text, float allowColorCodes)
+=========
+*/
+void VM_stringwidth(void)
+{
+ const char *string;
+ int colors;
+ VM_SAFEPARMCOUNT(2,VM_drawstring);
+
+ string = PRVM_G_STRING(OFS_PARM0);
+ colors = (int)PRVM_G_FLOAT(OFS_PARM1);
+
+ PRVM_G_FLOAT(OFS_RETURN) = DrawQ_String_Font(0, 0, string, 0, 1, 1, 0, 0, 0, 0, 0, NULL, !colors, getdrawfont()); // 1x1 characters, don't actually draw
+}
+/*
+=========
VM_drawpic
float drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
DrawQ_Pic(pos[0], pos[1], Draw_CachePic(picname, true), size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
+/*
+=========
+VM_drawsubpic
+
+float drawsubpic(vector position, vector size, string pic, vector srcPos, vector srcSize, vector rgb, float alpha, float flag)
+
+=========
+*/
+void VM_drawsubpic(void)
+{
+ const char *picname;
+ float *size, *pos, *rgb, *srcPos, *srcSize, alpha;
+ int flag;
+
+ VM_SAFEPARMCOUNT(8,VM_drawsubpic);
+
+ picname = PRVM_G_STRING(OFS_PARM2);
+ VM_CheckEmptyString (picname);
+
+ // is pic cached ? no function yet for that
+ if(!1)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_drawsubpic: %s: %s not cached !\n", PRVM_NAME, picname);
+ return;
+ }
+
+ pos = PRVM_G_VECTOR(OFS_PARM0);
+ size = PRVM_G_VECTOR(OFS_PARM1);
+ srcPos = PRVM_G_VECTOR(OFS_PARM3);
+ srcSize = PRVM_G_VECTOR(OFS_PARM4);
+ rgb = PRVM_G_VECTOR(OFS_PARM5);
+ alpha = PRVM_G_FLOAT(OFS_PARM6);
+ flag = (int) PRVM_G_FLOAT(OFS_PARM7);
+
+ if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
+ {
+ PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawsubpic: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
+ return;
+ }
+
+ if(pos[2] || size[2])
+ Con_Printf("VM_drawsubpic: z value%s from %s discarded\n",(pos[2] && size[2]) ? "s" : " ",((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
+
+ DrawQ_SuperPic(pos[0], pos[1], Draw_CachePic(picname, true),
+ size[0], size[1],
+ srcPos[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0] + srcSize[0], srcPos[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
+ srcPos[0] + srcSize[0], srcPos[1] + srcSize[1], rgb[0], rgb[1], rgb[2], alpha,
+ flag);
+ PRVM_G_FLOAT(OFS_RETURN) = 1;
+}
/*
=========
CL_RestartVideo( video );
}
+#ifdef SUPPORT_GECKO
+static const char *vm_gecko_getfullname( const char *name ) {
+ // FIXME: assert that PRVM_NAME is not empty.. [12/3/2007 Black]
+ return va( "%s/%s", PRVM_NAME, name );
+}
+
+/*
+========================
+VM_gecko_create
+
+float[bool] gecko_create( string name )
+========================
+*/
+void VM_gecko_create( void ) {
+ const char *name;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_create );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+
+ if( !CL_Gecko_CreateBrowser( vm_gecko_getfullname( name ) ) ) {
+ // TODO: error handling [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+ PRVM_G_FLOAT( OFS_RETURN ) = 1;
+}
+
+/*
+========================
+VM_gecko_destroy
+
+void gecko_destroy( string name )
+========================
+*/
+void VM_gecko_destroy( void ) {
+ const char *name;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 1, VM_gecko_destroy );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ instance = CL_Gecko_FindBrowser( vm_gecko_getfullname( name ) );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_DestroyBrowser( instance );
+}
+
+/*
+========================
+VM_gecko_navigate
+
+void gecko_navigate( string name, string URI )
+========================
+*/
+void VM_gecko_navigate( void ) {
+ const char *name;
+ const char *URI;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 2, VM_gecko_navigate );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ URI = PRVM_G_STRING( OFS_PARM1 );
+ VM_CheckEmptyString( name );
+ VM_CheckEmptyString( URI );
+
+ instance = CL_Gecko_FindBrowser( vm_gecko_getfullname( name ) );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_NavigateToURI( instance, URI );
+}
+
+/*
+========================
+VM_gecko_keyevent
+
+float[bool] gecko_keyevent( string name, float key, float eventtype )
+========================
+*/
+void VM_gecko_keyevent( void ) {
+ const char *name;
+ unsigned int key;
+ clgecko_buttoneventtype_t eventtype;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_keyevent );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ key = (unsigned int) PRVM_G_FLOAT( OFS_PARM1 );
+ switch( (unsigned int) PRVM_G_FLOAT( OFS_PARM3 ) ) {
+ case 0:
+ eventtype = CLG_BET_DOWN;
+ break;
+ case 1:
+ eventtype = CLG_BET_UP;
+ break;
+ case 2:
+ eventtype = CLG_BET_PRESS;
+ break;
+ case 3:
+ eventtype = CLG_BET_DOUBLECLICK;
+ break;
+ default:
+ // TODO: console printf? [12/3/2007 Black]
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ instance = CL_Gecko_FindBrowser( vm_gecko_getfullname( name ) );
+ if( !instance ) {
+ PRVM_G_FLOAT( OFS_RETURN ) = 0;
+ return;
+ }
+
+ PRVM_G_FLOAT( OFS_RETURN ) = (CL_Gecko_Event_Key( instance, key, eventtype ) == true);
+}
+
+/*
+========================
+VM_gecko_movemouse
+
+void gecko_mousemove( string name, float x, float y )
+========================
+*/
+void VM_gecko_movemouse( void ) {
+ const char *name;
+ float x, y;
+ clgecko_t *instance;
+
+ VM_SAFEPARMCOUNT( 3, VM_gecko_movemouse );
+
+ name = PRVM_G_STRING( OFS_PARM0 );
+ VM_CheckEmptyString( name );
+ x = PRVM_G_FLOAT( OFS_PARM1 );
+ y = PRVM_G_FLOAT( OFS_PARM2 );
+
+ instance = CL_Gecko_FindBrowser( vm_gecko_getfullname( name ) );
+ if( !instance ) {
+ return;
+ }
+ CL_Gecko_Event_CursorMove( instance, x, y );
+}
+#endif
+
/*
==============
VM_makevectors
DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
}
-
-
-
-
// float(float number, float quantity) bitshift (EXT_BITSHIFT)
void VM_bitshift (void)
{
/*
========================
VM_buf_sort
-sort buffer by beginnings of strings (sortpower defaults it's lenght)
+sort buffer by beginnings of strings (cmplength defaults it's length)
"backward == TRUE" means that sorting goes upside-down
-void buf_sort(float bufhandle, float sortpower, float backward) = #464;
+void buf_sort(float bufhandle, float cmplength, float backward) = #464;
========================
*/
void VM_buf_sort (void)
VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
+ // TODO: please someone rename this to buf_cmplength [12/3/2007 Black]
buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
if(buf_sortpower <= 0)
buf_sortpower = 99999999;
PRVM_EDICTFIELDVALUE(ent, prog->fieldoffsets.angles)->vector[0] = ANGLEMOD (current + move);
}
-
+// TODO: adapt all static function names to use a single naming convention... [12/3/2007 Black]
static int Is_Text_Color (char c, char t)
{
int a = 0;
const char *s;
VM_SAFEPARMCOUNT(2, VM_str2chr);
s = PRVM_G_STRING(OFS_PARM0);
- if((unsigned)PRVM_G_FLOAT(OFS_PARM1) > strlen(s))
- return;
- PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(int)PRVM_G_FLOAT(OFS_PARM1)];
+ if((unsigned)PRVM_G_FLOAT(OFS_PARM1) < strlen(s))
+ PRVM_G_FLOAT(OFS_RETURN) = (unsigned char)s[(unsigned)PRVM_G_FLOAT(OFS_PARM1)];
+ else
+ PRVM_G_FLOAT(OFS_RETURN) = 0;
}
//#223 string(float c, ...) chr2str (FTE_STRINGS)
{
char src[VM_STRINGTEMP_LENGTH];
char destbuf[VM_STRINGTEMP_LENGTH];
- char *dest = destbuf;
int pad;
VM_SAFEPARMCOUNTRANGE(1, 8, VM_strpad);
pad = PRVM_G_FLOAT(OFS_PARM0);
VM_VarString(1, src, sizeof(src));
- if (pad < 0)
- { //pad left
- pad = -pad - strlen(src);
- if (pad>=VM_STRINGTEMP_LENGTH)
- pad = VM_STRINGTEMP_LENGTH-1;
- if (pad < 0)
- pad = 0;
-
- strlcpy(dest+pad, src, VM_STRINGTEMP_LENGTH-pad);
- while(pad--)
- {
- pad--;
- dest[pad] = ' ';
- }
- }
- else
- { //pad right
- if (pad>=VM_STRINGTEMP_LENGTH)
- pad = VM_STRINGTEMP_LENGTH-1;
- pad -= strlen(src);
- if (pad < 0)
- pad = 0;
-
- strlcpy(dest, src, VM_STRINGTEMP_LENGTH);
- dest+=strlen(dest);
-
- while(pad-->0)
- *dest++ = ' ';
- *dest = '\0';
- }
+ // note: < 0 = left padding, > 0 = right padding,
+ // this is reverse logic of printf!
+ dpsnprintf(destbuf, sizeof(destbuf), "%*s", -pad, src);
PRVM_G_INT(OFS_RETURN) = PRVM_SetTempString(destbuf);
}