qcsrc/server/mutators/gamemode_ctf.qc

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