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 only
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"));
406 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield only
408 // set next take time
409 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
413 ctf_RespawnFlag(flag);
416 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
419 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
420 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
421 float pickup_dropped_score; // used to calculate dropped pickup score
423 // attach the flag to the player
425 player.flagcarried = flag;
426 setattachment(flag, player, "");
427 setorigin(flag, FLAG_CARRY_OFFSET);
430 flag.movetype = MOVETYPE_NONE;
431 flag.takedamage = DAMAGE_NO;
432 flag.solid = SOLID_NOT;
433 flag.angles = '0 0 0';
434 flag.ctf_carrier = player;
435 flag.ctf_status = FLAG_CARRY;
439 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
440 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
444 // messages and sounds
445 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
446 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
447 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
449 FOR_EACH_REALPLAYER(tmp_player)
450 if(tmp_player == player)
451 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
452 else if(!IsDifferentTeam(tmp_player, player))
453 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
454 else if(!IsDifferentTeam(tmp_player, flag))
455 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
459 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
460 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
465 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
470 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
476 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);
477 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);
478 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
479 PlayerTeamScore_AddScore(player, pickup_dropped_score);
487 if(pickuptype == PICKUP_BASE)
489 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
490 if((player.speedrunning) && (ctf_captimerecord))
491 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
495 if(autocvar_g_ctf_flag_pickup_effects)
496 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
499 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
500 ctf_FlagcarrierWaypoints(player);
501 WaypointSprite_Ping(player.wps_flagcarrier);
505 // ===================
506 // Main Flag Functions
507 // ===================
509 void ctf_CheckFlagReturn(entity flag)
511 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
513 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
515 bprint("The ", flag.netname, " has returned to base\n");
516 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
517 ctf_EventLog("returned", flag.team, world);
518 ctf_RespawnFlag(flag);
522 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
524 if(ITEM_DAMAGE_NEEDKILL(deathtype))
526 // automatically kill the flag and return it
528 ctf_CheckFlagReturn(self);
532 if(autocvar_g_ctf_flag_return_damage)
534 // reduce health and check if it should be returned
535 self.health = self.health - damage;
536 ctf_CheckFlagReturn(self);
546 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
549 if(self == ctf_worldflaglist) // only for the first flag
550 FOR_EACH_CLIENT(tmp_entity)
551 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
554 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
555 dprint("wtf the flag got squashed?\n");
556 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
557 if(!trace_startsolid) // can we resize it without getting stuck?
558 setsize(self, FLAG_MIN, FLAG_MAX); }
561 switch(self.ctf_status)
565 if(autocvar_g_ctf_dropped_capture_radius)
567 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
568 if(tmp_entity.ctf_status == FLAG_DROPPED)
569 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
570 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
577 if(autocvar_g_ctf_flag_return_dropped)
579 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
582 ctf_CheckFlagReturn(self);
586 if(autocvar_g_ctf_flag_return_time)
588 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
589 ctf_CheckFlagReturn(self);
597 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
599 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
600 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
601 ctf_EventLog("returned", self.team, world);
602 ctf_RespawnFlag(tmp_entity);
606 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
611 if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
612 if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
614 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));
616 if(!self.wpforenemy_announced)
618 FOR_EACH_REALPLAYER(tmp_entity)
620 if(tmp_entity == self.owner)
621 centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
622 else if(IsDifferentTeam(tmp_entity, self.owner))
623 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)"));
625 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)"));
628 self.wpforenemy_announced = TRUE;
634 case FLAG_PASSING: // todo make work with warpzones
636 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
637 traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
639 if((self.pass_target.deadflag != DEAD_NO)
640 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
641 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
642 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
644 ctf_Handle_Drop(self, world, DROP_PASS);
646 else // still a viable target, go for it
648 vector desired_direction = normalize(targ_origin - self.origin);
649 vector current_direction = normalize(self.velocity);
651 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
656 default: // this should never happen
658 dprint("ctf_FlagThink(): Flag exists with no status?\n");
666 if(gameover) { return; }
668 entity toucher = other;
670 // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
671 if(ITEM_TOUCH_NEEDKILL())
674 ctf_CheckFlagReturn(self);
678 // special touch behaviors
679 if(toucher.vehicle_flags & VHF_ISVEHICLE)
681 if(autocvar_g_ctf_allow_vehicle_touch)
682 toucher = toucher.owner; // the player is actually the vehicle owner, not other
684 return; // do nothing
686 else if(toucher.classname != "player") // The flag just touched an object, most likely the world
688 if(time > self.wait) // if we haven't in a while, play a sound/effect
690 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
691 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
692 self.wait = time + FLAG_TOUCHRATE;
696 else if(toucher.deadflag != DEAD_NO) { return; }
698 switch(self.ctf_status)
702 if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
703 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
704 else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
705 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
711 if(!IsDifferentTeam(toucher, self))
712 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
713 else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
714 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
720 dprint("Someone touched a flag even though it was being carried?\n");
726 if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
728 if(IsDifferentTeam(toucher, self.pass_sender))
729 ctf_Handle_Return(self, toucher);
731 ctf_Handle_Retrieve(self, toucher);
736 default: // this should never happen
738 dprint("Touch: Flag exists with no status?\n");
744 void ctf_RespawnFlag(entity flag)
746 // reset the player (if there is one)
747 if((flag.owner) && (flag.owner.flagcarried == flag))
749 if(flag.owner.wps_enemyflagcarrier)
750 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
752 WaypointSprite_Kill(flag.wps_flagcarrier);
754 flag.owner.flagcarried = world;
756 if(flag.speedrunning)
757 ctf_FakeTimeLimit(flag.owner, -1);
760 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
761 { WaypointSprite_Kill(flag.wps_flagdropped); }
764 setattachment(flag, world, "");
765 setorigin(flag, flag.ctf_spawnorigin);
767 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
768 flag.takedamage = DAMAGE_NO;
769 flag.health = flag.max_flag_health;
770 flag.solid = SOLID_TRIGGER;
771 flag.velocity = '0 0 0';
772 flag.angles = flag.mangle;
773 flag.flags = FL_ITEM | FL_NOTARGET;
775 flag.ctf_status = FLAG_BASE;
777 flag.pass_sender = world;
778 flag.pass_target = world;
779 flag.ctf_carrier = world;
780 flag.ctf_dropper = world;
781 flag.ctf_pickuptime = 0;
782 flag.ctf_droptime = 0;
783 flag.wpforenemy_announced = FALSE;
789 if(self.owner.classname == "player")
790 ctf_Handle_Throw(self.owner, world, DROP_RESET);
792 ctf_RespawnFlag(self);
795 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
798 waypoint_spawnforitem_force(self, self.origin);
799 self.nearestwaypointtimeout = 0; // activate waypointing again
800 self.bot_basewaypoint = self.nearestwaypoint;
803 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
804 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
806 // captureshield setup
807 ctf_CaptureShield_Spawn(self);
810 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
813 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.
814 self = flag; // for later usage with droptofloor()
817 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
818 ctf_worldflaglist = flag;
820 setattachment(flag, world, "");
822 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
823 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
824 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
825 flag.classname = "item_flag_team";
826 flag.target = "###item###"; // wut?
827 flag.flags = FL_ITEM | FL_NOTARGET;
828 flag.solid = SOLID_TRIGGER;
829 flag.takedamage = DAMAGE_NO;
830 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
831 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
832 flag.health = flag.max_flag_health;
833 flag.event_damage = ctf_FlagDamage;
834 flag.pushable = TRUE;
835 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
836 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
837 flag.velocity = '0 0 0';
838 flag.mangle = flag.angles;
839 flag.reset = ctf_Reset;
840 flag.touch = ctf_FlagTouch;
841 flag.think = ctf_FlagThink;
842 flag.nextthink = time + FLAG_THINKRATE;
843 flag.ctf_status = FLAG_BASE;
845 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
846 if(!flag.scale) { flag.scale = FLAG_SCALE; }
847 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
850 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
851 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
852 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
853 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.
854 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
855 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
858 precache_sound(flag.snd_flag_taken);
859 precache_sound(flag.snd_flag_returned);
860 precache_sound(flag.snd_flag_capture);
861 precache_sound(flag.snd_flag_respawn);
862 precache_sound(flag.snd_flag_dropped);
863 precache_sound(flag.snd_flag_touch);
864 precache_model(flag.model);
865 precache_model("models/ctf/shield.md3");
866 precache_model("models/ctf/shockwavetransring.md3");
869 setmodel(flag, flag.model); // precision set below
870 setsize(flag, FLAG_MIN, FLAG_MAX);
871 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
873 if(autocvar_g_ctf_flag_glowtrails)
875 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
880 flag.effects |= EF_LOWPRECISION;
881 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
882 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
885 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
887 flag.dropped_origin = flag.origin;
889 flag.movetype = MOVETYPE_NONE;
891 else // drop to floor, automatically find a platform and set that as spawn origin
893 flag.noalign = FALSE;
896 flag.movetype = MOVETYPE_TOSS;
899 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
907 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
911 // initially clear items so they can be set as necessary later.
912 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
913 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
915 // scan through all the flags and notify the client about them
916 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
918 if(flag.ctf_status == FLAG_CARRY)
919 if(flag.owner == self)
920 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
922 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
923 else if(flag.ctf_status == FLAG_DROPPED)
924 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
927 // item for stopping players from capturing the flag too often
928 if(self.ctf_captureshielded)
929 self.items |= IT_CTF_SHIELDED;
931 // update the health of the flag carrier waypointsprite
932 if(self.wps_flagcarrier)
933 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
938 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
940 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
942 if(frag_target == frag_attacker) // damage done to yourself
944 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
945 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
947 else // damage done everyone else
949 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
950 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
956 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
958 if((frag_attacker != frag_target) && (frag_attacker.classname == "player") && (frag_target.flagcarried))
960 PlayerTeamScore_AddScore(frag_attacker, ctf_ReadScore("score_kill"));
961 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
964 if(frag_target.flagcarried)
965 { ctf_Handle_Throw(frag_target, world, DROP_NORMAL); }
970 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
973 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
976 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
979 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
984 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
987 if(!autocvar_g_ctf_portalteleport)
988 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
993 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
995 entity player = self;
997 if((time > player.throw_antispam) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
999 // pass the flag to a team mate
1000 if(autocvar_g_ctf_pass)
1002 entity head, closest_target;
1003 head = findradius(player.origin, autocvar_g_ctf_pass_radius);
1005 while(head) // find the closest acceptable target to pass to
1007 if(head.classname == "player" && head.deadflag == DEAD_NO)
1008 if(head != player && !IsDifferentTeam(head, player))
1009 if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
1011 traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
1012 if not((trace_fraction < 1) && (trace_ent != head))
1014 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
1016 if(clienttype(head) == CLIENTTYPE_BOT)
1018 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1019 ctf_Handle_Throw(head, player, DROP_PASS);
1023 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
1024 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
1026 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
1029 else if(player.flagcarried)
1031 if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
1032 else { closest_target = head; }
1039 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1042 // throw the flag in front of you
1043 if(autocvar_g_ctf_drop && player.flagcarried)
1044 { ctf_Handle_Throw(player, world, DROP_THROW); }
1050 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
1052 if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
1054 WaypointSprite_HelpMePing(self.wps_flagcarrier);
1056 else // create a normal help me waypointsprite
1058 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');
1059 WaypointSprite_Ping(self.wps_helpme);
1065 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
1067 if(other.flagcarried)
1069 if(!autocvar_g_ctf_flagcarrier_allow_vehicle_carry)
1071 ctf_Handle_Throw(self, world, DROP_NORMAL);
1075 setattachment(other.flagcarried, self, "");
1076 setorigin(other, VEHICLE_FLAG_OFFSET);
1077 other.flagcarried.scale = VEHICLE_FLAG_SCALE;
1078 //other.flagcarried.angles = '0 0 0';
1085 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
1087 if(self.owner.flagcarried)
1089 setattachment(self.owner.flagcarried, self.owner, "");
1090 setorigin(self.owner.flagcarried, FLAG_CARRY_OFFSET);
1091 self.owner.flagcarried.scale = FLAG_SCALE;
1092 self.owner.flagcarried.angles = '0 0 0';
1098 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
1100 if(self.flagcarried)
1102 bprint("The ", self.flagcarried.netname, " was returned to base by its carrier\n");
1103 ctf_RespawnFlag(self);
1109 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
1111 entity flag; // temporary entity for the search method
1113 if(gameover) // is this necessary?
1115 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1117 switch(flag.ctf_status)
1122 // lock the flag, game is over
1123 flag.movetype = MOVETYPE_NONE;
1124 flag.takedamage = DAMAGE_NO;
1125 flag.solid = SOLID_NOT;
1126 flag.nextthink = 0; // stop thinking
1128 print("stopping the ", flag.netname, " from moving.\n");
1136 // do nothing for these flags
1151 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1152 CTF Starting point for a player in team one (Red).
1153 Keys: "angle" viewing angle when spawning. */
1154 void spawnfunc_info_player_team1()
1156 if(g_assault) { remove(self); return; }
1158 self.team = COLOR_TEAM1; // red
1159 spawnfunc_info_player_deathmatch();
1163 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1164 CTF Starting point for a player in team two (Blue).
1165 Keys: "angle" viewing angle when spawning. */
1166 void spawnfunc_info_player_team2()
1168 if(g_assault) { remove(self); return; }
1170 self.team = COLOR_TEAM2; // blue
1171 spawnfunc_info_player_deathmatch();
1174 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1175 CTF Starting point for a player in team three (Yellow).
1176 Keys: "angle" viewing angle when spawning. */
1177 void spawnfunc_info_player_team3()
1179 if(g_assault) { remove(self); return; }
1181 self.team = COLOR_TEAM3; // yellow
1182 spawnfunc_info_player_deathmatch();
1186 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1187 CTF Starting point for a player in team four (Purple).
1188 Keys: "angle" viewing angle when spawning. */
1189 void spawnfunc_info_player_team4()
1191 if(g_assault) { remove(self); return; }
1193 self.team = COLOR_TEAM4; // purple
1194 spawnfunc_info_player_deathmatch();
1197 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1198 CTF flag for team one (Red).
1200 "angle" Angle the flag will point (minus 90 degrees)...
1201 "model" model to use, note this needs red and blue as skins 0 and 1...
1202 "noise" sound played when flag is picked up...
1203 "noise1" sound played when flag is returned by a teammate...
1204 "noise2" sound played when flag is captured...
1205 "noise3" sound played when flag is lost in the field and respawns itself...
1206 "noise4" sound played when flag is dropped by a player...
1207 "noise5" sound played when flag touches the ground... */
1208 void spawnfunc_item_flag_team1()
1210 if(!g_ctf) { remove(self); return; }
1212 ctf_FlagSetup(1, self); // 1 = red
1215 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1216 CTF flag for team two (Blue).
1218 "angle" Angle the flag will point (minus 90 degrees)...
1219 "model" model to use, note this needs red and blue as skins 0 and 1...
1220 "noise" sound played when flag is picked up...
1221 "noise1" sound played when flag is returned by a teammate...
1222 "noise2" sound played when flag is captured...
1223 "noise3" sound played when flag is lost in the field and respawns itself...
1224 "noise4" sound played when flag is dropped by a player...
1225 "noise5" sound played when flag touches the ground... */
1226 void spawnfunc_item_flag_team2()
1228 if(!g_ctf) { remove(self); return; }
1230 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1233 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1234 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1235 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.
1237 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1238 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1239 void spawnfunc_ctf_team()
1241 if(!g_ctf) { remove(self); return; }
1243 self.classname = "ctf_team";
1244 self.team = self.cnt + 1;
1252 // code from here on is just to support maps that don't have flag and team entities
1253 void ctf_SpawnTeam (string teamname, float teamcolor)
1258 self.classname = "ctf_team";
1259 self.netname = teamname;
1260 self.cnt = teamcolor;
1262 spawnfunc_ctf_team();
1267 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1269 // if no teams are found, spawn defaults
1270 if(find(world, classname, "ctf_team") == world)
1272 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1273 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1274 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1280 void ctf_Initialize()
1282 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1284 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1285 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1286 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1288 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1292 MUTATOR_DEFINITION(gamemode_ctf)
1294 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1295 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1296 MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
1297 MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
1298 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1299 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1300 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1301 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1302 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1303 MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
1304 MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
1305 MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
1306 MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
1310 if(time > 1) // game loads at time 1
1311 error("This is a game type and it cannot be added at runtime.");
1319 error("This is a game type and it cannot be removed at runtime.");