#include "prvm_cmds.h"
+// LordHavoc: changed this to NOT use a return statement, so that it can be used in functions that must return a value
+void VM_Warning(const char *fmt, ...)
+{
+ va_list argptr;
+ char msg[MAX_INPUTLINE];
+
+ va_start(argptr,fmt);
+ dpvsnprintf(msg,sizeof(msg),fmt,argptr);
+ va_end(argptr);
+
+ Con_Print(msg);
+ PRVM_PrintState();
+}
+
+
//============================================================================
// Common
char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
- Con_Printf("======%S ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("======%s ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
if(prog->self)
{
ed = PRVM_G_EDICT(prog->self->ofs);
PRVM_ED_Print(ed);
}
- PRVM_ERROR ("%s: Program error", PRVM_NAME);
+ PRVM_ERROR ("%s: Program error in function %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
}
/*
char string[VM_STRINGTEMP_LENGTH];
VM_VarString(0, string, sizeof(string));
- Con_Printf("======%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
+ Con_Printf("======OBJECT ERROR======\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
if(prog->self)
{
ed = PRVM_G_EDICT (prog->self->ofs);
else
// objerror has to display the object fields -> else call
PRVM_ERROR ("VM_objecterror: self not defined !");
+ Con_Printf("%s OBJECT ERROR in %s:\n%s\nTip: read above for entity information\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
}
/*
if(!sv.active)
{
- Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
+ VM_Warning("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
return;
}
char string[VM_STRINGTEMP_LENGTH];
//find client for this entity
- clientnum = PRVM_G_FLOAT(OFS_PARM0);
+ clientnum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
{
- Con_Printf("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
+ VM_Warning("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
return;
}
client = svs.clients + clientnum;
+ if (!client->netconnection)
+ return;
+
VM_VarString(1, string, sizeof(string));
- MSG_WriteChar(&client->message,svc_print);
- MSG_WriteString(&client->message, string);
+ MSG_WriteChar(&client->netconnection->message,svc_print);
+ MSG_WriteString(&client->netconnection->message, string);
}
/*
if(!S_LocalSound (s))
{
- Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
return;
}
int ent;
VM_SAFEPARMCOUNT(1, VM_ftoi);
- ent = PRVM_G_FLOAT(OFS_PARM0);
+ ent = (int)PRVM_G_FLOAT(OFS_PARM0);
if(PRVM_PROG_TO_EDICT(ent)->priv.required->free)
PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!", PRVM_NAME, ent);
VM_SAFEPARMCOUNT(1, VM_remove);
ed = PRVM_G_EDICT(OFS_PARM0);
- if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts ) {
+ if( PRVM_NUM_FOR_EDICT(ed) <= prog->reserved_edicts )
+ {
Con_DPrint( "VM_remove: tried to remove the null entity or a reserved entity!\n" );
- } else if( ed->priv.required->free ) {
+ if (developer.integer >= 1)
+ PRVM_PrintState();
+ }
+ else if( ed->priv.required->free )
+ {
Con_DPrint( "VM_remove: tried to remove an already freed entity!\n" );
- } else {
- PRVM_ED_Free (ed);
+ if (developer.integer >= 1)
+ PRVM_PrintState();
}
+ else
+ PRVM_ED_Free (ed);
// if (ed == prog->edicts)
// PRVM_ERROR ("remove: tried to remove world");
// if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
f = PRVM_G_INT(OFS_PARM1);
s = PRVM_G_STRING(OFS_PARM2);
- if (!s || !s[0])
- {
- // return reserved edict 0 (could be used for whatever the prog wants)
- VM_RETURN_EDICT(prog->edicts);
- return;
- }
+ // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
+ // expects it to find all the monsters, so we must be careful to support
+ // searching for ""
+ if (!s)
+ s = "";
for (e++ ; e < prog->num_edicts ; e++)
{
continue;
t = PRVM_E_STRING(ed,f);
if (!t)
- continue;
+ t = "";
if (!strcmp(t,s))
{
VM_RETURN_EDICT(ed);
f = PRVM_G_INT(OFS_PARM0);
s = PRVM_G_STRING(OFS_PARM1);
- if (!s || !s[0])
- {
- VM_RETURN_EDICT(prog->edicts);
- return;
- }
+
+ // LordHavoc: apparently BloodMage does a find(world, weaponmodel, "") and
+ // expects it to find all the monsters, so we must be careful to support
+ // searching for ""
+ if (!s)
+ s = "";
ent = PRVM_NEXT_EDICT(prog->edicts);
for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
continue;
t = PRVM_E_STRING(ent,f);
if (!t)
- continue;
+ t = "";
if (strcmp(t,s))
continue;
ed = PRVM_EDICT_NUM(e);
if (ed->priv.required->free)
continue;
+ if (!PRVM_E_FLOAT(ed,f))
+ continue;
if ((int)PRVM_E_FLOAT(ed,f) & s)
{
VM_RETURN_EDICT(ed);
prog->xfunction->builtinsprofile++;
if (ent->priv.required->free)
continue;
+ if (!PRVM_E_FLOAT(ent,f))
+ continue;
if (!((int)PRVM_E_FLOAT(ent,f) & s))
continue;
if(!sv.active)
{
- Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
+ VM_Warning("VM_changelevel: game is not server (%s)\n", PRVM_NAME);
return;
}
name = PRVM_G_STRING(OFS_PARM0);
value = PRVM_G_STRING(OFS_PARM1);
- flags = PRVM_G_FLOAT(OFS_PARM2);
+ flags = (int)PRVM_G_FLOAT(OFS_PARM2);
PRVM_G_FLOAT(OFS_RETURN) = 0;
if(flags > CVAR_MAXFLAGSVAL)
// check for overlap with a command
if (Cmd_Exists (name))
{
- Con_Printf("VM_registercvar: %s is a command\n", name);
+ VM_Warning("VM_registercvar: %s is a command\n", name);
return;
}
break;
if (filenum >= MAX_VMFILES)
{
- Con_Printf("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
return;
}
- mode = PRVM_G_FLOAT(OFS_PARM1);
+ mode = (int)PRVM_G_FLOAT(OFS_PARM1);
switch(mode)
{
case 0: // FILE_READ
modestring = "wb";
break;
default:
- Con_Printf("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_fopen: %s: no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
return;
}
filename = PRVM_G_STRING(OFS_PARM0);
if (VM_FILES[filenum] == NULL)
{
- if (developer.integer)
- Con_Printf("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ if (developer.integer >= 10)
+ VM_Warning("VM_fopen: %s: %s mode %s failed\n", PRVM_NAME, filename, modestring);
}
else
{
- if (developer.integer)
- Con_Printf("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
PRVM_G_FLOAT(OFS_RETURN) = filenum;
+ if (developer.integer >= 10)
+ VM_Warning("VM_fopen: %s: %s mode %s opened as #%i\n", PRVM_NAME, filename, modestring, filenum);
}
}
VM_SAFEPARMCOUNT(1,VM_fclose);
- filenum = PRVM_G_FLOAT(OFS_PARM0);
+ filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (filenum < 0 || filenum >= MAX_VMFILES)
{
- Con_Printf("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
return;
}
if (VM_FILES[filenum] == NULL)
{
- Con_Printf("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
- if (developer.integer)
- Con_Printf("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
FS_Close(VM_FILES[filenum]);
VM_FILES[filenum] = NULL;
+ if (developer.integer >= 10)
+ VM_Warning("VM_fclose: %s: #%i closed\n", PRVM_NAME, filenum);
}
/*
VM_SAFEPARMCOUNT(1,VM_fgets);
- filenum = PRVM_G_FLOAT(OFS_PARM0);
+ filenum = (int)PRVM_G_FLOAT(OFS_PARM0);
if (filenum < 0 || filenum >= MAX_VMFILES)
{
- Con_Printf("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
return;
}
if (VM_FILES[filenum] == NULL)
{
- Con_Printf("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
end = 0;
if (c != '\n')
FS_UnGetc(VM_FILES[filenum], (unsigned char)c);
}
- if (developer.integer >= 3)
+ if (developer.integer >= 100)
Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
if (c >= 0 || end)
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(string);
VM_SAFEPARMCOUNT(2,VM_fputs);
- filenum = PRVM_G_FLOAT(OFS_PARM0);
+ filenum = (int)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);
+ VM_Warning("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);
+ VM_Warning("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
return;
}
VM_VarString(1, string, sizeof(string));
if ((stringlength = (int)strlen(string)))
FS_Write(VM_FILES[filenum], string, stringlength);
- if (developer.integer)
+ if (developer.integer >= 100)
Con_Printf("fputs: %s: %s\n", PRVM_NAME, string);
}
string = VM_GetTempString();
s = PRVM_G_STRING(OFS_PARM0);
- start = PRVM_G_FLOAT(OFS_PARM1);
- length = PRVM_G_FLOAT(OFS_PARM2);
+ start = (int)PRVM_G_FLOAT(OFS_PARM1);
+ length = (int)PRVM_G_FLOAT(OFS_PARM2);
if (!s)
s = "";
for (i = 0;i < start && *s;i++, s++);
VM_SAFEPARMCOUNT(2,VM_clcommand);
- i = PRVM_G_FLOAT(OFS_PARM0);
+ i = (int)PRVM_G_FLOAT(OFS_PARM0);
if (!sv.active || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
{
- Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
+ VM_Warning("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
return;
}
VM_SAFEPARMCOUNT(1,VM_argv);
- token_num = PRVM_G_FLOAT(OFS_PARM0);
+ token_num = (int)PRVM_G_FLOAT(OFS_PARM0);
if (token_num >= 0 && token_num < num_tokens)
PRVM_G_INT(OFS_RETURN) = PRVM_SetEngineString(tokens[token_num]);
OS_MAC - not supported
*/
-#ifdef _WIN32
+#ifdef WIN32
PRVM_G_FLOAT(OFS_RETURN) = 0;
-#elif defined _MAC
+#elif defined(MACOSX)
PRVM_G_FLOAT(OFS_RETURN) = 2;
#else
PRVM_G_FLOAT(OFS_RETURN) = 1;
data = PRVM_G_STRING(OFS_PARM1);
// parse the opening brace
- if (!COM_ParseToken(&data, false) || com_token[0] != '{' )
+ if (!COM_ParseTokenConsole(&data) || com_token[0] != '{' )
PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s", PRVM_NAME, data );
PRVM_ED_ParseEdict (data, ent);
// \ is a windows-ism (so it's naughty to use it, / works on all platforms)
if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
{
- Con_Printf("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
return;
}
VM_CheckEmptyString(pattern);
- caseinsens = PRVM_G_FLOAT(OFS_PARM1);
- quiet = PRVM_G_FLOAT(OFS_PARM2);
+ caseinsens = (int)PRVM_G_FLOAT(OFS_PARM1);
+ quiet = (int)PRVM_G_FLOAT(OFS_PARM2);
for(handle = 0; handle < MAX_VMSEARCHES; handle++)
if(!VM_SEARCHLIST[handle])
if(handle >= MAX_VMSEARCHES)
{
- Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
return;
}
int handle;
VM_SAFEPARMCOUNT(1, VM_search_end);
- handle = PRVM_G_FLOAT(OFS_PARM0);
+ handle = (int)PRVM_G_FLOAT(OFS_PARM0);
if(handle < 0 || handle >= MAX_VMSEARCHES)
{
- Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
if(VM_SEARCHLIST[handle] == NULL)
{
- Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
int handle;
VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
- handle = PRVM_G_FLOAT(OFS_PARM0);
+ handle = (int)PRVM_G_FLOAT(OFS_PARM0);
if(handle < 0 || handle >= MAX_VMSEARCHES)
{
- Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
if(VM_SEARCHLIST[handle] == NULL)
{
- Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
char *tmp;
VM_SAFEPARMCOUNT(2, VM_search_getfilename);
- handle = PRVM_G_FLOAT(OFS_PARM0);
- filenum = PRVM_G_FLOAT(OFS_PARM1);
+ handle = (int)PRVM_G_FLOAT(OFS_PARM0);
+ filenum = (int)PRVM_G_FLOAT(OFS_PARM1);
if(handle < 0 || handle >= MAX_VMSEARCHES)
{
- Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
return;
}
if(VM_SEARCHLIST[handle] == NULL)
{
- Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
return;
}
if(filenum < 0 || filenum >= VM_SEARCHLIST[handle]->numfilenames)
{
- Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
+ VM_Warning("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
return;
}
character = (char) PRVM_G_FLOAT(OFS_PARM1);
if(character == 0)
{
- Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(!scale[0] || !scale[1])
{
- Con_Printf("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
return;
}
string = PRVM_G_STRING(OFS_PARM1);
if(!string)
{
- Con_Printf("VM_drawstring: %s passed null string !\n",PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawstring: %s passed null string !\n",PRVM_NAME);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(!scale[0] || !scale[1])
{
- Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
PRVM_G_FLOAT(OFS_RETURN) = -3;
+ VM_Warning("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
return;
}
*/
void VM_drawpic(void)
{
- const char *pic;
+ const char *picname;
float *size, *pos, *rgb;
int flag;
VM_SAFEPARMCOUNT(6,VM_drawpic);
- pic = PRVM_G_STRING(OFS_PARM1);
+ picname = PRVM_G_STRING(OFS_PARM1);
- if(!pic)
+ if(!picname)
{
- Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
PRVM_G_FLOAT(OFS_RETURN) = -1;
+ VM_Warning("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
return;
}
- VM_CheckEmptyString (pic);
+ VM_CheckEmptyString (picname);
// is pic cached ? no function yet for that
if(!1)
{
- Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic);
PRVM_G_FLOAT(OFS_RETURN) = -4;
+ VM_Warning("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, picname);
return;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(pos[2] || size[2])
Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
- DrawQ_Pic(pos[0], pos[1], pic, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), 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;
}
if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
{
- Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
PRVM_G_FLOAT(OFS_RETURN) = -2;
+ VM_Warning("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
return;
}
if(pos[2] || size[2])
Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && size[2]) ? 's' : 0,((pos[2] && size[2]) ? "pos and size" : (pos[2] ? "pos" : "size")));
- DrawQ_Pic(pos[0], pos[1], 0, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
+ DrawQ_Pic(pos[0], pos[1], NULL, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
PRVM_G_FLOAT(OFS_RETURN) = 1;
}
char *tmp;
VM_SAFEPARMCOUNT(1, VM_keynumtostring);
- keynum = PRVM_G_FLOAT(OFS_PARM0);
+ keynum = (int)PRVM_G_FLOAT(OFS_PARM0);
tmp = VM_GetTempString();
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( name );
- CL_CloseVideo( CL_GetVideo( name ) );
+ CL_CloseVideo( CL_GetVideoByName( name ) );
}
/*
state = (clvideostate_t)((int)PRVM_G_FLOAT( OFS_PARM1 ));
- video = CL_GetVideo( name );
+ video = CL_GetVideoByName( name );
if( video && state > CLVIDEO_UNUSED && state < CLVIDEO_STATECOUNT )
CL_SetVideoState( video, state );
}
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( name );
- video = CL_GetVideo( name );
+ video = CL_GetVideoByName( name );
if( video )
PRVM_G_FLOAT( OFS_RETURN ) = (int)video->state;
else
name = PRVM_G_STRING( OFS_PARM0 );
VM_CheckEmptyString( name );
- video = CL_GetVideo( name );
+ video = CL_GetVideoByName( name );
if( video )
CL_RestartVideo( video );
}
c2 = PRVM_G_VECTOR(OFS_PARM2);
rgb = PRVM_G_VECTOR(OFS_PARM3);
alpha = PRVM_G_FLOAT(OFS_PARM4);
- flags = PRVM_G_FLOAT(OFS_PARM5);
+ flags = (int)PRVM_G_FLOAT(OFS_PARM5);
DrawQ_Line(width, c1[0], c1[1], c2[0], c2[1], rgb[0], rgb[1], rgb[2], alpha, flags);
}
void VM_InitPolygons (void)
{
vm_polygons_pool = Mem_AllocPool("VMPOLY", 0, NULL);
- vm_polygons = Mem_Alloc(vm_polygons_pool, VM_DEFPOLYNUM*sizeof(vm_polygon_t));
+ vm_polygons = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, VM_DEFPOLYNUM*sizeof(vm_polygon_t));
memset(vm_polygons, 0, VM_DEFPOLYNUM*sizeof(vm_polygon_t));
vm_polygons_num = VM_DEFPOLYNUM;
- vm_polygonbegin = vm_drawpolygons_num = 0;
+ vm_drawpolygons_num = 0;
+ vm_polygonbegin = false;
vm_polygons_initialized = true;
}
-void VM_DrawPolygonCallback (const entity_render_t *ent, int surfacenumber, const rtlight_t *rtlight)
+void VM_DrawPolygonCallback (const entity_render_t *ent, const rtlight_t *rtlight, int numsurfaces, int *surfacelist)
{
- const vm_polygon_t *p = &vm_polygons[surfacenumber];
- int flags = p->flags & 0x0f;
+ int surfacelistindex;
+ // LordHavoc: FIXME: this is stupid code
+ for (surfacelistindex = 0;surfacelistindex < numsurfaces;surfacelistindex++)
+ {
+ const vm_polygon_t *p = &vm_polygons[surfacelist[surfacelistindex]];
+ int flags = p->flags & 0x0f;
- if(flags == DRAWFLAG_ADDITIVE)
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
- else if(flags == DRAWFLAG_MODULATE)
- GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
- else if(flags == DRAWFLAG_2XMODULATE)
- GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
- else
- GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ if(flags == DRAWFLAG_ADDITIVE)
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE);
+ else if(flags == DRAWFLAG_MODULATE)
+ GL_BlendFunc(GL_DST_COLOR, GL_ZERO);
+ else if(flags == DRAWFLAG_2XMODULATE)
+ GL_BlendFunc(GL_DST_COLOR,GL_SRC_COLOR);
+ else
+ GL_BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- R_Mesh_TexBind(0, R_GetTexture(p->tex));
+ R_Mesh_TexBind(0, R_GetTexture(p->tex));
- //[515]: is speed is max ?
- if(p->flags & VM_POLYGON_FLLINES) //[515]: lines
- {
- qglLineWidth(p->data[13]);
- qglBegin(GL_LINE_LOOP);
- qglTexCoord1f (p->data[12]);
- qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]);
- qglVertex3f (p->data[0] , p->data[1], p->data[2]);
+ CHECKGLERROR
+ //[515]: is speed is max ?
+ if(p->flags & VM_POLYGON_FLLINES) //[515]: lines
+ {
+ qglLineWidth(p->data[13]);CHECKGLERROR
+ qglBegin(GL_LINE_LOOP);
+ qglTexCoord1f (p->data[12]);
+ qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]);
+ qglVertex3f (p->data[0] , p->data[1], p->data[2]);
- qglTexCoord1f (p->data[14]);
- qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]);
- qglVertex3f (p->data[3] , p->data[4], p->data[5]);
+ qglTexCoord1f (p->data[14]);
+ qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]);
+ qglVertex3f (p->data[3] , p->data[4], p->data[5]);
- if(p->flags & VM_POLYGON_FL3V)
- {
- qglTexCoord1f (p->data[16]);
+ if(p->flags & VM_POLYGON_FL3V)
+ {
+ qglTexCoord1f (p->data[16]);
+ qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]);
+ qglVertex3f (p->data[6] , p->data[7], p->data[8]);
+
+ if(p->flags & VM_POLYGON_FL4V)
+ {
+ qglTexCoord1f (p->data[18]);
+ qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]);
+ qglVertex3f (p->data[9] , p->data[10], p->data[11]);
+ }
+ }
+ qglEnd();
+ CHECKGLERROR
+ }
+ else
+ {
+ qglBegin(GL_POLYGON);
+ qglTexCoord2f (p->data[12], p->data[13]);
+ qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]);
+ qglVertex3f (p->data[0] , p->data[1], p->data[2]);
+
+ qglTexCoord2f (p->data[14], p->data[15]);
+ qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]);
+ qglVertex3f (p->data[3] , p->data[4], p->data[5]);
+
+ qglTexCoord2f (p->data[16], p->data[17]);
qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]);
qglVertex3f (p->data[6] , p->data[7], p->data[8]);
if(p->flags & VM_POLYGON_FL4V)
{
- qglTexCoord1f (p->data[18]);
+ qglTexCoord2f (p->data[18], p->data[19]);
qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]);
qglVertex3f (p->data[9] , p->data[10], p->data[11]);
}
- }
- qglEnd();
- }
- else
- {
- qglBegin(GL_POLYGON);
- qglTexCoord2f (p->data[12], p->data[13]);
- qglColor4f (p->data[20], p->data[21], p->data[22], p->data[23]);
- qglVertex3f (p->data[0] , p->data[1], p->data[2]);
-
- qglTexCoord2f (p->data[14], p->data[15]);
- qglColor4f (p->data[24], p->data[25], p->data[26], p->data[27]);
- qglVertex3f (p->data[3] , p->data[4], p->data[5]);
-
- qglTexCoord2f (p->data[16], p->data[17]);
- qglColor4f (p->data[28], p->data[29], p->data[30], p->data[31]);
- qglVertex3f (p->data[6] , p->data[7], p->data[8]);
-
- if(p->flags & VM_POLYGON_FL4V)
- {
- qglTexCoord2f (p->data[18], p->data[19]);
- qglColor4f (p->data[32], p->data[33], p->data[34], p->data[35]);
- qglVertex3f (p->data[9] , p->data[10], p->data[11]);
- }
- qglEnd();
+ qglEnd();
+ CHECKGLERROR
+ }
}
}
VM_InitPolygons();
if(vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonBegin: called twice without VM_R_PolygonEnd after first\n");
+ VM_Warning("VM_R_PolygonBegin: called twice without VM_R_PolygonEnd after first\n");
return;
}
if(vm_drawpolygons_num >= vm_polygons_num)
{
- p = Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t));
+ p = (vm_polygon_t *)Mem_Alloc(vm_polygons_pool, 2 * vm_polygons_num * sizeof(vm_polygon_t));
memset(p, 0, 2 * vm_polygons_num * sizeof(vm_polygon_t));
memcpy(p, vm_polygons, vm_polygons_num * sizeof(vm_polygon_t));
Mem_Free(vm_polygons);
p = &vm_polygons[vm_drawpolygons_num];
picname = PRVM_G_STRING(OFS_PARM0);
if(picname[0])
- p->tex = Draw_CachePic(picname, false)->tex;
+ p->tex = Draw_CachePic(picname, true)->tex;
else
p->tex = r_texture_notexture;
p->flags = (unsigned char)PRVM_G_FLOAT(OFS_PARM1);
if(!vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonVertex: VM_R_PolygonBegin wasn't called\n");
+ VM_Warning("VM_R_PolygonVertex: VM_R_PolygonBegin wasn't called\n");
return;
}
coords = PRVM_G_VECTOR(OFS_PARM0);
p = &vm_polygons[vm_drawpolygons_num];
if(vm_current_vertices > 4)
{
- Con_Printf("VM_R_PolygonVertex: may have 4 vertices max\n");
+ VM_Warning("VM_R_PolygonVertex: may have 4 vertices max\n");
return;
}
{
if(!vm_polygonbegin)
{
- Con_Printf("VM_R_PolygonEnd: VM_R_PolygonBegin wasn't called\n");
+ VM_Warning("VM_R_PolygonEnd: VM_R_PolygonBegin wasn't called\n");
return;
}
+ vm_polygonbegin = false;
if(vm_current_vertices > 2 || (vm_current_vertices >= 2 && vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FLLINES))
{
if(vm_polygons[vm_drawpolygons_num].flags & VM_POLYGON_FL2D) //[515]: don't use qcpolygons memory if 2D
vm_drawpolygons_num++;
}
else
- Con_Printf("VM_R_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices);
- vm_polygonbegin = false;
+ VM_Warning("VM_R_PolygonEnd: %i vertices isn't a good choice\n", vm_current_vertices);
}
void VM_AddPolygonsToMeshQueue (void)
if(!vm_drawpolygons_num)
return;
for(i = 0;i < vm_drawpolygons_num;i++)
- R_MeshQueue_Add(VM_DrawPolygonCallback, NULL, i, NULL);
+ VM_DrawPolygonCallback(NULL, NULL, i, NULL);
vm_drawpolygons_num = 0;
}
altstr = PRVM_G_STRING( OFS_PARM0 );
//VM_CheckEmptyString( altstr );
- count = PRVM_G_FLOAT( OFS_PARM1 );
+ count = (int)PRVM_G_FLOAT( OFS_PARM1 );
count = count * 2 + 1;
for( pos = altstr ; *pos && count ; pos++ )
altstr = PRVM_G_STRING( OFS_PARM0 );
//VM_CheckEmptyString( altstr );
- num = PRVM_G_FLOAT( OFS_PARM1 );
+ num = (int)PRVM_G_FLOAT( OFS_PARM1 );
str = PRVM_G_STRING( OFS_PARM2 );
//VM_CheckEmptyString( str );
char *out;
in = instr = PRVM_G_STRING( OFS_PARM0 );
- num = PRVM_G_FLOAT( OFS_PARM1 );
+ num = (int)PRVM_G_FLOAT( OFS_PARM1 );
set = setstr = PRVM_G_STRING( OFS_PARM2 );
out = outstr = VM_GetTempString();
for(i=0;i<MAX_QCSTR_BUFFERS;i++)
if(!qcstringbuffers[i])
{
- qcstringbuffers[i] = malloc(sizeof(qcstrbuffer_t));
+ qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
return i;
}
{
for(i=0;i<b->num_strings;i++)
if(b->strings[i])
- free(b->strings[i]);
+ Z_Free(b->strings[i]);
num_qcstringbuffers--;
}
- free(qcstringbuffers[index]);
+ Z_Free(qcstringbuffers[index]);
qcstringbuffers[index] = NULL;
}
}
BufStr_ClearBuffer((int)PRVM_G_FLOAT(OFS_PARM0));
else
{
- Con_Printf("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_del: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
}
if(!b)
{
PRVM_G_FLOAT(OFS_RETURN) = -1;
- Con_Printf("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_getsize: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
else
b1 = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b1)
{
- Con_Printf("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_copy: invalid source buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- i = PRVM_G_FLOAT(OFS_PARM1);
+ i = (int)PRVM_G_FLOAT(OFS_PARM1);
if(i == (int)PRVM_G_FLOAT(OFS_PARM0))
{
- Con_Printf("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
+ VM_Warning("VM_buf_copy: source == destination (%i) in %s\n", i, PRVM_NAME);
return;
}
b2 = BUFSTR_BUFFER(i);
if(!b2)
{
- Con_Printf("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+ VM_Warning("VM_buf_copy: invalid destination buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
return;
}
BufStr_ClearBuffer(i);
- qcstringbuffers[i] = malloc(sizeof(qcstrbuffer_t));
+ qcstringbuffers[i] = (qcstrbuffer_t *)Z_Malloc(sizeof(qcstrbuffer_t));
memset(qcstringbuffers[i], 0, sizeof(qcstrbuffer_t));
b2->num_strings = b1->num_strings;
for(i=0;i<b1->num_strings;i++)
if(b1->strings[i] && b1->strings[i][0])
{
- b2->strings[i] = malloc(strlen(b1->strings[i])+1);
+ b2->strings[i] = (char *)Z_Malloc(strlen(b1->strings[i])+1);
if(!b2->strings[i])
{
- Con_Printf("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
+ VM_Warning("VM_buf_copy: not enough memory for buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM1), PRVM_NAME);
break;
}
strcpy(b2->strings[i], b1->strings[i]);
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_sort: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
if(b->num_strings <= 0)
{
- Con_Printf("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_sort: tried to sort empty buffer %i in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- buf_sortpower = PRVM_G_FLOAT(OFS_PARM1);
+ buf_sortpower = (int)PRVM_G_FLOAT(OFS_PARM1);
if(buf_sortpower <= 0)
buf_sortpower = 99999999;
break;
else
{
- free(b->strings[i]);
+ Z_Free(b->strings[i]);
--b->num_strings;
b->strings[i] = NULL;
}
PRVM_G_INT(OFS_RETURN) = 0;
if(!b)
{
- Con_Printf("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_buf_implode: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
if(!b->num_strings)
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_bufstr_get: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_get: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
PRVM_G_INT(OFS_RETURN) = 0;
VM_SAFEPARMCOUNT(3, VM_bufstr_set);
- bufindex = PRVM_G_FLOAT(OFS_PARM0);
+ bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
b = BUFSTR_BUFFER(bufindex);
if(!b)
{
- Con_Printf("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_set: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
return;
}
- strindex = PRVM_G_FLOAT(OFS_PARM1);
+ strindex = (int)PRVM_G_FLOAT(OFS_PARM1);
if(strindex < 0 || strindex > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_set: invalid string index %i used in %s\n", strindex, PRVM_NAME);
return;
}
news = PRVM_G_STRING(OFS_PARM2);
if(!news)
{
- Con_Printf("VM_bufstr_set: null string used in %s\n", PRVM_NAME);
+ VM_Warning("VM_bufstr_set: null string used in %s\n", PRVM_NAME);
return;
}
if(b->strings[strindex])
- free(b->strings[strindex]);
- b->strings[strindex] = malloc(strlen(news)+1);
+ Z_Free(b->strings[strindex]);
+ b->strings[strindex] = (char *)Z_Malloc(strlen(news)+1);
strcpy(b->strings[strindex], news);
}
VM_SAFEPARMCOUNT(3, VM_bufstr_add);
- bufindex = PRVM_G_FLOAT(OFS_PARM0);
+ bufindex = (int)PRVM_G_FLOAT(OFS_PARM0);
b = BUFSTR_BUFFER(bufindex);
PRVM_G_FLOAT(OFS_RETURN) = -1;
if(!b)
{
- Con_Printf("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: invalid buffer %i used in %s\n", bufindex, PRVM_NAME);
return;
}
string = PRVM_G_STRING(OFS_PARM1);
if(!string)
{
- Con_Printf("VM_bufstr_add: null string used in %s\n", PRVM_NAME);
+ VM_Warning("VM_bufstr_add: null string used in %s\n", PRVM_NAME);
return;
}
- order = PRVM_G_FLOAT(OFS_PARM2);
+ order = (int)PRVM_G_FLOAT(OFS_PARM2);
if(order)
strindex = b->num_strings;
else
strindex = BufStr_FindFreeString(b);
if(strindex < 0)
{
- Con_Printf("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
return;
}
}
{
if(b->num_strings == MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
+ VM_Warning("VM_bufstr_add: buffer %i has no free string slots in %s\n", bufindex, PRVM_NAME);
return;
}
b->strings[b->num_strings] = NULL;
b->num_strings++;
}
if(b->strings[strindex])
- free(b->strings[strindex]);
- b->strings[strindex] = malloc(strlen(string)+1);
+ Z_Free(b->strings[strindex]);
+ b->strings[strindex] = (char *)Z_Malloc(strlen(string)+1);
strcpy(b->strings[strindex], string);
PRVM_G_FLOAT(OFS_RETURN) = strindex;
}
b = BUFSTR_BUFFER((int)PRVM_G_FLOAT(OFS_PARM0));
if(!b)
{
- Con_Printf("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
+ VM_Warning("VM_bufstr_free: invalid buffer %i used in %s\n", (int)PRVM_G_FLOAT(OFS_PARM0), PRVM_NAME);
return;
}
- i = PRVM_G_FLOAT(OFS_PARM1);
+ i = (int)PRVM_G_FLOAT(OFS_PARM1);
if(i < 0 || i > MAX_QCSTR_STRINGS)
{
- Con_Printf("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
+ VM_Warning("VM_bufstr_free: invalid string index %i used in %s\n", i, PRVM_NAME);
return;
}
if(b->strings[i])
- free(b->strings[i]);
+ Z_Free(b->strings[i]);
b->strings[i] = NULL;
if(i+1 == b->num_strings)
--b->num_strings;