qcsrc/common/mapinfo.qh

   1 #pragma once
   2
   3 bool autocvar_developer_mapper;
   4
   5 #define LOG_MAPWARN(...) MACRO_BEGIN { if (autocvar_developer_mapper) LOG_WARN(__VA_ARGS__); } MACRO_END
   6 #define LOG_MAPWARNF(...) MACRO_BEGIN { if (autocvar_developer_mapper) LOG_WARNF(__VA_ARGS__); } MACRO_END
   7
   8 #include "util.qh"
   9
  10 // info about a map that MapInfo loads
  11 string MapInfo_Map_bspname;
  12 string MapInfo_Map_title;
  13 string MapInfo_Map_titlestring; // either bspname: title or just title, depending on whether bspname is redundant
  14 string MapInfo_Map_description;
  15 string MapInfo_Map_author;
  16 string MapInfo_Map_clientstuff; // not in cache, only for map load
  17 string MapInfo_Map_fog; // not in cache, only for map load
  18 int MapInfo_Map_supportedGametypes;
  19 int MapInfo_Map_supportedFeatures;
  20 int MapInfo_Map_flags;
  21 vector MapInfo_Map_mins; // these are '0 0 0' if not supported!
  22 vector MapInfo_Map_maxs; // these are '0 0 0' if not specified!
  23
  24 int MAPINFO_TYPE_ALL;
  25 .int m_flags;
  26
  27 CLASS(Gametype, Object)
  28     ATTRIB(Gametype, m_id, int, 0);
  29     /** game type ID */
  30     ATTRIB(Gametype, items, int, 0);
  31     /** game type name as in cvar (with g_ prefix) */
  32     ATTRIB(Gametype, netname, string);
  33     /** game type short name */
  34     ATTRIB(Gametype, mdl, string);
  35     /** human readable name */
  36     ATTRIB(Gametype, message, string);
  37     /** does this gametype support teamplay? */
  38     ATTRIB(Gametype, team, bool, false);
  39     /** game type defaults */
  40     ATTRIB(Gametype, model2, string);
  41     /** game type description */
  42     ATTRIB(Gametype, gametype_description, string);
  43 #ifdef CSQC
  44     ATTRIB(Gametype, m_modicons, void(vector pos, vector mySize));
  45 #endif
  46
  47     ATTRIB(Gametype, m_mutators, string);
  48     METHOD(Gametype, m_parse_mapinfo, bool(string k, string v))
  49     {
  50         return false;
  51     }
  52     METHOD(Gametype, m_generate_mapinfo, void(Gametype this, string v))
  53     {
  54         TC(Gametype, this);
  55     }
  56     METHOD(Gametype, m_isTwoBaseMode, bool())
  57     {
  58         return false;
  59     }
  60
  61     METHOD(Gametype, describe, string(Gametype this))
  62     {
  63         TC(Gametype, this);
  64         return this.gametype_description;
  65     }
  66
  67     METHOD(Gametype, display, void(Gametype this, void(string name, string icon) returns))
  68     {
  69         TC(Gametype, this);
  70         returns(this.message, strcat("gametype_", this.mdl));
  71     }
  72
  73     METHOD(Gametype, gametype_init, void(Gametype this, string hname, string sname, string g_name, bool gteamplay, string mutators, string defaults, string gdescription))
  74     {
  75         this.netname = g_name;
  76         this.mdl = sname;
  77         this.message = hname;
  78         this.team = gteamplay;
  79         this.m_mutators = cons(sname, mutators);
  80         this.model2 = defaults;
  81         this.gametype_description = gdescription;
  82
  83         // same as `1 << m_id`
  84         MAPINFO_TYPE_ALL |= this.items = this.m_flags = (MAPINFO_TYPE_ALL + 1);
  85     }
  86 ENDCLASS(Gametype)
  87
  88 REGISTRY(Gametypes, 24)
  89 #define Gametypes_from(i) _Gametypes_from(i, NULL)
  90 REGISTER_REGISTRY(Gametypes)
  91 REGISTRY_CHECK(Gametypes)
  92 #define REGISTER_GAMETYPE(NAME, inst) REGISTER(Gametypes, MAPINFO_TYPE, NAME, m_id, inst)
  93
  94 #define IS_GAMETYPE(NAME) (MapInfo_LoadedGametype == MAPINFO_TYPE_##NAME)
  95
  96 CLASS(Deathmatch, Gametype)
  97     INIT(Deathmatch)
  98     {
  99         this.gametype_init(this, _("Deathmatch"),"dm","g_dm",false,"","timelimit=20 pointlimit=30 leadlimit=0",_("Score as many frags as you can"));
 100     }
 101 ENDCLASS(Deathmatch)
 102 REGISTER_GAMETYPE(DEATHMATCH, NEW(Deathmatch));
 103
 104 CLASS(LastManStanding, Gametype)
 105     INIT(LastManStanding)
 106     {
 107         this.gametype_init(this, _("Last Man Standing"),"lms","g_lms",false,"","timelimit=20 lives=9 leadlimit=0",_("Survive and kill until the enemies have no lives left"));
 108     }
 109 ENDCLASS(LastManStanding)
 110 REGISTER_GAMETYPE(LMS, NEW(LastManStanding));
 111
 112 #ifdef CSQC
 113 void HUD_Mod_Race(vector pos, vector mySize);
 114 #endif
 115 CLASS(Race, Gametype)
 116     INIT(Race)
 117     {
 118         this.gametype_init(this, _("Race"),"rc","g_race",false,"","timelimit=20 qualifying_timelimit=5 laplimit=7 teamlaplimit=15 leadlimit=0",_("Race against other players to the finish line"));
 119     }
 120     METHOD(Race, m_parse_mapinfo, bool(string k, string v))
 121     {
 122         if (!k) {
 123             cvar_set("g_race_qualifying_timelimit", cvar_defstring("g_race_qualifying_timelimit"));
 124             return true;
 125         }
 126         switch (k) {
 127             case "qualifying_timelimit":
 128                 cvar_set("g_race_qualifying_timelimit", v);
 129                 return true;
 130         }
 131         return false;
 132     }
 133     METHOD(Race, m_generate_mapinfo, void(Gametype this, string v))
 134     {
 135         if(v == "trigger_race_checkpoint")
 136             MapInfo_Map_supportedGametypes |= this.m_flags;
 137     }
 138     METHOD(Race, m_isTwoBaseMode, bool())
 139     {
 140         return true;
 141     }
 142 #ifdef CSQC
 143     ATTRIB(Race, m_modicons, void(vector pos, vector mySize), HUD_Mod_Race);
 144 #endif
 145 ENDCLASS(Race)
 146 REGISTER_GAMETYPE(RACE, NEW(Race));
 147 #define g_race IS_GAMETYPE(RACE)
 148
 149 CLASS(RaceCTS, Gametype)
 150     INIT(RaceCTS)
 151     {
 152         this.gametype_init(this, _("Race CTS"),"cts","g_cts",false,"cloaked","timelimit=20",_("Race for fastest time."));
 153     }
 154     METHOD(RaceCTS, m_generate_mapinfo, void(Gametype this, string v))
 155     {
 156         if(v == "target_startTimer")
 157             MapInfo_Map_supportedGametypes |= this.m_flags;
 158     }
 159 #ifdef CSQC
 160     ATTRIB(RaceCTS, m_modicons, void(vector pos, vector mySize), HUD_Mod_Race);
 161 #endif
 162 ENDCLASS(RaceCTS)
 163 REGISTER_GAMETYPE(CTS, NEW(RaceCTS));
 164 #define g_cts IS_GAMETYPE(CTS)
 165
 166 CLASS(TeamDeathmatch, Gametype)
 167     INIT(TeamDeathmatch)
 168     {
 169         this.gametype_init(this, _("Team Deathmatch"),"tdm","g_tdm",true,"","timelimit=20 pointlimit=50 teams=2 leadlimit=0",_("Help your team score the most frags against the enemy team"));
 170     }
 171     METHOD(TeamDeathmatch, m_parse_mapinfo, bool(string k, string v))
 172     {
 173         if (!k) {
 174             cvar_set("g_tdm_teams", cvar_defstring("g_tdm_teams"));
 175             return true;
 176         }
 177         switch (k) {
 178             case "teams":
 179                 cvar_set("g_tdm_teams", v);
 180                 return true;
 181         }
 182         return false;
 183     }
 184 ENDCLASS(TeamDeathmatch)
 185 REGISTER_GAMETYPE(TEAM_DEATHMATCH, NEW(TeamDeathmatch));
 186 #define g_tdm IS_GAMETYPE(TEAM_DEATHMATCH)
 187
 188 #ifdef CSQC
 189 void HUD_Mod_CTF(vector pos, vector mySize);
 190 #endif
 191 CLASS(CaptureTheFlag, Gametype)
 192     INIT(CaptureTheFlag)
 193     {
 194         this.gametype_init(this, _("Capture the Flag"),"ctf","g_ctf",true,"","timelimit=20 caplimit=10 leadlimit=6",_("Find and bring the enemy flag to your base to capture it, defend your base from the other team"));
 195     }
 196     METHOD(CaptureTheFlag, m_generate_mapinfo, void(Gametype this, string v))
 197     {
 198         if(v == "item_flag_team2" || v == "team_CTF_blueflag")
 199             MapInfo_Map_supportedGametypes |= this.m_flags;
 200     }
 201     METHOD(CaptureTheFlag, m_isTwoBaseMode, bool())
 202     {
 203         return true;
 204     }
 205 #ifdef CSQC
 206     ATTRIB(CaptureTheFlag, m_modicons, void(vector pos, vector mySize), HUD_Mod_CTF);
 207 #endif
 208 ENDCLASS(CaptureTheFlag)
 209 REGISTER_GAMETYPE(CTF, NEW(CaptureTheFlag));
 210 #define g_ctf IS_GAMETYPE(CTF)
 211
 212 #ifdef CSQC
 213 void HUD_Mod_CA(vector pos, vector mySize);
 214 #endif
 215 CLASS(ClanArena, Gametype)
 216     INIT(ClanArena)
 217     {
 218         this.gametype_init(this, _("Clan Arena"),"ca","g_ca",true,"","timelimit=20 pointlimit=10 teams=2 leadlimit=0",_("Kill all enemy teammates to win the round"));
 219     }
 220     METHOD(ClanArena, m_parse_mapinfo, bool(string k, string v))
 221     {
 222         if (!k) {
 223             cvar_set("g_ca_teams", cvar_defstring("g_ca_teams"));
 224             return true;
 225         }
 226         switch (k) {
 227             case "teams":
 228                 cvar_set("g_ca_teams", v);
 229                 return true;
 230         }
 231         return false;
 232     }
 233 #ifdef CSQC
 234     ATTRIB(ClanArena, m_modicons, void(vector pos, vector mySize), HUD_Mod_CA);
 235 #endif
 236 ENDCLASS(ClanArena)
 237 REGISTER_GAMETYPE(CA, NEW(ClanArena));
 238 #define g_ca IS_GAMETYPE(CA)
 239
 240 #ifdef CSQC
 241 void HUD_Mod_Dom(vector pos, vector mySize);
 242 #endif
 243 CLASS(Domination, Gametype)
 244     INIT(Domination)
 245     {
 246         this.gametype_init(this, _("Domination"),"dom","g_domination",true,"","timelimit=20 pointlimit=200 teams=2 leadlimit=0",_("Capture and defend all the control points to win"));
 247     }
 248     METHOD(Domination, m_parse_mapinfo, bool(string k, string v))
 249     {
 250         if (!k) {
 251             cvar_set("g_domination_default_teams", cvar_defstring("g_domination_default_teams"));
 252             return true;
 253         }
 254         switch (k) {
 255             case "teams":
 256                 cvar_set("g_domination_default_teams", v);
 257                 return true;
 258         }
 259         return false;
 260     }
 261     METHOD(Domination, m_generate_mapinfo, void(Gametype this, string v))
 262     {
 263         if(v == "dom_controlpoint")
 264             MapInfo_Map_supportedGametypes |= this.m_flags;
 265     }
 266 #ifdef CSQC
 267     ATTRIB(Domination, m_modicons, void(vector pos, vector mySize), HUD_Mod_Dom);
 268 #endif
 269 ENDCLASS(Domination)
 270 REGISTER_GAMETYPE(DOMINATION, NEW(Domination));
 271
 272 #ifdef CSQC
 273 void HUD_Mod_KH(vector pos, vector mySize);
 274 #endif
 275 CLASS(KeyHunt, Gametype)
 276     INIT(KeyHunt)
 277     {
 278         this.gametype_init(this, _("Key Hunt"),"kh","g_keyhunt",true,"","timelimit=20 pointlimit=1000 teams=3 leadlimit=0",_("Gather all the keys to win the round"));
 279     }
 280     METHOD(KeyHunt, m_parse_mapinfo, bool(string k, string v))
 281     {
 282         if (!k) {
 283             cvar_set("g_keyhunt_teams", cvar_defstring("g_keyhunt_teams"));
 284             return true;
 285         }
 286         switch (k) {
 287             case "teams":
 288                 cvar_set("g_keyhunt_teams", v);
 289                 return true;
 290         }
 291         return false;
 292     }
 293     METHOD(KeyHunt, m_modicons, void(vector pos, vector mySize))
 294     {
 295     #ifdef CSQC
 296         HUD_Mod_KH(pos, mySize);
 297     #endif
 298     }
 299 #ifdef CSQC
 300     ATTRIB(KeyHunt, m_modicons, void(vector pos, vector mySize), HUD_Mod_KH);
 301 #endif
 302 ENDCLASS(KeyHunt)
 303 REGISTER_GAMETYPE(KEYHUNT, NEW(KeyHunt));
 304
 305 CLASS(Assault, Gametype)
 306     INIT(Assault)
 307     {
 308         this.gametype_init(this, _("Assault"),"as","g_assault",true,"","timelimit=20",_("Destroy obstacles to find and destroy the enemy power core before time runs out"));
 309     }
 310     METHOD(Assault, m_generate_mapinfo, void(Gametype this, string v))
 311     {
 312         if(v == "target_assault_roundend")
 313             MapInfo_Map_supportedGametypes |= this.m_flags;
 314     }
 315     METHOD(Assault, m_isTwoBaseMode, bool())
 316     {
 317         return true;
 318     }
 319 ENDCLASS(Assault)
 320 REGISTER_GAMETYPE(ASSAULT, NEW(Assault));
 321 #define g_assault IS_GAMETYPE(ASSAULT)
 322
 323 CLASS(Onslaught, Gametype)
 324     INIT(Onslaught)
 325     {
 326         this.gametype_init(this, _("Onslaught"),"ons","g_onslaught",true,"","pointlimit=1 timelimit=20",_("Capture control points to reach and destroy the enemy generator"));
 327     }
 328     METHOD(Onslaught, m_generate_mapinfo, void(Gametype this, string v))
 329     {
 330         if(v == "onslaught_generator")
 331             MapInfo_Map_supportedGametypes |= this.m_flags;
 332     }
 333 ENDCLASS(Onslaught)
 334 REGISTER_GAMETYPE(ONSLAUGHT, NEW(Onslaught));
 335
 336 #ifdef CSQC
 337 void HUD_Mod_NexBall(vector pos, vector mySize);
 338 #endif
 339 CLASS(NexBall, Gametype)
 340     INIT(NexBall)
 341     {
 342         this.gametype_init(this, _("Nexball"),"nb","g_nexball",true,"","timelimit=20 pointlimit=5 leadlimit=0",_("Shoot and kick the ball into the enemies goal, keep your goal clean"));
 343     }
 344     METHOD(NexBall, m_generate_mapinfo, void(Gametype this, string v))
 345     {
 346         if(substring(v, 0, 8) == "nexball_" || substring(v, 0, 4) == "ball")
 347             MapInfo_Map_supportedGametypes |= this.m_flags;
 348     }
 349     METHOD(NexBall, m_isTwoBaseMode, bool())
 350     {
 351         return true;
 352     }
 353 #ifdef CSQC
 354     ATTRIB(NexBall, m_modicons, void(vector pos, vector mySize), HUD_Mod_NexBall);
 355 #endif
 356 ENDCLASS(NexBall)
 357 REGISTER_GAMETYPE(NEXBALL, NEW(NexBall));
 358 #define g_nexball IS_GAMETYPE(NEXBALL)
 359
 360 CLASS(FreezeTag, Gametype)
 361     INIT(FreezeTag)
 362     {
 363         this.gametype_init(this, _("Freeze Tag"),"ft","g_freezetag",true,"","timelimit=20 pointlimit=10 teams=2 leadlimit=0",_("Kill enemies to freeze them, stand next to teammates to revive them, freeze the most enemies to win"));
 364     }
 365     METHOD(FreezeTag, m_parse_mapinfo, bool(string k, string v))
 366     {
 367         if (!k) {
 368             cvar_set("g_freezetag_teams", cvar_defstring("g_freezetag_teams"));
 369             return true;
 370         }
 371         switch (k) {
 372             case "teams":
 373                 cvar_set("g_freezetag_teams", v);
 374                 return true;
 375         }
 376         return false;
 377     }
 378 #ifdef CSQC
 379     ATTRIB(FreezeTag, m_modicons, void(vector pos, vector mySize), HUD_Mod_CA);
 380 #endif
 381 ENDCLASS(FreezeTag)
 382 REGISTER_GAMETYPE(FREEZETAG, NEW(FreezeTag));
 383 #define g_freezetag IS_GAMETYPE(FREEZETAG)
 384
 385 #ifdef CSQC
 386 void HUD_Mod_Keepaway(vector pos, vector mySize);
 387 #endif
 388 CLASS(Keepaway, Gametype)
 389     INIT(Keepaway)
 390     {
 391         this.gametype_init(this, _("Keepaway"),"ka","g_keepaway",true,"","timelimit=20 pointlimit=30",_("Hold the ball to get points for kills"));
 392     }
 393 #ifdef CSQC
 394     ATTRIB(Keepaway, m_modicons, void(vector pos, vector mySize), HUD_Mod_Keepaway);
 395 #endif
 396 ENDCLASS(Keepaway)
 397 REGISTER_GAMETYPE(KEEPAWAY, NEW(Keepaway));
 398
 399 CLASS(Invasion, Gametype)
 400     INIT(Invasion)
 401     {
 402         this.gametype_init(this, _("Invasion"),"inv","g_invasion",false,"","pointlimit=50 teams=0",_("Survive against waves of monsters"));
 403     }
 404     METHOD(Invasion, m_parse_mapinfo, bool(string k, string v))
 405     {
 406         switch (k) {
 407             case "teams":
 408                 cvar_set("g_invasion_teams", v);
 409                 return true;
 410         }
 411         return false;
 412     }
 413     METHOD(Invasion, m_generate_mapinfo, void(Gametype this, string v))
 414     {
 415         if(v == "invasion_spawnpoint")
 416             MapInfo_Map_supportedGametypes |= this.m_flags;
 417     }
 418 ENDCLASS(Invasion)
 419 REGISTER_GAMETYPE(INVASION, NEW(Invasion));
 420
 421 const int MAPINFO_FEATURE_WEAPONS       = 1; // not defined for instagib-only maps
 422 const int MAPINFO_FEATURE_VEHICLES      = 2;
 423 const int MAPINFO_FEATURE_TURRETS       = 4;
 424 const int MAPINFO_FEATURE_MONSTERS      = 8;
 425
 426 const int MAPINFO_FLAG_HIDDEN           = 1; // not in lsmaps/menu/vcall/etc., can just be changed to manually
 427 const int MAPINFO_FLAG_FORBIDDEN        = 2; // don't even allow the map by a cvar setting that allows hidden maps
 428 const int MAPINFO_FLAG_FRUSTRATING      = 4; // this map is near impossible to play, enable at your own risk
 429 const int MAPINFO_FLAG_NOAUTOMAPLIST    = 8; // do not include when automatically building maplist (counts as hidden for maplist building purposes)
 430
 431 float MapInfo_count;
 432
 433 // load MapInfo_count; generate mapinfo for maps that miss them, and clear the
 434 // cache; you need to call MapInfo_FilterGametype afterwards!
 435 void MapInfo_Enumerate();
 436
 437 // filter the info by game type mask (updates MapInfo_count)
 438 float MapInfo_progress;
 439 float MapInfo_FilterGametype(Gametype gametypeFlags, float features, float pFlagsRequired, float pFlagsForbidden, float pAbortOnGenerate); // 1 on success, 0 on temporary failure (call it again next frame then; use MapInfo_progress as progress indicator)
 440 float _MapInfo_FilterGametype(int gametypeFlags, float features, float pFlagsRequired, float pFlagsForbidden, float pAbortOnGenerate); // 1 on success, 0 on temporary failure (call it again next frame then; use MapInfo_progress as progress indicator)
 441 void MapInfo_FilterString(string sf); // filter _MapInfo_filtered (created by MapInfo_FilterGametype) with keyword
 442 int MapInfo_CurrentFeatures(); // retrieves currently required features from cvars
 443 Gametype MapInfo_CurrentGametype(); // retrieves current gametype from cvars
 444 int MapInfo_ForbiddenFlags(); // retrieves current flags from cvars
 445 int MapInfo_RequiredFlags(); // retrieves current flags from cvars
 446
 447 // load info about the i-th map into the MapInfo_Map_* globals
 448 float MapInfo_Get_ByID(float i); // 1 on success, 0 on failure
 449 string MapInfo_BSPName_ByID(float i);
 450
 451 // load info about a map by name into the MapInfo_Map_* globals
 452 int MapInfo_Get_ByName(string s, float allowGenerate, Gametype gametypeToSet); // 1 on success, 0 on failure, 2 if it autogenerated a mapinfo file
 453
 454 // look for a map by a prefix, returns the actual map name on success, string_null on failure or ambigous match
 455 string MapInfo_FindName_match; // the name of the map that was found
 456 float MapInfo_FindName_firstResult; // -1 if none were found, index of first one if not unique but found (FindName then returns -1)
 457 float MapInfo_FindName(string s);
 458 string MapInfo_FixName(string s);
 459
 460 // play a map
 461 float MapInfo_CheckMap(string s); // returns 0 if the map can't be played with the current settings
 462 void MapInfo_LoadMap(string s, float reinit);
 463
 464 // list all maps for the current game type
 465 string MapInfo_ListAllowedMaps(Gametype type, float pFlagsRequired, float pFlagsForbidden);
 466 // list all allowed maps (for any game type)
 467 string MapInfo_ListAllAllowedMaps(float pFlagsRequired, float pFlagsForbidden);
 468
 469 // gets a gametype from a string
 470 string _MapInfo_GetDefaultEx(Gametype t);
 471 float _MapInfo_GetTeamPlayBool(Gametype t);
 472 Gametype MapInfo_Type_FromString(string t);
 473 string MapInfo_Type_Description(Gametype t);
 474 string MapInfo_Type_ToString(Gametype t);
 475 string MapInfo_Type_ToText(Gametype t);
 476 void MapInfo_SwitchGameType(Gametype t);
 477
 478 // to be called from worldspawn to set up cvars
 479 void MapInfo_LoadMapSettings(string s);
 480 Gametype MapInfo_LoadedGametype; // game type that was active during map load
 481
 482 void MapInfo_Cache_Destroy(); // disable caching
 483 void MapInfo_Cache_Create(); // enable caching
 484 void MapInfo_Cache_Invalidate(); // delete cache if any, but keep enabled
 485
 486 void MapInfo_ClearTemps(); // call this when done with mapinfo for this frame
 487
 488 void MapInfo_Shutdown(); // call this in the shutdown handler
 489
 490 #define MAPINFO_SETTEMP_ACL_USER cvar_string("g_mapinfo_settemp_acl")
 491 #define MAPINFO_SETTEMP_ACL_SYSTEM "-g_mapinfo_* -rcon_* -_* -g_ban* +*"