1 // ================================================================
2 // Official capture the flag game mode coding, reworked by Samual
3 // Last updated: March 30th, 2012
4 // ================================================================
6 float ctf_ReadScore(string parameter) // make this obsolete
8 //if(g_ctf_win_mode != 2)
9 return cvar(strcat("g_ctf_personal", parameter));
11 // return cvar(strcat("g_ctf_flag", parameter));
14 void ctf_FakeTimeLimit(entity e, float t)
17 WriteByte(MSG_ONE, 3); // svc_updatestat
18 WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
20 WriteCoord(MSG_ONE, autocvar_timelimit);
22 WriteCoord(MSG_ONE, (t + 1) / 60);
25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
27 if(autocvar_sv_eventlog)
28 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
31 string ctf_CaptureRecord(entity flag, entity player)
33 float cap_time, cap_record, success;
34 string cap_message, refername;
36 if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
38 cap_record = ctf_captimerecord;
39 cap_time = (time - flag.ctf_pickuptime);
41 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
42 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
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; }
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; }
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);
63 void ctf_FlagcarrierWaypoints(entity player)
65 WaypointSprite_Spawn("flagcarrier", 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_FLAGCARRIER(player.team));
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, WPCOLOR_FLAGCARRIER(player.team));
72 // =======================
73 // CaptureShield Functions
74 // =======================
76 float ctf_CaptureShield_CheckStatus(entity p)
80 float players_worseeq, players_total;
82 if(ctf_captureshield_max_ratio <= 0)
85 s = PlayerScore_Add(p, SP_SCORE, 0);
86 if(s >= -ctf_captureshield_min_negscore)
89 players_total = players_worseeq = 0;
92 if(IsDifferentTeam(e, p))
94 se = PlayerScore_Add(e, SP_SCORE, 0);
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
103 if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
109 void ctf_CaptureShield_Update(entity player, float wanted_status)
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
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);
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);
119 player.ctf_captureshielded = updated_status;
123 float ctf_CaptureShield_Customize()
125 if(!other.ctf_captureshielded) { return FALSE; }
126 if(!IsDifferentTeam(self, other)) { return FALSE; }
131 void ctf_CaptureShield_Touch()
133 if(!other.ctf_captureshielded) { return; }
134 if(!IsDifferentTeam(self, other)) { return; }
136 vector mymid = (self.absmin + self.absmax) * 0.5;
137 vector othermid = (other.absmin + other.absmax) * 0.5;
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);
143 void ctf_CaptureShield_Spawn(entity flag)
145 entity shield = spawn();
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';
158 setorigin(shield, self.origin);
159 setmodel(shield, "models/ctf/shield.md3");
160 setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
164 // ====================
165 // Drop/Pass/Throw Code
166 // ====================
168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
171 player = (player ? player : flag.pass_sender);
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;
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);
187 PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));
188 PlayerScore_Add(player, SP_CTF_DROPS, 1);
191 if(autocvar_g_ctf_flag_dropped_waypoint)
192 WaypointSprite_Spawn("flagdropped", 0, 0, flag, FLAG_WAYPOINT_OFFSET, world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, TRUE, RADARICON_FLAG, WPCOLOR_DROPPEDFLAG(flag.team));
194 if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
196 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
197 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
200 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
202 if(droptype == DROP_PASS)
204 flag.pass_sender = world;
205 flag.pass_target = world;
209 void ctf_Handle_Retrieve(entity flag, entity player)
211 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
212 entity sender = flag.pass_sender;
214 // transfer flag to player
215 flag.ctf_carrier = player;
217 flag.owner.flagcarried = 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;
228 // messages and sounds
229 sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM); // FIXCTF
230 ctf_EventLog("recieve", flag.team, player);
231 FOR_EACH_REALPLAYER(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(!IsDifferentTeam(tmp_player, sender))
237 centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
239 // create new waypoint
240 ctf_FlagcarrierWaypoints(player);
242 sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
243 player.throw_antispam = sender.throw_antispam;
245 flag.pass_sender = world;
246 flag.pass_target = world;
249 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
251 entity flag = player.flagcarried;
253 if(!flag) { return; }
254 if((droptype == DROP_PASS) && !reciever) { return; }
256 if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
259 setattachment(flag, world, "");
260 setorigin(flag, player.origin + FLAG_DROP_OFFSET);
261 flag.owner.flagcarried = world;
263 flag.solid = SOLID_TRIGGER;
264 flag.ctf_droptime = time;
266 flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
272 vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
273 flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_pass_velocity);
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_drop_velocity)), FALSE);
286 flag.velocity = '0 0 0'; // do nothing
293 flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom())), FALSE);
303 flag.movetype = MOVETYPE_FLY;
304 flag.takedamage = DAMAGE_NO;
305 flag.pass_sender = player;
306 flag.pass_target = reciever;
307 flag.ctf_status = FLAG_PASSING;
310 sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
311 ctf_EventLog("pass", flag.team, player);
312 te_lightning2(world, reciever.origin, player.origin);
326 ctf_Handle_Drop(flag, player, droptype);
331 // kill old waypointsprite
332 WaypointSprite_Ping(player.wps_flagcarrier);
333 WaypointSprite_Kill(player.wps_flagcarrier);
335 if(player.wps_enemyflagcarrier)
336 WaypointSprite_Kill(player.wps_enemyflagcarrier);
339 ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
347 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
349 entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
350 entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
352 if not(player) { return; } // without someone to give the reward to, we can't possibly cap
354 // messages and sounds
355 Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
356 sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
360 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
361 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
366 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
367 PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
370 if(autocvar_g_ctf_flag_capture_effects)
372 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
373 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
377 if(capturetype == CAPTURE_NORMAL)
379 WaypointSprite_Kill(player.wps_flagcarrier);
380 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
384 player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
385 ctf_RespawnFlag(enemy_flag);
388 void ctf_Handle_Return(entity flag, entity player)
390 // messages and sounds
391 //centerprint(player, strcat("You returned the ", flag.netname));
392 Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
393 sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
394 ctf_EventLog("return", flag.team, player);
397 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
398 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
400 TeamScore_AddToTeam(flag.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
404 // punish the player who dropped the flag
405 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned"));
408 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
410 // set next take time
411 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
415 ctf_RespawnFlag(flag);
418 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
421 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
422 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
423 float pickup_dropped_score; // used to calculate dropped pickup score
425 // attach the flag to the player
427 player.flagcarried = flag;
428 setattachment(flag, player, "");
429 setorigin(flag, FLAG_CARRY_OFFSET);
432 flag.movetype = MOVETYPE_NONE;
433 flag.takedamage = DAMAGE_NO;
434 flag.solid = SOLID_NOT;
435 flag.angles = '0 0 0';
436 flag.ctf_carrier = player;
437 flag.ctf_status = FLAG_CARRY;
441 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
442 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
446 // messages and sounds
447 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
448 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
449 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
451 FOR_EACH_REALPLAYER(tmp_player)
452 if(tmp_player == player)
453 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
454 else if(!IsDifferentTeam(tmp_player, player))
455 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
456 else if(!IsDifferentTeam(tmp_player, flag))
457 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
461 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
462 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
467 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
472 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
478 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);
479 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);
480 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
481 PlayerTeamScore_AddScore(player, pickup_dropped_score);
489 if(pickuptype == PICKUP_BASE)
491 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
492 if((player.speedrunning) && (ctf_captimerecord))
493 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
497 if(autocvar_g_ctf_flag_pickup_effects)
498 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
501 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
502 ctf_FlagcarrierWaypoints(player);
503 WaypointSprite_Ping(player.wps_flagcarrier);
507 // ===================
508 // Main Flag Functions
509 // ===================
511 void ctf_CheckFlagReturn(entity flag)
513 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
515 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
517 bprint("The ", flag.netname, " has returned to base\n");
518 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
519 ctf_EventLog("returned", flag.team, world);
520 ctf_RespawnFlag(flag);
524 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
526 if(ITEM_DAMAGE_NEEDKILL(deathtype))
528 // automatically kill the flag and return it
530 ctf_CheckFlagReturn(self);
534 if(autocvar_g_ctf_flag_return_damage)
536 // reduce health and check if it should be returned
537 self.health = self.health - damage;
538 ctf_CheckFlagReturn(self);
548 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
551 if(self == ctf_worldflaglist) // only for the first flag
552 FOR_EACH_CLIENT(tmp_entity)
553 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
556 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
557 dprint("wtf the flag got squashed?\n");
558 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
559 if(!trace_startsolid) // can we resize it without getting stuck?
560 setsize(self, FLAG_MIN, FLAG_MAX); }
562 switch(self.ctf_status) // reset flag angles in case warpzones adjust it
567 self.angles = '0 0 0';
575 switch(self.ctf_status)
579 if(autocvar_g_ctf_dropped_capture_radius)
581 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
582 if(tmp_entity.ctf_status == FLAG_DROPPED)
583 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
584 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
592 if(autocvar_g_ctf_flag_dropped_floatinwater && (self.flags & FL_INWATER))
593 self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater;
595 if(autocvar_g_ctf_flag_return_dropped)
597 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
600 ctf_CheckFlagReturn(self);
604 if(autocvar_g_ctf_flag_return_time)
606 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
607 ctf_CheckFlagReturn(self);
615 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
617 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
618 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
619 ctf_EventLog("returned", self.team, world);
620 ctf_RespawnFlag(tmp_entity);
624 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
629 if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
630 if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
632 WaypointSprite_Spawn("enemyflagcarrier", 0, 0, self.owner, FLAG_WAYPOINT_OFFSET, world, self.team, self.owner, wps_enemyflagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_ENEMYFC(self.owner.team));
634 if(!self.wpforenemy_announced)
636 FOR_EACH_REALPLAYER(tmp_entity)
638 if(tmp_entity == self.owner)
639 centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
640 else if(IsDifferentTeam(tmp_entity, self.owner))
641 centerprint(tmp_entity, strcat("You can now see the enemy flag carrier on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
643 centerprint(tmp_entity, strcat("Enemies can now see your flag carrier on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
646 self.wpforenemy_announced = TRUE;
652 case FLAG_PASSING: // todo make work with warpzones
654 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
655 traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
657 if((self.pass_target.deadflag != DEAD_NO)
658 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
659 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
660 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
662 ctf_Handle_Drop(self, world, DROP_PASS);
664 else // still a viable target, go for it
666 vector desired_direction = normalize(targ_origin - self.origin);
667 vector current_direction = normalize(self.velocity);
669 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
674 default: // this should never happen
676 dprint("ctf_FlagThink(): Flag exists with no status?\n");
684 if(gameover) { return; }
686 entity toucher = other;
688 // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
689 if(ITEM_TOUCH_NEEDKILL())
692 ctf_CheckFlagReturn(self);
696 // special touch behaviors
697 if(toucher.vehicle_flags & VHF_ISVEHICLE)
699 if(autocvar_g_ctf_allow_vehicle_touch)
700 toucher = toucher.owner; // the player is actually the vehicle owner, not other
702 return; // do nothing
704 else if(toucher.classname != "player") // The flag just touched an object, most likely the world
706 if(time > self.wait) // if we haven't in a while, play a sound/effect
708 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
709 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
710 self.wait = time + FLAG_TOUCHRATE;
714 else if(toucher.deadflag != DEAD_NO) { return; }
716 switch(self.ctf_status)
720 if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
721 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
722 else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
723 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
729 if(!IsDifferentTeam(toucher, self))
730 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
731 else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
732 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
738 dprint("Someone touched a flag even though it was being carried?\n");
744 if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
746 if(IsDifferentTeam(toucher, self.pass_sender))
747 ctf_Handle_Return(self, toucher);
749 ctf_Handle_Retrieve(self, toucher);
754 default: // this should never happen
756 dprint("Touch: Flag exists with no status?\n");
762 void ctf_RespawnFlag(entity flag)
764 // reset the player (if there is one)
765 if((flag.owner) && (flag.owner.flagcarried == flag))
767 if(flag.owner.wps_enemyflagcarrier)
768 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
770 WaypointSprite_Kill(flag.wps_flagcarrier);
772 flag.owner.flagcarried = world;
774 if(flag.speedrunning)
775 ctf_FakeTimeLimit(flag.owner, -1);
778 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
779 { WaypointSprite_Kill(flag.wps_flagdropped); }
782 setattachment(flag, world, "");
783 setorigin(flag, flag.ctf_spawnorigin);
785 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
786 flag.takedamage = DAMAGE_NO;
787 flag.health = flag.max_flag_health;
788 flag.solid = SOLID_TRIGGER;
789 flag.velocity = '0 0 0';
790 flag.angles = flag.mangle;
791 flag.flags = FL_ITEM | FL_NOTARGET;
793 flag.ctf_status = FLAG_BASE;
795 flag.pass_sender = world;
796 flag.pass_target = world;
797 flag.ctf_carrier = world;
798 flag.ctf_dropper = world;
799 flag.ctf_pickuptime = 0;
800 flag.ctf_droptime = 0;
801 flag.wpforenemy_announced = FALSE;
807 if(self.owner.classname == "player")
808 ctf_Handle_Throw(self.owner, world, DROP_RESET);
810 ctf_RespawnFlag(self);
813 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
816 waypoint_spawnforitem_force(self, self.origin);
817 self.nearestwaypointtimeout = 0; // activate waypointing again
818 self.bot_basewaypoint = self.nearestwaypoint;
821 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
822 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
824 // captureshield setup
825 ctf_CaptureShield_Spawn(self);
828 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
831 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.
832 self = flag; // for later usage with droptofloor()
835 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
836 ctf_worldflaglist = flag;
838 setattachment(flag, world, "");
840 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
841 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
842 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
843 flag.classname = "item_flag_team";
844 flag.target = "###item###"; // wut?
845 flag.flags = FL_ITEM | FL_NOTARGET;
846 flag.solid = SOLID_TRIGGER;
847 flag.takedamage = DAMAGE_NO;
848 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
849 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
850 flag.health = flag.max_flag_health;
851 flag.event_damage = ctf_FlagDamage;
852 flag.pushable = TRUE;
853 flag.teleportable = TELEPORT_NORMAL;
854 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
855 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
856 flag.velocity = '0 0 0';
857 flag.mangle = flag.angles;
858 flag.reset = ctf_Reset;
859 flag.touch = ctf_FlagTouch;
860 flag.think = ctf_FlagThink;
861 flag.nextthink = time + FLAG_THINKRATE;
862 flag.ctf_status = FLAG_BASE;
864 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
865 if(!flag.scale) { flag.scale = FLAG_SCALE; }
866 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
869 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
870 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
871 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
872 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.
873 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
874 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
877 precache_sound(flag.snd_flag_taken);
878 precache_sound(flag.snd_flag_returned);
879 precache_sound(flag.snd_flag_capture);
880 precache_sound(flag.snd_flag_respawn);
881 precache_sound(flag.snd_flag_dropped);
882 precache_sound(flag.snd_flag_touch);
883 precache_model(flag.model);
884 precache_model("models/ctf/shield.md3");
885 precache_model("models/ctf/shockwavetransring.md3");
888 setmodel(flag, flag.model); // precision set below
889 setsize(flag, FLAG_MIN, FLAG_MAX);
890 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
892 if(autocvar_g_ctf_flag_glowtrails)
894 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
899 flag.effects |= EF_LOWPRECISION;
900 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
901 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
904 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
906 flag.dropped_origin = flag.origin;
908 flag.movetype = MOVETYPE_NONE;
910 else // drop to floor, automatically find a platform and set that as spawn origin
912 flag.noalign = FALSE;
915 flag.movetype = MOVETYPE_TOSS;
918 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
926 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
930 // initially clear items so they can be set as necessary later.
931 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
932 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
934 // scan through all the flags and notify the client about them
935 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
937 if(flag.ctf_status == FLAG_CARRY)
938 if(flag.owner == self)
939 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
941 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
942 else if(flag.ctf_status == FLAG_DROPPED)
943 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
946 // item for stopping players from capturing the flag too often
947 if(self.ctf_captureshielded)
948 self.items |= IT_CTF_SHIELDED;
950 // update the health of the flag carrier waypointsprite
951 if(self.wps_flagcarrier)
952 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
957 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
959 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
961 if(frag_target == frag_attacker) // damage done to yourself
963 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
964 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
966 else // damage done everyone else
968 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
969 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
975 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
977 if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
979 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
980 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
983 if(frag_target.flagcarried)
984 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
989 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
992 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
995 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
998 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1003 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
1005 if(self.flagcarried)
1006 if(!autocvar_g_ctf_portalteleport)
1007 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
1012 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
1014 entity player = self;
1016 if((time > player.throw_antispam) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1018 // pass the flag to a team mate
1019 if(autocvar_g_ctf_pass)
1021 entity head, closest_target;
1022 head = findradius(player.origin, autocvar_g_ctf_pass_radius);
1024 while(head) // find the closest acceptable target to pass to
1026 if(head.classname == "player" && head.deadflag == DEAD_NO)
1027 if(head != player && !IsDifferentTeam(head, player))
1028 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1030 traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
1031 if not((trace_fraction < 1) && (trace_ent != head))
1033 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1035 if(clienttype(head) == CLIENTTYPE_BOT)
1037 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1038 ctf_Handle_Throw(head, player, DROP_PASS);
1042 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1043 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1045 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1048 else if(player.flagcarried)
1050 if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
1051 else { closest_target = head; }
1058 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1061 // throw the flag in front of you
1062 if(autocvar_g_ctf_drop && player.flagcarried)
1063 { ctf_Handle_Throw(player, world, DROP_THROW); }
1069 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1071 if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1073 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1075 else // create a normal help me waypointsprite
1077 WaypointSprite_Spawn("helpme", waypointsprite_deployed_lifetime, waypointsprite_limitedrange, self, FLAG_WAYPOINT_OFFSET, world, self.team, self, wps_helpme, FALSE, RADARICON_HELPME, '1 0.5 0');
1078 WaypointSprite_Ping(self.wps_helpme);
1084 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1086 if(other.flagcarried)
1088 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1090 ctf_Handle_Throw(self, world, DROP_NORMAL);
1094 setattachment(other.flagcarried, self, "");
1095 setorigin(other, VEHICLE_FLAG_OFFSET);
1096 other.flagcarried.scale = VEHICLE_FLAG_SCALE;
1097 //other.flagcarried.angles = '0 0 0';
1104 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1106 if(self.owner.flagcarried)
1108 setattachment(self.owner.flagcarried, self.owner, "");
1109 setorigin(self.owner.flagcarried, FLAG_CARRY_OFFSET);
1110 self.owner.flagcarried.scale = FLAG_SCALE;
1111 self.owner.flagcarried.angles = '0 0 0';
1117 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1119 if(self.flagcarried)
1121 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1122 ctf_RespawnFlag(self);
1128 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1130 entity flag; // temporary entity for the search method
1132 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1134 switch(flag.ctf_status)
1139 // lock the flag, game is over
1140 flag.movetype = MOVETYPE_NONE;
1141 flag.takedamage = DAMAGE_NO;
1142 flag.solid = SOLID_NOT;
1143 flag.nextthink = 0; // stop thinking
1145 print("stopping the ", flag.netname, " from moving.\n");
1153 // do nothing for these flags
1167 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1168 CTF Starting point for a player in team one (Red).
1169 Keys: "angle" viewing angle when spawning. */
1170 void spawnfunc_info_player_team1()
1172 if(g_assault) { remove(self); return; }
1174 self.team = COLOR_TEAM1; // red
1175 spawnfunc_info_player_deathmatch();
1179 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1180 CTF Starting point for a player in team two (Blue).
1181 Keys: "angle" viewing angle when spawning. */
1182 void spawnfunc_info_player_team2()
1184 if(g_assault) { remove(self); return; }
1186 self.team = COLOR_TEAM2; // blue
1187 spawnfunc_info_player_deathmatch();
1190 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1191 CTF Starting point for a player in team three (Yellow).
1192 Keys: "angle" viewing angle when spawning. */
1193 void spawnfunc_info_player_team3()
1195 if(g_assault) { remove(self); return; }
1197 self.team = COLOR_TEAM3; // yellow
1198 spawnfunc_info_player_deathmatch();
1202 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1203 CTF Starting point for a player in team four (Purple).
1204 Keys: "angle" viewing angle when spawning. */
1205 void spawnfunc_info_player_team4()
1207 if(g_assault) { remove(self); return; }
1209 self.team = COLOR_TEAM4; // purple
1210 spawnfunc_info_player_deathmatch();
1213 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1214 CTF flag for team one (Red).
1216 "angle" Angle the flag will point (minus 90 degrees)...
1217 "model" model to use, note this needs red and blue as skins 0 and 1...
1218 "noise" sound played when flag is picked up...
1219 "noise1" sound played when flag is returned by a teammate...
1220 "noise2" sound played when flag is captured...
1221 "noise3" sound played when flag is lost in the field and respawns itself...
1222 "noise4" sound played when flag is dropped by a player...
1223 "noise5" sound played when flag touches the ground... */
1224 void spawnfunc_item_flag_team1()
1226 if(!g_ctf) { remove(self); return; }
1228 ctf_FlagSetup(1, self); // 1 = red
1231 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1232 CTF flag for team two (Blue).
1234 "angle" Angle the flag will point (minus 90 degrees)...
1235 "model" model to use, note this needs red and blue as skins 0 and 1...
1236 "noise" sound played when flag is picked up...
1237 "noise1" sound played when flag is returned by a teammate...
1238 "noise2" sound played when flag is captured...
1239 "noise3" sound played when flag is lost in the field and respawns itself...
1240 "noise4" sound played when flag is dropped by a player...
1241 "noise5" sound played when flag touches the ground... */
1242 void spawnfunc_item_flag_team2()
1244 if(!g_ctf) { remove(self); return; }
1246 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1249 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1250 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1251 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.
1253 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1254 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1255 void spawnfunc_ctf_team()
1257 if(!g_ctf) { remove(self); return; }
1259 self.classname = "ctf_team";
1260 self.team = self.cnt + 1;
1268 // code from here on is just to support maps that don't have flag and team entities
1269 void ctf_SpawnTeam (string teamname, float teamcolor)
1274 self.classname = "ctf_team";
1275 self.netname = teamname;
1276 self.cnt = teamcolor;
1278 spawnfunc_ctf_team();
1283 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1285 // if no teams are found, spawn defaults
1286 if(find(world, classname, "ctf_team") == world)
1288 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1289 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1290 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1296 void ctf_Initialize()
1298 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1300 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1301 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1302 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1304 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1308 MUTATOR_DEFINITION(gamemode_ctf)
1310 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1311 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1312 MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1313 MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1314 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1315 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1316 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1317 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1318 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1319 MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1320 MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1321 MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1322 MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1326 if(time > 1) // game loads at time 1
1327 error("This is a game type and it cannot be added at runtime.");
1335 error("This is a game type and it cannot be removed at runtime.");