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