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