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