qcsrc/common/gamemodes/gamemode/assault/sv_assault.qc

   1 #include "sv_assault.qh"
   2
   3 .entity sprite;
   4 #define AS_ROUND_DELAY 5
   5
   6 // random functions
   7 void assault_objective_use(entity this, entity actor, entity trigger)
   8 {
   9         // activate objective
  10         SetResourceExplicit(this, RES_HEALTH, 100);
  11         //print("^2Activated objective ", this.targetname, "=", etos(this), "\n");
  12         //print("Activator is ", actor.classname, "\n");
  13
  14         IL_EACH(g_assault_objectivedecreasers, it.target == this.targetname,
  15         {
  16                 target_objective_decrease_activate(it);
  17         });
  18 }
  19
  20 vector target_objective_spawn_evalfunc(entity this, entity player, entity spot, vector current)
  21 {
  22         float hlth = GetResource(this, RES_HEALTH);
  23         if (hlth < 0 || hlth >= ASSAULT_VALUE_INACTIVE)
  24                 return '-1 0 0';
  25         return current;
  26 }
  27
  28 // reset this objective. Used when spawning an objective
  29 // and when a new round starts
  30 void assault_objective_reset(entity this)
  31 {
  32         SetResourceExplicit(this, RES_HEALTH, ASSAULT_VALUE_INACTIVE);
  33 }
  34
  35 // decrease the health of targeted objectives
  36 void assault_objective_decrease_use(entity this, entity actor, entity trigger)
  37 {
  38         if(actor.team != assault_attacker_team)
  39         {
  40                 // wrong team triggered decrease
  41                 return;
  42         }
  43
  44         if(trigger.assault_sprite)
  45         {
  46                 WaypointSprite_Disown(trigger.assault_sprite, waypointsprite_deadlifetime);
  47                 if(trigger.classname == "func_assault_destructible")
  48                         trigger.sprite = NULL; // TODO: just unsetting it?!
  49         }
  50         else
  51                 return; // already activated! cannot activate again!
  52
  53         float hlth = GetResource(this.enemy, RES_HEALTH);
  54         if (hlth < ASSAULT_VALUE_INACTIVE)
  55         {
  56                 if (hlth - this.dmg > 0.5)
  57                 {
  58                         GameRules_scoring_add_team(actor, SCORE, this.dmg);
  59                         TakeResource(this.enemy, RES_HEALTH, this.dmg);
  60                 }
  61                 else
  62                 {
  63                         GameRules_scoring_add_team(actor, SCORE, hlth);
  64                         GameRules_scoring_add_team(actor, ASSAULT_OBJECTIVES, 1);
  65                         SetResourceExplicit(this.enemy, RES_HEALTH, -1);
  66
  67                         if(this.enemy.message)
  68                                 FOREACH_CLIENT(IS_PLAYER(it), { centerprint(it, this.enemy.message); });
  69
  70                         SUB_UseTargets(this.enemy, this, trigger);
  71                 }
  72         }
  73 }
  74
  75 void assault_setenemytoobjective(entity this)
  76 {
  77         IL_EACH(g_assault_objectives, it.targetname == this.target,
  78         {
  79                 if(this.enemy == NULL)
  80                         this.enemy = it;
  81                 else
  82                         objerror(this, "more than one objective as target - fix the map!");
  83                 break;
  84         });
  85
  86         if(this.enemy == NULL)
  87                 objerror(this, "no objective as target - fix the map!");
  88 }
  89
  90 bool assault_decreaser_sprite_visible(entity this, entity player, entity view)
  91 {
  92         if(GetResource(this.assault_decreaser.enemy, RES_HEALTH) >= ASSAULT_VALUE_INACTIVE)
  93                 return false;
  94
  95         return true;
  96 }
  97
  98 void target_objective_decrease_activate(entity this)
  99 {
 100         entity spr;
 101         this.owner = NULL;
 102         FOREACH_ENTITY_STRING(target, this.targetname,
 103         {
 104                 if(it.assault_sprite != NULL)
 105                 {
 106                         WaypointSprite_Disown(it.assault_sprite, waypointsprite_deadlifetime);
 107                         if(it.classname == "func_assault_destructible")
 108                                 it.sprite = NULL; // TODO: just unsetting it?!
 109                 }
 110
 111                 spr = WaypointSprite_SpawnFixed(WP_AssaultDefend, 0.5 * (it.absmin + it.absmax), it, assault_sprite, RADARICON_OBJECTIVE);
 112                 spr.assault_decreaser = this;
 113                 spr.waypointsprite_visible_for_player = assault_decreaser_sprite_visible;
 114                 spr.classname = "sprite_waypoint";
 115                 WaypointSprite_UpdateRule(spr, assault_attacker_team, SPRITERULE_TEAMPLAY);
 116                 if(it.classname == "func_assault_destructible")
 117                 {
 118                         WaypointSprite_UpdateSprites(spr, WP_AssaultDefend, WP_AssaultDestroy, WP_AssaultDestroy);
 119                         WaypointSprite_UpdateMaxHealth(spr, it.max_health);
 120                         WaypointSprite_UpdateHealth(spr, GetResource(it, RES_HEALTH));
 121                         it.sprite = spr;
 122                 }
 123                 else
 124                         WaypointSprite_UpdateSprites(spr, WP_AssaultDefend, WP_AssaultPush, WP_AssaultPush);
 125         });
 126 }
 127
 128 void target_objective_decrease_findtarget(entity this)
 129 {
 130         assault_setenemytoobjective(this);
 131 }
 132
 133 void target_assault_roundend_reset(entity this)
 134 {
 135         //print("round end reset\n");
 136         ++this.cnt; // up round counter
 137         this.winning = false; // up round
 138 }
 139
 140 void target_assault_roundend_use(entity this, entity actor, entity trigger)
 141 {
 142         this.winning = 1; // round has been won by attackers
 143 }
 144
 145 void assault_roundstart_use(entity this, entity actor, entity trigger)
 146 {
 147         SUB_UseTargets(this, this, trigger);
 148
 149         //(Re)spawn all turrets
 150         IL_EACH(g_turrets, true,
 151         {
 152                 // Swap turret teams
 153                 if(it.team == NUM_TEAM_1)
 154                         it.team = NUM_TEAM_2;
 155                 else
 156                         it.team = NUM_TEAM_1;
 157
 158                 // Doubles as teamchange
 159                 turret_respawn(it);
 160         });
 161 }
 162 void assault_roundstart_use_this(entity this)
 163 {
 164         assault_roundstart_use(this, NULL, NULL);
 165 }
 166
 167 void assault_wall_think(entity this)
 168 {
 169         if(GetResource(this.enemy, RES_HEALTH) < 0)
 170         {
 171                 this.model = "";
 172                 this.solid = SOLID_NOT;
 173         }
 174         else
 175         {
 176                 this.model = this.mdl;
 177                 this.solid = SOLID_BSP;
 178         }
 179
 180         this.nextthink = time + 0.2;
 181 }
 182
 183 // trigger new round
 184 // reset objectives, toggle spawnpoints, reset triggers, ...
 185 void assault_new_round(entity this)
 186 {
 187         //bprint("ASSAULT: new round\n");
 188
 189         // up round counter
 190         this.winning = this.winning + 1;
 191
 192         // swap attacker/defender roles
 193         if(assault_attacker_team == NUM_TEAM_1)
 194                 assault_attacker_team = NUM_TEAM_2;
 195         else
 196                 assault_attacker_team = NUM_TEAM_1;
 197
 198         IL_EACH(g_saved_team, !IS_CLIENT(it),
 199         {
 200                 if(it.team_saved == NUM_TEAM_1)
 201                         it.team_saved = NUM_TEAM_2;
 202                 else if(it.team_saved == NUM_TEAM_2)
 203                         it.team_saved = NUM_TEAM_1;
 204         });
 205
 206         // reset the level with a countdown
 207         cvar_set("timelimit", ftos(ceil(time - AS_ROUND_DELAY - game_starttime) / 60));
 208         ReadyRestart_force(); // sets game_starttime
 209 }
 210
 211 entity as_round;
 212 .entity ent_winning;
 213 void as_round_think()
 214 {
 215         game_stopped = false;
 216         assault_new_round(as_round.ent_winning);
 217         delete(as_round);
 218         as_round = NULL;
 219 }
 220
 221 // Assault winning condition: If the attackers triggered a round end (by fulfilling all objectives)
 222 // they win. Otherwise the defending team wins once the timelimit passes.
 223 int WinningCondition_Assault()
 224 {
 225         if(as_round)
 226                 return WINNING_NO;
 227
 228         WinningConditionHelper(NULL); // set worldstatus
 229
 230         int status = WINNING_NO;
 231         // as the timelimit has not yet passed just assume the defending team will win
 232         if(assault_attacker_team == NUM_TEAM_1)
 233         {
 234                 SetWinners(team, NUM_TEAM_2);
 235         }
 236         else
 237         {
 238                 SetWinners(team, NUM_TEAM_1);
 239         }
 240
 241         entity ent;
 242         ent = find(NULL, classname, "target_assault_roundend");
 243         if(ent)
 244         {
 245                 if(ent.winning) // round end has been triggered by attacking team
 246                 {
 247                         bprint("Assault: round completed.\n");
 248                         SetWinners(team, assault_attacker_team);
 249
 250                         TeamScore_AddToTeam(assault_attacker_team, ST_ASSAULT_OBJECTIVES, 666 - TeamScore_AddToTeam(assault_attacker_team, ST_ASSAULT_OBJECTIVES, 0));
 251
 252                         if(ent.cnt == 1 || autocvar_g_campaign) // this was the second round
 253                         {
 254                                 status = WINNING_YES;
 255                         }
 256                         else
 257                         {
 258                                 Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_ASSAULT_OBJ_DESTROYED, ceil(time - game_starttime));
 259                                 as_round = new(as_round);
 260                                 as_round.think = as_round_think;
 261                                 as_round.ent_winning = ent;
 262                                 as_round.nextthink = time + AS_ROUND_DELAY;
 263                                 game_stopped = true;
 264
 265                                 // make sure timelimit isn't hit while the game is blocked
 266                                 if(autocvar_timelimit > 0)
 267                                 if(time + AS_ROUND_DELAY >= game_starttime + autocvar_timelimit * 60)
 268                                         cvar_set("timelimit", ftos(autocvar_timelimit + AS_ROUND_DELAY / 60));
 269                         }
 270                 }
 271         }
 272
 273         return status;
 274 }
 275
 276 // spawnfuncs
 277 spawnfunc(info_player_attacker)
 278 {
 279         if (!g_assault) { delete(this); return; }
 280
 281         this.team = NUM_TEAM_1; // red, gets swapped every round
 282         spawnfunc_info_player_deathmatch(this);
 283 }
 284
 285 spawnfunc(info_player_defender)
 286 {
 287         if (!g_assault) { delete(this); return; }
 288
 289         this.team = NUM_TEAM_2; // blue, gets swapped every round
 290         spawnfunc_info_player_deathmatch(this);
 291 }
 292
 293 spawnfunc(target_objective)
 294 {
 295         if (!g_assault) { delete(this); return; }
 296
 297         this.classname = "target_objective";
 298         IL_PUSH(g_assault_objectives, this);
 299         this.use = assault_objective_use;
 300         this.reset = assault_objective_reset;
 301         this.reset(this);
 302         this.spawn_evalfunc = target_objective_spawn_evalfunc;
 303 }
 304
 305 spawnfunc(target_objective_decrease)
 306 {
 307         if (!g_assault) { delete(this); return; }
 308
 309         this.classname = "target_objective_decrease";
 310         IL_PUSH(g_assault_objectivedecreasers, this);
 311
 312         if(!this.dmg)
 313                 this.dmg = 101;
 314
 315         this.use = assault_objective_decrease_use;
 316         SetResourceExplicit(this, RES_HEALTH, ASSAULT_VALUE_INACTIVE);
 317         this.max_health = ASSAULT_VALUE_INACTIVE;
 318         this.enemy = NULL;
 319
 320         InitializeEntity(this, target_objective_decrease_findtarget, INITPRIO_FINDTARGET);
 321 }
 322
 323 // destructible walls that can be used to trigger target_objective_decrease
 324 bool destructible_heal(entity targ, entity inflictor, float amount, float limit)
 325 {
 326         float true_limit = ((limit != RES_LIMIT_NONE) ? limit : targ.max_health);
 327         float hlth = GetResource(targ, RES_HEALTH);
 328         if (hlth <= 0 || hlth >= true_limit)
 329                 return false;
 330
 331         GiveResourceWithLimit(targ, RES_HEALTH, amount, true_limit);
 332         if(targ.sprite)
 333         {
 334                 WaypointSprite_UpdateHealth(targ.sprite, GetResource(targ, RES_HEALTH));
 335         }
 336         func_breakable_colormod(targ);
 337         return true;
 338 }
 339
 340 spawnfunc(func_breakable);
 341 spawnfunc(func_assault_destructible)
 342 {
 343         if (!g_assault) { delete(this); return; }
 344
 345         this.spawnflags = 3;
 346         this.classname = "func_assault_destructible";
 347         this.event_heal = destructible_heal;
 348         IL_PUSH(g_assault_destructibles, this);
 349
 350         if(assault_attacker_team == NUM_TEAM_1)
 351                 this.team = NUM_TEAM_2;
 352         else
 353                 this.team = NUM_TEAM_1;
 354
 355         spawnfunc_func_breakable(this);
 356 }
 357
 358 spawnfunc(func_assault_wall)
 359 {
 360         if (!g_assault) { delete(this); return; }
 361
 362         this.classname = "func_assault_wall";
 363         this.mdl = this.model;
 364         _setmodel(this, this.mdl);
 365         this.solid = SOLID_BSP;
 366         setthink(this, assault_wall_think);
 367         this.nextthink = time;
 368         InitializeEntity(this, assault_setenemytoobjective, INITPRIO_FINDTARGET);
 369 }
 370
 371 spawnfunc(target_assault_roundend)
 372 {
 373         if (!g_assault) { delete(this); return; }
 374
 375         this.winning = 0; // round not yet won by attackers
 376         this.classname = "target_assault_roundend";
 377         this.use = target_assault_roundend_use;
 378         this.cnt = 0; // first round
 379         this.reset = target_assault_roundend_reset;
 380 }
 381
 382 spawnfunc(target_assault_roundstart)
 383 {
 384         if (!g_assault) { delete(this); return; }
 385
 386         assault_attacker_team = NUM_TEAM_1;
 387         this.classname = "target_assault_roundstart";
 388         this.use = assault_roundstart_use;
 389         this.reset2 = assault_roundstart_use_this;
 390         InitializeEntity(this, assault_roundstart_use_this, INITPRIO_FINDTARGET);
 391 }
 392
 393 // legacy bot code
 394 void havocbot_goalrating_ast_targets(entity this, float ratingscale)
 395 {
 396         IL_EACH(g_assault_destructibles, it.bot_attack,
 397         {
 398                 if (it.target == "")
 399                         continue;
 400
 401                 bool found = false;
 402                 entity destr = it;
 403                 IL_EACH(g_assault_objectivedecreasers, it.targetname == destr.target,
 404                 {
 405                         float hlth = GetResource(it.enemy, RES_HEALTH);
 406                         if (hlth > 0 && hlth < ASSAULT_VALUE_INACTIVE)
 407                         {
 408                                 found = true;
 409                                 break;
 410                         }
 411                 });
 412
 413                 if(!found)
 414                         continue;
 415
 416                 vector p = 0.5 * (it.absmin + it.absmax);
 417
 418                 // Find and rate waypoints around it
 419                 found = false;
 420                 entity best = NULL;
 421                 float bestvalue = FLOAT_MAX;
 422                 entity des = it;
 423                 for (float radius = 500; radius <= 1500 && !found; radius += 500)
 424                 {
 425                         FOREACH_ENTITY_RADIUS(p, radius, it.classname == "waypoint" && !(it.wpflags & WAYPOINTFLAG_GENERATED),
 426                         {
 427                                 if(checkpvs(it.origin, des))
 428                                 {
 429                                         found = true;
 430                                         if(it.cnt < bestvalue)
 431                                         {
 432                                                 best = it;
 433                                                 bestvalue = it.cnt;
 434                                         }
 435                                 }
 436                         });
 437                 }
 438
 439                 if(best)
 440                 {
 441                 ///     dprint("waypoints around target were found\n");
 442                 //      te_lightning2(NULL, '0 0 0', best.origin);
 443                 //      te_knightspike(best.origin);
 444
 445                         navigation_routerating(this, best, ratingscale, 4000);
 446                         best.cnt += 1;
 447
 448                         this.havocbot_attack_time = 0;
 449
 450                         if(checkpvs(this.origin + this.view_ofs, it))
 451                         if(checkpvs(this.origin + this.view_ofs, best))
 452                         {
 453                         //      dprint("increasing attack time for this target\n");
 454                                 this.havocbot_attack_time = time + 2;
 455                         }
 456                 }
 457         });
 458 }
 459
 460 void havocbot_role_ast_offense(entity this)
 461 {
 462         if(IS_DEAD(this))
 463         {
 464                 this.havocbot_attack_time = 0;
 465                 havocbot_ast_reset_role(this);
 466                 return;
 467         }
 468
 469         // Set the role timeout if necessary
 470         if (!this.havocbot_role_timeout)
 471                 this.havocbot_role_timeout = time + 120;
 472
 473         if (time > this.havocbot_role_timeout)
 474         {
 475                 havocbot_ast_reset_role(this);
 476                 return;
 477         }
 478
 479         if(this.havocbot_attack_time>time)
 480                 return;
 481
 482         if (navigation_goalrating_timeout(this))
 483         {
 484                 // role: offense
 485                 navigation_goalrating_start(this);
 486                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 650);
 487                 havocbot_goalrating_ast_targets(this, 20000);
 488                 havocbot_goalrating_items(this, 30000, this.origin, 10000);
 489                 navigation_goalrating_end(this);
 490
 491                 navigation_goalrating_timeout_set(this);
 492         }
 493 }
 494
 495 void havocbot_role_ast_defense(entity this)
 496 {
 497         if(IS_DEAD(this))
 498         {
 499                 this.havocbot_attack_time = 0;
 500                 havocbot_ast_reset_role(this);
 501                 return;
 502         }
 503
 504         // Set the role timeout if necessary
 505         if (!this.havocbot_role_timeout)
 506                 this.havocbot_role_timeout = time + 120;
 507
 508         if (time > this.havocbot_role_timeout)
 509         {
 510                 havocbot_ast_reset_role(this);
 511                 return;
 512         }
 513
 514         if(this.havocbot_attack_time>time)
 515                 return;
 516
 517         if (navigation_goalrating_timeout(this))
 518         {
 519                 // role: defense
 520                 navigation_goalrating_start(this);
 521                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 3000);
 522                 havocbot_goalrating_ast_targets(this, 20000);
 523                 havocbot_goalrating_items(this, 30000, this.origin, 10000);
 524                 navigation_goalrating_end(this);
 525
 526                 navigation_goalrating_timeout_set(this);
 527         }
 528 }
 529
 530 void havocbot_role_ast_setrole(entity this, float role)
 531 {
 532         switch(role)
 533         {
 534                 case HAVOCBOT_AST_ROLE_DEFENSE:
 535                         this.havocbot_role = havocbot_role_ast_defense;
 536                         this.havocbot_role_timeout = 0;
 537                         break;
 538                 case HAVOCBOT_AST_ROLE_OFFENSE:
 539                         this.havocbot_role = havocbot_role_ast_offense;
 540                         this.havocbot_role_timeout = 0;
 541                         break;
 542         }
 543 }
 544
 545 void havocbot_ast_reset_role(entity this)
 546 {
 547         if(IS_DEAD(this))
 548                 return;
 549
 550         if(this.team == assault_attacker_team)
 551                 havocbot_role_ast_setrole(this, HAVOCBOT_AST_ROLE_OFFENSE);
 552         else
 553                 havocbot_role_ast_setrole(this, HAVOCBOT_AST_ROLE_DEFENSE);
 554 }
 555
 556 // mutator hooks
 557 MUTATOR_HOOKFUNCTION(as, PlayerSpawn)
 558 {
 559         entity player = M_ARGV(0, entity);
 560
 561         if(player.team == assault_attacker_team)
 562                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_ASSAULT_ATTACKING);
 563         else
 564                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_ASSAULT_DEFENDING);
 565 }
 566
 567 MUTATOR_HOOKFUNCTION(as, TurretSpawn)
 568 {
 569         entity turret = M_ARGV(0, entity);
 570
 571         if(!turret.team || turret.team == FLOAT_MAX)
 572                 turret.team = assault_attacker_team; // this gets reversed when match starts (assault_roundstart_use)
 573 }
 574
 575 MUTATOR_HOOKFUNCTION(as, VehicleInit)
 576 {
 577         entity veh = M_ARGV(0, entity);
 578
 579         veh.nextthink = time + 0.5;
 580 }
 581
 582 MUTATOR_HOOKFUNCTION(as, HavocBot_ChooseRole)
 583 {
 584         entity bot = M_ARGV(0, entity);
 585
 586         havocbot_ast_reset_role(bot);
 587         return true;
 588 }
 589
 590 MUTATOR_HOOKFUNCTION(as, PlayHitsound)
 591 {
 592         entity frag_victim = M_ARGV(0, entity);
 593
 594         return (frag_victim.classname == "func_assault_destructible");
 595 }
 596
 597 MUTATOR_HOOKFUNCTION(as, TeamBalance_CheckAllowedTeams)
 598 {
 599         // assault always has 2 teams
 600         M_ARGV(0, float) = BIT(0) | BIT(1);
 601         return true;
 602 }
 603
 604 MUTATOR_HOOKFUNCTION(as, CheckRules_World)
 605 {
 606         M_ARGV(0, float) = WinningCondition_Assault();
 607         return true;
 608 }
 609
 610 MUTATOR_HOOKFUNCTION(as, ReadLevelCvars)
 611 {
 612         // incompatible
 613         warmup_stage = 0;
 614         sv_ready_restart_after_countdown = 0;
 615 }
 616
 617 MUTATOR_HOOKFUNCTION(as, OnEntityPreSpawn)
 618 {
 619         entity ent = M_ARGV(0, entity);
 620
 621         switch(ent.classname)
 622         {
 623                 case "info_player_team1":
 624                 case "info_player_team2":
 625                 case "info_player_team3":
 626                 case "info_player_team4":
 627                         return true;
 628         }
 629 }
 630
 631 MUTATOR_HOOKFUNCTION(as, ReadyRestart_Deny)
 632 {
 633         // readyrestart not supported (yet)
 634         return true;
 635 }