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, '0 0 64', world, player.team, player, wps_flagcarrier, FALSE, RADARICON_FLAG, '1 1 0');
66 WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
67 WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
68 WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, '1 1 0');
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;
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 not(other.ctf_captureshielded) { return FALSE; }
126 if(self.team == other.team) { return FALSE; }
131 void ctf_CaptureShield_Touch()
133 if not(other.ctf_captureshielded) { return; }
134 if(self.team == other.team) { 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, '0 0 64', world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, FALSE, RADARICON_FLAG, '0 0.5 0' + ((flag.team == COLOR_TEAM1) ? '0.75 0 0' : '0 0 0.75')); // (COLOR_TEAM1 + COLOR_TEAM2 - flag.team)
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(tmp_player.team == sender.team)
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_throw_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_throw_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);
336 //ctf_CaptureShield_Update(player, 0); // shield only
344 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
346 entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
347 entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
349 if not(player) { return; } // without someone to give the reward to, we can't possibly cap
351 // messages and sounds
352 Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
353 sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
357 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
358 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
363 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
364 PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
367 if(autocvar_g_ctf_flag_capture_effects)
369 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
370 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
374 if(capturetype == CAPTURE_NORMAL)
376 WaypointSprite_Kill(player.wps_flagcarrier);
377 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
381 player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
382 ctf_RespawnFlag(enemy_flag);
385 void ctf_Handle_Return(entity flag, entity player)
387 // messages and sounds
388 //centerprint(player, strcat("You returned the ", flag.netname));
389 Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
390 sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
391 ctf_EventLog("return", flag.team, player);
394 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
395 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
397 TeamScore_AddToTeam(((flag.team == COLOR_TEAM1) ? COLOR_TEAM2 : COLOR_TEAM1), ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
398 FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
400 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
401 ctf_CaptureShield_Update(player, 0); // shield only
405 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
406 ctf_RespawnFlag(flag);
409 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
412 entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
413 string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
414 float pickup_dropped_score; // used to calculate dropped pickup score
416 // attach the flag to the player
418 player.flagcarried = flag;
419 setattachment(flag, player, "");
420 setorigin(flag, FLAG_CARRY_OFFSET);
423 flag.movetype = MOVETYPE_NONE;
424 flag.takedamage = DAMAGE_NO;
425 flag.solid = SOLID_NOT;
426 flag.angles = '0 0 0';
427 flag.ctf_carrier = player;
428 flag.ctf_status = FLAG_CARRY;
432 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
433 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
437 // messages and sounds
438 Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
439 sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
440 verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
442 FOR_EACH_PLAYER(tmp_player)
443 if(tmp_player == player)
444 centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
445 else if(tmp_player.team == player.team)
446 centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
447 else if(tmp_player.team == flag.team)
448 centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
452 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
453 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
458 PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
463 PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
469 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);
470 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);
471 print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
472 PlayerTeamScore_AddScore(player, pickup_dropped_score);
480 if(pickuptype == PICKUP_BASE)
482 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
483 if((player.speedrunning) && (ctf_captimerecord))
484 ctf_FakeTimeLimit(player, time + ctf_captimerecord);
488 if(autocvar_g_ctf_flag_pickup_effects)
489 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
492 if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
493 ctf_FlagcarrierWaypoints(player);
494 WaypointSprite_Ping(player.wps_flagcarrier);
498 // ===================
499 // Main Flag Functions
500 // ===================
502 void ctf_CheckFlagReturn(entity flag)
504 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
506 if((flag.health <= 0) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
508 bprint("The ", flag.netname, " has returned to base\n");
509 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
510 ctf_EventLog("returned", flag.team, world);
511 ctf_RespawnFlag(flag);
515 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
517 if(ITEM_DAMAGE_NEEDKILL(deathtype))
519 // automatically kill the flag and return it
521 ctf_CheckFlagReturn(self);
525 if(autocvar_g_ctf_flag_return_damage)
527 self.health = self.health - damage;
528 ctf_CheckFlagReturn(self);
538 self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
541 if(self == ctf_worldflaglist) // only for the first flag
542 FOR_EACH_CLIENT(tmp_entity)
543 ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
546 if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
547 dprint("wtf the flag got squashed?\n");
548 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
549 if(!trace_startsolid) // can we resize it without getting stuck?
550 setsize(self, FLAG_MIN, FLAG_MAX); }
553 switch(self.ctf_status)
557 if(autocvar_g_ctf_dropped_capture_radius)
559 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
560 if(tmp_entity.ctf_status == FLAG_DROPPED)
561 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
562 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
569 if(autocvar_g_ctf_flag_return_dropped)
571 if((vlen(self.origin - self.ctf_spawnorigin) < autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
574 ctf_CheckFlagReturn(self);
578 if(autocvar_g_ctf_flag_return_time)
580 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
581 ctf_CheckFlagReturn(self);
589 if((self.owner) && (self.speedrunning) && (ctf_captimerecord) && (time >= self.ctf_pickuptime + ctf_captimerecord))
591 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
592 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
593 ctf_EventLog("returned", self.team, world);
594 ctf_RespawnFlag(tmp_entity);
598 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
605 case FLAG_PASSING: // todo make work with warpzones
607 vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
609 traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
611 if((self.pass_target.deadflag != DEAD_NO)
612 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
613 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
614 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
616 ctf_Handle_Drop(self, world, DROP_PASS);
618 else // still a viable target, go for it
620 vector desired_direction = normalize(targ_origin - self.origin);
621 vector current_direction = normalize(self.velocity);
623 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_throw_velocity);
628 default: // this should never happen
630 dprint("ctf_FlagThink(): Flag exists with no status?\n");
638 if(gameover) { return; }
639 if(!self) { return; }
640 if(other.deadflag != DEAD_NO) { return; }
641 if(ITEM_TOUCH_NEEDKILL())
643 // automatically kill the flag and return it
645 ctf_CheckFlagReturn(self);
648 if(other.classname != "player") // The flag just touched an object, most likely the world
650 if(time > self.wait) // if we haven't in a while, play a sound/effect
652 pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
653 sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
654 self.wait = time + FLAG_TOUCHRATE;
659 switch(self.ctf_status)
663 if((other.team == self.team) && (other.flagcarried) && (other.flagcarried.team != self.team))
664 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
665 else if((other.team != self.team) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
666 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
672 if(other.team == self.team)
673 ctf_Handle_Return(self, other); // other just returned his own flag
674 else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
675 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
681 dprint("Someone touched a flag even though it was being carried?\n");
687 if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
689 if(IsDifferentTeam(other, self.pass_sender))
690 ctf_Handle_Return(self, other);
692 ctf_Handle_Retrieve(self, other);
697 default: // this should never happen
699 dprint("Touch: Flag exists with no status?\n");
705 void ctf_RespawnFlag(entity flag)
707 // reset the player (if there is one)
708 if((flag.owner) && (flag.owner.flagcarried == flag))
710 WaypointSprite_Kill(flag.wps_flagcarrier);
711 flag.owner.flagcarried = world;
713 if(flag.speedrunning)
714 ctf_FakeTimeLimit(flag.owner, -1);
717 if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
718 { WaypointSprite_Kill(flag.wps_flagdropped); }
721 setattachment(flag, world, "");
722 setorigin(flag, flag.ctf_spawnorigin);
724 flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
725 flag.takedamage = DAMAGE_NO;
726 flag.health = flag.max_flag_health;
727 flag.solid = SOLID_TRIGGER;
728 flag.velocity = '0 0 0';
729 flag.angles = flag.mangle;
730 flag.flags = FL_ITEM | FL_NOTARGET;
732 flag.ctf_status = FLAG_BASE;
734 flag.pass_sender = world;
735 flag.pass_target = world;
736 flag.ctf_carrier = world;
737 flag.ctf_dropper = world;
738 flag.ctf_pickuptime = 0;
739 flag.ctf_droptime = 0;
745 if(self.owner.classname == "player")
746 ctf_Handle_Throw(self.owner, world, DROP_RESET);
748 ctf_RespawnFlag(self);
751 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
754 float teamnumber = ((self.team == COLOR_TEAM1) ? TRUE : FALSE); // if we were originally 1, this will become 0. If we were originally 0, this will become 1.
757 waypoint_spawnforitem_force(self, self.origin);
758 self.nearestwaypointtimeout = 0; // activate waypointing again
759 self.bot_basewaypoint = self.nearestwaypoint;
762 WaypointSprite_SpawnFixed(((teamnumber) ? "redbase" : "bluebase"), self.origin + '0 0 64', self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
763 WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
765 // captureshield setup
766 ctf_CaptureShield_Spawn(self);
769 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
772 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.
773 self = flag; // for later usage with droptofloor()
776 flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
777 ctf_worldflaglist = flag;
779 setattachment(flag, world, "");
781 flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
782 flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
783 flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
784 flag.classname = "item_flag_team";
785 flag.target = "###item###"; // wut?
786 flag.flags = FL_ITEM | FL_NOTARGET;
787 flag.solid = SOLID_TRIGGER;
788 flag.takedamage = DAMAGE_NO;
789 flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
790 flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
791 flag.health = flag.max_flag_health;
792 flag.event_damage = ctf_FlagDamage;
793 flag.pushable = TRUE;
794 flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
795 flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
796 flag.velocity = '0 0 0';
797 flag.mangle = flag.angles;
798 flag.reset = ctf_Reset;
799 flag.touch = ctf_FlagTouch;
800 flag.think = ctf_FlagThink;
801 flag.nextthink = time + FLAG_THINKRATE;
802 flag.ctf_status = FLAG_BASE;
804 if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
805 if(!flag.scale) { flag.scale = FLAG_SCALE; }
806 if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
809 if(!flag.snd_flag_taken) { flag.snd_flag_taken = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
810 if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
811 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
812 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.
813 if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
814 if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
817 precache_sound(flag.snd_flag_taken);
818 precache_sound(flag.snd_flag_returned);
819 precache_sound(flag.snd_flag_capture);
820 precache_sound(flag.snd_flag_respawn);
821 precache_sound(flag.snd_flag_dropped);
822 precache_sound(flag.snd_flag_touch);
823 precache_model(flag.model);
824 precache_model("models/ctf/shield.md3");
825 precache_model("models/ctf/shockwavetransring.md3");
828 setmodel(flag, flag.model); // precision set below
829 setsize(flag, FLAG_MIN, FLAG_MAX);
830 setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
832 if(autocvar_g_ctf_flag_glowtrails)
834 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
839 flag.effects |= EF_LOWPRECISION;
840 if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
841 if(autocvar_g_ctf_dynamiclights) { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
844 if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
846 flag.dropped_origin = flag.origin;
848 flag.movetype = MOVETYPE_NONE;
850 else // drop to floor, automatically find a platform and set that as spawn origin
852 flag.noalign = FALSE;
855 flag.movetype = MOVETYPE_TOSS;
858 InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
866 MUTATOR_HOOKFUNCTION(ctf_HookedDrop)
868 if(self.flagcarried) { ctf_Handle_Throw(self, world, DROP_NORMAL); }
872 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
876 // initially clear items so they can be set as necessary later.
877 self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
878 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
880 // scan through all the flags and notify the client about them
881 for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
883 if(flag.ctf_status == FLAG_CARRY)
884 if(flag.owner == self)
885 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
887 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
888 else if(flag.ctf_status == FLAG_DROPPED)
889 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
892 // item for stopping players from capturing the flag too often
893 if(self.ctf_captureshielded)
894 self.items |= IT_CTF_SHIELDED;
896 // update the health of the flag carrier waypointsprite
897 if(self.wps_flagcarrier)
898 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
903 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
905 if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
907 if(frag_target == frag_attacker) // damage done to yourself
909 frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
910 frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
912 else // damage done everyone else
914 frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
915 frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
921 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
924 return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
927 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
929 entity player = self;
931 if(time > player.throw_antispam)
933 // pass the flag to a team mate
934 if(autocvar_g_ctf_allow_pass)
936 entity head, closest_target;
937 head = findradius(player.origin, autocvar_g_ctf_pass_radius);
939 while(head) // find the closest acceptable target to pass to
941 if(head.classname == "player" && head.deadflag == DEAD_NO)
942 if(head != player && !IsDifferentTeam(head, player))
943 if(!player.speedrunning && !head.speedrunning)
945 traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
946 if not((trace_fraction < 1) && (trace_ent != head))
948 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
950 if(clienttype(head) == CLIENTTYPE_BOT)
952 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
953 ctf_Handle_Throw(head, player, DROP_PASS);
957 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
958 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
960 player.throw_antispam = time + autocvar_g_ctf_pass_wait;
963 else if(player.flagcarried)
965 if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
966 else { closest_target = head; }
973 if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
976 // throw the flag in front of you
977 if(autocvar_g_ctf_allow_drop && player.flagcarried && !player.speedrunning)
978 { ctf_Handle_Throw(player, world, DROP_THROW); }
988 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
989 CTF Starting point for a player in team one (Red).
990 Keys: "angle" viewing angle when spawning. */
991 void spawnfunc_info_player_team1()
993 if(g_assault) { remove(self); return; }
995 self.team = COLOR_TEAM1; // red
996 spawnfunc_info_player_deathmatch();
1000 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
1001 CTF Starting point for a player in team two (Blue).
1002 Keys: "angle" viewing angle when spawning. */
1003 void spawnfunc_info_player_team2()
1005 if(g_assault) { remove(self); return; }
1007 self.team = COLOR_TEAM2; // blue
1008 spawnfunc_info_player_deathmatch();
1011 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1012 CTF Starting point for a player in team three (Yellow).
1013 Keys: "angle" viewing angle when spawning. */
1014 void spawnfunc_info_player_team3()
1016 if(g_assault) { remove(self); return; }
1018 self.team = COLOR_TEAM3; // yellow
1019 spawnfunc_info_player_deathmatch();
1023 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1024 CTF Starting point for a player in team four (Purple).
1025 Keys: "angle" viewing angle when spawning. */
1026 void spawnfunc_info_player_team4()
1028 if(g_assault) { remove(self); return; }
1030 self.team = COLOR_TEAM4; // purple
1031 spawnfunc_info_player_deathmatch();
1034 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1035 CTF flag for team one (Red).
1037 "angle" Angle the flag will point (minus 90 degrees)...
1038 "model" model to use, note this needs red and blue as skins 0 and 1...
1039 "noise" sound played when flag is picked up...
1040 "noise1" sound played when flag is returned by a teammate...
1041 "noise2" sound played when flag is captured...
1042 "noise3" sound played when flag is lost in the field and respawns itself...
1043 "noise4" sound played when flag is dropped by a player...
1044 "noise5" sound played when flag touches the ground... */
1045 void spawnfunc_item_flag_team1()
1047 if(!g_ctf) { remove(self); return; }
1049 ctf_FlagSetup(1, self); // 1 = red
1052 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1053 CTF flag for team two (Blue).
1055 "angle" Angle the flag will point (minus 90 degrees)...
1056 "model" model to use, note this needs red and blue as skins 0 and 1...
1057 "noise" sound played when flag is picked up...
1058 "noise1" sound played when flag is returned by a teammate...
1059 "noise2" sound played when flag is captured...
1060 "noise3" sound played when flag is lost in the field and respawns itself...
1061 "noise4" sound played when flag is dropped by a player...
1062 "noise5" sound played when flag touches the ground... */
1063 void spawnfunc_item_flag_team2()
1065 if(!g_ctf) { remove(self); return; }
1067 ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1070 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1071 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1072 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.
1074 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1075 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1076 void spawnfunc_ctf_team()
1078 if(!g_ctf) { remove(self); return; }
1080 self.classname = "ctf_team";
1081 self.team = self.cnt + 1;
1089 // code from here on is just to support maps that don't have flag and team entities
1090 void ctf_SpawnTeam (string teamname, float teamcolor)
1095 self.classname = "ctf_team";
1096 self.netname = teamname;
1097 self.cnt = teamcolor;
1099 spawnfunc_ctf_team();
1104 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1106 // if no teams are found, spawn defaults
1107 if(find(world, classname, "ctf_team") == world)
1109 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1110 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1111 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1117 void ctf_Initialize()
1119 ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1121 ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1122 ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1123 ctf_captureshield_force = autocvar_g_ctf_shield_force;
1125 InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1129 MUTATOR_DEFINITION(gamemode_ctf)
1131 MUTATOR_HOOK(MakePlayerObserver, ctf_HookedDrop, CBC_ORDER_ANY);
1132 MUTATOR_HOOK(ClientDisconnect, ctf_HookedDrop, CBC_ORDER_ANY);
1133 MUTATOR_HOOK(PlayerDies, ctf_HookedDrop, CBC_ORDER_ANY);
1134 MUTATOR_HOOK(PortalTeleport, ctf_HookedDrop, CBC_ORDER_ANY);
1135 MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1136 MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1137 MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1138 MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1142 if(time > 1) // game loads at time 1
1143 error("This is a game type and it cannot be added at runtime.");
1151 error("This is a game type and it cannot be removed at runtime.");