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, CTF_FLAG.m_maxs);
 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, CTF_FLAG.m_maxs);
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
2059         // initially clear items so they can be set as necessary later.
2060         player.ctf_flagstatus &= ~(CTF_RED_FLAG_CARRYING                | CTF_RED_FLAG_TAKEN            | CTF_RED_FLAG_LOST
2061                                                    | CTF_BLUE_FLAG_CARRYING             | CTF_BLUE_FLAG_TAKEN           | CTF_BLUE_FLAG_LOST
2062                                                    | CTF_YELLOW_FLAG_CARRYING   | CTF_YELLOW_FLAG_TAKEN         | CTF_YELLOW_FLAG_LOST
2063                                                    | CTF_PINK_FLAG_CARRYING     | CTF_PINK_FLAG_TAKEN           | CTF_PINK_FLAG_LOST
2064                                                    | CTF_NEUTRAL_FLAG_CARRYING  | CTF_NEUTRAL_FLAG_TAKEN        | CTF_NEUTRAL_FLAG_LOST
2065                                                    | CTF_FLAG_NEUTRAL | CTF_SHIELDED | CTF_STALEMATE);
2066
2067         // scan through all the flags and notify the client about them
2068         for(entity flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2069         {
2070                 if(flag.team == NUM_TEAM_1) { t = CTF_RED_FLAG_CARRYING;                t2 = CTF_RED_FLAG_TAKEN;                t3 = CTF_RED_FLAG_LOST; }
2071                 if(flag.team == NUM_TEAM_2) { t = CTF_BLUE_FLAG_CARRYING;               t2 = CTF_BLUE_FLAG_TAKEN;               t3 = CTF_BLUE_FLAG_LOST; }
2072                 if(flag.team == NUM_TEAM_3) { t = CTF_YELLOW_FLAG_CARRYING;     t2 = CTF_YELLOW_FLAG_TAKEN;             t3 = CTF_YELLOW_FLAG_LOST; }
2073                 if(flag.team == NUM_TEAM_4) { t = CTF_PINK_FLAG_CARRYING;               t2 = CTF_PINK_FLAG_TAKEN;               t3 = CTF_PINK_FLAG_LOST; }
2074                 if(flag.team == 0)                      { t = CTF_NEUTRAL_FLAG_CARRYING;        t2 = CTF_NEUTRAL_FLAG_TAKEN;    t3 = CTF_NEUTRAL_FLAG_LOST; player.ctf_flagstatus |= CTF_FLAG_NEUTRAL; }
2075
2076                 switch(flag.ctf_status)
2077                 {
2078                         case FLAG_PASSING:
2079                         case FLAG_CARRY:
2080                         {
2081                                 if((flag.owner == player) || (flag.pass_sender == player))
2082                                         player.ctf_flagstatus |= t; // carrying: player is currently carrying the flag
2083                                 else
2084                                         player.ctf_flagstatus |= t2; // taken: someone else is carrying the flag
2085                                 break;
2086                         }
2087                         case FLAG_DROPPED:
2088                         {
2089                                 player.ctf_flagstatus |= t3; // lost: the flag is dropped somewhere on the map
2090                                 break;
2091                         }
2092                 }
2093         }
2094
2095         // item for stopping players from capturing the flag too often
2096         if(player.ctf_captureshielded)
2097                 player.ctf_flagstatus |= CTF_SHIELDED;
2098
2099         if(ctf_stalemate)
2100                 player.ctf_flagstatus |= CTF_STALEMATE;
2101
2102         // update the health of the flag carrier waypointsprite
2103         if(player.wps_flagcarrier)
2104                 WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON.m_id));
2105 }
2106
2107 MUTATOR_HOOKFUNCTION(ctf, Damage_Calculate) // for changing damage and force values that are applied to players in g_damage.qc
2108 {
2109         entity frag_attacker = M_ARGV(1, entity);
2110         entity frag_target = M_ARGV(2, entity);
2111         float frag_damage = M_ARGV(4, float);
2112         vector frag_force = M_ARGV(6, vector);
2113
2114         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
2115         {
2116                 if(frag_target == frag_attacker) // damage done to yourself
2117                 {
2118                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
2119                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
2120                 }
2121                 else // damage done to everyone else
2122                 {
2123                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
2124                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
2125                 }
2126
2127                 M_ARGV(4, float) = frag_damage;
2128                 M_ARGV(6, vector) = frag_force;
2129         }
2130         else if(frag_target.flagcarried && !IS_DEAD(frag_target) && CTF_DIFFTEAM(frag_target, frag_attacker)) // if the target is a flagcarrier
2131         {
2132                 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)))
2133                 if(time > frag_target.wps_helpme_time + autocvar_g_ctf_flagcarrier_auto_helpme_time)
2134                 {
2135                         frag_target.wps_helpme_time = time;
2136                         WaypointSprite_HelpMePing(frag_target.wps_flagcarrier);
2137                 }
2138                 // todo: add notification for when flag carrier needs help?
2139         }
2140 }
2141
2142 MUTATOR_HOOKFUNCTION(ctf, PlayerDies)
2143 {
2144         entity frag_attacker = M_ARGV(1, entity);
2145         entity frag_target = M_ARGV(2, entity);
2146
2147         if((frag_attacker != frag_target) && (IS_PLAYER(frag_attacker)) && (frag_target.flagcarried))
2148         {
2149                 PlayerTeamScore_AddScore(frag_attacker, ((SAME_TEAM(frag_attacker, frag_target)) ? -autocvar_g_ctf_score_kill : autocvar_g_ctf_score_kill));
2150                 PlayerScore_Add(frag_attacker, SP_CTF_FCKILLS, 1);
2151         }
2152
2153         if(frag_target.flagcarried)
2154         {
2155                 entity tmp_entity = frag_target.flagcarried;
2156                 ctf_Handle_Throw(frag_target, NULL, DROP_NORMAL);
2157                 tmp_entity.ctf_dropper = NULL;
2158         }
2159 }
2160
2161 MUTATOR_HOOKFUNCTION(ctf, GiveFragsForKill)
2162 {
2163         M_ARGV(2, float) = 0; // frag score
2164         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
2165 }
2166
2167 void ctf_RemovePlayer(entity player)
2168 {
2169         if(player.flagcarried)
2170                 { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }
2171
2172         for(entity flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2173         {
2174                 if(flag.pass_sender == player) { flag.pass_sender = NULL; }
2175                 if(flag.pass_target == player) { flag.pass_target = NULL; }
2176                 if(flag.ctf_dropper == player) { flag.ctf_dropper = NULL; }
2177         }
2178 }
2179
2180 MUTATOR_HOOKFUNCTION(ctf, MakePlayerObserver)
2181 {
2182         entity player = M_ARGV(0, entity);
2183
2184         ctf_RemovePlayer(player);
2185 }
2186
2187 MUTATOR_HOOKFUNCTION(ctf, ClientDisconnect)
2188 {
2189         entity player = M_ARGV(0, entity);
2190
2191         ctf_RemovePlayer(player);
2192 }
2193
2194 MUTATOR_HOOKFUNCTION(ctf, ClientConnect)
2195 {
2196         if(!autocvar_g_ctf_leaderboard)
2197                 return;
2198
2199         entity player = M_ARGV(0, entity);
2200
2201         if(IS_REAL_CLIENT(player))
2202         {
2203                 for(int i = 1; i <= RANKINGS_CNT; ++i)
2204                 {
2205                         race_SendRankings(i, 0, 0, MSG_ONE);
2206                 }
2207         }
2208 }
2209
2210 MUTATOR_HOOKFUNCTION(ctf, GetPressedKeys)
2211 {
2212         if(!autocvar_g_ctf_leaderboard)
2213                 return;
2214
2215         entity player = M_ARGV(0, entity);
2216
2217         if(player.cvar_cl_allow_uidtracking == 1 && player.cvar_cl_allow_uid2name == 1)
2218         {
2219                 if (!player.stored_netname)
2220                         player.stored_netname = strzone(uid2name(player.crypto_idfp));
2221                 if(player.stored_netname != player.netname)
2222                 {
2223                         db_put(ServerProgsDB, strcat("/uid2name/", player.crypto_idfp), player.netname);
2224                         strunzone(player.stored_netname);
2225                         player.stored_netname = strzone(player.netname);
2226                 }
2227         }
2228 }
2229
2230 MUTATOR_HOOKFUNCTION(ctf, PortalTeleport)
2231 {
2232         entity player = M_ARGV(0, entity);
2233
2234         if(player.flagcarried)
2235         if(!autocvar_g_ctf_portalteleport)
2236                 { ctf_Handle_Throw(player, NULL, DROP_NORMAL); }
2237 }
2238
2239 MUTATOR_HOOKFUNCTION(ctf, PlayerUseKey)
2240 {
2241         if(MUTATOR_RETURNVALUE || game_stopped) return;
2242
2243         entity player = M_ARGV(0, entity);
2244
2245         if((time > player.throw_antispam) && !IS_DEAD(player) && !player.speedrunning && (!player.vehicle || autocvar_g_ctf_allow_vehicle_touch))
2246         {
2247                 // pass the flag to a team mate
2248                 if(autocvar_g_ctf_pass)
2249                 {
2250                         entity head, closest_target = NULL;
2251                         head = WarpZone_FindRadius(player.origin, autocvar_g_ctf_pass_radius, true);
2252
2253                         while(head) // find the closest acceptable target to pass to
2254                         {
2255                                 if(IS_PLAYER(head) && !IS_DEAD(head))
2256                                 if(head != player && SAME_TEAM(head, player))
2257                                 if(!head.speedrunning && !head.vehicle)
2258                                 {
2259                                         // if it's a player, use the view origin as reference (stolen from RadiusDamage functions in g_damage.qc)
2260                                         vector head_center = WarpZone_UnTransformOrigin(head, CENTER_OR_VIEWOFS(head));
2261                                         vector passer_center = CENTER_OR_VIEWOFS(player);
2262
2263                                         if(ctf_CheckPassDirection(head_center, passer_center, player.v_angle, head.WarpZone_findradius_nearest))
2264                                         {
2265                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
2266                                                 {
2267                                                         if(IS_BOT_CLIENT(head))
2268                                                         {
2269                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2270                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
2271                                                         }
2272                                                         else
2273                                                         {
2274                                                                 Send_Notification(NOTIF_ONE, head, MSG_CENTER, CENTER_CTF_PASS_REQUESTED, player.netname);
2275                                                                 Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_PASS_REQUESTING, head.netname);
2276                                                         }
2277                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
2278                                                         return true;
2279                                                 }
2280                                                 else if(player.flagcarried && !head.flagcarried)
2281                                                 {
2282                                                         if(closest_target)
2283                                                         {
2284                                                                 vector closest_target_center = WarpZone_UnTransformOrigin(closest_target, CENTER_OR_VIEWOFS(closest_target));
2285                                                                 if(vlen2(passer_center - head_center) < vlen2(passer_center - closest_target_center))
2286                                                                         { closest_target = head; }
2287                                                         }
2288                                                         else { closest_target = head; }
2289                                                 }
2290                                         }
2291                                 }
2292                                 head = head.chain;
2293                         }
2294
2295                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return true; }
2296                 }
2297
2298                 // throw the flag in front of you
2299                 if(autocvar_g_ctf_throw && player.flagcarried)
2300                 {
2301                         if(player.throw_count == -1)
2302                         {
2303                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_delay)
2304                                 {
2305                                         player.throw_prevtime = time;
2306                                         player.throw_count = 1;
2307                                         ctf_Handle_Throw(player, NULL, DROP_THROW);
2308                                         return true;
2309                                 }
2310                                 else
2311                                 {
2312                                         Send_Notification(NOTIF_ONE, player, MSG_CENTER, CENTER_CTF_FLAG_THROW_PUNISH, rint((player.throw_prevtime + autocvar_g_ctf_throw_punish_delay) - time));
2313                                         return false;
2314                                 }
2315                         }
2316                         else
2317                         {
2318                                 if(time > player.throw_prevtime + autocvar_g_ctf_throw_punish_time) { player.throw_count = 1; }
2319                                 else { player.throw_count += 1; }
2320                                 if(player.throw_count >= autocvar_g_ctf_throw_punish_count) { player.throw_count = -1; }
2321
2322                                 player.throw_prevtime = time;
2323                                 ctf_Handle_Throw(player, NULL, DROP_THROW);
2324                                 return true;
2325                         }
2326                 }
2327         }
2328 }
2329
2330 MUTATOR_HOOKFUNCTION(ctf, HelpMePing)
2331 {
2332         entity player = M_ARGV(0, entity);
2333
2334         if(player.wps_flagcarrier) // update the flagcarrier waypointsprite with "NEEDING HELP" notification
2335         {
2336                 player.wps_helpme_time = time;
2337                 WaypointSprite_HelpMePing(player.wps_flagcarrier);
2338         }
2339         else // create a normal help me waypointsprite
2340         {
2341                 WaypointSprite_Spawn(WP_Helpme, waypointsprite_deployed_lifetime, waypointsprite_limitedrange, player, FLAG_WAYPOINT_OFFSET, NULL, player.team, player, wps_helpme, false, RADARICON_HELPME);
2342                 WaypointSprite_Ping(player.wps_helpme);
2343         }
2344
2345         return true;
2346 }
2347
2348 MUTATOR_HOOKFUNCTION(ctf, VehicleEnter)
2349 {
2350         entity player = M_ARGV(0, entity);
2351         entity veh = M_ARGV(1, entity);
2352
2353         if(player.flagcarried)
2354         {
2355                 if(!autocvar_g_ctf_allow_vehicle_carry && !autocvar_g_ctf_allow_vehicle_touch)
2356                 {
2357                         ctf_Handle_Throw(player, NULL, DROP_NORMAL);
2358                 }
2359                 else
2360                 {
2361                         player.flagcarried.nodrawtoclient = player; // hide the flag from the driver
2362                         setattachment(player.flagcarried, veh, "");
2363                         setorigin(player.flagcarried, VEHICLE_FLAG_OFFSET);
2364                         player.flagcarried.scale = VEHICLE_FLAG_SCALE;
2365                         //player.flagcarried.angles = '0 0 0';
2366                 }
2367                 return true;
2368         }
2369 }
2370
2371 MUTATOR_HOOKFUNCTION(ctf, VehicleExit)
2372 {
2373         entity player = M_ARGV(0, entity);
2374
2375         if(player.flagcarried)
2376         {
2377                 setattachment(player.flagcarried, player, "");
2378                 setorigin(player.flagcarried, FLAG_CARRY_OFFSET);
2379                 player.flagcarried.scale = FLAG_SCALE;
2380                 player.flagcarried.angles = '0 0 0';
2381                 player.flagcarried.nodrawtoclient = NULL;
2382                 return true;
2383         }
2384 }
2385
2386 MUTATOR_HOOKFUNCTION(ctf, AbortSpeedrun)
2387 {
2388         entity player = M_ARGV(0, entity);
2389
2390         if(player.flagcarried)
2391         {
2392                 Send_Notification(NOTIF_ALL, NULL, MSG_INFO, APP_NUM(player.flagcarried.team, INFO_CTF_FLAGRETURN_ABORTRUN));
2393                 ctf_RespawnFlag(player.flagcarried);
2394                 return true;
2395         }
2396 }
2397
2398 MUTATOR_HOOKFUNCTION(ctf, MatchEnd)
2399 {
2400         entity flag; // temporary entity for the search method
2401
2402         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
2403         {
2404                 switch(flag.ctf_status)
2405                 {
2406                         case FLAG_DROPPED:
2407                         case FLAG_PASSING:
2408                         {
2409                                 // lock the flag, game is over
2410                                 set_movetype(flag, MOVETYPE_NONE);
2411                                 flag.takedamage = DAMAGE_NO;
2412                                 flag.solid = SOLID_NOT;
2413                                 flag.nextthink = false; // stop thinking
2414
2415                                 //dprint("stopping the ", flag.netname, " from moving.\n");
2416                                 break;
2417                         }
2418
2419                         default:
2420                         case FLAG_BASE:
2421                         case FLAG_CARRY:
2422                         {
2423                                 // do nothing for these flags
2424                                 break;
2425                         }
2426                 }
2427         }
2428 }
2429
2430 MUTATOR_HOOKFUNCTION(ctf, HavocBot_ChooseRole)
2431 {
2432         entity bot = M_ARGV(0, entity);
2433
2434         havocbot_ctf_reset_role(bot);
2435         return true;
2436 }
2437
2438 MUTATOR_HOOKFUNCTION(ctf, CheckAllowedTeams)
2439 {
2440         //M_ARGV(0, float) = ctf_teams;
2441         M_ARGV(1, string) = "ctf_team";
2442         return true;
2443 }
2444
2445 MUTATOR_HOOKFUNCTION(ctf, SpectateCopy)
2446 {
2447         entity spectatee = M_ARGV(0, entity);
2448         entity client = M_ARGV(1, entity);
2449
2450         client.ctf_flagstatus = spectatee.ctf_flagstatus;
2451 }
2452
2453 MUTATOR_HOOKFUNCTION(ctf, GetRecords)
2454 {
2455         int record_page = M_ARGV(0, int);
2456         string ret_string = M_ARGV(1, string);
2457
2458         for(int i = record_page * 200; i < MapInfo_count && i < record_page * 200 + 200; ++i)
2459         {
2460                 if (MapInfo_Get_ByID(i))
2461                 {
2462                         float r = stof(db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/time")));
2463
2464                         if(!r)
2465                                 continue;
2466
2467                         // TODO: uid2name
2468                         string h = db_get(ServerProgsDB, strcat(MapInfo_Map_bspname, "/captimerecord/netname"));
2469                         ret_string = strcat(ret_string, strpad(32, MapInfo_Map_bspname), " ", strpad(-6, ftos_decimals(r, 2)), " ", h, "\n");
2470                 }
2471         }
2472
2473         M_ARGV(1, string) = ret_string;
2474 }
2475
2476 bool superspec_Spectate(entity this, entity targ); // TODO
2477 void superspec_msg(string _center_title, string _con_title, entity _to, string _msg, float _spamlevel); // TODO
2478 MUTATOR_HOOKFUNCTION(ctf, SV_ParseClientCommand)
2479 {
2480         entity player = M_ARGV(0, entity);
2481         string cmd_name = M_ARGV(1, string);
2482         int cmd_argc = M_ARGV(2, int);
2483
2484         if(IS_PLAYER(player) || MUTATOR_RETURNVALUE || !cvar("g_superspectate")) { return false; }
2485
2486         if(cmd_name == "followfc")
2487         {
2488                 if(!g_ctf)
2489                         return true;
2490
2491                 int _team = 0;
2492                 bool found = false;
2493
2494                 if(cmd_argc == 2)
2495                 {
2496                         switch(argv(1))
2497                         {
2498                                 case "red":    if(ctf_teams & BIT(0)) _team = NUM_TEAM_1; break;
2499                                 case "blue":   if(ctf_teams & BIT(1)) _team = NUM_TEAM_2; break;
2500                                 case "yellow": if(ctf_teams & BIT(2)) _team = NUM_TEAM_3; break;
2501                                 case "pink":   if(ctf_teams & BIT(3)) _team = NUM_TEAM_4; break;
2502                         }
2503                 }
2504
2505                 FOREACH_CLIENT(IS_PLAYER(it), LAMBDA(
2506                         if(it.flagcarried && (it.team == _team || _team == 0))
2507                         {
2508                                 found = true;
2509                                 if(_team == 0 && IS_SPEC(player) && player.enemy == it)
2510                                         continue; // already spectating this fc, try another
2511                                 return superspec_Spectate(player, it);
2512                         }
2513                 ));
2514
2515                 if(!found)
2516                         superspec_msg("", "", player, "No active flag carrier\n", 1);
2517                 return true;
2518         }
2519 }
2520
2521 MUTATOR_HOOKFUNCTION(ctf, DropSpecialItems)
2522 {
2523         entity frag_target = M_ARGV(0, entity);
2524
2525         if(frag_target.flagcarried)
2526                 ctf_Handle_Throw(frag_target, NULL, DROP_THROW);
2527 }
2528
2529
2530 // ==========
2531 // Spawnfuncs
2532 // ==========
2533
2534 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2535 CTF flag for team one (Red).
2536 Keys:
2537 "angle" Angle the flag will point (minus 90 degrees)...
2538 "model" model to use, note this needs red and blue as skins 0 and 1...
2539 "noise" sound played when flag is picked up...
2540 "noise1" sound played when flag is returned by a teammate...
2541 "noise2" sound played when flag is captured...
2542 "noise3" sound played when flag is lost in the field and respawns itself...
2543 "noise4" sound played when flag is dropped by a player...
2544 "noise5" sound played when flag touches the ground... */
2545 spawnfunc(item_flag_team1)
2546 {
2547         if(!g_ctf) { delete(this); return; }
2548
2549         ctf_FlagSetup(NUM_TEAM_1, this);
2550 }
2551
2552 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2553 CTF flag for team two (Blue).
2554 Keys:
2555 "angle" Angle the flag will point (minus 90 degrees)...
2556 "model" model to use, note this needs red and blue as skins 0 and 1...
2557 "noise" sound played when flag is picked up...
2558 "noise1" sound played when flag is returned by a teammate...
2559 "noise2" sound played when flag is captured...
2560 "noise3" sound played when flag is lost in the field and respawns itself...
2561 "noise4" sound played when flag is dropped by a player...
2562 "noise5" sound played when flag touches the ground... */
2563 spawnfunc(item_flag_team2)
2564 {
2565         if(!g_ctf) { delete(this); return; }
2566
2567         ctf_FlagSetup(NUM_TEAM_2, this);
2568 }
2569
2570 /*QUAKED spawnfunc_item_flag_team3 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2571 CTF flag for team three (Yellow).
2572 Keys:
2573 "angle" Angle the flag will point (minus 90 degrees)...
2574 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2575 "noise" sound played when flag is picked up...
2576 "noise1" sound played when flag is returned by a teammate...
2577 "noise2" sound played when flag is captured...
2578 "noise3" sound played when flag is lost in the field and respawns itself...
2579 "noise4" sound played when flag is dropped by a player...
2580 "noise5" sound played when flag touches the ground... */
2581 spawnfunc(item_flag_team3)
2582 {
2583         if(!g_ctf) { delete(this); return; }
2584
2585         ctf_FlagSetup(NUM_TEAM_3, this);
2586 }
2587
2588 /*QUAKED spawnfunc_item_flag_team4 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2589 CTF flag for team four (Pink).
2590 Keys:
2591 "angle" Angle the flag will point (minus 90 degrees)...
2592 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2593 "noise" sound played when flag is picked up...
2594 "noise1" sound played when flag is returned by a teammate...
2595 "noise2" sound played when flag is captured...
2596 "noise3" sound played when flag is lost in the field and respawns itself...
2597 "noise4" sound played when flag is dropped by a player...
2598 "noise5" sound played when flag touches the ground... */
2599 spawnfunc(item_flag_team4)
2600 {
2601         if(!g_ctf) { delete(this); return; }
2602
2603         ctf_FlagSetup(NUM_TEAM_4, this);
2604 }
2605
2606 /*QUAKED spawnfunc_item_flag_neutral (0 0.5 0.8) (-48 -48 -37) (48 48 37)
2607 CTF flag (Neutral).
2608 Keys:
2609 "angle" Angle the flag will point (minus 90 degrees)...
2610 "model" model to use, note this needs red, blue yellow and pink as skins 0, 1, 2 and 3...
2611 "noise" sound played when flag is picked up...
2612 "noise1" sound played when flag is returned by a teammate...
2613 "noise2" sound played when flag is captured...
2614 "noise3" sound played when flag is lost in the field and respawns itself...
2615 "noise4" sound played when flag is dropped by a player...
2616 "noise5" sound played when flag touches the ground... */
2617 spawnfunc(item_flag_neutral)
2618 {
2619         if(!g_ctf) { delete(this); return; }
2620         if(!cvar("g_ctf_oneflag")) { delete(this); return; }
2621
2622         ctf_FlagSetup(0, this);
2623 }
2624
2625 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
2626 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
2627 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.
2628 Keys:
2629 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
2630 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
2631 spawnfunc(ctf_team)
2632 {
2633         if(!g_ctf) { delete(this); return; }
2634
2635         this.classname = "ctf_team";
2636         this.team = this.cnt + 1;
2637 }
2638
2639 // compatibility for quake maps
2640 spawnfunc(team_CTF_redflag)    { spawnfunc_item_flag_team1(this);    }
2641 spawnfunc(team_CTF_blueflag)   { spawnfunc_item_flag_team2(this);    }
2642 spawnfunc(info_player_team1);
2643 spawnfunc(team_CTF_redplayer)  { spawnfunc_info_player_team1(this);  }
2644 spawnfunc(team_CTF_redspawn)   { spawnfunc_info_player_team1(this);  }
2645 spawnfunc(info_player_team2);
2646 spawnfunc(team_CTF_blueplayer) { spawnfunc_info_player_team2(this);  }
2647 spawnfunc(team_CTF_bluespawn)  { spawnfunc_info_player_team2(this);  }
2648
2649 spawnfunc(team_CTF_neutralflag) { spawnfunc_item_flag_neutral(this);  }
2650 spawnfunc(team_neutralobelisk)  { spawnfunc_item_flag_neutral(this);  }
2651
2652 // compatibility for wop maps
2653 spawnfunc(team_redplayer)      { spawnfunc_info_player_team1(this);  }
2654 spawnfunc(team_blueplayer)     { spawnfunc_info_player_team2(this);  }
2655 spawnfunc(team_ctl_redlolly)   { spawnfunc_item_flag_team1(this);    }
2656 spawnfunc(team_CTL_redlolly)   { spawnfunc_item_flag_team1(this);    }
2657 spawnfunc(team_ctl_bluelolly)  { spawnfunc_item_flag_team2(this);    }
2658 spawnfunc(team_CTL_bluelolly)  { spawnfunc_item_flag_team2(this);    }
2659
2660
2661 // ==============
2662 // Initialization
2663 // ==============
2664
2665 // scoreboard setup
2666 void ctf_ScoreRules(int teams)
2667 {
2668         CheckAllowedTeams(NULL);
2669         ScoreRules_basics(teams, SFL_SORT_PRIO_PRIMARY, 0, true);
2670         ScoreInfo_SetLabel_TeamScore  (ST_CTF_CAPS,     "caps",      SFL_SORT_PRIO_PRIMARY);
2671         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPS,    "caps",      SFL_SORT_PRIO_SECONDARY);
2672         ScoreInfo_SetLabel_PlayerScore(SP_CTF_CAPTIME, "captime",   SFL_LOWER_IS_BETTER | SFL_TIME);
2673         ScoreInfo_SetLabel_PlayerScore(SP_CTF_PICKUPS, "pickups",   0);
2674         ScoreInfo_SetLabel_PlayerScore(SP_CTF_FCKILLS, "fckills",   0);
2675         ScoreInfo_SetLabel_PlayerScore(SP_CTF_RETURNS, "returns",   0);
2676         ScoreInfo_SetLabel_PlayerScore(SP_CTF_DROPS,   "drops",     SFL_LOWER_IS_BETTER);
2677         ScoreRules_basics_end();
2678 }
2679
2680 // code from here on is just to support maps that don't have flag and team entities
2681 void ctf_SpawnTeam (string teamname, int teamcolor)
2682 {
2683         entity this = new_pure(ctf_team);
2684         this.netname = teamname;
2685         this.cnt = teamcolor - 1;
2686         this.spawnfunc_checked = true;
2687         this.team = teamcolor;
2688 }
2689
2690 void ctf_DelayedInit(entity this) // Do this check with a delay so we can wait for teams to be set up.
2691 {
2692         ctf_teams = 0;
2693
2694         entity tmp_entity;
2695         for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
2696         {
2697                 //if(tmp_entity.team == NUM_TEAM_3) { ctf_teams = max(3, ctf_teams); }
2698                 //if(tmp_entity.team == NUM_TEAM_4) { ctf_teams = max(4, ctf_teams); }
2699
2700                 switch(tmp_entity.team)
2701                 {
2702                         case NUM_TEAM_1: BITSET_ASSIGN(ctf_teams, BIT(0)); break;
2703                         case NUM_TEAM_2: BITSET_ASSIGN(ctf_teams, BIT(1)); break;
2704                         case NUM_TEAM_3: BITSET_ASSIGN(ctf_teams, BIT(2)); break;
2705                         case NUM_TEAM_4: BITSET_ASSIGN(ctf_teams, BIT(3)); break;
2706                 }
2707                 if(tmp_entity.team == 0) { ctf_oneflag = true; }
2708         }
2709
2710         if(NumTeams(ctf_teams) < 2) // somehow, there's not enough flags!
2711         {
2712                 ctf_teams = 0; // so set the default red and blue teams
2713                 BITSET_ASSIGN(ctf_teams, BIT(0));
2714                 BITSET_ASSIGN(ctf_teams, BIT(1));
2715         }
2716
2717         //ctf_teams = bound(2, ctf_teams, 4);
2718
2719         // if no teams are found, spawn defaults
2720         if(find(NULL, classname, "ctf_team") == NULL)
2721         {
2722                 LOG_TRACE("No \"ctf_team\" entities found on this map, creating them anyway.");
2723                 if(ctf_teams & BIT(0))
2724                         ctf_SpawnTeam("Red", NUM_TEAM_1);
2725                 if(ctf_teams & BIT(1))
2726                         ctf_SpawnTeam("Blue", NUM_TEAM_2);
2727                 if(ctf_teams & BIT(2))
2728                         ctf_SpawnTeam("Yellow", NUM_TEAM_3);
2729                 if(ctf_teams & BIT(3))
2730                         ctf_SpawnTeam("Pink", NUM_TEAM_4);
2731         }
2732
2733         ctf_ScoreRules(ctf_teams);
2734 }
2735
2736 void ctf_Initialize()
2737 {
2738         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
2739
2740         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
2741         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
2742         ctf_captureshield_force = autocvar_g_ctf_shield_force;
2743
2744         InitializeEntity(NULL, ctf_DelayedInit, INITPRIO_GAMETYPE);
2745 }