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