qcsrc/server/mutators/mutator/gamemode_ctf.qc

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