// messages and sounds
sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM); // FIXCTF
ctf_EventLog("recieve", flag.team, player);
+
FOR_EACH_REALPLAYER(tmp_player)
+ {
if(tmp_player == sender)
centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
else if(tmp_player == player)
centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
else if(!IsDifferentTeam(tmp_player, sender))
centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
+ }
// create new waypoint
ctf_FlagcarrierWaypoints(player);
WaypointSprite_Kill(player.wps_flagcarrier);
if(player.wps_enemyflagcarrier)
- WaypointSprite_Kill(player.wps_enemyflagcarrier);
+ WaypointSprite_Kill(player.wps_enemyflagcarrier);
// captureshield
- //ctf_CaptureShield_Update(player, 0); // shield only
+ ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
}
{
// messages and sounds
//centerprint(player, strcat("You returned the ", flag.netname));
- Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
+ Send_KillNotification(player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
ctf_EventLog("return", flag.team, player);
if(flag.ctf_dropper)
{
- // punish the player who dropped the flag
- PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned"));
- ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield only
-
- // set next take time
- flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
+ PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -ctf_ReadScore("penalty_returned")); // punish the player who dropped the flag
+ ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
+ flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
}
// reset the flag
verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
FOR_EACH_REALPLAYER(tmp_player)
+ {
if(tmp_player == player)
centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
else if(!IsDifferentTeam(tmp_player, player))
centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
else if(!IsDifferentTeam(tmp_player, flag))
centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
-
+ }
+
switch(pickuptype)
{
case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
// Main Flag Functions
// ===================
-void ctf_CheckFlagReturn(entity flag)
+void ctf_CheckFlagReturn(entity flag, float returntype)
{
if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
{
- bprint("The ", flag.netname, " has returned to base\n");
+ switch(returntype)
+ {
+ case RETURN_DROPPED: bprint("The ", flag.netname, " was dropped in the base and returned itself\n"); break;
+ case RETURN_DAMAGE: bprint("The ", flag.netname, " was destroyed and returned to base\n"); break;
+ case RETURN_SPEEDRUN: bprint("The ", flag.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n"); break;
+ case RETURN_NEEDKILL: bprint("The ", flag.netname, " fell somewhere it couldn't be reached and returned to base\n"); break;
+
+ default:
+ case RETURN_TIMEOUT:
+ { bprint("The ", flag.netname, " has returned to base\n"); break; }
+ }
sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
ctf_EventLog("returned", flag.team, world);
ctf_RespawnFlag(flag);
}
}
+void ctf_CheckStalemate(void)
+{
+ // declarations
+ float stale_red_flags, stale_blue_flags;
+ entity tmp_entity;
+
+ // build list of stale flags
+ for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
+ {
+ if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
+ if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
+ {
+ tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
+ ctf_staleflaglist = tmp_entity;
+
+ switch(tmp_entity.team)
+ {
+ case COLOR_TEAM1: ++stale_red_flags; break;
+ case COLOR_TEAM2: ++stale_blue_flags; break;
+ }
+ }
+ }
+
+ // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
+ if(stale_red_flags && stale_blue_flags)
+ {
+ for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
+ {
+ if not(tmp_entity.owner.wps_enemyflagcarrier)
+ WaypointSprite_Spawn("enemyflagcarrier", 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, world, tmp_entity.team, tmp_entity.owner, wps_enemyflagcarrier, TRUE, RADARICON_FLAG, WPCOLOR_ENEMYFC(tmp_entity.owner.team));
+ }
+
+ if not(wpforenemy_announced)
+ {
+ FOR_EACH_REALPLAYER(tmp_entity)
+ if(tmp_entity.flagcarried)
+ centerprint(tmp_entity, "Stalemate! Enemies can now see you on radar!");
+ else
+ centerprint(tmp_entity, "Stalemate! Flag carriers can now be seen by enemies on radar!");
+
+ wpforenemy_announced = TRUE;
+ }
+ }
+}
+
void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
{
if(ITEM_DAMAGE_NEEDKILL(deathtype))
{
// automatically kill the flag and return it
self.health = 0;
- ctf_CheckFlagReturn(self);
+ ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
return;
}
-
if(autocvar_g_ctf_flag_return_damage)
{
// reduce health and check if it should be returned
self.health = self.health - damage;
- ctf_CheckFlagReturn(self);
+ ctf_CheckFlagReturn(self, RETURN_DAMAGE);
return;
}
}
tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
if(!trace_startsolid) // can we resize it without getting stuck?
setsize(self, FLAG_MIN, FLAG_MAX); }
+
+ switch(self.ctf_status) // reset flag angles in case warpzones adjust it
+ {
+ case FLAG_DROPPED:
+ case FLAG_PASSING:
+ {
+ self.angles = '0 0 0';
+ break;
+ }
+
+ default: break;
+ }
// main think method
switch(self.ctf_status)
case FLAG_DROPPED:
{
+ if(autocvar_g_ctf_flag_dropped_floatinwater && (self.flags & FL_INWATER))
+ self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater;
+
if(autocvar_g_ctf_flag_return_dropped)
{
if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
{
self.health = 0;
- ctf_CheckFlagReturn(self);
+ ctf_CheckFlagReturn(self, RETURN_DROPPED);
return;
}
}
if(autocvar_g_ctf_flag_return_time)
{
self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
- ctf_CheckFlagReturn(self);
+ ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
return;
}
return;
{
if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
{
- bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
- sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
- ctf_EventLog("returned", self.team, world);
- ctf_RespawnFlag(tmp_entity);
+ self.health = 0;
+ ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
tmp_entity = self;
self = self.owner;
ImpulseCommands();
self = tmp_entity;
}
-
- if(autocvar_g_ctf_flagcarrier_waypointforenemy_time)
- if((time >= self.ctf_pickuptime + autocvar_g_ctf_flagcarrier_waypointforenemy_time) && !self.owner.wps_enemyflagcarrier)
+ if(autocvar_g_ctf_flagcarrier_waypointforenemy_stalemate)
{
- 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));
-
- if(!self.wpforenemy_announced)
+ if(time >= wpforenemy_nextthink)
{
- FOR_EACH_REALPLAYER(tmp_entity)
- {
- if(tmp_entity == self.owner)
- centerprint(tmp_entity, strcat("Enemies can now see you on radar! (held ", self.netname, " for ", ftos(autocvar_g_ctf_flagcarrier_waypointforenemy_time), " seconds)"));
- else if(IsDifferentTeam(tmp_entity, self.owner))
- 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)"));
- else
- 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)"));
- }
-
- self.wpforenemy_announced = TRUE;
+ ctf_CheckStalemate();
+ wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
}
}
return;
case FLAG_PASSING: // todo make work with warpzones
{
vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
-
traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
if((self.pass_target.deadflag != DEAD_NO)
void ctf_FlagTouch()
{
if(gameover) { return; }
- if(!self) { return; }
- if(other.deadflag != DEAD_NO) { return; }
+
+ entity toucher = other;
+
+ // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
if(ITEM_TOUCH_NEEDKILL())
{
- // automatically kill the flag and return it
self.health = 0;
- ctf_CheckFlagReturn(self);
+ ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
return;
}
- if(other.classname != "player") // The flag just touched an object, most likely the world
+
+ // special touch behaviors
+ if(toucher.vehicle_flags & VHF_ISVEHICLE)
+ {
+ if(autocvar_g_ctf_allow_vehicle_touch)
+ toucher = toucher.owner; // the player is actually the vehicle owner, not other
+ else
+ return; // do nothing
+ }
+ else if(toucher.classname != "player") // The flag just touched an object, most likely the world
{
if(time > self.wait) // if we haven't in a while, play a sound/effect
{
}
return;
}
+ else if(toucher.deadflag != DEAD_NO) { return; }
switch(self.ctf_status)
{
case FLAG_BASE:
{
- if(!IsDifferentTeam(other, self) && (other.flagcarried) && IsDifferentTeam(other.flagcarried, self))
- ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
- else if(IsDifferentTeam(other, self) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
- ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
+ if(!IsDifferentTeam(toucher, self) && (toucher.flagcarried) && IsDifferentTeam(toucher.flagcarried, self))
+ ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
+ else if(IsDifferentTeam(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time))
+ ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
break;
}
case FLAG_DROPPED:
{
- if(!IsDifferentTeam(other, self))
- ctf_Handle_Return(self, other); // other just returned his own flag
- else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
- ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
+ if(!IsDifferentTeam(toucher, self))
+ ctf_Handle_Return(self, toucher); // toucher just returned his own flag
+ else if((!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
+ ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
break;
}
case FLAG_PASSING:
{
- if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
+ if((toucher.classname == "player") && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
{
- if(IsDifferentTeam(other, self.pass_sender))
- ctf_Handle_Return(self, other);
+ if(IsDifferentTeam(toucher, self.pass_sender))
+ ctf_Handle_Return(self, toucher);
else
- ctf_Handle_Retrieve(self, other);
+ ctf_Handle_Retrieve(self, toucher);
}
break;
}
-
- default: // this should never happen
- {
- dprint("Touch: Flag exists with no status?\n");
- break;
- }
}
}
flag.ctf_dropper = world;
flag.ctf_pickuptime = 0;
flag.ctf_droptime = 0;
- flag.wpforenemy_announced = FALSE;
+
+ wpforenemy_announced = FALSE;
}
void ctf_Reset()
flag.health = flag.max_flag_health;
flag.event_damage = ctf_FlagDamage;
flag.pushable = TRUE;
+ flag.teleportable = TELEPORT_NORMAL;
flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
flag.velocity = '0 0 0';
// scan through all the flags and notify the client about them
for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
{
- if(flag.ctf_status == FLAG_CARRY)
- if(flag.owner == self)
- self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
- else
- self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
- else if(flag.ctf_status == FLAG_DROPPED)
- self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
+ switch(flag.ctf_status)
+ {
+ case FLAG_CARRY:
+ {
+ if(flag.owner == self)
+ self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
+ else
+ self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
+ break;
+ }
+ case FLAG_DROPPED:
+ {
+ self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
+ break;
+ }
+ }
}
// item for stopping players from capturing the flag too often
frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
}
- else // damage done everyone else
+ else // damage done to everyone else
{
frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
}
}
+ else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && IsDifferentTeam(frag_target, frag_attacker)) // if the target is a flagcarrier
+ {
+ if(autocvar_g_ctf_flagcarrier_auto_helpme_when_damaged > frag_target.health)
+ WaypointSprite_HelpMePing(frag_target.wps_flagcarrier); // TODO: only do this if there is a significant loss of health?
+ }
return 0;
}
{
entity player = self;
- if((time > player.throw_antispam) && !player.speedrunning && !player.vehicle)
+ if((time > player.throw_antispam) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
{
// pass the flag to a team mate
if(autocvar_g_ctf_pass)
{
if(head.classname == "player" && head.deadflag == DEAD_NO)
if(head != player && !IsDifferentTeam(head, player))
- if(!head.speedrunning && !head.vehicle)
+ if(!head.speedrunning && (!head.vehicle || autocvar_g_ctf_allow_vehicle_touch))
{
traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
if not((trace_fraction < 1) && (trace_ent != head))
{
entity flag; // temporary entity for the search method
- if(gameover) // is this necessary?
+ for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
{
- for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
+ switch(flag.ctf_status)
{
- switch(flag.ctf_status)
+ case FLAG_DROPPED:
+ case FLAG_PASSING:
{
- case FLAG_DROPPED:
- case FLAG_PASSING:
- {
- // lock the flag, game is over
- flag.movetype = MOVETYPE_NONE;
- flag.takedamage = DAMAGE_NO;
- flag.solid = SOLID_NOT;
- flag.nextthink = 0; // stop thinking
-
- print("stopping the ", flag.netname, " from moving.\n");
- break;
- }
+ // lock the flag, game is over
+ flag.movetype = MOVETYPE_NONE;
+ flag.takedamage = DAMAGE_NO;
+ flag.solid = SOLID_NOT;
+ flag.nextthink = 0; // stop thinking
- default:
- case FLAG_BASE:
- case FLAG_CARRY:
- {
- // do nothing for these flags
- break;
- }
+ print("stopping the ", flag.netname, " from moving.\n");
+ break;
+ }
+
+ default:
+ case FLAG_BASE:
+ case FLAG_CARRY:
+ {
+ // do nothing for these flags
+ break;
}
}
}