e9d9afe6067afeade4747df5b1cf5864f4280731
[xonotic/darkplaces.git] / prvm_cmds.c
1 // AK
2 // Basically every vm builtin cmd should be in here.
3 // All 3 builtin and extension lists can be found here
4 // cause large (I think they will) parts are from pr_cmds the same copyright like in pr_cmds
5 // also applies here
6
7
8 /*
9 ============================================================================
10 common cmd list:
11 =================
12
13                 checkextension(string)
14                 error(...[string])
15                 objerror(...[string)
16                 print(...[strings])
17                 bprint(...[string])
18                 sprint(float clientnum,...[string])
19                 centerprint(...[string])
20 vector  normalize(vector)
21 float   vlen(vector)
22 float   vectoyaw(vector)
23 vector  vectoangles(vector)
24 float   random()
25                 cmd(string)
26                 float cvar (string)
27                 cvar_set (string,string)
28                 dprint(...[string])
29 string  ftos(float)
30 float   fabs(float)
31 string  vtos(vector)
32 string  etos(entity)
33 float   stof(...[string])
34 entity  spawn()
35                 remove(entity e)
36 entity  find(entity start, .string field, string match)
37
38 entity  findfloat(entity start, .float field, float match)
39 entity  findentity(entity start, .entity field, entity match)
40
41 entity  findchain(.string field, string match)
42
43 entity  findchainfloat(.string field, float match)
44 entity  findchainentity(.string field, entity match)
45   
46 string  precache_file(string)
47 string  precache_sound (string sample)
48                 coredump()
49                 traceon()
50                 traceoff()
51                 eprint(entity e)
52 float   rint(float)
53 float   floor(float)
54 float   ceil(float)
55 entity  nextent(entity)
56 float   sin(float)
57 float   cos(float)
58 float   sqrt(float)
59 vector  randomvec()
60 float   registercvar (string name, string value, float flags)
61 float   min(float a, float b, ...[float])
62 float   max(float a, float b, ...[float])
63 float   bound(float min, float value, float max)
64 float   pow(float a, float b)
65                 copyentity(entity src, entity dst)
66 float   fopen(string filename, float mode)
67                 fclose(float fhandle)
68 string  fgets(float fhandle)
69                 fputs(float fhandle, string s)
70 float   strlen(string s)
71 string  strcat(string,string,...[string])
72 string  substring(string s, float start, float length)
73 vector  stov(string s)
74 string  strzone(string s)
75                 strunzone(string s)
76 float   tokenize(string s)
77 string  argv(float n)
78 float   isserver()
79 float   clientcount()
80 float   clientstate()
81                 clientcommand(float client, string s) (for client and menu)
82                 changelevel(string map)
83                 localsound(string sample)
84 vector  getmousepos()
85 float   gettime()
86                 loadfromdata(string data)
87                 loadfromfile(string file)
88 float   mod(float val, float m)
89 const string    str_cvar (string)
90                 crash()
91                 stackdump()
92                 
93 float   search_begin(string pattern, float caseinsensitive, float quiet)
94 void    search_end(float handle)
95 float   search_getsize(float handle)
96 string  search_getfilename(float handle, float num)
97
98 string  chr(float ascii)
99
100 float   itof(intt ent)
101 intt    ftoi(float num)
102                 
103 perhaps only : Menu : WriteMsg 
104 ===============================
105
106                 WriteByte(float data, float dest, float desto)
107                 WriteChar(float data, float dest, float desto)
108                 WriteShort(float data, float dest, float desto)
109                 WriteLong(float data, float dest, float desto)
110                 WriteAngle(float data, float dest, float desto)
111                 WriteCoord(float data, float dest, float desto)
112                 WriteString(string data, float dest, float desto)
113                 WriteEntity(entity data, float dest, float desto)
114                 
115 Client & Menu : draw functions 
116 ===============================
117
118 float   iscachedpic(string pic)
119 string  precache_pic(string pic) 
120                 freepic(string s)
121 float   drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
122 float   drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
123 float   drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
124 float   drawfill(vector position, vector size, vector rgb, float alpha, float flag)
125                 drawsetcliparea(float x, float y, float width, float height)
126                 drawresetcliparea()
127 vector  getimagesize(string pic)
128                 
129
130 ==============================================================================
131 menu cmd list:
132 ===============
133
134                 setkeydest(float dest)
135 float   getkeydest()
136                 setmousetarget(float target)
137 float   getmousetarget(void)
138
139                 callfunction(...,string function_name)
140                 writetofile(float fhandle, entity ent)
141 float   isfunction(string function_name)
142 vector  getresolution(float number)
143 string  keynumtostring(float keynum)
144 string  findkeysforcommand(string command)
145 float   gethostcachevalue(float type)
146 string  gethostcachestring(float type, float hostnr)
147
148                 parseentitydata(entity ent, string data)
149 */
150
151 #include "quakedef.h"
152 #include "progdefs.h"
153 #include "progsvm.h"
154 #include "clprogdefs.h"
155 #include "mprogdefs.h"
156
157 //============================================================================
158 // nice helper macros
159
160 #ifndef VM_NOPARMCHECK
161 #define VM_SAFEPARMCOUNT(p,f)   if(prog->argc != p) PRVM_ERROR(#f " wrong parameter count (" #p " expected ) !\n")
162 #else
163 #define VM_SAFEPARMCOUNT(p,f)
164 #endif
165
166 #define VM_RETURN_EDICT(e)              (((int *)prog->globals)[OFS_RETURN] = PRVM_EDICT_TO_PROG(e))
167
168 #define VM_STRINGS_MEMPOOL              vm_strings_mempool[PRVM_GetProgNr()]
169
170 #define e10 0,0,0,0,0,0,0,0,0,0
171 #define e100 e10,e10,e10,e10,e10,e10,e10,e10,e10,e10
172 #define e1000 e100,e100,e100,e100,e100,e100,e100,e100,e100,e100
173
174 //============================================================================
175 // Common
176
177 // string zone mempool
178 mempool_t *vm_strings_mempool[PRVM_MAXPROGS];
179
180 // temp string handling
181 // LordHavoc: added this to semi-fix the problem of using many ftos calls in a print
182 #define VM_STRINGTEMP_BUFFERS 16
183 #define VM_STRINGTEMP_LENGTH 4096
184 static char vm_string_temp[VM_STRINGTEMP_BUFFERS][VM_STRINGTEMP_LENGTH];
185 static int vm_string_tempindex = 0;
186
187 // qc file handling
188 #define MAX_VMFILES             256
189 #define MAX_PRVMFILES   MAX_VMFILES * PRVM_MAXPROGS
190 #define VM_FILES ((qfile_t**)(vm_files + PRVM_GetProgNr() * MAX_VMFILES))
191
192 qfile_t *vm_files[MAX_PRVMFILES];
193
194 // qc fs search handling
195 #define MAX_VMSEARCHES 128
196 #define TOTAL_VMSEARCHES MAX_VMSEARCHES * PRVM_MAXPROGS
197 #define VM_SEARCHLIST ((fssearch_t**)(vm_fssearchlist + PRVM_GetProgNr() * MAX_VMSEARCHES))
198
199 fssearch_t *vm_fssearchlist[TOTAL_VMSEARCHES];
200
201 static char *VM_GetTempString(void)
202 {
203         char *s;
204         s = vm_string_temp[vm_string_tempindex];
205         vm_string_tempindex = (vm_string_tempindex + 1) % VM_STRINGTEMP_BUFFERS;
206         return s;
207 }
208
209 void VM_CheckEmptyString (char *s)
210 {
211         if (s[0] <= ' ')
212                 PRVM_ERROR ("%s: Bad string", PRVM_NAME);
213 }
214
215 //============================================================================
216 //BUILT-IN FUNCTIONS
217
218 void VM_VarString(int first, char *out, int outlength)
219 {
220         int i;
221         const char *s;
222         char *outend;
223
224         outend = out + outlength - 1;
225         for (i = first;i < prog->argc && out < outend;i++)
226         {
227                 s = PRVM_G_STRING((OFS_PARM0+i*3));
228                 while (out < outend && *s)
229                         *out++ = *s++;
230         }
231         *out++ = 0;
232 }
233
234 /*
235 =================
236 VM_checkextension
237
238 returns true if the extension is supported by the server
239
240 checkextension(extensionname)
241 =================
242 */
243
244 // kind of helper function
245 static qboolean checkextension(char *name)
246 {
247         int len;
248         char *e, *start;
249         len = strlen(name);
250
251         for (e = prog->extensionstring;*e;e++)
252         {
253                 while (*e == ' ')
254                         e++;
255                 if (!*e)
256                         break;
257                 start = e;
258                 while (*e && *e != ' ')
259                         e++;
260                 if (e - start == len)
261                         if (!strncasecmp(start, name, len))
262                         {
263                                 return true;
264                         }
265         }
266         return false;
267 }
268
269 void VM_checkextension (void)
270 {
271         VM_SAFEPARMCOUNT(1,VM_checkextension);
272
273         PRVM_G_FLOAT(OFS_RETURN) = checkextension(PRVM_G_STRING(OFS_PARM0));
274 }
275
276 /*
277 =================
278 VM_error
279
280 This is a TERMINAL error, which will kill off the entire prog.
281 Dumps self.
282
283 error(value)
284 =================
285 */
286 void VM_error (void)
287 {
288         prvm_edict_t    *ed;
289         char string[VM_STRINGTEMP_LENGTH];
290
291         VM_VarString(0, string, sizeof(string));
292         Con_Printf("======%S ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
293         if(prog->self)
294         {
295                 ed = PRVM_G_EDICT(prog->self->ofs);
296                 PRVM_ED_Print(ed);
297         }
298
299         PRVM_ERROR ("%s: Program error", PRVM_NAME);
300 }
301
302 /*
303 =================
304 VM_objerror
305
306 Dumps out self, then an error message.  The program is aborted and self is
307 removed, but the level can continue.
308
309 objerror(value)
310 =================
311 */
312 void VM_objerror (void)
313 {
314         prvm_edict_t    *ed;
315         char string[VM_STRINGTEMP_LENGTH];
316
317         VM_VarString(0, string, sizeof(string));
318         Con_Printf("======%s OBJECT ERROR in %s:\n%s\n", PRVM_NAME, PRVM_GetString(prog->xfunction->s_name), string);
319         if(prog->self)
320         {
321                 ed = PRVM_G_EDICT (prog->self->ofs);
322                 PRVM_ED_Print(ed);
323
324                 PRVM_ED_Free (ed);
325         }
326         else
327                 // objerror has to display the object fields -> else call
328                 PRVM_ERROR ("VM_objecterror: self not defined !\n");
329 }
330
331 /*
332 =================
333 VM_print (actually used only by client and menu)
334
335 print to console
336
337 print(string)
338 =================
339 */
340 void VM_print (void)
341 {
342         char string[VM_STRINGTEMP_LENGTH];
343
344         VM_VarString(0, string, sizeof(string));
345         Con_Print(string);
346 }
347
348 /*
349 =================
350 VM_bprint
351
352 broadcast print to everyone on server
353
354 bprint(...[string])
355 =================
356 */
357 void VM_bprint (void)
358 {
359         char string[VM_STRINGTEMP_LENGTH];
360
361         if(!sv.active)
362         {
363                 Con_Printf("VM_bprint: game is not server(%s) !\n", PRVM_NAME);
364                 return;
365         }
366
367         VM_VarString(0, string, sizeof(string));
368         SV_BroadcastPrint(string);
369 }
370
371 /*
372 =================
373 VM_sprint (menu & client but only if server.active == true)
374
375 single print to a specific client
376
377 sprint(float clientnum,...[string])
378 =================
379 */
380 void VM_sprint (void)
381 {
382         client_t        *client;
383         int                     clientnum;
384         char string[VM_STRINGTEMP_LENGTH];
385
386         //find client for this entity
387         clientnum = PRVM_G_FLOAT(OFS_PARM0);
388         if (!sv.active  || clientnum < 0 || clientnum >= svs.maxclients || !svs.clients[clientnum].active)
389         {
390                 Con_Printf("VM_sprint: %s: invalid client or server is not active !\n", PRVM_NAME);
391                 return;
392         }
393         
394         client = svs.clients + clientnum;
395         VM_VarString(1, string, sizeof(string));
396         MSG_WriteChar(&client->message,svc_print);
397         MSG_WriteString(&client->message, string);
398 }
399
400 /*
401 =================
402 VM_centerprint
403
404 single print to the screen
405
406 centerprint(clientent, value)
407 =================
408 */
409 void VM_centerprint (void)
410 {
411         char string[VM_STRINGTEMP_LENGTH];
412
413         VM_VarString(0, string, sizeof(string));
414         SCR_CenterPrint(string);
415 }
416
417 /*
418 =================
419 VM_normalize
420
421 vector normalize(vector)
422 =================
423 */
424 void VM_normalize (void)
425 {
426         float   *value1;
427         vec3_t  newvalue;
428         float   new;
429
430         VM_SAFEPARMCOUNT(1,VM_normalize);
431
432         value1 = PRVM_G_VECTOR(OFS_PARM0);
433
434         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
435         new = sqrt(new);
436
437         if (new == 0)
438                 newvalue[0] = newvalue[1] = newvalue[2] = 0;
439         else
440         {
441                 new = 1/new;
442                 newvalue[0] = value1[0] * new;
443                 newvalue[1] = value1[1] * new;
444                 newvalue[2] = value1[2] * new;
445         }
446
447         VectorCopy (newvalue, PRVM_G_VECTOR(OFS_RETURN));
448 }
449
450 /*
451 =================
452 VM_vlen
453
454 scalar vlen(vector)
455 =================
456 */
457 void VM_vlen (void)
458 {
459         float   *value1;
460         float   new;
461
462         VM_SAFEPARMCOUNT(1,VM_vlen);
463
464         value1 = PRVM_G_VECTOR(OFS_PARM0);
465
466         new = value1[0] * value1[0] + value1[1] * value1[1] + value1[2]*value1[2];
467         new = sqrt(new);
468
469         PRVM_G_FLOAT(OFS_RETURN) = new;
470 }
471
472 /*
473 =================
474 VM_vectoyaw
475
476 float vectoyaw(vector)
477 =================
478 */
479 void VM_vectoyaw (void)
480 {
481         float   *value1;
482         float   yaw;
483
484         VM_SAFEPARMCOUNT(1,VM_vectoyaw);
485
486         value1 = PRVM_G_VECTOR(OFS_PARM0);
487
488         if (value1[1] == 0 && value1[0] == 0)
489                 yaw = 0;
490         else
491         {
492                 yaw = (int) (atan2(value1[1], value1[0]) * 180 / M_PI);
493                 if (yaw < 0)
494                         yaw += 360;
495         }
496
497         PRVM_G_FLOAT(OFS_RETURN) = yaw;
498 }
499
500
501 /*
502 =================
503 VM_vectoangles
504
505 vector vectoangles(vector)
506 =================
507 */
508 void VM_vectoangles (void)
509 {
510         float   *value1;
511         float   forward;
512         float   yaw, pitch;
513
514         VM_SAFEPARMCOUNT(1,VM_vectoangles);
515
516         value1 = PRVM_G_VECTOR(OFS_PARM0);
517
518         if (value1[1] == 0 && value1[0] == 0)
519         {
520                 yaw = 0;
521                 if (value1[2] > 0)
522                         pitch = 90;
523                 else
524                         pitch = 270;
525         }
526         else
527         {
528                 // LordHavoc: optimized a bit
529                 if (value1[0])
530                 {
531                         yaw = (atan2(value1[1], value1[0]) * 180 / M_PI);
532                         if (yaw < 0)
533                                 yaw += 360;
534                 }
535                 else if (value1[1] > 0)
536                         yaw = 90;
537                 else
538                         yaw = 270;
539
540                 forward = sqrt(value1[0]*value1[0] + value1[1]*value1[1]);
541                 pitch = (int) (atan2(value1[2], forward) * 180 / M_PI);
542                 if (pitch < 0)
543                         pitch += 360;
544         }
545
546         PRVM_G_FLOAT(OFS_RETURN+0) = pitch;
547         PRVM_G_FLOAT(OFS_RETURN+1) = yaw;
548         PRVM_G_FLOAT(OFS_RETURN+2) = 0;
549 }
550
551 /*
552 =================
553 VM_random
554
555 Returns a number from 0<= num < 1
556
557 float random()
558 =================
559 */
560 void VM_random (void)
561 {
562         VM_SAFEPARMCOUNT(0,VM_random);
563
564         PRVM_G_FLOAT(OFS_RETURN) = lhrandom(0, 1);
565 }
566
567 /*
568 =================
569 PF_sound
570
571 Each entity can have eight independant sound sources, like voice,
572 weapon, feet, etc.
573
574 Channel 0 is an auto-allocate channel, the others override anything
575 already running on that entity/channel pair.
576
577 An attenuation of 0 will play full volume everywhere in the level.
578 Larger attenuations will drop off.
579
580 =================
581 */
582 /*
583 void PF_sound (void)
584 {
585         char            *sample;
586         int                     channel;
587         edict_t         *entity;
588         int             volume;
589         float attenuation;
590
591         entity = G_EDICT(OFS_PARM0);
592         channel = G_FLOAT(OFS_PARM1);
593         sample = G_STRING(OFS_PARM2);
594         volume = G_FLOAT(OFS_PARM3) * 255;
595         attenuation = G_FLOAT(OFS_PARM4);
596
597         if (volume < 0 || volume > 255)
598                 Host_Error ("SV_StartSound: volume = %i", volume);
599
600         if (attenuation < 0 || attenuation > 4)
601                 Host_Error ("SV_StartSound: attenuation = %f", attenuation);
602
603         if (channel < 0 || channel > 7)
604                 Host_Error ("SV_StartSound: channel = %i", channel);
605
606         SV_StartSound (entity, channel, sample, volume, attenuation);
607 }
608 */
609
610 /*
611 =========
612 VM_localsound
613
614 localsound(string sample)
615 =========
616 */
617 void VM_localsound(void)
618 {
619         char *s;
620         
621         VM_SAFEPARMCOUNT(1,VM_localsound);
622
623         s = PRVM_G_STRING(OFS_PARM0);
624
625         if(!S_LocalSound (s))
626         {
627                 Con_Printf("VM_localsound: Failed to play %s for %s !\n", s, PRVM_NAME);
628                 PRVM_G_FLOAT(OFS_RETURN) = -4;
629                 return;
630         }               
631
632         PRVM_G_FLOAT(OFS_RETURN) = 1;
633 }
634
635 /*
636 =================
637 VM_break
638
639 break()
640 =================
641 */
642 void VM_break (void)
643 {
644         PRVM_ERROR ("%s: break statement", PRVM_NAME);
645 }
646
647 //============================================================================
648
649 /*
650 =================
651 VM_localcmd
652
653 Sends text over to the client's execution buffer
654
655 [localcmd (string) or]
656 cmd (string)
657 =================
658 */
659 void VM_localcmd (void)
660 {
661         VM_SAFEPARMCOUNT(1,VM_localcmd);
662
663         Cbuf_AddText(PRVM_G_STRING(OFS_PARM0));
664 }
665
666 /*
667 =================
668 VM_cvar
669
670 float cvar (string)
671 =================
672 */
673 void VM_cvar (void)
674 {
675         VM_SAFEPARMCOUNT(1,VM_cvar);
676
677         PRVM_G_FLOAT(OFS_RETURN) = Cvar_VariableValue(PRVM_G_STRING(OFS_PARM0));
678 }
679
680 /*
681 =================
682 VM_str_cvar
683
684 const string    str_cvar (string)
685 =================
686 */
687 void VM_str_cvar(void) 
688 {
689         char *out, *name;
690         const char *cvar_string;
691         VM_SAFEPARMCOUNT(1,VM_str_cvar);
692
693         name = PRVM_G_STRING(OFS_PARM0);
694
695         if(!name)
696                 PRVM_ERROR("VM_str_cvar: %s: null string\n", PRVM_NAME);
697
698         VM_CheckEmptyString(name);
699
700         out = VM_GetTempString(); 
701
702         cvar_string = Cvar_VariableString(name);
703         
704         strcpy(out, cvar_string);
705
706         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out);
707 }
708
709 /*
710 =================
711 VM_cvar_set
712
713 void cvar_set (string,string)
714 =================
715 */
716 void VM_cvar_set (void)
717 {
718         VM_SAFEPARMCOUNT(2,VM_cvar_set);
719
720         Cvar_Set(PRVM_G_STRING(OFS_PARM0), PRVM_G_STRING(OFS_PARM1));
721 }
722
723 /*
724 =========
725 VM_dprint
726
727 dprint(...[string])
728 =========
729 */
730 void VM_dprint (void)
731 {
732         char string[VM_STRINGTEMP_LENGTH];
733         if (developer.integer)
734         {
735                 VM_VarString(0, string, sizeof(string));
736                 Con_Printf("%s: %s", PRVM_NAME, string);
737         }
738 }
739
740 /*
741 =========
742 VM_ftos
743
744 string  ftos(float)
745 =========
746 */
747
748 void VM_ftos (void)
749 {
750         float v;
751         char *s;
752
753         VM_SAFEPARMCOUNT(1, VM_ftos);
754
755         v = PRVM_G_FLOAT(OFS_PARM0);
756
757         s = VM_GetTempString();
758         if ((float)((int)v) == v)
759                 sprintf(s, "%i", (int)v);
760         else
761                 sprintf(s, "%f", v);
762         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
763 }
764
765 /*
766 =========
767 VM_fabs
768
769 float   fabs(float)
770 =========
771 */
772
773 void VM_fabs (void)
774 {
775         float   v;
776
777         VM_SAFEPARMCOUNT(1,VM_fabs);
778
779         v = PRVM_G_FLOAT(OFS_PARM0);
780         PRVM_G_FLOAT(OFS_RETURN) = fabs(v);
781 }
782
783 /*
784 =========
785 VM_vtos
786
787 string  vtos(vector)
788 =========
789 */
790
791 void VM_vtos (void)
792 {
793         char *s;
794
795         VM_SAFEPARMCOUNT(1,VM_vtos);
796
797         s = VM_GetTempString();
798         sprintf (s, "'%5.1f %5.1f %5.1f'", PRVM_G_VECTOR(OFS_PARM0)[0], PRVM_G_VECTOR(OFS_PARM0)[1], PRVM_G_VECTOR(OFS_PARM0)[2]);
799         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
800 }
801
802 /*
803 =========
804 VM_etos
805
806 string  etos(entity)
807 =========
808 */
809
810 void VM_etos (void)
811 {
812         char *s;
813
814         VM_SAFEPARMCOUNT(1, VM_etos);
815
816         s = VM_GetTempString();
817         sprintf (s, "entity %i", PRVM_G_EDICTNUM(OFS_PARM0));
818         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
819 }
820
821 /*
822 =========
823 VM_stof
824
825 float stof(...[string])
826 =========
827 */
828 void VM_stof(void)
829 {
830         char string[VM_STRINGTEMP_LENGTH];
831         VM_VarString(0, string, sizeof(string));
832         PRVM_G_FLOAT(OFS_RETURN) = atof(string);
833 }
834
835 /*
836 ========================
837 VM_itof
838
839 float itof(intt ent)
840 ========================
841 */
842 void VM_itof(void)
843 {
844         VM_SAFEPARMCOUNT(1, VM_itof);
845         PRVM_G_FLOAT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
846 }
847
848 /*
849 ========================
850 VM_itoe
851
852 intt ftoi(float num)
853 ========================
854 */
855 void VM_ftoi(void)
856 {
857         int ent;
858         VM_SAFEPARMCOUNT(1, VM_ftoi);
859
860         ent = PRVM_G_FLOAT(OFS_PARM0);
861         if(PRVM_PROG_TO_EDICT(ent)->p.e->free)
862                 PRVM_ERROR ("VM_ftoe: %s tried to access a freed entity (entity %i)!\n", PRVM_NAME, ent);
863     
864         PRVM_G_INT(OFS_RETURN) = ent;
865 }
866
867 /*
868 =========
869 VM_spawn
870
871 entity spawn()
872 =========
873 */
874
875 void VM_spawn (void)
876 {
877         prvm_edict_t    *ed;
878         prog->xfunction->builtinsprofile += 20;
879         ed = PRVM_ED_Alloc();
880         VM_RETURN_EDICT(ed);
881 }
882
883 /*
884 =========
885 VM_remove
886
887 remove(entity e)
888 =========
889 */
890
891 void VM_remove (void)
892 {
893         prvm_edict_t    *ed;
894         prog->xfunction->builtinsprofile += 20;
895
896         VM_SAFEPARMCOUNT(1, VM_remove);
897
898         ed = PRVM_G_EDICT(OFS_PARM0);
899 //      if (ed == prog->edicts)
900 //              PRVM_ERROR ("remove: tried to remove world\n");
901 //      if (PRVM_NUM_FOR_EDICT(ed) <= sv.maxclients)
902 //              Host_Error("remove: tried to remove a client\n");
903         PRVM_ED_Free (ed);
904 }
905
906 /*
907 =========
908 VM_find
909
910 entity  find(entity start, .string field, string match)
911 =========
912 */
913
914 void VM_find (void)
915 {
916         int             e;
917         int             f;
918         char    *s, *t;
919         prvm_edict_t    *ed;
920
921         VM_SAFEPARMCOUNT(3,VM_find);
922
923         e = PRVM_G_EDICTNUM(OFS_PARM0);
924         f = PRVM_G_INT(OFS_PARM1);
925         s = PRVM_G_STRING(OFS_PARM2);
926
927         if (!s || !s[0])
928         {
929                 // return reserved edict 0 (could be used for whatever the prog wants)
930                 VM_RETURN_EDICT(prog->edicts);
931                 return;
932         }
933
934         for (e++ ; e < prog->num_edicts ; e++)
935         {
936                 prog->xfunction->builtinsprofile++;
937                 ed = PRVM_EDICT_NUM(e);
938                 if (ed->p.e->free)
939                         continue;
940                 t = PRVM_E_STRING(ed,f);
941                 if (!t)
942                         continue;
943                 if (!strcmp(t,s))
944                 {
945                         VM_RETURN_EDICT(ed);
946                         return;
947                 }
948         }
949
950         VM_RETURN_EDICT(prog->edicts);
951 }
952
953 /*
954 =========
955 VM_findfloat
956
957   entity        findfloat(entity start, .float field, float match)
958   entity        findentity(entity start, .entity field, entity match)
959 =========
960 */
961 // LordHavoc: added this for searching float, int, and entity reference fields
962 void VM_findfloat (void)
963 {
964         int             e;
965         int             f;
966         float   s;
967         prvm_edict_t    *ed;
968
969         VM_SAFEPARMCOUNT(3,VM_findfloat);
970
971         e = PRVM_G_EDICTNUM(OFS_PARM0);
972         f = PRVM_G_INT(OFS_PARM1);
973         s = PRVM_G_FLOAT(OFS_PARM2);
974
975         for (e++ ; e < prog->num_edicts ; e++)
976         {
977                 prog->xfunction->builtinsprofile++;
978                 ed = PRVM_EDICT_NUM(e);
979                 if (ed->p.e->free)
980                         continue;
981                 if (PRVM_E_FLOAT(ed,f) == s)
982                 {
983                         VM_RETURN_EDICT(ed);
984                         return;
985                 }
986         }
987
988         VM_RETURN_EDICT(prog->edicts);
989 }
990
991 /*
992 =========
993 VM_findchain
994
995 entity  findchain(.string field, string match)
996 =========
997 */
998 int PRVM_ED_FindFieldOffset(const char *field);
999 // chained search for strings in entity fields
1000 // entity(.string field, string match) findchain = #402;
1001 void VM_findchain (void)
1002 {
1003         int             i;
1004         int             f;
1005         int             chain_of;
1006         char    *s, *t;
1007         prvm_edict_t    *ent, *chain;
1008
1009         VM_SAFEPARMCOUNT(2,VM_findchain);
1010
1011         // is the same like !(prog->flag & PRVM_FE_CHAIN) - even if the operator precedence is another
1012         if(!prog->flag & PRVM_FE_CHAIN)
1013                 PRVM_ERROR("VM_findchain: %s doesnt have a chain field !\n", PRVM_NAME);
1014
1015         chain_of = PRVM_ED_FindFieldOffset ("chain");
1016
1017         chain = prog->edicts;
1018
1019         f = PRVM_G_INT(OFS_PARM0);
1020         s = PRVM_G_STRING(OFS_PARM1);
1021         if (!s || !s[0])
1022         {
1023                 VM_RETURN_EDICT(prog->edicts);
1024                 return;
1025         }
1026
1027         ent = PRVM_NEXT_EDICT(prog->edicts);
1028         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1029         {
1030                 prog->xfunction->builtinsprofile++;
1031                 if (ent->p.e->free)
1032                         continue;
1033                 t = PRVM_E_STRING(ent,f);
1034                 if (!t)
1035                         continue;
1036                 if (strcmp(t,s))
1037                         continue;
1038
1039                 PRVM_E_INT(ent,chain_of) = PRVM_NUM_FOR_EDICT(chain);
1040                 chain = ent;
1041         }
1042
1043         VM_RETURN_EDICT(chain);
1044 }
1045
1046 /*
1047 =========
1048 VM_findchainfloat
1049
1050 entity  findchainfloat(.string field, float match)
1051 entity  findchainentity(.string field, entity match)
1052 =========
1053 */
1054 // LordHavoc: chained search for float, int, and entity reference fields
1055 // entity(.string field, float match) findchainfloat = #403;
1056 void VM_findchainfloat (void)
1057 {
1058         int             i;
1059         int             f;
1060         int             chain_of;
1061         float   s;
1062         prvm_edict_t    *ent, *chain;
1063
1064         VM_SAFEPARMCOUNT(2, VM_findchainfloat);
1065
1066         if(!prog->flag & PRVM_FE_CHAIN)
1067                 PRVM_ERROR("VM_findchainfloat: %s doesnt have a chain field !\n", PRVM_NAME);
1068
1069         chain_of = PRVM_ED_FindFieldOffset ("chain");
1070
1071         chain = (prvm_edict_t *)prog->edicts;
1072
1073         f = PRVM_G_INT(OFS_PARM0);
1074         s = PRVM_G_FLOAT(OFS_PARM1);
1075
1076         ent = PRVM_NEXT_EDICT(prog->edicts);
1077         for (i = 1;i < prog->num_edicts;i++, ent = PRVM_NEXT_EDICT(ent))
1078         {
1079                 prog->xfunction->builtinsprofile++;
1080                 if (ent->p.e->free)
1081                         continue;
1082                 if (PRVM_E_FLOAT(ent,f) != s)
1083                         continue;
1084
1085                 PRVM_E_INT(ent,chain_of) = PRVM_EDICT_TO_PROG(chain);
1086                 chain = ent;
1087         }
1088
1089         VM_RETURN_EDICT(chain);
1090 }
1091
1092 /*
1093 =========
1094 VM_precache_file
1095
1096 string  precache_file(string)
1097 =========
1098 */
1099 void VM_precache_file (void)
1100 {       // precache_file is only used to copy files with qcc, it does nothing
1101         VM_SAFEPARMCOUNT(1,VM_precache_file);
1102
1103         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1104 }
1105
1106 /*
1107 =========
1108 VM_preache_error
1109
1110 used instead of the other VM_precache_* functions in the builtin list
1111 =========
1112 */
1113
1114 void VM_precache_error (void)
1115 {
1116         PRVM_ERROR ("PF_Precache_*: Precache can only be done in spawn functions");
1117 }
1118
1119 /*
1120 =========
1121 VM_precache_sound
1122
1123 string  precache_sound (string sample)
1124 =========
1125 */
1126 void VM_precache_sound (void)
1127 {
1128         char    *s;
1129
1130         VM_SAFEPARMCOUNT(1, VM_precache_sound);
1131
1132         s = PRVM_G_STRING(OFS_PARM0);
1133         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
1134         VM_CheckEmptyString (s);
1135
1136         if(!S_PrecacheSound (s,true, true))
1137                 Con_Printf("VM_precache_sound: Failed to load %s for %s\n", s, PRVM_NAME);
1138 }
1139
1140 /*
1141 =========
1142 VM_coredump
1143
1144 coredump()
1145 =========
1146 */
1147 void VM_coredump (void)
1148 {
1149         VM_SAFEPARMCOUNT(0,VM_coredump);
1150
1151         Cbuf_AddText("prvm_edicts ");
1152         Cbuf_AddText(PRVM_NAME);
1153         Cbuf_AddText("\n");
1154 }
1155
1156 /*
1157 =========
1158 VM_stackdump
1159
1160 stackdump()
1161 =========
1162 */
1163 void PRVM_StackTrace(void);
1164 void VM_stackdump (void)
1165 {
1166         VM_SAFEPARMCOUNT(0, VM_stackdump);
1167
1168         PRVM_StackTrace();
1169 }
1170
1171 /*
1172 =========
1173 VM_crash
1174
1175 crash()
1176 =========
1177 */
1178
1179 void VM_crash(void) 
1180 {
1181         VM_SAFEPARMCOUNT(0, VM_crash);
1182
1183         PRVM_ERROR("Crash called by %s\n",PRVM_NAME);
1184 }
1185
1186 /*
1187 =========
1188 VM_traceon
1189
1190 traceon()
1191 =========
1192 */
1193 void VM_traceon (void)
1194 {
1195         VM_SAFEPARMCOUNT(0,VM_traceon);
1196
1197         prog->trace = true;
1198 }
1199
1200 /*
1201 =========
1202 VM_traceoff
1203
1204 traceoff()
1205 =========
1206 */
1207 void VM_traceoff (void)
1208 {
1209         VM_SAFEPARMCOUNT(0,VM_traceoff);
1210
1211         prog->trace = false;
1212 }
1213
1214 /*
1215 =========
1216 VM_eprint
1217
1218 eprint(entity e)
1219 =========
1220 */
1221 void VM_eprint (void)
1222 {
1223         VM_SAFEPARMCOUNT(1,VM_eprint);
1224
1225         PRVM_ED_PrintNum (PRVM_G_EDICTNUM(OFS_PARM0));
1226 }
1227
1228 /*
1229 =========
1230 VM_rint
1231
1232 float   rint(float)
1233 =========
1234 */
1235 void VM_rint (void)
1236 {
1237         float   f;
1238
1239         VM_SAFEPARMCOUNT(1,VM_rint);
1240
1241         f = PRVM_G_FLOAT(OFS_PARM0);
1242         if (f > 0)
1243                 PRVM_G_FLOAT(OFS_RETURN) = (int)(f + 0.5);
1244         else
1245                 PRVM_G_FLOAT(OFS_RETURN) = (int)(f - 0.5);
1246 }
1247
1248 /*
1249 =========
1250 VM_floor
1251
1252 float   floor(float)
1253 =========
1254 */
1255 void VM_floor (void)
1256 {
1257         VM_SAFEPARMCOUNT(1,VM_floor);
1258
1259         PRVM_G_FLOAT(OFS_RETURN) = floor(PRVM_G_FLOAT(OFS_PARM0));
1260 }
1261
1262 /*
1263 =========
1264 VM_ceil
1265
1266 float   ceil(float)
1267 =========
1268 */
1269 void VM_ceil (void)
1270 {
1271         VM_SAFEPARMCOUNT(1,VM_ceil);
1272
1273         PRVM_G_FLOAT(OFS_RETURN) = ceil(PRVM_G_FLOAT(OFS_PARM0));
1274 }
1275
1276
1277 /*
1278 =============
1279 VM_nextent
1280
1281 entity  nextent(entity)
1282 =============
1283 */
1284 void VM_nextent (void)
1285 {
1286         int             i;
1287         prvm_edict_t    *ent;
1288
1289         i = PRVM_G_EDICTNUM(OFS_PARM0);
1290         while (1)
1291         {
1292                 prog->xfunction->builtinsprofile++;
1293                 i++;
1294                 if (i == prog->num_edicts)
1295                 {
1296                         VM_RETURN_EDICT(prog->edicts);
1297                         return;
1298                 }
1299                 ent = PRVM_EDICT_NUM(i);
1300                 if (!ent->p.e->free)
1301                 {
1302                         VM_RETURN_EDICT(ent);
1303                         return;
1304                 }
1305         }
1306 }
1307
1308 /*
1309 ===============================================================================
1310 MESSAGE WRITING
1311
1312 used only for client and menu
1313 severs uses VM_SV_...
1314
1315 Write*(* data, float type, float to)
1316
1317 ===============================================================================
1318 */
1319
1320 #define MSG_BROADCAST   0               // unreliable to all
1321 #define MSG_ONE                 1               // reliable to one (msg_entity)
1322 #define MSG_ALL                 2               // reliable to all
1323 #define MSG_INIT                3               // write to the init string
1324
1325 sizebuf_t *VM_WriteDest (void)
1326 {
1327         int             dest;
1328         int             destclient;
1329
1330         if(!sv.active)
1331                 PRVM_ERROR("VM_WriteDest: game is not server (%s)\n", PRVM_NAME);
1332
1333         dest = G_FLOAT(OFS_PARM1);
1334         switch (dest)
1335         {
1336         case MSG_BROADCAST:
1337                 return &sv.datagram;
1338
1339         case MSG_ONE:
1340                 destclient = (int) PRVM_G_FLOAT(OFS_PARM2);
1341                 if (destclient < 0 || destclient >= svs.maxclients || !svs.clients[destclient].active)
1342                         PRVM_ERROR("VM_clientcommand: %s: invalid client !\n", PRVM_NAME);
1343
1344                 return &svs.clients[destclient].message;
1345
1346         case MSG_ALL:
1347                 return &sv.reliable_datagram;
1348
1349         case MSG_INIT:
1350                 return &sv.signon;
1351
1352         default:
1353                 PRVM_ERROR ("WriteDest: bad destination");
1354                 break;
1355         }
1356
1357         return NULL;
1358 }
1359
1360 void VM_WriteByte (void)
1361 {
1362         MSG_WriteByte (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
1363 }
1364
1365 void VM_WriteChar (void)
1366 {
1367         MSG_WriteChar (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
1368 }
1369
1370 void VM_WriteShort (void)
1371 {
1372         MSG_WriteShort (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
1373 }
1374
1375 void VM_WriteLong (void)
1376 {
1377         MSG_WriteLong (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0));
1378 }
1379
1380 void VM_WriteAngle (void)
1381 {
1382         MSG_WriteAngle (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
1383 }
1384
1385 void VM_WriteCoord (void)
1386 {
1387         MSG_WriteCoord (VM_WriteDest(), PRVM_G_FLOAT(OFS_PARM0), sv.protocol);
1388 }
1389
1390 void VM_WriteString (void)
1391 {
1392         MSG_WriteString (VM_WriteDest(), PRVM_G_STRING(OFS_PARM0));
1393 }
1394
1395 void VM_WriteEntity (void)
1396 {
1397         MSG_WriteShort (VM_WriteDest(), PRVM_G_EDICTNUM(OFS_PARM0));
1398 }
1399
1400 //=============================================================================
1401
1402 /*
1403 ==============
1404 VM_changelevel
1405 server and menu
1406
1407 changelevel(string map)
1408 ==============
1409 */
1410 void VM_changelevel (void)
1411 {
1412         char    *s;
1413
1414         VM_SAFEPARMCOUNT(1, VM_changelevel);
1415
1416         if(!sv.active)
1417         {
1418                 Con_Printf("VM_changelevel: game is not server (%s)\n", PRVM_NAME); 
1419                 return;
1420         }
1421
1422 // make sure we don't issue two changelevels
1423         if (svs.changelevel_issued)
1424                 return;
1425         svs.changelevel_issued = true;
1426
1427         s = G_STRING(OFS_PARM0);
1428         Cbuf_AddText (va("changelevel %s\n",s));
1429 }
1430
1431 /*
1432 =========
1433 VM_sin
1434
1435 float   sin(float)
1436 =========
1437 */
1438 void VM_sin (void)
1439 {
1440         VM_SAFEPARMCOUNT(1,VM_sin);
1441         PRVM_G_FLOAT(OFS_RETURN) = sin(PRVM_G_FLOAT(OFS_PARM0));
1442 }
1443
1444 /*
1445 =========
1446 VM_cos
1447 float   cos(float)
1448 =========
1449 */
1450 void VM_cos (void)
1451 {
1452         VM_SAFEPARMCOUNT(1,VM_cos);
1453         PRVM_G_FLOAT(OFS_RETURN) = cos(PRVM_G_FLOAT(OFS_PARM0));
1454 }
1455
1456 /*
1457 =========
1458 VM_sqrt
1459
1460 float   sqrt(float)
1461 =========
1462 */
1463 void VM_sqrt (void)
1464 {
1465         VM_SAFEPARMCOUNT(1,VM_sqrt);
1466         PRVM_G_FLOAT(OFS_RETURN) = sqrt(PRVM_G_FLOAT(OFS_PARM0));
1467 }
1468
1469 /*
1470 =================
1471 VM_randomvec
1472
1473 Returns a vector of length < 1 and > 0
1474
1475 vector randomvec()
1476 =================
1477 */
1478 void VM_randomvec (void)
1479 {
1480         vec3_t          temp;
1481         //float         length;
1482
1483         VM_SAFEPARMCOUNT(0, VM_randomvec);
1484
1485         //// WTF ??
1486         do
1487         {
1488                 temp[0] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1489                 temp[1] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1490                 temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1491         }
1492         while (DotProduct(temp, temp) >= 1);
1493         VectorCopy (temp, PRVM_G_VECTOR(OFS_RETURN));
1494
1495         /*
1496         temp[0] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1497         temp[1] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1498         temp[2] = (rand()&32767) * (2.0 / 32767.0) - 1.0;
1499         // length returned always > 0
1500         length = (rand()&32766 + 1) * (1.0 / 32767.0) / VectorLength(temp);
1501         VectorScale(temp,length, temp);*/
1502         //VectorCopy(temp, PRVM_G_VECTOR(OFS_RETURN));
1503 }
1504
1505 //=============================================================================
1506
1507 /*
1508 =========
1509 VM_registercvar
1510
1511 float   registercvar (string name, string value, float flags)
1512 =========
1513 */
1514 void VM_registercvar (void)
1515 {
1516         char *name, *value;
1517         int     flags;
1518
1519         VM_SAFEPARMCOUNT(3,VM_registercvar);
1520
1521         name = PRVM_G_STRING(OFS_PARM0);
1522         value = PRVM_G_STRING(OFS_PARM1);
1523         flags = PRVM_G_FLOAT(OFS_PARM2);
1524         PRVM_G_FLOAT(OFS_RETURN) = 0;
1525
1526         if(flags > CVAR_MAXFLAGSVAL)
1527                 return;
1528
1529 // first check to see if it has already been defined
1530         if (Cvar_FindVar (name))
1531                 return;
1532
1533 // check for overlap with a command
1534         if (Cmd_Exists (name))
1535         {
1536                 Con_Printf("VM_registercvar: %s is a command\n", name);
1537                 return;
1538         }
1539
1540         Cvar_Get(name, value, flags);
1541
1542         PRVM_G_FLOAT(OFS_RETURN) = 1; // success
1543 }
1544
1545 /*
1546 =================
1547 VM_min
1548
1549 returns the minimum of two supplied floats
1550
1551 float min(float a, float b, ...[float])
1552 =================
1553 */
1554 void VM_min (void)
1555 {
1556         // LordHavoc: 3+ argument enhancement suggested by FrikaC
1557         if (prog->argc == 2)
1558                 PRVM_G_FLOAT(OFS_RETURN) = min(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1559         else if (prog->argc >= 3)
1560         {
1561                 int i;
1562                 float f = PRVM_G_FLOAT(OFS_PARM0);
1563                 for (i = 1;i < prog->argc;i++)
1564                         if (PRVM_G_FLOAT((OFS_PARM0+i*3)) < f)
1565                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1566                 PRVM_G_FLOAT(OFS_RETURN) = f;
1567         }
1568         else
1569                 PRVM_ERROR("VM_min: %s must supply at least 2 floats\n", PRVM_NAME);
1570 }
1571
1572 /*
1573 =================
1574 VM_max
1575
1576 returns the maximum of two supplied floats
1577
1578 float   max(float a, float b, ...[float])
1579 =================
1580 */
1581 void VM_max (void)
1582 {
1583         // LordHavoc: 3+ argument enhancement suggested by FrikaC
1584         if (prog->argc == 2)
1585                 PRVM_G_FLOAT(OFS_RETURN) = max(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1586         else if (prog->argc >= 3)
1587         {
1588                 int i;
1589                 float f = PRVM_G_FLOAT(OFS_PARM0);
1590                 for (i = 1;i < prog->argc;i++)
1591                         if (PRVM_G_FLOAT((OFS_PARM0+i*3)) > f)
1592                                 f = PRVM_G_FLOAT((OFS_PARM0+i*3));
1593                 G_FLOAT(OFS_RETURN) = f;
1594         }
1595         else
1596                 PRVM_ERROR("VM_max: %s must supply at least 2 floats\n", PRVM_NAME);
1597 }
1598
1599 /*
1600 =================
1601 VM_bound
1602
1603 returns number bounded by supplied range
1604
1605 float   bound(float min, float value, float max)
1606 =================
1607 */
1608 void VM_bound (void)
1609 {
1610         VM_SAFEPARMCOUNT(3,VM_bound);
1611         PRVM_G_FLOAT(OFS_RETURN) = bound(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1), PRVM_G_FLOAT(OFS_PARM2));
1612 }
1613
1614 /*
1615 =================
1616 VM_pow
1617
1618 returns a raised to power b
1619
1620 float   pow(float a, float b)
1621 =================
1622 */
1623 void VM_pow (void)
1624 {
1625         VM_SAFEPARMCOUNT(2,VM_pow);
1626         PRVM_G_FLOAT(OFS_RETURN) = pow(PRVM_G_FLOAT(OFS_PARM0), PRVM_G_FLOAT(OFS_PARM1));
1627 }
1628
1629 /*
1630 =================
1631 VM_copyentity
1632
1633 copies data from one entity to another
1634
1635 copyentity(entity src, entity dst)
1636 =================
1637 */
1638 void VM_copyentity (void)
1639 {
1640         prvm_edict_t *in, *out;
1641         VM_SAFEPARMCOUNT(2,VM_copyentity);
1642         in = PRVM_G_EDICT(OFS_PARM0);
1643         out = PRVM_G_EDICT(OFS_PARM1);
1644         memcpy(out->v, in->v, prog->progs->entityfields * 4);
1645 }
1646
1647 /*
1648 =================
1649 VM_setcolor
1650
1651 sets the color of a client and broadcasts the update to all connected clients
1652
1653 setcolor(clientent, value)
1654 =================
1655 */
1656 /*void PF_setcolor (void)
1657 {
1658         client_t *client;
1659         int entnum, i;
1660         eval_t *val;
1661
1662         entnum = G_EDICTNUM(OFS_PARM0);
1663         i = G_FLOAT(OFS_PARM1);
1664
1665         if (entnum < 1 || entnum > svs.maxclients || !svs.clients[entnum-1].active)
1666         {
1667                 Con_Print("tried to setcolor a non-client\n");
1668                 return;
1669         }
1670
1671         client = svs.clients + entnum-1;
1672         if ((val = GETEDICTFIELDVALUE(client->edict, eval_clientcolors)))
1673                 val->_float = i;
1674         client->colors = i;
1675         client->old_colors = i;
1676         client->edict->v->team = (i & 15) + 1;
1677
1678         MSG_WriteByte (&sv.reliable_datagram, svc_updatecolors);
1679         MSG_WriteByte (&sv.reliable_datagram, entnum - 1);
1680         MSG_WriteByte (&sv.reliable_datagram, i);
1681 }*/
1682
1683 void VM_Files_Init(void)
1684 {
1685         memset(VM_FILES, 0, sizeof(qfile_t*[MAX_VMFILES]));
1686 }
1687
1688 void VM_Files_CloseAll(void)
1689 {
1690         int i;
1691         for (i = 0;i < MAX_VMFILES;i++)
1692         {
1693                 if (VM_FILES[i])
1694                         FS_Close(VM_FILES[i]);
1695                 //VM_FILES[i] = NULL;
1696         }
1697         memset(VM_FILES,0,sizeof(qfile_t*[MAX_VMFILES])); // this should be faster (is it ?)
1698 }
1699
1700 /*
1701 =========
1702 VM_fopen
1703
1704 float   fopen(string filename, float mode)
1705 =========
1706 */
1707 // float(string filename, float mode) fopen = #110;
1708 // opens a file inside quake/gamedir/data/ (mode is FILE_READ, FILE_APPEND, or FILE_WRITE),
1709 // returns fhandle >= 0 if successful, or fhandle < 0 if unable to open file for any reason
1710 void VM_fopen(void)
1711 {
1712         int filenum, mode;
1713         char *modestring, *filename;
1714
1715         VM_SAFEPARMCOUNT(2,VM_fopen);
1716
1717         for (filenum = 0;filenum < MAX_VMFILES;filenum++)
1718                 if (VM_FILES[filenum] == NULL)
1719                         break;
1720         if (filenum >= MAX_VMFILES)
1721         {
1722                 Con_Printf("VM_fopen: %s ran out of file handles (%i)\n", PRVM_NAME, MAX_VMFILES);
1723                 PRVM_G_FLOAT(OFS_RETURN) = -2;
1724                 return;
1725         }
1726         mode = PRVM_G_FLOAT(OFS_PARM1);
1727         switch(mode)
1728         {
1729         case 0: // FILE_READ
1730                 modestring = "rb";
1731                 break;
1732         case 1: // FILE_APPEND
1733                 modestring = "ab";
1734                 break;
1735         case 2: // FILE_WRITE
1736                 modestring = "wb";
1737                 break;
1738         default:
1739                 Con_Printf("VM_fopen: %s no such mode %i (valid: 0 = read, 1 = append, 2 = write)\n", PRVM_NAME, mode);
1740                 PRVM_G_FLOAT(OFS_RETURN) = -3;
1741                 return;
1742         }
1743         filename = PRVM_G_STRING(OFS_PARM0);
1744         // .. is parent directory on many platforms
1745         // / is parent directory on Amiga
1746         // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea)
1747         // \ is a windows-ism (so it's naughty to use it, / works on all platforms)
1748         if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
1749         {
1750                 Con_Printf("VM_fopen: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
1751                 PRVM_G_FLOAT(OFS_RETURN) = -4;
1752                 return;
1753         }
1754         VM_FILES[filenum] = FS_Open(va("data/%s", filename), modestring, false);
1755         if (VM_FILES[filenum] == NULL && mode == 0)
1756                 VM_FILES[filenum] = FS_Open(va("%s", filename), modestring, false);
1757
1758         if (VM_FILES[filenum] == NULL)
1759                 PRVM_G_FLOAT(OFS_RETURN) = -1;
1760         else
1761                 PRVM_G_FLOAT(OFS_RETURN) = filenum;
1762 }
1763
1764 /*
1765 =========
1766 VM_fclose
1767
1768 fclose(float fhandle)
1769 =========
1770 */
1771 //void(float fhandle) fclose = #111; // closes a file
1772 void VM_fclose(void)
1773 {
1774         int filenum;
1775
1776         VM_SAFEPARMCOUNT(1,VM_fclose);
1777
1778         filenum = PRVM_G_FLOAT(OFS_PARM0);
1779         if (filenum < 0 || filenum >= MAX_VMFILES)
1780         {
1781                 Con_Printf("VM_fclose: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1782                 return;
1783         }
1784         if (VM_FILES[filenum] == NULL)
1785         {
1786                 Con_Printf("VM_fclose: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1787                 return;
1788         }
1789         FS_Close(VM_FILES[filenum]);
1790         VM_FILES[filenum] = NULL;
1791 }
1792
1793 /*
1794 =========
1795 VM_fgets
1796
1797 string  fgets(float fhandle)
1798 =========
1799 */
1800 //string(float fhandle) fgets = #112; // reads a line of text from the file and returns as a tempstring
1801 void VM_fgets(void)
1802 {
1803         int c, end;
1804         static char string[VM_STRINGTEMP_LENGTH];
1805         int filenum;
1806
1807         VM_SAFEPARMCOUNT(1,VM_fgets);
1808
1809         filenum = PRVM_G_FLOAT(OFS_PARM0);
1810         if (filenum < 0 || filenum >= MAX_VMFILES)
1811         {
1812                 Con_Printf("VM_fgets: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1813                 return;
1814         }
1815         if (VM_FILES[filenum] == NULL)
1816         {
1817                 Con_Printf("VM_fgets: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1818                 return;
1819         }
1820         end = 0;
1821         for (;;)
1822         {
1823                 c = FS_Getc(VM_FILES[filenum]);
1824                 if (c == '\r' || c == '\n' || c < 0)
1825                         break;
1826                 if (end < VM_STRINGTEMP_LENGTH - 1)
1827                         string[end++] = c;
1828         }
1829         string[end] = 0;
1830         // remove \n following \r
1831         if (c == '\r')
1832                 c = FS_Getc(VM_FILES[filenum]);
1833         if (developer.integer)
1834                 Con_Printf("fgets: %s: %s\n", PRVM_NAME, string);
1835         if (c >= 0 || end)
1836                 PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
1837         else
1838                 PRVM_G_INT(OFS_RETURN) = 0;
1839 }
1840
1841 /*
1842 =========
1843 VM_fputs
1844
1845 fputs(float fhandle, string s)
1846 =========
1847 */
1848 //void(float fhandle, string s) fputs = #113; // writes a line of text to the end of the file
1849 void VM_fputs(void)
1850 {
1851         int stringlength;
1852         char string[VM_STRINGTEMP_LENGTH];
1853         int filenum;
1854
1855         VM_SAFEPARMCOUNT(2,VM_fputs);
1856
1857         filenum = PRVM_G_FLOAT(OFS_PARM0);
1858         if (filenum < 0 || filenum >= MAX_VMFILES)
1859         {
1860                 Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
1861                 return;
1862         }
1863         if (VM_FILES[filenum] == NULL)
1864         {
1865                 Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
1866                 return;
1867         }
1868         VM_VarString(1, string, sizeof(string));
1869         if ((stringlength = strlen(string)))
1870                 FS_Write(VM_FILES[filenum], string, stringlength);
1871         if (developer.integer)
1872                 Con_Printf("fputs: %s: %s\n", PRVM_NAME, string);
1873 }
1874
1875 /*
1876 =========
1877 VM_strlen
1878
1879 float   strlen(string s)
1880 =========
1881 */
1882 //float(string s) strlen = #114; // returns how many characters are in a string
1883 void VM_strlen(void)
1884 {
1885         char *s;
1886
1887         VM_SAFEPARMCOUNT(1,VM_strlen);
1888
1889         s = PRVM_G_STRING(OFS_PARM0);
1890         if (s)
1891                 PRVM_G_FLOAT(OFS_RETURN) = strlen(s);
1892         else
1893                 PRVM_G_FLOAT(OFS_RETURN) = 0;
1894 }
1895
1896 /*
1897 =========
1898 VM_strcat
1899
1900 string strcat(string,string,...[string])
1901 =========
1902 */
1903 //string(string s1, string s2) strcat = #115;
1904 // concatenates two strings (for example "abc", "def" would return "abcdef")
1905 // and returns as a tempstring
1906 void VM_strcat(void)
1907 {
1908         char *s;
1909
1910         if(prog->argc < 1) 
1911                 PRVM_ERROR("VM_strcat wrong parameter count (min. 1 expected ) !\n");
1912         
1913         s = VM_GetTempString();
1914         VM_VarString(0, s, VM_STRINGTEMP_LENGTH);
1915         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(s);
1916 }
1917
1918 /*
1919 =========
1920 VM_substring
1921
1922 string  substring(string s, float start, float length)
1923 =========
1924 */
1925 // string(string s, float start, float length) substring = #116;
1926 // returns a section of a string as a tempstring
1927 void VM_substring(void)
1928 {
1929         int i, start, length;
1930         char *s, *string;
1931
1932         VM_SAFEPARMCOUNT(3,VM_substring);
1933
1934         string = VM_GetTempString();
1935         s = PRVM_G_STRING(OFS_PARM0);
1936         start = PRVM_G_FLOAT(OFS_PARM1);
1937         length = PRVM_G_FLOAT(OFS_PARM2);
1938         if (!s)
1939                 s = "";
1940         for (i = 0;i < start && *s;i++, s++);
1941         for (i = 0;i < VM_STRINGTEMP_LENGTH - 1 && *s && i < length;i++, s++)
1942                 string[i] = *s;
1943         string[i] = 0;
1944         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(string);
1945 }
1946
1947 /*
1948 =========
1949 VM_stov
1950
1951 vector  stov(string s)
1952 =========
1953 */
1954 //vector(string s) stov = #117; // returns vector value from a string
1955 void VM_stov(void)
1956 {
1957         char string[VM_STRINGTEMP_LENGTH];
1958
1959         VM_SAFEPARMCOUNT(1,VM_stov);
1960
1961         VM_VarString(0, string, sizeof(string));
1962         Math_atov(string, PRVM_G_VECTOR(OFS_RETURN));
1963 }
1964
1965 /*
1966 =========
1967 VM_strzone
1968
1969 string  strzone(string s)
1970 =========
1971 */
1972 //string(string s) strzone = #118; // makes a copy of a string into the string zone and returns it, this is often used to keep around a tempstring for longer periods of time (tempstrings are replaced often)
1973 void VM_strzone(void)
1974 {
1975         char *in, *out;
1976
1977         VM_SAFEPARMCOUNT(1,VM_strzone);
1978
1979         in = PRVM_G_STRING(OFS_PARM0);
1980         out = Mem_Alloc(VM_STRINGS_MEMPOOL, strlen(in) + 1);
1981         strcpy(out, in);
1982         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(out);
1983 }
1984
1985 /*
1986 =========
1987 VM_strunzone
1988
1989 strunzone(string s)
1990 =========
1991 */
1992 //void(string s) strunzone = #119; // removes a copy of a string from the string zone (you can not use that string again or it may crash!!!)
1993 void VM_strunzone(void)
1994 {
1995         char *str;
1996         VM_SAFEPARMCOUNT(1,VM_strunzone);
1997
1998         str = PRVM_G_STRING(OFS_PARM0);
1999         if( developer.integer && !Mem_IsAllocated( VM_STRINGS_MEMPOOL, str ) )
2000                 PRVM_ERROR( "VM_strunzone: Zone string already freed in %s!", PRVM_NAME );
2001         else
2002                 Mem_Free( str );
2003 }
2004
2005 /*
2006 =========
2007 VM_command (used by client and menu)
2008
2009 clientcommand(float client, string s) (for client and menu)
2010 =========
2011 */
2012 //void(entity e, string s) clientcommand = #440; // executes a command string as if it came from the specified client
2013 //this function originally written by KrimZon, made shorter by LordHavoc
2014 void VM_clcommand (void)
2015 {
2016         client_t *temp_client;
2017         int i;
2018
2019         VM_SAFEPARMCOUNT(2,VM_clcommand);
2020
2021         i = PRVM_G_FLOAT(OFS_PARM0);
2022         if (!sv.active  || i < 0 || i >= svs.maxclients || !svs.clients[i].active)
2023         {
2024                 Con_Printf("VM_clientcommand: %s: invalid client/server is not active !\n", PRVM_NAME);
2025                 return;
2026         }
2027
2028         temp_client = host_client;
2029         host_client = svs.clients + i;
2030         Cmd_ExecuteString (PRVM_G_STRING(OFS_PARM1), src_client);
2031         host_client = temp_client;
2032 }
2033
2034
2035 /*
2036 =========
2037 VM_tokenize
2038
2039 float tokenize(string s)
2040 =========
2041 */
2042 //float(string s) tokenize = #441;
2043 // takes apart a string into individal words (access them with argv), returns how many
2044 // this function originally written by KrimZon, made shorter by LordHavoc
2045 static char **tokens = NULL;
2046 static int    max_tokens, num_tokens = 0;
2047 void VM_tokenize (void)
2048 {
2049         const char *p;
2050         char *str;
2051
2052         VM_SAFEPARMCOUNT(1,VM_tokenize);
2053
2054         str = PRVM_G_STRING(OFS_PARM0);
2055
2056         if (tokens != NULL)
2057         {
2058                 int i;
2059                 for (i=0;i<num_tokens;i++)
2060                         Z_Free(tokens[i]);
2061                 Z_Free(tokens);
2062                 num_tokens = 0;
2063         }
2064
2065         tokens = Z_Malloc(strlen(str) * sizeof(char *));
2066         max_tokens = strlen(str);
2067
2068         for (p = str;COM_ParseToken(&p, false) && num_tokens < max_tokens;num_tokens++)
2069         {
2070                 tokens[num_tokens] = Z_Malloc(strlen(com_token) + 1);
2071                 strcpy(tokens[num_tokens], com_token);
2072         }
2073
2074         PRVM_G_FLOAT(OFS_RETURN) = num_tokens;
2075 }
2076
2077 /*
2078 =========
2079 VM_argv
2080
2081 string argv(float n)
2082 =========
2083 */
2084 //string(float n) argv = #442;
2085 // returns a word from the tokenized string (returns nothing for an invalid index)
2086 // this function originally written by KrimZon, made shorter by LordHavoc
2087 void VM_argv (void)
2088 {
2089         int token_num;
2090
2091         VM_SAFEPARMCOUNT(1,VM_argv);
2092
2093         token_num = PRVM_G_FLOAT(OFS_PARM0);
2094         if (token_num >= 0 && token_num < num_tokens)
2095                 PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tokens[token_num]);
2096         else
2097                 PRVM_G_INT(OFS_RETURN) = PRVM_SetString("");
2098 }
2099
2100 /*
2101 //void(entity e, entity tagentity, string tagname) setattachment = #443; // attachs e to a tag on tagentity (note: use "" to attach to entity origin/angles instead of a tag)
2102 void PF_setattachment (void)
2103 {
2104         edict_t *e = G_EDICT(OFS_PARM0);
2105         edict_t *tagentity = G_EDICT(OFS_PARM1);
2106         char *tagname = G_STRING(OFS_PARM2);
2107         eval_t *v;
2108         int i, modelindex;
2109         model_t *model;
2110
2111         if (tagentity == NULL)
2112                 tagentity = sv.edicts;
2113
2114         v = GETEDICTFIELDVALUE(e, eval_tag_entity);
2115         if (v)
2116                 v->edict = EDICT_TO_PROG(tagentity);
2117
2118         v = GETEDICTFIELDVALUE(e, eval_tag_index);
2119         if (v)
2120                 v->_float = 0;
2121         if (tagentity != NULL && tagentity != sv.edicts && tagname && tagname[0])
2122         {
2123                 modelindex = (int)tagentity->v->modelindex;
2124                 if (modelindex >= 0 && modelindex < MAX_MODELS)
2125                 {
2126                         model = sv.models[modelindex];
2127                         if (model->data_overridetagnamesforskin && (unsigned int)tagentity->v->skin < (unsigned int)model->numskins && model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames)
2128                                 for (i = 0;i < model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].num_overridetagnames;i++)
2129                                         if (!strcmp(tagname, model->data_overridetagnamesforskin[(unsigned int)tagentity->v->skin].data_overridetagnames[i].name))
2130                                                 v->_float = i + 1;
2131                         // FIXME: use a model function to get tag info (need to handle skeletal)
2132                         if (v->_float == 0 && model->alias.aliasnum_tags)
2133                                 for (i = 0;i < model->alias.aliasnum_tags;i++)
2134                                         if (!strcmp(tagname, model->alias.aliasdata_tags[i].name))
2135                                                 v->_float = i + 1;
2136                         if (v->_float == 0)
2137                                 Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i (model \"%s\") but could not find it\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity), model->name);
2138                 }
2139                 else
2140                         Con_DPrintf("setattachment(edict %i, edict %i, string \"%s\"): tried to find tag named \"%s\" on entity %i but it has no model\n", NUM_FOR_EDICT(e), NUM_FOR_EDICT(tagentity), tagname, tagname, NUM_FOR_EDICT(tagentity));
2141         }
2142 }*/
2143
2144 /*
2145 =========
2146 VM_isserver
2147
2148 float   isserver()
2149 =========
2150 */
2151 void VM_isserver(void)
2152 {
2153         VM_SAFEPARMCOUNT(0,VM_serverstate);
2154
2155         PRVM_G_FLOAT(OFS_RETURN) = sv.active;
2156 }
2157
2158 /*
2159 =========
2160 VM_clientcount
2161
2162 float   clientcount()
2163 =========
2164 */
2165 void VM_clientcount(void)
2166 {
2167         VM_SAFEPARMCOUNT(0,VM_clientcount);
2168
2169         PRVM_G_FLOAT(OFS_RETURN) = svs.maxclients;
2170 }
2171
2172 /*
2173 =========
2174 VM_clientstate
2175
2176 float   clientstate()
2177 =========
2178 */
2179 void VM_clientstate(void)
2180 {
2181         VM_SAFEPARMCOUNT(0,VM_clientstate);
2182
2183         PRVM_G_FLOAT(OFS_RETURN) = cls.state;
2184 }
2185
2186 /*
2187 =========
2188 VM_getostype
2189
2190 float   getostype(void)
2191 =========
2192 */ // not used at the moment -> not included in the common list
2193 void VM_getostype(void)
2194 {
2195         VM_SAFEPARMCOUNT(0,VM_getostype);
2196
2197         /*
2198         OS_WINDOWS
2199         OS_LINUX
2200         OS_MAC - not supported
2201         */
2202
2203 #ifdef _WIN32
2204         PRVM_G_FLOAT(OFS_RETURN) = 0;
2205 #elif defined _MAC
2206         PRVM_G_FLOAT(OFS_RETURN) = 2;
2207 #else
2208         PRVM_G_FLOAT(OFS_RETURN) = 1;
2209 #endif
2210 }
2211
2212 /*
2213 =========
2214 VM_getmousepos
2215
2216 vector  getmousepos()
2217 =========
2218 */
2219 void VM_getmousepos(void)
2220 {
2221
2222         VM_SAFEPARMCOUNT(0,VM_getmousepos);
2223         
2224         PRVM_G_VECTOR(OFS_RETURN)[0] = in_mouse_x;
2225         PRVM_G_VECTOR(OFS_RETURN)[1] = in_mouse_y;
2226         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
2227 }
2228
2229 /*
2230 =========
2231 VM_gettime
2232
2233 float   gettime(void)
2234 =========
2235 */
2236 void VM_gettime(void)
2237 {
2238         VM_SAFEPARMCOUNT(0,VM_gettime);
2239
2240         PRVM_G_FLOAT(OFS_RETURN) = (float) *prog->time;
2241 }
2242
2243 /*
2244 =========
2245 VM_loadfromdata
2246
2247 loadfromdata(string data)
2248 =========
2249 */
2250 void VM_loadfromdata(void)
2251 {
2252         VM_SAFEPARMCOUNT(1,VM_loadentsfromfile);
2253
2254         PRVM_ED_LoadFromFile(PRVM_G_STRING(OFS_PARM0));
2255 }
2256
2257 /*
2258 ========================
2259 VM_M_parseentitydata
2260
2261 parseentitydata(entity ent, string data)
2262 ========================
2263 */
2264 void VM_M_parseentitydata(void)
2265 {
2266         prvm_edict_t *ent;
2267         const char *data;
2268
2269         VM_SAFEPARMCOUNT(2, VM_parseentitydata);
2270     
2271     // get edict and test it
2272         ent = PRVM_G_EDICT(OFS_PARM0);
2273         if (ent->p.e->free)
2274                 PRVM_ERROR ("VM_parseentitydata: %s: Can only set already spawned entities (entity %i is free)!\n", PRVM_NAME, PRVM_NUM_FOR_EDICT(ent));
2275
2276         data = PRVM_G_STRING(OFS_PARM1);
2277
2278     // parse the opening brace
2279         if (!COM_ParseToken(&data, false) || com_token[0] != '{' )
2280                 PRVM_ERROR ("VM_parseentitydata: %s: Couldn't parse entity data:\n%s\n", PRVM_NAME, data );
2281
2282         PRVM_ED_ParseEdict (data, ent);
2283 }
2284
2285 /*
2286 =========
2287 VM_loadfromfile
2288
2289 loadfromfile(string file)
2290 =========
2291 */
2292 void VM_loadfromfile(void)
2293 {
2294         char *filename;
2295         qbyte *data;
2296         
2297         VM_SAFEPARMCOUNT(1,VM_loadfromfile);
2298         
2299         filename = PRVM_G_STRING(OFS_PARM0);
2300         // .. is parent directory on many platforms
2301         // / is parent directory on Amiga
2302         // : is root of drive on Amiga (also used as a directory separator on Mac, but / works there too, so that's a bad idea)
2303         // \ is a windows-ism (so it's naughty to use it, / works on all platforms)
2304         if ((filename[0] == '.' && filename[1] == '.') || filename[0] == '/' || strrchr(filename, ':') || strrchr(filename, '\\'))
2305         {
2306                 Con_Printf("VM_loadfromfile: %s dangerous or non-portable filename \"%s\" not allowed. (contains : or \\ or begins with .. or /)\n", PRVM_NAME, filename);
2307                 PRVM_G_FLOAT(OFS_RETURN) = -4;
2308                 return;
2309         }
2310
2311         // not conform with VM_fopen
2312         data = FS_LoadFile(filename, tempmempool, false);
2313         if (data == NULL)
2314                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2315         
2316         PRVM_ED_LoadFromFile(data);
2317
2318         if(data)
2319                 Mem_Free(data);
2320 }
2321
2322
2323 /*
2324 =========
2325 VM_modulo
2326
2327 float   mod(float val, float m)
2328 =========
2329 */
2330 void VM_modulo(void)
2331 {
2332         int val, m;
2333         VM_SAFEPARMCOUNT(2,VM_module);
2334
2335         val = (int) PRVM_G_FLOAT(OFS_PARM0);
2336         m       = (int) PRVM_G_FLOAT(OFS_PARM1);
2337
2338         PRVM_G_FLOAT(OFS_RETURN) = (float) (val % m);
2339 }
2340
2341 void VM_Search_Init(void)
2342 {
2343         memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
2344 }
2345
2346 void VM_Search_Reset(void)
2347 {
2348         int i;
2349         // reset the fssearch list
2350         for(i = 0; i < MAX_VMSEARCHES; i++)
2351                 if(VM_SEARCHLIST[i])
2352                         FS_FreeSearch(VM_SEARCHLIST[i]);
2353         memset(VM_SEARCHLIST,0,sizeof(fssearch_t*[MAX_VMSEARCHES]));
2354 }
2355
2356 /*
2357 =========
2358 VM_search_begin
2359
2360 float search_begin(string pattern, float caseinsensitive, float quiet)
2361 =========
2362 */
2363 void VM_search_begin(void)
2364 {
2365         int handle;
2366         char *pattern;
2367         int caseinsens, quiet;
2368
2369         VM_SAFEPARMCOUNT(3, VM_search_begin);
2370
2371         pattern = PRVM_G_STRING(OFS_PARM0);
2372
2373         VM_CheckEmptyString(pattern);
2374
2375         caseinsens = PRVM_G_FLOAT(OFS_PARM1);
2376         quiet = PRVM_G_FLOAT(OFS_PARM2);
2377         
2378         for(handle = 0; handle < MAX_VMSEARCHES; handle++)
2379                 if(!VM_SEARCHLIST[handle])
2380                         break;
2381
2382         if(handle >= MAX_VMSEARCHES)
2383         {
2384                 Con_Printf("VM_search_begin: %s ran out of search handles (%i)\n", PRVM_NAME, MAX_VMSEARCHES);
2385                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2386                 return;
2387         }
2388
2389         if(!(VM_SEARCHLIST[handle] = FS_Search(pattern,caseinsens, quiet)))
2390                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2391         else
2392                 PRVM_G_FLOAT(OFS_RETURN) = handle;
2393 }
2394
2395 /*
2396 =========
2397 VM_search_end
2398
2399 void    search_end(float handle)
2400 =========
2401 */
2402 void VM_search_end(void)
2403 {
2404         int handle;
2405         VM_SAFEPARMCOUNT(1, VM_search_end);
2406
2407         handle = PRVM_G_FLOAT(OFS_PARM0);
2408         
2409         if(handle < 0 || handle >= MAX_VMSEARCHES)
2410         {
2411                 Con_Printf("VM_search_end: invalid handle %i used in %s\n", handle, PRVM_NAME);
2412                 return;
2413         }
2414         if(VM_SEARCHLIST[handle] == NULL)
2415         {
2416                 Con_Printf("VM_search_end: no such handle %i in %s\n", handle, PRVM_NAME);
2417                 return;
2418         }
2419
2420         FS_FreeSearch(VM_SEARCHLIST[handle]);
2421         VM_SEARCHLIST[handle] = NULL;
2422 }
2423
2424 /*
2425 =========
2426 VM_search_getsize
2427
2428 float   search_getsize(float handle)
2429 =========
2430 */
2431 void VM_search_getsize(void)
2432 {
2433         int handle;
2434         VM_SAFEPARMCOUNT(1, VM_M_search_getsize);
2435
2436         handle = PRVM_G_FLOAT(OFS_PARM0);
2437
2438         if(handle < 0 || handle >= MAX_VMSEARCHES)
2439         {
2440                 Con_Printf("VM_search_getsize: invalid handle %i used in %s\n", handle, PRVM_NAME);
2441                 return;
2442         }
2443         if(VM_SEARCHLIST[handle] == NULL)
2444         {
2445                 Con_Printf("VM_search_getsize: no such handle %i in %s\n", handle, PRVM_NAME);
2446                 return;
2447         }
2448         
2449         PRVM_G_FLOAT(OFS_RETURN) = VM_SEARCHLIST[handle]->numfilenames;
2450 }
2451
2452 /*
2453 =========
2454 VM_search_getfilename
2455
2456 string  search_getfilename(float handle, float num)
2457 =========
2458 */
2459 void VM_search_getfilename(void)
2460 {
2461         int handle, filenum;
2462         char *tmp;
2463         VM_SAFEPARMCOUNT(2, VM_search_getfilename);
2464
2465         handle = PRVM_G_FLOAT(OFS_PARM0);
2466         filenum = PRVM_G_FLOAT(OFS_PARM1);
2467
2468         if(handle < 0 || handle >= MAX_VMSEARCHES)
2469         {
2470                 Con_Printf("VM_search_getfilename: invalid handle %i used in %s\n", handle, PRVM_NAME);
2471                 return;
2472         }
2473         if(VM_SEARCHLIST[handle] == NULL)
2474         {
2475                 Con_Printf("VM_search_getfilename: no such handle %i in %s\n", handle, PRVM_NAME);
2476                 return;
2477         }
2478         if(filenum < 0 || filenum >= VM_SEARCHLIST[handle]->numfilenames)
2479         {
2480                 Con_Printf("VM_search_getfilename: invalid filenum %i in %s\n", filenum, PRVM_NAME);
2481                 return;
2482         }
2483         
2484         tmp = VM_GetTempString();
2485         strcpy(tmp, VM_SEARCHLIST[handle]->filenames[filenum]);
2486
2487         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
2488 }
2489
2490 /*
2491 =========
2492 VM_chr
2493
2494 string  chr(float ascii)
2495 =========
2496 */
2497 void VM_chr(void)
2498 {
2499         char *tmp;
2500         VM_SAFEPARMCOUNT(1, VM_chr);
2501
2502         tmp = VM_GetTempString();
2503         tmp[0] = (unsigned char) PRVM_G_FLOAT(OFS_PARM0);
2504         tmp[1] = 0;
2505
2506         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
2507 }
2508
2509 //=============================================================================
2510 // Draw builtins (client & menu)
2511
2512 /*
2513 =========
2514 VM_iscachedpic
2515
2516 float   iscachedpic(string pic)
2517 =========
2518 */
2519 void VM_iscachedpic(void)
2520 {
2521         VM_SAFEPARMCOUNT(1,VM_iscachedpic);
2522
2523         // drawq hasnt such a function, thus always return true 
2524         PRVM_G_FLOAT(OFS_RETURN) = TRUE;
2525 }
2526
2527 /*
2528 =========
2529 VM_precache_pic
2530
2531 string  precache_pic(string pic) 
2532 =========
2533 */
2534 void VM_precache_pic(void)
2535 {
2536         char    *s;
2537         
2538         VM_SAFEPARMCOUNT(1, VM_precache_pic);
2539         
2540         s = PRVM_G_STRING(OFS_PARM0);
2541         PRVM_G_INT(OFS_RETURN) = PRVM_G_INT(OFS_PARM0);
2542         
2543         if(!s)
2544                 PRVM_ERROR ("VM_precache_pic: %s: NULL\n", PRVM_NAME);
2545
2546         VM_CheckEmptyString (s);
2547         
2548         if(!Draw_CachePic(s))
2549                 PRVM_G_INT(OFS_RETURN) = PRVM_SetString(""); 
2550 }
2551
2552 /*
2553 =========
2554 VM_freepic
2555
2556 freepic(string s)
2557 =========
2558 */
2559 void VM_freepic(void)
2560 {
2561         char *s;
2562
2563         VM_SAFEPARMCOUNT(1,VM_freepic);
2564
2565         s = PRVM_G_STRING(OFS_PARM0);
2566         
2567         if(!s)
2568                 PRVM_ERROR ("VM_freepic: %s: NULL\n");
2569         
2570         VM_CheckEmptyString (s);
2571         
2572         Draw_FreePic(s);
2573 }
2574
2575 /*
2576 =========
2577 VM_drawcharacter
2578
2579 float   drawcharacter(vector position, float character, vector scale, vector rgb, float alpha, float flag)
2580 =========
2581 */
2582 void VM_drawcharacter(void)
2583 {
2584         float *pos,*scale,*rgb;
2585         char   character;
2586         int flag;
2587         VM_SAFEPARMCOUNT(6,VM_drawcharacter);
2588
2589         character = (char) PRVM_G_FLOAT(OFS_PARM1);
2590         if(character == 0)
2591         {
2592                 Con_Printf("VM_drawcharacter: %s passed null character !\n",PRVM_NAME);
2593                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2594                 return;
2595         }
2596         
2597         pos = PRVM_G_VECTOR(OFS_PARM0);
2598         scale = PRVM_G_VECTOR(OFS_PARM2);
2599         rgb = PRVM_G_VECTOR(OFS_PARM3);
2600         flag = (int)PRVM_G_FLOAT(OFS_PARM5);
2601         
2602         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2603         {
2604                 Con_Printf("VM_drawcharacter: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2605                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2606                 return;
2607         }
2608         
2609         if(pos[2] || scale[2])
2610                 Con_Printf("VM_drawcharacter: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); 
2611
2612         if(!scale[0] || !scale[1])
2613         {
2614                 Con_Printf("VM_drawcharacter: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
2615                 PRVM_G_FLOAT(OFS_RETURN) = -3;
2616                 return;
2617         }
2618
2619         DrawQ_String (pos[0], pos[1], &character, 1, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
2620         PRVM_G_FLOAT(OFS_RETURN) = 1;
2621 }       
2622
2623 /*
2624 =========
2625 VM_drawstring
2626
2627 float   drawstring(vector position, string text, vector scale, vector rgb, float alpha, float flag)
2628 =========
2629 */
2630 void VM_drawstring(void)
2631 {
2632         float *pos,*scale,*rgb;
2633         char  *string;
2634         int flag;
2635         VM_SAFEPARMCOUNT(6,VM_drawstring);
2636         
2637         string = PRVM_G_STRING(OFS_PARM1);
2638         if(!string)
2639         {
2640                 Con_Printf("VM_drawstring: %s passed null string !\n",PRVM_NAME);
2641                 PRVM_G_FLOAT(OFS_RETURN) = -1;
2642                 return;
2643         }
2644         
2645         VM_CheckEmptyString(string);
2646         
2647         pos = PRVM_G_VECTOR(OFS_PARM0);
2648         scale = PRVM_G_VECTOR(OFS_PARM2);
2649         rgb = PRVM_G_VECTOR(OFS_PARM3);
2650         flag = (int)PRVM_G_FLOAT(OFS_PARM5);
2651         
2652         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2653         {
2654                 Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2655                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2656                 return;
2657         }
2658         
2659         if(!scale[0] || !scale[1])
2660         {
2661                 Con_Printf("VM_drawstring: scale %s is null !\n", (scale[0] == 0) ? ((scale[1] == 0) ? "x and y" : "x") : "y");
2662                 PRVM_G_FLOAT(OFS_RETURN) = -3;
2663                 return;
2664         }
2665
2666         if(pos[2] || scale[2])
2667                 Con_Printf("VM_drawstring: z value%c from %s discarded\n",(pos[2] && scale[2]) ? 's' : 0,((pos[2] && scale[2]) ? "pos and scale" : (pos[2] ? "pos" : "scale"))); 
2668         
2669         DrawQ_String (pos[0], pos[1], string, 0, scale[0], scale[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
2670         PRVM_G_FLOAT(OFS_RETURN) = 1;
2671 }
2672 /*
2673 =========
2674 VM_drawpic
2675
2676 float   drawpic(vector position, string pic, vector size, vector rgb, float alpha, float flag)
2677 =========
2678 */
2679 void VM_drawpic(void)
2680 {
2681         char *pic;
2682         float *size, *pos, *rgb;
2683         int flag;
2684
2685         VM_SAFEPARMCOUNT(6,VM_drawpic);
2686
2687         pic = PRVM_G_STRING(OFS_PARM1);
2688
2689         if(!pic)
2690         {
2691                 Con_Printf("VM_drawpic: %s passed null picture name !\n", PRVM_NAME);
2692                 PRVM_G_FLOAT(OFS_RETURN) = -1;  
2693                 return;
2694         }
2695
2696         VM_CheckEmptyString (pic);
2697
2698         // is pic cached ? no function yet for that
2699         if(!1)
2700         {
2701                 Con_Printf("VM_drawpic: %s: %s not cached !\n", PRVM_NAME, pic);
2702                 PRVM_G_FLOAT(OFS_RETURN) = -4;
2703                 return;
2704         }
2705         
2706         pos = PRVM_G_VECTOR(OFS_PARM0);
2707         size = PRVM_G_VECTOR(OFS_PARM2);
2708         rgb = PRVM_G_VECTOR(OFS_PARM3);
2709         flag = (int) PRVM_G_FLOAT(OFS_PARM5);
2710
2711         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2712         {
2713                 Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2714                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2715                 return;
2716         }
2717
2718         if(pos[2] || size[2])
2719                 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"))); 
2720         
2721         DrawQ_Pic(pos[0], pos[1], pic, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM4), flag);
2722         PRVM_G_FLOAT(OFS_RETURN) = 1;
2723 }
2724
2725 /*
2726 =========
2727 VM_drawfill
2728
2729 float drawfill(vector position, vector size, vector rgb, float alpha, float flag)
2730 =========
2731 */
2732 void VM_drawfill(void)
2733 {
2734         float *size, *pos, *rgb;
2735         int flag;
2736         
2737         VM_SAFEPARMCOUNT(5,VM_drawfill);
2738         
2739         
2740         pos = PRVM_G_VECTOR(OFS_PARM0);
2741         size = PRVM_G_VECTOR(OFS_PARM1);
2742         rgb = PRVM_G_VECTOR(OFS_PARM2);
2743         flag = (int) PRVM_G_FLOAT(OFS_PARM4);
2744         
2745         if(flag < DRAWFLAG_NORMAL || flag >=DRAWFLAG_NUMFLAGS)
2746         {
2747                 Con_Printf("VM_drawstring: %s: wrong DRAWFLAG %i !\n",PRVM_NAME,flag);
2748                 PRVM_G_FLOAT(OFS_RETURN) = -2;
2749                 return;
2750         }
2751         
2752         if(pos[2] || size[2])
2753                 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"))); 
2754         
2755         DrawQ_Pic(pos[0], pos[1], 0, size[0], size[1], rgb[0], rgb[1], rgb[2], PRVM_G_FLOAT(OFS_PARM3), flag);
2756         PRVM_G_FLOAT(OFS_RETURN) = 1;
2757 }
2758
2759 /*
2760 =========
2761 VM_drawsetcliparea
2762
2763 drawsetcliparea(float x, float y, float width, float height)
2764 =========
2765 */
2766 void VM_drawsetcliparea(void)
2767 {
2768         float x,y,w,h;
2769         VM_SAFEPARMCOUNT(4,VM_drawsetcliparea);
2770
2771         x = bound(0,PRVM_G_FLOAT(OFS_PARM0),vid.conwidth);
2772         y = bound(0,PRVM_G_FLOAT(OFS_PARM1),vid.conheight);
2773         w = bound(0,PRVM_G_FLOAT(OFS_PARM2),(vid.conwidth  - x));
2774         h = bound(0,PRVM_G_FLOAT(OFS_PARM3),(vid.conheight - y)); 
2775
2776         DrawQ_SetClipArea(x,y,w,h);
2777 }
2778
2779 /*
2780 =========
2781 VM_drawresetcliparea
2782
2783 drawresetcliparea()
2784 =========
2785 */
2786 void VM_drawresetcliparea(void)
2787 {
2788         VM_SAFEPARMCOUNT(0,VM_drawresetcliparea);
2789
2790         DrawQ_ResetClipArea();
2791 }
2792
2793 /*
2794 =========
2795 VM_getimagesize
2796
2797 vector  getimagesize(string pic)
2798 =========
2799 */
2800 void VM_getimagesize(void)
2801 {
2802         char *p;
2803         cachepic_t *pic;
2804
2805         VM_SAFEPARMCOUNT(1,VM_getimagesize);
2806         
2807         p = PRVM_G_STRING(OFS_PARM0);
2808
2809         if(!p)
2810                 PRVM_ERROR("VM_getimagepos: %s passed null picture name !\n", PRVM_NAME);
2811         
2812         VM_CheckEmptyString (p);
2813
2814         pic = Draw_CachePic (p);
2815
2816         PRVM_G_VECTOR(OFS_RETURN)[0] = pic->width;
2817         PRVM_G_VECTOR(OFS_RETURN)[1] = pic->height;
2818         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;
2819 }
2820
2821 void VM_Cmd_Init(void)
2822 {
2823         // only init the stuff for the current prog
2824         VM_STRINGS_MEMPOOL = Mem_AllocPool(va("vm_stringsmempool[%s]",PRVM_NAME), 0, NULL);
2825         VM_Files_Init();
2826         VM_Search_Init();
2827 }
2828
2829 void VM_Cmd_Reset(void)
2830 {
2831         //Mem_EmptyPool(VM_STRINGS_MEMPOOL);
2832         Mem_FreePool(&VM_STRINGS_MEMPOOL);
2833         VM_Search_Reset();
2834         VM_Files_CloseAll();
2835 }
2836
2837 //============================================================================
2838 // Server
2839
2840 char *vm_sv_extensions =
2841 "";
2842
2843 prvm_builtin_t vm_sv_builtins[] = {
2844 0  // to be consistent with the old vm
2845 };
2846
2847 const int vm_sv_numbuiltins = sizeof(vm_sv_builtins) / sizeof(prvm_builtin_t);
2848
2849 void VM_SV_Cmd_Init(void)
2850 {
2851 }
2852
2853 void VM_SV_Cmd_Reset(void)
2854 {
2855 }
2856
2857 //============================================================================
2858 // Client
2859
2860 char *vm_cl_extensions =
2861 "";
2862
2863 prvm_builtin_t vm_cl_builtins[] = {
2864 0  // to be consistent with the old vm
2865 };
2866
2867 const int vm_cl_numbuiltins = sizeof(vm_cl_builtins) / sizeof(prvm_builtin_t);
2868
2869 void VM_CL_Cmd_Init(void)
2870 {
2871 }
2872
2873 void VM_CL_Cmd_Reset(void)
2874 {
2875 }
2876
2877 //============================================================================
2878 // Menu
2879
2880 char *vm_m_extensions =
2881 "";
2882
2883 /*
2884 =========
2885 VM_M_setmousetarget
2886
2887 setmousetarget(float target)
2888 =========
2889 */
2890 void VM_M_setmousetarget(void)
2891 {
2892         VM_SAFEPARMCOUNT(1, VM_M_setmousetarget);
2893
2894         switch((int)PRVM_G_FLOAT(OFS_PARM0))
2895         {
2896         case 1:
2897                 in_client_mouse = false;
2898                 break;
2899         case 2:
2900                 in_client_mouse = true;
2901                 break;
2902         default:
2903                 PRVM_ERROR("VM_M_setmousetarget: wrong destination %i !\n",PRVM_G_FLOAT(OFS_PARM0));
2904         }
2905 }
2906
2907 /*
2908 =========
2909 VM_M_getmousetarget
2910
2911 float   getmousetarget
2912 =========
2913 */
2914 void VM_M_getmousetarget(void)
2915 {
2916         VM_SAFEPARMCOUNT(0,VM_M_getmousetarget);
2917
2918         if(in_client_mouse)
2919                 PRVM_G_FLOAT(OFS_RETURN) = 2;
2920         else
2921                 PRVM_G_FLOAT(OFS_RETURN) = 1;
2922 }
2923         
2924
2925
2926 /*
2927 =========
2928 VM_M_setkeydest
2929
2930 setkeydest(float dest)
2931 =========
2932 */
2933 void VM_M_setkeydest(void)
2934 {
2935         VM_SAFEPARMCOUNT(1,VM_M_setkeydest);
2936
2937         switch((int)PRVM_G_FLOAT(OFS_PARM0))
2938         {
2939         case 0:
2940                 // key_game
2941                 key_dest = key_game;
2942                 break;
2943         case 2:
2944                 // key_menu
2945                 key_dest = key_menu;
2946                 break;
2947         case 1:
2948                 // key_message
2949                 // key_dest = key_message
2950                 // break;
2951         default:
2952                 PRVM_ERROR("VM_M_setkeydest: wrong destination %i !\n",prog->globals[OFS_PARM0]);
2953         }
2954 }
2955
2956 /*
2957 =========
2958 VM_M_getkeydest
2959
2960 float   getkeydest
2961 =========
2962 */
2963 void VM_M_getkeydest(void)
2964 {
2965         VM_SAFEPARMCOUNT(0,VM_M_getkeydest);
2966
2967         // key_game = 0, key_message = 1, key_menu = 2, unknown = 3
2968         switch(key_dest)
2969         {
2970         case key_game:
2971                 PRVM_G_FLOAT(OFS_RETURN) = 0;
2972                 break;
2973         case key_menu:
2974                 PRVM_G_FLOAT(OFS_RETURN) = 2;
2975                 break;
2976         case key_message:
2977                 // not supported
2978                 // PRVM_G_FLOAT(OFS_RETURN) = 1;
2979                 // break;
2980         default:
2981                 PRVM_G_FLOAT(OFS_RETURN) = 3;
2982         }
2983 }
2984
2985 /*
2986 =========
2987 VM_M_callfunction
2988
2989         callfunction(...,string function_name)
2990 Extension: pass 
2991 =========
2992 */
2993 mfunction_t *PRVM_ED_FindFunction (const char *name);
2994 void VM_M_callfunction(void)
2995 {
2996         mfunction_t *func;
2997         char *s;
2998
2999         if(prog->argc == 0)
3000                 PRVM_ERROR("VM_M_callfunction: 1 parameter is required !\n");
3001
3002         s = PRVM_G_STRING(OFS_PARM0 + (prog->argc - 1));
3003
3004         if(!s)
3005                 PRVM_ERROR("VM_M_callfunction: null string !\n");
3006
3007         VM_CheckEmptyString(s); 
3008
3009         func = PRVM_ED_FindFunction(s);
3010
3011         if(!func)
3012                 PRVM_ERROR("VM_M_callfunciton: function %s not found !\n", s);
3013         else if (func->first_statement < 0)
3014         {
3015                 // negative statements are built in functions
3016                 int builtinnumber = -func->first_statement;
3017                 prog->xfunction->builtinsprofile++;
3018                 if (builtinnumber < prog->numbuiltins && prog->builtins[builtinnumber])
3019                         prog->builtins[builtinnumber]();
3020                 else
3021                         PRVM_ERROR("No such builtin #%i in %s", builtinnumber, PRVM_NAME);
3022         }
3023         else if(func > 0)
3024         {
3025                 prog->argc--;
3026                 PRVM_ExecuteProgram(func - prog->functions,"");
3027                 prog->argc++;
3028         }
3029 }       
3030
3031 /*
3032 =========
3033 VM_M_isfunction
3034
3035 float   isfunction(string function_name)
3036 =========
3037 */
3038 mfunction_t *PRVM_ED_FindFunction (const char *name);
3039 void VM_M_isfunction(void)
3040 {
3041         mfunction_t *func;
3042         char *s;
3043         
3044         VM_SAFEPARMCOUNT(1, VM_M_isfunction);
3045         
3046         s = PRVM_G_STRING(OFS_PARM0);
3047         
3048         if(!s)
3049                 PRVM_ERROR("VM_M_isfunction: null string !\n");
3050         
3051         VM_CheckEmptyString(s); 
3052         
3053         func = PRVM_ED_FindFunction(s);
3054
3055         if(!func)
3056                 PRVM_G_FLOAT(OFS_RETURN) = false;
3057         else
3058                 PRVM_G_FLOAT(OFS_RETURN) = true;
3059 }
3060
3061 /*
3062 =========
3063 VM_M_writetofile
3064
3065         writetofile(float fhandle, entity ent)
3066 =========
3067 */
3068 void VM_M_writetofile(void)
3069 {
3070         prvm_edict_t * ent;
3071         int filenum;
3072
3073         VM_SAFEPARMCOUNT(2, VM_M_writetofile);
3074
3075         filenum = PRVM_G_FLOAT(OFS_PARM0);
3076         if (filenum < 0 || filenum >= MAX_VMFILES)
3077         {
3078                 Con_Printf("VM_fputs: invalid file handle %i used in %s\n", filenum, PRVM_NAME);
3079                 return;
3080         }
3081         if (VM_FILES[filenum] == NULL)
3082         {
3083                 Con_Printf("VM_fputs: no such file handle %i (or file has been closed) in %s\n", filenum, PRVM_NAME);
3084                 return;
3085         }
3086
3087         ent = PRVM_G_EDICT(OFS_PARM1);  
3088         if(ent->p.e->free)
3089         {
3090                 Con_Printf("VM_M_writetofile: %s: entity %i is free !\n", PRVM_NAME, PRVM_EDICT_NUM(OFS_PARM1));
3091                 return;
3092         }
3093
3094         PRVM_ED_Write (VM_FILES[filenum], ent);
3095 }
3096
3097 /*
3098 =========
3099 VM_M_getresolution
3100
3101 vector  getresolution(float number)
3102 =========
3103 */
3104 extern unsigned short video_resolutions[][2];
3105 void VM_M_getresolution(void)
3106 {
3107         int nr;
3108         VM_SAFEPARMCOUNT(1, VM_getresolution);
3109
3110         nr = PRVM_G_FLOAT(OFS_PARM0);
3111
3112
3113         PRVM_G_VECTOR(OFS_RETURN)[0] = video_resolutions[nr][0];
3114         PRVM_G_VECTOR(OFS_RETURN)[1] = video_resolutions[nr][1];
3115         PRVM_G_VECTOR(OFS_RETURN)[2] = 0;       
3116 }
3117
3118 /*
3119 =========
3120 VM_M_keynumtostring
3121
3122 string keynumtostring(float keynum)
3123 =========
3124 */
3125 void VM_M_keynumtostring(void)
3126 {
3127         int keynum;
3128         char *tmp;
3129         VM_SAFEPARMCOUNT(1, VM_M_keynumtostring);
3130
3131         keynum = PRVM_G_FLOAT(OFS_PARM0);
3132
3133         tmp = VM_GetTempString();
3134         
3135         strcpy(tmp, Key_KeynumToString(keynum));
3136
3137         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(tmp);
3138 }
3139
3140 /*
3141 =========
3142 VM_M_findkeysforcommand
3143
3144 string  findkeysforcommand(string command)
3145
3146 the returned string is an altstring
3147 =========
3148 */
3149 #define NUMKEYS 5 // TODO: merge the constant in keys.c with this one somewhen
3150
3151 void M_FindKeysForCommand(char *command, int *keys);
3152 void VM_M_findkeysforcommand(void)
3153 {
3154         char *cmd, *ret;
3155         int keys[NUMKEYS];
3156         int i;
3157
3158         VM_SAFEPARMCOUNT(1, VM_M_findkeysforcommand);
3159
3160         cmd = PRVM_G_STRING(OFS_PARM0);
3161         
3162         VM_CheckEmptyString(cmd);
3163
3164         (ret = VM_GetTempString())[0] = 0;
3165         
3166         M_FindKeysForCommand(cmd, keys);
3167
3168         for(i = 0; i < NUMKEYS; i++)
3169                 ret = strcat(ret, va(" \'%i\'", keys[i]));
3170
3171         PRVM_G_INT(OFS_RETURN) = PRVM_SetString(ret);
3172 }
3173
3174 /*
3175 =========
3176 VM_M_gethostcachecount
3177
3178 float   gethostcachevalue(float type)
3179 =========
3180 */
3181 /*
3182         type:
3183 0       hostcachecount
3184 1       masterquerycount
3185 2       masterreplycount
3186 3       serverquerycount
3187 4       serverreplycount
3188 */
3189 void VM_M_gethostcachevalue( void )
3190 {
3191         int type;
3192         VM_SAFEPARMCOUNT ( 1, VM_M_gethostcachevalue );
3193
3194         PRVM_G_FLOAT( OFS_RETURN ) = 0;
3195
3196         type = PRVM_G_FLOAT( OFS_PARM0 );
3197         if( type < 0 || type > 4 )
3198                 Con_Printf( "VM_M_gethostcachevalue: bad type %i!\n", type );
3199         else switch(type)
3200         {
3201         case 0:
3202                 PRVM_G_FLOAT ( OFS_RETURN ) = hostCacheCount;
3203                 return;
3204         case 1:
3205                 PRVM_G_FLOAT ( OFS_RETURN ) = masterquerycount;
3206                 return;
3207         case 2:
3208                 PRVM_G_FLOAT ( OFS_RETURN ) = masterreplycount;
3209                 return;
3210         case 3:
3211                 PRVM_G_FLOAT ( OFS_RETURN ) = serverquerycount;
3212                 return;
3213         case 4:
3214                 PRVM_G_FLOAT ( OFS_RETURN ) = serverreplycount;
3215                 return;
3216         }
3217 }
3218
3219 /*
3220 =========
3221 VM_M_gethostcachestring
3222
3223 string  gethostcachestring(float type, float hostnr)
3224 =========
3225 */
3226 /*
3227 0       Get CName
3228 1       Get line1
3229 2       Get line2 
3230 */
3231 void VM_M_gethostcachestring(void)
3232 {
3233         int type;
3234         int hostnr;
3235
3236         VM_SAFEPARMCOUNT(2, VM_M_gethostcachestring);
3237
3238         PRVM_G_INT(OFS_RETURN) = 0;
3239
3240         type = PRVM_G_FLOAT(OFS_PARM0);
3241         
3242         if(type < 0 || type > 2)
3243         {
3244                 Con_Print("VM_M_gethostcachestring: bad string type requested!\n");
3245                 return;
3246         }
3247
3248         hostnr = PRVM_G_FLOAT(OFS_PARM1);
3249
3250         if(hostnr < 0 || hostnr >= hostCacheCount)
3251         {
3252                 Con_Print("VM_M_gethostcachestring: bad hostnr passed!\n");
3253                 return;
3254         }
3255
3256         if( type == 0 )
3257                 PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].cname );
3258         else if( type == 1 )
3259                 PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line1 );
3260         else
3261                 PRVM_G_INT( OFS_RETURN ) = PRVM_SetString( hostcache[hostnr].line2 );
3262 }
3263
3264 prvm_builtin_t vm_m_builtins[] = {
3265         0, // to be consistent with the old vm
3266         // common builtings (mostly)
3267         VM_checkextension,
3268         VM_error,
3269         VM_objerror,
3270         VM_print,
3271         VM_bprint,
3272         VM_sprint,
3273         VM_centerprint,
3274         VM_normalize,
3275         VM_vlen,
3276         VM_vectoyaw,    // #10
3277         VM_vectoangles,
3278         VM_random,
3279         VM_localcmd,
3280         VM_cvar,
3281         VM_cvar_set,
3282         VM_dprint,
3283         VM_ftos,
3284         VM_fabs,
3285         VM_vtos,
3286         VM_etos,                // 20
3287         VM_stof,
3288         VM_spawn,
3289         VM_remove,
3290         VM_find,
3291         VM_findfloat,
3292         VM_findchain,
3293         VM_findchainfloat,
3294         VM_precache_file,
3295         VM_precache_sound,
3296         VM_coredump,    // 30
3297         VM_traceon,
3298         VM_traceoff,
3299         VM_eprint,
3300         VM_rint,
3301         VM_floor,
3302         VM_ceil,
3303         VM_nextent,
3304         VM_sin,
3305         VM_cos,
3306         VM_sqrt,                // 40
3307         VM_randomvec,
3308         VM_registercvar,
3309         VM_min,
3310         VM_max,
3311         VM_bound,
3312         VM_pow,
3313         VM_copyentity,
3314         VM_fopen,
3315         VM_fclose,
3316         VM_fgets,               // 50
3317         VM_fputs,
3318         VM_strlen,
3319         VM_strcat,
3320         VM_substring,
3321         VM_stov,
3322         VM_strzone,
3323         VM_strunzone,
3324         VM_tokenize,
3325         VM_argv,
3326         VM_isserver,    // 60
3327         VM_clientcount, 
3328         VM_clientstate, 
3329         VM_clcommand,
3330         VM_changelevel,
3331         VM_localsound,  
3332         VM_getmousepos,
3333         VM_gettime,
3334         VM_loadfromdata,
3335         VM_loadfromfile,
3336         VM_modulo,              // 70
3337         VM_str_cvar,    
3338         VM_crash,
3339         VM_stackdump,   // 73
3340         VM_search_begin,
3341         VM_search_end,
3342         VM_search_getsize,
3343         VM_search_getfilename, // 77
3344         VM_chr, 
3345         VM_itof,
3346         VM_ftoi,// 80
3347         e10,                    // 90
3348         e10,                    // 100
3349         e100,                   // 200
3350         e100,                   // 300
3351         e100,                   // 400
3352         // msg functions
3353         VM_WriteByte,
3354         VM_WriteChar,
3355         VM_WriteShort,
3356         VM_WriteLong,
3357         VM_WriteAngle,
3358         VM_WriteCoord,
3359         VM_WriteString,
3360         VM_WriteEntity, // 408
3361         0,
3362         0,                              // 410
3363         e10,                    // 420
3364         e10,                    // 430
3365         e10,                    // 440
3366         e10,                    // 450
3367         // draw functions
3368         VM_iscachedpic,
3369         VM_precache_pic,
3370         VM_freepic,
3371         VM_drawcharacter,
3372         VM_drawstring,
3373         VM_drawpic,
3374         VM_drawfill,    
3375         VM_drawsetcliparea,
3376         VM_drawresetcliparea,
3377         VM_getimagesize,// 460
3378         e10,                    // 470
3379         e10,                    // 480
3380         e10,                    // 490
3381         e10,                    // 500
3382         e100,                   // 600
3383         // menu functions
3384         VM_M_setkeydest,
3385         VM_M_getkeydest,
3386         VM_M_setmousetarget,
3387         VM_M_getmousetarget,
3388         VM_M_callfunction,
3389         VM_M_writetofile,
3390         VM_M_isfunction,
3391         VM_M_getresolution,
3392         VM_M_keynumtostring,
3393         VM_M_findkeysforcommand,// 610
3394         VM_M_gethostcachevalue,
3395         VM_M_gethostcachestring,
3396         VM_M_parseentitydata    // 613
3397 };
3398
3399 const int vm_m_numbuiltins = sizeof(vm_m_builtins) / sizeof(prvm_builtin_t);
3400
3401 void VM_M_Cmd_Init(void)
3402 {
3403         VM_Cmd_Init();
3404 }
3405
3406 void VM_M_Cmd_Reset(void)
3407 {
3408         //VM_Cmd_Init();
3409         VM_Cmd_Reset();
3410 }