]> git.xonotic.org Git - xonotic/xonotic-data.pk3dir.git/blob - qcsrc/server/mutators/gamemode_ctf.qc
Fix flag throwing bug and dropped capture bug
[xonotic/xonotic-data.pk3dir.git] / qcsrc / server / mutators / gamemode_ctf.qc
1 // ================================================================
2 //  Official capture the flag game mode coding, reworked by Samual
3 //  Last updated: March 30th, 2012
4 // ================================================================
5
6 float ctf_ReadScore(string parameter) // make this obsolete
7 {
8         //if(g_ctf_win_mode != 2)
9                 return cvar(strcat("g_ctf_personal", parameter));
10         //else
11         //      return cvar(strcat("g_ctf_flag", parameter));
12 }
13
14 void ctf_FakeTimeLimit(entity e, float t)
15 {
16         msg_entity = e;
17         WriteByte(MSG_ONE, 3); // svc_updatestat
18         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
19         if(t < 0)
20                 WriteCoord(MSG_ONE, autocvar_timelimit);
21         else
22                 WriteCoord(MSG_ONE, (t + 1) / 60);
23 }
24
25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
26 {
27         if(autocvar_sv_eventlog)
28                 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
29 }
30
31 string ctf_CaptureRecord(entity flag, entity player)
32 {
33         float cap_time, cap_record, success;
34         string cap_message, refername;
35         
36         if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots)) 
37         {
38                 cap_record = ctf_captimerecord;
39                 cap_time = (time - flag.ctf_pickuptime);
40
41                 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
42                 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
43
44                 if(!ctf_captimerecord) 
45                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
46                 else if(cap_time < cap_record) 
47                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
48                 else
49                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
50
51                 if(success) 
52                 {
53                         ctf_captimerecord = cap_time;
54                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
55                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
56                         write_recordmarker(player, (time - cap_time), cap_time); 
57                 } 
58         }
59         
60         return cap_message;
61 }
62
63 void ctf_FlagcarrierWaypoints(entity player)
64 {
65         WaypointSprite_Spawn("flagcarrier", 0, 0, player, '0 0 64', world, player.team, player, wps_flagcarrier, FALSE, RADARICON_FLAG, '1 1 0');
66         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
67         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
68         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, '1 1 0');
69 }
70
71
72 // =======================
73 // CaptureShield Functions 
74 // =======================
75
76 float ctf_CaptureShield_CheckStatus(entity p) 
77 {
78         float s, se;
79         entity e;
80         float players_worseeq, players_total;
81
82         if(ctf_captureshield_max_ratio <= 0)
83                 return FALSE;
84
85         s = PlayerScore_Add(p, SP_SCORE, 0);
86         if(s >= -ctf_captureshield_min_negscore)
87                 return FALSE;
88
89         players_total = players_worseeq = 0;
90         FOR_EACH_PLAYER(e)
91         {
92                 if(e.team != p.team)
93                         continue;
94                 se = PlayerScore_Add(e, SP_SCORE, 0);
95                 if(se <= s)
96                         ++players_worseeq;
97                 ++players_total;
98         }
99
100         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
101         // use this rule here
102         
103         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
104                 return FALSE;
105
106         return TRUE;
107 }
108
109 void ctf_CaptureShield_Update(entity player, float wanted_status)
110 {
111         float updated_status = ctf_CaptureShield_CheckStatus(player);
112         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
113         {
114                 if(updated_status) // TODO csqc notifier for this // Samual: How?
115                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Make some defensive scores before trying again.", 5, 0);
116                 else
117                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
118                         
119                 player.ctf_captureshielded = updated_status;
120         }
121 }
122
123 float ctf_CaptureShield_Customize()
124 {
125         if not(other.ctf_captureshielded) { return FALSE; }
126         if(self.team == other.team) { return FALSE; }
127         
128         return TRUE;
129 }
130
131 void ctf_CaptureShield_Touch()
132 {
133         if not(other.ctf_captureshielded) { return; }
134         if(self.team == other.team) { return; }
135         
136         vector mymid = (self.absmin + self.absmax) * 0.5;
137         vector othermid = (other.absmin + other.absmax) * 0.5;
138
139         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
140         Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
141 }
142
143 void ctf_CaptureShield_Spawn(entity flag)
144 {
145         entity shield = spawn();
146         
147         shield.enemy = self;
148         shield.team = self.team;
149         shield.touch = ctf_CaptureShield_Touch;
150         shield.customizeentityforclient = ctf_CaptureShield_Customize;
151         shield.classname = "ctf_captureshield";
152         shield.effects = EF_ADDITIVE;
153         shield.movetype = MOVETYPE_NOCLIP;
154         shield.solid = SOLID_TRIGGER;
155         shield.avelocity = '7 0 11';
156         shield.scale = 0.5;
157         
158         setorigin(shield, self.origin);
159         setmodel(shield, "models/ctf/shield.md3");
160         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
161 }
162
163
164 // ====================
165 // Drop/Pass/Throw Code
166 // ====================
167
168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
169 {
170         // declarations
171         player = (player ? player : flag.pass_sender);
172
173         // main
174         flag.movetype = MOVETYPE_TOSS;
175         flag.takedamage = DAMAGE_YES;
176         flag.health = flag.max_flag_health;
177         flag.ctf_droptime = time;
178         flag.ctf_dropper = player;
179         flag.ctf_status = FLAG_DROPPED;
180         
181         // messages and sounds
182         Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
183         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
184         ctf_EventLog("dropped", player.team, player);
185
186         // scoring
187         PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));       
188         PlayerScore_Add(player, SP_CTF_DROPS, 1);
189         
190         // waypoints
191         if(autocvar_g_ctf_flag_dropped_waypoint)
192                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, '0 0 64', world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, FALSE, RADARICON_FLAG, '0 0.5 0' + ((flag.team == COLOR_TEAM1) ? '0.75 0 0' : '0 0 0.75')); // (COLOR_TEAM1 + COLOR_TEAM2 - flag.team)
193
194         if(autocvar_g_ctf_flag_returntime || (autocvar_g_ctf_flag_take_damage && autocvar_g_ctf_flag_health))
195         {
196                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
197                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
198         }
199         
200         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
201         
202         if(droptype == DROP_PASS)
203         {
204                 flag.pass_sender = world;
205                 flag.pass_target = world;
206         }
207 }
208
209 void ctf_Handle_Retrieve(entity flag, entity player)
210 {
211         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
212         entity sender = flag.pass_sender;
213         
214         // transfer flag to player
215         flag.ctf_carrier = player;
216         flag.owner = player;
217         flag.owner.flagcarried = flag;
218         
219         // reset flag
220         setattachment(flag, player, "");
221         setorigin(flag, FLAG_CARRY_OFFSET);
222         flag.movetype = MOVETYPE_NONE;
223         flag.takedamage = DAMAGE_NO;
224         flag.solid = SOLID_NOT;
225         flag.ctf_carrier = player;
226         flag.ctf_status = FLAG_CARRY;
227
228         // messages and sounds
229         sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM);
230         ctf_EventLog("recieve", flag.team, player);
231         FOR_EACH_PLAYER(tmp_player)
232                 if(tmp_player == sender)
233                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
234                 else if(tmp_player == player)
235                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
236                 else if(tmp_player.team == sender.team)
237                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
238         
239         // create new waypoint
240         ctf_FlagcarrierWaypoints(player);
241         
242         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
243         player.throw_antispam = sender.throw_antispam;
244         
245         flag.pass_sender = world;
246         flag.pass_target = world;
247 }
248
249 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
250 {
251         entity flag = player.flagcarried;
252         
253         if(!flag) { return; }
254         if((droptype == DROP_PASS) && !reciever) { return; }
255         
256         //if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
257         
258         // reset the flag
259         setattachment(flag, world, "");
260         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
261         flag.owner.flagcarried = world;
262         flag.owner = world;
263         flag.solid = SOLID_TRIGGER;
264         flag.ctf_droptime = time;
265         
266         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
267         
268         switch(droptype)
269         {
270                 case DROP_PASS:
271                 {
272                         vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
273                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_throw_velocity);
274                         break;
275                 }
276                 
277                 case DROP_THROW:
278                 {
279                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
280                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_throw_velocity)), FALSE);
281                         break;
282                 }
283                 
284                 default:
285                 case DROP_NORMAL:
286                 {
287                         flag.velocity = ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom()));
288                         break;
289                 }
290         }
291         
292         switch(droptype)
293         {
294                 case DROP_PASS:
295                 {
296                         // main
297                         flag.movetype = MOVETYPE_FLY;
298                         flag.takedamage = DAMAGE_NO;
299                         flag.pass_sender = player;
300                         flag.pass_target = reciever;
301                         flag.ctf_status = FLAG_PASSING;
302                         
303                         // other
304                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
305                         ctf_EventLog("pass", flag.team, player);
306                         te_lightning2(world, reciever.origin, player.origin);
307                         break;
308                 }
309                 
310                 default:
311                 case DROP_THROW:
312                 case DROP_NORMAL:
313                 {
314                         ctf_Handle_Drop(flag, player, droptype);
315                         break;
316                 }
317         }
318
319         // kill old waypointsprite
320         WaypointSprite_Ping(player.wps_flagcarrier);
321         WaypointSprite_Kill(player.wps_flagcarrier);
322         
323         // captureshield
324         //ctf_CaptureShield_Update(player, 0); // shield only
325 }
326
327
328 // ==============
329 // Event Handlers
330 // ==============
331
332 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
333 {
334         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
335         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
336         
337         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
338         
339         // messages and sounds
340         Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
341         sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
342         
343         switch(capturetype)
344         {
345                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
346                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
347                 default: break;
348         }
349         
350         // scoring
351         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
352         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
353
354         // effects
355         if(autocvar_g_ctf_flag_capture_effects) 
356         {
357                 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
358                 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
359         }
360
361         // other
362         if(capturetype == CAPTURE_NORMAL)
363         {
364                 WaypointSprite_Kill(player.wps_flagcarrier);
365                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
366         }
367         
368         // reset the flag
369         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
370         ctf_RespawnFlag(enemy_flag);
371 }
372
373 void ctf_Handle_Return(entity flag, entity player)
374 {
375         // messages and sounds
376         //centerprint(player, strcat("You returned ", flag.netname));
377         Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
378         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
379         ctf_EventLog("return", flag.team, player);
380
381         // scoring
382         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
383         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
384
385         TeamScore_AddToTeam(((flag.team == COLOR_TEAM1) ? COLOR_TEAM2 : COLOR_TEAM1), ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
386         FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
387         {
388                 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
389                 ctf_CaptureShield_Update(player, 0); // shield only
390         }
391         
392         // reset the flag
393         ctf_RespawnFlag(flag);
394 }
395
396 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
397 {
398         // declarations
399         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
400         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
401         float pickup_dropped_score; // used to calculate dropped pickup score
402         
403         // attach the flag to the player
404         flag.owner = player;
405         player.flagcarried = flag;
406         setattachment(flag, player, "");
407         setorigin(flag, FLAG_CARRY_OFFSET);
408         
409         // flag setup
410         flag.movetype = MOVETYPE_NONE;
411         flag.takedamage = DAMAGE_NO;
412         flag.solid = SOLID_NOT;
413         flag.angles = '0 0 0';
414         flag.ctf_carrier = player;
415         flag.ctf_status = FLAG_CARRY;
416         
417         switch(pickuptype)
418         {
419                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
420                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
421                 default: break;
422         }
423
424         // messages and sounds
425         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
426         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
427         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
428         
429         FOR_EACH_PLAYER(tmp_player)
430                 if(tmp_player == player)
431                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
432                 else if(tmp_player.team == player.team)
433                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
434                 else if(tmp_player.team == flag.team)
435                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
436                         
437         switch(pickuptype)
438         {
439                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
440                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
441                 default: break;
442         }
443         
444         // scoring
445         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
446         switch(pickuptype)
447         {               
448                 case PICKUP_BASE:
449                 {
450                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
451                         break;
452                 }
453                 
454                 case PICKUP_DROPPED:
455                 {
456                         pickup_dropped_score = (autocvar_g_ctf_flag_returntime ? bound(0, ((flag.ctf_droptime + autocvar_g_ctf_flag_returntime) - time) / autocvar_g_ctf_flag_returntime, 1) : 1);
457                         pickup_dropped_score = floor((ctf_ReadScore("score_pickup_dropped_late") * (1 - pickup_dropped_score) + ctf_ReadScore("score_pickup_dropped_early") * pickup_dropped_score) + 0.5);
458                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
459                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
460                         break;
461                 }
462                 
463                 default: break;
464         }
465         
466         // speedrunning
467         if(pickuptype == PICKUP_BASE)
468         {
469                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
470                 if((player.speedrunning) && (ctf_captimerecord))
471                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
472         }
473                 
474         // effects
475         if(autocvar_g_ctf_flag_pickup_effects)
476                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
477         
478         // waypoints 
479         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
480         ctf_FlagcarrierWaypoints(player);
481         WaypointSprite_Ping(player.wps_flagcarrier);
482 }
483
484
485 // ===================
486 // Main Flag Functions
487 // ===================
488
489 void ctf_CheckFlagReturn(entity flag)
490 {
491         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
492         
493         if((flag.health <= 0) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_returntime))
494         {
495                 bprint("The ", flag.netname, " has returned to base\n");
496                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
497                 ctf_EventLog("returned", flag.team, world);
498                 ctf_RespawnFlag(flag);
499         }
500 }
501
502 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
503 {
504         if(ITEM_DAMAGE_NEEDKILL(deathtype))
505         {
506                 // automatically kill the flag and return it
507                 self.health = 0;
508                 ctf_CheckFlagReturn(self);
509         }
510         
511         if(autocvar_g_ctf_flag_take_damage) 
512         {
513                 self.health = self.health - damage;
514                 ctf_CheckFlagReturn(self);
515         }
516 }
517
518 void ctf_FlagThink()
519 {
520         // declarations
521         entity tmp_entity;
522
523         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
524
525         // captureshield
526         if(self == ctf_worldflaglist) // only for the first flag
527                 FOR_EACH_CLIENT(tmp_entity)
528                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
529
530         // sanity checks
531         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
532                 dprint("wtf the flag got squashed?\n");
533                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
534                 if(!trace_startsolid) // can we resize it without getting stuck?
535                         setsize(self, FLAG_MIN, FLAG_MAX); }
536
537         // main think method
538         switch(self.ctf_status)
539         {       
540                 case FLAG_BASE:
541                 {
542                         if(autocvar_g_ctf_dropped_capture_radius)
543                         {
544                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
545                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
546                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
547                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
548                         }
549                         return;
550                 }
551                 
552                 case FLAG_DROPPED:
553                 {
554                         if(autocvar_g_ctf_flag_returntime)
555                         {
556                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_returntime) * FLAG_THINKRATE);
557                                 ctf_CheckFlagReturn(self);
558                         } 
559                         return;
560                 }
561                         
562                 case FLAG_CARRY:
563                 {
564                         if((self.owner) && (self.speedrunning) && (ctf_captimerecord) && (time >= self.ctf_pickuptime + ctf_captimerecord)) 
565                         {
566                                 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
567                                 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
568                                 ctf_EventLog("returned", self.team, world);
569                                 ctf_RespawnFlag(tmp_entity);
570
571                                 tmp_entity = self;
572                                 self = self.owner;
573                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
574                                 ImpulseCommands();
575                                 self = tmp_entity;
576                         }
577                         return;
578                 }
579                 
580                 case FLAG_PASSING: // todo make work with warpzones
581                 {                       
582                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
583                         
584                         traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
585                         
586                         if((self.pass_target.deadflag != DEAD_NO)
587                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
588                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
589                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
590                         {
591                                 ctf_Handle_Drop(self, world, DROP_PASS);
592                         }
593                         else // still a viable target, go for it
594                         {
595                                 vector desired_direction = normalize(targ_origin - self.origin);
596                                 vector current_direction = normalize(self.velocity);
597                                 
598                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_throw_velocity); 
599                         }
600                         return;
601                 }
602
603                 default: // this should never happen
604                 {
605                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
606                         return;
607                 }
608         }
609 }
610
611 void ctf_FlagTouch()
612 {
613         if(gameover) { return; }
614         if(!self) { return; }
615         if(other.deadflag != DEAD_NO) { return; }
616         if(ITEM_TOUCH_NEEDKILL())
617         {
618                 // automatically kill the flag and return it
619                 self.health = 0;
620                 ctf_CheckFlagReturn(self);
621                 return;
622         }
623         if(other.classname != "player") // The flag just touched an object, most likely the world
624         {
625                 if(time > self.wait) // if we haven't in a while, play a sound/effect
626                 {
627                         pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
628                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
629                         self.wait = time + FLAG_TOUCHRATE;
630                 }
631                 return;
632         }
633
634         switch(self.ctf_status) 
635         {       
636                 case FLAG_BASE:
637                 {
638                         if((other.team == self.team) && (other.flagcarried) && (other.flagcarried.team != self.team))
639                                 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
640                         else if((other.team != self.team) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
641                                 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
642                         break;
643                 }
644                 
645                 case FLAG_DROPPED:
646                 {
647                         if(other.team == self.team)
648                                 ctf_Handle_Return(self, other); // other just returned his own flag
649                         else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
650                                 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
651                         break;
652                 }
653                         
654                 case FLAG_CARRY:
655                 {
656                         dprint("Someone touched a flag even though it was being carried?\n");
657                         break;
658                 }
659                 
660                 case FLAG_PASSING:
661                 {
662                         if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
663                         {
664                                 if(IsDifferentTeam(other, self.pass_sender))
665                                         ctf_Handle_Return(self, other);
666                                 else
667                                         ctf_Handle_Retrieve(self, other);
668                         }
669                         break;
670                 }
671                 
672                 default: // this should never happen
673                 {
674                         dprint("Touch: Flag exists with no status?\n");
675                         break;
676                 }
677         }
678 }
679
680 void ctf_RespawnFlag(entity flag)
681 {
682         // reset the player (if there is one)
683         if((flag.owner) && (flag.owner.flagcarried == flag))
684         {
685                 WaypointSprite_Kill(flag.wps_flagcarrier);
686                 flag.owner.flagcarried = world;
687
688                 if(flag.speedrunning)
689                         ctf_FakeTimeLimit(flag.owner, -1);
690         }
691
692         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
693                 { WaypointSprite_Kill(flag.wps_flagdropped); }
694
695         // reset the flag
696         setattachment(flag, world, "");
697         setorigin(flag, flag.ctf_spawnorigin);
698         
699         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
700         flag.takedamage = DAMAGE_NO;
701         flag.health = flag.max_flag_health;
702         flag.solid = SOLID_TRIGGER;
703         flag.velocity = '0 0 0';
704         flag.angles = flag.mangle;
705         flag.flags = FL_ITEM | FL_NOTARGET;
706         
707         flag.ctf_status = FLAG_BASE;
708         flag.owner = world;
709         flag.pass_sender = world;
710         flag.pass_target = world;
711         flag.ctf_carrier = world;
712         flag.ctf_dropper = world;
713         flag.ctf_pickuptime = 0;
714         flag.ctf_droptime = 0;
715 }
716
717 void ctf_Reset()
718 {
719         if(self.owner)
720                 if(self.owner.classname == "player")
721                         ctf_Handle_Throw(self.owner, world, DROP_NORMAL);
722                         
723         ctf_RespawnFlag(self);
724 }
725
726 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
727 {
728         // declarations
729         float teamnumber = ((self.team == COLOR_TEAM1) ? TRUE : FALSE); // if we were originally 1, this will become 0. If we were originally 0, this will become 1. 
730
731         // bot waypoints
732         waypoint_spawnforitem_force(self, self.origin);
733         self.nearestwaypointtimeout = 0; // activate waypointing again
734         self.bot_basewaypoint = self.nearestwaypoint;
735
736         // waypointsprites
737         WaypointSprite_SpawnFixed(((teamnumber) ? "redbase" : "bluebase"), self.origin + '0 0 64', self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
738         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
739
740         // captureshield setup
741         ctf_CaptureShield_Spawn(self);
742 }
743
744 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc 
745 {       
746         // declarations
747         teamnumber = fabs(teamnumber - bound(0, autocvar_g_ctf_reverse, 1)); // if we were originally 1, this will become 0. If we were originally 0, this will become 1. 
748         self = flag; // for later usage with droptofloor()
749         
750         // main setup
751         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
752         ctf_worldflaglist = flag;
753
754         setattachment(flag, world, ""); 
755
756         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
757         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
758         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
759         flag.classname = "item_flag_team";
760         flag.target = "###item###"; // wut?
761         flag.flags = FL_ITEM | FL_NOTARGET;
762         flag.solid = SOLID_TRIGGER;
763         flag.takedamage = DAMAGE_NO;
764         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;   
765         flag.max_flag_health = ((autocvar_g_ctf_flag_take_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
766         flag.health = flag.max_flag_health;
767         flag.event_damage = ctf_FlagDamage;
768         flag.pushable = TRUE;
769         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
770         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
771         flag.velocity = '0 0 0';
772         flag.mangle = flag.angles;
773         flag.reset = ctf_Reset;
774         flag.touch = ctf_FlagTouch;
775         flag.think = ctf_FlagThink;
776         flag.nextthink = time + FLAG_THINKRATE;
777         flag.ctf_status = FLAG_BASE;
778         
779         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
780         if(!flag.scale) { flag.scale = FLAG_SCALE; }
781         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
782         
783         // sound 
784         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
785         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
786         if(!flag.snd_flag_capture) { flag.snd_flag_capture = ((teamnumber) ? "ctf/red_capture.wav" : "ctf/blue_capture.wav"); } // blue team scores by capturing the red flag
787         if(!flag.snd_flag_respawn) { flag.snd_flag_respawn = "ctf/flag_respawn.wav"; } // if there is ever a team-based sound for this, update the code to match.
788         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
789         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
790         
791         // precache
792         precache_sound(flag.snd_flag_taken);
793         precache_sound(flag.snd_flag_returned);
794         precache_sound(flag.snd_flag_capture);
795         precache_sound(flag.snd_flag_respawn);
796         precache_sound(flag.snd_flag_dropped);
797         precache_sound(flag.snd_flag_touch);
798         precache_model(flag.model);
799         precache_model("models/ctf/shield.md3");
800         precache_model("models/ctf/shockwavetransring.md3");
801
802         // appearence
803         setmodel(flag, flag.model); // precision set below
804         setsize(flag, FLAG_MIN, FLAG_MAX);
805         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
806         
807         if(autocvar_g_ctf_flag_glowtrails)
808         {
809                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
810                 flag.glow_size = 25;
811                 flag.glow_trail = 1;
812         }
813         
814         flag.effects |= EF_LOWPRECISION;
815         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
816         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
817         
818         // flag placement
819         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
820         {       
821                 flag.dropped_origin = flag.origin; 
822                 flag.noalign = TRUE;
823                 flag.movetype = MOVETYPE_NONE;
824         }
825         else // drop to floor, automatically find a platform and set that as spawn origin
826         { 
827                 flag.noalign = FALSE;
828                 self = flag;
829                 droptofloor();
830                 flag.movetype = MOVETYPE_TOSS; 
831         }       
832         
833         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
834 }
835
836
837 // ==============
838 // Hook Functions
839 // ==============
840
841 MUTATOR_HOOKFUNCTION(ctf_HookedDrop)
842 {
843         if(self.flagcarried) { ctf_Handle_Throw(self, world, DROP_NORMAL); }
844         return 0;
845 }
846
847 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
848 {
849         entity flag;
850         
851         // initially clear items so they can be set as necessary later.
852         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST 
853                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
854
855         // scan through all the flags and notify the client about them 
856         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
857         {
858                 if(flag.ctf_status == FLAG_CARRY)
859                         if(flag.owner == self)
860                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
861                         else 
862                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
863                 else if(flag.ctf_status == FLAG_DROPPED) 
864                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
865         }
866         
867         // item for stopping players from capturing the flag too often
868         if(self.ctf_captureshielded)
869                 self.items |= IT_CTF_SHIELDED;
870         
871         // update the health of the flag carrier waypointsprite
872         if(self.wps_flagcarrier) 
873                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
874         
875         return 0;
876 }
877
878 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
879 {
880         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
881         {
882                 if(frag_target == frag_attacker) // damage done to yourself
883                 {
884                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
885                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
886                 }
887                 else // damage done everyone else
888                 {
889                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
890                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
891                 }
892         }
893         return 0;
894 }
895
896 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
897 {
898         frag_score = 0;
899         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
900 }
901
902 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
903 {
904         entity player = self;
905
906         if(time > player.throw_antispam)
907         {
908                 // pass the flag to a team mate
909                 if(autocvar_g_ctf_allow_pass)
910                 {
911                         entity head, closest_target;
912                         head = findradius(player.origin, autocvar_g_ctf_pass_radius);
913                         
914                         while(head) // find the closest acceptable target to pass to
915                         {
916                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
917                                 if(head != player && !IsDifferentTeam(head, player))
918                                 if(!player.speedrunning && !head.speedrunning)
919                                 {
920                                         traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
921                                         if not((trace_fraction < 1) && (trace_ent != head))
922                                         {
923                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried) 
924                                                 { 
925                                                         if(clienttype(head) == CLIENTTYPE_BOT)
926                                                         {
927                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
928                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
929                                                         }
930                                                         else
931                                                         {
932                                                                 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname)); 
933                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname)); 
934                                                         }
935                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait; 
936                                                         return 0; 
937                                                 }
938                                                 else if(player.flagcarried)
939                                                 {
940                                                         if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
941                                                         else { closest_target = head; }
942                                                 }
943                                         }
944                                 }
945                                 head = head.chain;
946                         }
947                         
948                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
949                 }
950                 
951                 // throw the flag in front of you
952                 if(autocvar_g_ctf_allow_drop && player.flagcarried && !player.speedrunning)
953                         { ctf_Handle_Throw(player, world, DROP_THROW); }
954         }
955                 
956         return 0;
957 }
958
959 // ==========
960 // Spawnfuncs
961 // ==========
962
963 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
964 CTF Starting point for a player in team one (Red).
965 Keys: "angle" viewing angle when spawning. */
966 void spawnfunc_info_player_team1()
967 {
968         if(g_assault) { remove(self); return; }
969         
970         self.team = COLOR_TEAM1; // red
971         spawnfunc_info_player_deathmatch();
972 }
973
974
975 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
976 CTF Starting point for a player in team two (Blue).
977 Keys: "angle" viewing angle when spawning. */
978 void spawnfunc_info_player_team2()
979 {
980         if(g_assault) { remove(self); return; }
981         
982         self.team = COLOR_TEAM2; // blue
983         spawnfunc_info_player_deathmatch();
984 }
985
986 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
987 CTF Starting point for a player in team three (Yellow).
988 Keys: "angle" viewing angle when spawning. */
989 void spawnfunc_info_player_team3()
990 {
991         if(g_assault) { remove(self); return; }
992         
993         self.team = COLOR_TEAM3; // yellow
994         spawnfunc_info_player_deathmatch();
995 }
996
997
998 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
999 CTF Starting point for a player in team four (Purple).
1000 Keys: "angle" viewing angle when spawning. */
1001 void spawnfunc_info_player_team4()
1002 {
1003         if(g_assault) { remove(self); return; }
1004         
1005         self.team = COLOR_TEAM4; // purple
1006         spawnfunc_info_player_deathmatch();
1007 }
1008
1009 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1010 CTF flag for team one (Red).
1011 Keys: 
1012 "angle" Angle the flag will point (minus 90 degrees)... 
1013 "model" model to use, note this needs red and blue as skins 0 and 1...
1014 "noise" sound played when flag is picked up...
1015 "noise1" sound played when flag is returned by a teammate...
1016 "noise2" sound played when flag is captured...
1017 "noise3" sound played when flag is lost in the field and respawns itself... 
1018 "noise4" sound played when flag is dropped by a player...
1019 "noise5" sound played when flag touches the ground... */
1020 void spawnfunc_item_flag_team1()
1021 {
1022         if(!g_ctf) { remove(self); return; }
1023
1024         ctf_FlagSetup(1, self); // 1 = red
1025 }
1026
1027 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1028 CTF flag for team two (Blue).
1029 Keys: 
1030 "angle" Angle the flag will point (minus 90 degrees)... 
1031 "model" model to use, note this needs red and blue as skins 0 and 1...
1032 "noise" sound played when flag is picked up...
1033 "noise1" sound played when flag is returned by a teammate...
1034 "noise2" sound played when flag is captured...
1035 "noise3" sound played when flag is lost in the field and respawns itself... 
1036 "noise4" sound played when flag is dropped by a player...
1037 "noise5" sound played when flag touches the ground... */
1038 void spawnfunc_item_flag_team2()
1039 {
1040         if(!g_ctf) { remove(self); return; }
1041
1042         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1043 }
1044
1045 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1046 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1047 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.
1048 Keys:
1049 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1050 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1051 void spawnfunc_ctf_team()
1052 {
1053         if(!g_ctf) { remove(self); return; }
1054         
1055         self.classname = "ctf_team";
1056         self.team = self.cnt + 1;
1057 }
1058
1059
1060 // ==============
1061 // Initialization
1062 // ==============
1063
1064 // code from here on is just to support maps that don't have flag and team entities
1065 void ctf_SpawnTeam (string teamname, float teamcolor)
1066 {
1067         entity oldself;
1068         oldself = self;
1069         self = spawn();
1070         self.classname = "ctf_team";
1071         self.netname = teamname;
1072         self.cnt = teamcolor;
1073
1074         spawnfunc_ctf_team();
1075
1076         self = oldself;
1077 }
1078
1079 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1080 {
1081         // if no teams are found, spawn defaults
1082         if(find(world, classname, "ctf_team") == world)
1083         {
1084                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1085                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1086                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1087         }
1088         
1089         ScoreRules_ctf();
1090 }
1091
1092 void ctf_Initialize()
1093 {
1094         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1095
1096         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1097         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1098         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1099         
1100         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1101 }
1102
1103
1104 MUTATOR_DEFINITION(gamemode_ctf)
1105 {
1106         MUTATOR_HOOK(MakePlayerObserver, ctf_HookedDrop, CBC_ORDER_ANY);
1107         MUTATOR_HOOK(ClientDisconnect, ctf_HookedDrop, CBC_ORDER_ANY);
1108         MUTATOR_HOOK(PlayerDies, ctf_HookedDrop, CBC_ORDER_ANY);
1109         MUTATOR_HOOK(PortalTeleport, ctf_HookedDrop, CBC_ORDER_ANY);
1110         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1111         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1112         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1113         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1114
1115         MUTATOR_ONADD
1116         {
1117                 if(time > 1) // game loads at time 1
1118                         error("This is a game type and it cannot be added at runtime.");
1119                 g_ctf = 1;
1120                 ctf_Initialize();
1121         }
1122
1123         MUTATOR_ONREMOVE
1124         {
1125                 g_ctf = 0;
1126                 error("This is a game type and it cannot be removed at runtime.");
1127         }
1128
1129         return 0;
1130 }