qcsrc/server/mutators/gamemode_ctf.qc

   1 // ================================================================
   2 //  Official capture the flag game mode coding, reworked by Samual
   3 //  Last updated: March 30th, 2012
   4 // ================================================================
   5
   6 float ctf_ReadScore(string parameter) // make this obsolete
   7 {
   8         //if(g_ctf_win_mode != 2)
   9                 return cvar(strcat("g_ctf_personal", parameter));
  10         //else
  11         //      return cvar(strcat("g_ctf_flag", parameter));
  12 }
  13
  14 void ctf_FakeTimeLimit(entity e, float t)
  15 {
  16         msg_entity = e;
  17         WriteByte(MSG_ONE, 3); // svc_updatestat
  18         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
  19         if(t < 0)
  20                 WriteCoord(MSG_ONE, autocvar_timelimit);
  21         else
  22                 WriteCoord(MSG_ONE, (t + 1) / 60);
  23 }
  24
  25 void ctf_EventLog(string mode, float flagteam, entity actor) // use an alias for easy changing and quick editing later
  26 {
  27         if(autocvar_sv_eventlog)
  28                 GameLogEcho(strcat(":ctf:", mode, ":", ftos(flagteam), ((actor != world) ? (strcat(":", ftos(actor.playerid))) : "")));
  29 }
  30
  31 string ctf_CaptureRecord(entity flag, entity player)
  32 {
  33         float cap_time, cap_record, success;
  34         string cap_message, refername;
  35
  36         if((autocvar_g_ctf_captimerecord_always) || (player_count - currentbots))
  37         {
  38                 cap_record = ctf_captimerecord;
  39                 cap_time = (time - flag.ctf_pickuptime);
  40
  41                 refername = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
  42                 refername = ((refername == player.netname) ? "their" : strcat(refername, "^7's"));
  43
  44                 if(!ctf_captimerecord)
  45                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds"); success = TRUE; }
  46                 else if(cap_time < cap_record)
  47                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, breaking ", refername, " previous record of ", ftos_decimals(cap_record, 2), " seconds"); success = TRUE; }
  48                 else
  49                         { cap_message = strcat(" in ", ftos_decimals(cap_time, 2), " seconds, failing to break ", refername, " record of ", ftos_decimals(cap_record, 2), " seconds"); success = FALSE; }
  50
  51                 if(success)
  52                 {
  53                         ctf_captimerecord = cap_time;
  54                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(cap_time));
  55                         db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), player.netname);
  56                         write_recordmarker(player, (time - cap_time), cap_time);
  57                 }
  58         }
  59
  60         return cap_message;
  61 }
  62
  63 void ctf_FlagcarrierWaypoints(entity player)
  64 {
  65         WaypointSprite_Spawn("flagcarrier", 0, 0, player, '0 0 64', world, player.team, player, wps_flagcarrier, FALSE, RADARICON_FLAG, '1 1 0');
  66         WaypointSprite_UpdateMaxHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(start_health, start_armorvalue, autocvar_g_balance_armor_blockpercent) * 2);
  67         WaypointSprite_UpdateHealth(player.wps_flagcarrier, '1 0 0' * healtharmor_maxdamage(player.health, player.armorvalue, autocvar_g_balance_armor_blockpercent));
  68         WaypointSprite_UpdateTeamRadar(player.wps_flagcarrier, RADARICON_FLAGCARRIER, '1 1 0');
  69 }
  70
  71
  72 // =======================
  73 // CaptureShield Functions
  74 // =======================
  75
  76 float ctf_CaptureShield_CheckStatus(entity p)
  77 {
  78         float s, se;
  79         entity e;
  80         float players_worseeq, players_total;
  81
  82         if(ctf_captureshield_max_ratio <= 0)
  83                 return FALSE;
  84
  85         s = PlayerScore_Add(p, SP_SCORE, 0);
  86         if(s >= -ctf_captureshield_min_negscore)
  87                 return FALSE;
  88
  89         players_total = players_worseeq = 0;
  90         FOR_EACH_PLAYER(e)
  91         {
  92                 if(e.team != p.team)
  93                         continue;
  94                 se = PlayerScore_Add(e, SP_SCORE, 0);
  95                 if(se <= s)
  96                         ++players_worseeq;
  97                 ++players_total;
  98         }
  99
 100         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
 101         // use this rule here
 102
 103         if(players_worseeq >= players_total * ctf_captureshield_max_ratio)
 104                 return FALSE;
 105
 106         return TRUE;
 107 }
 108
 109 void ctf_CaptureShield_Update(entity player, float wanted_status)
 110 {
 111         float updated_status = ctf_CaptureShield_CheckStatus(player);
 112         if((wanted_status == player.ctf_captureshielded) && (updated_status != wanted_status)) // 0: shield only, 1: unshield only
 113         {
 114                 if(updated_status) // TODO csqc notifier for this // Samual: How?
 115                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Make some defensive scores before trying again.", 5, 0);
 116                 else
 117                         Send_CSQC_Centerprint_Generic(player, CPID_CTF_CAPTURESHIELD, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.", 5, 0);
 118
 119                 player.ctf_captureshielded = updated_status;
 120         }
 121 }
 122
 123 float ctf_CaptureShield_Customize()
 124 {
 125         if not(other.ctf_captureshielded) { return FALSE; }
 126         if(self.team == other.team) { return FALSE; }
 127
 128         return TRUE;
 129 }
 130
 131 void ctf_CaptureShield_Touch()
 132 {
 133         if not(other.ctf_captureshielded) { return; }
 134         if(self.team == other.team) { return; }
 135
 136         vector mymid = (self.absmin + self.absmax) * 0.5;
 137         vector othermid = (other.absmin + other.absmax) * 0.5;
 138
 139         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * ctf_captureshield_force);
 140         Send_CSQC_Centerprint_Generic(other, CPID_CTF_CAPTURESHIELD, "^3You are ^4shielded^3 from the flag\n^3for ^1too many unsuccessful attempts^3 to capture.\n\n^3Get some defensive scores before trying again.", 5, 0);
 141 }
 142
 143 void ctf_CaptureShield_Spawn(entity flag)
 144 {
 145         entity shield = spawn();
 146
 147         shield.enemy = self;
 148         shield.team = self.team;
 149         shield.touch = ctf_CaptureShield_Touch;
 150         shield.customizeentityforclient = ctf_CaptureShield_Customize;
 151         shield.classname = "ctf_captureshield";
 152         shield.effects = EF_ADDITIVE;
 153         shield.movetype = MOVETYPE_NOCLIP;
 154         shield.solid = SOLID_TRIGGER;
 155         shield.avelocity = '7 0 11';
 156         shield.scale = 0.5;
 157
 158         setorigin(shield, self.origin);
 159         setmodel(shield, "models/ctf/shield.md3");
 160         setsize(shield, shield.scale * shield.mins, shield.scale * shield.maxs);
 161 }
 162
 163
 164 // ====================
 165 // Drop/Pass/Throw Code
 166 // ====================
 167
 168 void ctf_Handle_Drop(entity flag, entity player, float droptype)
 169 {
 170         // declarations
 171         player = (player ? player : flag.pass_sender);
 172
 173         // main
 174         flag.movetype = MOVETYPE_TOSS;
 175         flag.takedamage = DAMAGE_YES;
 176         flag.health = flag.max_flag_health;
 177         flag.ctf_droptime = time;
 178         flag.ctf_dropper = player;
 179         flag.ctf_status = FLAG_DROPPED;
 180
 181         // messages and sounds
 182         Send_KillNotification(player.netname, flag.netname, "", INFO_LOSTFLAG, MSG_INFO);
 183         sound(flag, CH_TRIGGER, flag.snd_flag_dropped, VOL_BASE, ATTN_NONE);
 184         ctf_EventLog("dropped", player.team, player);
 185
 186         // scoring
 187         PlayerTeamScore_AddScore(player, -ctf_ReadScore("penalty_drop"));
 188         PlayerScore_Add(player, SP_CTF_DROPS, 1);
 189
 190         // waypoints
 191         if(autocvar_g_ctf_flag_dropped_waypoint)
 192                 WaypointSprite_Spawn("flagdropped", 0, 0, flag, '0 0 64', world, ((autocvar_g_ctf_flag_dropped_waypoint == 2) ? 0 : player.team), flag, wps_flagdropped, FALSE, RADARICON_FLAG, '0 0.5 0' + ((flag.team == COLOR_TEAM1) ? '0.75 0 0' : '0 0 0.75')); // (COLOR_TEAM1 + COLOR_TEAM2 - flag.team)
 193
 194         if(autocvar_g_ctf_flag_return_time || (autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health))
 195         {
 196                 WaypointSprite_UpdateMaxHealth(flag.wps_flagdropped, flag.max_flag_health);
 197                 WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health);
 198         }
 199
 200         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
 201
 202         if(droptype == DROP_PASS)
 203         {
 204                 flag.pass_sender = world;
 205                 flag.pass_target = world;
 206         }
 207 }
 208
 209 void ctf_Handle_Retrieve(entity flag, entity player)
 210 {
 211         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 212         entity sender = flag.pass_sender;
 213
 214         // transfer flag to player
 215         flag.ctf_carrier = player;
 216         flag.owner = player;
 217         flag.owner.flagcarried = flag;
 218
 219         // reset flag
 220         setattachment(flag, player, "");
 221         setorigin(flag, FLAG_CARRY_OFFSET);
 222         flag.movetype = MOVETYPE_NONE;
 223         flag.takedamage = DAMAGE_NO;
 224         flag.solid = SOLID_NOT;
 225         flag.ctf_carrier = player;
 226         flag.ctf_status = FLAG_CARRY;
 227
 228         // messages and sounds
 229         sound(player, CH_TRIGGER, "keepaway/respawn.wav", VOL_BASE, ATTN_NORM);
 230         ctf_EventLog("recieve", flag.team, player);
 231         FOR_EACH_PLAYER(tmp_player)
 232                 if(tmp_player == sender)
 233                         centerprint(tmp_player, strcat("You passed the ", flag.netname, " to ", player.netname));
 234                 else if(tmp_player == player)
 235                         centerprint(tmp_player, strcat("You recieved the ", flag.netname, " from ", sender.netname));
 236                 else if(tmp_player.team == sender.team)
 237                         centerprint(tmp_player, strcat(sender.netname, " passed the ", flag.netname, " to ", player.netname));
 238
 239         // create new waypoint
 240         ctf_FlagcarrierWaypoints(player);
 241
 242         sender.throw_antispam = time + autocvar_g_ctf_pass_wait;
 243         player.throw_antispam = sender.throw_antispam;
 244
 245         flag.pass_sender = world;
 246         flag.pass_target = world;
 247 }
 248
 249 void ctf_Handle_Throw(entity player, entity reciever, float droptype)
 250 {
 251         entity flag = player.flagcarried;
 252
 253         if(!flag) { return; }
 254         if((droptype == DROP_PASS) && !reciever) { return; }
 255
 256         if(flag.speedrunning) { ctf_RespawnFlag(flag); return; }
 257
 258         // reset the flag
 259         setattachment(flag, world, "");
 260         setorigin(flag, player.origin + FLAG_DROP_OFFSET);
 261         flag.owner.flagcarried = world;
 262         flag.owner = world;
 263         flag.solid = SOLID_TRIGGER;
 264         flag.ctf_droptime = time;
 265
 266         flag.flags = FL_ITEM | FL_NOTARGET; // clear FL_ONGROUND for MOVETYPE_TOSS
 267
 268         switch(droptype)
 269         {
 270                 case DROP_PASS:
 271                 {
 272                         vector targ_origin = (0.5 * (reciever.absmin + reciever.absmax));
 273                         flag.velocity = (normalize(targ_origin - player.origin) * autocvar_g_ctf_throw_velocity);
 274                         break;
 275                 }
 276
 277                 case DROP_THROW:
 278                 {
 279                         makevectors((player.v_angle_y * '0 1 0') + (player.v_angle_x * '0.5 0 0'));
 280                         flag.velocity = W_CalculateProjectileVelocity(player.velocity, ('0 0 200' + (v_forward * autocvar_g_ctf_throw_velocity)), FALSE);
 281                         break;
 282                 }
 283
 284                 default:
 285                 case DROP_RESET:
 286                 case DROP_NORMAL:
 287                 {
 288                         flag.velocity = ('0 0 200' + ('0 100 0' * crandom()) + ('100 0 0' * crandom()));
 289                         break;
 290                 }
 291         }
 292
 293         switch(droptype)
 294         {
 295                 case DROP_PASS:
 296                 {
 297                         // main
 298                         flag.movetype = MOVETYPE_FLY;
 299                         flag.takedamage = DAMAGE_NO;
 300                         flag.pass_sender = player;
 301                         flag.pass_target = reciever;
 302                         flag.ctf_status = FLAG_PASSING;
 303
 304                         // other
 305                         sound(player, CH_TRIGGER, flag.snd_flag_touch, VOL_BASE, ATTN_NORM);
 306                         ctf_EventLog("pass", flag.team, player);
 307                         te_lightning2(world, reciever.origin, player.origin);
 308                         break;
 309                 }
 310
 311                 case DROP_RESET:
 312                 {
 313                         // do nothing
 314                         break;
 315                 }
 316
 317                 default:
 318                 case DROP_THROW:
 319                 case DROP_NORMAL:
 320                 {
 321                         ctf_Handle_Drop(flag, player, droptype);
 322                         break;
 323                 }
 324         }
 325
 326         // kill old waypointsprite
 327         WaypointSprite_Ping(player.wps_flagcarrier);
 328         WaypointSprite_Kill(player.wps_flagcarrier);
 329
 330         // captureshield
 331         //ctf_CaptureShield_Update(player, 0); // shield only
 332 }
 333
 334
 335 // ==============
 336 // Event Handlers
 337 // ==============
 338
 339 void ctf_Handle_Capture(entity flag, entity toucher, float capturetype)
 340 {
 341         entity enemy_flag = ((capturetype == CAPTURE_NORMAL) ? toucher.flagcarried : toucher);
 342         entity player = ((capturetype == CAPTURE_NORMAL) ? toucher : enemy_flag.ctf_dropper);
 343
 344         if not(player) { return; } // without someone to give the reward to, we can't possibly cap
 345
 346         // messages and sounds
 347         Send_KillNotification(player.netname, enemy_flag.netname, ctf_CaptureRecord(enemy_flag, player), INFO_CAPTUREFLAG, MSG_INFO);
 348         sound(player, CH_TRIGGER, flag.snd_flag_capture, VOL_BASE, ATTN_NONE);
 349
 350         switch(capturetype)
 351         {
 352                 case CAPTURE_NORMAL: ctf_EventLog("capture", enemy_flag.team, player); break;
 353                 case CAPTURE_DROPPED: ctf_EventLog("droppedcapture", enemy_flag.team, player); break;
 354                 default: break;
 355         }
 356
 357         // scoring
 358         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_capture"));
 359         PlayerTeamScore_Add(player, SP_CTF_CAPS, ST_CTF_CAPS, 1);
 360
 361         // effects
 362         if(autocvar_g_ctf_flag_capture_effects)
 363         {
 364                 pointparticles(particleeffectnum((player.team == COLOR_TEAM1) ? "red_ground_quake" : "blue_ground_quake"), flag.origin, '0 0 0', 1);
 365                 shockwave_spawn("models/ctf/shockwavetransring.md3", flag.origin - '0 0 15', -0.8, 0, 1);
 366         }
 367
 368         // other
 369         if(capturetype == CAPTURE_NORMAL)
 370         {
 371                 WaypointSprite_Kill(player.wps_flagcarrier);
 372                 if(flag.speedrunning) { ctf_FakeTimeLimit(player, -1); }
 373         }
 374
 375         // reset the flag
 376         player.next_take_time = time + autocvar_g_ctf_flag_collect_delay;
 377         ctf_RespawnFlag(enemy_flag);
 378 }
 379
 380 void ctf_Handle_Return(entity flag, entity player)
 381 {
 382         // messages and sounds
 383         //centerprint(player, strcat("You returned the ", flag.netname));
 384         Send_KillNotification (player.netname, flag.netname, "", INFO_RETURNFLAG, MSG_INFO);
 385         sound(player, CH_TRIGGER, flag.snd_flag_returned, VOL_BASE, ATTN_NONE);
 386         ctf_EventLog("return", flag.team, player);
 387
 388         // scoring
 389         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_return")); // reward for return
 390         PlayerScore_Add(player, SP_CTF_RETURNS, 1); // add to count of returns
 391
 392         TeamScore_AddToTeam(((flag.team == COLOR_TEAM1) ? COLOR_TEAM2 : COLOR_TEAM1), ST_SCORE, -ctf_ReadScore("penalty_returned")); // punish the team who was last carrying it
 393         FOR_EACH_PLAYER(player) if(player == flag.ctf_dropper) // punish the player who dropped the flag
 394         {
 395                 PlayerScore_Add(player, SP_SCORE, -ctf_ReadScore("penalty_returned"));
 396                 ctf_CaptureShield_Update(player, 0); // shield only
 397         }
 398
 399         // reset the flag
 400         ctf_RespawnFlag(flag);
 401 }
 402
 403 void ctf_Handle_Pickup(entity flag, entity player, float pickuptype)
 404 {
 405         // declarations
 406         entity tmp_player; // temporary entity which the FOR_EACH_PLAYER loop uses to scan players
 407         string verbosename; // holds the name of the player OR no name at all for printing in the centerprints
 408         float pickup_dropped_score; // used to calculate dropped pickup score
 409
 410         // attach the flag to the player
 411         flag.owner = player;
 412         player.flagcarried = flag;
 413         setattachment(flag, player, "");
 414         setorigin(flag, FLAG_CARRY_OFFSET);
 415
 416         // flag setup
 417         flag.movetype = MOVETYPE_NONE;
 418         flag.takedamage = DAMAGE_NO;
 419         flag.solid = SOLID_NOT;
 420         flag.angles = '0 0 0';
 421         flag.ctf_carrier = player;
 422         flag.ctf_status = FLAG_CARRY;
 423
 424         switch(pickuptype)
 425         {
 426                 case PICKUP_BASE: flag.ctf_pickuptime = time; break; // used for timing runs
 427                 case PICKUP_DROPPED: flag.health = flag.max_flag_health; break; // reset health/return timelimit
 428                 default: break;
 429         }
 430
 431         // messages and sounds
 432         Send_KillNotification (player.netname, flag.netname, "", INFO_GOTFLAG, MSG_INFO);
 433         sound(player, CH_TRIGGER, flag.snd_flag_taken, VOL_BASE, ATTN_NONE);
 434         verbosename = ((autocvar_g_ctf_flag_pickup_verbosename) ? strcat(Team_ColorCode(player.team), "(^7", player.netname, Team_ColorCode(player.team), ") ") : "");
 435
 436         FOR_EACH_PLAYER(tmp_player)
 437                 if(tmp_player == player)
 438                         centerprint(tmp_player, strcat("You got the ", flag.netname, "!"));
 439                 else if(tmp_player.team == player.team)
 440                         centerprint(tmp_player, strcat("Your ", Team_ColorCode(player.team), "team mate ", verbosename, "^7got the flag! Protect them!"));
 441                 else if(tmp_player.team == flag.team)
 442                         centerprint(tmp_player, strcat("The ", Team_ColorCode(player.team), "enemy ", verbosename, "^7got your flag! Retrieve it!"));
 443
 444         switch(pickuptype)
 445         {
 446                 case PICKUP_BASE: ctf_EventLog("steal", flag.team, player); break;
 447                 case PICKUP_DROPPED: ctf_EventLog("pickup", flag.team, player); break;
 448                 default: break;
 449         }
 450
 451         // scoring
 452         PlayerScore_Add(player, SP_CTF_PICKUPS, 1);
 453         switch(pickuptype)
 454         {
 455                 case PICKUP_BASE:
 456                 {
 457                         PlayerTeamScore_AddScore(player, ctf_ReadScore("score_pickup_base"));
 458                         break;
 459                 }
 460
 461                 case PICKUP_DROPPED:
 462                 {
 463                         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);
 464                         pickup_dropped_score = floor((ctf_ReadScore("score_pickup_dropped_late") * (1 - pickup_dropped_score) + ctf_ReadScore("score_pickup_dropped_early") * pickup_dropped_score) + 0.5);
 465                         print("pickup_dropped_score is ", ftos(pickup_dropped_score), "\n");
 466                         PlayerTeamScore_AddScore(player, pickup_dropped_score);
 467                         break;
 468                 }
 469
 470                 default: break;
 471         }
 472
 473         // speedrunning
 474         if(pickuptype == PICKUP_BASE)
 475         {
 476                 flag.speedrunning = player.speedrunning; // if speedrunning, flag will flag-return and teleport the owner back after the record
 477                 if((player.speedrunning) && (ctf_captimerecord))
 478                         ctf_FakeTimeLimit(player, time + ctf_captimerecord);
 479         }
 480
 481         // effects
 482         if(autocvar_g_ctf_flag_pickup_effects)
 483                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (flag.absmin + flag.absmax), '0 0 0', 1);
 484
 485         // waypoints
 486         if(pickuptype == PICKUP_DROPPED) { WaypointSprite_Kill(flag.wps_flagdropped); }
 487         ctf_FlagcarrierWaypoints(player);
 488         WaypointSprite_Ping(player.wps_flagcarrier);
 489 }
 490
 491
 492 // ===================
 493 // Main Flag Functions
 494 // ===================
 495
 496 void ctf_CheckFlagReturn(entity flag)
 497 {
 498         if(flag.wps_flagdropped) { WaypointSprite_UpdateHealth(flag.wps_flagdropped, flag.health); }
 499
 500         if((flag.health <= 0) || (time > flag.ctf_droptime + autocvar_g_ctf_flag_return_time))
 501         {
 502                 bprint("The ", flag.netname, " has returned to base\n");
 503                 sound(flag, CH_TRIGGER, flag.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 504                 ctf_EventLog("returned", flag.team, world);
 505                 ctf_RespawnFlag(flag);
 506         }
 507 }
 508
 509 void ctf_FlagDamage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 510 {
 511         if(ITEM_DAMAGE_NEEDKILL(deathtype))
 512         {
 513                 // automatically kill the flag and return it
 514                 self.health = 0;
 515                 ctf_CheckFlagReturn(self);
 516                 return;
 517         }
 518
 519         if(autocvar_g_ctf_flag_return_damage)
 520         {
 521                 self.health = self.health - damage;
 522                 ctf_CheckFlagReturn(self);
 523                 return;
 524         }
 525 }
 526
 527 void ctf_FlagThink()
 528 {
 529         // declarations
 530         entity tmp_entity;
 531
 532         self.nextthink = time + FLAG_THINKRATE; // only 5 fps, more is unnecessary.
 533
 534         // captureshield
 535         if(self == ctf_worldflaglist) // only for the first flag
 536                 FOR_EACH_CLIENT(tmp_entity)
 537                         ctf_CaptureShield_Update(tmp_entity, 1); // release shield only
 538
 539         // sanity checks
 540         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX) { // reset the flag boundaries in case it got squished
 541                 dprint("wtf the flag got squashed?\n");
 542                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
 543                 if(!trace_startsolid) // can we resize it without getting stuck?
 544                         setsize(self, FLAG_MIN, FLAG_MAX); }
 545
 546         // main think method
 547         switch(self.ctf_status)
 548         {
 549                 case FLAG_BASE:
 550                 {
 551                         if(autocvar_g_ctf_dropped_capture_radius)
 552                         {
 553                                 for(tmp_entity = ctf_worldflaglist; tmp_entity; tmp_entity = tmp_entity.ctf_worldflagnext)
 554                                         if(tmp_entity.ctf_status == FLAG_DROPPED)
 555                                                 if(vlen(self.origin - tmp_entity.origin) < autocvar_g_ctf_dropped_capture_radius)
 556                                                         ctf_Handle_Capture(self, tmp_entity, CAPTURE_DROPPED);
 557                         }
 558                         return;
 559                 }
 560
 561                 case FLAG_DROPPED:
 562                 {
 563                         if(autocvar_g_ctf_flag_return_dropped)
 564                         {
 565                                 if((vlen(self.origin - self.ctf_spawnorigin) < autocvar_g_ctf_flag_return_dropped) || (autocvar_g_ctf_flag_return_dropped == -1))
 566                                 {
 567                                         self.health = 0;
 568                                         ctf_CheckFlagReturn(self);
 569                                         return;
 570                                 }
 571                         }
 572                         if(autocvar_g_ctf_flag_return_time)
 573                         {
 574                                 self.health -= ((self.max_flag_health / autocvar_g_ctf_flag_return_time) * FLAG_THINKRATE);
 575                                 ctf_CheckFlagReturn(self);
 576                                 return;
 577                         }
 578                         return;
 579                 }
 580
 581                 case FLAG_CARRY:
 582                 {
 583                         if((self.owner) && (self.speedrunning) && (ctf_captimerecord) && (time >= self.ctf_pickuptime + ctf_captimerecord))
 584                         {
 585                                 bprint("The ", self.netname, " became impatient after ", ftos_decimals(ctf_captimerecord, 2), " seconds and returned itself\n");
 586                                 sound(self, CH_TRIGGER, self.snd_flag_respawn, VOL_BASE, ATTN_NONE);
 587                                 ctf_EventLog("returned", self.team, world);
 588                                 ctf_RespawnFlag(tmp_entity);
 589
 590                                 tmp_entity = self;
 591                                 self = self.owner;
 592                                 self.impulse = CHIMPULSE_SPEEDRUN; // move the player back to the waypoint they set
 593                                 ImpulseCommands();
 594                                 self = tmp_entity;
 595                         }
 596                         return;
 597                 }
 598
 599                 case FLAG_PASSING: // todo make work with warpzones
 600                 {
 601                         vector targ_origin = ((self.pass_target.absmin + self.pass_target.absmax) * 0.5);
 602
 603                         traceline(self.origin, targ_origin, MOVE_NOMONSTERS, self);
 604
 605                         if((self.pass_target.deadflag != DEAD_NO)
 606                                 || (vlen(self.origin - targ_origin) > autocvar_g_ctf_pass_radius)
 607                                 || ((trace_fraction < 1) && (trace_ent != self.pass_target))
 608                                 || (time > self.ctf_droptime + autocvar_g_ctf_pass_timelimit))
 609                         {
 610                                 ctf_Handle_Drop(self, world, DROP_PASS);
 611                         }
 612                         else // still a viable target, go for it
 613                         {
 614                                 vector desired_direction = normalize(targ_origin - self.origin);
 615                                 vector current_direction = normalize(self.velocity);
 616
 617                                 self.velocity = (normalize(current_direction + (desired_direction * autocvar_g_ctf_pass_turnrate)) * autocvar_g_ctf_throw_velocity);
 618                         }
 619                         return;
 620                 }
 621
 622                 default: // this should never happen
 623                 {
 624                         dprint("ctf_FlagThink(): Flag exists with no status?\n");
 625                         return;
 626                 }
 627         }
 628 }
 629
 630 void ctf_FlagTouch()
 631 {
 632         if(gameover) { return; }
 633         if(!self) { return; }
 634         if(other.deadflag != DEAD_NO) { return; }
 635         if(ITEM_TOUCH_NEEDKILL())
 636         {
 637                 // automatically kill the flag and return it
 638                 self.health = 0;
 639                 ctf_CheckFlagReturn(self);
 640                 return;
 641         }
 642         if(other.classname != "player") // The flag just touched an object, most likely the world
 643         {
 644                 if(time > self.wait) // if we haven't in a while, play a sound/effect
 645                 {
 646                         pointparticles(particleeffectnum("kaball_sparks"), self.origin, '0 0 0', 1);
 647                         sound(self, CH_TRIGGER, self.snd_flag_touch, VOL_BASE, ATTN_NORM);
 648                         self.wait = time + FLAG_TOUCHRATE;
 649                 }
 650                 return;
 651         }
 652
 653         switch(self.ctf_status)
 654         {
 655                 case FLAG_BASE:
 656                 {
 657                         if((other.team == self.team) && (other.flagcarried) && (other.flagcarried.team != self.team))
 658                                 ctf_Handle_Capture(self, other, CAPTURE_NORMAL); // other just captured the enemies flag to his base
 659                         else if((other.team != self.team) && (!other.flagcarried) && (!other.ctf_captureshielded) && (time > other.next_take_time))
 660                                 ctf_Handle_Pickup(self, other, PICKUP_BASE); // other just stole the enemies flag
 661                         break;
 662                 }
 663
 664                 case FLAG_DROPPED:
 665                 {
 666                         if(other.team == self.team)
 667                                 ctf_Handle_Return(self, other); // other just returned his own flag
 668                         else if((!other.flagcarried) && ((other != self.ctf_dropper) || (time > self.ctf_droptime + autocvar_g_ctf_flag_collect_delay)))
 669                                 ctf_Handle_Pickup(self, other, PICKUP_DROPPED); // other just picked up a dropped enemy flag
 670                         break;
 671                 }
 672
 673                 case FLAG_CARRY:
 674                 {
 675                         dprint("Someone touched a flag even though it was being carried?\n");
 676                         break;
 677                 }
 678
 679                 case FLAG_PASSING:
 680                 {
 681                         if((other.classname == "player") && (other.deadflag == DEAD_NO) && (other != self.pass_sender))
 682                         {
 683                                 if(IsDifferentTeam(other, self.pass_sender))
 684                                         ctf_Handle_Return(self, other);
 685                                 else
 686                                         ctf_Handle_Retrieve(self, other);
 687                         }
 688                         break;
 689                 }
 690
 691                 default: // this should never happen
 692                 {
 693                         dprint("Touch: Flag exists with no status?\n");
 694                         break;
 695                 }
 696         }
 697 }
 698
 699 void ctf_RespawnFlag(entity flag)
 700 {
 701         // reset the player (if there is one)
 702         if((flag.owner) && (flag.owner.flagcarried == flag))
 703         {
 704                 WaypointSprite_Kill(flag.wps_flagcarrier);
 705                 flag.owner.flagcarried = world;
 706
 707                 if(flag.speedrunning)
 708                         ctf_FakeTimeLimit(flag.owner, -1);
 709         }
 710
 711         if((flag.ctf_status == FLAG_DROPPED) && (flag.wps_flagdropped))
 712                 { WaypointSprite_Kill(flag.wps_flagdropped); }
 713
 714         // reset the flag
 715         setattachment(flag, world, "");
 716         setorigin(flag, flag.ctf_spawnorigin);
 717
 718         flag.movetype = ((flag.noalign) ? MOVETYPE_NONE : MOVETYPE_TOSS);
 719         flag.takedamage = DAMAGE_NO;
 720         flag.health = flag.max_flag_health;
 721         flag.solid = SOLID_TRIGGER;
 722         flag.velocity = '0 0 0';
 723         flag.angles = flag.mangle;
 724         flag.flags = FL_ITEM | FL_NOTARGET;
 725
 726         flag.ctf_status = FLAG_BASE;
 727         flag.owner = world;
 728         flag.pass_sender = world;
 729         flag.pass_target = world;
 730         flag.ctf_carrier = world;
 731         flag.ctf_dropper = world;
 732         flag.ctf_pickuptime = 0;
 733         flag.ctf_droptime = 0;
 734 }
 735
 736 void ctf_Reset()
 737 {
 738         if(self.owner)
 739                 if(self.owner.classname == "player")
 740                         ctf_Handle_Throw(self.owner, world, DROP_RESET);
 741
 742         ctf_RespawnFlag(self);
 743 }
 744
 745 void ctf_DelayedFlagSetup(void) // called after a flag is placed on a map by ctf_FlagSetup()
 746 {
 747         // declarations
 748         float teamnumber = ((self.team == COLOR_TEAM1) ? TRUE : FALSE); // if we were originally 1, this will become 0. If we were originally 0, this will become 1.
 749
 750         // bot waypoints
 751         waypoint_spawnforitem_force(self, self.origin);
 752         self.nearestwaypointtimeout = 0; // activate waypointing again
 753         self.bot_basewaypoint = self.nearestwaypoint;
 754
 755         // waypointsprites
 756         WaypointSprite_SpawnFixed(((teamnumber) ? "redbase" : "bluebase"), self.origin + '0 0 64', self, wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
 757         WaypointSprite_UpdateTeamRadar(self.wps_flagbase, RADARICON_FLAG, colormapPaletteColor(((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2) - 1, FALSE));
 758
 759         // captureshield setup
 760         ctf_CaptureShield_Spawn(self);
 761 }
 762
 763 void ctf_FlagSetup(float teamnumber, entity flag) // called when spawning a flag entity on the map as a spawnfunc
 764 {
 765         // declarations
 766         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.
 767         self = flag; // for later usage with droptofloor()
 768
 769         // main setup
 770         flag.ctf_worldflagnext = ctf_worldflaglist; // link flag into ctf_worldflaglist
 771         ctf_worldflaglist = flag;
 772
 773         setattachment(flag, world, "");
 774
 775         flag.netname = ((teamnumber) ? "^1RED^7 flag" : "^4BLUE^7 flag");
 776         flag.team = ((teamnumber) ? COLOR_TEAM1 : COLOR_TEAM2); // COLOR_TEAM1: color 4 team (red) - COLOR_TEAM2: color 13 team (blue)
 777         flag.items = ((teamnumber) ? IT_KEY2 : IT_KEY1); // IT_KEY2: gold key (redish enough) - IT_KEY1: silver key (bluish enough)
 778         flag.classname = "item_flag_team";
 779         flag.target = "###item###"; // wut?
 780         flag.flags = FL_ITEM | FL_NOTARGET;
 781         flag.solid = SOLID_TRIGGER;
 782         flag.takedamage = DAMAGE_NO;
 783         flag.damageforcescale = autocvar_g_ctf_flag_damageforcescale;
 784         flag.max_flag_health = ((autocvar_g_ctf_flag_return_damage && autocvar_g_ctf_flag_health) ? autocvar_g_ctf_flag_health : 100);
 785         flag.health = flag.max_flag_health;
 786         flag.event_damage = ctf_FlagDamage;
 787         flag.pushable = TRUE;
 788         flag.damagedbytriggers = autocvar_g_ctf_flag_return_when_unreachable;
 789         flag.damagedbycontents = autocvar_g_ctf_flag_return_when_unreachable;
 790         flag.velocity = '0 0 0';
 791         flag.mangle = flag.angles;
 792         flag.reset = ctf_Reset;
 793         flag.touch = ctf_FlagTouch;
 794         flag.think = ctf_FlagThink;
 795         flag.nextthink = time + FLAG_THINKRATE;
 796         flag.ctf_status = FLAG_BASE;
 797
 798         if(!flag.model) { flag.model = ((teamnumber) ? autocvar_g_ctf_flag_red_model : autocvar_g_ctf_flag_blue_model); }
 799         if(!flag.scale) { flag.scale = FLAG_SCALE; }
 800         if(!flag.skin) { flag.skin = ((teamnumber) ? autocvar_g_ctf_flag_red_skin : autocvar_g_ctf_flag_blue_skin); }
 801
 802         // sound
 803         if(!flag.snd_flag_taken) { flag.snd_flag_taken  = ((teamnumber) ? "ctf/red_taken.wav" : "ctf/blue_taken.wav"); }
 804         if(!flag.snd_flag_returned) { flag.snd_flag_returned = ((teamnumber) ? "ctf/red_returned.wav" : "ctf/blue_returned.wav"); }
 805         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
 806         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.
 807         if(!flag.snd_flag_dropped) { flag.snd_flag_dropped = ((teamnumber) ? "ctf/red_dropped.wav" : "ctf/blue_dropped.wav"); }
 808         if(!flag.snd_flag_touch) { flag.snd_flag_touch = "keepaway/touch.wav"; } // again has no team-based sound // FIXME
 809
 810         // precache
 811         precache_sound(flag.snd_flag_taken);
 812         precache_sound(flag.snd_flag_returned);
 813         precache_sound(flag.snd_flag_capture);
 814         precache_sound(flag.snd_flag_respawn);
 815         precache_sound(flag.snd_flag_dropped);
 816         precache_sound(flag.snd_flag_touch);
 817         precache_model(flag.model);
 818         precache_model("models/ctf/shield.md3");
 819         precache_model("models/ctf/shockwavetransring.md3");
 820
 821         // appearence
 822         setmodel(flag, flag.model); // precision set below
 823         setsize(flag, FLAG_MIN, FLAG_MAX);
 824         setorigin(flag, (flag.origin + FLAG_SPAWN_OFFSET));
 825
 826         if(autocvar_g_ctf_flag_glowtrails)
 827         {
 828                 flag.glow_color = ((teamnumber) ? 251 : 210); // 251: red - 210: blue
 829                 flag.glow_size = 25;
 830                 flag.glow_trail = 1;
 831         }
 832
 833         flag.effects |= EF_LOWPRECISION;
 834         if(autocvar_g_ctf_fullbrightflags) { flag.effects |= EF_FULLBRIGHT; }
 835         if(autocvar_g_ctf_dynamiclights)   { flag.effects |= ((teamnumber) ? EF_RED : EF_BLUE); }
 836
 837         // flag placement
 838         if((flag.spawnflags & 1) || flag.noalign) // don't drop to floor, just stay at fixed location
 839         {
 840                 flag.dropped_origin = flag.origin;
 841                 flag.noalign = TRUE;
 842                 flag.movetype = MOVETYPE_NONE;
 843         }
 844         else // drop to floor, automatically find a platform and set that as spawn origin
 845         {
 846                 flag.noalign = FALSE;
 847                 self = flag;
 848                 droptofloor();
 849                 flag.movetype = MOVETYPE_TOSS;
 850         }
 851
 852         InitializeEntity(flag, ctf_DelayedFlagSetup, INITPRIO_SETLOCATION);
 853 }
 854
 855
 856 // ==============
 857 // Hook Functions
 858 // ==============
 859
 860 MUTATOR_HOOKFUNCTION(ctf_HookedDrop)
 861 {
 862         if(self.flagcarried) { ctf_Handle_Throw(self, world, DROP_NORMAL); }
 863         return 0;
 864 }
 865
 866 MUTATOR_HOOKFUNCTION(ctf_PlayerPreThink)
 867 {
 868         entity flag;
 869
 870         // initially clear items so they can be set as necessary later.
 871         self.items &~= (IT_RED_FLAG_CARRYING | IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST
 872                 | IT_BLUE_FLAG_CARRYING | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST | IT_CTF_SHIELDED);
 873
 874         // scan through all the flags and notify the client about them
 875         for(flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext)
 876         {
 877                 if(flag.ctf_status == FLAG_CARRY)
 878                         if(flag.owner == self)
 879                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_CARRYING : IT_BLUE_FLAG_CARRYING); // carrying: self is currently carrying the flag
 880                         else
 881                                 self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_TAKEN : IT_BLUE_FLAG_TAKEN); // taken: someone on self's team is carrying the flag
 882                 else if(flag.ctf_status == FLAG_DROPPED)
 883                         self.items |= ((flag.items & IT_KEY2) ? IT_RED_FLAG_LOST : IT_BLUE_FLAG_LOST); // lost: the flag is dropped somewhere on the map
 884         }
 885
 886         // item for stopping players from capturing the flag too often
 887         if(self.ctf_captureshielded)
 888                 self.items |= IT_CTF_SHIELDED;
 889
 890         // update the health of the flag carrier waypointsprite
 891         if(self.wps_flagcarrier)
 892                 WaypointSprite_UpdateHealth(self.wps_flagcarrier, self.health);
 893
 894         return 0;
 895 }
 896
 897 MUTATOR_HOOKFUNCTION(ctf_PlayerDamage) // for changing damage and force values that are applied to players in g_damage.qc
 898 {
 899         if(frag_attacker.flagcarried) // if the attacker is a flagcarrier
 900         {
 901                 if(frag_target == frag_attacker) // damage done to yourself
 902                 {
 903                         frag_damage *= autocvar_g_ctf_flagcarrier_selfdamagefactor;
 904                         frag_force *= autocvar_g_ctf_flagcarrier_selfforcefactor;
 905                 }
 906                 else // damage done everyone else
 907                 {
 908                         frag_damage *= autocvar_g_ctf_flagcarrier_damagefactor;
 909                         frag_force *= autocvar_g_ctf_flagcarrier_forcefactor;
 910                 }
 911         }
 912         return 0;
 913 }
 914
 915 MUTATOR_HOOKFUNCTION(ctf_GiveFragsForKill)
 916 {
 917         frag_score = 0;
 918         return (autocvar_g_ctf_ignore_frags); // no frags counted in ctf if this is true
 919 }
 920
 921 MUTATOR_HOOKFUNCTION(ctf_PlayerUseKey)
 922 {
 923         entity player = self;
 924
 925         if(time > player.throw_antispam)
 926         {
 927                 // pass the flag to a team mate
 928                 if(autocvar_g_ctf_allow_pass)
 929                 {
 930                         entity head, closest_target;
 931                         head = findradius(player.origin, autocvar_g_ctf_pass_radius);
 932
 933                         while(head) // find the closest acceptable target to pass to
 934                         {
 935                                 if(head.classname == "player" && head.deadflag == DEAD_NO)
 936                                 if(head != player && !IsDifferentTeam(head, player))
 937                                 if(!player.speedrunning && !head.speedrunning)
 938                                 {
 939                                         traceline(player.origin, head.origin, MOVE_NOMONSTERS, player);
 940                                         if not((trace_fraction < 1) && (trace_ent != head))
 941                                         {
 942                                                 if(autocvar_g_ctf_pass_request && !player.flagcarried && head.flagcarried)
 943                                                 {
 944                                                         if(clienttype(head) == CLIENTTYPE_BOT)
 945                                                         {
 946                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
 947                                                                 ctf_Handle_Throw(head, player, DROP_PASS);
 948                                                         }
 949                                                         else
 950                                                         {
 951                                                                 centerprint(head, strcat(player.netname, " requests you to pass the ", head.flagcarried.netname));
 952                                                                 centerprint(player, strcat("Requesting ", head.netname, " to pass you the ", head.flagcarried.netname));
 953                                                         }
 954                                                         player.throw_antispam = time + autocvar_g_ctf_pass_wait;
 955                                                         return 0;
 956                                                 }
 957                                                 else if(player.flagcarried)
 958                                                 {
 959                                                         if(closest_target) { if(vlen(player.origin - head.origin) < vlen(player.origin - closest_target.origin)) { closest_target = head; } }
 960                                                         else { closest_target = head; }
 961                                                 }
 962                                         }
 963                                 }
 964                                 head = head.chain;
 965                         }
 966
 967                         if(closest_target) { ctf_Handle_Throw(player, closest_target, DROP_PASS); return 0; }
 968                 }
 969
 970                 // throw the flag in front of you
 971                 if(autocvar_g_ctf_allow_drop && player.flagcarried && !player.speedrunning)
 972                         { ctf_Handle_Throw(player, world, DROP_THROW); }
 973         }
 974
 975         return 0;
 976 }
 977
 978 // ==========
 979 // Spawnfuncs
 980 // ==========
 981
 982 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
 983 CTF Starting point for a player in team one (Red).
 984 Keys: "angle" viewing angle when spawning. */
 985 void spawnfunc_info_player_team1()
 986 {
 987         if(g_assault) { remove(self); return; }
 988
 989         self.team = COLOR_TEAM1; // red
 990         spawnfunc_info_player_deathmatch();
 991 }
 992
 993
 994 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
 995 CTF Starting point for a player in team two (Blue).
 996 Keys: "angle" viewing angle when spawning. */
 997 void spawnfunc_info_player_team2()
 998 {
 999         if(g_assault) { remove(self); return; }
1000
1001         self.team = COLOR_TEAM2; // blue
1002         spawnfunc_info_player_deathmatch();
1003 }
1004
1005 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
1006 CTF Starting point for a player in team three (Yellow).
1007 Keys: "angle" viewing angle when spawning. */
1008 void spawnfunc_info_player_team3()
1009 {
1010         if(g_assault) { remove(self); return; }
1011
1012         self.team = COLOR_TEAM3; // yellow
1013         spawnfunc_info_player_deathmatch();
1014 }
1015
1016
1017 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
1018 CTF Starting point for a player in team four (Purple).
1019 Keys: "angle" viewing angle when spawning. */
1020 void spawnfunc_info_player_team4()
1021 {
1022         if(g_assault) { remove(self); return; }
1023
1024         self.team = COLOR_TEAM4; // purple
1025         spawnfunc_info_player_deathmatch();
1026 }
1027
1028 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1029 CTF flag for team one (Red).
1030 Keys:
1031 "angle" Angle the flag will point (minus 90 degrees)...
1032 "model" model to use, note this needs red and blue as skins 0 and 1...
1033 "noise" sound played when flag is picked up...
1034 "noise1" sound played when flag is returned by a teammate...
1035 "noise2" sound played when flag is captured...
1036 "noise3" sound played when flag is lost in the field and respawns itself...
1037 "noise4" sound played when flag is dropped by a player...
1038 "noise5" sound played when flag touches the ground... */
1039 void spawnfunc_item_flag_team1()
1040 {
1041         if(!g_ctf) { remove(self); return; }
1042
1043         ctf_FlagSetup(1, self); // 1 = red
1044 }
1045
1046 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
1047 CTF flag for team two (Blue).
1048 Keys:
1049 "angle" Angle the flag will point (minus 90 degrees)...
1050 "model" model to use, note this needs red and blue as skins 0 and 1...
1051 "noise" sound played when flag is picked up...
1052 "noise1" sound played when flag is returned by a teammate...
1053 "noise2" sound played when flag is captured...
1054 "noise3" sound played when flag is lost in the field and respawns itself...
1055 "noise4" sound played when flag is dropped by a player...
1056 "noise5" sound played when flag touches the ground... */
1057 void spawnfunc_item_flag_team2()
1058 {
1059         if(!g_ctf) { remove(self); return; }
1060
1061         ctf_FlagSetup(0, self); // the 0 is misleading, but -- 0 = blue.
1062 }
1063
1064 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
1065 Team declaration for CTF gameplay, this allows you to decide what team names and control point models are used in your map.
1066 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.
1067 Keys:
1068 "netname" Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)...
1069 "cnt" Scoreboard color of the team (for example 4 is red and 13 is blue)... */
1070 void spawnfunc_ctf_team()
1071 {
1072         if(!g_ctf) { remove(self); return; }
1073
1074         self.classname = "ctf_team";
1075         self.team = self.cnt + 1;
1076 }
1077
1078
1079 // ==============
1080 // Initialization
1081 // ==============
1082
1083 // code from here on is just to support maps that don't have flag and team entities
1084 void ctf_SpawnTeam (string teamname, float teamcolor)
1085 {
1086         entity oldself;
1087         oldself = self;
1088         self = spawn();
1089         self.classname = "ctf_team";
1090         self.netname = teamname;
1091         self.cnt = teamcolor;
1092
1093         spawnfunc_ctf_team();
1094
1095         self = oldself;
1096 }
1097
1098 void ctf_DelayedInit() // Do this check with a delay so we can wait for teams to be set up.
1099 {
1100         // if no teams are found, spawn defaults
1101         if(find(world, classname, "ctf_team") == world)
1102         {
1103                 print("No ""ctf_team"" entities found on this map, creating them anyway.\n");
1104                 ctf_SpawnTeam("Red", COLOR_TEAM1 - 1);
1105                 ctf_SpawnTeam("Blue", COLOR_TEAM2 - 1);
1106         }
1107
1108         ScoreRules_ctf();
1109 }
1110
1111 void ctf_Initialize()
1112 {
1113         ctf_captimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1114
1115         ctf_captureshield_min_negscore = autocvar_g_ctf_shield_min_negscore;
1116         ctf_captureshield_max_ratio = autocvar_g_ctf_shield_max_ratio;
1117         ctf_captureshield_force = autocvar_g_ctf_shield_force;
1118
1119         InitializeEntity(world, ctf_DelayedInit, INITPRIO_GAMETYPE);
1120 }
1121
1122
1123 MUTATOR_DEFINITION(gamemode_ctf)
1124 {
1125         MUTATOR_HOOK(MakePlayerObserver, ctf_HookedDrop, CBC_ORDER_ANY);
1126         MUTATOR_HOOK(ClientDisconnect, ctf_HookedDrop, CBC_ORDER_ANY);
1127         MUTATOR_HOOK(PlayerDies, ctf_HookedDrop, CBC_ORDER_ANY);
1128         MUTATOR_HOOK(PortalTeleport, ctf_HookedDrop, CBC_ORDER_ANY);
1129         MUTATOR_HOOK(GiveFragsForKill, ctf_GiveFragsForKill, CBC_ORDER_ANY);
1130         MUTATOR_HOOK(PlayerPreThink, ctf_PlayerPreThink, CBC_ORDER_ANY);
1131         MUTATOR_HOOK(PlayerDamage_Calculate, ctf_PlayerDamage, CBC_ORDER_ANY);
1132         MUTATOR_HOOK(PlayerUseKey, ctf_PlayerUseKey, CBC_ORDER_ANY);
1133
1134         MUTATOR_ONADD
1135         {
1136                 if(time > 1) // game loads at time 1
1137                         error("This is a game type and it cannot be added at runtime.");
1138                 g_ctf = 1;
1139                 ctf_Initialize();
1140         }
1141
1142         MUTATOR_ONREMOVE
1143         {
1144                 g_ctf = 0;
1145                 error("This is a game type and it cannot be removed at runtime.");
1146         }
1147
1148         return 0;
1149 }