- add a "frustrating" flag to race maps in mapinfo so they are not playable by default
[divverent/nexuiz.git] / data / qcsrc / common / mapinfo.qc
1 // generic string stuff
2 float startsWith(string haystack, string needle)
3 {
4         return substring(haystack, 0, strlen(needle)) == needle;
5 }
6 float startsWithNocase(string haystack, string needle)
7 {
8         return strcasecmp(substring(haystack, 0, strlen(needle)), needle) == 0;
9 }
10 string extractRestOfLine(string haystack, string needle)
11 {
12         if(startsWith(haystack, needle))
13                 return substring(haystack, strlen(needle), strlen(haystack) - strlen(needle));
14         return string_null;
15 }
16 string car(string s)
17 {
18         float o;
19         o = strstrofs(s, " ", 0);
20         if(o < 0)
21                 return s;
22         return substring(s, 0, o);
23 }
24 string cdr(string s)
25 {
26         float o;
27         o = strstrofs(s, " ", 0);
28         if(o < 0)
29                 return string_null;
30         return substring(s, o + 1, strlen(s) - (o + 1));
31 }
32
33 float _MapInfo_Cache_Active;
34 float _MapInfo_Cache_DB_NameToIndex;
35 float _MapInfo_Cache_Buf_IndexToMapData;
36
37 void MapInfo_Cache_Destroy()
38 {
39         if(!_MapInfo_Cache_Active)
40                 return;
41
42         db_close(_MapInfo_Cache_DB_NameToIndex);
43         buf_del(_MapInfo_Cache_Buf_IndexToMapData);
44         _MapInfo_Cache_Active = 0;
45 }
46
47 void MapInfo_Cache_Create()
48 {
49         MapInfo_Cache_Destroy();
50         _MapInfo_Cache_DB_NameToIndex = db_create();
51         _MapInfo_Cache_Buf_IndexToMapData = buf_create();
52         _MapInfo_Cache_Active = 1;
53 }
54
55 void MapInfo_Cache_Invalidate()
56 {
57         if(!_MapInfo_Cache_Active)
58                 return;
59
60         MapInfo_Cache_Create();
61 }
62
63 void MapInfo_Cache_Store()
64 {
65         float i;
66         string s;
67         if(!_MapInfo_Cache_Active)
68                 return;
69
70         s = db_get(_MapInfo_Cache_DB_NameToIndex, MapInfo_Map_bspname);
71         if(!s) // empty string is NOT valid here!
72         {
73                 i = buf_getsize(_MapInfo_Cache_Buf_IndexToMapData);
74                 db_put(_MapInfo_Cache_DB_NameToIndex, MapInfo_Map_bspname, ftos(i));
75         }
76         else
77                 i = stof(s);
78
79         // now store all the stuff
80         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData,   i, MapInfo_Map_bspname);
81         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, MapInfo_Map_title);
82         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, MapInfo_Map_description);
83         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, MapInfo_Map_author);
84         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, ftos(MapInfo_Map_supportedGametypes));
85         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, ftos(MapInfo_Map_supportedFeatures));
86         bufstr_set(_MapInfo_Cache_Buf_IndexToMapData, ++i, ftos(MapInfo_Map_flags));
87 }
88
89 float MapInfo_Cache_Retrieve(string map)
90 {
91         float i;
92         string s;
93         if(!_MapInfo_Cache_Active)
94                 return 0;
95
96         s = db_get(_MapInfo_Cache_DB_NameToIndex, map);
97         if(!s)
98                 return 0;
99         i = stof(s);
100
101         // now retrieve all the stuff
102         MapInfo_Map_bspname = bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, i);
103         MapInfo_Map_title = bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i);
104         MapInfo_Map_description = bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i);
105         MapInfo_Map_author = bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i);
106         MapInfo_Map_supportedGametypes = stof(bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i));
107         MapInfo_Map_supportedFeatures = stof(bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i));
108         MapInfo_Map_flags = stof(bufstr_get(_MapInfo_Cache_Buf_IndexToMapData, ++i));
109         return 1;
110 }
111
112 // GLOB HANDLING (for all BSP files)
113 float _MapInfo_globopen;
114 float _MapInfo_globcount; 
115 float _MapInfo_globhandle;
116 string _MapInfo_GlobItem(float i)
117 {
118         string s;
119         s = search_getfilename(_MapInfo_globhandle, i);
120         return substring(s, 5, strlen(s) - 9); // without maps/ and .bsp
121 }
122
123 void MapInfo_Enumerate()
124 {
125         if(_MapInfo_globopen)
126                 search_end(_MapInfo_globhandle);
127         MapInfo_Cache_Invalidate();
128         _MapInfo_globhandle = search_begin("maps/*.bsp", TRUE, TRUE);
129         _MapInfo_globcount = search_getsize(_MapInfo_globhandle);
130         _MapInfo_globopen = 1;
131 }
132
133 // filter the info by game type mask (updates MapInfo_count)
134 //
135 float _MapInfo_filtered;
136 float _MapInfo_filtered_allocated;
137 float MapInfo_FilterList_Lookup(float i)
138 {
139         return stof(bufstr_get(_MapInfo_filtered, i));
140 }
141
142 void _MapInfo_FilterList_swap(float i, float j, entity pass)
143 {
144         string h;
145         h = bufstr_get(_MapInfo_filtered, i);
146         bufstr_set(_MapInfo_filtered, i, bufstr_get(_MapInfo_filtered, j));
147         bufstr_set(_MapInfo_filtered, j, h);
148 }
149
150 float _MapInfo_FilterList_cmp(float i, float j, entity pass)
151 {
152         string a, b;
153         a = _MapInfo_GlobItem(stof(bufstr_get(_MapInfo_filtered, i)));
154         b = _MapInfo_GlobItem(stof(bufstr_get(_MapInfo_filtered, j)));
155         return strcasecmp(a, b);
156 }
157
158 float MapInfo_FilterGametype(float pGametype, float pFeatures, float pFlagsRequired, float pFlagsForbidden, float pAbortOnGenerate)
159 {
160         float i, j;
161         if not(_MapInfo_filtered_allocated)
162         {
163                 _MapInfo_filtered_allocated = 1;
164                 _MapInfo_filtered = buf_create();
165         }
166         MapInfo_count = 0;
167         for(i = 0, j = -1; i < _MapInfo_globcount; ++i)
168         {
169                 if(MapInfo_Get_ByName(_MapInfo_GlobItem(i), 1, 0) == 2) // if we generated one... BAIL OUT and let the caller continue in the next frame.
170                         if(pAbortOnGenerate)
171                         {
172                                 dprint("Autogenerated a .mapinfo, doing the rest later.\n");
173                                 MapInfo_progress = i / _MapInfo_globcount;
174                                 return 0;
175                         }
176                 if((MapInfo_Map_supportedGametypes & pGametype) != 0)
177                 if((MapInfo_Map_supportedFeatures & pFeatures) == pFeatures)
178                 if((MapInfo_Map_flags & pFlagsForbidden) == 0)
179                 if((MapInfo_Map_flags & pFlagsRequired) == pFlagsRequired)
180                         bufstr_set(_MapInfo_filtered, ++j, ftos(i));
181         }
182         MapInfo_count = j + 1;
183         MapInfo_ClearTemps();
184         
185         // sometimes the glob isn't sorted nicely, so fix it here...
186         heapsort(MapInfo_count, _MapInfo_FilterList_swap, _MapInfo_FilterList_cmp, world);
187
188         return 1;
189 }
190
191 void MapInfo_Filter_Free()
192 {
193         if(_MapInfo_filtered_allocated)
194         {
195                 buf_del(_MapInfo_filtered);
196                 _MapInfo_filtered_allocated = 0;
197         }
198 }
199
200 // load info about the i-th map into the MapInfo_Map_* globals
201 string MapInfo_BSPName_ByID(float i)
202 {
203         return _MapInfo_GlobItem(MapInfo_FilterList_Lookup(i));
204 }
205
206 string unquote(string s)
207 {
208         float i, j, l;
209         l = strlen(s);
210         j = -1;
211         for(i = 0; i < l; ++i)
212         {
213                 string ch;
214                 ch = substring(s, i, 1);
215                 if(ch != " ") if(ch != "\"")
216                 {
217                         for(j = strlen(s) - i - 1; j > 0; --j)
218                         {
219                                 ch = substring(s, i+j, 1);
220                                 if(ch != " ") if(ch != "\"")
221                                         return substring(s, i, j+1);
222                         }
223                         return substring(s, i, 1);
224                 }
225         }
226         return "";
227 }
228
229 float MapInfo_Get_ByID(float i)
230 {
231         if(MapInfo_Get_ByName(MapInfo_BSPName_ByID(i), 0, 0))
232                 return 1;
233         return 0;
234 }
235
236 string _MapInfo_Map_worldspawn_music;
237
238 float _MapInfo_Generate(string pFilename) // 0: failure, 1: ok ent, 2: ok bsp
239 {
240         string fn;
241         float fh;
242         string s, k, v;
243         vector o;
244         float i;
245         float inWorldspawn;
246         float r;
247         float twoBaseModes;
248         float diameter, spawnpoints;
249         float spawnplaces;
250
251         vector mapMins, mapMaxs;
252
253         r = 1;
254         fn = strcat("maps/", pFilename, ".ent");
255         fh = fopen(fn, FILE_READ);
256         if(fh < 0)
257         {
258                 r = 2;
259                 fn = strcat("maps/", pFilename, ".bsp");
260                 fh = fopen(fn, FILE_READ);
261         }
262         if(fh < 0)
263                 return 0;
264         print("Analyzing ", fn, " to generate initial mapinfo; please edit that file later\n");
265
266         inWorldspawn = 2;
267         MapInfo_Map_flags = 0;
268         MapInfo_Map_supportedGametypes = 0;
269         spawnpoints = 0;
270         spawnplaces = 0;
271         _MapInfo_Map_worldspawn_music = "";
272
273         for(;;)
274         {
275                 if not((s = fgets(fh)))
276                         break;
277                 if(inWorldspawn == 1)
278                         if(startsWith(s, "}"))
279                                 inWorldspawn = 0;
280                 k = unquote(car(s));
281                 v = unquote(cdr(s));
282                 if(inWorldspawn)
283                 {
284                         if(k == "classname" && v == "worldspawn")
285                                 inWorldspawn = 1;
286                         else if(k == "author")
287                                 MapInfo_Map_author = v;
288                         else if(k == "_description")
289                                 MapInfo_Map_description = v;
290                         else if(k == "music")
291                                 _MapInfo_Map_worldspawn_music = v;
292                         else if(k == "noise")
293                                 _MapInfo_Map_worldspawn_music = v;
294                         else if(k == "message")
295                         {
296                                 i = strstrofs(v, " by ", 0);
297                                 if(MapInfo_Map_author == "<AUTHOR>" && i >= 0)
298                                 {
299                                         MapInfo_Map_title = substring(v, 0, i);
300                                         MapInfo_Map_author = substring(v, i + 4, strlen(v) - (i + 4));
301                                 }
302                                 else
303                                         MapInfo_Map_title = v;
304                         }
305                 }
306                 else
307                 {
308                         if(k == "origin")
309                         {
310                                 o = stov(strcat("'", v, "'"));
311                                 mapMins_x = min(mapMins_x, o_x);
312                                 mapMins_y = min(mapMins_y, o_y);
313                                 mapMins_z = min(mapMins_z, o_z);
314                                 mapMaxs_x = max(mapMaxs_x, o_x);
315                                 mapMaxs_y = max(mapMaxs_y, o_y);
316                                 mapMaxs_z = max(mapMaxs_z, o_z);
317                         }
318                         else if(k == "race_place")
319                         {
320                                 if(v == "1")
321                                         spawnplaces |= 1;
322                                 else if(v == "2")
323                                         spawnplaces |= 2;
324                                 else if(v == "3")
325                                         spawnplaces |= 4;
326                         }
327                         else if(k == "classname")
328                         {
329                                 if(v == "dom_controlpoint")
330                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_DOMINATION;
331                                 else if(v == "item_flag_team2")
332                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_CTF;
333                                 else if(v == "team_CTF_blueflag")
334                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_CTF;
335                                 else if(v == "runematch_spawn_point")
336                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_RUNEMATCH;
337                                 else if(v == "target_assault_roundend")
338                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_ASSAULT;
339                                 else if(v == "onslaught_generator")
340                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_ONSLAUGHT;
341                                 else if(substring(v, 0, 8) == "nexball_" || substring(v, 0, 4) == "ball")
342                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_NEXBALL;
343                                 else if(v == "info_player_team1")
344                                         ++spawnpoints;
345                                 else if(v == "info_player_team2")
346                                         ++spawnpoints;
347                                 else if(v == "info_player_start")
348                                         ++spawnpoints;
349                                 else if(v == "info_player_deathmatch")
350                                         ++spawnpoints;
351                                 else if(v == "trigger_race_checkpoint")
352                                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_RACE;
353                                 else if(v == "weapon_nex")
354                                         { }
355                                 else if(v == "weapon_railgun")
356                                         { }
357                                 else if(startsWith(v, "weapon_"))
358                                         MapInfo_Map_supportedFeatures |= MAPINFO_FEATURE_WEAPONS;
359                         }
360                 }
361         }
362         if(inWorldspawn)
363         {
364                 print(fn, " ended still in worldspawn, BUG\n");
365                 return 0;
366         }
367         diameter = vlen(mapMaxs - mapMins);
368
369         twoBaseModes = MapInfo_Map_supportedGametypes & (MAPINFO_TYPE_CTF | MAPINFO_TYPE_ASSAULT | MAPINFO_TYPE_RACE | MAPINFO_TYPE_NEXBALL);
370         if(twoBaseModes && (MapInfo_Map_supportedGametypes == twoBaseModes))
371         {
372                 // we have a CTF-only or Assault-only map. Don't add other modes then,
373                 // as the map is too symmetric for them.
374         }
375         else
376         {
377                 MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_DEATHMATCH;      // DM always works
378                 MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_RUNEMATCH;       // Rune always works
379                 MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_LMS;             // LMS always works
380
381                 if(spawnpoints >= 8  && diameter > 4096)
382                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_TEAM_DEATHMATCH;
383                 if(                     diameter < 4096)
384                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_ARENA;
385                 if(spawnpoints >= 12 && diameter > 5120)
386                         MapInfo_Map_supportedGametypes |= MAPINFO_TYPE_KEYHUNT;
387         }
388
389         if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_RACE)
390                 if(spawnplaces != 7)
391                         MapInfo_Map_flags |= MAPINFO_FLAG_FRUSTRATING;
392
393         dprint("-> diameter ",    ftos(diameter));
394         dprint(";  spawnpoints ", ftos(spawnpoints));
395         dprint(";  modes ",       ftos(MapInfo_Map_supportedGametypes), "\n");
396
397         fclose(fh);
398
399         return r;
400 }
401
402 void _MapInfo_Map_Reset()
403 {
404         MapInfo_Map_title = "<TITLE>";
405         MapInfo_Map_description = "<DESCRIPTION>";
406         MapInfo_Map_author = "<AUTHOR>";
407         MapInfo_Map_supportedGametypes = 0;
408         MapInfo_Map_supportedFeatures = 0;
409         MapInfo_Map_flags = 0;
410         MapInfo_Map_clientstuff = "";
411         MapInfo_Map_fog = "";
412         MapInfo_Map_mins = '0 0 0';
413         MapInfo_Map_maxs = '0 0 0';
414 }
415
416 void _MapInfo_Map_ApplyGametype(string s, float pWantedType, float pThisType)
417 {
418         string sa;
419         MapInfo_Map_supportedGametypes |= pThisType;
420         if(!(pThisType & pWantedType))
421                 return;
422         
423         if(pWantedType == MAPINFO_TYPE_ASSAULT || pWantedType == MAPINFO_TYPE_ONSLAUGHT) // these modes don't use fraglimit
424         {
425                 cvar_set("fraglimit", "0");
426         }
427         else
428         {
429                 cvar_set("fraglimit", car(s));
430                 s = cdr(s);
431         }
432
433         cvar_set("timelimit", car(s));
434         s = cdr(s);
435
436         if(pWantedType == MAPINFO_TYPE_TEAM_DEATHMATCH)
437         {
438                 sa = car(s); if(sa == "") sa = "2";
439                 cvar_set("g_tdm_teams", sa);
440                 s = cdr(s);
441         }
442
443         if(pWantedType == MAPINFO_TYPE_KEYHUNT)
444         {
445                 sa = car(s); if(sa == "") sa = "3";
446                 cvar_set("g_keyhunt_teams", sa);
447                 s = cdr(s);
448         }
449
450         if(pWantedType == MAPINFO_TYPE_CTF)
451         {
452                 sa = car(s); if(sa == "") sa = "10";
453                 if(cvar("g_ctf_win_mode") < 2)
454                         cvar_set("fraglimit", sa);
455                 s = cdr(s);
456         }
457
458         if(pWantedType == MAPINFO_TYPE_RACE)
459         {
460                 sa = car(s); if(sa == "") sa = cvar_string("fraglimit");
461                 if(cvar("g_race_teams"))
462                         cvar_set("fraglimit", sa);
463                 s = cdr(s);
464         }
465
466         sa = car(s); if(sa == "") sa = "0";
467         cvar_set("leadlimit", sa);
468         s = cdr(s);
469 }
470
471 float MapInfo_Type_FromString(string t)
472 {
473         if     (t == "dm")      return MAPINFO_TYPE_DEATHMATCH;
474         else if(t == "tdm")     return MAPINFO_TYPE_TEAM_DEATHMATCH;
475         else if(t == "dom")     return MAPINFO_TYPE_DOMINATION;
476         else if(t == "ctf")     return MAPINFO_TYPE_CTF;
477         else if(t == "rune")    return MAPINFO_TYPE_RUNEMATCH;
478         else if(t == "lms")     return MAPINFO_TYPE_LMS;
479         else if(t == "arena")   return MAPINFO_TYPE_ARENA;
480         else if(t == "kh")      return MAPINFO_TYPE_KEYHUNT;
481         else if(t == "as")      return MAPINFO_TYPE_ASSAULT;
482         else if(t == "ons")     return MAPINFO_TYPE_ONSLAUGHT;
483         else if(t == "race")    return MAPINFO_TYPE_RACE;
484         else if(t == "nexball") return MAPINFO_TYPE_NEXBALL;
485         else if(t == "all")     return MAPINFO_TYPE_ALL;
486         else                    return 0;
487 }
488
489 // load info about a map by name into the MapInfo_Map_* globals
490 float MapInfo_Get_ByName(string pFilename, float pAllowGenerate, float pGametypeToSet)
491 {
492         string fn;
493         string s, t;
494         float fh, fh2;
495         float r, f, n, i;
496
497         if(strstrofs(pFilename, "/", 0) >= 0)
498         {
499                 print("Invalid character in map name, ignored\n");
500                 return 0;
501         }
502
503         if(pGametypeToSet == 0)
504                 if(MapInfo_Cache_Retrieve(pFilename))
505                         return 1;
506
507         r = 1;
508
509         MapInfo_Map_bspname = pFilename;
510
511         // default all generic fields so they have "good" values in case something fails
512         fn = strcat("maps/", pFilename, ".mapinfo");
513         fh = fopen(fn, FILE_READ);
514         if(fh < 0)
515         {
516                 if(!pAllowGenerate)
517                         return 0;
518                 _MapInfo_Map_Reset();
519                 r = _MapInfo_Generate(pFilename);
520                 if(!r)
521                         return 0;
522                 fh = fopen(fn, FILE_WRITE);
523                 fputs(fh, strcat("title ", MapInfo_Map_title, "\n"));
524                 fputs(fh, strcat("description ", MapInfo_Map_description, "\n"));
525                 fputs(fh, strcat("author ", MapInfo_Map_author, "\n"));
526                 if(_MapInfo_Map_worldspawn_music != "")
527                 {
528                         if(
529                                 substring(_MapInfo_Map_worldspawn_music, strlen(_MapInfo_Map_worldspawn_music) - 4, 4) == ".wav"
530                                 ||
531                                 substring(_MapInfo_Map_worldspawn_music, strlen(_MapInfo_Map_worldspawn_music) - 4, 4) == ".ogg"
532                         )
533                                 fputs(fh, strcat("cdtrack ", substring(_MapInfo_Map_worldspawn_music, 0, strlen(_MapInfo_Map_worldspawn_music) - 4), "\n"));
534                         else
535                                 fputs(fh, strcat("cdtrack ", _MapInfo_Map_worldspawn_music, "\n"));
536                 }
537                 else
538                 {
539                         n = tokenize_console(cvar_string("g_cdtracks_remaplist"));
540                         s = strcat(" ", cvar_string("g_cdtracks_dontusebydefault"), " ");
541                         for(;;)
542                         {
543                                 i = floor(random() * n);
544                                 if(strstrofs(s, strcat(" ", argv(i), " "), 0) < 0)
545                                         break;
546                         }
547                         fputs(fh, strcat("cdtrack ", ftos(i + 1), "\n"));
548                 }
549                 if(MapInfo_Map_supportedFeatures & MAPINFO_FEATURE_WEAPONS)
550                         fputs(fh, "has weapons\n");
551                 else
552                         fputs(fh, "// uncomment this if you added weapon pickups: has weapons\n");
553                 if(MapInfo_Map_flags & MAPINFO_FLAG_FRUSTRATING)
554                         fputs(fh, "frustrating\n");
555                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_DEATHMATCH)      fputs(fh, "type dm 30 20\n");
556                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_TEAM_DEATHMATCH) fputs(fh, "type tdm 50 20 2\n");
557                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_DOMINATION)      fputs(fh, "type dom 200 20\n");
558                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_CTF)             fputs(fh, "type ctf 300 20 10\n");
559                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_RUNEMATCH)       fputs(fh, "type rune 200 20\n");
560                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_LMS)             fputs(fh, "type lms 9 20\n");
561                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_ARENA)           fputs(fh, "type arena 10 20\n");
562                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_KEYHUNT)         fputs(fh, "type kh 1000 20 3\n");
563                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_ASSAULT)         fputs(fh, "type as 20\n");
564                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_RACE)            fputs(fh, "type race 5 20 15\n");
565                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_ONSLAUGHT)       fputs(fh, "type ons 20\n");
566                 if(MapInfo_Map_supportedGametypes & MAPINFO_TYPE_NEXBALL)         fputs(fh, "type nexball 5 20\n");
567
568                 fh2 = fopen(strcat("scripts/", pFilename, ".arena"), FILE_READ);
569                 if(fh2 >= 0)
570                 {
571                         fclose(fh2);
572                         fputs(fh, "settemp_for_type all sv_q3acompat_machineshotgunswap 1\n");
573                 }
574
575                 fputs(fh, "// optional: fog density red green blue alpha mindist maxdist\n");
576                 fputs(fh, "// optional: settemp_for_type (all|gametypename) cvarname value\n");
577                 fputs(fh, "// optional: clientsettemp_for_type (all|gametypename) cvarname value\n");
578                 fputs(fh, "// optional: size mins_x mins_y mins_z maxs_x maxs_y maxs_z\n");
579                 fputs(fh, "// optional: hidden\n");
580
581                 fclose(fh);
582                 r = 2;
583                 // return r;
584                 fh = fopen(fn, FILE_READ);
585                 if(fh < 0)
586                         error("... but I just wrote it!");
587         }
588
589         _MapInfo_Map_Reset();
590         for(;;)
591         {
592                 if not((s = fgets(fh)))
593                         break;
594
595                 // catch different sorts of comments
596                 if(s == "")                    // empty lines
597                         continue;
598                 if(substring(s, 0, 1) == "#")  // UNIX style
599                         continue;
600                 if(substring(s, 0, 2) == "//") // C++ style
601                         continue;
602                 if(substring(s, 0, 1) == "_")  // q3map style
603                         continue;
604
605                 t = car(s); s = cdr(s);
606                 if(t == "title")
607                         MapInfo_Map_title = s;
608                 else if(t == "description")
609                         MapInfo_Map_description = s;
610                 else if(t == "author")
611                         MapInfo_Map_author = s;
612                 else if(t == "has")
613                 {
614                         t = car(s); s = cdr(s);
615                         if     (t == "weapons") MapInfo_Map_supportedFeatures |= MAPINFO_FEATURE_WEAPONS;
616                         else
617                                 dprint("Map ", pFilename, " supports unknown feature ", t, ", ignored\n");
618                 }
619                 else if(t == "hidden")
620                 {
621                         MapInfo_Map_flags |= MAPINFO_FLAG_HIDDEN;
622                 }
623                 else if(t == "forbidden")
624                 {
625                         MapInfo_Map_flags |= MAPINFO_FLAG_FORBIDDEN;
626                 }
627                 else if(t == "frustrating")
628                 {
629                         MapInfo_Map_flags |= MAPINFO_FLAG_FRUSTRATING;
630                 }
631                 else if(t == "type")
632                 {
633                         t = car(s); s = cdr(s);
634                         f = MapInfo_Type_FromString(t);
635                         if(f)
636                                 _MapInfo_Map_ApplyGametype (s, pGametypeToSet, f);
637                         else
638                                 dprint("Map ", pFilename, " supports unknown game type ", t, ", ignored\n");
639                 }
640                 else if(t == "size")
641                 {
642                         float a, b, c, d, e;
643                         t = car(s); s = cdr(s); a = stof(t);
644                         t = car(s); s = cdr(s); b = stof(t);
645                         t = car(s); s = cdr(s); c = stof(t);
646                         t = car(s); s = cdr(s); d = stof(t);
647                         t = car(s); s = cdr(s); e = stof(t);
648                         if(s == "")
649                                 print("Map ", pFilename, " contains an incorrect size line (not enough params), syntax: size mins_x mins_y mins_z maxs_x maxs_y maxs_z\n");
650                         else
651                         {
652                                 t = car(s); s = cdr(s); f = stof(t);
653                                 if(s != "")
654                                         print("Map ", pFilename, " contains an incorrect size line (too many params), syntax: size mins_x mins_y mins_z maxs_x maxs_y maxs_z\n");
655                                 else
656                                 {
657                                         if(a >= d || b >= e || c >= f)
658                                                 print("Map ", pFilename, " contains an incorrect size line, mins have to be < maxs\n");
659                                         else
660                                         {
661                                                 MapInfo_Map_mins_x = a;
662                                                 MapInfo_Map_mins_y = b;
663                                                 MapInfo_Map_mins_z = c;
664                                                 MapInfo_Map_maxs_x = d;
665                                                 MapInfo_Map_maxs_y = e;
666                                                 MapInfo_Map_maxs_z = f;
667                                         }
668                                 }
669                         }
670                 }
671                 else if(t == "settemp_for_type")
672                 {
673                         t = car(s); s = cdr(s);
674                         if((f = MapInfo_Type_FromString(t)))
675                         {
676                                 if(f & pGametypeToSet)
677                                 {
678                                         t = car(s); s = cdr(s);
679                                         if not(cvar_value_issafe(t))
680                                                 print("Map ", pFilename, " contains a potentially harmful setting, ignored\n");
681                                         else if not (cvar_value_issafe(s))
682                                                 print("Map ", pFilename, " contains a potentially harmful setting, ignored\n");
683                                         else
684                                         {
685                                                 dprint("Applying temporary setting ", t, " := ", s, "\n");
686                                                 cvar_settemp(t, s);
687                                         }
688                                 }
689                         }
690                         else
691                         {
692                                 dprint("Map ", pFilename, " has a setting for unknown game type ", t, ", ignored\n");
693                         }
694                 }
695                 else if(t == "clientsettemp_for_type")
696                 {
697                         t = car(s); s = cdr(s);
698                         if((f = MapInfo_Type_FromString(t)))
699                         {
700                                 if(f & pGametypeToSet)
701                                 {
702                                         t = car(s); s = cdr(s);
703                                         if not(cvar_value_issafe(t))
704                                                 print("Map ", pFilename, " contains a potentially harmful client setting, ignored\n");
705                                         else if not (cvar_value_issafe(s))
706                                                 print("Map ", pFilename, " contains a potentially harmful client setting, ignored\n");
707                                         else
708                                         {
709                                                 dprint("Applying temporary client setting ", t, " := ", s, "\n");
710                                                 MapInfo_Map_clientstuff = strcat(
711                                                         MapInfo_Map_clientstuff, "cl_cmd settemp \"", t, "\" \"", s, "\"\n"
712                                                 );
713                                         }
714                                 }
715                         }
716                         else
717                         {
718                                 dprint("Map ", pFilename, " has a client setting for unknown game type ", t, ", ignored\n");
719                         }
720                 }
721                 else if(t == "fog")
722                 {
723                         if not(cvar_value_issafe(t))
724                                 print("Map ", pFilename, " contains a potentially harmful fog setting, ignored\n");
725                         else
726                                 MapInfo_Map_fog = s;
727                 }
728                 else if(t == "cdtrack")
729                 {
730                         if(pGametypeToSet)
731                         {
732                                 if not(cvar_value_issafe(t))
733                                         print("Map ", pFilename, " contains a potentially harmful cdtrack, ignored\n");
734                                 else
735                                         MapInfo_Map_clientstuff = strcat(
736                                                 MapInfo_Map_clientstuff, "cd loop \"", s, "\"\n"
737                                         );
738                         }
739                 }
740                 else
741                         dprint("Map ", pFilename, " provides unknown info item ", t, ", ignored\n");
742         }
743         fclose(fh);
744
745         if(!MapInfo_Map_supportedGametypes)
746                 _MapInfo_Map_ApplyGametype("30 20", pGametypeToSet, MAPINFO_TYPE_DEATHMATCH);
747
748         if(pGametypeToSet)
749                 if(!(MapInfo_Map_supportedGametypes & pGametypeToSet))
750                         error("Can't select the requested game type. Bailing out.");
751         MapInfo_Cache_Store();
752         if(MapInfo_Map_supportedGametypes != 0)
753                 return r;
754         dprint("Map ", pFilename, " supports no game types, ignored\n");
755         return 0;
756 }
757
758 float MapInfo_FindName(string s)
759 {
760         // if there is exactly one map of prefix s, return it
761         // if not, return the null string
762         // note that DP sorts glob results... so I can use a binary search
763         float l, r, m, cmp;
764         l = 0;
765         r = MapInfo_count;
766         // invariants: r is behind s, l-1 is equal or before
767         while(l != r)
768         {
769                 m = floor((l + r) / 2);
770                 MapInfo_FindName_match = _MapInfo_GlobItem(MapInfo_FilterList_Lookup(m));
771                 cmp = strcasecmp(MapInfo_FindName_match, s);
772                 if(cmp == 0)
773                         return m; // found and good
774                 if(cmp < 0)
775                         l = m + 1; // l-1 is before s
776                 else
777                         r = m; // behind s
778         }
779         MapInfo_FindName_match = _MapInfo_GlobItem(MapInfo_FilterList_Lookup(l));
780         MapInfo_FindName_firstResult = l;
781         // r == l, so: l is behind s, l-1 is before
782         // SO: if there is any, l is the one with the right prefix
783         //     and l+1 may be one too
784         if(l == MapInfo_count)
785         {
786                 MapInfo_FindName_match = string_null;
787                 MapInfo_FindName_firstResult = -1;
788                 return -1; // no MapInfo_FindName_match, behind last item
789         }
790         if(!startsWithNocase(MapInfo_FindName_match, s))
791         {
792                 MapInfo_FindName_match = string_null;
793                 MapInfo_FindName_firstResult = -1;
794                 return -1; // wrong prefix
795         }
796         if(l == MapInfo_count - 1)
797                 return l; // last one, nothing can follow => unique
798         if(startsWithNocase(_MapInfo_GlobItem(MapInfo_FilterList_Lookup(l + 1)), s))
799         {
800                 MapInfo_FindName_match = string_null;
801                 return -1; // ambigous MapInfo_FindName_match
802         }
803         return l;
804 }
805
806 string MapInfo_FixName(string s)
807 {
808         MapInfo_FindName(s);
809         return MapInfo_FindName_match;
810 }
811
812 float MapInfo_CurrentFeatures()
813 {
814         float req;
815         req = 0;
816         if(!(cvar("g_lms") || cvar("g_instagib") || cvar("g_minstagib") || cvar("g_nixnex") || cvar("g_rocketarena") || !cvar("g_pickup_items") || cvar("g_race") || cvar("g_nexball")))
817                 req |= MAPINFO_FEATURE_WEAPONS;
818         return req;
819 }
820
821 float MapInfo_CurrentGametype()
822 {
823         if(cvar("g_domination"))
824                 return MAPINFO_TYPE_DOMINATION;
825         else if(cvar("g_ctf"))
826                 return MAPINFO_TYPE_CTF;
827         else if(cvar("g_runematch"))
828                 return MAPINFO_TYPE_RUNEMATCH;
829         else if(cvar("g_tdm"))
830                 return MAPINFO_TYPE_TEAM_DEATHMATCH;
831         else if(cvar("g_assault"))
832                 return MAPINFO_TYPE_ASSAULT;
833         else if(cvar("g_lms"))
834                 return MAPINFO_TYPE_LMS;
835         else if(cvar("g_arena"))
836                 return MAPINFO_TYPE_ARENA;
837         else if(cvar("g_keyhunt"))
838                 return MAPINFO_TYPE_KEYHUNT;
839         else if(cvar("g_onslaught"))
840                 return MAPINFO_TYPE_ONSLAUGHT;
841         else if(cvar("g_race"))
842                 return MAPINFO_TYPE_RACE;
843         else if(cvar("g_nexball"))
844                 return MAPINFO_TYPE_NEXBALL;
845         else
846                 return MAPINFO_TYPE_DEATHMATCH;
847 }
848
849 float _MapInfo_CheckMap(string s) // returns 0 if the map can't be played with the current settings, 1 otherwise
850 {
851         if(!MapInfo_Get_ByName(s, 1, 0))
852                 return 0;
853         if((MapInfo_Map_supportedGametypes & MapInfo_CurrentGametype()) == 0)
854                 return 0;
855         if((MapInfo_Map_supportedFeatures & MapInfo_CurrentFeatures()) != MapInfo_CurrentFeatures())
856                 return 0;
857         return 1;
858 }
859
860 float MapInfo_CheckMap(string s) // returns 0 if the map can't be played with the current settings, 1 otherwise
861 {
862         float r;
863         r = _MapInfo_CheckMap(s);
864         MapInfo_ClearTemps();
865         return r;
866 }
867
868 string MapInfo_GetGameTypeCvar(float t)
869 {
870         switch(t)
871         {
872                 case MAPINFO_TYPE_DEATHMATCH: return "g_dm";
873                 case MAPINFO_TYPE_TEAM_DEATHMATCH: return "g_tdm";
874                 case MAPINFO_TYPE_DOMINATION: return "g_domination";
875                 case MAPINFO_TYPE_CTF: return "g_ctf";
876                 case MAPINFO_TYPE_RUNEMATCH: return "g_runematch";
877                 case MAPINFO_TYPE_LMS: return "g_lms";
878                 case MAPINFO_TYPE_ARENA: return "g_arena";
879                 case MAPINFO_TYPE_KEYHUNT: return "g_kh";
880                 case MAPINFO_TYPE_ASSAULT: return "g_assault";
881                 case MAPINFO_TYPE_ONSLAUGHT: return "g_onslaught";
882                 case MAPINFO_TYPE_RACE: return "g_race";
883                 default: return "";
884         }
885 }
886
887 void MapInfo_SwitchGameType(float t)
888 {
889         cvar_set("gamecfg",      "0");
890         cvar_set("g_dm",         (t == MAPINFO_TYPE_DEATHMATCH)      ? "1" : "0");
891         cvar_set("g_tdm",        (t == MAPINFO_TYPE_TEAM_DEATHMATCH) ? "1" : "0");
892         cvar_set("g_domination", (t == MAPINFO_TYPE_DOMINATION)      ? "1" : "0");
893         cvar_set("g_ctf",        (t == MAPINFO_TYPE_CTF)             ? "1" : "0");
894         cvar_set("g_runematch",  (t == MAPINFO_TYPE_RUNEMATCH)       ? "1" : "0");
895         cvar_set("g_lms",        (t == MAPINFO_TYPE_LMS)             ? "1" : "0");
896         cvar_set("g_arena",      (t == MAPINFO_TYPE_ARENA)           ? "1" : "0");
897         cvar_set("g_keyhunt",    (t == MAPINFO_TYPE_KEYHUNT)         ? "1" : "0");
898         cvar_set("g_assault",    (t == MAPINFO_TYPE_ASSAULT)         ? "1" : "0");
899         cvar_set("g_onslaught",  (t == MAPINFO_TYPE_ONSLAUGHT)       ? "1" : "0");
900         cvar_set("g_race",       (t == MAPINFO_TYPE_RACE)            ? "1" : "0");
901         cvar_set("g_nexball",    (t == MAPINFO_TYPE_NEXBALL)         ? "1" : "0");
902 }
903
904 void MapInfo_LoadMap(string s)
905 {
906         MapInfo_Map_supportedGametypes = 0;
907         if(!MapInfo_CheckMap(s))
908         {
909                 print("EMERGENCY: can't play the selected map in the given game mode. Falling back to DM.\n");
910                 MapInfo_SwitchGameType(MAPINFO_TYPE_DEATHMATCH);
911         }
912         localcmd(strcat("\nsettemp_restore\nchangelevel ", s, "\n"));
913 }
914
915 string MapInfo_ListAllowedMaps(float pRequiredFlags, float pForbiddenFlags)
916 {
917         string out;
918         float i;
919
920         // to make absolutely sure:
921         MapInfo_Enumerate();
922         MapInfo_FilterGametype(MapInfo_CurrentGametype(), MapInfo_CurrentFeatures(), pRequiredFlags, pForbiddenFlags, 0);
923
924         out = "";
925         for(i = 0; i < MapInfo_count; ++i)
926                 out = strcat(out, " ", _MapInfo_GlobItem(MapInfo_FilterList_Lookup(i)));
927         return substring(out, 1, strlen(out) - 1);
928 }
929
930 void MapInfo_LoadMapSettings(string s) // to be called from worldspawn
931 {
932         float t;
933         if(!_MapInfo_CheckMap(s)) // with underscore, it keeps temps
934         {
935                 if(MapInfo_Map_supportedGametypes <= 0)
936                         error("Mapinfo system is not functional at all. BAILED OUT.\n");
937
938                 t = 1;
939                 while(!(MapInfo_Map_supportedGametypes & 1))
940                 {
941                         t *= 2;
942                         MapInfo_Map_supportedGametypes = floor(MapInfo_Map_supportedGametypes / 2);
943                 }
944                 // t is now a supported mode!
945                 print("EMERGENCY: can't play the selected map in the given game mode. Falling back to a supported mode.\n");
946                 MapInfo_SwitchGameType(t);
947         }
948         cvar_settemp_restore();
949         MapInfo_Get_ByName(s, 1, MapInfo_CurrentGametype());
950 }
951
952 void MapInfo_ClearTemps()
953 {
954         MapInfo_Map_bspname = string_null;
955         MapInfo_Map_title = string_null;
956         MapInfo_Map_description = string_null;
957         MapInfo_Map_author = string_null;
958         MapInfo_Map_clientstuff = string_null;
959         MapInfo_Map_supportedGametypes = 0;
960         MapInfo_Map_supportedFeatures = 0;
961 }
962
963 void MapInfo_Shutdown()
964 {
965         MapInfo_ClearTemps();
966         MapInfo_Filter_Free();
967         MapInfo_Cache_Destroy();
968         if(_MapInfo_globopen)
969         {
970                 search_end(_MapInfo_globhandle);
971                 _MapInfo_globhandle = -1;
972                 _MapInfo_globopen = FALSE;
973         }
974 }
975
976 float MapInfo_ForbiddenFlags()
977 {
978         float f;
979         f = MAPINFO_FLAG_FORBIDDEN;
980
981 #ifndef MENUQC
982         if not(cvar("g_maplist_allow_hidden"))
983 #endif
984                 f |= MAPINFO_FLAG_HIDDEN;
985
986         if not(cvar("g_maplist_allow_frustrating"))
987                 f |= MAPINFO_FLAG_FRUSTRATING;
988
989         return f;
990 }
991
992 float MapInfo_RequiredFlags()
993 {
994         float f;
995         f = 0;
996
997         if(cvar("g_maplist_allow_frustrating") > 1)
998                 f |= MAPINFO_FLAG_FRUSTRATING;
999
1000         return f;
1001 }