qcsrc/server/mutators/gamemode_ctf.qc

   1 #include "gamemode_ctf.qh"
   2 #include "../_all.qh"
   3
   4 #include "gamemode.qh"
   5
   6 #ifdef SVQC
   7 #include "../../common/vehicles/all.qh"
   8 #endif
   9
  10 #include "../../warpzonelib/common.qh"
  11
  12 void ctf_FakeTimeLimit(entity e, float t)
  13 {
  14         msg_entity = e;
  15         WriteByte(MSG_ONE, 3); // svc_updatestat
  16         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
  17         if(t < 0)
  18                 WriteCoord(MSG_ONE, autocvar_timelimit);
  19         else
  20                 WriteCoord(MSG_ONE, (t + 1) / 60);
  21 }
  22
  23 void ctf_EventLog(string mode, int flagteam, entity actor) // use an alias for easy changing and quick editing later
  24 {
  25         if(autocvar_sv_eventlog)
  26                 GameLogEcho(sprintf(":ctf:%s:%d:%d:%s", mode, flagteam, actor.team, ((actor != world) ? ftos(actor.playerid) : "")));
  27                 //GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
  28 }
  29
  30 void ctf_CaptureRecord(entity flag, entity player)
  31 {
  32         float cap_record = ctf_captimerecord;
  33         float cap_time = (time - flag.ctf_pickuptime);
  34         string refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
  35
  36         // notify about shit
  37         if(ctf_oneflag) { Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_CTF_CAPTURE_NEUTRAL, player.netname); }
  38         else if(!ctf_captimerecord) { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT_4(flag, CHOICE_CTF_CAPTURE_TIME_), player.netname, (cap_time * 100)); }
  39         else if(cap_time < cap_record) { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT_4(flag, CHOICE_CTF_CAPTURE_BROKEN_), player.netname, refername, (cap_time * 100), (cap_record * 100)); }
  40         else { Send_Notification(NOTIF_ALL, world, MSG_CHOICE, APP_TEAM_ENT_4(flag, CHOICE_CTF_CAPTURE_UNBROKEN_), player.netname, refername, (cap_time * 100), (cap_record * 100)); }
  41
  42         // write that shit in the database
  43         if(!ctf_oneflag) // but not in 1-flag mode
  44         if((!ctf_captimerecord) || (cap_time < cap_record))
  45         {
  46                 ctf_captimerecord = cap_time;
  47                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
  48                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
  49                 write_recordmarker(player, (time - cap_time), cap_time);
  50         }
  51 }
  52
  53 void ctf_FlagcarrierWaypoints(entity player)
  54 {
  55         WaypointSprite_Spawn(WP_FlagCarrier, 0, 0, player, FLAG_WAYPOINT_OFFSET, world, player.team, player, wps_flagcarrier, true, RADARICON_FLAG);
  56         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON) * 2);
  57         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON));
  58         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, WPCOLOR_FLAGCARRIER(player.team));
  59 }
  60
  61 void ctf_CalculatePassVelocity(entity flag, vector to, vector from, float turnrate)
  62 {
  63         float current_distance = vlen((('1 0 0' * to.x) + ('0 1 0' * to.y)) - (('1 0 0' * from.x) + ('0 1 0' * from.y))); // for the sake of this check, exclude Z axis
  64         float initial_height = min(autocvar_g_ctf_pass_arc_max, (flag.pass_distance * tanh(autocvar_g_ctf_pass_arc)));
  65         float current_height = (initial_height * min(1, (current_distance / flag.pass_distance)));
  66         //print("current_height = ", ftos(current_height), ", initial_height = ", ftos(initial_height), ".\n");
  67
  68         vector targpos;
  69         if(current_height) // make sure we can actually do this arcing path
  70         {
  71                 targpos = (to + ('0 0 1' * current_height));
  72                 WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
  73                 if(trace_fraction < 1)
  74                 {
  75                         //print("normal arc line failed, trying to find new pos...");
  76                         WarpZone_TraceLine(to, targpos, MOVE_NOMONSTERS, flag);
  77                         targpos = (trace_endpos + FLAG_PASS_ARC_OFFSET);
  78                         WarpZone_TraceLine(flag.origin, targpos, MOVE_NOMONSTERS, flag);
  79                         if(trace_fraction < 1) { targpos = to; /* print(" ^1FAILURE^7, reverting to original direction.\n"); */ }
  80                         /*else { print(" ^3SUCCESS^7, using new arc line.\n"); } */
  81                 }
  82         }
  83         else { targpos = to; }
  84
  85         //flag.angles = normalize(('0 1 0' * to_y) - ('0 1 0' * from_y));
  86
  87         vector desired_direction = normalize(targpos - from);
  88         if(turnrate) { flag.velocity = (normalize(normalize(flag.velocity) + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_pass_velocity); }
  89         else { flag.velocity = (desired_direction * autocvar_g_ctf_pass_velocity); }
  90 }
  91
  92 bool ctf_CheckPassDirection(vector head_center, vector passer_center, vector passer_angle, vector nearest_to_passer)
  93 {
  94         if(autocvar_g_ctf_pass_directional_max || autocvar_g_ctf_pass_directional_min)
  95         {
  96                 // directional tracing only
  97                 float spreadlimit;
  98                 makevectors(passer_angle);
  99
 100                 // find the closest point on the enemy to the center of the attack
 101                 float h; // hypotenuse, which is the distance between attacker to head
 102                 float a; // adjacent side, which is the distance between attacker and the point on w_shotdir that is closest to head.origin
 103
 104                 h = vlen(head_center - passer_center);
 105                 a = h * (normalize(head_center - passer_center) * v_forward);
 106
 107                 vector nearest_on_line = (passer_center + a * v_forward);
 108                 float distance_from_line = vlen(nearest_to_passer - nearest_on_line);
 109
 110                 spreadlimit = (autocvar_g_ctf_pass_radius ? min(1, (vlen(passer_center - nearest_on_line) / autocvar_g_ctf_pass_radius)) : 1);
 111                 spreadlimit = (autocvar_g_ctf_pass_directional_min * (1 - spreadlimit) + autocvar_g_ctf_pass_directional_max * spreadlimit);
 112
 113                 if(spreadlimit && (distance_from_line <= spreadlimit) && ((vlen(normalize(head_center - passer_center) - v_forward) * RAD2DEG) <= 90))
 114                         { return true; }
 115                 else
 116                         { return false; }
 117         }
 118         else { return true; }
 119 }
 120
 121
 122 // =======================
 123 // CaptureShield Functions
 124 // =======================
 125
 126 bool ctf_CaptureShield_CheckStatus(entity p)
 127 {
 128         int s, s2, s3, s4, se, se2, se3, se4, sr, ser;
 129         entity e;
 130         int players_worseeq, players_total;
 131
 132         if(ctf_captureshield_max_ratio <= 0)
 133                 return false;
 134
 135         s = PlayerScore_Add(p, SP_CTF_CAPS, 0);
 136         s2 = PlayerScore_Add(p, SP_CTF_PICKUPS, 0);
 137         s3 = PlayerScore_Add(p, SP_CTF_RETURNS, 0);
 138         s4 = PlayerScore_Add(p, SP_CTF_FCKILLS, 0);
 139
 140         sr = ((s - s2) + (s3 + s4));
 141
 142         if(sr >= -ctf_captureshield_min_negscore)
 143                 return false;
 144
 145         players_total = players_worseeq = 0;
 146         FOR_EACH_PLAYER(e)
 147         {
 148                 if(DIFF_TEAM(e, p))
 149                         continue;
 150                 se = PlayerScore_Add(e, SP_CTF_CAPS, 0);
 151                 se2 = PlayerScore_Add(e, SP_CTF_PICKUPS, 0);
 152                 se3 = PlayerScore_Add(e, SP_CTF_RETURNS, 0);
 153                 se4 = PlayerScore_Add(e, SP_CTF_FCKILLS, 0);
 154
 155                 ser = ((se - se2) + (se3 + se4));
 156
 157                 if(ser <= sr)
 158                         ++players_worseeq;
 159                 ++players_total;
 160         }
 161
 162         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
 163         // use this rule here
 164
 165         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
 166                 return false;
 167
 168         return true;
 169 }
 170
 171 void ctf_CaptureShield_Update(entity player, bool wanted_status)
 172 {
 173         bool updated_status = ctf_CaptureShield_CheckStatus(player);
 174         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
 175         {
 176                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((updated_status) ? CENTER_CTF_CAPTURESHIELD_SHIELDED : CENTER_CTF_CAPTURESHIELD_FREE));
 177                 player.ctf_captureshielded = updated_status;
 178         }
 179 }
 180
 181 bool ctf_CaptureShield_Customize()
 182 {
 183         if(!other.ctf_captureshielded) { return false; }
 184         if(CTF_SAMETEAM(self, other)) { return false; }
 185
 186         return true;
 187 }
 188
 189 void ctf_CaptureShield_Touch()
 190 {
 191         if(!other.ctf_captureshielded) { return; }
 192         if(CTF_SAMETEAM(self, other)) { return; }
 193
 194         vector mymid = (self.absmin + self.absmax) * 0.5;
 195         vector othermid = (other.absmin + other.absmax) * 0.5;
 196
 197         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
 198         if(IS_REAL_CLIENT(other)) { Send_Notification(NOTIF_ONE, other, MSG_CENTER, CENTER_CTF_CAPTURESHIELD_SHIELDED); }
 199 }
 200
 201 void ctf_CaptureShield_Spawn(entity flag)
 202 {
 203         entity shield = spawn();
 204
 205         shield.enemy = self;
 206         shield.team = self.team;
 207         shield.touch = ctf_CaptureShield_Touch;
 208         shield.customizeentityforclient = ctf_CaptureShield_Customize;
 209         shield.classname = "ctf_captureshield";
 210         shield.effects = EF_ADDITIVE;
 211         shield.movetype = MOVETYPE_NOCLIP;
 212         shield.solid = SOLID_TRIGGER;
 213         shield.avelocity = '7 0 11';
 214         shield.scale = 0.5;
 215
 216         setorigin(shield, self.origin);
 217         setmodel(shield, "models/ctf/shield.md3");
 218         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 219 }
 220
 221
 222 // ====================
 223 // Drop/Pass/Throw Code
 224 // ====================
 225
 226 void ctf_Handle_Drop(entity flag, entity player, int droptype)
 227 {
 228         // declarations
 229         player = (player ? player : flag.pass_sender);
 230
 231         // main
 232         flag.movetype = MOVETYPE_TOSS;
 233         flag.takedamage = DAMAGE_YES;
 234         flag.angles = '0 0 0';
 235         flag.health = flag.max_flag_health;
 236         flag.ctf_droptime = time;
 237         flag.ctf_dropper = player;
 238         flag.ctf_status = FLAG_DROPPED;
 239
 240         // messages and sounds
 241         Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_LOST_) : INFO_CTF_LOST_NEUTRAL), player.netname);
 242         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTEN_NONE);
 243         ctf_EventLog("dropped", player.team, player);
 244
 245         // scoring
 246         PlayerTeamScore_AddScore(player, -autocvar_g_ctf_score_penalty_drop);
 247         PlayerScore_Add(player, SP_CTF_DROPS, 1);
 248
 249         // waypoints
 250         if(autocvar_g_ctf_flag_dropped_waypoint) {
 251                 entity wp = WaypointSprite_Spawn(WP_FlagDropped, 0, 0, flag, FLAG_WAYPOINT_OFFSET, world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, true, RADARICON_FLAG);
 252                 wp.colormod = WPCOLOR_DROPPEDFLAG(flag.team);
 253         }
 254
 255         if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
 256         {
 257                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
 258                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
 259         }
 260
 261         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
 262
 263         if(droptype == DROP_PASS)
 264         {
 265                 flag.pass_distance = 0;
 266                 flag.pass_sender = world;
 267                 flag.pass_target = world;
 268         }
 269 }
 270
 271 void ctf_Handle_Retrieve(entity flag, entity player)
 272 {
 273         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 274         entity sender = flag.pass_sender;
 275
 276         // transfer flag to player
 277         flag.owner = player;
 278         flag.owner.flagcarried = flag;
 279
 280         // reset flag
 281         if(player.vehicle)
 282         {
 283                 setattachment(flag, player.vehicle, "");
 284                 setorigin(flag, VEHICLE_FLAG_OFFSET);
 285                 flag.scale = VEHICLE_FLAG_SCALE;
 286         }
 287         else
 288         {
 289                 setattachment(flag, player, "");
 290                 setorigin(flag, FLAG_CARRY_OFFSET);
 291         }
 292         flag.movetype = MOVETYPE_NONE;
 293         flag.takedamage = DAMAGE_NO;
 294         flag.solid = SOLID_NOT;
 295         flag.angles = '0 0 0';
 296         flag.ctf_status = FLAG_CARRY;
 297
 298         // messages and sounds
 299         sound(player, CH_TRIGGER, flag.snd_flag_pass, VOL_BASE, ATTEN_NORM);
 300         ctf_EventLog("receive", flag.team, player);
 301
 302         FOR_EACH_REALPLAYER(tmp_player)
 303         {
 304                 if(tmp_player == sender)
 305                         Send_Notification(NOTIF_ONE, tmp_player, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT_4(flag, CENTER_CTF_PASS_SENT_) : CENTER_CTF_PASS_SENT_NEUTRAL), player.netname);
 306                 else if(tmp_player == player)
 307                         Send_Notification(NOTIF_ONE, tmp_player, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT_4(flag, CENTER_CTF_PASS_RECEIVED_) : CENTER_CTF_PASS_RECEIVED_NEUTRAL), sender.netname);
 308                 else if(SAME_TEAM(tmp_player, sender))
 309                         Send_Notification(NOTIF_ONE, tmp_player, MSG_CENTER, ((flag.team) ? APP_TEAM_ENT_4(flag, CENTER_CTF_PASS_OTHER_) : CENTER_CTF_PASS_OTHER_NEUTRAL), sender.netname, player.netname);
 310         }
 311
 312         // create new waypoint
 313         ctf_FlagcarrierWaypoints(player);
 314
 315         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
 316         player.throw_antispam = sender.throw_antispam;
 317
 318         flag.pass_distance = 0;
 319         flag.pass_sender = world;
 320         flag.pass_target = world;
 321 }
 322
 323 void ctf_Handle_Throw(entity player, entity receiver, int droptype)
 324 {
 325         entity flag = player.flagcarried;
 326         vector targ_origin, flag_velocity;
 327
 328         if(!flag) { return; }
 329         if((droptype == DROP_PASS) && !receiver) { return; }
 330
 331         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
 332
 333         // reset the flag
 334         setattachment(flag, world, "");
 335         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
 336         flag.owner.flagcarried = world;
 337         flag.owner = world;
 338         flag.solid = SOLID_TRIGGER;
 339         flag.ctf_dropper = player;
 340         flag.ctf_droptime = time;
 341
 342         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
 343
 344         switch(droptype)
 345         {
 346                 case DROP_PASS:
 347                 {
 348                         // warpzone support:
 349                         // for the examples, we assume player -> wz1 -> ... -> wzn -> receiver
 350                         // findradius has already put wzn ... wz1 into receiver's warpzone parameters!
 351                         WarpZone_RefSys_Copy(flag, receiver);
 352                         WarpZone_RefSys_AddInverse(flag, receiver); // wz1^-1 ... wzn^-1 receiver
 353                         targ_origin = WarpZone_RefSys_TransformOrigin(receiver, flag, (0.5 * (receiver.absmin + receiver.absmax))); // this is target origin as seen by the flag
 354
 355                         flag.pass_distance = vlen((('1 0 0' * targ_origin.x) + ('0 1 0' * targ_origin.y)) - (('1 0 0' *  player.origin.x) + ('0 1 0' *  player.origin.y))); // for the sake of this check, exclude Z axis
 356                         ctf_CalculatePassVelocity(flag, targ_origin, player.origin, false);
 357
 358                         // main
 359                         flag.movetype = MOVETYPE_FLY;
 360                         flag.takedamage = DAMAGE_NO;
 361                         flag.pass_sender = player;
 362                         flag.pass_target = receiver;
 363                         flag.ctf_status = FLAG_PASSING;
 364
 365                         // other
 366                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTEN_NORM);
 367                         WarpZone_TrailParticles(world, _particleeffectnum(flag.passeffect), player.origin, targ_origin);
 368                         ctf_EventLog("pass", flag.team, player);
 369                         break;
 370                 }
 371
 372                 case DROP_THROW:
 373                 {
 374                         makevectors((player.v_angle.y * '0 1 0') + (bound(autocvar_g_ctf_throw_angle_min, player.v_angle.x, autocvar_g_ctf_throw_angle_max) * '1 0 0'));
 375
 376                         flag_velocity = (('0 0 1' * autocvar_g_ctf_throw_velocity_up) + ((v_forward * autocvar_g_ctf_throw_velocity_forward) * ((player.items & ITEM_Strength.m_itemid) ? autocvar_g_ctf_throw_strengthmultiplier : 1)));
 377                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, flag_velocity, false);
 378                         ctf_Handle_Drop(flag, player, droptype);
 379                         break;
 380                 }
 381
 382                 case DROP_RESET:
 383                 {
 384                         flag.velocity = '0 0 0'; // do nothing
 385                         break;
 386                 }
 387
 388                 default:
 389                 case DROP_NORMAL:
 390                 {
 391                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, (('0 0 1' * autocvar_g_ctf_drop_velocity_up) + ((('0 1 0' * crandom()) + ('1 0 0' * crandom())) * autocvar_g_ctf_drop_velocity_side)), false);
 392                         ctf_Handle_Drop(flag, player, droptype);
 393                         break;
 394                 }
 395         }
 396
 397         // kill old waypointsprite
 398         WaypointSprite_Ping(player.wps_flagcarrier);
 399         WaypointSprite_Kill(player.wps_flagcarrier);
 400
 401         if(player.wps_enemyflagcarrier)
 402                 WaypointSprite_Kill(player.wps_enemyflagcarrier);
 403
 404         // captureshield
 405         ctf_CaptureShield_Update(player, 0); // shield player from picking up flag
 406 }
 407
 408
 409 // ==============
 410 // Event Handlers
 411 // ==============
 412
 413 void ctf_Handle_Capture(entity flag, entity toucher, int capturetype)
 414 {
 415         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
 416         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
 417         entity player_team_flag = world, tmp_entity;
 418         float old_time, new_time;
 419
 420         if(!player) { return; } // without someone to give the reward to, we can't possibly cap
 421         if(CTF_DIFFTEAM(player, flag)) { return; }
 422
 423         if(ctf_oneflag)
 424         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 425         if(SAME_TEAM(tmp_entity, player))
 426         {
 427                 player_team_flag = tmp_entity;
 428                 break;
 429         }
 430
 431         nades_GiveBonus(player, autocvar_g_nades_bonus_score_high );
 432
 433         player.throw_prevtime = time;
 434         player.throw_count = 0;
 435
 436         // messages and sounds
 437         Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((enemy_flag.team) ? APP_TEAM_ENT_4(enemy_flag, CENTER_CTF_CAPTURE_) : CENTER_CTF_CAPTURE_NEUTRAL));
 438         ctf_CaptureRecord(enemy_flag, player);
 439         sound(player, CH_TRIGGER, ((ctf_oneflag) ? player_team_flag.snd_flag_capture : ((DIFF_TEAM(player, flag)) ? enemy_flag.snd_flag_capture : flag.snd_flag_capture)), VOL_BASE, ATTEN_NONE);
 440
 441         switch(capturetype)
 442         {
 443                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
 444                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
 445                 default: break;
 446         }
 447
 448         // scoring
 449         PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_capture);
 450         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
 451
 452         old_time = PlayerScore_Add(player, SP_CTF_CAPTIME, 0);
 453         new_time = TIME_ENCODE(time - enemy_flag.ctf_pickuptime);
 454         if(!old_time || new_time < old_time)
 455                 PlayerScore_Add(player, SP_CTF_CAPTIME, new_time - old_time);
 456
 457         // effects
 458         Send_Effect_(flag.capeffect, flag.origin, '0 0 0', 1);
 459         //shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
 460
 461         // other
 462         if(capturetype == CAPTURE_NORMAL)
 463         {
 464                 WaypointSprite_Kill(player.wps_flagcarrier);
 465                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
 466
 467                 if((enemy_flag.ctf_dropper) && (player != enemy_flag.ctf_dropper))
 468                         { PlayerTeamScore_AddScore(enemy_flag.ctf_dropper, autocvar_g_ctf_score_capture_assist); }
 469         }
 470
 471         // reset the flag
 472         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
 473         ctf_RespawnFlag(enemy_flag);
 474 }
 475
 476 void ctf_Handle_Return(entity flag, entity player)
 477 {
 478         // messages and sounds
 479         if(IS_MONSTER(player))
 480         {
 481                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT_4(flag, INFO_CTF_RETURN_MONSTER_), player.monster_name);
 482         }
 483         else if(flag.team)
 484         {
 485                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_ENT_4(flag, CENTER_CTF_RETURN_));
 486                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT_4(flag, INFO_CTF_RETURN_), player.netname);
 487         }
 488         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTEN_NONE);
 489         ctf_EventLog("return", flag.team, player);
 490
 491         // scoring
 492         if(IS_PLAYER(player))
 493         {
 494                 PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_return); // reward for return
 495                 PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
 496
 497                 nades_GiveBonus(player,autocvar_g_nades_bonus_score_medium);
 498         }
 499
 500         TeamScore_AddToTeam(flag.team, ST_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the team who was last carrying it
 501
 502         if(flag.ctf_dropper)
 503         {
 504                 PlayerScore_Add(flag.ctf_dropper, SP_SCORE, -autocvar_g_ctf_score_penalty_returned); // punish the player who dropped the flag
 505                 ctf_CaptureShield_Update(flag.ctf_dropper, 0); // shield player from picking up flag
 506                 flag.ctf_dropper.next_take_time = time + autocvar_g_ctf_flag_collect_delay; // set next take time
 507         }
 508
 509         // other
 510         if(player.flagcarried == flag)
 511                 WaypointSprite_Kill(player.wps_flagcarrier);
 512
 513         // reset the flag
 514         ctf_RespawnFlag(flag);
 515 }
 516
 517 void ctf_Handle_Pickup(entity flag, entity player, int pickuptype)
 518 {
 519         // declarations
 520         float pickup_dropped_score; // used to calculate dropped pickup score
 521         entity tmp_entity; // temporary entity
 522
 523         // attach the flag to the player
 524         flag.owner = player;
 525         player.flagcarried = flag;
 526         if(player.vehicle)
 527         {
 528                 setattachment(flag, player.vehicle, "");
 529                 setorigin(flag, VEHICLE_FLAG_OFFSET);
 530                 flag.scale = VEHICLE_FLAG_SCALE;
 531         }
 532         else
 533         {
 534                 setattachment(flag, player, "");
 535                 setorigin(flag, FLAG_CARRY_OFFSET);
 536         }
 537
 538         // flag setup
 539         flag.movetype = MOVETYPE_NONE;
 540         flag.takedamage = DAMAGE_NO;
 541         flag.solid = SOLID_NOT;
 542         flag.angles = '0 0 0';
 543         flag.ctf_status = FLAG_CARRY;
 544
 545         switch(pickuptype)
 546         {
 547                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
 548                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
 549                 default: break;
 550         }
 551
 552         // messages and sounds
 553         Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_PICKUP_) : INFO_CTF_PICKUP_NEUTRAL), player.netname);
 554         if(ctf_stalemate) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_STALEMATE_CARRIER); }
 555         if(!flag.team) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PICKUP_NEUTRAL); }
 556         else if(CTF_DIFFTEAM(player, flag)) { Send_Notification(NOTIF_ONE, player, MSG_CENTER, APP_TEAM_ENT_4(flag, CENTER_CTF_PICKUP_)); }
 557         else { Send_Notification(NOTIF_ONE, player, MSG_CENTER, ((SAME_TEAM(player, flag)) ? CENTER_CTF_PICKUP_TEAM : CENTER_CTF_PICKUP_TEAM_ENEMY), Team_ColorCode(flag.team)); }
 558
 559         Send_Notification(NOTIF_TEAM_EXCEPT, player, MSG_CHOICE, ((flag.team) ? APP_TEAM_ENT_4(flag, CHOICE_CTF_PICKUP_TEAM_) : CHOICE_CTF_PICKUP_TEAM_NEUTRAL), Team_ColorCode(player.team), player.netname);
 560
 561         if(!flag.team)
 562         FOR_EACH_PLAYER(tmp_entity)
 563         if(tmp_entity != player)
 564         if(DIFF_TEAM(player, tmp_entity))
 565                 Send_Notification(NOTIF_ONE, tmp_entity, MSG_CHOICE, CHOICE_CTF_PICKUP_ENEMY_NEUTRAL, Team_ColorCode(player.team), player.netname);
 566
 567         if(flag.team)
 568         FOR_EACH_PLAYER(tmp_entity)
 569         if(tmp_entity != player)
 570         if(CTF_SAMETEAM(flag, tmp_entity))
 571         if(SAME_TEAM(player, tmp_entity))
 572                 Send_Notification(NOTIF_ONE, tmp_entity, MSG_CHOICE, APP_TEAM_ENT_4(flag, CHOICE_CTF_PICKUP_TEAM_), Team_ColorCode(player.team), player.netname);
 573         else
 574                 Send_Notification(NOTIF_ONE, tmp_entity, MSG_CHOICE, ((SAME_TEAM(flag, player)) ? CHOICE_CTF_PICKUP_ENEMY_TEAM : CHOICE_CTF_PICKUP_ENEMY), Team_ColorCode(player.team), player.netname);
 575
 576         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTEN_NONE);
 577
 578         // scoring
 579         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
 580         nades_GiveBonus(player, autocvar_g_nades_bonus_score_minor);
 581         switch(pickuptype)
 582         {
 583                 case PICKUP_BASE:
 584                 {
 585                         PlayerTeamScore_AddScore(player, autocvar_g_ctf_score_pickup_base);
 586                         ctf_EventLog("steal", flag.team, player);
 587                         break;
 588                 }
 589
 590                 case PICKUP_DROPPED:
 591                 {
 592                         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);
 593                         pickup_dropped_score = floor((autocvar_g_ctf_score_pickup_dropped_late * (1 - pickup_dropped_score) + autocvar_g_ctf_score_pickup_dropped_early * pickup_dropped_score) + 0.5);
 594                         LOG_TRACE("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
 595                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
 596                         ctf_EventLog("pickup", flag.team, player);
 597                         break;
 598                 }
 599
 600                 default: break;
 601         }
 602
 603         // speedrunning
 604         if(pickuptype == PICKUP_BASE)
 605         {
 606                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
 607                 if((player.speedrunning) && (ctf_captimerecord))
 608                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
 609         }
 610
 611         // effects
 612         Send_Effect_(flag.toucheffect, player.origin, '0 0 0', 1);
 613
 614         // waypoints
 615         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
 616         ctf_FlagcarrierWaypoints(player);
 617         WaypointSprite_Ping(player.wps_flagcarrier);
 618 }
 619
 620
 621 // ===================
 622 // Main Flag Functions
 623 // ===================
 624
 625 void ctf_CheckFlagReturn(entity flag, int returntype)
 626 {
 627         if((flag.ctf_status == FLAG_DROPPED) || (flag.ctf_status == FLAG_PASSING))
 628         {
 629                 if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
 630
 631                 if((flag.health <= 0) || (time >= flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
 632                 {
 633                         switch(returntype)
 634                         {
 635                                 case RETURN_DROPPED: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_FLAGRETURN_DROPPED_) : INFO_CTF_FLAGRETURN_DROPPED_NEUTRAL)); break;
 636                                 case RETURN_DAMAGE: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_FLAGRETURN_DAMAGED_) : INFO_CTF_FLAGRETURN_DAMAGED_NEUTRAL)); break;
 637                                 case RETURN_SPEEDRUN: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_FLAGRETURN_SPEEDRUN_) : INFO_CTF_FLAGRETURN_SPEEDRUN_NEUTRAL), ctf_captimerecord); break;
 638                                 case RETURN_NEEDKILL: Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_FLAGRETURN_NEEDKILL_) : INFO_CTF_FLAGRETURN_NEEDKILL_NEUTRAL)); break;
 639
 640                                 default:
 641                                 case RETURN_TIMEOUT:
 642                                         { Send_Notification(NOTIF_ALL, world, MSG_INFO, ((flag.team) ? APP_TEAM_ENT_4(flag, INFO_CTF_FLAGRETURN_TIMEOUT_) : INFO_CTF_FLAGRETURN_TIMEOUT_NEUTRAL)); break; }
 643                         }
 644                         sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTEN_NONE);
 645                         ctf_EventLog("returned", flag.team, world);
 646                         ctf_RespawnFlag(flag);
 647                 }
 648         }
 649 }
 650
 651 bool ctf_Stalemate_Customize()
 652 {
 653         // make spectators see what the player would see
 654         entity e, wp_owner;
 655         e = WaypointSprite_getviewentity(other);
 656         wp_owner = self.owner;
 657
 658         // team waypoints
 659         if(CTF_SAMETEAM(wp_owner.flagcarried, wp_owner)) { return false; }
 660         if(SAME_TEAM(wp_owner, e)) { return false; }
 661         if(!IS_PLAYER(e)) { return false; }
 662
 663         return true;
 664 }
 665
 666 void ctf_CheckStalemate(void)
 667 {
 668         // declarations
 669         int stale_flags = 0, stale_red_flags = 0, stale_blue_flags = 0, stale_yellow_flags = 0, stale_pink_flags = 0, stale_neutral_flags = 0;
 670         entity tmp_entity;
 671
 672         entity ctf_staleflaglist = world; // reset the list, we need to build the list each time this function runs
 673
 674         // build list of stale flags
 675         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 676         {
 677                 if(autocvar_g_ctf_stalemate)
 678                 if(tmp_entity.ctf_status != FLAG_BASE)
 679                 if(time >= tmp_entity.ctf_pickuptime + autocvar_g_ctf_stalemate_time || !tmp_entity.team) // instant stalemate in oneflag
 680                 {
 681                         tmp_entity.ctf_staleflagnext = ctf_staleflaglist; // link flag into staleflaglist
 682                         ctf_staleflaglist = tmp_entity;
 683
 684                         switch(tmp_entity.team)
 685                         {
 686                                 case NUM_TEAM_1: ++stale_red_flags; break;
 687                                 case NUM_TEAM_2: ++stale_blue_flags; break;
 688                                 case NUM_TEAM_3: ++stale_yellow_flags; break;
 689                                 case NUM_TEAM_4: ++stale_pink_flags; break;
 690                                 default: ++stale_neutral_flags; break;
 691                         }
 692                 }
 693         }
 694
 695         if(ctf_oneflag)
 696                 stale_flags = (stale_neutral_flags >= 1);
 697         else
 698                 stale_flags = (stale_red_flags >= 1) + (stale_blue_flags >= 1) + (stale_yellow_flags >= 1) + (stale_pink_flags >= 1);
 699
 700         if(ctf_oneflag && stale_flags == 1)
 701                 ctf_stalemate = true;
 702         else if(stale_flags >= 2)
 703                 ctf_stalemate = true;
 704         else if(stale_flags == 0 && autocvar_g_ctf_stalemate_endcondition == 2)
 705                 { ctf_stalemate = false; wpforenemy_announced = false; }
 706         else if(stale_flags < 2 && autocvar_g_ctf_stalemate_endcondition == 1)
 707                 { ctf_stalemate = false; wpforenemy_announced = false; }
 708
 709         // if sufficient stalemate, then set up the waypointsprite and announce the stalemate if necessary
 710         if(ctf_stalemate)
 711         {
 712                 for(tmp_entity = ctf_staleflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_staleflagnext)
 713                 {
 714                         if((tmp_entity.owner) && (!tmp_entity.owner.wps_enemyflagcarrier))
 715                         {
 716                                 entity wp = WaypointSprite_Spawn(((ctf_oneflag) ? WP_FlagCarrier : WP_FlagCarrierEnemy), 0, 0, tmp_entity.owner, FLAG_WAYPOINT_OFFSET, world, 0, tmp_entity.owner, wps_enemyflagcarrier, true, RADARICON_FLAG);
 717                                 wp.colormod = WPCOLOR_ENEMYFC(tmp_entity.owner.team);
 718                                 tmp_entity.owner.wps_enemyflagcarrier.customizeentityforclient = ctf_Stalemate_Customize;
 719                         }
 720                 }
 721
 722                 if (!wpforenemy_announced)
 723                 {
 724                         FOR_EACH_REALPLAYER(tmp_entity)
 725                                 Send_Notification(NOTIF_ONE, tmp_entity, MSG_CENTER, ((tmp_entity.flagcarried) ? CENTER_CTF_STALEMATE_CARRIER : CENTER_CTF_STALEMATE_OTHER));
 726
 727                         wpforenemy_announced = true;
 728                 }
 729         }
 730 }
 731
 732 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, int deathtype, vector hitloc, vector force)
 733 {
 734         if(ITEM_DAMAGE_NEEDKILL(deathtype))
 735         {
 736                 if(autocvar_g_ctf_flag_return_damage_delay)
 737                 {
 738                         self.ctf_flagdamaged = true;
 739                 }
 740                 else
 741                 {
 742                         self.health = 0;
 743                         ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
 744                 }
 745                 return;
 746         }
 747         if(autocvar_g_ctf_flag_return_damage)
 748         {
 749                 // reduce health and check if it should be returned
 750                 self.health = self.health - damage;
 751                 ctf_CheckFlagReturn(self, RETURN_DAMAGE);
 752                 return;
 753         }
 754 }
 755
 756 void ctf_FlagThink()
 757 {
 758         // declarations
 759         entity tmp_entity;
 760
 761         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
 762
 763         // captureshield
 764         if(self == ctf_worldflaglist) // only for the first flag
 765                 FOR_EACH_CLIENT(tmp_entity)
 766                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
 767
 768         // sanity checks
 769         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
 770                 LOG_TRACE("wtf the flag got squashed?\n");
 771                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
 772                 if(!trace_startsolid || self.noalign) // can we resize it without getting stuck?
 773                         setsize(self, FLAG_MIN, FLAG_MAX); }
 774
 775         switch(self.ctf_status) // reset flag angles in case warpzones adjust it
 776         {
 777                 case FLAG_DROPPED:
 778                 {
 779                         self.angles = '0 0 0';
 780                         break;
 781                 }
 782
 783                 default: break;
 784         }
 785
 786         // main think method
 787         switch(self.ctf_status)
 788         {
 789                 case FLAG_BASE:
 790                 {
 791                         if(autocvar_g_ctf_dropped_capture_radius)
 792                         {
 793                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 794                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
 795                                         if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
 796                                         if(time > tmp_entity.ctf_droptime + autocvar_g_ctf_dropped_capture_delay)
 797                                                 ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
 798                         }
 799                         return;
 800                 }
 801
 802                 case FLAG_DROPPED:
 803                 {
 804                         if(autocvar_g_ctf_flag_dropped_floatinwater)
 805                         {
 806                                 vector midpoint = ((self.absmin + self.absmax) * 0.5);
 807                                 if(pointcontents(midpoint) == CONTENT_WATER)
 808                                 {
 809                                         self.velocity = self.velocity * 0.5;
 810
 811                                         if(pointcontents(midpoint + FLAG_FLOAT_OFFSET) == CONTENT_WATER)
 812                                                 { self.velocity_z = autocvar_g_ctf_flag_dropped_floatinwater; }
 813                                         else
 814                                                 { self.movetype = MOVETYPE_FLY; }
 815                                 }
 816                                 else if(self.movetype == MOVETYPE_FLY) { self.movetype = MOVETYPE_TOSS; }
 817                         }
 818                         if(autocvar_g_ctf_flag_return_dropped)
 819                         {
 820                                 if((vlen(self.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
 821                                 {
 822                                         self.health = 0;
 823                                         ctf_CheckFlagReturn(self, RETURN_DROPPED);
 824                                         return;
 825                                 }
 826                         }
 827                         if(self.ctf_flagdamaged)
 828                         {
 829                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_damage_delay) * FLAG_THINKRATE);
 830                                 ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
 831                                 return;
 832                         }
 833                         else if(autocvar_g_ctf_flag_return_time)
 834                         {
 835                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
 836                                 ctf_CheckFlagReturn(self, RETURN_TIMEOUT);
 837                                 return;
 838                         }
 839                         return;
 840                 }
 841
 842                 case FLAG_CARRY:
 843                 {
 844                         if(self.speedrunning && ctf_captimerecord && (time >= self.ctf_pickuptime + ctf_captimerecord))
 845                         {
 846                                 self.health = 0;
 847                                 ctf_CheckFlagReturn(self, RETURN_SPEEDRUN);
 848
 849                                 tmp_entity = self;
 850                                 self = self.owner;
 851                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
 852                                 ImpulseCommands();
 853                                 self = tmp_entity;
 854                         }
 855                         if(autocvar_g_ctf_stalemate)
 856                         {
 857                                 if(time >= wpforenemy_nextthink)
 858                                 {
 859                                         ctf_CheckStalemate();
 860                                         wpforenemy_nextthink = time + WPFE_THINKRATE; // waypoint for enemy think rate (to reduce unnecessary spam of this check)
 861                                 }
 862                         }
 863                         if(CTF_SAMETEAM(self, self.owner) && self.team)
 864                         {
 865                                 if(autocvar_g_ctf_flag_return) // drop the flag if reverse status has changed
 866                                         ctf_Handle_Throw(self.owner, world, DROP_THROW);
 867                                 else if(vlen(self.owner.origin - self.ctf_spawnorigin) <= autocvar_g_ctf_flag_return_carried_radius)
 868                                         ctf_Handle_Return(self, self.owner);
 869                         }
 870                         return;
 871                 }
 872
 873                 case FLAG_PASSING:
 874                 {
 875                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
 876                         targ_origin = WarpZone_RefSys_TransformOrigin(self.pass_target, self, targ_origin); // origin of target as seen by the flag (us)
 877                         WarpZone_TraceLine(self.origin, targ_origin, MOVE_NOMONSTERS, self);
 878
 879                         if((self.pass_target == world)
 880                                 || (self.pass_target.deadflag != DEAD_NO)
 881                                 || (self.pass_target.flagcarried)
 882                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
 883                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
 884                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
 885                         {
 886                                 // give up, pass failed
 887                                 ctf_Handle_Drop(self, world, DROP_PASS);
 888                         }
 889                         else
 890                         {
 891                                 // still a viable target, go for it
 892                                 ctf_CalculatePassVelocity(self, targ_origin, self.origin, true);
 893                         }
 894                         return;
 895                 }
 896
 897                 default: // this should never happen
 898                 {
 899                         LOG_TRACE("ctf_FlagThink(): Flag exists with no status?\n");
 900                         return;
 901                 }
 902         }
 903 }
 904
 905 void ctf_FlagTouch()
 906 {
 907         if(gameover) { return; }
 908         if(trace_dphitcontents & (DPCONTENTS_PLAYERCLIP | DPCONTENTS_MONSTERCLIP)) { return; }
 909
 910         entity toucher = other, tmp_entity;
 911         bool is_not_monster = (!IS_MONSTER(toucher)), num_perteam = 0;
 912
 913         // automatically kill the flag and return it if it touched lava/slime/nodrop surfaces
 914         if(ITEM_TOUCH_NEEDKILL())
 915         {
 916                 if(!autocvar_g_ctf_flag_return_damage_delay)
 917                 {
 918                         self.health = 0;
 919                         ctf_CheckFlagReturn(self, RETURN_NEEDKILL);
 920                 }
 921                 if(!self.ctf_flagdamaged) { return; }
 922         }
 923
 924         FOR_EACH_PLAYER(tmp_entity) if(SAME_TEAM(toucher, tmp_entity)) { ++num_perteam; }
 925
 926         // special touch behaviors
 927         if(toucher.frozen) { return; }
 928         else if(IS_VEHICLE(toucher))
 929         {
 930                 if(autocvar_g_ctf_allow_vehicle_touch && toucher.owner)
 931                         toucher = toucher.owner; // the player is actually the vehicle owner, not other
 932                 else
 933                         return; // do nothing
 934         }
 935         else if(IS_MONSTER(toucher))
 936         {
 937                 if(!autocvar_g_ctf_allow_monster_touch)
 938                         return; // do nothing
 939         }
 940         else if (!IS_PLAYER(toucher)) // The flag just touched an object, most likely the world
 941         {
 942                 if(time > self.wait) // if we haven't in a while, play a sound/effect
 943                 {
 944                         Send_Effect_(self.toucheffect, self.origin, '0 0 0', 1);
 945                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTEN_NORM);
 946                         self.wait = time + FLAG_TOUCHRATE;
 947                 }
 948                 return;
 949         }
 950         else if(toucher.deadflag != DEAD_NO) { return; }
 951
 952         switch(self.ctf_status)
 953         {
 954                 case FLAG_BASE:
 955                 {
 956                         if(ctf_oneflag)
 957                         {
 958                                 if(CTF_SAMETEAM(toucher, self) && (toucher.flagcarried) && !toucher.flagcarried.team && is_not_monster)
 959                                         ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the neutral flag to enemy base
 960                                 else if(!self.team && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
 961                                         ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the neutral flag
 962                         }
 963                         else if(CTF_SAMETEAM(toucher, self) && (toucher.flagcarried) && DIFF_TEAM(toucher.flagcarried, self) && is_not_monster)
 964                                 ctf_Handle_Capture(self, toucher, CAPTURE_NORMAL); // toucher just captured the enemies flag to his base
 965                         else if(CTF_DIFFTEAM(toucher, self) && (!toucher.flagcarried) && (!toucher.ctf_captureshielded) && (time > toucher.next_take_time) && is_not_monster)
 966                                 ctf_Handle_Pickup(self, toucher, PICKUP_BASE); // toucher just stole the enemies flag
 967                         break;
 968                 }
 969
 970                 case FLAG_DROPPED:
 971                 {
 972                         if(CTF_SAMETEAM(toucher, self) && (autocvar_g_ctf_flag_return || num_perteam <= 1) && self.team) // automatically return if there's only 1 player on the team
 973                                 ctf_Handle_Return(self, toucher); // toucher just returned his own flag
 974                         else if(is_not_monster && (!toucher.flagcarried) && ((toucher != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
 975                                 ctf_Handle_Pickup(self, toucher, PICKUP_DROPPED); // toucher just picked up a dropped enemy flag
 976                         break;
 977                 }
 978
 979                 case FLAG_CARRY:
 980                 {
 981                         LOG_TRACE("Someone touched a flag even though it was being carried?\n");
 982                         break;
 983                 }
 984
 985                 case FLAG_PASSING:
 986                 {
 987                         if((IS_PLAYER(toucher)) && (toucher.deadflag == DEAD_NO) && (toucher != self.pass_sender))
 988                         {
 989                                 if(DIFF_TEAM(toucher, self.pass_sender))
 990                                         ctf_Handle_Return(self, toucher);
 991                                 else
 992                                         ctf_Handle_Retrieve(self, toucher);
 993                         }
 994                         break;
 995                 }
 996         }
 997 }
 998
 999 .float last_respawn;
1000 void ctf_RespawnFlag(entity flag)
1001 {
1002         // check for flag respawn being called twice in a row
1003         if(flag.last_respawn > time - 0.5)
1004                 { backtrace("flag respawn called twice quickly! please notify Samual about this..."); }
1005
1006         flag.last_respawn = time;
1007
1008         // reset the player (if there is one)
1009         if((flag.owner) && (flag.owner.flagcarried == flag))
1010         {
1011                 WaypointSprite_Kill(flag.owner.wps_enemyflagcarrier);
1012                 WaypointSprite_Kill(flag.wps_flagcarrier);
1013
1014                 flag.owner.flagcarried = world;
1015
1016                 if(flag.speedrunning)
1017                         ctf_FakeTimeLimit(flag.owner, -1);
1018         }
1019
1020         if((flag.owner) && (flag.owner.vehicle))
1021                 flag.scale = FLAG_SCALE;
1022
1023         if(flag.ctf_status == FLAG_DROPPED)
1024                 { WaypointSprite_Kill(flag.wps_flagdropped); }
1025
1026         // reset the flag
1027         setattachment(flag, world, "");
1028         setorigin(flag, flag.ctf_spawnorigin);
1029
1030         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
1031         flag.takedamage = DAMAGE_NO;
1032         flag.health = flag.max_flag_health;
1033         flag.solid = SOLID_TRIGGER;
1034         flag.velocity = '0 0 0';
1035         flag.angles = flag.mangle;
1036         flag.flags = FL_ITEM | FL_NOTARGET;
1037
1038         flag.ctf_status = FLAG_BASE;
1039         flag.owner = world;
1040         flag.pass_distance = 0;
1041         flag.pass_sender = world;
1042         flag.pass_target = world;
1043         flag.ctf_dropper = world;
1044         flag.ctf_pickuptime = 0;
1045         flag.ctf_droptime = 0;
1046         flag.ctf_flagdamaged = 0;
1047
1048         ctf_CheckStalemate();
1049 }
1050
1051 void ctf_Reset()
1052 {
1053         if(self.owner)
1054                 if(IS_PLAYER(self.owner))
1055                         ctf_Handle_Throw(self.owner, world, DROP_RESET);
1056
1057         ctf_RespawnFlag(self);
1058 }
1059
1060 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
1061 {
1062         // bot waypoints
1063         waypoint_spawnforitem_force(self, self.origin);
1064         self.nearestwaypointtimeout = 0; // activate waypointing again
1065         self.bot_basewaypoint = self.nearestwaypoint;
1066
1067         // waypointsprites
1068         entity basename;
1069         switch (self.team)
1070         {
1071                 case NUM_TEAM_1: basename = WP_FlagBaseRed; break;
1072                 case NUM_TEAM_2: basename = WP_FlagBaseBlue; break;
1073                 case NUM_TEAM_3: basename = WP_FlagBaseYellow; break;
1074                 case NUM_TEAM_4: basename = WP_FlagBasePink; break;
1075                 default: basename = WP_FlagBaseNeutral; break;
1076         }
1077
1078         entity wp = WaypointSprite_SpawnFixed(basename, self.origin + FLAG_WAYPOINT_OFFSET, self, wps_flagbase, RADARICON_FLAG);
1079         wp.colormod = ((self.team) ? Team_ColorRGB(self.team) : '1 1 1');
1080         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, ((self.team) ? colormapPaletteColor(self.team - 1, false) : '1 1 1'));
1081
1082         // captureshield setup
1083         ctf_CaptureShield_Spawn(self);
1084 }
1085
1086 void set_flag_string(entity flag, .string field, string value, string teamname)
1087 {
1088         if(flag.field == "")
1089                 flag.field = strzone(sprintf(value,teamname));
1090 }
1091
1092 void ctf_FlagSetup(int teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
1093 {
1094         // declarations
1095         string teamname = Static_Team_ColorName_Lower(teamnumber);
1096         self = flag; // for later usage with droptofloor()
1097
1098         // main setup
1099         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
1100         ctf_worldflaglist = flag;
1101
1102         setattachment(flag, world, "");
1103
1104         flag.netname = strzone(sprintf("%s%s^7 flag", Team_ColorCode(teamnumber), Team_ColorName_Upper(teamnumber)));
1105         flag.team = teamnumber;
1106         flag.classname = "item_flag_team";
1107         flag.target = "###item###"; // wut?
1108         flag.flags = FL_ITEM | FL_NOTARGET;
1109         flag.solid = SOLID_TRIGGER;
1110         flag.takedamage = DAMAGE_NO;
1111         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
1112         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
1113         flag.health = flag.max_flag_health;
1114         flag.event_damage = ctf_FlagDamage;
1115         flag.pushable = true;
1116         flag.teleportable = TELEPORT_NORMAL;
1117         flag.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_PLAYERCLIP | DPCONTENTS_BOTCLIP;
1118         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
1119         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
1120         flag.velocity = '0 0 0';
1121         flag.mangle = flag.angles;
1122         flag.reset = ctf_Reset;
1123         flag.touch = ctf_FlagTouch;
1124         flag.think = ctf_FlagThink;
1125         flag.nextthink = time + FLAG_THINKRATE;
1126         flag.ctf_status = FLAG_BASE;
1127
1128         // appearence
1129         if(!flag.scale)                         { flag.scale = FLAG_SCALE; }
1130         if(flag.skin == 0)                      { flag.skin = cvar(sprintf("g_ctf_flag_%s_skin", teamname)); }
1131         if(flag.model == "")            { flag.model = cvar_string(sprintf("g_ctf_flag_%s_model", teamname)); }
1132         set_flag_string(flag, toucheffect,      "%sflag_touch", teamname);
1133         set_flag_string(flag, passeffect,       "%s_pass",              teamname);
1134         set_flag_string(flag, capeffect,        "%s_cap",               teamname);
1135
1136         // sounds
1137         set_flag_string(flag, snd_flag_taken,           "ctf/%s_taken.wav",     teamname);
1138         set_flag_string(flag, snd_flag_returned,        "ctf/%s_returned.wav",  teamname);
1139         set_flag_string(flag, snd_flag_capture,         "ctf/%s_capture.wav",   teamname);
1140         set_flag_string(flag, snd_flag_dropped,         "ctf/%s_dropped.wav",   teamname);
1141         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.
1142         if(flag.snd_flag_touch == "")           { flag.snd_flag_touch = "ctf/touch.wav"; } // again has no team-based sound
1143         if(flag.snd_flag_pass == "")            { flag.snd_flag_pass = "ctf/pass.wav"; } // same story here
1144
1145         // precache
1146         precache_sound(flag.snd_flag_taken);
1147         precache_sound(flag.snd_flag_returned);
1148         precache_sound(flag.snd_flag_capture);
1149         precache_sound(flag.snd_flag_respawn);
1150         precache_sound(flag.snd_flag_dropped);
1151         precache_sound(flag.snd_flag_touch);
1152         precache_sound(flag.snd_flag_pass);
1153         precache_model(flag.model);
1154         precache_model("models/ctf/shield.md3");
1155         precache_model("models/ctf/shockwavetransring.md3");
1156
1157         // appearence
1158         setmodel(flag, flag.model); // precision set below
1159         setsize(flag, FLAG_MIN, FLAG_MAX);
1160         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
1161
1162         if(autocvar_g_ctf_flag_glowtrails)
1163         {
1164                 switch(teamnumber)
1165                 {
1166                         case NUM_TEAM_1: flag.glow_color = 251; break;
1167                         case NUM_TEAM_2: flag.glow_color = 210; break;
1168                         case NUM_TEAM_3: flag.glow_color = 110; break;
1169                         case NUM_TEAM_4: flag.glow_color = 145; break;
1170                         default:                 flag.glow_color = 254; break;
1171                 }
1172                 flag.glow_size = 25;
1173                 flag.glow_trail = 1;
1174         }
1175
1176         flag.effects |= EF_LOWPRECISION;
1177         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
1178         if(autocvar_g_ctf_dynamiclights)
1179         {
1180                 switch(teamnumber)
1181                 {
1182                         case NUM_TEAM_1: flag.effects |= EF_RED; break;
1183                         case NUM_TEAM_2: flag.effects |= EF_BLUE; break;
1184                         case NUM_TEAM_3: flag.effects |= EF_DIMLIGHT; break;
1185                         case NUM_TEAM_4: flag.effects |= EF_RED; break;
1186                         default:                 flag.effects |= EF_DIMLIGHT; break;
1187                 }
1188         }
1189
1190         // flag placement
1191         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
1192         {
1193                 flag.dropped_origin = flag.origin;
1194                 flag.noalign = true;
1195                 flag.movetype = MOVETYPE_NONE;
1196         }
1197         else // drop to floor, automatically find a platform and set that as spawn origin
1198         {
1199                 flag.noalign = false;
1200                 self = flag;
1201                 droptofloor();
1202                 flag.movetype = MOVETYPE_TOSS;
1203         }
1204
1205         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
1206 }
1207
1208
1209 // ================
1210 // Bot player logic
1211 // ================
1212
1213 // NOTE: LEGACY CODE, needs to be re-written!
1214
1215 void havocbot_calculate_middlepoint()
1216 {
1217         entity f;
1218         vector s = '0 0 0';
1219         vector fo = '0 0 0';
1220         float n = 0;
1221
1222         f = ctf_worldflaglist;
1223         while (f)
1224         {
1225                 fo = f.origin;
1226                 s = s + fo;
1227                 f = f.ctf_worldflagnext;
1228         }
1229         if(!n)
1230                 return;
1231         havocbot_ctf_middlepoint = s * (1.0 / n);
1232         havocbot_ctf_middlepoint_radius  = vlen(fo - havocbot_ctf_middlepoint);
1233 }
1234
1235
1236 entity havocbot_ctf_find_flag(entity bot)
1237 {
1238         entity f;
1239         f = ctf_worldflaglist;
1240         while (f)
1241         {
1242                 if (CTF_SAMETEAM(bot, f))
1243                         return f;
1244                 f = f.ctf_worldflagnext;
1245         }
1246         return world;
1247 }
1248
1249 entity havocbot_ctf_find_enemy_flag(entity bot)
1250 {
1251         entity f;
1252         f = ctf_worldflaglist;
1253         while (f)
1254         {
1255                 if(ctf_oneflag)
1256                 {
1257                         if(CTF_DIFFTEAM(bot, f))
1258                         {
1259                                 if(f.team)
1260                                 {
1261                                         if(bot.flagcarried)
1262                                                 return f;
1263                                 }
1264                                 else if(!bot.flagcarried)
1265                                         return f;
1266                         }
1267                 }
1268                 else if (CTF_DIFFTEAM(bot, f))
1269                         return f;
1270                 f = f.ctf_worldflagnext;
1271         }
1272         return world;
1273 }
1274
1275 int havocbot_ctf_teamcount(entity bot, vector org, float tc_radius)
1276 {
1277         if (!teamplay)
1278                 return 0;
1279
1280         int c = 0;
1281         entity head;
1282
1283         FOR_EACH_PLAYER(head)
1284         {
1285                 if(DIFF_TEAM(head, bot) || head.deadflag != DEAD_NO || head == bot)
1286                         continue;
1287
1288                 if(vlen(head.origin - org) < tc_radius)
1289                         ++c;
1290         }
1291
1292         return c;
1293 }
1294
1295 void havocbot_goalrating_ctf_ourflag(float ratingscale)
1296 {
1297         entity head;
1298         head = ctf_worldflaglist;
1299         while (head)
1300         {
1301                 if (CTF_SAMETEAM(self, head))
1302                         break;
1303                 head = head.ctf_worldflagnext;
1304         }
1305         if (head)
1306                 navigation_routerating(head, ratingscale, 10000);
1307 }
1308
1309 void havocbot_goalrating_ctf_ourbase(float ratingscale)
1310 {
1311         entity head;
1312         head = ctf_worldflaglist;
1313         while (head)
1314         {
1315                 if (CTF_SAMETEAM(self, head))
1316                         break;
1317                 head = head.ctf_worldflagnext;
1318         }
1319         if (!head)
1320                 return;
1321
1322         navigation_routerating(head.bot_basewaypoint, ratingscale, 10000);
1323 }
1324
1325 void havocbot_goalrating_ctf_enemyflag(float ratingscale)
1326 {
1327         entity head;
1328         head = ctf_worldflaglist;
1329         while (head)
1330         {
1331                 if(ctf_oneflag)
1332                 {
1333                         if(CTF_DIFFTEAM(self, head))
1334                         {
1335                                 if(head.team)
1336                                 {
1337                                         if(self.flagcarried)
1338                                                 break;
1339                                 }
1340                                 else if(!self.flagcarried)
1341                                         break;
1342                         }
1343                 }
1344                 else if(CTF_DIFFTEAM(self, head))
1345                         break;
1346                 head = head.ctf_worldflagnext;
1347         }
1348         if (head)
1349                 navigation_routerating(head, ratingscale, 10000);
1350 }
1351
1352 void havocbot_goalrating_ctf_enemybase(float ratingscale)
1353 {
1354         if (!bot_waypoints_for_items)
1355         {
1356                 havocbot_goalrating_ctf_enemyflag(ratingscale);
1357                 return;
1358         }
1359
1360         entity head;
1361
1362         head = havocbot_ctf_find_enemy_flag(self);
1363
1364         if (!head)
1365                 return;
1366
1367         navigation_routerating(head.bot_basewaypoint, ratingscale, 10000);
1368 }
1369
1370 void havocbot_goalrating_ctf_ourstolenflag(float ratingscale)
1371 {
1372         entity mf;
1373
1374         mf = havocbot_ctf_find_flag(self);
1375
1376         if(mf.ctf_status == FLAG_BASE)
1377                 return;
1378
1379         if(mf.tag_entity)
1380                 navigation_routerating(mf.tag_entity, ratingscale, 10000);
1381 }
1382
1383 void havocbot_goalrating_ctf_droppedflags(float ratingscale, vector org, float df_radius)
1384 {
1385         entity head;
1386         head = ctf_worldflaglist;
1387         while (head)
1388         {
1389                 // flag is out in the field
1390                 if(head.ctf_status != FLAG_BASE)
1391                 if(head.tag_entity==world)      // dropped
1392                 {
1393                         if(df_radius)
1394                         {
1395                                 if(vlen(org-head.origin)<df_radius)
1396                                         navigation_routerating(head, ratingscale, 10000);
1397                         }
1398                         else
1399                                 navigation_routerating(head, ratingscale, 10000);
1400                 }
1401
1402                 head = head.ctf_worldflagnext;
1403         }
1404 }
1405
1406 void havocbot_goalrating_ctf_carrieritems(float ratingscale, vector org, float sradius)
1407 {
1408         entity head;
1409         float t;
1410         head = findchainfloat(bot_pickup, true);
1411         while (head)
1412         {
1413                 // gather health and armor only
1414                 if (head.solid)
1415                 if (head.health || head.armorvalue)
1416                 if (vlen(head.origin - org) < sradius)
1417                 {
1418                         // get the value of the item
1419                         t = head.bot_pickupevalfunc(self, head) * 0.0001;
1420                         if (t > 0)
1421                                 navigation_routerating(head, t * ratingscale, 500);
1422                 }
1423                 head = head.chain;
1424         }
1425 }
1426
1427 void havocbot_ctf_reset_role(entity bot)
1428 {
1429         float cdefense, cmiddle, coffense;
1430         entity mf, ef, head;
1431         float c;
1432
1433         if(bot.deadflag != DEAD_NO)
1434                 return;
1435
1436         if(vlen(havocbot_ctf_middlepoint)==0)
1437                 havocbot_calculate_middlepoint();
1438
1439         // Check ctf flags
1440         if (bot.flagcarried)
1441         {
1442                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_CARRIER);
1443                 return;
1444         }
1445
1446         mf = havocbot_ctf_find_flag(bot);
1447         ef = havocbot_ctf_find_enemy_flag(bot);
1448
1449         // Retrieve stolen flag
1450         if(mf.ctf_status!=FLAG_BASE)
1451         {
1452                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_RETRIEVER);
1453                 return;
1454         }
1455
1456         // If enemy flag is taken go to the middle to intercept pursuers
1457         if(ef.ctf_status!=FLAG_BASE)
1458         {
1459                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_MIDDLE);
1460                 return;
1461         }
1462
1463         // if there is only me on the team switch to offense
1464         c = 0;
1465         FOR_EACH_PLAYER(head)
1466         if(SAME_TEAM(head, bot))
1467                 ++c;
1468
1469         if(c==1)
1470         {
1471                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_OFFENSE);
1472                 return;
1473         }
1474
1475         // Evaluate best position to take
1476         // Count mates on middle position
1477         cmiddle = havocbot_ctf_teamcount(bot, havocbot_ctf_middlepoint, havocbot_ctf_middlepoint_radius * 0.5);
1478
1479         // Count mates on defense position
1480         cdefense = havocbot_ctf_teamcount(bot, mf.dropped_origin, havocbot_ctf_middlepoint_radius * 0.5);
1481
1482         // Count mates on offense position
1483         coffense = havocbot_ctf_teamcount(bot, ef.dropped_origin, havocbot_ctf_middlepoint_radius);
1484
1485         if(cdefense<=coffense)
1486                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_DEFENSE);
1487         else if(coffense<=cmiddle)
1488                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_OFFENSE);
1489         else
1490                 havocbot_role_ctf_setrole(bot, HAVOCBOT_CTF_ROLE_MIDDLE);
1491 }
1492
1493 void havocbot_role_ctf_carrier()
1494 {
1495         if(self.deadflag != DEAD_NO)
1496         {
1497                 havocbot_ctf_reset_role(self);
1498                 return;
1499         }
1500
1501         if (self.flagcarried == world)
1502         {
1503                 havocbot_ctf_reset_role(self);
1504                 return;
1505         }
1506
1507         if (self.bot_strategytime < time)
1508         {
1509                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1510
1511                 navigation_goalrating_start();
1512                 if(ctf_oneflag)
1513                         havocbot_goalrating_ctf_enemybase(50000);
1514                 else
1515                         havocbot_goalrating_ctf_ourbase(50000);
1516
1517                 if(self.health<100)
1518                         havocbot_goalrating_ctf_carrieritems(1000, self.origin, 1000);
1519
1520                 navigation_goalrating_end();
1521
1522                 if (self.navigation_hasgoals)
1523                         self.havocbot_cantfindflag = time + 10;
1524                 else if (time > self.havocbot_cantfindflag)
1525                 {
1526                         // Can't navigate to my own base, suicide!
1527                         // TODO: drop it and wander around
1528                         Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
1529                         return;
1530                 }
1531         }
1532 }
1533
1534 void havocbot_role_ctf_escort()
1535 {
1536         entity mf, ef;
1537
1538         if(self.deadflag != DEAD_NO)
1539         {
1540                 havocbot_ctf_reset_role(self);
1541                 return;
1542         }
1543
1544         if (self.flagcarried)
1545         {
1546                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_CARRIER);
1547                 return;
1548         }
1549
1550         // If enemy flag is back on the base switch to previous role
1551         ef = havocbot_ctf_find_enemy_flag(self);
1552         if(ef.ctf_status==FLAG_BASE)
1553         {
1554                 self.havocbot_role = self.havocbot_previous_role;
1555                 self.havocbot_role_timeout = 0;
1556                 return;
1557         }
1558
1559         // If the flag carrier reached the base switch to defense
1560         mf = havocbot_ctf_find_flag(self);
1561         if(mf.ctf_status!=FLAG_BASE)
1562         if(vlen(ef.origin - mf.dropped_origin) < 300)
1563         {
1564                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_DEFENSE);
1565                 return;
1566         }
1567
1568         // Set the role timeout if necessary
1569         if (!self.havocbot_role_timeout)
1570         {
1571                 self.havocbot_role_timeout = time + random() * 30 + 60;
1572         }
1573
1574         // If nothing happened just switch to previous role
1575         if (time > self.havocbot_role_timeout)
1576         {
1577                 self.havocbot_role = self.havocbot_previous_role;
1578                 self.havocbot_role_timeout = 0;
1579                 return;
1580         }
1581
1582         // Chase the flag carrier
1583         if (self.bot_strategytime < time)
1584         {
1585                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1586                 navigation_goalrating_start();
1587                 havocbot_goalrating_ctf_enemyflag(30000);
1588                 havocbot_goalrating_ctf_ourstolenflag(40000);
1589                 havocbot_goalrating_items(10000, self.origin, 10000);
1590                 navigation_goalrating_end();
1591         }
1592 }
1593
1594 void havocbot_role_ctf_offense()
1595 {
1596         entity mf, ef;
1597         vector pos;
1598
1599         if(self.deadflag != DEAD_NO)
1600         {
1601                 havocbot_ctf_reset_role(self);
1602                 return;
1603         }
1604
1605         if (self.flagcarried)
1606         {
1607                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_CARRIER);
1608                 return;
1609         }
1610
1611         // Check flags
1612         mf = havocbot_ctf_find_flag(self);
1613         ef = havocbot_ctf_find_enemy_flag(self);
1614
1615         // Own flag stolen
1616         if(mf.ctf_status!=FLAG_BASE)
1617         {
1618                 if(mf.tag_entity)
1619                         pos = mf.tag_entity.origin;
1620                 else
1621                         pos = mf.origin;
1622
1623                 // Try to get it if closer than the enemy base
1624                 if(vlen(self.origin-ef.dropped_origin)>vlen(self.origin-pos))
1625                 {
1626                         havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_RETRIEVER);
1627                         return;
1628                 }
1629         }
1630
1631         // Escort flag carrier
1632         if(ef.ctf_status!=FLAG_BASE)
1633         {
1634                 if(ef.tag_entity)
1635                         pos = ef.tag_entity.origin;
1636                 else
1637                         pos = ef.origin;
1638
1639                 if(vlen(pos-mf.dropped_origin)>700)
1640                 {
1641                         havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_ESCORT);
1642                         return;
1643                 }
1644         }
1645
1646         // About to fail, switch to middlefield
1647         if(self.health<50)
1648         {
1649                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_MIDDLE);
1650                 return;
1651         }
1652
1653         // Set the role timeout if necessary
1654         if (!self.havocbot_role_timeout)
1655                 self.havocbot_role_timeout = time + 120;
1656
1657         if (time > self.havocbot_role_timeout)
1658         {
1659                 havocbot_ctf_reset_role(self);
1660                 return;
1661         }
1662
1663         if (self.bot_strategytime < time)
1664         {
1665                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1666                 navigation_goalrating_start();
1667                 havocbot_goalrating_ctf_ourstolenflag(50000);
1668                 havocbot_goalrating_ctf_enemybase(20000);
1669                 havocbot_goalrating_items(5000, self.origin, 1000);
1670                 havocbot_goalrating_items(1000, self.origin, 10000);
1671                 navigation_goalrating_end();
1672         }
1673 }
1674
1675 // Retriever (temporary role):
1676 void havocbot_role_ctf_retriever()
1677 {
1678         entity mf;
1679
1680         if(self.deadflag != DEAD_NO)
1681         {
1682                 havocbot_ctf_reset_role(self);
1683                 return;
1684         }
1685
1686         if (self.flagcarried)
1687         {
1688                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_CARRIER);
1689                 return;
1690         }
1691
1692         // If flag is back on the base switch to previous role
1693         mf = havocbot_ctf_find_flag(self);
1694         if(mf.ctf_status==FLAG_BASE)
1695         {
1696                 havocbot_ctf_reset_role(self);
1697                 return;
1698         }
1699
1700         if (!self.havocbot_role_timeout)
1701                 self.havocbot_role_timeout = time + 20;
1702
1703         if (time > self.havocbot_role_timeout)
1704         {
1705                 havocbot_ctf_reset_role(self);
1706                 return;
1707         }
1708
1709         if (self.bot_strategytime < time)
1710         {
1711                 float rt_radius;
1712                 rt_radius = 10000;
1713
1714                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1715                 navigation_goalrating_start();
1716                 havocbot_goalrating_ctf_ourstolenflag(50000);
1717                 havocbot_goalrating_ctf_droppedflags(40000, self.origin, rt_radius);
1718                 havocbot_goalrating_ctf_enemybase(30000);
1719                 havocbot_goalrating_items(500, self.origin, rt_radius);
1720                 navigation_goalrating_end();
1721         }
1722 }
1723
1724 void havocbot_role_ctf_middle()
1725 {
1726         entity mf;
1727
1728         if(self.deadflag != DEAD_NO)
1729         {
1730                 havocbot_ctf_reset_role(self);
1731                 return;
1732         }
1733
1734         if (self.flagcarried)
1735         {
1736                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_CARRIER);
1737                 return;
1738         }
1739
1740         mf = havocbot_ctf_find_flag(self);
1741         if(mf.ctf_status!=FLAG_BASE)
1742         {
1743                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_RETRIEVER);
1744                 return;
1745         }
1746
1747         if (!self.havocbot_role_timeout)
1748                 self.havocbot_role_timeout = time + 10;
1749
1750         if (time > self.havocbot_role_timeout)
1751         {
1752                 havocbot_ctf_reset_role(self);
1753                 return;
1754         }
1755
1756         if (self.bot_strategytime < time)
1757         {
1758                 vector org;
1759
1760                 org = havocbot_ctf_middlepoint;
1761                 org.z = self.origin.z;
1762
1763                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1764                 navigation_goalrating_start();
1765                 havocbot_goalrating_ctf_ourstolenflag(50000);
1766                 havocbot_goalrating_ctf_droppedflags(30000, self.origin, 10000);
1767                 havocbot_goalrating_enemyplayers(10000, org, havocbot_ctf_middlepoint_radius * 0.5);
1768                 havocbot_goalrating_items(5000, org, havocbot_ctf_middlepoint_radius * 0.5);
1769                 havocbot_goalrating_items(2500, self.origin, 10000);
1770                 havocbot_goalrating_ctf_enemybase(2500);
1771                 navigation_goalrating_end();
1772         }
1773 }
1774
1775 void havocbot_role_ctf_defense()
1776 {
1777         entity mf;
1778
1779         if(self.deadflag != DEAD_NO)
1780         {
1781                 havocbot_ctf_reset_role(self);
1782                 return;
1783         }
1784
1785         if (self.flagcarried)
1786         {
1787                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_CARRIER);
1788                 return;
1789         }
1790
1791         // If own flag was captured
1792         mf = havocbot_ctf_find_flag(self);
1793         if(mf.ctf_status!=FLAG_BASE)
1794         {
1795                 havocbot_role_ctf_setrole(self, HAVOCBOT_CTF_ROLE_RETRIEVER);
1796                 return;
1797         }
1798
1799         if (!self.havocbot_role_timeout)
1800                 self.havocbot_role_timeout = time + 30;
1801
1802         if (time > self.havocbot_role_timeout)
1803         {
1804                 havocbot_ctf_reset_role(self);
1805                 return;
1806         }
1807         if (self.bot_strategytime < time)
1808         {
1809                 float mp_radius;
1810                 vector org;
1811
1812                 org = mf.dropped_origin;
1813                 mp_radius = havocbot_ctf_middlepoint_radius;
1814
1815                 self.bot_strategytime = time + autocvar_bot_ai_strategyinterval;
1816                 navigation_goalrating_start();
1817
1818                 // if enemies are closer to our base, go there
1819                 entity head, closestplayer = world;
1820                 float distance, bestdistance = 10000;
1821                 FOR_EACH_PLAYER(head)
1822                 {
1823                         if(head.deadflag!=DEAD_NO)
1824                                 continue;
1825
1826                         distance = vlen(org - head.origin);
1827                         if(distance<bestdistance)
1828                         {
1829                                 closestplayer = head;
1830                                 bestdistance = distance;
1831                         }
1832                 }
1833
1834                 if(closestplayer)
1835                 if(DIFF_TEAM(closestplayer, self))
1836                 if(vlen(org - self.origin)>1000)
1837                 if(checkpvs(self.origin,closestplayer)||random()<0.5)
1838                         havocbot_goalrating_ctf_ourbase(30000);
1839
1840                 havocbot_goalrating_ctf_ourstolenflag(20000);
1841                 havocbot_goalrating_ctf_droppedflags(20000, org, mp_radius);
1842                 havocbot_goalrating_enemyplayers(15000, org, mp_radius);
1843                 havocbot_goalrating_items(10000, org, mp_radius);
1844                 havocbot_goalrating_items(5000, self.origin, 10000);
1845                 navigation_goalrating_end();
1846         }
1847 }
1848
1849 void havocbot_role_ctf_setrole(entity bot, int role)
1850 {
1851         LOG_TRACE(strcat(bot.netname," switched to "));
1852         switch(role)
1853         {
1854                 case HAVOCBOT_CTF_ROLE_CARRIER:
1855                         LOG_TRACE("carrier");
1856                         bot.havocbot_role = havocbot_role_ctf_carrier;
1857                         bot.havocbot_role_timeout = 0;
1858                         bot.havocbot_cantfindflag = time + 10;
1859                         bot.bot_strategytime = 0;
1860                         break;
1861                 case HAVOCBOT_CTF_ROLE_DEFENSE:
1862                         LOG_TRACE("defense");
1863                         bot.havocbot_role = havocbot_role_ctf_defense;
1864                         bot.havocbot_role_timeout = 0;
1865                         break;
1866                 case HAVOCBOT_CTF_ROLE_MIDDLE:
1867                         LOG_TRACE("middle");
1868                         bot.havocbot_role = havocbot_role_ctf_middle;
1869                         bot.havocbot_role_timeout = 0;
1870                         break;
1871                 case HAVOCBOT_CTF_ROLE_OFFENSE:
1872                         LOG_TRACE("offense");
1873                         bot.havocbot_role = havocbot_role_ctf_offense;
1874                         bot.havocbot_role_timeout = 0;
1875                         break;
1876                 case HAVOCBOT_CTF_ROLE_RETRIEVER:
1877                         LOG_TRACE("retriever");
1878                         bot.havocbot_previous_role = bot.havocbot_role;
1879                         bot.havocbot_role = havocbot_role_ctf_retriever;
1880                         bot.havocbot_role_timeout = time + 10;
1881                         bot.bot_strategytime = 0;
1882                         break;
1883                 case HAVOCBOT_CTF_ROLE_ESCORT:
1884                         LOG_TRACE("escort");
1885                         bot.havocbot_previous_role = bot.havocbot_role;
1886                         bot.havocbot_role = havocbot_role_ctf_escort;
1887                         bot.havocbot_role_timeout = time + 30;
1888                         bot.bot_strategytime = 0;
1889                         break;
1890         }
1891         LOG_TRACE("\n");
1892 }
1893
1894
1895 // ==============
1896 // Hook Functions
1897 // ==============
1898
1899 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
1900 {
1901         entity flag;
1902         int t = 0, t2 = 0, t3 = 0;
1903
1904         // initially clear items so they can be set as necessary later.
1905         self.ctf_flagstatus &= ~(CTF_RED_FLAG_CARRYING          | CTF_RED_FLAG_TAKEN            | CTF_RED_FLAG_LOST
1906                                                    | CTF_BLUE_FLAG_CARRYING             | CTF_BLUE_FLAG_TAKEN           | CTF_BLUE_FLAG_LOST
1907                                                    | CTF_YELLOW_FLAG_CARRYING   | CTF_YELLOW_FLAG_TAKEN         | CTF_YELLOW_FLAG_LOST
1908                                                    | CTF_PINK_FLAG_CARRYING     | CTF_PINK_FLAG_TAKEN           | CTF_PINK_FLAG_LOST
1909                                                    | CTF_NEUTRAL_FLAG_CARRYING  | CTF_NEUTRAL_FLAG_TAKEN        | CTF_NEUTRAL_FLAG_LOST
1910                                                    | CTF_FLAG_NEUTRAL | CTF_SHIELDED);
1911
1912         // scan through all the flags and notify the client about them
1913         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
1914         {
1915                 if(flag.team == NUM_TEAM_1) { t = CTF_RED_FLAG_CARRYING;                t2 = CTF_RED_FLAG_TAKEN;                t3 = CTF_RED_FLAG_LOST; }
1916                 if(flag.team == NUM_TEAM_2) { t = CTF_BLUE_FLAG_CARRYING;               t2 = CTF_BLUE_FLAG_TAKEN;               t3 = CTF_BLUE_FLAG_LOST; }
1917                 if(flag.team == NUM_TEAM_3) { t = CTF_YELLOW_FLAG_CARRYING;     t2 = CTF_YELLOW_FLAG_TAKEN;             t3 = CTF_YELLOW_FLAG_LOST; }
1918                 if(flag.team == NUM_TEAM_4) { t = CTF_PINK_FLAG_CARRYING;               t2 = CTF_PINK_FLAG_TAKEN;               t3 = CTF_PINK_FLAG_LOST; }
1919                 if(flag.team == 0)                      { t = CTF_NEUTRAL_FLAG_CARRYING;        t2 = CTF_NEUTRAL_FLAG_TAKEN;    t3 = CTF_NEUTRAL_FLAG_LOST; self.ctf_flagstatus |= CTF_FLAG_NEUTRAL; }
1920
1921                 switch(flag.ctf_status)
1922                 {
1923                         case FLAG_PASSING:
1924                         case FLAG_CARRY:
1925                         {
1926                                 if((flag.owner == self) || (flag.pass_sender == self))
1927                                         self.ctf_flagstatus |= t; // carrying: self is currently carrying the flag
1928                                 else
1929                                         self.ctf_flagstatus |= t2; // taken: someone else is carrying the flag
1930                                 break;
1931                         }
1932                         case FLAG_DROPPED:
1933                         {
1934                                 self.ctf_flagstatus |= t3; // lost: the flag is dropped somewhere on the map
1935                                 break;
1936                         }
1937                 }
1938         }
1939
1940         // item for stopping players from capturing the flag too often
1941         if(self.ctf_captureshielded)
1942                 self.ctf_flagstatus |= CTF_SHIELDED;
1943
1944         // update the health of the flag carrier waypointsprite
1945         if(self.wps_flagcarrier)
1946                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(self.health, self.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON));
1947
1948         return false;
1949 }
1950
1951 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
1952 {
1953         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
1954         {
1955                 if(frag_target == frag_attacker) // damage done to yourself
1956                 {
1957                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
1958                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
1959                 }
1960                 else // damage done to everyone else
1961                 {
1962                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
1963                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
1964                 }
1965         }
1966         else if(frag_target.flagcarried && (frag_target.deadflag == DEAD_NO) && CTF_DIFFTEAM(frag_target, frag_attacker)) // if the target is a flagcarrier
1967         {
1968                 if(autocvar_g_ctf_flagcarrier_auto_helpme_damage > ('1 0 0' * healtharmor_maxdamage(frag_target.health, frag_target.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON)))
1969                 if(time > frag_target.wps_helpme_time + autocvar_g_ctf_flagcarrier_auto_helpme_time)
1970                 {
1971                         frag_target.wps_helpme_time = time;
1972                         WaypointSprite_HelpMePing(frag_target.wps_flagcarrier);
1973                 }
1974                 // todo: add notification for when flag carrier needs help?
1975         }
1976         return false;
1977 }
1978
1979 MUTATOR_HOOKFUNCTION(ctf_PlayerDies)
1980 {
1981         if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)) && (frag_target.flagcarried))
1982         {
1983                 PlayerTeamScore_AddScore(frag_attacker, autocvar_g_ctf_score_kill);
1984                 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
1985         }
1986
1987         if(frag_target.flagcarried)
1988         {
1989                 entity tmp_entity = frag_target.flagcarried;
1990                 ctf_Handle_Throw(frag_target, world, DROP_NORMAL);
1991                 tmp_entity.ctf_dropper = world;
1992         }
1993
1994         return false;
1995 }
1996
1997 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
1998 {
1999         frag_score = 0;
2000         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
2001 }
2002
2003 MUTATOR_HOOKFUNCTION(ctf_RemovePlayer)
2004 {
2005         entity flag; // temporary entity for the search method
2006
2007         if(self.flagcarried)
2008                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
2009
2010         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2011         {
2012                 if(flag.pass_sender == self) { flag.pass_sender = world; }
2013                 if(flag.pass_target == self) { flag.pass_target = world; }
2014                 if(flag.ctf_dropper == self) { flag.ctf_dropper = world; }
2015         }
2016
2017         return false;
2018 }
2019
2020 MUTATOR_HOOKFUNCTION(ctf_PortalTeleport)
2021 {
2022         if(self.flagcarried)
2023         if(!autocvar_g_ctf_portalteleport)
2024                 { ctf_Handle_Throw(self, world, DROP_NORMAL); }
2025
2026         return false;
2027 }
2028
2029 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
2030 {
2031         if(MUTATOR_RETURNVALUE || gameover) { return false; }
2032
2033         entity player = self;
2034
2035         if((time > player.throw_antispam) && (player.deadflag == DEAD_NO) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
2036         {
2037                 // pass the flag to a team mate
2038                 if(autocvar_g_ctf_pass)
2039                 {
2040                         entity head, closest_target = world;
2041                         head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, true);
2042
2043                         while(head) // find the closest acceptable target to pass to
2044                         {
2045                                 if(IS_PLAYER(head) && head.deadflag == DEAD_NO)
2046                                 if(head != player && SAME_TEAM(head, player))
2047                                 if(!head.speedrunning && !head.vehicle)
2048                                 {
2049                                         // if it's a player, use the view origin as reference (stolen from RadiusDamage functions in g_damage.qc)
2050                                         vector head_center = WarpZone_UnTransformOrigin(head, CENTER_OR_VIEWOFS(head));
2051                                         vector passer_center = CENTER_OR_VIEWOFS(player);
2052
2053                                         if(ctf_CheckPassDirection(head_center, passer_center, player.v_angle, head.WarpZone_findradius_nearest))
2054                                         {
2055                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
2056                                                 {
2057                                                         if(IS_BOT_CLIENT(head))
2058                                                         {
2059                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2060                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
2061                                                         }
2062                                                         else
2063                                                         {
2064                                                                 Send_Notification(NOTIF_ONE, head, MSG_CENTER, CENTER_CTF_PASS_REQUESTED, player.netname);
2065                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2066                                                         }
2067                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
2068                                                         return true;
2069                                                 }
2070                                                 else if(player.flagcarried)
2071                                                 {
2072                                                         if(closest_target)
2073                                                         {
2074                                                                 vector closest_target_center = WarpZone_UnTransformOrigin(closest_target, CENTER_OR_VIEWOFS(closest_target));
2075                                                                 if(vlen(passer_center - head_center) < vlen(passer_center - closest_target_center))
2076                                                                         { closest_target = head; }
2077                                                         }
2078                                                         else { closest_target = head; }
2079                                                 }
2080                                         }
2081                                 }
2082                                 head = head.chain;
2083                         }
2084
2085                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return true; }
2086                 }
2087
2088                 // throw the flag in front of you
2089                 if(autocvar_g_ctf_throw && player.flagcarried)
2090                 {
2091                         if(player.throw_count == -1)
2092                         {
2093                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_delay)
2094                                 {
2095                                         player.throw_prevtime = time;
2096                                         player.throw_count = 1;
2097                                         ctf_Handle_Throw(player, world, DROP_THROW);
2098                                         return true;
2099                                 }
2100                                 else
2101                                 {
2102                                         Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_FLAG_THROW_PUNISH, rint((player.throw_prevtime + autocvar_g_ctf_throw_punish_delay) - time));
2103                                         return false;
2104                                 }
2105                         }
2106                         else
2107                         {
2108                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_time) { player.throw_count = 1; }
2109                                 else { player.throw_count += 1; }
2110                                 if(player.throw_count >= autocvar_g_ctf_throw_punish_count) { player.throw_count = -1; }
2111
2112                                 player.throw_prevtime = time;
2113                                 ctf_Handle_Throw(player, world, DROP_THROW);
2114                                 return true;
2115                         }
2116                 }
2117         }
2118
2119         return false;
2120 }
2121
2122 MUTATOR_HOOKFUNCTION(ctf_HelpMePing)
2123 {
2124         if(self.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
2125         {
2126                 self.wps_helpme_time = time;
2127                 WaypointSprite_HelpMePing(self.wps_flagcarrier);
2128         }
2129         else // create a normal help me waypointsprite
2130         {
2131                 WaypointSprite_Spawn(WP_Helpme, waypointsprite_deployed_lifetime, waypointsprite_limitedrange, self, FLAG_WAYPOINT_OFFSET, world, self.team, self, wps_helpme, false, RADARICON_HELPME);
2132                 WaypointSprite_Ping(self.wps_helpme);
2133         }
2134
2135         return true;
2136 }
2137
2138 MUTATOR_HOOKFUNCTION(ctf_VehicleEnter)
2139 {
2140         if(vh_player.flagcarried)
2141         {
2142                 vh_player.flagcarried.nodrawtoclient = vh_player; // hide the flag from the driver
2143
2144                 if(!autocvar_g_ctf_allow_vehicle_carry && !autocvar_g_ctf_allow_vehicle_touch)
2145                 {
2146                         ctf_Handle_Throw(vh_player, world, DROP_NORMAL);
2147                 }
2148                 else
2149                 {
2150                         setattachment(vh_player.flagcarried, vh_vehicle, "");
2151                         setorigin(vh_player.flagcarried, VEHICLE_FLAG_OFFSET);
2152                         vh_player.flagcarried.scale = VEHICLE_FLAG_SCALE;
2153                         //vh_player.flagcarried.angles = '0 0 0';
2154                 }
2155                 return true;
2156         }
2157
2158         return false;
2159 }
2160
2161 MUTATOR_HOOKFUNCTION(ctf_VehicleExit)
2162 {
2163         if(vh_player.flagcarried)
2164         {
2165                 setattachment(vh_player.flagcarried, vh_player, "");
2166                 setorigin(vh_player.flagcarried, FLAG_CARRY_OFFSET);
2167                 vh_player.flagcarried.scale = FLAG_SCALE;
2168                 vh_player.flagcarried.angles = '0 0 0';
2169                 vh_player.flagcarried.nodrawtoclient = world;
2170                 return true;
2171         }
2172
2173         return false;
2174 }
2175
2176 MUTATOR_HOOKFUNCTION(ctf_AbortSpeedrun)
2177 {
2178         if(self.flagcarried)
2179         {
2180                 Send_Notification(NOTIF_ALL, world, MSG_INFO, ((self.flagcarried.team) ? APP_TEAM_ENT_4(self.flagcarried, INFO_CTF_FLAGRETURN_ABORTRUN_) : INFO_CTF_FLAGRETURN_ABORTRUN_NEUTRAL));
2181                 ctf_RespawnFlag(self.flagcarried);
2182                 return true;
2183         }
2184
2185         return false;
2186 }
2187
2188 MUTATOR_HOOKFUNCTION(ctf_MatchEnd)
2189 {
2190         entity flag; // temporary entity for the search method
2191
2192         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2193         {
2194                 switch(flag.ctf_status)
2195                 {
2196                         case FLAG_DROPPED:
2197                         case FLAG_PASSING:
2198                         {
2199                                 // lock the flag, game is over
2200                                 flag.movetype = MOVETYPE_NONE;
2201                                 flag.takedamage = DAMAGE_NO;
2202                                 flag.solid = SOLID_NOT;
2203                                 flag.nextthink = false; // stop thinking
2204
2205                                 //dprint("stopping the ", flag.netname, " from moving.\n");
2206                                 break;
2207                         }
2208
2209                         default:
2210                         case FLAG_BASE:
2211                         case FLAG_CARRY:
2212                         {
2213                                 // do nothing for these flags
2214                                 break;
2215                         }
2216                 }
2217         }
2218
2219         return false;
2220 }
2221
2222 MUTATOR_HOOKFUNCTION(ctf_BotRoles)
2223 {
2224         havocbot_ctf_reset_role(self);
2225         return true;
2226 }
2227
2228 MUTATOR_HOOKFUNCTION(ctf_GetTeamCount)
2229 {
2230         //ret_float = ctf_teams;
2231         ret_string = "ctf_team";
2232         return true;
2233 }
2234
2235 MUTATOR_HOOKFUNCTION(ctf_SpectateCopy)
2236 {
2237         self.ctf_flagstatus = other.ctf_flagstatus;
2238         return false;
2239 }
2240
2241
2242 // ==========
2243 // Spawnfuncs
2244 // ==========
2245
2246 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2247 CTF flag for team one (Red).
2248 Keys:
2249 "angle" Angle the flag will point (minus 90 degrees)...
2250 "model" model to use, note this needs red and blue as skins 0 and 1...
2251 "noise" sound played when flag is picked up...
2252 "noise1" sound played when flag is returned by a teammate...
2253 "noise2" sound played when flag is captured...
2254 "noise3" sound played when flag is lost in the field and respawns itself...
2255 "noise4" sound played when flag is dropped by a player...
2256 "noise5" sound played when flag touches the ground... */
2257 void spawnfunc_item_flag_team1()
2258 {
2259         if(!g_ctf) { remove(self); return; }
2260
2261         ctf_FlagSetup(NUM_TEAM_1, self);
2262 }
2263
2264 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2265 CTF flag for team two (Blue).
2266 Keys:
2267 "angle" Angle the flag will point (minus 90 degrees)...
2268 "model" model to use, note this needs red and blue as skins 0 and 1...
2269 "noise" sound played when flag is picked up...
2270 "noise1" sound played when flag is returned by a teammate...
2271 "noise2" sound played when flag is captured...
2272 "noise3" sound played when flag is lost in the field and respawns itself...
2273 "noise4" sound played when flag is dropped by a player...
2274 "noise5" sound played when flag touches the ground... */
2275 void spawnfunc_item_flag_team2()
2276 {
2277         if(!g_ctf) { remove(self); return; }
2278
2279         ctf_FlagSetup(NUM_TEAM_2, self);
2280 }
2281
2282 /*QUAKED spawnfunc_item_flag_team3 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2283 CTF flag for team three (Yellow).
2284 Keys:
2285 "angle" Angle the flag will point (minus 90 degrees)...
2286 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2287 "noise" sound played when flag is picked up...
2288 "noise1" sound played when flag is returned by a teammate...
2289 "noise2" sound played when flag is captured...
2290 "noise3" sound played when flag is lost in the field and respawns itself...
2291 "noise4" sound played when flag is dropped by a player...
2292 "noise5" sound played when flag touches the ground... */
2293 void spawnfunc_item_flag_team3()
2294 {
2295         if(!g_ctf) { remove(self); return; }
2296
2297         ctf_FlagSetup(NUM_TEAM_3, self);
2298 }
2299
2300 /*QUAKED spawnfunc_item_flag_team4 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2301 CTF flag for team four (Pink).
2302 Keys:
2303 "angle" Angle the flag will point (minus 90 degrees)...
2304 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2305 "noise" sound played when flag is picked up...
2306 "noise1" sound played when flag is returned by a teammate...
2307 "noise2" sound played when flag is captured...
2308 "noise3" sound played when flag is lost in the field and respawns itself...
2309 "noise4" sound played when flag is dropped by a player...
2310 "noise5" sound played when flag touches the ground... */
2311 void spawnfunc_item_flag_team4()
2312 {
2313         if(!g_ctf) { remove(self); return; }
2314
2315         ctf_FlagSetup(NUM_TEAM_4, self);
2316 }
2317
2318 /*QUAKED spawnfunc_item_flag_neutral (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2319 CTF flag (Neutral).
2320 Keys:
2321 "angle" Angle the flag will point (minus 90 degrees)...
2322 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2323 "noise" sound played when flag is picked up...
2324 "noise1" sound played when flag is returned by a teammate...
2325 "noise2" sound played when flag is captured...
2326 "noise3" sound played when flag is lost in the field and respawns itself...
2327 "noise4" sound played when flag is dropped by a player...
2328 "noise5" sound played when flag touches the ground... */
2329 void spawnfunc_item_flag_neutral()
2330 {
2331         if(!g_ctf) { remove(self); return; }
2332         if(!cvar("g_ctf_oneflag")) { remove(self); return; }
2333
2334         ctf_FlagSetup(0, self);
2335 }
2336
2337 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
2338 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
2339 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.
2340 Keys:
2341 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
2342 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
2343 void spawnfunc_ctf_team()
2344 {
2345         if(!g_ctf) { remove(self); return; }
2346
2347         self.classname = "ctf_team";
2348         self.team = self.cnt + 1;
2349 }
2350
2351 // compatibility for quake maps
2352 void spawnfunc_team_CTF_redflag()    { spawnfunc_item_flag_team1();    }
2353 void spawnfunc_team_CTF_blueflag()   { spawnfunc_item_flag_team2();    }
2354 void spawnfunc_team_CTF_redplayer()  { spawnfunc_info_player_team1();  }
2355 void spawnfunc_team_CTF_blueplayer() { spawnfunc_info_player_team2();  }
2356 void spawnfunc_team_CTF_redspawn()   { spawnfunc_info_player_team1();  }
2357 void spawnfunc_team_CTF_bluespawn()  { spawnfunc_info_player_team2();  }
2358
2359 void team_CTF_neutralflag()                      { spawnfunc_item_flag_neutral();  }
2360 void team_neutralobelisk()                       { spawnfunc_item_flag_neutral();  }
2361
2362
2363 // ==============
2364 // Initialization
2365 // ==============
2366
2367 // scoreboard setup
2368 void ctf_ScoreRules(int teams)
2369 {
2370         CheckAllowedTeams(world);
2371         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
2372         ScoreInfo_SetLabel_TeamScore  (ST_CTF_CAPS,     "caps",      SFL_SORT_PRIO_PRIMARY);
2373         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPS,     "caps",      SFL_SORT_PRIO_SECONDARY);
2374         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPTIME,  "captime",   SFL_LOWER_IS_BETTER | SFL_TIME);
2375         ScoreInfo_SetLabel_PlayerScore(SP_CTF_PICKUPS,  "pickups",   0);
2376         ScoreInfo_SetLabel_PlayerScore(SP_CTF_FCKILLS,  "fckills",   0);
2377         ScoreInfo_SetLabel_PlayerScore(SP_CTF_RETURNS,  "returns",   0);
2378         ScoreInfo_SetLabel_PlayerScore(SP_CTF_DROPS,    "drops",     SFL_LOWER_IS_BETTER);
2379         ScoreRules_basics_end();
2380 }
2381
2382 // code from here on is just to support maps that don't have flag and team entities
2383 void ctf_SpawnTeam (string teamname, int teamcolor)
2384 {
2385         entity oldself;
2386         oldself = self;
2387         self = spawn();
2388         self.classname = "ctf_team";
2389         self.netname = teamname;
2390         self.cnt = teamcolor;
2391
2392         spawnfunc_ctf_team();
2393
2394         self = oldself;
2395 }
2396
2397 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
2398 {
2399         ctf_teams = 2;
2400
2401         entity tmp_entity;
2402         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
2403         {
2404                 if(tmp_entity.team == NUM_TEAM_3) { ctf_teams = max(3, ctf_teams); }
2405                 if(tmp_entity.team == NUM_TEAM_4) { ctf_teams = max(4, ctf_teams); }
2406                 if(tmp_entity.team == 0) { ctf_oneflag = true; }
2407         }
2408
2409         ctf_teams = bound(2, ctf_teams, 4);
2410
2411         // if no teams are found, spawn defaults
2412         if(find(world, classname, "ctf_team") == world)
2413         {
2414                 LOG_INFO("No ""ctf_team"" entities found on this map, creating them anyway.\n");
2415                 ctf_SpawnTeam("Red", NUM_TEAM_1 - 1);
2416                 ctf_SpawnTeam("Blue", NUM_TEAM_2 - 1);
2417                 if(ctf_teams >= 3)
2418                         ctf_SpawnTeam("Yellow", NUM_TEAM_3 - 1);
2419                 if(ctf_teams >= 4)
2420                         ctf_SpawnTeam("Pink", NUM_TEAM_4 - 1);
2421         }
2422
2423         ctf_ScoreRules(ctf_teams);
2424 }
2425
2426 void ctf_Initialize()
2427 {
2428         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
2429
2430         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
2431         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
2432         ctf_captureshield_force = autocvar_g_ctf_shield_force;
2433
2434         addstat(STAT_CTF_FLAGSTATUS, AS_INT, ctf_flagstatus);
2435
2436         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
2437 }
2438
2439
2440 MUTATOR_DEFINITION(gamemode_ctf)
2441 {
2442         MUTATOR_HOOK(MakePlayerObserver, ctf_RemovePlayer, CBC_ORDER_ANY);
2443         MUTATOR_HOOK(ClientDisconnect, ctf_RemovePlayer, CBC_ORDER_ANY);
2444         MUTATOR_HOOK(PlayerDies, ctf_PlayerDies, CBC_ORDER_ANY);
2445         MUTATOR_HOOK(MatchEnd, ctf_MatchEnd, CBC_ORDER_ANY);
2446         MUTATOR_HOOK(PortalTeleport, ctf_PortalTeleport, CBC_ORDER_ANY);
2447         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
2448         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
2449         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
2450         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
2451         MUTATOR_HOOK(HelpMePing, ctf_HelpMePing, CBC_ORDER_ANY);
2452         MUTATOR_HOOK(VehicleEnter, ctf_VehicleEnter, CBC_ORDER_ANY);
2453         MUTATOR_HOOK(VehicleExit, ctf_VehicleExit, CBC_ORDER_ANY);
2454         MUTATOR_HOOK(AbortSpeedrun, ctf_AbortSpeedrun, CBC_ORDER_ANY);
2455         MUTATOR_HOOK(HavocBot_ChooseRole, ctf_BotRoles, CBC_ORDER_ANY);
2456         MUTATOR_HOOK(GetTeamCount, ctf_GetTeamCount, CBC_ORDER_ANY);
2457         MUTATOR_HOOK(SpectateCopy, ctf_SpectateCopy, CBC_ORDER_ANY);
2458
2459         MUTATOR_ONADD
2460         {
2461                 if(time > 1) // game loads at time 1
2462                         error("This is a game type and it cannot be added at runtime.");
2463                 ctf_Initialize();
2464         }
2465
2466         MUTATOR_ONROLLBACK_OR_REMOVE
2467         {
2468                 // we actually cannot roll back ctf_Initialize here
2469                 // BUT: we don't need to! If this gets called, adding always
2470                 // succeeds.
2471         }
2472
2473         MUTATOR_ONREMOVE
2474         {
2475                 LOG_INFO("This is a game type and it cannot be removed at runtime.");
2476                 return -1;
2477         }
2478
2479         return 0;
2480 }