Remove SELFPARAM() from .think and .touch
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / mutator / gamemode_ctf.qc
1 #include "gamemode_ctf.qh"
2
3 #ifdef IMPLEMENTATION
4 #ifndef CSQC
5 void ctf_Initialize();
6
7 REGISTER_MUTATOR(ctf, false)
8 {
9         MUTATOR_ONADD
10         {
11                 if (time > 1) // game loads at time 1
12                         error("This is a game type and it cannot be added at runtime.");
13                 ctf_Initialize();
14
15                 ActivateTeamplay();
16                 SetLimits(autocvar_capturelimit_override, autocvar_captureleadlimit_override, autocvar_timelimit_override, -1);
17                 have_team_spawns = -1; // request team spawns
18         }
19
20         MUTATOR_ONROLLBACK_OR_REMOVE
21         {
22                 // we actually cannot roll back ctf_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 #endif
36
37 #ifdef SVQC
38 #include <common/vehicles/all.qh>
39 #include <server/teamplay.qh>
40 #endif
41
42 #include <lib/warpzone/common.qh>
43
44 bool autocvar_g_ctf_allow_vehicle_carry;
45 bool autocvar_g_ctf_allow_vehicle_touch;
46 bool autocvar_g_ctf_allow_monster_touch;
47 bool autocvar_g_ctf_throw;
48 float autocvar_g_ctf_throw_angle_max;
49 float autocvar_g_ctf_throw_angle_min;
50 int autocvar_g_ctf_throw_punish_count;
51 float autocvar_g_ctf_throw_punish_delay;
52 float autocvar_g_ctf_throw_punish_time;
53 float autocvar_g_ctf_throw_strengthmultiplier;
54 float autocvar_g_ctf_throw_velocity_forward;
55 float autocvar_g_ctf_throw_velocity_up;
56 float autocvar_g_ctf_drop_velocity_up;
57 float autocvar_g_ctf_drop_velocity_side;
58 bool autocvar_g_ctf_oneflag_reverse;
59 bool autocvar_g_ctf_portalteleport;
60 bool autocvar_g_ctf_pass;
61 float autocvar_g_ctf_pass_arc;
62 float autocvar_g_ctf_pass_arc_max;
63 float autocvar_g_ctf_pass_directional_max;
64 float autocvar_g_ctf_pass_directional_min;
65 float autocvar_g_ctf_pass_radius;
66 float autocvar_g_ctf_pass_wait;
67 bool autocvar_g_ctf_pass_request;
68 float autocvar_g_ctf_pass_turnrate;
69 float autocvar_g_ctf_pass_timelimit;
70 float autocvar_g_ctf_pass_velocity;
71 bool autocvar_g_ctf_dynamiclights;
72 float autocvar_g_ctf_flag_collect_delay;
73 float autocvar_g_ctf_flag_damageforcescale;
74 bool autocvar_g_ctf_flag_dropped_waypoint;
75 bool autocvar_g_ctf_flag_dropped_floatinwater;
76 bool autocvar_g_ctf_flag_glowtrails;
77 int autocvar_g_ctf_flag_health;
78 bool autocvar_g_ctf_flag_return;
79 bool autocvar_g_ctf_flag_return_carrying;
80 float autocvar_g_ctf_flag_return_carried_radius;
81 float autocvar_g_ctf_flag_return_time;
82 bool autocvar_g_ctf_flag_return_when_unreachable;
83 float autocvar_g_ctf_flag_return_damage;
84 float autocvar_g_ctf_flag_return_damage_delay;
85 float autocvar_g_ctf_flag_return_dropped;
86 float autocvar_g_ctf_flagcarrier_auto_helpme_damage;
87 float autocvar_g_ctf_flagcarrier_auto_helpme_time;
88 float autocvar_g_ctf_flagcarrier_selfdamagefactor;
89 float autocvar_g_ctf_flagcarrier_selfforcefactor;
90 float autocvar_g_ctf_flagcarrier_damagefactor;
91 float autocvar_g_ctf_flagcarrier_forcefactor;
92 //float autocvar_g_ctf_flagcarrier_waypointforenemy_spotting;
93 bool autocvar_g_ctf_fullbrightflags;
94 bool autocvar_g_ctf_ignore_frags;
95 int autocvar_g_ctf_score_capture;
96 int autocvar_g_ctf_score_capture_assist;
97 int autocvar_g_ctf_score_kill;
98 int autocvar_g_ctf_score_penalty_drop;
99 int autocvar_g_ctf_score_penalty_returned;
100 int autocvar_g_ctf_score_pickup_base;
101 int autocvar_g_ctf_score_pickup_dropped_early;
102 int autocvar_g_ctf_score_pickup_dropped_late;
103 int autocvar_g_ctf_score_return;
104 float autocvar_g_ctf_shield_force;
105 float autocvar_g_ctf_shield_max_ratio;
106 int autocvar_g_ctf_shield_min_negscore;
107 bool autocvar_g_ctf_stalemate;
108 int autocvar_g_ctf_stalemate_endcondition;
109 float autocvar_g_ctf_stalemate_time;
110 bool autocvar_g_ctf_reverse;
111 float autocvar_g_ctf_dropped_capture_delay;
112 float autocvar_g_ctf_dropped_capture_radius;
113
114 void ctf_FakeTimeLimit(entity e, float t)
115 {
116         msg_entity = e;
117         WriteByte(MSG_ONE, 3); // svc_updatestat
118         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
119         if(t < 0)
120                 WriteCoord(MSG_ONE, autocvar_timelimit);
121         else
122                 WriteCoord(MSG_ONE, (t + 1) / 60);
123 }
124
125 void ctf_EventLog(string mode, int flagteam, entity actor) // use an alias for easy changing and quick editing later
126 {
127         if(autocvar_sv_eventlog)
128                 GameLogEcho(sprintf(":ctf:%s:%d:%d:%s", mode, flagteam, actor.team, ((actor != world) ? ftos(actor.playerid) : "")));
129                 //GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
130 }
131
132 void ctf_CaptureRecord(entity flag, entity player)
133 {
134         float cap_record = ctf_captimerecord;
135         float cap_time = (time - flag.ctf_pickuptime);
136         string refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
137
138         // notify about shit
139         if(ctf_oneflag) { Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_CTF_CAPTURE_NEUTRAL, player.netname); }
140         else if(!ctf_captimerecord) { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT(flag, CHOICE_CTF_CAPTURE_TIME), player.netname, (cap_time * 100)); }
141         else if(cap_time < cap_record) { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT(flag, CHOICE_CTF_CAPTURE_BROKEN), player.netname, refername, (cap_time * 100), (cap_record * 100)); }
142         else { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT(flag, CHOICE_CTF_CAPTURE_UNBROKEN), player.netname, refername, (cap_time * 100), (cap_record * 100)); }
143
144         // write that shit in the database
145         if(!ctf_oneflag) // but not in 1-flag mode
146         if((!ctf_captimerecord) || (cap_time < cap_record))
147         {
148                 ctf_captimerecord = cap_time;
149                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
150                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
151                 write_recordmarker(player, (time - cap_time), cap_time);
152         }
153 }
154
155 void ctf_FlagcarrierWaypoints(entity player)
156 {
157         WaypointSprite_Spawn(WP_FlagCarrier, 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, true, RADARICON_FLAG);
158         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id) * 2);
159         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id));
160         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));
161 }
162
163 void ctf_CalculatePassVelocity(entity flag, vector to, vector from, float turnrate)
164 {
165         float current_distance = vlen((('1 0 0' * to.x) + ('0 1 0' * to.y)) - (('1 0 0' * from.x) + ('0 1 0' * from.y))); // for the sake of this check, exclude Z axis
166         float initial_height = min(autocvar_g_ctf_pass_arc_max, (flag.pass_distance * tanh(autocvar_g_ctf_pass_arc)));
167         float current_height = (initial_height * min(1, (current_distance / flag.pass_distance)));
168         //print("current_height = ", ftos(current_height), ", initial_height = ", ftos(initial_height), ".\n");
169
170         vector targpos;
171         if(current_height) // make sure we can actually do this arcing path
172         {
173                 targpos = (to + ('0 0 1' * current_height));
174                 WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
175                 if(trace_fraction < 1)
176                 {
177                         //print("normal arc line failed, trying to find new pos...");
178                         WarpZone_TraceLine(to, targpos, MOVE_NOMONSTERS, flag);
179                         targpos = (trace_endpos + FLAG_PASS_ARC_OFFSET);
180                         WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
181                         if(trace_fraction < 1) { targpos = to; /* print(" ^1FAILURE^7, reverting to original direction.\n"); */ }
182                         /*else { print(" ^3SUCCESS^7, using new arc line.\n"); } */
183                 }
184         }
185         else { targpos = to; }
186
187         //flag.angles = normalize(('0 1 0' * to_y) - ('0 1 0' * from_y));
188
189         vector desired_direction = normalize(targpos - from);
190         if(turnrate) { flag.velocity = (normalize(normalize(flag.velocity) + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); }
191         else { flag.velocity = (desired_direction * autocvar_g_ctf_pass_velocity); }
192 }
193
194 bool ctf_CheckPassDirection(vector head_center, vector passer_center, vector passer_angle, vector nearest_to_passer)
195 {
196         if(autocvar_g_ctf_pass_directional_max || autocvar_g_ctf_pass_directional_min)
197         {
198                 // directional tracing only
199                 float spreadlimit;
200                 makevectors(passer_angle);
201
202                 // find the closest point on the enemy to the center of the attack
203                 float h; // hypotenuse, which is the distance between attacker to head
204                 float a; // adjacent side, which is the distance between attacker and the point on w_shotdir that is closest to head.origin
205
206                 h = vlen(head_center - passer_center);
207                 a = h * (normalize(head_center - passer_center) * v_forward);
208
209                 vector nearest_on_line = (passer_center + a * v_forward);
210                 float distance_from_line = vlen(nearest_to_passer - nearest_on_line);
211
212                 spreadlimit = (autocvar_g_ctf_pass_radius ? min(1, (vlen(passer_center - nearest_on_line) / autocvar_g_ctf_pass_radius)) : 1);
213                 spreadlimit = (autocvar_g_ctf_pass_directional_min * (1 - spreadlimit) + autocvar_g_ctf_pass_directional_max * spreadlimit);
214
215                 if(spreadlimit && (distance_from_line <= spreadlimit) && ((vlen(normalize(head_center - passer_center) - v_forward) * RAD2DEG) <= 90))
216                         { return true; }
217                 else
218                         { return false; }
219         }
220         else { return true; }
221 }
222
223
224 // =======================
225 // CaptureShield Functions
226 // =======================
227
228 bool ctf_CaptureShield_CheckStatus(entity p)
229 {
230         int s, s2, s3, s4, se, se2, se3, se4, sr, ser;
231         int players_worseeq, players_total;
232
233         if(ctf_captureshield_max_ratio <= 0)
234                 return false;
235
236         s = PlayerScore_Add(p, SP_CTF_CAPS, 0);
237         s2 = PlayerScore_Add(p, SP_CTF_PICKUPS, 0);
238         s3 = PlayerScore_Add(p, SP_CTF_RETURNS, 0);
239         s4 = PlayerScore_Add(p, SP_CTF_FCKILLS, 0);
240
241         sr = ((s - s2) + (s3 + s4));
242
243         if(sr >= -ctf_captureshield_min_negscore)
244                 return false;
245
246         players_total = players_worseeq = 0;
247         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
248                 if(DIFF_TEAM(it, p))
249                         continue;
250                 se = PlayerScore_Add(it, SP_CTF_CAPS, 0);
251                 se2 = PlayerScore_Add(it, SP_CTF_PICKUPS, 0);
252                 se3 = PlayerScore_Add(it, SP_CTF_RETURNS, 0);
253                 se4 = PlayerScore_Add(it, SP_CTF_FCKILLS, 0);
254
255                 ser = ((se - se2) + (se3 + se4));
256
257                 if(ser <= sr)
258                         ++players_worseeq;
259                 ++players_total;
260         ));
261
262         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
263         // use this rule here
264
265         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
266                 return false;
267
268         return true;
269 }
270
271 void ctf_CaptureShield_Update(entity player, bool wanted_status)
272 {
273         bool updated_status = ctf_CaptureShield_CheckStatus(player);
274         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
275         {
276                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((updated_status) ? CENTER_CTF_CAPTURESHIELD_SHIELDED : CENTER_CTF_CAPTURESHIELD_FREE));
277                 player.ctf_captureshielded = updated_status;
278         }
279 }
280
281 bool ctf_CaptureShield_Customize()
282 {SELFPARAM();
283         if(!other.ctf_captureshielded) { return false; }
284         if(CTF_SAMETEAM(self, other)) { return false; }
285
286         return true;
287 }
288
289 void ctf_CaptureShield_Touch(entity this)
290 {
291         if(!other.ctf_captureshielded) { return; }
292         if(CTF_SAMETEAM(self, other)) { return; }
293
294         vector mymid = (self.absmin + self.absmax) * 0.5;
295         vector othermid = (other.absmin + other.absmax) * 0.5;
296
297         Damage(other, self, self, 0, DEATH_HURTTRIGGER.m_id, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
298         if(IS_REAL_CLIENT(other)) { Send_Notification(NOTIF_ONE, other, MSG_CENTER, CENTER_CTF_CAPTURESHIELD_SHIELDED); }
299 }
300
301 void ctf_CaptureShield_Spawn(entity flag)
302 {SELFPARAM();
303         entity shield = new(ctf_captureshield);
304
305         shield.enemy = self;
306         shield.team = self.team;
307         settouch(shield, ctf_CaptureShield_Touch);
308         shield.customizeentityforclient = ctf_CaptureShield_Customize;
309         shield.effects = EF_ADDITIVE;
310         shield.movetype = MOVETYPE_NOCLIP;
311         shield.solid = SOLID_TRIGGER;
312         shield.avelocity = '7 0 11';
313         shield.scale = 0.5;
314
315         setorigin(shield, self.origin);
316         setmodel(shield, MDL_CTF_SHIELD);
317         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
318 }
319
320
321 // ====================
322 // Drop/Pass/Throw Code
323 // ====================
324
325 void ctf_Handle_Drop(entity flag, entity player, int droptype)
326 {
327         // declarations
328         player = (player ? player : flag.pass_sender);
329
330         // main
331         flag.movetype = MOVETYPE_TOSS;
332         flag.takedamage = DAMAGE_YES;
333         flag.angles = '0 0 0';
334         flag.health = flag.max_flag_health;
335         flag.ctf_droptime = time;
336         flag.ctf_dropper = player;
337         flag.ctf_status = FLAG_DROPPED;
338
339         // messages and sounds
340         Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_LOST) : INFO_CTF_LOST_NEUTRAL), player.netname);
341         _sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTEN_NONE);
342         ctf_EventLog("dropped", player.team, player);
343
344         // scoring
345         PlayerTeamScore_AddScore(player, -autocvar_g_ctf_score_penalty_drop);
346         PlayerScore_Add(player, SP_CTF_DROPS, 1);
347
348         // waypoints
349         if(autocvar_g_ctf_flag_dropped_waypoint) {
350                 entity wp = WaypointSprite_Spawn(WP_FlagDropped, 0, 0, flag, FLAG_WAYPOINT_OFFSET, world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, true, RADARICON_FLAG);
351                 wp.colormod = WPCOLOR_DROPPEDFLAG(flag.team);
352         }
353
354         if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
355         {
356                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
357                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
358         }
359
360         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
361
362         if(droptype == DROP_PASS)
363         {
364                 flag.pass_distance = 0;
365                 flag.pass_sender = world;
366                 flag.pass_target = world;
367         }
368 }
369
370 void ctf_Handle_Retrieve(entity flag, entity player)
371 {
372         entity sender = flag.pass_sender;
373
374         // transfer flag to player
375         flag.owner = player;
376         flag.owner.flagcarried = flag;
377
378         // reset flag
379         if(player.vehicle)
380         {
381                 setattachment(flag, player.vehicle, "");
382                 setorigin(flag, VEHICLE_FLAG_OFFSET);
383                 flag.scale = VEHICLE_FLAG_SCALE;
384         }
385         else
386         {
387                 setattachment(flag, player, "");
388                 setorigin(flag, FLAG_CARRY_OFFSET);
389         }
390         flag.movetype = MOVETYPE_NONE;
391         flag.takedamage = DAMAGE_NO;
392         flag.solid = SOLID_NOT;
393         flag.angles = '0 0 0';
394         flag.ctf_status = FLAG_CARRY;
395
396         // messages and sounds
397         _sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTEN_NORM);
398         ctf_EventLog("receive", flag.team, player);
399
400         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), LAMBDA(
401                 if(it == sender)
402                         Send_Notification(NOTIF_ONE, it, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT(flag, CENTER_CTF_PASS_SENT) : CENTER_CTF_PASS_SENT_NEUTRAL), player.netname);
403                 else if(it == player)
404                         Send_Notification(NOTIF_ONE, it, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT(flag, CENTER_CTF_PASS_RECEIVED) : CENTER_CTF_PASS_RECEIVED_NEUTRAL), sender.netname);
405                 else if(SAME_TEAM(it, sender))
406                         Send_Notification(NOTIF_ONE, it, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT(flag, CENTER_CTF_PASS_OTHER) : CENTER_CTF_PASS_OTHER_NEUTRAL), sender.netname, player.netname);
407         ));
408
409         // create new waypoint
410         ctf_FlagcarrierWaypoints(player);
411
412         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
413         player.throw_antispam = sender.throw_antispam;
414
415         flag.pass_distance = 0;
416         flag.pass_sender = world;
417         flag.pass_target = world;
418 }
419
420 void ctf_Handle_Throw(entity player, entity receiver, int droptype)
421 {
422         entity flag = player.flagcarried;
423         vector targ_origin, flag_velocity;
424
425         if(!flag) { return; }
426         if((droptype == DROP_PASS) && !receiver) { return; }
427
428         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
429
430         // reset the flag
431         setattachment(flag, world, "");
432         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
433         flag.owner.flagcarried = world;
434         flag.owner = world;
435         flag.solid = SOLID_TRIGGER;
436         flag.ctf_dropper = player;
437         flag.ctf_droptime = time;
438
439         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
440
441         switch(droptype)
442         {
443                 case DROP_PASS:
444                 {
445                         // warpzone support:
446                         // for the examples, we assume player -> wz1 -> ... -> wzn -> receiver
447                         // findradius has already put wzn ... wz1 into receiver's warpzone parameters!
448                         WarpZone_RefSys_Copy(flag, receiver);
449                         WarpZone_RefSys_AddInverse(flag, receiver); // wz1^-1 ... wzn^-1 receiver
450                         targ_origin = WarpZone_RefSys_TransformOrigin(receiver, flag, (0.5 * (receiver.absmin + receiver.absmax))); // this is target origin as seen by the flag
451
452                         flag.pass_distance = vlen((('1 0 0' * targ_origin.x) + ('0 1 0' * targ_origin.y)) - (('1 0 0' *  player.origin.x) + ('0 1 0' *  player.origin.y))); // for the sake of this check, exclude Z axis
453                         ctf_CalculatePassVelocity(flag, targ_origin, player.origin, false);
454
455                         // main
456                         flag.movetype = MOVETYPE_FLY;
457                         flag.takedamage = DAMAGE_NO;
458                         flag.pass_sender = player;
459                         flag.pass_target = receiver;
460                         flag.ctf_status = FLAG_PASSING;
461
462                         // other
463                         _sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTEN_NORM);
464                         WarpZone_TrailParticles(world, _particleeffectnum(flag.passeffect), player.origin, targ_origin);
465                         ctf_EventLog("pass", flag.team, player);
466                         break;
467                 }
468
469                 case DROP_THROW:
470                 {
471                         makevectors((player.v_angle.y * '0 1 0') + (bound(autocvar_g_ctf_throw_angle_min, player.v_angle.x, autocvar_g_ctf_throw_angle_max) * '1 0 0'));
472
473                         flag_velocity = (('0 0 1' * autocvar_g_ctf_throw_velocity_up) + ((v_forward * autocvar_g_ctf_throw_velocity_forward) * ((player.items & ITEM_Strength.m_itemid) ? autocvar_g_ctf_throw_strengthmultiplier : 1)));
474                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, flag_velocity, false);
475                         ctf_Handle_Drop(flag, player, droptype);
476                         break;
477                 }
478
479                 case DROP_RESET:
480                 {
481                         flag.velocity = '0 0 0'; // do nothing
482                         break;
483                 }
484
485                 default:
486                 case DROP_NORMAL:
487                 {
488                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, (('0 0 1' * autocvar_g_ctf_drop_velocity_up) + ((('0 1 0' * crandom()) + ('1 0 0' * crandom())) * autocvar_g_ctf_drop_velocity_side)), false);
489                         ctf_Handle_Drop(flag, player, droptype);
490                         break;
491                 }
492         }
493
494         // kill old waypointsprite
495         WaypointSprite_Ping(player.wps_flagcarrier);
496         WaypointSprite_Kill(player.wps_flagcarrier);
497
498         if(player.wps_enemyflagcarrier)
499                 WaypointSprite_Kill(player.wps_enemyflagcarrier);
500
501         // captureshield
502         ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
503 }
504
505 void shockwave_spawn(string m, vector org, float sz, float t1, float t2)
506 {
507         return modeleffect_spawn(m, 0, 0, org, '0 0 0', '0 0 0', '0 0 0', 0, sz, 1, t1, t2);
508 }
509
510 // ==============
511 // Event Handlers
512 // ==============
513
514 void nades_GiveBonus(entity player, float score);
515
516 void ctf_Handle_Capture(entity flag, entity toucher, int capturetype)
517 {
518         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
519         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
520         entity player_team_flag = world, tmp_entity;
521         float old_time, new_time;
522
523         if(!player) { return; } // without someone to give the reward to, we can't possibly cap
524         if(CTF_DIFFTEAM(player, flag)) { return; }
525
526         if(ctf_oneflag)
527         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
528         if(SAME_TEAM(tmp_entity, player))
529         {
530                 player_team_flag = tmp_entity;
531                 break;
532         }
533
534         nades_GiveBonus(player, autocvar_g_nades_bonus_score_high );
535
536         player.throw_prevtime = time;
537         player.throw_count = 0;
538
539         // messages and sounds
540         Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((enemy_flag.team) ? APP_TEAM_ENT(enemy_flag, CENTER_CTF_CAPTURE) : CENTER_CTF_CAPTURE_NEUTRAL));
541         ctf_CaptureRecord(enemy_flag, player);
542         _sound(player, CH_TRIGGER, ((ctf_oneflag) ? player_team_flag.snd_flag_capture : ((DIFF_TEAM(player, flag)) ? enemy_flag.snd_flag_capture : flag.snd_flag_capture)), VOL_BASE, ATTEN_NONE);
543
544         switch(capturetype)
545         {
546                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
547                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
548                 default: break;
549         }
550
551         // scoring
552         PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_capture);
553         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
554
555         old_time = PlayerScore_Add(player, SP_CTF_CAPTIME, 0);
556         new_time = TIME_ENCODE(time - enemy_flag.ctf_pickuptime);
557         if(!old_time || new_time < old_time)
558                 PlayerScore_Add(player, SP_CTF_CAPTIME, new_time - old_time);
559
560         // effects
561         Send_Effect_(flag.capeffect, flag.origin, '0 0 0', 1);
562         //shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
563
564         // other
565         if(capturetype == CAPTURE_NORMAL)
566         {
567                 WaypointSprite_Kill(player.wps_flagcarrier);
568                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
569
570                 if((enemy_flag.ctf_dropper) && (player != enemy_flag.ctf_dropper))
571                         { PlayerTeamScore_AddScore(enemy_flag.ctf_dropper, autocvar_g_ctf_score_capture_assist); }
572         }
573
574         // reset the flag
575         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
576         ctf_RespawnFlag(enemy_flag);
577 }
578
579 void ctf_Handle_Return(entity flag, entity player)
580 {
581         // messages and sounds
582         if(IS_MONSTER(player))
583         {
584                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT(flag, INFO_CTF_RETURN_MONSTER), player.monster_name);
585         }
586         else if(flag.team)
587         {
588                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_ENT(flag, CENTER_CTF_RETURN));
589                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT(flag, INFO_CTF_RETURN), player.netname);
590         }
591         _sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTEN_NONE);
592         ctf_EventLog("return", flag.team, player);
593
594         // scoring
595         if(IS_PLAYER(player))
596         {
597                 PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_return); // reward for return
598                 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
599
600                 nades_GiveBonus(player,autocvar_g_nades_bonus_score_medium);
601         }
602
603         TeamScore_AddToTeam(flag.team, ST_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the team who was last carrying it
604
605         if(flag.ctf_dropper)
606         {
607                 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the player who dropped the flag
608                 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
609                 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
610         }
611
612         // other
613         if(player.flagcarried == flag)
614                 WaypointSprite_Kill(player.wps_flagcarrier);
615
616         // reset the flag
617         ctf_RespawnFlag(flag);
618 }
619
620 void ctf_Handle_Pickup(entity flag, entity player, int pickuptype)
621 {
622         // declarations
623         float pickup_dropped_score; // used to calculate dropped pickup score
624
625         // attach the flag to the player
626         flag.owner = player;
627         player.flagcarried = flag;
628         if(player.vehicle)
629         {
630                 setattachment(flag, player.vehicle, "");
631                 setorigin(flag, VEHICLE_FLAG_OFFSET);
632                 flag.scale = VEHICLE_FLAG_SCALE;
633         }
634         else
635         {
636                 setattachment(flag, player, "");
637                 setorigin(flag, FLAG_CARRY_OFFSET);
638         }
639
640         // flag setup
641         flag.movetype = MOVETYPE_NONE;
642         flag.takedamage = DAMAGE_NO;
643         flag.solid = SOLID_NOT;
644         flag.angles = '0 0 0';
645         flag.ctf_status = FLAG_CARRY;
646
647         switch(pickuptype)
648         {
649                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
650                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
651                 default: break;
652         }
653
654         // messages and sounds
655         Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_PICKUP) : INFO_CTF_PICKUP_NEUTRAL), player.netname);
656         if(ctf_stalemate) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_STALEMATE_CARRIER); }
657         if(!flag.team) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PICKUP_NEUTRAL); }
658         else if(CTF_DIFFTEAM(player, flag)) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_ENT(flag, CENTER_CTF_PICKUP)); }
659         else { Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((SAME_TEAM(player, flag)) ? CENTER_CTF_PICKUP_TEAM : CENTER_CTF_PICKUP_TEAM_ENEMY), Team_ColorCode(flag.team)); }
660
661         Send_Notification(NOTIF_TEAM_EXCEPT, player, MSG_CHOICE, ((flag.team) ? APP_TEAM_ENT(flag, CHOICE_CTF_PICKUP_TEAM) : CHOICE_CTF_PICKUP_TEAM_NEUTRAL), Team_ColorCode(player.team), player.netname);
662
663         if(!flag.team)
664                 FOREACH_CLIENT(IS_PLAYER(it) && it != player && DIFF_TEAM(it, player), LAMBDA(Send_Notification(NOTIF_ONE, it, MSG_CHOICE, CHOICE_CTF_PICKUP_ENEMY_NEUTRAL, Team_ColorCode(player.team), player.netname)));
665
666         if(flag.team)
667                 FOREACH_CLIENT(IS_PLAYER(it) && it != player, LAMBDA(
668                         if(CTF_SAMETEAM(flag, it))
669                         if(SAME_TEAM(player, it))
670                                 Send_Notification(NOTIF_ONE, it, MSG_CHOICE, APP_TEAM_ENT(flag, CHOICE_CTF_PICKUP_TEAM), Team_ColorCode(player.team), player.netname);
671                         else
672                                 Send_Notification(NOTIF_ONE, it, MSG_CHOICE, ((SAME_TEAM(flag, player)) ? CHOICE_CTF_PICKUP_ENEMY_TEAM : CHOICE_CTF_PICKUP_ENEMY), Team_ColorCode(player.team), player.netname);
673                 ));
674
675         _sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTEN_NONE);
676
677         // scoring
678         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
679         nades_GiveBonus(player, autocvar_g_nades_bonus_score_minor);
680         switch(pickuptype)
681         {
682                 case PICKUP_BASE:
683                 {
684                         PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_pickup_base);
685                         ctf_EventLog("steal", flag.team, player);
686                         break;
687                 }
688
689                 case PICKUP_DROPPED:
690                 {
691                         pickup_dropped_score = (autocvar_g_ctf_flag_return_time ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_return_time) - time) / autocvar_g_ctf_flag_return_time, 1) : 1);
692                         pickup_dropped_score = floor((autocvar_g_ctf_score_pickup_dropped_late * (1 - pickup_dropped_score) + autocvar_g_ctf_score_pickup_dropped_early * pickup_dropped_score) + 0.5);
693                         LOG_TRACE("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
694                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
695                         ctf_EventLog("pickup", flag.team, player);
696                         break;
697                 }
698
699                 default: break;
700         }
701
702         // speedrunning
703         if(pickuptype == PICKUP_BASE)
704         {
705                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
706                 if((player.speedrunning) && (ctf_captimerecord))
707                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
708         }
709
710         // effects
711         Send_Effect_(flag.toucheffect, player.origin, '0 0 0', 1);
712
713         // waypoints
714         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
715         ctf_FlagcarrierWaypoints(player);
716         WaypointSprite_Ping(player.wps_flagcarrier);
717 }
718
719
720 // ===================
721 // Main Flag Functions
722 // ===================
723
724 void ctf_CheckFlagReturn(entity flag, int returntype)
725 {
726         if((flag.ctf_status == FLAG_DROPPED) || (flag.ctf_status == FLAG_PASSING))
727         {
728                 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
729
730                 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
731                 {
732                         switch(returntype)
733                         {
734                                 case RETURN_DROPPED: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_FLAGRETURN_DROPPED) : INFO_CTF_FLAGRETURN_DROPPED_NEUTRAL)); break;
735                                 case RETURN_DAMAGE: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_FLAGRETURN_DAMAGED) : INFO_CTF_FLAGRETURN_DAMAGED_NEUTRAL)); break;
736                                 case RETURN_SPEEDRUN: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_FLAGRETURN_SPEEDRUN) : INFO_CTF_FLAGRETURN_SPEEDRUN_NEUTRAL), ctf_captimerecord); break;
737                                 case RETURN_NEEDKILL: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_FLAGRETURN_NEEDKILL) : INFO_CTF_FLAGRETURN_NEEDKILL_NEUTRAL)); break;
738
739                                 default:
740                                 case RETURN_TIMEOUT:
741                                         { Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT(flag, INFO_CTF_FLAGRETURN_TIMEOUT) : INFO_CTF_FLAGRETURN_TIMEOUT_NEUTRAL)); break; }
742                         }
743                         _sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTEN_NONE);
744                         ctf_EventLog("returned", flag.team, world);
745                         ctf_RespawnFlag(flag);
746                 }
747         }
748 }
749
750 bool ctf_Stalemate_Customize()
751 {SELFPARAM();
752         // make spectators see what the player would see
753         entity e, wp_owner;
754         e = WaypointSprite_getviewentity(other);
755         wp_owner = self.owner;
756
757         // team waypoints
758         if(CTF_SAMETEAM(wp_owner.flagcarried, wp_owner)) { return false; }
759         if(SAME_TEAM(wp_owner, e)) { return false; }
760         if(!IS_PLAYER(e)) { return false; }
761
762         return true;
763 }
764
765 void ctf_CheckStalemate()
766 {
767         // declarations
768         int stale_flags = 0, stale_red_flags = 0, stale_blue_flags = 0, stale_yellow_flags = 0, stale_pink_flags = 0, stale_neutral_flags = 0;
769         entity tmp_entity;
770
771         entity ctf_staleflaglist = world; // reset the list, we need to build the list each time this function runs
772
773         // build list of stale flags
774         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
775         {
776                 if(autocvar_g_ctf_stalemate)
777                 if(tmp_entity.ctf_status != FLAG_BASE)
778                 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_stalemate_time || !tmp_entity.team) // instant stalemate in oneflag
779                 {
780                         tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
781                         ctf_staleflaglist = tmp_entity;
782
783                         switch(tmp_entity.team)
784                         {
785                                 case NUM_TEAM_1: ++stale_red_flags; break;
786                                 case NUM_TEAM_2: ++stale_blue_flags; break;
787                                 case NUM_TEAM_3: ++stale_yellow_flags; break;
788                                 case NUM_TEAM_4: ++stale_pink_flags; break;
789                                 default: ++stale_neutral_flags; break;
790                         }
791                 }
792         }
793
794         if(ctf_oneflag)
795                 stale_flags = (stale_neutral_flags >= 1);
796         else
797                 stale_flags = (stale_red_flags >= 1) + (stale_blue_flags >= 1) + (stale_yellow_flags >= 1) + (stale_pink_flags >= 1);
798
799         if(ctf_oneflag && stale_flags == 1)
800                 ctf_stalemate = true;
801         else if(stale_flags >= 2)
802                 ctf_stalemate = true;
803         else if(stale_flags == 0 && autocvar_g_ctf_stalemate_endcondition == 2)
804                 { ctf_stalemate = false; wpforenemy_announced = false; }
805         else if(stale_flags < 2 && autocvar_g_ctf_stalemate_endcondition == 1)
806                 { ctf_stalemate = false; wpforenemy_announced = false; }
807
808         // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
809         if(ctf_stalemate)
810         {
811                 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
812                 {
813                         if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
814                         {
815                                 entity wp = WaypointSprite_Spawn(((ctf_oneflag) ? WP_FlagCarrier : WP_FlagCarrierEnemy), 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, world, 0, tmp_entity.owner, wps_enemyflagcarrier, true, RADARICON_FLAG);
816                                 wp.colormod = WPCOLOR_ENEMYFC(tmp_entity.owner.team);
817                                 tmp_entity.owner.wps_enemyflagcarrier.customizeentityforclient = ctf_Stalemate_Customize;
818                         }
819                 }
820
821                 if (!wpforenemy_announced)
822                 {
823                         FOREACH_CLIENT(IS_PLAYER(it) && IS_REAL_CLIENT(it), LAMBDA(Send_Notification(NOTIF_ONE, it, MSG_CENTER, ((it.flagcarried) ? CENTER_CTF_STALEMATE_CARRIER : CENTER_CTF_STALEMATE_OTHER))));
824
825                         wpforenemy_announced = true;
826                 }
827         }
828 }
829
830 void ctf_FlagDamage(entity this, entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
831 {
832         if(ITEM_DAMAGE_NEEDKILL(deathtype))
833         {
834                 if(autocvar_g_ctf_flag_return_damage_delay)
835                 {
836                         this.ctf_flagdamaged = true;
837                 }
838                 else
839                 {
840                         this.health = 0;
841                         ctf_CheckFlagReturn(this, RETURN_NEEDKILL);
842                 }
843                 return;
844         }
845         if(autocvar_g_ctf_flag_return_damage)
846         {
847                 // reduce health and check if it should be returned
848                 this.health = this.health - damage;
849                 ctf_CheckFlagReturn(this, RETURN_DAMAGE);
850                 return;
851         }
852 }
853
854 void ctf_FlagThink(entity this)
855 {
856         // declarations
857         entity tmp_entity;
858
859         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
860
861         // captureshield
862         if(self == ctf_worldflaglist) // only for the first flag
863                 FOREACH_CLIENT(true, LAMBDA(ctf_CaptureShield_Update(it, 1))); // release shield only
864
865         // sanity checks
866         if(self.mins != CTF_FLAG.m_mins || self.maxs != CTF_FLAG.m_maxs) { // reset the flag boundaries in case it got squished
867                 LOG_TRACE("wtf the flag got squashed?\n");
868                 tracebox(self.origin, CTF_FLAG.m_mins, CTF_FLAG.m_maxs, self.origin, MOVE_NOMONSTERS, self);
869                 if(!trace_startsolid || self.noalign) // can we resize it without getting stuck?
870                         setsize(self, CTF_FLAG.m_mins, CTF_FLAG.m_maxs); }
871
872         switch(self.ctf_status) // reset flag angles in case warpzones adjust it
873         {
874                 case FLAG_DROPPED:
875                 {
876                         self.angles = '0 0 0';
877                         break;
878                 }
879
880                 default: break;
881         }
882
883         // main think method
884         switch(self.ctf_status)
885         {
886                 case FLAG_BASE:
887                 {
888                         if(autocvar_g_ctf_dropped_capture_radius)
889                         {
890                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
891                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
892                                         if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
893                                         if(time > tmp_entity.ctf_droptime + autocvar_g_ctf_dropped_capture_delay)
894                                                 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
895                         }
896                         return;
897                 }
898
899                 case FLAG_DROPPED:
900                 {
901                         if(autocvar_g_ctf_flag_dropped_floatinwater)
902                         {
903                                 vector midpoint = ((self.absmin + self.absmax) * 0.5);
904                                 if(pointcontents(midpoint) == CONTENT_WATER)
905                                 {
906                                         self.velocity = self.velocity * 0.5;
907
908                                         if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
909                                                 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
910                                         else
911                                                 { self.movetype = MOVETYPE_FLY; }
912                                 }
913                                 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
914                         }
915                         if(autocvar_g_ctf_flag_return_dropped)
916                         {
917                                 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
918                                 {
919                                         self.health = 0;
920                                         ctf_CheckFlagReturn(self, RETURN_DROPPED);
921                                         return;
922                                 }
923                         }
924                         if(self.ctf_flagdamaged)
925                         {
926                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_damage_delay) * FLAG_THINKRATE);
927                                 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
928                                 return;
929                         }
930                         else if(autocvar_g_ctf_flag_return_time)
931                         {
932                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
933                                 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
934                                 return;
935                         }
936                         return;
937                 }
938
939                 case FLAG_CARRY:
940                 {
941                         if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
942                         {
943                                 self.health = 0;
944                                 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
945
946                                 self.owner.impulse = CHIMPULSE_SPEEDRUN.impulse; // move the player back to the waypoint they set
947                                 ImpulseCommands(self.owner);
948                         }
949                         if(autocvar_g_ctf_stalemate)
950                         {
951                                 if(time >= wpforenemy_nextthink)
952                                 {
953                                         ctf_CheckStalemate();
954                                         wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
955                                 }
956                         }
957                         if(CTF_SAMETEAM(self, self.owner) && self.team)
958                         {
959                                 if(autocvar_g_ctf_flag_return) // drop the flag if reverse status has changed
960                                         ctf_Handle_Throw(self.owner, world, DROP_THROW);
961                                 else if(vlen(self.owner.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_carried_radius)
962                                         ctf_Handle_Return(self, self.owner);
963                         }
964                         return;
965                 }
966
967                 case FLAG_PASSING:
968                 {
969                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
970                         targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_target, self, targ_origin); // origin of target as seen by the flag (us)
971                         WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
972
973                         if((self.pass_target == world)
974                                 || (IS_DEAD(self.pass_target))
975                                 || (self.pass_target.flagcarried)
976                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
977                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
978                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
979                         {
980                                 // give up, pass failed
981                                 ctf_Handle_Drop(self, world, DROP_PASS);
982                         }
983                         else
984                         {
985                                 // still a viable target, go for it
986                                 ctf_CalculatePassVelocity(self, targ_origin, self.origin, true);
987                         }
988                         return;
989                 }
990
991                 default: // this should never happen
992                 {
993                         LOG_TRACE("ctf_FlagThink(): Flag exists with no status?\n");
994                         return;
995                 }
996         }
997 }
998
999 METHOD(Flag, giveTo, bool(Flag this, entity flag, entity toucher))
1000 {
1001         return = false;
1002         if(gameover) { return; }
1003         if(trace_dphitcontents & (DPCONTENTS_PLAYERCLIP | DPCONTENTS_MONSTERCLIP)) { return; }
1004
1005         bool is_not_monster = (!IS_MONSTER(toucher));
1006
1007         // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
1008         if(ITEM_TOUCH_NEEDKILL())
1009         {
1010                 if(!autocvar_g_ctf_flag_return_damage_delay)
1011                 {
1012                         flag.health = 0;
1013                         ctf_CheckFlagReturn(flag, RETURN_NEEDKILL);
1014                 }
1015                 if(!flag.ctf_flagdamaged) { return; }
1016         }
1017
1018         int num_perteam = 0;
1019         FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(toucher, it), LAMBDA(++num_perteam));
1020
1021         // special touch behaviors
1022         if(STAT(FROZEN, toucher)) { return; }
1023         else if(IS_VEHICLE(toucher))
1024         {
1025                 if(autocvar_g_ctf_allow_vehicle_touch && toucher.owner)
1026                         toucher = toucher.owner; // the player is actually the vehicle owner, not other
1027                 else
1028                         return; // do nothing
1029         }
1030         else if(IS_MONSTER(toucher))
1031         {
1032                 if(!autocvar_g_ctf_allow_monster_touch)
1033                         return; // do nothing
1034         }
1035         else if (!IS_PLAYER(toucher)) // The flag just touched an object, most likely the world
1036         {
1037                 if(time > flag.wait) // if we haven't in a while, play a sound/effect
1038                 {
1039                         Send_Effect_(flag.toucheffect, flag.origin, '0 0 0', 1);
1040                         _sound(flag, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTEN_NORM);
1041                         flag.wait = time + FLAG_TOUCHRATE;
1042                 }
1043                 return;
1044         }
1045         else if(IS_DEAD(toucher)) { return; }
1046
1047         switch(flag.ctf_status)
1048         {
1049                 case FLAG_BASE:
1050                 {
1051                         if(ctf_oneflag)
1052                         {
1053                                 if(CTF_SAMETEAM(toucher, flag) && (toucher.flagcarried) && !toucher.flagcarried.team && is_not_monster)
1054                                         ctf_Handle_Capture(flag, toucher, CAPTURE_NORMAL); // toucher just captured the neutral flag to enemy base
1055                                 else if(!flag.team && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
1056                                         ctf_Handle_Pickup(flag, toucher, PICKUP_BASE); // toucher just stole the neutral flag
1057                         }
1058                         else if(CTF_SAMETEAM(toucher, flag) && (toucher.flagcarried) && DIFF_TEAM(toucher.flagcarried, flag) && is_not_monster)
1059                                 ctf_Handle_Capture(flag, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
1060                         else if(CTF_DIFFTEAM(toucher, flag) && (toucher.flagcarried) && CTF_SAMETEAM(toucher.flagcarried, toucher) && (!toucher.ctf_captureshielded) && autocvar_g_ctf_flag_return_carrying && (time > toucher.next_take_time) && is_not_monster)
1061                         {
1062                                 ctf_Handle_Return(toucher.flagcarried, toucher); // return their current flag
1063                                 ctf_Handle_Pickup(flag, toucher, PICKUP_BASE); // now pickup the flag
1064                         }
1065                         else if(CTF_DIFFTEAM(toucher, flag) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
1066                                 ctf_Handle_Pickup(flag, toucher, PICKUP_BASE); // toucher just stole the enemies flag
1067                         break;
1068                 }
1069
1070                 case FLAG_DROPPED:
1071                 {
1072                         if(CTF_SAMETEAM(toucher, flag) && (autocvar_g_ctf_flag_return || num_perteam <= 1 || (autocvar_g_ctf_flag_return_carrying && toucher.flagcarried)) && flag.team) // automatically return if there's only 1 player on the team
1073                                 ctf_Handle_Return(flag, toucher); // toucher just returned his own flag
1074                         else if(is_not_monster && (!toucher.flagcarried) && ((toucher != flag.ctf_dropper) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
1075                                 ctf_Handle_Pickup(flag, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
1076                         break;
1077                 }
1078
1079                 case FLAG_CARRY:
1080                 {
1081                         LOG_TRACE("Someone touched a flag even though it was being carried?\n");
1082                         break;
1083                 }
1084
1085                 case FLAG_PASSING:
1086                 {
1087                         if((IS_PLAYER(toucher)) && !IS_DEAD(toucher) && (toucher != flag.pass_sender))
1088                         {
1089                                 if(DIFF_TEAM(toucher, flag.pass_sender))
1090                                         ctf_Handle_Return(flag, toucher);
1091                                 else
1092                                         ctf_Handle_Retrieve(flag, toucher);
1093                         }
1094                         break;
1095                 }
1096         }
1097 }
1098
1099 .float last_respawn;
1100 void ctf_RespawnFlag(entity flag)
1101 {
1102         // check for flag respawn being called twice in a row
1103         if(flag.last_respawn > time - 0.5)
1104                 { backtrace("flag respawn called twice quickly! please notify Samual about this..."); }
1105
1106         flag.last_respawn = time;
1107
1108         // reset the player (if there is one)
1109         if((flag.owner) && (flag.owner.flagcarried == flag))
1110         {
1111                 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
1112                 WaypointSprite_Kill(flag.wps_flagcarrier);
1113
1114                 flag.owner.flagcarried = world;
1115
1116                 if(flag.speedrunning)
1117                         ctf_FakeTimeLimit(flag.owner, -1);
1118         }
1119
1120         if((flag.owner) && (flag.owner.vehicle))
1121                 flag.scale = FLAG_SCALE;
1122
1123         if(flag.ctf_status == FLAG_DROPPED)
1124                 { WaypointSprite_Kill(flag.wps_flagdropped); }
1125
1126         // reset the flag
1127         setattachment(flag, world, "");
1128         setorigin(flag, flag.ctf_spawnorigin);
1129
1130         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
1131         flag.takedamage = DAMAGE_NO;
1132         flag.health = flag.max_flag_health;
1133         flag.solid = SOLID_TRIGGER;
1134         flag.velocity = '0 0 0';
1135         flag.angles = flag.mangle;
1136         flag.flags = FL_ITEM | FL_NOTARGET;
1137
1138         flag.ctf_status = FLAG_BASE;
1139         flag.owner = world;
1140         flag.pass_distance = 0;
1141         flag.pass_sender = world;
1142         flag.pass_target = world;
1143         flag.ctf_dropper = world;
1144         flag.ctf_pickuptime = 0;
1145         flag.ctf_droptime = 0;
1146         flag.ctf_flagdamaged = 0;
1147
1148         ctf_CheckStalemate();
1149 }
1150
1151 void ctf_Reset(entity this)
1152 {
1153         if(this.owner && IS_PLAYER(this.owner))
1154         ctf_Handle_Throw(this.owner, world, DROP_RESET);
1155
1156         ctf_RespawnFlag(this);
1157 }
1158
1159 void ctf_DelayedFlagSetup(entity this) // called after a flag is placed on a map by ctf_FlagSetup()
1160 {
1161         // bot waypoints
1162         waypoint_spawnforitem_force(self, self.origin);
1163         self.nearestwaypointtimeout = 0; // activate waypointing again
1164         self.bot_basewaypoint = self.nearestwaypoint;
1165
1166         // waypointsprites
1167         entity basename;
1168         switch (self.team)
1169         {
1170                 case NUM_TEAM_1: basename = WP_FlagBaseRed; break;
1171                 case NUM_TEAM_2: basename = WP_FlagBaseBlue; break;
1172                 case NUM_TEAM_3: basename = WP_FlagBaseYellow; break;
1173                 case NUM_TEAM_4: basename = WP_FlagBasePink; break;
1174                 default: basename = WP_FlagBaseNeutral; break;
1175         }
1176
1177         entity wp = WaypointSprite_SpawnFixed(basename, self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG);
1178         wp.colormod = ((self.team) ? Team_ColorRGB(self.team) : '1 1 1');
1179         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, ((self.team) ? colormapPaletteColor(self.team - 1, false) : '1 1 1'));
1180
1181         // captureshield setup
1182         ctf_CaptureShield_Spawn(self);
1183 }
1184
1185 .bool pushable;
1186
1187 void ctf_FlagSetup(int teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
1188 {
1189         // main setup
1190         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
1191         ctf_worldflaglist = flag;
1192
1193         setattachment(flag, world, "");
1194
1195         flag.netname = strzone(sprintf("%s%s^7 flag", Team_ColorCode(teamnumber), Team_ColorName_Upper(teamnumber)));
1196         flag.team = teamnumber;
1197         flag.classname = "item_flag_team";
1198         flag.target = "###item###"; // wut?
1199         flag.flags = FL_ITEM | FL_NOTARGET;
1200         flag.solid = SOLID_TRIGGER;
1201         flag.takedamage = DAMAGE_NO;
1202         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
1203         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
1204         flag.health = flag.max_flag_health;
1205         flag.event_damage = ctf_FlagDamage;
1206         flag.pushable = true;
1207         flag.teleportable = TELEPORT_NORMAL;
1208         flag.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_PLAYERCLIP;
1209         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
1210         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
1211         flag.velocity = '0 0 0';
1212         flag.mangle = flag.angles;
1213         flag.reset = ctf_Reset;
1214         settouch(flag, ctf_FlagTouch);
1215         setthink(flag, ctf_FlagThink);
1216         flag.nextthink = time + FLAG_THINKRATE;
1217         flag.ctf_status = FLAG_BASE;
1218
1219         string teamname = Static_Team_ColorName_Lower(teamnumber);
1220         // appearence
1221         if(!flag.scale)                         { flag.scale = FLAG_SCALE; }
1222         if(flag.skin == 0)                      { flag.skin = cvar(sprintf("g_ctf_flag_%s_skin", teamname)); }
1223         if(flag.model == "")            { flag.model = cvar_string(sprintf("g_ctf_flag_%s_model", teamname)); }
1224         if (flag.toucheffect == "") { flag.toucheffect = EFFECT_FLAG_TOUCH(teamnumber).eent_eff_name; }
1225         if (flag.passeffect == "")      { flag.passeffect = EFFECT_PASS(teamnumber).eent_eff_name; }
1226         if (flag.capeffect == "")       { flag.capeffect = EFFECT_CAP(teamnumber).eent_eff_name; }
1227
1228         // sounds
1229 #define X(s,b) \
1230                 if(flag.s == "") flag.s = b; \
1231                 precache_sound(flag.s);
1232
1233         X(snd_flag_taken,               strzone(SND(CTF_TAKEN(teamnumber))))
1234         X(snd_flag_returned,    strzone(SND(CTF_RETURNED(teamnumber))))
1235         X(snd_flag_capture,     strzone(SND(CTF_CAPTURE(teamnumber))))
1236         X(snd_flag_dropped,     strzone(SND(CTF_DROPPED(teamnumber))))
1237         X(snd_flag_respawn,     strzone(SND(CTF_RESPAWN)))
1238         X(snd_flag_touch,               strzone(SND(CTF_TOUCH)))
1239         X(snd_flag_pass,                strzone(SND(CTF_PASS)))
1240 #undef X
1241
1242         // precache
1243         precache_model(flag.model);
1244
1245         // appearence
1246         _setmodel(flag, flag.model); // precision set below
1247         setsize(flag, CTF_FLAG.m_mins, CTF_FLAG.m_maxs);
1248         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
1249
1250         if(autocvar_g_ctf_flag_glowtrails)
1251         {
1252                 switch(teamnumber)
1253                 {
1254                         case NUM_TEAM_1: flag.glow_color = 251; break;
1255                         case NUM_TEAM_2: flag.glow_color = 210; break;
1256                         case NUM_TEAM_3: flag.glow_color = 110; break;
1257                         case NUM_TEAM_4: flag.glow_color = 145; break;
1258                         default:                 flag.glow_color = 254; break;
1259                 }
1260                 flag.glow_size = 25;
1261                 flag.glow_trail = 1;
1262         }
1263
1264         flag.effects |= EF_LOWPRECISION;
1265         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
1266         if(autocvar_g_ctf_dynamiclights)
1267         {
1268                 switch(teamnumber)
1269                 {
1270                         case NUM_TEAM_1: flag.effects |= EF_RED; break;
1271                         case NUM_TEAM_2: flag.effects |= EF_BLUE; break;
1272                         case NUM_TEAM_3: flag.effects |= EF_DIMLIGHT; break;
1273                         case NUM_TEAM_4: flag.effects |= EF_RED; break;
1274                         default:                 flag.effects |= EF_DIMLIGHT; break;
1275                 }
1276         }
1277
1278         // flag placement
1279         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
1280         {
1281                 flag.dropped_origin = flag.origin;
1282                 flag.noalign = true;
1283                 flag.movetype = MOVETYPE_NONE;
1284         }
1285         else // drop to floor, automatically find a platform and set that as spawn origin
1286         {
1287                 flag.noalign = false;
1288                 WITHSELF(flag, droptofloor());
1289                 flag.movetype = MOVETYPE_TOSS;
1290         }
1291
1292         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
1293 }
1294
1295
1296 // ================
1297 // Bot player logic
1298 // ================
1299
1300 // NOTE: LEGACY CODE, needs to be re-written!
1301
1302 void havocbot_calculate_middlepoint()
1303 {
1304         entity f;
1305         vector s = '0 0 0';
1306         vector fo = '0 0 0';
1307         float n = 0;
1308
1309         f = ctf_worldflaglist;
1310         while (f)
1311         {
1312                 fo = f.origin;
1313                 s = s + fo;
1314                 f = f.ctf_worldflagnext;
1315         }
1316         if(!n)
1317                 return;
1318         havocbot_ctf_middlepoint = s * (1.0 / n);
1319         havocbot_ctf_middlepoint_radius  = vlen(fo - havocbot_ctf_middlepoint);
1320 }
1321
1322
1323 entity havocbot_ctf_find_flag(entity bot)
1324 {
1325         entity f;
1326         f = ctf_worldflaglist;
1327         while (f)
1328         {
1329                 if (CTF_SAMETEAM(bot, f))
1330                         return f;
1331                 f = f.ctf_worldflagnext;
1332         }
1333         return world;
1334 }
1335
1336 entity havocbot_ctf_find_enemy_flag(entity bot)
1337 {
1338         entity f;
1339         f = ctf_worldflaglist;
1340         while (f)
1341         {
1342                 if(ctf_oneflag)
1343                 {
1344                         if(CTF_DIFFTEAM(bot, f))
1345                         {
1346                                 if(f.team)
1347                                 {
1348                                         if(bot.flagcarried)
1349                                                 return f;
1350                                 }
1351                                 else if(!bot.flagcarried)
1352                                         return f;
1353                         }
1354                 }
1355                 else if (CTF_DIFFTEAM(bot, f))
1356                         return f;
1357                 f = f.ctf_worldflagnext;
1358         }
1359         return world;
1360 }
1361
1362 int havocbot_ctf_teamcount(entity bot, vector org, float tc_radius)
1363 {
1364         if (!teamplay)
1365                 return 0;
1366
1367         int c = 0;
1368
1369         FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
1370                 if(DIFF_TEAM(it, bot) || IS_DEAD(it) || it == bot)
1371                         continue;
1372
1373                 if(vlen(it.origin - org) < tc_radius)
1374                         ++c;
1375         ));
1376
1377         return c;
1378 }
1379
1380 void havocbot_goalrating_ctf_ourflag(entity this, float ratingscale)
1381 {
1382         entity head;
1383         head = ctf_worldflaglist;
1384         while (head)
1385         {
1386                 if (CTF_SAMETEAM(this, head))
1387                         break;
1388                 head = head.ctf_worldflagnext;
1389         }
1390         if (head)
1391                 navigation_routerating(this, head, ratingscale, 10000);
1392 }
1393
1394 void havocbot_goalrating_ctf_ourbase(entity this, float ratingscale)
1395 {
1396         entity head;
1397         head = ctf_worldflaglist;
1398         while (head)
1399         {
1400                 if (CTF_SAMETEAM(this, head))
1401                         break;
1402                 head = head.ctf_worldflagnext;
1403         }
1404         if (!head)
1405                 return;
1406
1407         navigation_routerating(this, head.bot_basewaypoint, ratingscale, 10000);
1408 }
1409
1410 void havocbot_goalrating_ctf_enemyflag(entity this, float ratingscale)
1411 {
1412         entity head;
1413         head = ctf_worldflaglist;
1414         while (head)
1415         {
1416                 if(ctf_oneflag)
1417                 {
1418                         if(CTF_DIFFTEAM(this, head))
1419                         {
1420                                 if(head.team)
1421                                 {
1422                                         if(this.flagcarried)
1423                                                 break;
1424                                 }
1425                                 else if(!this.flagcarried)
1426                                         break;
1427                         }
1428                 }
1429                 else if(CTF_DIFFTEAM(this, head))
1430                         break;
1431                 head = head.ctf_worldflagnext;
1432         }
1433         if (head)
1434                 navigation_routerating(this, head, ratingscale, 10000);
1435 }
1436
1437 void havocbot_goalrating_ctf_enemybase(entity this, float ratingscale)
1438 {
1439         if (!bot_waypoints_for_items)
1440         {
1441                 havocbot_goalrating_ctf_enemyflag(this, ratingscale);
1442                 return;
1443         }
1444
1445         entity head;
1446
1447         head = havocbot_ctf_find_enemy_flag(this);
1448
1449         if (!head)
1450                 return;
1451
1452         navigation_routerating(this, head.bot_basewaypoint, ratingscale, 10000);
1453 }
1454
1455 void havocbot_goalrating_ctf_ourstolenflag(entity this, float ratingscale)
1456 {
1457         entity mf;
1458
1459         mf = havocbot_ctf_find_flag(this);
1460
1461         if(mf.ctf_status == FLAG_BASE)
1462                 return;
1463
1464         if(mf.tag_entity)
1465                 navigation_routerating(this, mf.tag_entity, ratingscale, 10000);
1466 }
1467
1468 void havocbot_goalrating_ctf_droppedflags(entity this, float ratingscale, vector org, float df_radius)
1469 {
1470         entity head;
1471         head = ctf_worldflaglist;
1472         while (head)
1473         {
1474                 // flag is out in the field
1475                 if(head.ctf_status != FLAG_BASE)
1476                 if(head.tag_entity==world)      // dropped
1477                 {
1478                         if(df_radius)
1479                         {
1480                                 if(vlen(org-head.origin)<df_radius)
1481                                         navigation_routerating(self, head, ratingscale, 10000);
1482                         }
1483                         else
1484                                 navigation_routerating(self, head, ratingscale, 10000);
1485                 }
1486
1487                 head = head.ctf_worldflagnext;
1488         }
1489 }
1490
1491 void havocbot_goalrating_ctf_carrieritems(entity this, float ratingscale, vector org, float sradius)
1492 {
1493         entity head;
1494         float t;
1495         head = findchainfloat(bot_pickup, true);
1496         while (head)
1497         {
1498                 // gather health and armor only
1499                 if (head.solid)
1500                 if (head.health || head.armorvalue)
1501                 if (vlen(head.origin - org) < sradius)
1502                 {
1503                         // get the value of the item
1504                         t = head.bot_pickupevalfunc(this, head) * 0.0001;
1505                         if (t > 0)
1506                                 navigation_routerating(this, head, t * ratingscale, 500);
1507                 }
1508                 head = head.chain;
1509         }
1510 }
1511
1512 void havocbot_ctf_reset_role(entity this)
1513 {
1514         float cdefense, cmiddle, coffense;
1515         entity mf, ef;
1516         float c;
1517
1518         if(IS_DEAD(this))
1519                 return;
1520
1521         if(havocbot_ctf_middlepoint == '0 0 0')
1522                 havocbot_calculate_middlepoint();
1523
1524         // Check ctf flags
1525         if (this.flagcarried)
1526         {
1527                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1528                 return;
1529         }
1530
1531         mf = havocbot_ctf_find_flag(this);
1532         ef = havocbot_ctf_find_enemy_flag(this);
1533
1534         // Retrieve stolen flag
1535         if(mf.ctf_status!=FLAG_BASE)
1536         {
1537                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
1538                 return;
1539         }
1540
1541         // If enemy flag is taken go to the middle to intercept pursuers
1542         if(ef.ctf_status!=FLAG_BASE)
1543         {
1544                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);
1545                 return;
1546         }
1547
1548         // if there is only me on the team switch to offense
1549         c = 0;
1550         FOREACH_CLIENT(IS_PLAYER(it) && SAME_TEAM(it, this), LAMBDA(++c));
1551
1552         if(c==1)
1553         {
1554                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_OFFENSE);
1555                 return;
1556         }
1557
1558         // Evaluate best position to take
1559         // Count mates on middle position
1560         cmiddle = havocbot_ctf_teamcount(this, havocbot_ctf_middlepoint, havocbot_ctf_middlepoint_radius * 0.5);
1561
1562         // Count mates on defense position
1563         cdefense = havocbot_ctf_teamcount(this, mf.dropped_origin, havocbot_ctf_middlepoint_radius * 0.5);
1564
1565         // Count mates on offense position
1566         coffense = havocbot_ctf_teamcount(this, ef.dropped_origin, havocbot_ctf_middlepoint_radius);
1567
1568         if(cdefense<=coffense)
1569                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_DEFENSE);
1570         else if(coffense<=cmiddle)
1571                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_OFFENSE);
1572         else
1573                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);
1574 }
1575
1576 void havocbot_role_ctf_carrier(entity this)
1577 {
1578         if(IS_DEAD(this))
1579         {
1580                 havocbot_ctf_reset_role(this);
1581                 return;
1582         }
1583
1584         if (this.flagcarried == world)
1585         {
1586                 havocbot_ctf_reset_role(this);
1587                 return;
1588         }
1589
1590         if (this.bot_strategytime < time)
1591         {
1592                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1593
1594                 navigation_goalrating_start(this);
1595                 if(ctf_oneflag)
1596                         havocbot_goalrating_ctf_enemybase(this, 50000);
1597                 else
1598                         havocbot_goalrating_ctf_ourbase(this, 50000);
1599
1600                 if(this.health<100)
1601                         havocbot_goalrating_ctf_carrieritems(this, 1000, this.origin, 1000);
1602
1603                 navigation_goalrating_end(this);
1604
1605                 if (this.navigation_hasgoals)
1606                         this.havocbot_cantfindflag = time + 10;
1607                 else if (time > this.havocbot_cantfindflag)
1608                 {
1609                         // Can't navigate to my own base, suicide!
1610                         // TODO: drop it and wander around
1611                         Damage(this, this, this, 100000, DEATH_KILL.m_id, this.origin, '0 0 0');
1612                         return;
1613                 }
1614         }
1615 }
1616
1617 void havocbot_role_ctf_escort(entity this)
1618 {
1619         entity mf, ef;
1620
1621         if(IS_DEAD(this))
1622         {
1623                 havocbot_ctf_reset_role(this);
1624                 return;
1625         }
1626
1627         if (this.flagcarried)
1628         {
1629                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1630                 return;
1631         }
1632
1633         // If enemy flag is back on the base switch to previous role
1634         ef = havocbot_ctf_find_enemy_flag(this);
1635         if(ef.ctf_status==FLAG_BASE)
1636         {
1637                 this.havocbot_role = this.havocbot_previous_role;
1638                 this.havocbot_role_timeout = 0;
1639                 return;
1640         }
1641
1642         // If the flag carrier reached the base switch to defense
1643         mf = havocbot_ctf_find_flag(this);
1644         if(mf.ctf_status!=FLAG_BASE)
1645         if(vlen(ef.origin - mf.dropped_origin) < 300)
1646         {
1647                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_DEFENSE);
1648                 return;
1649         }
1650
1651         // Set the role timeout if necessary
1652         if (!this.havocbot_role_timeout)
1653         {
1654                 this.havocbot_role_timeout = time + random() * 30 + 60;
1655         }
1656
1657         // If nothing happened just switch to previous role
1658         if (time > this.havocbot_role_timeout)
1659         {
1660                 this.havocbot_role = this.havocbot_previous_role;
1661                 this.havocbot_role_timeout = 0;
1662                 return;
1663         }
1664
1665         // Chase the flag carrier
1666         if (this.bot_strategytime < time)
1667         {
1668                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1669                 navigation_goalrating_start(this);
1670                 havocbot_goalrating_ctf_enemyflag(this, 30000);
1671                 havocbot_goalrating_ctf_ourstolenflag(this, 40000);
1672                 havocbot_goalrating_items(this, 10000, this.origin, 10000);
1673                 navigation_goalrating_end(this);
1674         }
1675 }
1676
1677 void havocbot_role_ctf_offense(entity this)
1678 {
1679         entity mf, ef;
1680         vector pos;
1681
1682         if(IS_DEAD(this))
1683         {
1684                 havocbot_ctf_reset_role(this);
1685                 return;
1686         }
1687
1688         if (this.flagcarried)
1689         {
1690                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1691                 return;
1692         }
1693
1694         // Check flags
1695         mf = havocbot_ctf_find_flag(this);
1696         ef = havocbot_ctf_find_enemy_flag(this);
1697
1698         // Own flag stolen
1699         if(mf.ctf_status!=FLAG_BASE)
1700         {
1701                 if(mf.tag_entity)
1702                         pos = mf.tag_entity.origin;
1703                 else
1704                         pos = mf.origin;
1705
1706                 // Try to get it if closer than the enemy base
1707                 if(vlen(this.origin-ef.dropped_origin)>vlen(this.origin-pos))
1708                 {
1709                         havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
1710                         return;
1711                 }
1712         }
1713
1714         // Escort flag carrier
1715         if(ef.ctf_status!=FLAG_BASE)
1716         {
1717                 if(ef.tag_entity)
1718                         pos = ef.tag_entity.origin;
1719                 else
1720                         pos = ef.origin;
1721
1722                 if(vlen(pos-mf.dropped_origin)>700)
1723                 {
1724                         havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_ESCORT);
1725                         return;
1726                 }
1727         }
1728
1729         // About to fail, switch to middlefield
1730         if(this.health<50)
1731         {
1732                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_MIDDLE);
1733                 return;
1734         }
1735
1736         // Set the role timeout if necessary
1737         if (!this.havocbot_role_timeout)
1738                 this.havocbot_role_timeout = time + 120;
1739
1740         if (time > this.havocbot_role_timeout)
1741         {
1742                 havocbot_ctf_reset_role(this);
1743                 return;
1744         }
1745
1746         if (this.bot_strategytime < time)
1747         {
1748                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1749                 navigation_goalrating_start(this);
1750                 havocbot_goalrating_ctf_ourstolenflag(this, 50000);
1751                 havocbot_goalrating_ctf_enemybase(this, 20000);
1752                 havocbot_goalrating_items(this, 5000, this.origin, 1000);
1753                 havocbot_goalrating_items(this, 1000, this.origin, 10000);
1754                 navigation_goalrating_end(this);
1755         }
1756 }
1757
1758 // Retriever (temporary role):
1759 void havocbot_role_ctf_retriever(entity this)
1760 {
1761         entity mf;
1762
1763         if(IS_DEAD(this))
1764         {
1765                 havocbot_ctf_reset_role(this);
1766                 return;
1767         }
1768
1769         if (this.flagcarried)
1770         {
1771                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1772                 return;
1773         }
1774
1775         // If flag is back on the base switch to previous role
1776         mf = havocbot_ctf_find_flag(this);
1777         if(mf.ctf_status==FLAG_BASE)
1778         {
1779                 havocbot_ctf_reset_role(this);
1780                 return;
1781         }
1782
1783         if (!this.havocbot_role_timeout)
1784                 this.havocbot_role_timeout = time + 20;
1785
1786         if (time > this.havocbot_role_timeout)
1787         {
1788                 havocbot_ctf_reset_role(this);
1789                 return;
1790         }
1791
1792         if (this.bot_strategytime < time)
1793         {
1794                 float rt_radius;
1795                 rt_radius = 10000;
1796
1797                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1798                 navigation_goalrating_start(this);
1799                 havocbot_goalrating_ctf_ourstolenflag(this, 50000);
1800                 havocbot_goalrating_ctf_droppedflags(this, 40000, this.origin, rt_radius);
1801                 havocbot_goalrating_ctf_enemybase(this, 30000);
1802                 havocbot_goalrating_items(this, 500, this.origin, rt_radius);
1803                 navigation_goalrating_end(this);
1804         }
1805 }
1806
1807 void havocbot_role_ctf_middle(entity this)
1808 {
1809         entity mf;
1810
1811         if(IS_DEAD(this))
1812         {
1813                 havocbot_ctf_reset_role(this);
1814                 return;
1815         }
1816
1817         if (this.flagcarried)
1818         {
1819                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1820                 return;
1821         }
1822
1823         mf = havocbot_ctf_find_flag(this);
1824         if(mf.ctf_status!=FLAG_BASE)
1825         {
1826                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
1827                 return;
1828         }
1829
1830         if (!this.havocbot_role_timeout)
1831                 this.havocbot_role_timeout = time + 10;
1832
1833         if (time > this.havocbot_role_timeout)
1834         {
1835                 havocbot_ctf_reset_role(this);
1836                 return;
1837         }
1838
1839         if (this.bot_strategytime < time)
1840         {
1841                 vector org;
1842
1843                 org = havocbot_ctf_middlepoint;
1844                 org.z = this.origin.z;
1845
1846                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1847                 navigation_goalrating_start(this);
1848                 havocbot_goalrating_ctf_ourstolenflag(this, 50000);
1849                 havocbot_goalrating_ctf_droppedflags(this, 30000, this.origin, 10000);
1850                 havocbot_goalrating_enemyplayers(this, 10000, org, havocbot_ctf_middlepoint_radius * 0.5);
1851                 havocbot_goalrating_items(this, 5000, org, havocbot_ctf_middlepoint_radius * 0.5);
1852                 havocbot_goalrating_items(this, 2500, this.origin, 10000);
1853                 havocbot_goalrating_ctf_enemybase(this, 2500);
1854                 navigation_goalrating_end(this);
1855         }
1856 }
1857
1858 void havocbot_role_ctf_defense(entity this)
1859 {
1860         entity mf;
1861
1862         if(IS_DEAD(this))
1863         {
1864                 havocbot_ctf_reset_role(this);
1865                 return;
1866         }
1867
1868         if (this.flagcarried)
1869         {
1870                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_CARRIER);
1871                 return;
1872         }
1873
1874         // If own flag was captured
1875         mf = havocbot_ctf_find_flag(this);
1876         if(mf.ctf_status!=FLAG_BASE)
1877         {
1878                 havocbot_role_ctf_setrole(this, HAVOCBOT_CTF_ROLE_RETRIEVER);
1879                 return;
1880         }
1881
1882         if (!this.havocbot_role_timeout)
1883                 this.havocbot_role_timeout = time + 30;
1884
1885         if (time > this.havocbot_role_timeout)
1886         {
1887                 havocbot_ctf_reset_role(this);
1888                 return;
1889         }
1890         if (this.bot_strategytime < time)
1891         {
1892                 float mp_radius;
1893                 vector org;
1894
1895                 org = mf.dropped_origin;
1896                 mp_radius = havocbot_ctf_middlepoint_radius;
1897
1898                 this.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1899                 navigation_goalrating_start(this);
1900
1901                 // if enemies are closer to our base, go there
1902                 entity closestplayer = world;
1903                 float distance, bestdistance = 10000;
1904                 FOREACH_CLIENT(IS_PLAYER(it) && !IS_DEAD(it), LAMBDA(
1905                         distance = vlen(org - it.origin);
1906                         if(distance<bestdistance)
1907                         {
1908                                 closestplayer = it;
1909                                 bestdistance = distance;
1910                         }
1911                 ));
1912
1913                 if(closestplayer)
1914                 if(DIFF_TEAM(closestplayer, this))
1915                 if(vlen(org - this.origin)>1000)
1916                 if(checkpvs(this.origin,closestplayer)||random()<0.5)
1917                         havocbot_goalrating_ctf_ourbase(this, 30000);
1918
1919                 havocbot_goalrating_ctf_ourstolenflag(this, 20000);
1920                 havocbot_goalrating_ctf_droppedflags(this, 20000, org, mp_radius);
1921                 havocbot_goalrating_enemyplayers(this, 15000, org, mp_radius);
1922                 havocbot_goalrating_items(this, 10000, org, mp_radius);
1923                 havocbot_goalrating_items(this, 5000, this.origin, 10000);
1924                 navigation_goalrating_end(this);
1925         }
1926 }
1927
1928 void havocbot_role_ctf_setrole(entity bot, int role)
1929 {
1930         LOG_TRACE(strcat(bot.netname," switched to "));
1931         switch(role)
1932         {
1933                 case HAVOCBOT_CTF_ROLE_CARRIER:
1934                         LOG_TRACE("carrier");
1935                         bot.havocbot_role = havocbot_role_ctf_carrier;
1936                         bot.havocbot_role_timeout = 0;
1937                         bot.havocbot_cantfindflag = time + 10;
1938                         bot.bot_strategytime = 0;
1939                         break;
1940                 case HAVOCBOT_CTF_ROLE_DEFENSE:
1941                         LOG_TRACE("defense");
1942                         bot.havocbot_role = havocbot_role_ctf_defense;
1943                         bot.havocbot_role_timeout = 0;
1944                         break;
1945                 case HAVOCBOT_CTF_ROLE_MIDDLE:
1946                         LOG_TRACE("middle");
1947                         bot.havocbot_role = havocbot_role_ctf_middle;
1948                         bot.havocbot_role_timeout = 0;
1949                         break;
1950                 case HAVOCBOT_CTF_ROLE_OFFENSE:
1951                         LOG_TRACE("offense");
1952                         bot.havocbot_role = havocbot_role_ctf_offense;
1953                         bot.havocbot_role_timeout = 0;
1954                         break;
1955                 case HAVOCBOT_CTF_ROLE_RETRIEVER:
1956                         LOG_TRACE("retriever");
1957                         bot.havocbot_previous_role = bot.havocbot_role;
1958                         bot.havocbot_role = havocbot_role_ctf_retriever;
1959                         bot.havocbot_role_timeout = time + 10;
1960                         bot.bot_strategytime = 0;
1961                         break;
1962                 case HAVOCBOT_CTF_ROLE_ESCORT:
1963                         LOG_TRACE("escort");
1964                         bot.havocbot_previous_role = bot.havocbot_role;
1965                         bot.havocbot_role = havocbot_role_ctf_escort;
1966                         bot.havocbot_role_timeout = time + 30;
1967                         bot.bot_strategytime = 0;
1968                         break;
1969         }
1970         LOG_TRACE("\n");
1971 }
1972
1973
1974 // ==============
1975 // Hook Functions
1976 // ==============
1977
1978 MUTATOR_HOOKFUNCTION(ctf, PlayerPreThink)
1979 {SELFPARAM();
1980         entity flag;
1981         int t = 0, t2 = 0, t3 = 0;
1982
1983         // initially clear items so they can be set as necessary later.
1984         self.ctf_flagstatus &= ~(CTF_RED_FLAG_CARRYING          | CTF_RED_FLAG_TAKEN            | CTF_RED_FLAG_LOST
1985                                                    | CTF_BLUE_FLAG_CARRYING             | CTF_BLUE_FLAG_TAKEN           | CTF_BLUE_FLAG_LOST
1986                                                    | CTF_YELLOW_FLAG_CARRYING   | CTF_YELLOW_FLAG_TAKEN         | CTF_YELLOW_FLAG_LOST
1987                                                    | CTF_PINK_FLAG_CARRYING     | CTF_PINK_FLAG_TAKEN           | CTF_PINK_FLAG_LOST
1988                                                    | CTF_NEUTRAL_FLAG_CARRYING  | CTF_NEUTRAL_FLAG_TAKEN        | CTF_NEUTRAL_FLAG_LOST
1989                                                    | CTF_FLAG_NEUTRAL | CTF_SHIELDED);
1990
1991         // scan through all the flags and notify the client about them
1992         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1993         {
1994                 if(flag.team == NUM_TEAM_1) { t = CTF_RED_FLAG_CARRYING;                t2 = CTF_RED_FLAG_TAKEN;                t3 = CTF_RED_FLAG_LOST; }
1995                 if(flag.team == NUM_TEAM_2) { t = CTF_BLUE_FLAG_CARRYING;               t2 = CTF_BLUE_FLAG_TAKEN;               t3 = CTF_BLUE_FLAG_LOST; }
1996                 if(flag.team == NUM_TEAM_3) { t = CTF_YELLOW_FLAG_CARRYING;     t2 = CTF_YELLOW_FLAG_TAKEN;             t3 = CTF_YELLOW_FLAG_LOST; }
1997                 if(flag.team == NUM_TEAM_4) { t = CTF_PINK_FLAG_CARRYING;               t2 = CTF_PINK_FLAG_TAKEN;               t3 = CTF_PINK_FLAG_LOST; }
1998                 if(flag.team == 0)                      { t = CTF_NEUTRAL_FLAG_CARRYING;        t2 = CTF_NEUTRAL_FLAG_TAKEN;    t3 = CTF_NEUTRAL_FLAG_LOST; self.ctf_flagstatus |= CTF_FLAG_NEUTRAL; }
1999
2000                 switch(flag.ctf_status)
2001                 {
2002                         case FLAG_PASSING:
2003                         case FLAG_CARRY:
2004                         {
2005                                 if((flag.owner == self) || (flag.pass_sender == self))
2006                                         self.ctf_flagstatus |= t; // carrying: self is currently carrying the flag
2007                                 else
2008                                         self.ctf_flagstatus |= t2; // taken: someone else is carrying the flag
2009                                 break;
2010                         }
2011                         case FLAG_DROPPED:
2012                         {
2013                                 self.ctf_flagstatus |= t3; // lost: the flag is dropped somewhere on the map
2014                                 break;
2015                         }
2016                 }
2017         }
2018
2019         // item for stopping players from capturing the flag too often
2020         if(self.ctf_captureshielded)
2021                 self.ctf_flagstatus |= CTF_SHIELDED;
2022
2023         // update the health of the flag carrier waypointsprite
2024         if(self.wps_flagcarrier)
2025                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(self.health, self.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id));
2026
2027         return false;
2028 }
2029
2030 MUTATOR_HOOKFUNCTION(ctf, PlayerDamage_Calculate) // for changing damage and force values that are applied to players in g_damage.qc
2031 {
2032         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
2033         {
2034                 if(frag_target == frag_attacker) // damage done to yourself
2035                 {
2036                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
2037                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
2038                 }
2039                 else // damage done to everyone else
2040                 {
2041                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
2042                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
2043                 }
2044         }
2045         else if(frag_target.flagcarried && !IS_DEAD(frag_target) && CTF_DIFFTEAM(frag_target, frag_attacker)) // if the target is a flagcarrier
2046         {
2047                 if(autocvar_g_ctf_flagcarrier_auto_helpme_damage > ('1 0 0' * healtharmor_maxdamage(frag_target.health, frag_target.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id)))
2048                 if(time > frag_target.wps_helpme_time + autocvar_g_ctf_flagcarrier_auto_helpme_time)
2049                 {
2050                         frag_target.wps_helpme_time = time;
2051                         WaypointSprite_HelpMePing(frag_target.wps_flagcarrier);
2052                 }
2053                 // todo: add notification for when flag carrier needs help?
2054         }
2055         return false;
2056 }
2057
2058 MUTATOR_HOOKFUNCTION(ctf, PlayerDies)
2059 {
2060         if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)) && (frag_target.flagcarried))
2061         {
2062                 PlayerTeamScore_AddScore(frag_attacker, ((SAME_TEAM(frag_attacker, frag_target)) ? -autocvar_g_ctf_score_kill : autocvar_g_ctf_score_kill));
2063                 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
2064         }
2065
2066         if(frag_target.flagcarried)
2067         {
2068                 entity tmp_entity = frag_target.flagcarried;
2069                 ctf_Handle_Throw(frag_target, world, DROP_NORMAL);
2070                 tmp_entity.ctf_dropper = world;
2071         }
2072
2073         return false;
2074 }
2075
2076 MUTATOR_HOOKFUNCTION(ctf, GiveFragsForKill)
2077 {
2078         frag_score = 0;
2079         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
2080 }
2081
2082 void ctf_RemovePlayer(entity player)
2083 {
2084         if(player.flagcarried)
2085                 { ctf_Handle_Throw(player, world, DROP_NORMAL); }
2086
2087         for(entity flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2088         {
2089                 if(flag.pass_sender == player) { flag.pass_sender = world; }
2090                 if(flag.pass_target == player) { flag.pass_target = world; }
2091                 if(flag.ctf_dropper == player) { flag.ctf_dropper = world; }
2092         }
2093 }
2094
2095 MUTATOR_HOOKFUNCTION(ctf, MakePlayerObserver)
2096 {SELFPARAM();
2097         ctf_RemovePlayer(self);
2098         return false;
2099 }
2100
2101 MUTATOR_HOOKFUNCTION(ctf, ClientDisconnect)
2102 {SELFPARAM();
2103         ctf_RemovePlayer(self);
2104         return false;
2105 }
2106
2107 MUTATOR_HOOKFUNCTION(ctf, PortalTeleport)
2108 {SELFPARAM();
2109         if(self.flagcarried)
2110         if(!autocvar_g_ctf_portalteleport)
2111                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
2112
2113         return false;
2114 }
2115
2116 MUTATOR_HOOKFUNCTION(ctf, PlayerUseKey)
2117 {SELFPARAM();
2118         if(MUTATOR_RETURNVALUE || gameover) { return false; }
2119
2120         entity player = self;
2121
2122         if((time > player.throw_antispam) && !IS_DEAD(player) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
2123         {
2124                 // pass the flag to a team mate
2125                 if(autocvar_g_ctf_pass)
2126                 {
2127                         entity head, closest_target = world;
2128                         head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, true);
2129
2130                         while(head) // find the closest acceptable target to pass to
2131                         {
2132                                 if(IS_PLAYER(head) && !IS_DEAD(head))
2133                                 if(head != player && SAME_TEAM(head, player))
2134                                 if(!head.speedrunning && !head.vehicle)
2135                                 {
2136                                         // if it's a player, use the view origin as reference (stolen from RadiusDamage functions in g_damage.qc)
2137                                         vector head_center = WarpZone_UnTransformOrigin(head, CENTER_OR_VIEWOFS(head));
2138                                         vector passer_center = CENTER_OR_VIEWOFS(player);
2139
2140                                         if(ctf_CheckPassDirection(head_center, passer_center, player.v_angle, head.WarpZone_findradius_nearest))
2141                                         {
2142                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
2143                                                 {
2144                                                         if(IS_BOT_CLIENT(head))
2145                                                         {
2146                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2147                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
2148                                                         }
2149                                                         else
2150                                                         {
2151                                                                 Send_Notification(NOTIF_ONE, head, MSG_CENTER, CENTER_CTF_PASS_REQUESTED, player.netname);
2152                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2153                                                         }
2154                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
2155                                                         return true;
2156                                                 }
2157                                                 else if(player.flagcarried)
2158                                                 {
2159                                                         if(closest_target)
2160                                                         {
2161                                                                 vector closest_target_center = WarpZone_UnTransformOrigin(closest_target, CENTER_OR_VIEWOFS(closest_target));
2162                                                                 if(vlen(passer_center - head_center) < vlen(passer_center - closest_target_center))
2163                                                                         { closest_target = head; }
2164                                                         }
2165                                                         else { closest_target = head; }
2166                                                 }
2167                                         }
2168                                 }
2169                                 head = head.chain;
2170                         }
2171
2172                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return true; }
2173                 }
2174
2175                 // throw the flag in front of you
2176                 if(autocvar_g_ctf_throw && player.flagcarried)
2177                 {
2178                         if(player.throw_count == -1)
2179                         {
2180                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_delay)
2181                                 {
2182                                         player.throw_prevtime = time;
2183                                         player.throw_count = 1;
2184                                         ctf_Handle_Throw(player, world, DROP_THROW);
2185                                         return true;
2186                                 }
2187                                 else
2188                                 {
2189                                         Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_FLAG_THROW_PUNISH, rint((player.throw_prevtime + autocvar_g_ctf_throw_punish_delay) - time));
2190                                         return false;
2191                                 }
2192                         }
2193                         else
2194                         {
2195                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_time) { player.throw_count = 1; }
2196                                 else { player.throw_count += 1; }
2197                                 if(player.throw_count >= autocvar_g_ctf_throw_punish_count) { player.throw_count = -1; }
2198
2199                                 player.throw_prevtime = time;
2200                                 ctf_Handle_Throw(player, world, DROP_THROW);
2201                                 return true;
2202                         }
2203                 }
2204         }
2205
2206         return false;
2207 }
2208
2209 MUTATOR_HOOKFUNCTION(ctf, HelpMePing)
2210 {SELFPARAM();
2211         if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
2212         {
2213                 self.wps_helpme_time = time;
2214                 WaypointSprite_HelpMePing(self.wps_flagcarrier);
2215         }
2216         else // create a normal help me waypointsprite
2217         {
2218                 WaypointSprite_Spawn(WP_Helpme, waypointsprite_deployed_lifetime, waypointsprite_limitedrange, self, FLAG_WAYPOINT_OFFSET, world, self.team, self, wps_helpme, false, RADARICON_HELPME);
2219                 WaypointSprite_Ping(self.wps_helpme);
2220         }
2221
2222         return true;
2223 }
2224
2225 MUTATOR_HOOKFUNCTION(ctf, VehicleEnter)
2226 {
2227         if(vh_player.flagcarried)
2228         {
2229                 vh_player.flagcarried.nodrawtoclient = vh_player; // hide the flag from the driver
2230
2231                 if(!autocvar_g_ctf_allow_vehicle_carry && !autocvar_g_ctf_allow_vehicle_touch)
2232                 {
2233                         ctf_Handle_Throw(vh_player, world, DROP_NORMAL);
2234                 }
2235                 else
2236                 {
2237                         setattachment(vh_player.flagcarried, vh_vehicle, "");
2238                         setorigin(vh_player.flagcarried, VEHICLE_FLAG_OFFSET);
2239                         vh_player.flagcarried.scale = VEHICLE_FLAG_SCALE;
2240                         //vh_player.flagcarried.angles = '0 0 0';
2241                 }
2242                 return true;
2243         }
2244
2245         return false;
2246 }
2247
2248 MUTATOR_HOOKFUNCTION(ctf, VehicleExit)
2249 {
2250         if(vh_player.flagcarried)
2251         {
2252                 setattachment(vh_player.flagcarried, vh_player, "");
2253                 setorigin(vh_player.flagcarried, FLAG_CARRY_OFFSET);
2254                 vh_player.flagcarried.scale = FLAG_SCALE;
2255                 vh_player.flagcarried.angles = '0 0 0';
2256                 vh_player.flagcarried.nodrawtoclient = world;
2257                 return true;
2258         }
2259
2260         return false;
2261 }
2262
2263 MUTATOR_HOOKFUNCTION(ctf, AbortSpeedrun)
2264 {SELFPARAM();
2265         if(self.flagcarried)
2266         {
2267                 Send_Notification(NOTIF_ALL, world, MSG_INFO, ((self.flagcarried.team) ? APP_TEAM_ENT(self.flagcarried, INFO_CTF_FLAGRETURN_ABORTRUN) : INFO_CTF_FLAGRETURN_ABORTRUN_NEUTRAL));
2268                 ctf_RespawnFlag(self.flagcarried);
2269                 return true;
2270         }
2271
2272         return false;
2273 }
2274
2275 MUTATOR_HOOKFUNCTION(ctf, MatchEnd)
2276 {
2277         entity flag; // temporary entity for the search method
2278
2279         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2280         {
2281                 switch(flag.ctf_status)
2282                 {
2283                         case FLAG_DROPPED:
2284                         case FLAG_PASSING:
2285                         {
2286                                 // lock the flag, game is over
2287                                 flag.movetype = MOVETYPE_NONE;
2288                                 flag.takedamage = DAMAGE_NO;
2289                                 flag.solid = SOLID_NOT;
2290                                 flag.nextthink = false; // stop thinking
2291
2292                                 //dprint("stopping the ", flag.netname, " from moving.\n");
2293                                 break;
2294                         }
2295
2296                         default:
2297                         case FLAG_BASE:
2298                         case FLAG_CARRY:
2299                         {
2300                                 // do nothing for these flags
2301                                 break;
2302                         }
2303                 }
2304         }
2305
2306         return false;
2307 }
2308
2309 MUTATOR_HOOKFUNCTION(ctf, HavocBot_ChooseRole)
2310 {SELFPARAM();
2311         havocbot_ctf_reset_role(self);
2312         return true;
2313 }
2314
2315 MUTATOR_HOOKFUNCTION(ctf, GetTeamCount)
2316 {
2317         //ret_float = ctf_teams;
2318         ret_string = "ctf_team";
2319         return true;
2320 }
2321
2322 MUTATOR_HOOKFUNCTION(ctf, SpectateCopy)
2323 {SELFPARAM();
2324         self.ctf_flagstatus = other.ctf_flagstatus;
2325         return false;
2326 }
2327
2328 MUTATOR_HOOKFUNCTION(ctf, GetRecords)
2329 {
2330         for(int i = record_page * 200; i < MapInfo_count && i < record_page * 200 + 200; ++i)
2331         {
2332                 if (MapInfo_Get_ByID(i))
2333                 {
2334                         float r = stof(db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/time")));
2335
2336                         if(!r)
2337                                 continue;
2338
2339                         // TODO: uid2name
2340                         string h = db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/netname"));
2341                         ret_string = strcat(ret_string, strpad(32, MapInfo_Map_bspname), " ", strpad(-6, ftos_decimals(r, 2)), " ", h, "\n");
2342                 }
2343         }
2344
2345         return false;
2346 }
2347
2348 bool superspec_Spectate(entity _player); // TODO
2349 void superspec_msg(string _center_title, string _con_title, entity _to, string _msg, float _spamlevel); // TODO
2350 MUTATOR_HOOKFUNCTION(ctf, SV_ParseClientCommand)
2351 {
2352     SELFPARAM();
2353         if(IS_PLAYER(self) || MUTATOR_RETURNVALUE || !cvar("g_superspectate")) { return false; }
2354
2355         if(cmd_name == "followfc")
2356         {
2357                 if(!g_ctf)
2358                         return true;
2359
2360                 int _team = 0;
2361                 bool found = false;
2362
2363                 if(cmd_argc == 2)
2364                 {
2365                         switch(argv(1))
2366                         {
2367                                 case "red": _team = NUM_TEAM_1; break;
2368                                 case "blue": _team = NUM_TEAM_2; break;
2369                                 case "yellow": if(ctf_teams >= 3) _team = NUM_TEAM_3; break;
2370                                 case "pink": if(ctf_teams >= 4) _team = NUM_TEAM_4; break;
2371                         }
2372                 }
2373
2374                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
2375                         if(it.flagcarried && (it.team == _team || _team == 0))
2376                         {
2377                                 found = true;
2378                                 if(_team == 0 && IS_SPEC(self) && self.enemy == it)
2379                                         continue; // already spectating this fc, try another
2380                                 return superspec_Spectate(it);
2381                         }
2382                 ));
2383
2384                 if(!found)
2385                         superspec_msg("", "", self, "No active flag carrier\n", 1);
2386                 return true;
2387         }
2388
2389         return false;
2390 }
2391
2392 MUTATOR_HOOKFUNCTION(ctf, DropSpecialItems)
2393 {
2394         if(frag_target.flagcarried)
2395                 ctf_Handle_Throw(frag_target, world, DROP_THROW);
2396
2397         return false;
2398 }
2399
2400
2401 // ==========
2402 // Spawnfuncs
2403 // ==========
2404
2405 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2406 CTF flag for team one (Red).
2407 Keys:
2408 "angle" Angle the flag will point (minus 90 degrees)...
2409 "model" model to use, note this needs red and blue as skins 0 and 1...
2410 "noise" sound played when flag is picked up...
2411 "noise1" sound played when flag is returned by a teammate...
2412 "noise2" sound played when flag is captured...
2413 "noise3" sound played when flag is lost in the field and respawns itself...
2414 "noise4" sound played when flag is dropped by a player...
2415 "noise5" sound played when flag touches the ground... */
2416 spawnfunc(item_flag_team1)
2417 {
2418         if(!g_ctf) { remove(this); return; }
2419
2420         ctf_FlagSetup(NUM_TEAM_1, this);
2421 }
2422
2423 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2424 CTF flag for team two (Blue).
2425 Keys:
2426 "angle" Angle the flag will point (minus 90 degrees)...
2427 "model" model to use, note this needs red and blue as skins 0 and 1...
2428 "noise" sound played when flag is picked up...
2429 "noise1" sound played when flag is returned by a teammate...
2430 "noise2" sound played when flag is captured...
2431 "noise3" sound played when flag is lost in the field and respawns itself...
2432 "noise4" sound played when flag is dropped by a player...
2433 "noise5" sound played when flag touches the ground... */
2434 spawnfunc(item_flag_team2)
2435 {
2436         if(!g_ctf) { remove(this); return; }
2437
2438         ctf_FlagSetup(NUM_TEAM_2, this);
2439 }
2440
2441 /*QUAKED spawnfunc_item_flag_team3 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2442 CTF flag for team three (Yellow).
2443 Keys:
2444 "angle" Angle the flag will point (minus 90 degrees)...
2445 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2446 "noise" sound played when flag is picked up...
2447 "noise1" sound played when flag is returned by a teammate...
2448 "noise2" sound played when flag is captured...
2449 "noise3" sound played when flag is lost in the field and respawns itself...
2450 "noise4" sound played when flag is dropped by a player...
2451 "noise5" sound played when flag touches the ground... */
2452 spawnfunc(item_flag_team3)
2453 {
2454         if(!g_ctf) { remove(this); return; }
2455
2456         ctf_FlagSetup(NUM_TEAM_3, this);
2457 }
2458
2459 /*QUAKED spawnfunc_item_flag_team4 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2460 CTF flag for team four (Pink).
2461 Keys:
2462 "angle" Angle the flag will point (minus 90 degrees)...
2463 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2464 "noise" sound played when flag is picked up...
2465 "noise1" sound played when flag is returned by a teammate...
2466 "noise2" sound played when flag is captured...
2467 "noise3" sound played when flag is lost in the field and respawns itself...
2468 "noise4" sound played when flag is dropped by a player...
2469 "noise5" sound played when flag touches the ground... */
2470 spawnfunc(item_flag_team4)
2471 {
2472         if(!g_ctf) { remove(this); return; }
2473
2474         ctf_FlagSetup(NUM_TEAM_4, this);
2475 }
2476
2477 /*QUAKED spawnfunc_item_flag_neutral (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2478 CTF flag (Neutral).
2479 Keys:
2480 "angle" Angle the flag will point (minus 90 degrees)...
2481 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2482 "noise" sound played when flag is picked up...
2483 "noise1" sound played when flag is returned by a teammate...
2484 "noise2" sound played when flag is captured...
2485 "noise3" sound played when flag is lost in the field and respawns itself...
2486 "noise4" sound played when flag is dropped by a player...
2487 "noise5" sound played when flag touches the ground... */
2488 spawnfunc(item_flag_neutral)
2489 {
2490         if(!g_ctf) { remove(this); return; }
2491         if(!cvar("g_ctf_oneflag")) { remove(this); return; }
2492
2493         ctf_FlagSetup(0, this);
2494 }
2495
2496 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
2497 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
2498 Note: If you use spawnfunc_ctf_team entities you must define at least 2!  However, unlike domination, you don't need to make a blank one too.
2499 Keys:
2500 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
2501 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
2502 spawnfunc(ctf_team)
2503 {
2504         if(!g_ctf) { remove(this); return; }
2505
2506         this.classname = "ctf_team";
2507         this.team = this.cnt + 1;
2508 }
2509
2510 // compatibility for quake maps
2511 spawnfunc(team_CTF_redflag)    { spawnfunc_item_flag_team1(this);    }
2512 spawnfunc(team_CTF_blueflag)   { spawnfunc_item_flag_team2(this);    }
2513 spawnfunc(info_player_team1);
2514 spawnfunc(team_CTF_redplayer)  { spawnfunc_info_player_team1(this);  }
2515 spawnfunc(team_CTF_redspawn)   { spawnfunc_info_player_team1(this);  }
2516 spawnfunc(info_player_team2);
2517 spawnfunc(team_CTF_blueplayer) { spawnfunc_info_player_team2(this);  }
2518 spawnfunc(team_CTF_bluespawn)  { spawnfunc_info_player_team2(this);  }
2519
2520 void team_CTF_neutralflag()                      { SELFPARAM(); spawnfunc_item_flag_neutral(self);  }
2521 void team_neutralobelisk()                       { SELFPARAM(); spawnfunc_item_flag_neutral(self);  }
2522
2523
2524 // ==============
2525 // Initialization
2526 // ==============
2527
2528 // scoreboard setup
2529 void ctf_ScoreRules(int teams)
2530 {
2531         CheckAllowedTeams(world);
2532         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
2533         ScoreInfo_SetLabel_TeamScore  (ST_CTF_CAPS,     "caps",      SFL_SORT_PRIO_PRIMARY);
2534         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPS,     "caps",      SFL_SORT_PRIO_SECONDARY);
2535         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPTIME,  "captime",   SFL_LOWER_IS_BETTER | SFL_TIME);
2536         ScoreInfo_SetLabel_PlayerScore(SP_CTF_PICKUPS,  "pickups",   0);
2537         ScoreInfo_SetLabel_PlayerScore(SP_CTF_FCKILLS,  "fckills",   0);
2538         ScoreInfo_SetLabel_PlayerScore(SP_CTF_RETURNS,  "returns",   0);
2539         ScoreInfo_SetLabel_PlayerScore(SP_CTF_DROPS,    "drops",     SFL_LOWER_IS_BETTER);
2540         ScoreRules_basics_end();
2541 }
2542
2543 // code from here on is just to support maps that don't have flag and team entities
2544 void ctf_SpawnTeam (string teamname, int teamcolor)
2545 {
2546         entity this = new_pure(ctf_team);
2547         this.netname = teamname;
2548         this.cnt = teamcolor;
2549         this.spawnfunc_checked = true;
2550         WITHSELF(this, spawnfunc_ctf_team(this));
2551 }
2552
2553 void ctf_DelayedInit(entity this) // Do this check with a delay so we can wait for teams to be set up.
2554 {
2555         ctf_teams = 2;
2556
2557         entity tmp_entity;
2558         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
2559         {
2560                 if(tmp_entity.team == NUM_TEAM_3) { ctf_teams = max(3, ctf_teams); }
2561                 if(tmp_entity.team == NUM_TEAM_4) { ctf_teams = max(4, ctf_teams); }
2562                 if(tmp_entity.team == 0) { ctf_oneflag = true; }
2563         }
2564
2565         ctf_teams = bound(2, ctf_teams, 4);
2566
2567         // if no teams are found, spawn defaults
2568         if(find(world, classname, "ctf_team") == world)
2569         {
2570                 LOG_TRACE("No \"ctf_team\" entities found on this map, creating them anyway.\n");
2571                 ctf_SpawnTeam("Red", NUM_TEAM_1 - 1);
2572                 ctf_SpawnTeam("Blue", NUM_TEAM_2 - 1);
2573                 if(ctf_teams >= 3)
2574                         ctf_SpawnTeam("Yellow", NUM_TEAM_3 - 1);
2575                 if(ctf_teams >= 4)
2576                         ctf_SpawnTeam("Pink", NUM_TEAM_4 - 1);
2577         }
2578
2579         ctf_ScoreRules(ctf_teams);
2580 }
2581
2582 void ctf_Initialize()
2583 {
2584         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
2585
2586         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
2587         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
2588         ctf_captureshield_force = autocvar_g_ctf_shield_force;
2589
2590         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
2591 }
2592
2593 #endif