f3c140fd11472c37437644e22aa3c5fe56db721f
[xonotic/xonotic-data.pk3dir.git] / qcsrc / common / gamemodes / gamemode / keepaway / sv_keepaway.qc
1 #include "sv_keepaway.qh"
2
3 #include <common/effects/all.qh>
4
5 .entity ballcarried;
6
7 int autocvar_g_keepaway_ballcarrier_effects;
8 float autocvar_g_keepaway_ballcarrier_damage;
9 float autocvar_g_keepaway_ballcarrier_force;
10 float autocvar_g_keepaway_ballcarrier_highspeed;
11 float autocvar_g_keepaway_ballcarrier_selfdamage;
12 float autocvar_g_keepaway_ballcarrier_selfforce;
13 float autocvar_g_keepaway_noncarrier_damage;
14 float autocvar_g_keepaway_noncarrier_force;
15 float autocvar_g_keepaway_noncarrier_selfdamage;
16 float autocvar_g_keepaway_noncarrier_selfforce;
17 bool autocvar_g_keepaway_noncarrier_warn;
18 int autocvar_g_keepaway_score_bckill;
19 int autocvar_g_keepaway_score_killac;
20 int autocvar_g_keepaway_score_timepoints;
21 float autocvar_g_keepaway_score_timeinterval;
22 float autocvar_g_keepawayball_damageforcescale;
23 int autocvar_g_keepawayball_effects;
24 float autocvar_g_keepawayball_respawntime;
25 int autocvar_g_keepawayball_trail_color;
26
27 bool ka_ballcarrier_waypointsprite_visible_for_player(entity this, entity player, entity view) // runs on waypoints which are attached to ballcarriers, updates once per frame
28 {
29         if(view.ballcarried)
30                 if(IS_SPEC(player))
31                         return false; // we don't want spectators of the ballcarrier to see the attached waypoint on the top of their screen
32
33         // TODO: Make the ballcarrier lack a waypointsprite whenever they have the invisibility powerup
34
35         return true;
36 }
37
38 void ka_EventLog(string mode, entity actor) // use an alias for easy changing and quick editing later
39 {
40         if(autocvar_sv_eventlog)
41                 GameLogEcho(strcat(":ka:", mode, ((actor != NULL) ? (strcat(":", ftos(actor.playerid))) : "")));
42 }
43
44 void ka_TouchEvent(entity this, entity toucher);
45 void ka_RespawnBall(entity this) // runs whenever the ball needs to be relocated
46 {
47         if(game_stopped) return;
48         vector oldballorigin = this.origin;
49
50         if(!MoveToRandomMapLocation(this, DPCONTENTS_SOLID | DPCONTENTS_CORPSE | DPCONTENTS_PLAYERCLIP, DPCONTENTS_SLIME | DPCONTENTS_LAVA | DPCONTENTS_SKY | DPCONTENTS_BODY | DPCONTENTS_DONOTENTER, Q3SURFACEFLAG_SKY, 10, 1024, 256))
51         {
52                 entity spot = SelectSpawnPoint(this, true);
53                 setorigin(this, spot.origin);
54                 this.angles = spot.angles;
55         }
56
57         makevectors(this.angles);
58         set_movetype(this, MOVETYPE_BOUNCE);
59         this.velocity = '0 0 200';
60         this.angles = '0 0 0';
61         this.effects = autocvar_g_keepawayball_effects;
62         settouch(this, ka_TouchEvent);
63         setthink(this, ka_RespawnBall);
64         this.nextthink = time + autocvar_g_keepawayball_respawntime;
65         navigation_dynamicgoal_set(this, NULL);
66
67         Send_Effect(EFFECT_ELECTRO_COMBO, oldballorigin, '0 0 0', 1);
68         Send_Effect(EFFECT_ELECTRO_COMBO, this.origin, '0 0 0', 1);
69
70         WaypointSprite_Spawn(WP_KaBall, 0, 0, this, '0 0 64', NULL, this.team, this, waypointsprite_attachedforcarrier, false, RADARICON_FLAGCARRIER);
71         WaypointSprite_Ping(this.waypointsprite_attachedforcarrier);
72
73         sound(this, CH_TRIGGER, SND_KA_RESPAWN, VOL_BASE, ATTEN_NONE); // ATTEN_NONE (it's a sound intended to be heard anywhere)
74 }
75
76 void ka_TimeScoring(entity this)
77 {
78         if(this.owner.ballcarried)
79         { // add points for holding the ball after a certain amount of time
80                 if(autocvar_g_keepaway_score_timepoints)
81                         GameRules_scoring_add(this.owner, SCORE, autocvar_g_keepaway_score_timepoints);
82
83                 GameRules_scoring_add(this.owner, KEEPAWAY_BCTIME, (autocvar_g_keepaway_score_timeinterval / 1)); // interval is divided by 1 so that time always shows "seconds"
84                 this.nextthink = time + autocvar_g_keepaway_score_timeinterval;
85         }
86 }
87
88 void ka_TouchEvent(entity this, entity toucher) // runs any time that the ball comes in contact with something
89 {
90         if (!this || game_stopped)
91                 return;
92
93         if(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT)
94         { // The ball fell off the map, respawn it since players can't get to it
95                 ka_RespawnBall(this);
96                 return;
97         }
98         if(IS_DEAD(toucher)) { return; }
99         if(STAT(FROZEN, toucher)) { return; }
100         if (!IS_PLAYER(toucher))
101         {  // The ball just touched an object, most likely the world
102                 Send_Effect(EFFECT_BALL_SPARKS, this.origin, '0 0 0', 1);
103                 sound(this, CH_TRIGGER, SND_KA_TOUCH, VOL_BASE, ATTEN_NORM);
104                 return;
105         }
106         else if(this.wait > time) { return; }
107
108         // attach the ball to the player
109         this.owner = toucher;
110         toucher.ballcarried = this;
111         GameRules_scoring_vip(toucher, true);
112         setattachment(this, toucher, "");
113         setorigin(this, '0 0 0');
114
115         // make the ball invisible/unable to do anything/set up time scoring
116         this.velocity = '0 0 0';
117         set_movetype(this, MOVETYPE_NONE);
118         this.effects |= EF_NODRAW;
119         settouch(this, func_null);
120         setthink(this, ka_TimeScoring);
121         this.nextthink = time + autocvar_g_keepaway_score_timeinterval;
122         this.takedamage = DAMAGE_NO;
123         navigation_dynamicgoal_unset(this);
124
125         // apply effects to player
126         toucher.glow_color = autocvar_g_keepawayball_trail_color;
127         toucher.glow_trail = true;
128         toucher.effects |= autocvar_g_keepaway_ballcarrier_effects;
129
130         // messages and sounds
131         ka_EventLog("pickup", toucher);
132         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_KEEPAWAY_PICKUP, toucher.netname);
133         Send_Notification(NOTIF_ALL_EXCEPT, toucher, MSG_CENTER, CENTER_KEEPAWAY_PICKUP, toucher.netname);
134         Send_Notification(NOTIF_ONE, toucher, MSG_CENTER, CENTER_KEEPAWAY_PICKUP_SELF);
135         sound(this.owner, CH_TRIGGER, SND_KA_PICKEDUP, VOL_BASE, ATTEN_NONE); // ATTEN_NONE (it's a sound intended to be heard anywhere)
136
137         // scoring
138         GameRules_scoring_add(toucher, KEEPAWAY_PICKUPS, 1);
139
140         // waypoints
141         WaypointSprite_AttachCarrier(WP_KaBallCarrier, toucher, RADARICON_FLAGCARRIER);
142         toucher.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = ka_ballcarrier_waypointsprite_visible_for_player;
143         WaypointSprite_UpdateRule(toucher.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
144         WaypointSprite_Ping(toucher.waypointsprite_attachedforcarrier);
145         WaypointSprite_Kill(this.waypointsprite_attachedforcarrier);
146 }
147
148 void ka_PlayerReset(entity plyr)
149 {
150         plyr.ballcarried = NULL;
151         GameRules_scoring_vip(plyr, false);
152         WaypointSprite_Kill(plyr.waypointsprite_attachedforcarrier);
153
154         // reset the player effects
155         plyr.glow_trail = false;
156         plyr.effects &= ~autocvar_g_keepaway_ballcarrier_effects;
157 }
158
159 void ka_DropEvent(entity plyr) // runs any time that a player is supposed to lose the ball
160 {
161         entity ball;
162         ball = plyr.ballcarried;
163
164         if(!ball) { return; }
165
166         // reset the ball
167         setattachment(ball, NULL, "");
168         set_movetype(ball, MOVETYPE_BOUNCE);
169         ball.wait = time + 1;
170         settouch(ball, ka_TouchEvent);
171         setthink(ball, ka_RespawnBall);
172         ball.nextthink = time + autocvar_g_keepawayball_respawntime;
173         ball.takedamage = DAMAGE_YES;
174         ball.effects &= ~EF_NODRAW;
175         setorigin(ball, plyr.origin + '0 0 10');
176         ball.velocity = '0 0 200' + '0 100 0'*crandom() + '100 0 0'*crandom();
177         ball.owner = NULL;
178         navigation_dynamicgoal_set(ball, plyr);
179
180         // messages and sounds
181         ka_EventLog("dropped", plyr);
182         Send_Notification(NOTIF_ALL, NULL, MSG_INFO, INFO_KEEPAWAY_DROPPED, plyr.netname);
183         Send_Notification(NOTIF_ALL, NULL, MSG_CENTER, CENTER_KEEPAWAY_DROPPED, plyr.netname);
184         sound(NULL, CH_TRIGGER, SND_KA_DROPPED, VOL_BASE, ATTEN_NONE); // ATTEN_NONE (it's a sound intended to be heard anywhere)
185
186         // waypoints
187         WaypointSprite_Spawn(WP_KaBall, 0, 0, ball, '0 0 64', NULL, ball.team, ball, waypointsprite_attachedforcarrier, false, RADARICON_FLAGCARRIER);
188         WaypointSprite_UpdateRule(ball.waypointsprite_attachedforcarrier, 0, SPRITERULE_DEFAULT);
189         WaypointSprite_Ping(ball.waypointsprite_attachedforcarrier);
190
191         ka_PlayerReset(plyr);
192 }
193
194 .bool pushable;
195
196 MODEL(KA_BALL, "models/orbs/orbblue.md3");
197
198 void ka_RemoveBall()
199 {
200         entity plyr = ka_ball.owner;
201         if (plyr) // it was attached
202                 ka_PlayerReset(plyr);
203         else
204                 WaypointSprite_DetachCarrier(ka_ball);
205         delete(ka_ball);
206         ka_ball = NULL;
207 }
208
209 void ka_SpawnBall()
210 {
211         entity e = new(keepawayball);
212         setmodel(e, MDL_KA_BALL);
213         setsize(e, '-16 -16 -20', '16 16 20'); // 20 20 20 was too big, player is only 16 16 24... gotta cheat with the Z (20) axis so that the particle isn't cut off
214         e.damageforcescale = autocvar_g_keepawayball_damageforcescale;
215         e.takedamage = DAMAGE_YES;
216         e.solid = SOLID_TRIGGER;
217         set_movetype(e, MOVETYPE_BOUNCE);
218         e.glow_color = autocvar_g_keepawayball_trail_color;
219         e.glow_trail = true;
220         e.flags = FL_ITEM;
221         IL_PUSH(g_items, e);
222         e.pushable = true;
223         settouch(e, ka_TouchEvent);
224         e.owner = NULL;
225         ka_ball = e;
226         navigation_dynamicgoal_init(ka_ball, false);
227
228         InitializeEntity(e, ka_RespawnBall, INITPRIO_SETLOCATION); // is this the right priority? Neh, I have no idea.. Well-- it works! So.
229 }
230
231 void ka_Handler_CheckBall(entity this)
232 {
233         if(time < game_starttime)
234         {
235                 if (ka_ball)
236                         ka_RemoveBall();
237         }
238         else
239         {
240                 if (!ka_ball)
241                         ka_SpawnBall();
242         }
243
244         this.nextthink = time;
245 }
246
247 void ka_Initialize() // run at the start of a match, initiates game mode
248 {
249         ka_Handler = new(ka_Handler);
250         setthink(ka_Handler, ka_Handler_CheckBall);
251         ka_Handler.nextthink = time;
252 }
253
254
255 // ================
256 // Bot player logic
257 // ================
258
259 void havocbot_goalrating_ball(entity this, float ratingscale, vector org)
260 {
261         entity ball_owner;
262         ball_owner = ka_ball.owner;
263
264         if (ball_owner == this)
265                 return;
266
267         if (ball_owner)
268                 navigation_routerating(this, ball_owner, ratingscale, 2000);
269         else
270                 navigation_routerating(this, ka_ball, ratingscale, 2000);
271 }
272
273 void havocbot_role_ka_carrier(entity this)
274 {
275         if (IS_DEAD(this))
276                 return;
277
278         if (navigation_goalrating_timeout(this))
279         {
280                 navigation_goalrating_start(this);
281                 havocbot_goalrating_items(this, 10000, this.origin, 10000);
282                 havocbot_goalrating_enemyplayers(this, 10000, this.origin, 10000);
283                 havocbot_goalrating_waypoints(this, 1, this.origin, 3000);
284                 navigation_goalrating_end(this);
285
286                 navigation_goalrating_timeout_set(this);
287         }
288
289         if (!this.ballcarried)
290         {
291                 this.havocbot_role = havocbot_role_ka_collector;
292                 navigation_goalrating_timeout_expire(this, 2);
293         }
294 }
295
296 void havocbot_role_ka_collector(entity this)
297 {
298         if (IS_DEAD(this))
299                 return;
300
301         if (navigation_goalrating_timeout(this))
302         {
303                 navigation_goalrating_start(this);
304                 havocbot_goalrating_items(this, 10000, this.origin, 10000);
305                 havocbot_goalrating_enemyplayers(this, 500, this.origin, 10000);
306                 havocbot_goalrating_ball(this, 8000, this.origin);
307                 navigation_goalrating_end(this);
308
309                 navigation_goalrating_timeout_set(this);
310         }
311
312         if (this.ballcarried)
313         {
314                 this.havocbot_role = havocbot_role_ka_carrier;
315                 navigation_goalrating_timeout_expire(this, 2);
316         }
317 }
318
319
320 // ==============
321 // Hook Functions
322 // ==============
323
324 MUTATOR_HOOKFUNCTION(ka, PlayerDies)
325 {
326         entity frag_attacker = M_ARGV(1, entity);
327         entity frag_target = M_ARGV(2, entity);
328
329         if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)))
330         {
331                 if(frag_target.ballcarried) { // add to amount of times killing carrier
332                         GameRules_scoring_add(frag_attacker, KEEPAWAY_CARRIERKILLS, 1);
333                         if(autocvar_g_keepaway_score_bckill) // add bckills to the score
334                                 GameRules_scoring_add(frag_attacker, SCORE, autocvar_g_keepaway_score_bckill);
335                 }
336                 else if(!frag_attacker.ballcarried)
337                         if(autocvar_g_keepaway_noncarrier_warn)
338                                 Send_Notification(NOTIF_ONE_ONLY, frag_attacker, MSG_CENTER, CENTER_KEEPAWAY_WARN);
339
340                 if(frag_attacker.ballcarried) // add to amount of kills while ballcarrier
341                         GameRules_scoring_add(frag_attacker, SCORE, autocvar_g_keepaway_score_killac);
342         }
343
344         if(frag_target.ballcarried) { ka_DropEvent(frag_target); } // a player with the ball has died, drop it
345 }
346
347 MUTATOR_HOOKFUNCTION(ka, GiveFragsForKill)
348 {
349         M_ARGV(2, float) = 0; // no frags counted in keepaway
350         return true; // you deceptive little bugger ;3 This needs to be true in order for this function to even count.
351 }
352
353 MUTATOR_HOOKFUNCTION(ka, Scores_CountFragsRemaining)
354 {
355         // announce remaining frags, but only when timed scoring is off
356         return !autocvar_g_keepaway_score_timepoints;
357 }
358
359 MUTATOR_HOOKFUNCTION(ka, PlayerPreThink)
360 {
361         entity player = M_ARGV(0, entity);
362
363         // clear the item used for the ball in keepaway
364         player.items &= ~IT_KEY1;
365
366         // if the player has the ball, make sure they have the item for it (Used for HUD primarily)
367         if(player.ballcarried)
368                 player.items |= IT_KEY1;
369 }
370
371 MUTATOR_HOOKFUNCTION(ka, PlayerUseKey)
372 {
373         entity player = M_ARGV(0, entity);
374
375         if(MUTATOR_RETURNVALUE == 0)
376         if(player.ballcarried)
377         {
378                 ka_DropEvent(player);
379                 return true;
380         }
381 }
382
383 MUTATOR_HOOKFUNCTION(ka, Damage_Calculate) // for changing damage and force values that are applied to players in g_damage.qc
384 {
385         entity frag_attacker = M_ARGV(1, entity);
386         entity frag_target = M_ARGV(2, entity);
387         float frag_damage = M_ARGV(4, float);
388         vector frag_force = M_ARGV(6, vector);
389
390         if(frag_attacker.ballcarried) // if the attacker is a ballcarrier
391         {
392                 if(frag_target == frag_attacker) // damage done to yourself
393                 {
394                         frag_damage *= autocvar_g_keepaway_ballcarrier_selfdamage;
395                         frag_force *= autocvar_g_keepaway_ballcarrier_selfforce;
396                 }
397                 else // damage done to noncarriers
398                 {
399                         frag_damage *= autocvar_g_keepaway_ballcarrier_damage;
400                         frag_force *= autocvar_g_keepaway_ballcarrier_force;
401                 }
402         }
403         else if (IS_PLAYER(frag_attacker) && !frag_target.ballcarried) // if the target is a noncarrier
404         {
405                 if(frag_target == frag_attacker) // damage done to yourself
406                 {
407                         frag_damage *= autocvar_g_keepaway_noncarrier_selfdamage;
408                         frag_force *= autocvar_g_keepaway_noncarrier_selfforce;
409                 }
410                 else // damage done to other noncarriers
411                 {
412                         frag_damage *= autocvar_g_keepaway_noncarrier_damage;
413                         frag_force *= autocvar_g_keepaway_noncarrier_force;
414                 }
415         }
416
417         M_ARGV(4, float) = frag_damage;
418         M_ARGV(6, vector) = frag_force;
419 }
420
421 MUTATOR_HOOKFUNCTION(ka, ClientDisconnect)
422 {
423         entity player = M_ARGV(0, entity);
424
425         if(player.ballcarried) { ka_DropEvent(player); } // a player with the ball has left the match, drop it
426 }
427
428 MUTATOR_HOOKFUNCTION(ka, MakePlayerObserver)
429 {
430         entity player = M_ARGV(0, entity);
431
432         if(player.ballcarried) { ka_DropEvent(player); } // a player with the ball has left the match, drop it
433 }
434
435 MUTATOR_HOOKFUNCTION(ka, PlayerPowerups)
436 {
437         entity player = M_ARGV(0, entity);
438
439         // In the future this hook is supposed to allow me to do some extra stuff with waypointsprites and invisibility powerup
440         // So bare with me until I can fix a certain bug with ka_ballcarrier_waypointsprite_visible_for_player()
441
442         player.effects &= ~autocvar_g_keepaway_ballcarrier_effects;
443
444         if(player.ballcarried)
445                 player.effects |= autocvar_g_keepaway_ballcarrier_effects;
446 }
447
448
449 MUTATOR_HOOKFUNCTION(ka, PlayerPhysics_UpdateStats)
450 {
451         entity player = M_ARGV(0, entity);
452         // these automatically reset, no need to worry
453
454         if(player.ballcarried)
455                 STAT(MOVEVARS_HIGHSPEED, player) *= autocvar_g_keepaway_ballcarrier_highspeed;
456 }
457
458 MUTATOR_HOOKFUNCTION(ka, BotShouldAttack)
459 {
460         entity bot = M_ARGV(0, entity);
461         entity targ = M_ARGV(1, entity);
462
463         // if neither player has ball then don't attack unless the ball is on the ground
464         if(!targ.ballcarried && !bot.ballcarried && ka_ball.owner)
465                 return true;
466 }
467
468 MUTATOR_HOOKFUNCTION(ka, HavocBot_ChooseRole)
469 {
470         entity bot = M_ARGV(0, entity);
471
472         if (bot.ballcarried)
473                 bot.havocbot_role = havocbot_role_ka_carrier;
474         else
475                 bot.havocbot_role = havocbot_role_ka_collector;
476         return true;
477 }
478
479 MUTATOR_HOOKFUNCTION(ka, DropSpecialItems)
480 {
481         entity frag_target = M_ARGV(0, entity);
482
483         if(frag_target.ballcarried)
484                 ka_DropEvent(frag_target);
485 }