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);
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(!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 = ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom()));
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.ctf_dropper.team, ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
401 FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
403 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
404 ctf_CaptureShield_Update(player, 0); // shield only
408 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
409 ctf_RespawnFlag(flag);
412 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
415 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
416 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
417 float pickup_dropped_score; // used to calculate dropped pickup score
419 // attach the flag to the player
421 player.flagcarried = flag;
422 setattachment(flag, player, "");
423 setorigin(flag, FLAG_CARRY_OFFSET);
426 flag.movetype = MOVETYPE_NONE;
427 flag.takedamage = DAMAGE_NO;
428 flag.solid = SOLID_NOT;
429 flag.angles = '0 0 0';
430 flag.ctf_carrier = player;
431 flag.ctf_status = FLAG_CARRY;
435 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
436 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
440 // messages and sounds
441 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
442 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
443 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
445 FOR_EACH_PLAYER(tmp_player)
446 if(tmp_player == player)
447 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
448 else if(!IsDifferentTeam(tmp_player, player))
449 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
450 else if(!IsDifferentTeam(tmp_player, flag))
451 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
455 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
456 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
461 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
466 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
472 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);
473 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);
474 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
475 PlayerTeamScore_AddScore(player, pickup_dropped_score);
483 if(pickuptype == PICKUP_BASE)
485 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
486 if((player.speedrunning) && (ctf_captimerecord))
487 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
491 if(autocvar_g_ctf_flag_pickup_effects)
492 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
495 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
496 ctf_FlagcarrierWaypoints(player);
497 WaypointSprite_Ping(player.wps_flagcarrier);
501 // ===================
502 // Main Flag Functions
503 // ===================
505 void ctf_CheckFlagReturn(entity flag)
507 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
509 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
511 bprint("The ", flag.netname, " has returned to base\n");
512 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
513 ctf_EventLog("returned", flag.team, world);
514 ctf_RespawnFlag(flag);
518 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
520 if(ITEM_DAMAGE_NEEDKILL(deathtype))
522 // automatically kill the flag and return it
524 ctf_CheckFlagReturn(self);
528 if(autocvar_g_ctf_flag_return_damage)
530 self.health = self.health - damage;
531 ctf_CheckFlagReturn(self);
541 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
544 if(self == ctf_worldflaglist) // only for the first flag
545 FOR_EACH_CLIENT(tmp_entity)
546 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
549 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
550 dprint("wtf the flag got squashed?\n");
551 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
552 if(!trace_startsolid) // can we resize it without getting stuck?
553 setsize(self, FLAG_MIN, FLAG_MAX); }
556 switch(self.ctf_status)
560 if(autocvar_g_ctf_dropped_capture_radius)
562 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
563 if(tmp_entity.ctf_status == FLAG_DROPPED)
564 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
565 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
572 if(autocvar_g_ctf_flag_return_dropped)
574 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
577 ctf_CheckFlagReturn(self);
581 if(autocvar_g_ctf_flag_return_time)
583 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
584 ctf_CheckFlagReturn(self);
592 if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
594 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
595 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
596 ctf_EventLog("returned", self.team, world);
597 ctf_RespawnFlag(tmp_entity);
601 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
606 if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
607 if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
609 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));
611 if(!self.wpforenemy_announced)
613 FOR_EACH_PLAYER(tmp_entity)
614 if(tmp_entity == self.owner)
615 centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
616 else if(!IsDifferentTeam(tmp_entity, self.owner))
617 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)"));
618 else if(!IsDifferentTeam(tmp_entity, self))
619 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)"));
621 self.wpforenemy_announced = TRUE;
628 case FLAG_PASSING: // todo make work with warpzones
630 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
632 traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
634 if((self.pass_target.deadflag != DEAD_NO)
635 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
636 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
637 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
639 ctf_Handle_Drop(self, world, DROP_PASS);
641 else // still a viable target, go for it
643 vector desired_direction = normalize(targ_origin - self.origin);
644 vector current_direction = normalize(self.velocity);
646 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity);
651 default: // this should never happen
653 dprint("ctf_FlagThink(): Flag exists with no status?\n");
661 if(gameover) { return; }
662 if(!self) { return; }
663 if(other.deadflag != DEAD_NO) { return; }
664 if(ITEM_TOUCH_NEEDKILL())
666 // automatically kill the flag and return it
668 ctf_CheckFlagReturn(self);
671 if(other.classname != "player") // The flag just touched an object, most likely the world
673 if(time > self.wait) // if we haven't in a while, play a sound/effect
675 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
676 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
677 self.wait = time + FLAG_TOUCHRATE;
682 switch(self.ctf_status)
686 if(!IsDifferentTeam(other, self) && (other.flagcarried) && IsDifferentTeam(other.flagcarried, self))
687 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
688 else if(IsDifferentTeam(other, self) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
689 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
695 if(!IsDifferentTeam(other, self))
696 ctf_Handle_Return(self, other); // other just returned his own flag
697 else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
698 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
704 dprint("Someone touched a flag even though it was being carried?\n");
710 if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
712 if(IsDifferentTeam(other, self.pass_sender))
713 ctf_Handle_Return(self, other);
715 ctf_Handle_Retrieve(self, other);
720 default: // this should never happen
722 dprint("Touch: Flag exists with no status?\n");
728 void ctf_RespawnFlag(entity flag)
730 // reset the player (if there is one)
731 if((flag.owner) && (flag.owner.flagcarried == flag))
733 if(flag.owner.wps_enemyflagcarrier)
734 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
736 WaypointSprite_Kill(flag.wps_flagcarrier);
738 flag.owner.flagcarried = world;
740 if(flag.speedrunning)
741 ctf_FakeTimeLimit(flag.owner, -1);
744 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
745 { WaypointSprite_Kill(flag.wps_flagdropped); }
748 setattachment(flag, world, "");
749 setorigin(flag, flag.ctf_spawnorigin);
751 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
752 flag.takedamage = DAMAGE_NO;
753 flag.health = flag.max_flag_health;
754 flag.solid = SOLID_TRIGGER;
755 flag.velocity = '0 0 0';
756 flag.angles = flag.mangle;
757 flag.flags = FL_ITEM | FL_NOTARGET;
759 flag.ctf_status = FLAG_BASE;
761 flag.pass_sender = world;
762 flag.pass_target = world;
763 flag.ctf_carrier = world;
764 flag.ctf_dropper = world;
765 flag.ctf_pickuptime = 0;
766 flag.ctf_droptime = 0;
767 flag.wpforenemy_announced = FALSE;
773 if(self.owner.classname == "player")
774 ctf_Handle_Throw(self.owner, world, DROP_RESET);
776 ctf_RespawnFlag(self);
779 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
782 waypoint_spawnforitem_force(self, self.origin);
783 self.nearestwaypointtimeout = 0; // activate waypointing again
784 self.bot_basewaypoint = self.nearestwaypoint;
787 WaypointSprite_SpawnFixed(((self.team == COLOR_TEAM1) ? "redbase" : "bluebase"), self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
788 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(self.team - 1, FALSE));
790 // captureshield setup
791 ctf_CaptureShield_Spawn(self);
794 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
797 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.
798 self = flag; // for later usage with droptofloor()
801 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
802 ctf_worldflaglist = flag;
804 setattachment(flag, world, "");
806 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
807 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
808 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
809 flag.classname = "item_flag_team";
810 flag.target = "###item###"; // wut?
811 flag.flags = FL_ITEM | FL_NOTARGET;
812 flag.solid = SOLID_TRIGGER;
813 flag.takedamage = DAMAGE_NO;
814 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
815 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
816 flag.health = flag.max_flag_health;
817 flag.event_damage = ctf_FlagDamage;
818 flag.pushable = TRUE;
819 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
820 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
821 flag.velocity = '0 0 0';
822 flag.mangle = flag.angles;
823 flag.reset = ctf_Reset;
824 flag.touch = ctf_FlagTouch;
825 flag.think = ctf_FlagThink;
826 flag.nextthink = time + FLAG_THINKRATE;
827 flag.ctf_status = FLAG_BASE;
829 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
830 if(!flag.scale) { flag.scale = FLAG_SCALE; }
831 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
834 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
835 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
836 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
837 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.
838 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
839 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
842 precache_sound(flag.snd_flag_taken);
843 precache_sound(flag.snd_flag_returned);
844 precache_sound(flag.snd_flag_capture);
845 precache_sound(flag.snd_flag_respawn);
846 precache_sound(flag.snd_flag_dropped);
847 precache_sound(flag.snd_flag_touch);
848 precache_model(flag.model);
849 precache_model("models/ctf/shield.md3");
850 precache_model("models/ctf/shockwavetransring.md3");
853 setmodel(flag, flag.model); // precision set below
854 setsize(flag, FLAG_MIN, FLAG_MAX);
855 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
857 if(autocvar_g_ctf_flag_glowtrails)
859 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
864 flag.effects |= EF_LOWPRECISION;
865 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
866 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
869 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
871 flag.dropped_origin = flag.origin;
873 flag.movetype = MOVETYPE_NONE;
875 else // drop to floor, automatically find a platform and set that as spawn origin
877 flag.noalign = FALSE;
880 flag.movetype = MOVETYPE_TOSS;
883 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
891 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
894 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
899 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
902 if(!autocvar_g_ctf_portalteleport)
903 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
908 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
912 // initially clear items so they can be set as necessary later.
913 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
914 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
916 // scan through all the flags and notify the client about them
917 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
919 if(flag.ctf_status == FLAG_CARRY)
920 if(flag.owner == self)
921 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
923 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
924 else if(flag.ctf_status == FLAG_DROPPED)
925 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
928 // item for stopping players from capturing the flag too often
929 if(self.ctf_captureshielded)
930 self.items |= IT_CTF_SHIELDED;
932 // update the health of the flag carrier waypointsprite
933 if(self.wps_flagcarrier)
934 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
939 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
941 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
943 if(frag_target == frag_attacker) // damage done to yourself
945 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
946 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
948 else // damage done everyone else
950 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
951 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
957 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
960 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
963 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
965 entity player = self;
967 if(time > player.throw_antispam)
969 // pass the flag to a team mate
970 if(autocvar_g_ctf_pass)
972 entity head, closest_target;
973 head = findradius(player.origin, autocvar_g_ctf_pass_radius);
975 while(head) // find the closest acceptable target to pass to
977 if(head.classname == "player" && head.deadflag == DEAD_NO)
978 if(head != player && !IsDifferentTeam(head, player))
979 if(!player.speedrunning && !head.speedrunning)
981 traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
982 if not((trace_fraction < 1) && (trace_ent != head))
984 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
986 if(clienttype(head) == CLIENTTYPE_BOT)
988 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
989 ctf_Handle_Throw(head, player, DROP_PASS);
993 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
994 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
996 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
999 else if(player.flagcarried)
1001 if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
1002 else { closest_target = head; }
1009 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
1012 // throw the flag in front of you
1013 if(autocvar_g_ctf_drop && player.flagcarried && !player.speedrunning)
1014 { ctf_Handle_Throw(player, world, DROP_THROW); }
1024 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
1025 CTF Starting point for a player in team one (Red).
1026 Keys: "angle" viewing angle when spawning. */
1027 void spawnfunc_info_player_team1()
1029 if(g_assault) { remove(self); return; }
1031 self.team = COLOR_TEAM1; // red
1032 spawnfunc_info_player_deathmatch();
1036 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1037 CTF Starting point for a player in team two (Blue).
1038 Keys: "angle" viewing angle when spawning. */
1039 void spawnfunc_info_player_team2()
1041 if(g_assault) { remove(self); return; }
1043 self.team = COLOR_TEAM2; // blue
1044 spawnfunc_info_player_deathmatch();
1047 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1048 CTF Starting point for a player in team three (Yellow).
1049 Keys: "angle" viewing angle when spawning. */
1050 void spawnfunc_info_player_team3()
1052 if(g_assault) { remove(self); return; }
1054 self.team = COLOR_TEAM3; // yellow
1055 spawnfunc_info_player_deathmatch();
1059 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1060 CTF Starting point for a player in team four (Purple).
1061 Keys: "angle" viewing angle when spawning. */
1062 void spawnfunc_info_player_team4()
1064 if(g_assault) { remove(self); return; }
1066 self.team = COLOR_TEAM4; // purple
1067 spawnfunc_info_player_deathmatch();
1070 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1071 CTF flag for team one (Red).
1073 "angle" Angle the flag will point (minus 90 degrees)...
1074 "model" model to use, note this needs red and blue as skins 0 and 1...
1075 "noise" sound played when flag is picked up...
1076 "noise1" sound played when flag is returned by a teammate...
1077 "noise2" sound played when flag is captured...
1078 "noise3" sound played when flag is lost in the field and respawns itself...
1079 "noise4" sound played when flag is dropped by a player...
1080 "noise5" sound played when flag touches the ground... */
1081 void spawnfunc_item_flag_team1()
1083 if(!g_ctf) { remove(self); return; }
1085 ctf_FlagSetup(1, self); // 1 = red
1088 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1089 CTF flag for team two (Blue).
1091 "angle" Angle the flag will point (minus 90 degrees)...
1092 "model" model to use, note this needs red and blue as skins 0 and 1...
1093 "noise" sound played when flag is picked up...
1094 "noise1" sound played when flag is returned by a teammate...
1095 "noise2" sound played when flag is captured...
1096 "noise3" sound played when flag is lost in the field and respawns itself...
1097 "noise4" sound played when flag is dropped by a player...
1098 "noise5" sound played when flag touches the ground... */
1099 void spawnfunc_item_flag_team2()
1101 if(!g_ctf) { remove(self); return; }
1103 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1106 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1107 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1108 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.
1110 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1111 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1112 void spawnfunc_ctf_team()
1114 if(!g_ctf) { remove(self); return; }
1116 self.classname = "ctf_team";
1117 self.team = self.cnt + 1;
1125 // code from here on is just to support maps that don't have flag and team entities
1126 void ctf_SpawnTeam (string teamname, float teamcolor)
1131 self.classname = "ctf_team";
1132 self.netname = teamname;
1133 self.cnt = teamcolor;
1135 spawnfunc_ctf_team();
1140 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1142 // if no teams are found, spawn defaults
1143 if(find(world, classname, "ctf_team") == world)
1145 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1146 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1147 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1153 void ctf_Initialize()
1155 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1157 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1158 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1159 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1161 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1165 MUTATOR_DEFINITION(gamemode_ctf)
1167 MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
1168 MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
1169 MUTATOR_HOOK(PlayerDies, ctf_RemovePlayer, CBC_ORDER_ANY);
1170 MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
1171 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1172 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1173 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1174 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1178 if(time > 1) // game loads at time 1
1179 error("This is a game type and it cannot be added at runtime.");
1187 error("This is a game type and it cannot be removed at runtime.");