merge FruitieX's onslaught config changes
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / util.qc
1 // checkextension wrapper for log
2 float sqrt(float f); // declared later
3 float exp(float f); // declared later
4 float pow(float f, float e); // declared later
5 float checkextension(string s); // declared later
6 float log_synth(float f)
7 {
8         float p, l;
9         if(f < 0)
10                 return sqrt(-1); // nan? -inf?
11         if(f == 0)
12                 return sqrt(-1); // ACTUALLY this should rather be -inf, but we cannot create a +inf in QC
13         if(f + f == f)
14                 return l; // +inf
15         if(f < 1)
16         {
17                 f = 1 / f;
18                 p = -1;
19         }
20         else
21                 p = 1;
22         while(f > 2)
23         {
24                 f = sqrt(f);
25                 p *= 2;
26         }
27         // two steps are good enough
28         l = ((6-f) * f - 5) / 4.32808512266689022212;
29         l += exp(-l) * f - 1;
30         l += exp(-l) * f - 1;
31         return l * p;
32 }
33 float log(float f)
34 {
35         if(checkextension("DP_QC_LOG"))
36                 return log_builtin(f);
37         else
38                 return log_synth(f);
39 }
40
41 string wordwrap_buffer;
42
43 void wordwrap_buffer_put(string s)
44 {
45         wordwrap_buffer = strcat(wordwrap_buffer, s);
46 }
47
48 string wordwrap(string s, float l)
49 {
50         string r;
51         wordwrap_buffer = "";
52         wordwrap_cb(s, l, wordwrap_buffer_put);
53         r = wordwrap_buffer;
54         wordwrap_buffer = "";
55         return r;
56 }
57
58 #ifndef MENUQC
59 #ifndef CSQC
60 void wordwrap_buffer_sprint(string s)
61 {
62         wordwrap_buffer = strcat(wordwrap_buffer, s);
63         if(s == "\n")
64         {
65                 sprint(self, wordwrap_buffer);
66                 wordwrap_buffer = "";
67         }
68 }
69
70 void wordwrap_sprint(string s, float l)
71 {
72         wordwrap_buffer = "";
73         wordwrap_cb(s, l, wordwrap_buffer_sprint);
74         if(wordwrap_buffer != "")
75                 sprint(self, strcat(wordwrap_buffer, "\n"));
76         wordwrap_buffer = "";
77         return;
78 }
79 #endif
80 #endif
81
82 string unescape(string in)
83 {
84         local float i, len;
85         local string str, s;
86
87         // but it doesn't seem to be necessary in my tests at least
88         in = strzone(in);
89
90         len = strlen(in);
91         str = "";
92         for(i = 0; i < len; ++i)
93         {
94                 s = substring(in, i, 1);
95                 if(s == "\\")
96                 {
97                         s = substring(in, i+1, 1);
98                         if(s == "n")
99                                 str = strcat(str, "\n");
100                         else if(s == "\\")
101                                 str = strcat(str, "\\");
102                         else
103                                 str = strcat(str, substring(in, i, 2));
104                         ++i;
105                 } else
106                         str = strcat(str, s);
107         }
108
109         strunzone(in);
110         return str;
111 }
112
113 void wordwrap_cb(string s, float l, void(string) callback)
114 {
115         local string c;
116         local float lleft, i, j, wlen;
117
118         s = strzone(s);
119         lleft = l;
120         for (i = 0;i < strlen(s);++i)
121         {
122                 if (substring(s, i, 2) == "\\n")
123                 {
124                         callback("\n");
125                         lleft = l;
126                         ++i;
127                 }
128                 else if (substring(s, i, 1) == "\n")
129                 {
130                         callback("\n");
131                         lleft = l;
132                 }
133                 else if (substring(s, i, 1) == " ")
134                 {
135                         if (lleft > 0)
136                         {
137                                 callback(" ");
138                                 lleft = lleft - 1;
139                         }
140                 }
141                 else
142                 {
143                         for (j = i+1;j < strlen(s);++j)
144                                 //    ^^ this skips over the first character of a word, which
145                                 //       is ALWAYS part of the word
146                                 //       this is safe since if i+1 == strlen(s), i will become
147                                 //       strlen(s)-1 at the end of this block and the function
148                                 //       will terminate. A space can't be the first character we
149                                 //       read here, and neither can a \n be the start, since these
150                                 //       two cases have been handled above.
151                         {
152                                 c = substring(s, j, 1);
153                                 if (c == " ")
154                                         break;
155                                 if (c == "\\")
156                                         break;
157                                 if (c == "\n")
158                                         break;
159                                 // we need to keep this tempstring alive even if substring is
160                                 // called repeatedly, so call strcat even though we're not
161                                 // doing anything
162                                 callback("");
163                         }
164                         wlen = j - i;
165                         if (lleft < wlen)
166                         {
167                                 callback("\n");
168                                 lleft = l;
169                         }
170                         callback(substring(s, i, wlen));
171                         lleft = lleft - wlen;
172                         i = j - 1;
173                 }
174         }
175         strunzone(s);
176 }
177
178 float dist_point_line(vector p, vector l0, vector ldir)
179 {
180         ldir = normalize(ldir);
181         
182         // remove the component in line direction
183         p = p - (p * ldir) * ldir;
184
185         // vlen of the remaining vector
186         return vlen(p);
187 }
188
189 void depthfirst(entity start, .entity up, .entity downleft, .entity right, void(entity, entity) funcPre, void(entity, entity) funcPost, entity pass)
190 {
191         entity e;
192         e = start;
193         funcPre(pass, e);
194         while(e.downleft)
195         {
196                 e = e.downleft;
197                 funcPre(pass, e);
198         }
199         funcPost(pass, e);
200         while(e != start)
201         {
202                 if(e.right)
203                 {
204                         e = e.right;
205                         funcPre(pass, e);
206                         while(e.downleft)
207                         {
208                                 e = e.downleft;
209                                 funcPre(pass, e);
210                         }
211                 }
212                 else
213                         e = e.up;
214                 funcPost(pass, e);
215         }
216 }
217
218 float median(float a, float b, float c)
219 {
220         if(a < c)
221                 return bound(a, b, c);
222         return bound(c, b, a);
223 }
224
225 // converts a number to a string with the indicated number of decimals
226 // works for up to 10 decimals!
227 string ftos_decimals(float number, float decimals)
228 {
229         // we have sprintf...
230         return sprintf("%.*f", decimals, number);
231 }
232
233 float time;
234 vector colormapPaletteColor(float c, float isPants)
235 {
236         switch(c)
237         {
238                 case  0: return '0.800000 0.800000 0.800000';
239                 case  1: return '0.600000 0.400000 0.000000';
240                 case  2: return '0.000000 1.000000 0.501961';
241                 case  3: return '0.000000 1.000000 0.000000';
242                 case  4: return '1.000000 0.000000 0.000000';
243                 case  5: return '0.000000 0.658824 1.000000';
244                 case  6: return '0.000000 1.000000 1.000000';
245                 case  7: return '0.501961 1.000000 0.000000';
246                 case  8: return '0.501961 0.000000 1.000000';
247                 case  9: return '1.000000 0.000000 1.000000';
248                 case 10: return '1.000000 0.000000 0.501961';
249                 case 11: return '0.600000 0.600000 0.600000';
250                 case 12: return '1.000000 1.000000 0.000000';
251                 case 13: return '0.000000 0.313725 1.000000';
252                 case 14: return '1.000000 0.501961 0.000000';
253                 case 15:
254                         if(isPants)
255                                 return
256                                           '1 0 0' * (0.502 + 0.498 * sin(time / 2.7182818285 + 0.0000000000))
257                                         + '0 1 0' * (0.502 + 0.498 * sin(time / 2.7182818285 + 2.0943951024))
258                                         + '0 0 1' * (0.502 + 0.498 * sin(time / 2.7182818285 + 4.1887902048));
259                         else
260                                 return
261                                           '1 0 0' * (0.502 + 0.498 * sin(time / 3.1415926536 + 5.2359877560))
262                                         + '0 1 0' * (0.502 + 0.498 * sin(time / 3.1415926536 + 3.1415926536))
263                                         + '0 0 1' * (0.502 + 0.498 * sin(time / 3.1415926536 + 1.0471975512));
264                 default: return '0.000 0.000 0.000';
265         }
266 }
267
268 // unzone the string, and return it as tempstring. Safe to be called on string_null
269 string fstrunzone(string s)
270 {
271         string sc;
272         if not(s)
273                 return s;
274         sc = strcat(s, "");
275         strunzone(s);
276         return sc;
277 }
278
279 // Databases (hash tables)
280 #define DB_BUCKETS 8192
281 void db_save(float db, string pFilename)
282 {
283         float fh, i, n;
284         fh = fopen(pFilename, FILE_WRITE);
285         if(fh < 0) 
286         {
287                 print(strcat("^1Can't write DB to ", pFilename));
288                 return;
289         }
290         n = buf_getsize(db);
291         fputs(fh, strcat(ftos(DB_BUCKETS), "\n"));
292         for(i = 0; i < n; ++i)
293                 fputs(fh, strcat(bufstr_get(db, i), "\n"));
294         fclose(fh);
295 }
296
297 float db_create()
298 {
299         return buf_create();
300 }
301
302 float db_load(string pFilename)
303 {
304         float db, fh, i, j, n;
305         string l;
306         db = buf_create();
307         if(db < 0)
308                 return -1;
309         fh = fopen(pFilename, FILE_READ);
310         if(fh < 0)
311                 return db;
312         l = fgets(fh);
313         if(stof(l) == DB_BUCKETS)
314         {
315                 i = 0;
316                 while((l = fgets(fh)))
317                 {
318                         if(l != "")
319                                 bufstr_set(db, i, l);
320                         ++i;
321                 }
322         }
323         else
324         {
325                 // different count of buckets, or a dump?
326                 // need to reorganize the database then (SLOW)
327                 //
328                 // note: we also parse the first line (l) in case the DB file is
329                 // missing the bucket count
330                 do
331                 {
332                         n = tokenizebyseparator(l, "\\");
333                         for(j = 2; j < n; j += 2)
334                                 db_put(db, argv(j-1), uri_unescape(argv(j)));
335                 }
336                 while((l = fgets(fh)));
337         }
338         fclose(fh);
339         return db;
340 }
341
342 void db_dump(float db, string pFilename)
343 {
344         float fh, i, j, n, m;
345         fh = fopen(pFilename, FILE_WRITE);
346         if(fh < 0)
347                 error(strcat("Can't dump DB to ", pFilename));
348         n = buf_getsize(db);
349         fputs(fh, "0\n");
350         for(i = 0; i < n; ++i)
351         {
352                 m = tokenizebyseparator(bufstr_get(db, i), "\\");
353                 for(j = 2; j < m; j += 2)
354                         fputs(fh, strcat("\\", argv(j-1), "\\", argv(j), "\n"));
355         }
356         fclose(fh);
357 }
358
359 void db_close(float db)
360 {
361         buf_del(db);
362 }
363
364 string db_get(float db, string pKey)
365 {
366         float h;
367         h = mod(crc16(FALSE, pKey), DB_BUCKETS);
368         return uri_unescape(infoget(bufstr_get(db, h), pKey));
369 }
370
371 void db_put(float db, string pKey, string pValue)
372 {
373         float h;
374         h = mod(crc16(FALSE, pKey), DB_BUCKETS);
375         bufstr_set(db, h, infoadd(bufstr_get(db, h), pKey, uri_escape(pValue)));
376 }
377
378 void db_test()
379 {
380         float db, i;
381         print("LOAD...\n");
382         db = db_load("foo.db");
383         print("LOADED. FILL...\n");
384         for(i = 0; i < DB_BUCKETS; ++i)
385                 db_put(db, ftos(random()), "X");
386         print("FILLED. SAVE...\n");
387         db_save(db, "foo.db");
388         print("SAVED. CLOSE...\n");
389         db_close(db);
390         print("CLOSED.\n");
391 }
392
393 // Multiline text file buffers
394 float buf_load(string pFilename)
395 {
396         float buf, fh, i;
397         string l;
398         buf = buf_create();
399         if(buf < 0)
400                 return -1;
401         fh = fopen(pFilename, FILE_READ);
402         if(fh < 0)
403                 return buf;
404         i = 0;
405         while((l = fgets(fh)))
406         {
407                 bufstr_set(buf, i, l);
408                 ++i;
409         }
410         fclose(fh);
411         return buf;
412 }
413
414 void buf_save(float buf, string pFilename)
415 {
416         float fh, i, n;
417         fh = fopen(pFilename, FILE_WRITE);
418         if(fh < 0)
419                 error(strcat("Can't write buf to ", pFilename));
420         n = buf_getsize(buf);
421         for(i = 0; i < n; ++i)
422                 fputs(fh, strcat(bufstr_get(buf, i), "\n"));
423         fclose(fh);
424 }
425
426 string GametypeNameFromType(float g)
427 {
428         if      (g == GAME_DEATHMATCH) return "dm";
429         else if (g == GAME_TEAM_DEATHMATCH) return "tdm";
430         else if (g == GAME_DOMINATION) return "dom";
431         else if (g == GAME_CTF) return "ctf";
432         else if (g == GAME_RUNEMATCH) return "rune";
433         else if (g == GAME_LMS) return "lms";
434         else if (g == GAME_ARENA) return "arena";
435         else if (g == GAME_CA) return "ca";
436         else if (g == GAME_KEYHUNT) return "kh";
437         else if (g == GAME_ONSLAUGHT) return "ons";
438         else if (g == GAME_ASSAULT) return "as";
439         else if (g == GAME_RACE) return "rc";
440         else if (g == GAME_NEXBALL) return "nexball";
441         else if (g == GAME_CTS) return "cts";
442         return "dm";
443 }
444
445 string mmsss(float tenths)
446 {
447         float minutes;
448         string s;
449         tenths = floor(tenths + 0.5);
450         minutes = floor(tenths / 600);
451         tenths -= minutes * 600;
452         s = ftos(1000 + tenths);
453         return strcat(ftos(minutes), ":", substring(s, 1, 2), ".", substring(s, 3, 1));
454 }
455
456 string mmssss(float hundredths)
457 {
458         float minutes;
459         string s;
460         hundredths = floor(hundredths + 0.5);
461         minutes = floor(hundredths / 6000);
462         hundredths -= minutes * 6000;
463         s = ftos(10000 + hundredths);
464         return strcat(ftos(minutes), ":", substring(s, 1, 2), ".", substring(s, 3, 2));
465 }
466
467 string ScoreString(float pFlags, float pValue)
468 {
469         string valstr;
470         float l;
471
472         pValue = floor(pValue + 0.5); // round
473
474         if((pValue == 0) && (pFlags & (SFL_HIDE_ZERO | SFL_RANK | SFL_TIME)))
475                 valstr = "";
476         else if(pFlags & SFL_RANK)
477         {
478                 valstr = ftos(pValue);
479                 l = strlen(valstr);
480                 if((l >= 2) && (substring(valstr, l - 2, 1) == "1"))
481                         valstr = strcat(valstr, "th");
482                 else if(substring(valstr, l - 1, 1) == "1")
483                         valstr = strcat(valstr, "st");
484                 else if(substring(valstr, l - 1, 1) == "2")
485                         valstr = strcat(valstr, "nd");
486                 else if(substring(valstr, l - 1, 1) == "3")
487                         valstr = strcat(valstr, "rd");
488                 else
489                         valstr = strcat(valstr, "th");
490         }
491         else if(pFlags & SFL_TIME)
492                 valstr = TIME_ENCODED_TOSTRING(pValue);
493         else
494                 valstr = ftos(pValue);
495         
496         return valstr;
497 }
498
499 vector cross(vector a, vector b)
500 {
501         return
502                 '1 0 0' * (a_y * b_z - a_z * b_y)
503         +       '0 1 0' * (a_z * b_x - a_x * b_z)
504         +       '0 0 1' * (a_x * b_y - a_y * b_x);
505 }
506
507 // compressed vector format:
508 // like MD3, just even shorter
509 //   4 bit pitch (16 angles), 0 is -90, 8 is 0, 16 would be 90
510 //   5 bit yaw (32 angles), 0=0, 8=90, 16=180, 24=270
511 //   7 bit length (logarithmic encoding), 1/8 .. about 7844
512 //     length = 2^(length_encoded/8) / 8
513 // if pitch is 90, yaw does nothing and therefore indicates the sign (yaw is then either 11111 or 11110); 11111 is pointing DOWN
514 // thus, valid values are from 0000.11110.0000000 to 1111.11111.1111111
515 // the special value 0 indicates the zero vector
516
517 float lengthLogTable[128];
518
519 float invertLengthLog(float x)
520 {
521         float l, r, m, lerr, rerr;
522
523         if(x >= lengthLogTable[127])
524                 return 127;
525         if(x <= lengthLogTable[0])
526                 return 0;
527
528         l = 0;
529         r = 127;
530
531         while(r - l > 1)
532         {
533                 m = floor((l + r) / 2);
534                 if(lengthLogTable[m] < x)
535                         l = m;
536                 else
537                         r = m;
538         }
539
540         // now: r is >=, l is <
541         lerr = (x - lengthLogTable[l]);
542         rerr = (lengthLogTable[r] - x);
543         if(lerr < rerr)
544                 return l;
545         return r;
546 }
547
548 vector decompressShortVector(float data)
549 {
550         vector out;
551         float pitch, yaw, len;
552         if(data == 0)
553                 return '0 0 0';
554         pitch = (data & 0xF000) / 0x1000;
555         yaw =   (data & 0x0F80) / 0x80;
556         len =   (data & 0x007F);
557
558         //print("\ndecompress: pitch ", ftos(pitch)); print("yaw ", ftos(yaw)); print("len ", ftos(len), "\n");
559
560         if(pitch == 0)
561         {
562                 out_x = 0;
563                 out_y = 0;
564                 if(yaw == 31)
565                         out_z = -1;
566                 else
567                         out_z = +1;
568         }
569         else
570         {
571                 yaw   = .19634954084936207740 * yaw;
572                 pitch = .19634954084936207740 * pitch - 1.57079632679489661922;
573                 out_x = cos(yaw) *  cos(pitch);
574                 out_y = sin(yaw) *  cos(pitch);
575                 out_z =            -sin(pitch);
576         }
577
578         //print("decompressed: ", vtos(out), "\n");
579
580         return out * lengthLogTable[len];
581 }
582
583 float compressShortVector(vector vec)
584 {
585         vector ang;
586         float pitch, yaw, len;
587         if(vlen(vec) == 0)
588                 return 0;
589         //print("compress: ", vtos(vec), "\n");
590         ang = vectoangles(vec);
591         ang_x = -ang_x;
592         if(ang_x < -90)
593                 ang_x += 360;
594         if(ang_x < -90 && ang_x > +90)
595                 error("BOGUS vectoangles");
596         //print("angles: ", vtos(ang), "\n");
597
598         pitch = floor(0.5 + (ang_x + 90) * 16 / 180) & 15; // -90..90 to 0..14
599         if(pitch == 0)
600         {
601                 if(vec_z < 0)
602                         yaw = 31;
603                 else
604                         yaw = 30;
605         }
606         else
607                 yaw = floor(0.5 + ang_y * 32 / 360)          & 31; // 0..360 to 0..32
608         len = invertLengthLog(vlen(vec));
609
610         //print("compressed: pitch ", ftos(pitch)); print("yaw ", ftos(yaw)); print("len ", ftos(len), "\n");
611
612         return (pitch * 0x1000) + (yaw * 0x80) + len;
613 }
614
615 void compressShortVector_init()
616 {
617         float l, f, i;
618         l = 1;
619         f = pow(2, 1/8);
620         for(i = 0; i < 128; ++i)
621         {
622                 lengthLogTable[i] = l;
623                 l *= f;
624         }
625
626         if(cvar("developer"))
627         {
628                 print("Verifying vector compression table...\n");
629                 for(i = 0x0F00; i < 0xFFFF; ++i)
630                         if(i != compressShortVector(decompressShortVector(i)))
631                         {
632                                 print("BROKEN vector compression: ", ftos(i));
633                                 print(" -> ", vtos(decompressShortVector(i)));
634                                 print(" -> ", ftos(compressShortVector(decompressShortVector(i))));
635                                 print("\n");
636                                 error("b0rk");
637                         }
638                 print("Done.\n");
639         }
640 }
641
642 #ifndef MENUQC
643 float CheckWireframeBox(entity forent, vector v0, vector dvx, vector dvy, vector dvz)
644 {
645         traceline(v0, v0 + dvx, TRUE, forent); if(trace_fraction < 1) return 0;
646         traceline(v0, v0 + dvy, TRUE, forent); if(trace_fraction < 1) return 0;
647         traceline(v0, v0 + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
648         traceline(v0 + dvx, v0 + dvx + dvy, TRUE, forent); if(trace_fraction < 1) return 0;
649         traceline(v0 + dvx, v0 + dvx + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
650         traceline(v0 + dvy, v0 + dvy + dvx, TRUE, forent); if(trace_fraction < 1) return 0;
651         traceline(v0 + dvy, v0 + dvy + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
652         traceline(v0 + dvz, v0 + dvz + dvx, TRUE, forent); if(trace_fraction < 1) return 0;
653         traceline(v0 + dvz, v0 + dvz + dvy, TRUE, forent); if(trace_fraction < 1) return 0;
654         traceline(v0 + dvx + dvy, v0 + dvx + dvy + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
655         traceline(v0 + dvx + dvz, v0 + dvx + dvy + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
656         traceline(v0 + dvy + dvz, v0 + dvx + dvy + dvz, TRUE, forent); if(trace_fraction < 1) return 0;
657         return 1;
658 }
659 #endif
660
661 string fixPriorityList(string order, float from, float to, float subtract, float complete)
662 {
663         string neworder;
664         float i, n, w;
665
666         n = tokenize_console(order);
667         neworder = "";
668         for(i = 0; i < n; ++i)
669         {
670                 w = stof(argv(i));
671                 if(w == floor(w))
672                 {
673                         if(w >= from && w <= to)
674                                 neworder = strcat(neworder, ftos(w), " ");
675                         else
676                         {
677                                 w -= subtract;
678                                 if(w >= from && w <= to)
679                                         neworder = strcat(neworder, ftos(w), " ");
680                         }
681                 }
682         }
683
684         if(complete)
685         {
686                 n = tokenize_console(neworder);
687                 for(w = to; w >= from; --w)
688                 {
689                         for(i = 0; i < n; ++i)
690                                 if(stof(argv(i)) == w)
691                                         break;
692                         if(i == n) // not found
693                                 neworder = strcat(neworder, ftos(w), " ");
694                 }
695         }
696         
697         return substring(neworder, 0, strlen(neworder) - 1);
698 }
699
700 string mapPriorityList(string order, string(string) mapfunc)
701 {
702         string neworder;
703         float i, n;
704
705         n = tokenize_console(order);
706         neworder = "";
707         for(i = 0; i < n; ++i)
708                 neworder = strcat(neworder, mapfunc(argv(i)), " ");
709         
710         return substring(neworder, 0, strlen(neworder) - 1);
711 }
712
713 string swapInPriorityList(string order, float i, float j)
714 {
715         string s;
716         float w, n;
717
718         n = tokenize_console(order);
719
720         if(i >= 0 && i < n && j >= 0 && j < n && i != j)
721         {
722                 s = "";
723                 for(w = 0; w < n; ++w)
724                 {
725                         if(w == i)
726                                 s = strcat(s, argv(j), " ");
727                         else if(w == j)
728                                 s = strcat(s, argv(i), " ");
729                         else
730                                 s = strcat(s, argv(w), " ");
731                 }
732                 return substring(s, 0, strlen(s) - 1);
733         }
734         
735         return order;
736 }
737
738 float cvar_value_issafe(string s)
739 {
740         if(strstrofs(s, "\"", 0) >= 0)
741                 return 0;
742         if(strstrofs(s, "\\", 0) >= 0)
743                 return 0;
744         if(strstrofs(s, ";", 0) >= 0)
745                 return 0;
746         if(strstrofs(s, "$", 0) >= 0)
747                 return 0;
748         if(strstrofs(s, "\r", 0) >= 0)
749                 return 0;
750         if(strstrofs(s, "\n", 0) >= 0)
751                 return 0;
752         return 1;
753 }
754
755 #ifndef MENUQC
756 void get_mi_min_max(float mode)
757 {
758         vector mi, ma;
759
760         if(mi_shortname)
761                 strunzone(mi_shortname);
762         mi_shortname = mapname;
763         if(!strcasecmp(substring(mi_shortname, 0, 5), "maps/"))
764                 mi_shortname = substring(mi_shortname, 5, strlen(mi_shortname) - 5);
765         if(!strcasecmp(substring(mi_shortname, strlen(mi_shortname) - 4, 4), ".bsp"))
766                 mi_shortname = substring(mi_shortname, 0, strlen(mi_shortname) - 4);
767         mi_shortname = strzone(mi_shortname);
768
769 #ifdef CSQC
770         mi = world.mins;
771         ma = world.maxs;
772 #else
773         mi = world.absmin;
774         ma = world.absmax;
775 #endif
776
777         mi_min = mi;
778         mi_max = ma;
779         MapInfo_Get_ByName(mi_shortname, 0, 0);
780         if(MapInfo_Map_mins_x < MapInfo_Map_maxs_x)
781         {
782                 mi_min = MapInfo_Map_mins;
783                 mi_max = MapInfo_Map_maxs;
784         }
785         else
786         {
787                 // not specified
788                 if(mode)
789                 {
790                         // be clever
791                         tracebox('1 0 0' * mi_x,
792                                          '0 1 0' * mi_y + '0 0 1' * mi_z,
793                                          '0 1 0' * ma_y + '0 0 1' * ma_z,
794                                          '1 0 0' * ma_x,
795                                          MOVE_WORLDONLY,
796                                          world);
797                         if(!trace_startsolid)
798                                 mi_min_x = trace_endpos_x;
799
800                         tracebox('0 1 0' * mi_y,
801                                          '1 0 0' * mi_x + '0 0 1' * mi_z,
802                                          '1 0 0' * ma_x + '0 0 1' * ma_z,
803                                          '0 1 0' * ma_y,
804                                          MOVE_WORLDONLY,
805                                          world);
806                         if(!trace_startsolid)
807                                 mi_min_y = trace_endpos_y;
808
809                         tracebox('0 0 1' * mi_z,
810                                          '1 0 0' * mi_x + '0 1 0' * mi_y,
811                                          '1 0 0' * ma_x + '0 1 0' * ma_y,
812                                          '0 0 1' * ma_z,
813                                          MOVE_WORLDONLY,
814                                          world);
815                         if(!trace_startsolid)
816                                 mi_min_z = trace_endpos_z;
817
818                         tracebox('1 0 0' * ma_x,
819                                          '0 1 0' * mi_y + '0 0 1' * mi_z,
820                                          '0 1 0' * ma_y + '0 0 1' * ma_z,
821                                          '1 0 0' * mi_x,
822                                          MOVE_WORLDONLY,
823                                          world);
824                         if(!trace_startsolid)
825                                 mi_max_x = trace_endpos_x;
826
827                         tracebox('0 1 0' * ma_y,
828                                          '1 0 0' * mi_x + '0 0 1' * mi_z,
829                                          '1 0 0' * ma_x + '0 0 1' * ma_z,
830                                          '0 1 0' * mi_y,
831                                          MOVE_WORLDONLY,
832                                          world);
833                         if(!trace_startsolid)
834                                 mi_max_y = trace_endpos_y;
835
836                         tracebox('0 0 1' * ma_z,
837                                          '1 0 0' * mi_x + '0 1 0' * mi_y,
838                                          '1 0 0' * ma_x + '0 1 0' * ma_y,
839                                          '0 0 1' * mi_z,
840                                          MOVE_WORLDONLY,
841                                          world);
842                         if(!trace_startsolid)
843                                 mi_max_z = trace_endpos_z;
844                 }
845         }
846 }
847
848 void get_mi_min_max_texcoords(float mode)
849 {
850         vector extend;
851
852         get_mi_min_max(mode);
853
854         mi_picmin = mi_min;
855         mi_picmax = mi_max;
856
857         // extend mi_picmax to get a square aspect ratio
858         // center the map in that area
859         extend = mi_picmax - mi_picmin;
860         if(extend_y > extend_x)
861         {
862                 mi_picmin_x -= (extend_y - extend_x) * 0.5;
863                 mi_picmax_x += (extend_y - extend_x) * 0.5;
864         }
865         else
866         {
867                 mi_picmin_y -= (extend_x - extend_y) * 0.5;
868                 mi_picmax_y += (extend_x - extend_y) * 0.5;
869         }
870
871         // add another some percent
872         extend = (mi_picmax - mi_picmin) * (1 / 64.0);
873         mi_picmin -= extend;
874         mi_picmax += extend;
875
876         // calculate the texcoords
877         mi_pictexcoord0 = mi_pictexcoord1 = mi_pictexcoord2 = mi_pictexcoord3 = '0 0 0';
878         // first the two corners of the origin
879         mi_pictexcoord0_x = (mi_min_x - mi_picmin_x) / (mi_picmax_x - mi_picmin_x);
880         mi_pictexcoord0_y = (mi_min_y - mi_picmin_y) / (mi_picmax_y - mi_picmin_y);
881         mi_pictexcoord2_x = (mi_max_x - mi_picmin_x) / (mi_picmax_x - mi_picmin_x);
882         mi_pictexcoord2_y = (mi_max_y - mi_picmin_y) / (mi_picmax_y - mi_picmin_y);
883         // then the other corners
884         mi_pictexcoord1_x = mi_pictexcoord0_x;
885         mi_pictexcoord1_y = mi_pictexcoord2_y;
886         mi_pictexcoord3_x = mi_pictexcoord2_x;
887         mi_pictexcoord3_y = mi_pictexcoord0_y;
888 }
889 #endif
890
891 #ifdef CSQC
892 void cvar_settemp(string pKey, string pValue)
893 {
894         error("cvar_settemp called from CSQC - use cvar_clientsettemp instead!");
895 }
896 void cvar_settemp_restore()
897 {
898         error("cvar_settemp_restore called from CSQC - use cvar_clientsettemp instead!");
899 }
900 #else
901 void cvar_settemp(string pKey, string pValue)
902 {
903         float i;
904         string settemp_var;
905         if(cvar_string(pKey) == pValue)
906                 return;
907         i = cvar("settemp_idx");
908         cvar_set("settemp_idx", ftos(i+1));
909         settemp_var = strcat("_settemp_x", ftos(i));
910 #ifdef MENUQC
911         registercvar(settemp_var, "", 0);
912 #else
913         registercvar(settemp_var, "");
914 #endif
915         cvar_set("settemp_list", strcat("1 ", pKey, " ", settemp_var, " ", cvar_string("settemp_list")));
916         cvar_set(settemp_var, cvar_string(pKey));
917         cvar_set(pKey, pValue);
918 }
919
920 void cvar_settemp_restore()
921 {
922         // undo what cvar_settemp did
923         float n, i;
924         n = tokenize_console(cvar_string("settemp_list"));
925         for(i = 0; i < n - 3; i += 3)
926                 cvar_set(argv(i + 1), cvar_string(argv(i + 2)));
927         cvar_set("settemp_list", "0");
928 }
929 #endif
930
931 float almost_equals(float a, float b)
932 {
933         float eps;
934         eps = (max(a, -a) + max(b, -b)) * 0.001;
935         if(a - b < eps && b - a < eps)
936                 return TRUE;
937         return FALSE;
938 }
939
940 float almost_in_bounds(float a, float b, float c)
941 {
942         float eps;
943         eps = (max(a, -a) + max(c, -c)) * 0.001;
944         return b == median(a - eps, b, c + eps);
945 }
946
947 float power2of(float e)
948 {
949         return pow(2, e);
950 }
951 float log2of(float x)
952 {
953         // NOTE: generated code
954         if(x > 2048)
955                 if(x > 131072)
956                         if(x > 1048576)
957                                 if(x > 4194304)
958                                         return 23;
959                                 else
960                                         if(x > 2097152)
961                                                 return 22;
962                                         else
963                                                 return 21;
964                         else
965                                 if(x > 524288)
966                                         return 20;
967                                 else
968                                         if(x > 262144)
969                                                 return 19;
970                                         else
971                                                 return 18;
972                 else
973                         if(x > 16384)
974                                 if(x > 65536)
975                                         return 17;
976                                 else
977                                         if(x > 32768)
978                                                 return 16;
979                                         else
980                                                 return 15;
981                         else
982                                 if(x > 8192)
983                                         return 14;
984                                 else
985                                         if(x > 4096)
986                                                 return 13;
987                                         else
988                                                 return 12;
989         else
990                 if(x > 32)
991                         if(x > 256)
992                                 if(x > 1024)
993                                         return 11;
994                                 else
995                                         if(x > 512)
996                                                 return 10;
997                                         else
998                                                 return 9;
999                         else
1000                                 if(x > 128)
1001                                         return 8;
1002                                 else
1003                                         if(x > 64)
1004                                                 return 7;
1005                                         else
1006                                                 return 6;
1007                 else
1008                         if(x > 4)
1009                                 if(x > 16)
1010                                         return 5;
1011                                 else
1012                                         if(x > 8)
1013                                                 return 4;
1014                                         else
1015                                                 return 3;
1016                         else
1017                                 if(x > 2)
1018                                         return 2;
1019                                 else
1020                                         if(x > 1)
1021                                                 return 1;
1022                                         else
1023                                                 return 0;
1024 }
1025
1026 float rgb_mi_ma_to_hue(vector rgb, float mi, float ma)
1027 {
1028         if(mi == ma)
1029                 return 0;
1030         else if(ma == rgb_x)
1031         {
1032                 if(rgb_y >= rgb_z)
1033                         return (rgb_y - rgb_z) / (ma - mi);
1034                 else
1035                         return (rgb_y - rgb_z) / (ma - mi) + 6;
1036         }
1037         else if(ma == rgb_y)
1038                 return (rgb_z - rgb_x) / (ma - mi) + 2;
1039         else // if(ma == rgb_z)
1040                 return (rgb_x - rgb_y) / (ma - mi) + 4;
1041 }
1042
1043 vector hue_mi_ma_to_rgb(float hue, float mi, float ma)
1044 {
1045         vector rgb;
1046
1047         hue -= 6 * floor(hue / 6);
1048
1049         //else if(ma == rgb_x)
1050         //      hue = 60 * (rgb_y - rgb_z) / (ma - mi);
1051         if(hue <= 1)
1052         {
1053                 rgb_x = ma;
1054                 rgb_y = hue * (ma - mi) + mi;
1055                 rgb_z = mi;
1056         }
1057         //else if(ma == rgb_y)
1058         //      hue = 60 * (rgb_z - rgb_x) / (ma - mi) + 120;
1059         else if(hue <= 2)
1060         {
1061                 rgb_x = (2 - hue) * (ma - mi) + mi;
1062                 rgb_y = ma;
1063                 rgb_z = mi;
1064         }
1065         else if(hue <= 3)
1066         {
1067                 rgb_x = mi;
1068                 rgb_y = ma;
1069                 rgb_z = (hue - 2) * (ma - mi) + mi;
1070         }
1071         //else // if(ma == rgb_z)
1072         //      hue = 60 * (rgb_x - rgb_y) / (ma - mi) + 240;
1073         else if(hue <= 4)
1074         {
1075                 rgb_x = mi;
1076                 rgb_y = (4 - hue) * (ma - mi) + mi;
1077                 rgb_z = ma;
1078         }
1079         else if(hue <= 5)
1080         {
1081                 rgb_x = (hue - 4) * (ma - mi) + mi;
1082                 rgb_y = mi;
1083                 rgb_z = ma;
1084         }
1085         //else if(ma == rgb_x)
1086         //      hue = 60 * (rgb_y - rgb_z) / (ma - mi);
1087         else // if(hue <= 6)
1088         {
1089                 rgb_x = ma;
1090                 rgb_y = mi;
1091                 rgb_z = (6 - hue) * (ma - mi) + mi;
1092         }
1093
1094         return rgb;
1095 }
1096
1097 vector rgb_to_hsv(vector rgb)
1098 {
1099         float mi, ma;
1100         vector hsv;
1101
1102         mi = min3(rgb_x, rgb_y, rgb_z);
1103         ma = max3(rgb_x, rgb_y, rgb_z);
1104
1105         hsv_x = rgb_mi_ma_to_hue(rgb, mi, ma);
1106         hsv_z = ma;
1107
1108         if(ma == 0)
1109                 hsv_y = 0;
1110         else
1111                 hsv_y = 1 - mi/ma;
1112         
1113         return hsv;
1114 }
1115
1116 vector hsv_to_rgb(vector hsv)
1117 {
1118         return hue_mi_ma_to_rgb(hsv_x, hsv_z * (1 - hsv_y), hsv_z);
1119 }
1120
1121 vector rgb_to_hsl(vector rgb)
1122 {
1123         float mi, ma;
1124         vector hsl;
1125
1126         mi = min3(rgb_x, rgb_y, rgb_z);
1127         ma = max3(rgb_x, rgb_y, rgb_z);
1128
1129         hsl_x = rgb_mi_ma_to_hue(rgb, mi, ma);
1130         
1131         hsl_z = 0.5 * (mi + ma);
1132         if(mi == ma)
1133                 hsl_y = 0;
1134         else if(hsl_z <= 0.5)
1135                 hsl_y = (ma - mi) / (2*hsl_z);
1136         else // if(hsl_z > 0.5)
1137                 hsl_y = (ma - mi) / (2 - 2*hsl_z);
1138         
1139         return hsl;
1140 }
1141
1142 vector hsl_to_rgb(vector hsl)
1143 {
1144         float mi, ma, maminusmi;
1145
1146         if(hsl_z <= 0.5)
1147                 maminusmi = hsl_y * 2 * hsl_z;
1148         else
1149                 maminusmi = hsl_y * (2 - 2 * hsl_z);
1150         
1151         // hsl_z     = 0.5 * mi + 0.5 * ma
1152         // maminusmi =     - mi +       ma
1153         mi = hsl_z - 0.5 * maminusmi;
1154         ma = hsl_z + 0.5 * maminusmi;
1155
1156         return hue_mi_ma_to_rgb(hsl_x, mi, ma);
1157 }
1158
1159 string rgb_to_hexcolor(vector rgb)
1160 {
1161         return
1162                 strcat(
1163                         "^x",
1164                         DEC_TO_HEXDIGIT(floor(rgb_x * 15 + 0.5)),
1165                         DEC_TO_HEXDIGIT(floor(rgb_y * 15 + 0.5)),
1166                         DEC_TO_HEXDIGIT(floor(rgb_z * 15 + 0.5))
1167                 );
1168 }
1169
1170 // requires that m2>m1 in all coordinates, and that m4>m3
1171 float boxesoverlap(vector m1, vector m2, vector m3, vector m4) {return m2_x >= m3_x && m1_x <= m4_x && m2_y >= m3_y && m1_y <= m4_y && m2_z >= m3_z && m1_z <= m4_z;};
1172
1173 // requires the same, but is a stronger condition
1174 float boxinsidebox(vector smins, vector smaxs, vector bmins, vector bmaxs) {return smins_x >= bmins_x && smaxs_x <= bmaxs_x && smins_y >= bmins_y && smaxs_y <= bmaxs_y && smins_z >= bmins_z && smaxs_z <= bmaxs_z;};
1175
1176 #ifndef MENUQC
1177 #endif
1178
1179 float textLengthUpToWidth(string theText, float maxWidth, vector theSize, textLengthUpToWidth_widthFunction_t w)
1180 {
1181         float ICanHasKallerz;
1182
1183         // detect color codes support in the width function
1184         ICanHasKallerz = (w("^7", theSize) == 0);
1185
1186         // STOP.
1187         // The following function is SLOW.
1188         // For your safety and for the protection of those around you...
1189         // DO NOT CALL THIS AT HOME.
1190         // No really, don't.
1191         if(w(theText, theSize) <= maxWidth)
1192                 return strlen(theText); // yeah!
1193
1194         // binary search for right place to cut string
1195         float ch;
1196         float left, right, middle; // this always works
1197         left = 0;
1198         right = strlen(theText); // this always fails
1199         do
1200         {
1201                 middle = floor((left + right) / 2);
1202                 if(w(substring(theText, 0, middle), theSize) <= maxWidth)
1203                         left = middle;
1204                 else
1205                         right = middle;
1206         }
1207         while(left < right - 1);
1208
1209         if(ICanHasKallerz)
1210         {
1211                 // NOTE: when color codes are involved, this binary search is,
1212                 // mathematically, BROKEN. However, it is obviously guaranteed to
1213                 // terminate, as the range still halves each time - but nevertheless, it is
1214                 // guaranteed that it finds ONE valid cutoff place (where "left" is in
1215                 // range, and "right" is outside).
1216                 
1217                 // terencehill: the following code detects truncated ^xrgb tags (e.g. ^x or ^x4)
1218                 // and decrease left on the basis of the chars detected of the truncated tag
1219                 // Even if the ^xrgb tag is not complete/correct, left is decreased
1220                 // (sometimes too much but with a correct result)
1221                 // it fixes also ^[0-9]
1222                 while(left >= 1 && substring(theText, left-1, 1) == "^")
1223                         left-=1;
1224
1225                 if (left >= 2 && substring(theText, left-2, 2) == "^x") // ^x/
1226                         left-=2;
1227                 else if (left >= 3 && substring(theText, left-3, 2) == "^x")
1228                         {
1229                                 ch = str2chr(theText, left-1);
1230                                 if( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') ) // ^xr/
1231                                         left-=3;
1232                         }
1233                 else if (left >= 4 && substring(theText, left-4, 2) == "^x")
1234                         {
1235                                 ch = str2chr(theText, left-2);
1236                                 if ( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') )
1237                                 {
1238                                         ch = str2chr(theText, left-1);
1239                                         if ( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') ) // ^xrg/
1240                                                 left-=4;
1241                                 }
1242                         }
1243         }
1244         
1245         return left;
1246 }
1247
1248 float textLengthUpToLength(string theText, float maxWidth, textLengthUpToLength_lenFunction_t w)
1249 {
1250         float ICanHasKallerz;
1251
1252         // detect color codes support in the width function
1253         ICanHasKallerz = (w("^7") == 0);
1254
1255         // STOP.
1256         // The following function is SLOW.
1257         // For your safety and for the protection of those around you...
1258         // DO NOT CALL THIS AT HOME.
1259         // No really, don't.
1260         if(w(theText) <= maxWidth)
1261                 return strlen(theText); // yeah!
1262
1263         // binary search for right place to cut string
1264         float ch;
1265         float left, right, middle; // this always works
1266         left = 0;
1267         right = strlen(theText); // this always fails
1268         do
1269         {
1270                 middle = floor((left + right) / 2);
1271                 if(w(substring(theText, 0, middle)) <= maxWidth)
1272                         left = middle;
1273                 else
1274                         right = middle;
1275         }
1276         while(left < right - 1);
1277
1278         if(ICanHasKallerz)
1279         {
1280                 // NOTE: when color codes are involved, this binary search is,
1281                 // mathematically, BROKEN. However, it is obviously guaranteed to
1282                 // terminate, as the range still halves each time - but nevertheless, it is
1283                 // guaranteed that it finds ONE valid cutoff place (where "left" is in
1284                 // range, and "right" is outside).
1285                 
1286                 // terencehill: the following code detects truncated ^xrgb tags (e.g. ^x or ^x4)
1287                 // and decrease left on the basis of the chars detected of the truncated tag
1288                 // Even if the ^xrgb tag is not complete/correct, left is decreased
1289                 // (sometimes too much but with a correct result)
1290                 // it fixes also ^[0-9]
1291                 while(left >= 1 && substring(theText, left-1, 1) == "^")
1292                         left-=1;
1293
1294                 if (left >= 2 && substring(theText, left-2, 2) == "^x") // ^x/
1295                         left-=2;
1296                 else if (left >= 3 && substring(theText, left-3, 2) == "^x")
1297                         {
1298                                 ch = str2chr(theText, left-1);
1299                                 if( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') ) // ^xr/
1300                                         left-=3;
1301                         }
1302                 else if (left >= 4 && substring(theText, left-4, 2) == "^x")
1303                         {
1304                                 ch = str2chr(theText, left-2);
1305                                 if ( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') )
1306                                 {
1307                                         ch = str2chr(theText, left-1);
1308                                         if ( (ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F') ) // ^xrg/
1309                                                 left-=4;
1310                                 }
1311                         }
1312         }
1313         
1314         return left;
1315 }
1316
1317 string getWrappedLine(float w, vector theFontSize, textLengthUpToWidth_widthFunction_t tw)
1318 {
1319         float cantake;
1320         float take;
1321         string s;
1322
1323         s = getWrappedLine_remaining;
1324
1325         cantake = textLengthUpToWidth(s, w, theFontSize, tw);
1326         if(cantake > 0 && cantake < strlen(s))
1327         {
1328                 take = cantake - 1;
1329                 while(take > 0 && substring(s, take, 1) != " ")
1330                         --take;
1331                 if(take == 0)
1332                 {
1333                         getWrappedLine_remaining = substring(s, cantake, strlen(s) - cantake);
1334                         if(getWrappedLine_remaining == "")
1335                                 getWrappedLine_remaining = string_null;
1336                         return substring(s, 0, cantake);
1337                 }
1338                 else
1339                 {
1340                         getWrappedLine_remaining = substring(s, take + 1, strlen(s) - take);
1341                         if(getWrappedLine_remaining == "")
1342                                 getWrappedLine_remaining = string_null;
1343                         return substring(s, 0, take);
1344                 }
1345         }
1346         else
1347         {
1348                 getWrappedLine_remaining = string_null;
1349                 return s;
1350         }
1351 }
1352
1353 string getWrappedLineLen(float w, textLengthUpToLength_lenFunction_t tw)
1354 {
1355         float cantake;
1356         float take;
1357         string s;
1358
1359         s = getWrappedLine_remaining;
1360
1361         cantake = textLengthUpToLength(s, w, tw);
1362         if(cantake > 0 && cantake < strlen(s))
1363         {
1364                 take = cantake - 1;
1365                 while(take > 0 && substring(s, take, 1) != " ")
1366                         --take;
1367                 if(take == 0)
1368                 {
1369                         getWrappedLine_remaining = substring(s, cantake, strlen(s) - cantake);
1370                         if(getWrappedLine_remaining == "")
1371                                 getWrappedLine_remaining = string_null;
1372                         return substring(s, 0, cantake);
1373                 }
1374                 else
1375                 {
1376                         getWrappedLine_remaining = substring(s, take + 1, strlen(s) - take);
1377                         if(getWrappedLine_remaining == "")
1378                                 getWrappedLine_remaining = string_null;
1379                         return substring(s, 0, take);
1380                 }
1381         }
1382         else
1383         {
1384                 getWrappedLine_remaining = string_null;
1385                 return s;
1386         }
1387 }
1388
1389 string textShortenToWidth(string theText, float maxWidth, vector theFontSize, textLengthUpToWidth_widthFunction_t tw)
1390 {
1391         if(tw(theText, theFontSize) <= maxWidth)
1392                 return theText;
1393         else
1394                 return strcat(substring(theText, 0, textLengthUpToWidth(theText, maxWidth - tw("...", theFontSize), theFontSize, tw)), "...");
1395 }
1396
1397 string textShortenToLength(string theText, float maxWidth, textLengthUpToLength_lenFunction_t tw)
1398 {
1399         if(tw(theText) <= maxWidth)
1400                 return theText;
1401         else
1402                 return strcat(substring(theText, 0, textLengthUpToLength(theText, maxWidth - tw("..."), tw)), "...");
1403 }
1404
1405 float isGametypeInFilter(float gt, float tp, string pattern)
1406 {
1407         string subpattern, subpattern2, subpattern3;
1408         subpattern = strcat(",", GametypeNameFromType(gt), ",");
1409         if(tp)
1410                 subpattern2 = ",teams,";
1411         else
1412                 subpattern2 = ",noteams,";
1413         if(gt == GAME_RACE || gt == GAME_CTS)
1414                 subpattern3 = ",race,";
1415         else
1416                 subpattern3 = string_null;
1417
1418         if(substring(pattern, 0, 1) == "-")
1419         {
1420                 pattern = substring(pattern, 1, strlen(pattern) - 1);
1421                 if(strstrofs(strcat(",", pattern, ","), subpattern, 0) >= 0)
1422                         return 0;
1423                 if(strstrofs(strcat(",", pattern, ","), subpattern2, 0) >= 0)
1424                         return 0;
1425                 if(subpattern3 && strstrofs(strcat(",", pattern, ","), subpattern3, 0) >= 0)
1426                         return 0;
1427         }
1428         else
1429         {
1430                 if(substring(pattern, 0, 1) == "+")
1431                         pattern = substring(pattern, 1, strlen(pattern) - 1);
1432                 if(strstrofs(strcat(",", pattern, ","), subpattern, 0) < 0)
1433                 if(strstrofs(strcat(",", pattern, ","), subpattern2, 0) < 0)
1434                 if((!subpattern3) || strstrofs(strcat(",", pattern, ","), subpattern3, 0) < 0)
1435                         return 0;
1436         }
1437         return 1;
1438 }
1439
1440 void shuffle(float n, swapfunc_t swap, entity pass)
1441 {
1442         float i, j;
1443         for(i = 1; i < n; ++i)
1444         {
1445                 // swap i-th item at a random position from 0 to i
1446                 // proof for even distribution:
1447                 //   n = 1: obvious
1448                 //   n -> n+1:
1449                 //     item n+1 gets at any position with chance 1/(n+1)
1450                 //     all others will get their 1/n chance reduced by factor n/(n+1)
1451                 //     to be on place n+1, their chance will be 1/(n+1)
1452                 //     1/n * n/(n+1) = 1/(n+1)
1453                 //     q.e.d.
1454                 j = floor(random() * (i + 1));
1455                 if(j != i)
1456                         swap(j, i, pass);
1457         }
1458 }
1459
1460 string substring_range(string s, float b, float e)
1461 {
1462         return substring(s, b, e - b);
1463 }
1464
1465 string swapwords(string str, float i, float j)
1466 {
1467         float n;
1468         string s1, s2, s3, s4, s5;
1469         float si, ei, sj, ej, s0, en;
1470         n = tokenizebyseparator(str, " "); // must match g_maplist processing in ShuffleMaplist and "shuffle"
1471         si = argv_start_index(i);
1472         sj = argv_start_index(j);
1473         ei = argv_end_index(i);
1474         ej = argv_end_index(j);
1475         s0 = argv_start_index(0);
1476         en = argv_end_index(n-1);
1477         s1 = substring_range(str, s0, si);
1478         s2 = substring_range(str, si, ei);
1479         s3 = substring_range(str, ei, sj);
1480         s4 = substring_range(str, sj, ej);
1481         s5 = substring_range(str, ej, en);
1482         return strcat(s1, s4, s3, s2, s5);
1483 }
1484
1485 string _shufflewords_str;
1486 void _shufflewords_swapfunc(float i, float j, entity pass)
1487 {
1488         _shufflewords_str = swapwords(_shufflewords_str, i, j);
1489 }
1490 string shufflewords(string str)
1491 {
1492         float n;
1493         _shufflewords_str = str;
1494         n = tokenizebyseparator(str, " ");
1495         shuffle(n, _shufflewords_swapfunc, world);
1496         str = _shufflewords_str;
1497         _shufflewords_str = string_null;
1498         return str;
1499 }
1500
1501 vector solve_quadratic(float a, float b, float c) // ax^2 + bx + c = 0
1502 {
1503         vector v;
1504         float D;
1505         v = '0 0 0';
1506         if(a == 0)
1507         {
1508                 if(b != 0)
1509                 {
1510                         v_x = v_y = -c / b;
1511                         v_z = 1;
1512                 }
1513                 else
1514                 {
1515                         if(c == 0)
1516                         {
1517                                 // actually, every number solves the equation!
1518                                 v_z = 1;
1519                         }
1520                 }
1521         }
1522         else
1523         {
1524                 D = b*b - 4*a*c;
1525                 if(D >= 0)
1526                 {
1527                         D = sqrt(D);
1528                         if(a > 0) // put the smaller solution first
1529                         {
1530                                 v_x = ((-b)-D) / (2*a);
1531                                 v_y = ((-b)+D) / (2*a);
1532                         }
1533                         else
1534                         {
1535                                 v_x = (-b+D) / (2*a);
1536                                 v_y = (-b-D) / (2*a);
1537                         }
1538                         v_z = 1;
1539                 }
1540                 else
1541                 {
1542                         // complex solutions!
1543                         D = sqrt(-D);
1544                         v_x = -b / (2*a);
1545                         if(a > 0)
1546                                 v_y =  D / (2*a);
1547                         else
1548                                 v_y = -D / (2*a);
1549                         v_z = 0;
1550                 }
1551         }
1552         return v;
1553 }
1554
1555
1556 float _unacceptable_compiler_bug_1_a(float b, float c) { return b == c; }
1557 float _unacceptable_compiler_bug_1_b() { return 1; }
1558 float _unacceptable_compiler_bug_1_c(float d) { return 2 * d; }
1559 float _unacceptable_compiler_bug_1_d() { return 1; }
1560
1561 void check_unacceptable_compiler_bugs()
1562 {
1563         if(cvar("_allow_unacceptable_compiler_bugs"))
1564                 return;
1565         tokenize_console("foo bar");
1566         if(strcat(argv(0), substring("foo bar", 4, 7 - argv_start_index(1))) == "barbar")
1567                 error("fteqcc bug introduced with revision 3178 detected. Please upgrade fteqcc to a later revision, downgrade fteqcc to revision 3177, or pester Spike until he fixes it. You can set _allow_unacceptable_compiler_bugs 1 to skip this check, but expect stuff to be horribly broken then.");
1568 }
1569
1570 float compressShotOrigin(vector v)
1571 {
1572         float x, y, z;
1573         x = rint(v_x * 2);
1574         y = rint(v_y * 4) + 128;
1575         z = rint(v_z * 4) + 128;
1576         if(x > 255 || x < 0)
1577         {
1578                 print("shot origin ", vtos(v), " x out of bounds\n");
1579                 x = bound(0, x, 255);
1580         }
1581         if(y > 255 || y < 0)
1582         {
1583                 print("shot origin ", vtos(v), " y out of bounds\n");
1584                 y = bound(0, y, 255);
1585         }
1586         if(z > 255 || z < 0)
1587         {
1588                 print("shot origin ", vtos(v), " z out of bounds\n");
1589                 z = bound(0, z, 255);
1590         }
1591         return x * 0x10000 + y * 0x100 + z;
1592 }
1593 vector decompressShotOrigin(float f)
1594 {
1595         vector v;
1596         v_x = ((f & 0xFF0000) / 0x10000) / 2;
1597         v_y = ((f & 0xFF00) / 0x100 - 128) / 4;
1598         v_z = ((f & 0xFF) - 128) / 4;
1599         return v;
1600 }
1601
1602 void heapsort(float n, swapfunc_t swap, comparefunc_t cmp, entity pass)
1603 {
1604         float start, end, root, child;
1605
1606         // heapify
1607         start = floor((n - 2) / 2);
1608         while(start >= 0)
1609         {
1610                 // siftdown(start, count-1);
1611                 root = start;
1612                 while(root * 2 + 1 <= n-1)
1613                 {
1614                         child = root * 2 + 1;
1615                         if(child < n-1)
1616                                 if(cmp(child, child+1, pass) < 0)
1617                                         ++child;
1618                         if(cmp(root, child, pass) < 0)
1619                         {
1620                                 swap(root, child, pass);
1621                                 root = child;
1622                         }
1623                         else
1624                                 break;
1625                 }
1626                 // end of siftdown
1627                 --start;
1628         }
1629
1630         // extract
1631         end = n - 1;
1632         while(end > 0)
1633         {
1634                 swap(0, end, pass);
1635                 --end;
1636                 // siftdown(0, end);
1637                 root = 0;
1638                 while(root * 2 + 1 <= end)
1639                 {
1640                         child = root * 2 + 1;
1641                         if(child < end && cmp(child, child+1, pass) < 0)
1642                                 ++child;
1643                         if(cmp(root, child, pass) < 0)
1644                         {
1645                                 swap(root, child, pass);
1646                                 root = child;
1647                         }
1648                         else
1649                                 break;
1650                 }
1651                 // end of siftdown
1652         }
1653 }
1654
1655 void RandomSelection_Init()
1656 {
1657         RandomSelection_totalweight = 0;
1658         RandomSelection_chosen_ent = world;
1659         RandomSelection_chosen_float = 0;
1660         RandomSelection_chosen_string = string_null;
1661         RandomSelection_best_priority = -1;
1662 }
1663 void RandomSelection_Add(entity e, float f, string s, float weight, float priority)
1664 {
1665         if(priority > RandomSelection_best_priority)
1666         {
1667                 RandomSelection_best_priority = priority;
1668                 RandomSelection_chosen_ent = e;
1669                 RandomSelection_chosen_float = f;
1670                 RandomSelection_chosen_string = s;
1671                 RandomSelection_totalweight = weight;
1672         }
1673         else if(priority == RandomSelection_best_priority)
1674         {
1675                 RandomSelection_totalweight += weight;
1676                 if(random() * RandomSelection_totalweight <= weight)
1677                 {
1678                         RandomSelection_chosen_ent = e;
1679                         RandomSelection_chosen_float = f;
1680                         RandomSelection_chosen_string = s;
1681                 }
1682         }
1683 }
1684
1685 vector healtharmor_maxdamage(float h, float a, float armorblock)
1686 {
1687         // NOTE: we'll always choose the SMALLER value...
1688         float healthdamage, armordamage, armorideal;
1689         vector v;
1690         healthdamage = (h - 1) / (1 - armorblock); // damage we can take if we could use more health
1691         armordamage = a + (h - 1); // damage we can take if we could use more armor
1692         armorideal = healthdamage * armorblock;
1693         v_y = armorideal;
1694         if(armordamage < healthdamage)
1695         {
1696                 v_x = armordamage;
1697                 v_z = 1;
1698         }
1699         else
1700         {
1701                 v_x = healthdamage;
1702                 v_z = 0;
1703         }
1704         return v;
1705 }
1706
1707 vector healtharmor_applydamage(float a, float armorblock, float damage)
1708 {
1709         vector v;
1710         v_y = bound(0, damage * armorblock, a); // save
1711         v_x = bound(0, damage - v_y, damage); // take
1712         v_z = 0;
1713         return v;
1714 }
1715
1716 string getcurrentmod()
1717 {
1718         float n;
1719         string m;
1720         m = cvar_string("fs_gamedir");
1721         n = tokenize_console(m);
1722         if(n == 0)
1723                 return "data";
1724         else
1725                 return argv(n - 1);
1726 }
1727
1728 #ifndef MENUQC
1729 #ifdef CSQC
1730 float ReadInt24_t()
1731 {
1732         float v;
1733         v = ReadShort() * 256; // note: this is signed
1734         v += ReadByte(); // note: this is unsigned
1735         return v;
1736 }
1737 #else
1738 void WriteInt24_t(float dest, float val)
1739 {
1740         float v;
1741         WriteShort(dest, (v = floor(val / 256)));
1742         WriteByte(dest, val - v * 256); // 0..255
1743 }
1744 #endif
1745 #endif
1746
1747 float float2range11(float f)
1748 {
1749         // continuous function mapping all reals into -1..1
1750         return f / (fabs(f) + 1);
1751 }
1752
1753 float float2range01(float f)
1754 {
1755         // continuous function mapping all reals into 0..1
1756         return 0.5 + 0.5 * float2range11(f);
1757 }
1758
1759 // from the GNU Scientific Library
1760 float gsl_ran_gaussian_lastvalue;
1761 float gsl_ran_gaussian_lastvalue_set;
1762 float gsl_ran_gaussian(float sigma)
1763 {
1764         float a, b;
1765         if(gsl_ran_gaussian_lastvalue_set)
1766         {
1767                 gsl_ran_gaussian_lastvalue_set = 0;
1768                 return sigma * gsl_ran_gaussian_lastvalue;
1769         }
1770         else
1771         {
1772                 a = random() * 2 * M_PI;
1773                 b = sqrt(-2 * log(random()));
1774                 gsl_ran_gaussian_lastvalue = cos(a) * b;
1775                 gsl_ran_gaussian_lastvalue_set = 1;
1776                 return sigma * sin(a) * b;
1777         }
1778 }
1779
1780 string car(string s)
1781 {
1782         float o;
1783         o = strstrofs(s, " ", 0);
1784         if(o < 0)
1785                 return s;
1786         return substring(s, 0, o);
1787 }
1788 string cdr(string s)
1789 {
1790         float o;
1791         o = strstrofs(s, " ", 0);
1792         if(o < 0)
1793                 return string_null;
1794         return substring(s, o + 1, strlen(s) - (o + 1));
1795 }
1796 float matchacl(string acl, string str)
1797 {
1798         string t, s;
1799         float r, d;
1800         r = 0;
1801         while(acl)
1802         {
1803                 t = car(acl); acl = cdr(acl);
1804                 d = 1;
1805                 if(substring(t, 0, 1) == "-")
1806                 {
1807                         d = -1;
1808                         t = substring(t, 1, strlen(t) - 1);
1809                 }
1810                 else if(substring(t, 0, 1) == "+")
1811                         t = substring(t, 1, strlen(t) - 1);
1812                 if(substring(t, -1, 1) == "*")
1813                 {
1814                         t = substring(t, 0, strlen(t) - 1);
1815                         s = substring(s, 0, strlen(t));
1816                 }
1817                 else
1818                         s = str;
1819
1820                 if(s == t)
1821                 {
1822                         r = d;
1823                 }
1824         }
1825         return r;
1826 }
1827 float startsWith(string haystack, string needle)
1828 {
1829         return substring(haystack, 0, strlen(needle)) == needle;
1830 }
1831 float startsWithNocase(string haystack, string needle)
1832 {
1833         return strcasecmp(substring(haystack, 0, strlen(needle)), needle) == 0;
1834 }
1835
1836 string get_model_datafilename(string m, float sk, string fil)
1837 {
1838         if(m)
1839                 m = strcat(m, "_");
1840         else
1841                 m = "models/player/*_";
1842         if(sk >= 0)
1843                 m = strcat(m, ftos(sk));
1844         else
1845                 m = strcat(m, "*");
1846         return strcat(m, ".", fil);
1847 }
1848
1849 float get_model_parameters(string m, float sk)
1850 {
1851         string fn, s, c;
1852         float fh;
1853
1854         get_model_parameters_modelname = string_null;
1855         get_model_parameters_modelskin = -1;
1856         get_model_parameters_name = string_null;
1857         get_model_parameters_species = -1;
1858         get_model_parameters_sex = string_null;
1859         get_model_parameters_weight = -1;
1860         get_model_parameters_age = -1;
1861         get_model_parameters_desc = string_null;
1862
1863         if not(m)
1864                 return 1;
1865         if(sk < 0)
1866         {
1867                 if(substring(m, -4, -1) != ".txt")
1868                         return 0;
1869                 if(substring(m, -6, 1) != "_")
1870                         return 0;
1871                 sk = stof(substring(m, -5, 1));
1872                 m = substring(m, 0, -7);
1873         }
1874
1875         fn = get_model_datafilename(m, sk, "txt");
1876         fh = fopen(fn, FILE_READ);
1877         if(fh < 0)
1878                 return 0;
1879
1880         get_model_parameters_modelname = m;
1881         get_model_parameters_modelskin = sk;
1882         while((s = fgets(fh)))
1883         {
1884                 if(s == "")
1885                         break; // next lines will be description
1886                 c = car(s);
1887                 s = cdr(s);
1888                 if(c == "name")
1889                         get_model_parameters_name = s;
1890                 if(c == "species")
1891                         switch(s)
1892                         {
1893                                 case "human":       get_model_parameters_species = SPECIES_HUMAN;       break;
1894                                 case "alien":       get_model_parameters_species = SPECIES_ALIEN;       break;
1895                                 case "robot_shiny": get_model_parameters_species = SPECIES_ROBOT_SHINY; break;
1896                                 case "robot_rusty": get_model_parameters_species = SPECIES_ROBOT_RUSTY; break;
1897                                 case "robot_solid": get_model_parameters_species = SPECIES_ROBOT_SOLID; break;
1898                                 case "animal":      get_model_parameters_species = SPECIES_ANIMAL;      break;
1899                                 case "reserved":    get_model_parameters_species = SPECIES_RESERVED;    break;
1900                         }
1901                 if(c == "sex")
1902                         get_model_parameters_sex = s;
1903                 if(c == "weight")
1904                         get_model_parameters_weight = stof(s);
1905                 if(c == "age")
1906                         get_model_parameters_age = stof(s);
1907         }
1908
1909         while((s = fgets(fh)))
1910         {
1911                 if(get_model_parameters_desc)
1912                         get_model_parameters_desc = strcat(get_model_parameters_desc, "\n");
1913                 if(s != "")
1914                         get_model_parameters_desc = strcat(get_model_parameters_desc, s);
1915         }
1916
1917         fclose(fh);
1918
1919         return 1;
1920 }
1921
1922 vector vec2(vector v)
1923 {
1924         v_z = 0;
1925         return v;
1926 }
1927
1928 #ifndef MENUQC
1929 vector NearestPointOnBox(entity box, vector org)
1930 {
1931         vector m1, m2, nearest;
1932
1933         m1 = box.mins + box.origin;
1934         m2 = box.maxs + box.origin;
1935
1936         nearest_x = bound(m1_x, org_x, m2_x);
1937         nearest_y = bound(m1_y, org_y, m2_y);
1938         nearest_z = bound(m1_z, org_z, m2_z);
1939
1940         return nearest;
1941 }
1942 #endif
1943
1944 float vercmp_recursive(string v1, string v2)
1945 {
1946         float dot1, dot2;
1947         string s1, s2;
1948         float r;
1949
1950         dot1 = strstrofs(v1, ".", 0);
1951         dot2 = strstrofs(v2, ".", 0);
1952         if(dot1 == -1)
1953                 s1 = v1;
1954         else
1955                 s1 = substring(v1, 0, dot1);
1956         if(dot2 == -1)
1957                 s2 = v2;
1958         else
1959                 s2 = substring(v2, 0, dot2);
1960
1961         r = stof(s1) - stof(s2);
1962         if(r != 0)
1963                 return r;
1964
1965         r = strcasecmp(s1, s2);
1966         if(r != 0)
1967                 return r;
1968
1969         if(dot1 == -1)
1970                 if(dot2 == -1)
1971                         return 0;
1972                 else
1973                         return -1;
1974         else
1975                 if(dot2 == -1)
1976                         return 1;
1977                 else
1978                         return vercmp_recursive(substring(v1, dot1 + 1, 999), substring(v2, dot2 + 1, 999));
1979 }
1980
1981 float vercmp(string v1, string v2)
1982 {
1983         if(strcasecmp(v1, v2) == 0) // early out check
1984                 return 0;
1985
1986         // "git" beats all
1987         if(v1 == "git")
1988                 return 1;
1989         if(v2 == "git")
1990                 return -1;
1991
1992         return vercmp_recursive(v1, v2);
1993 }