qcsrc/server/ctf.qc

   1 #define FLAG_MIN (PL_MIN + '0 0 -13')
   2 #define FLAG_MAX (PL_MAX + '0 0 -13')
   3
   4 .entity basewaypoint;
   5 .entity sprite;
   6 entity ctf_worldflaglist; // CTF flags in the map
   7 .entity ctf_worldflagnext;
   8 .float dropperid;
   9 .float ctf_droptime;
  10
  11 .float next_take_time;                  // the next time a player can pick up a flag (time + blah)
  12                                                                 /// I used this, in part, to fix the looping score bug. - avirox
  13 //float FLAGSCORE_PICKUP        =  1;
  14 //float FLAGSCORE_RETURN        =  5; // returned by owner team
  15 //float FLAGSCORE_RETURNROGUE   = 10; // returned by rogue team
  16 //float FLAGSCORE_CAPTURE       =  5;
  17
  18 #define FLAG_CARRY_POS '-15 0 7'
  19
  20 .float ctf_captureshielded; // set to 1 if the player is too bad to be allowed to capture
  21
  22 float captureshield_min_negscore; // punish at -20 points
  23 float captureshield_max_ratio; // punish at most 30% of each team
  24 float captureshield_force; // push force of the shield
  25
  26 float ctf_captureshield_shielded(entity p)
  27 {
  28         float s, se;
  29         entity e;
  30         float players_worseeq, players_total;
  31
  32         if(captureshield_max_ratio <= 0)
  33                 return FALSE;
  34
  35         s = PlayerScore_Add(p, SP_SCORE, 0);
  36         if(s >= -captureshield_min_negscore)
  37                 return FALSE;
  38
  39         players_total = players_worseeq = 0;
  40         FOR_EACH_PLAYER(e)
  41         {
  42                 if(e.team != p.team)
  43                         continue;
  44                 se = PlayerScore_Add(e, SP_SCORE, 0);
  45                 if(se <= s)
  46                         ++players_worseeq;
  47                 ++players_total;
  48         }
  49
  50         // player is in the worse half, if >= half the players are better than him, or consequently, if < half of the players are worse
  51         // use this rule here
  52
  53         if(players_worseeq >= players_total * captureshield_max_ratio)
  54                 return FALSE;
  55
  56         return TRUE;
  57 }
  58
  59 void ctf_captureshield_update(entity p, float dir)
  60 {
  61         float should;
  62         if(dir == p.ctf_captureshielded) // 0: shield only, 1: unshield only
  63         {
  64                 should = ctf_captureshield_shielded(p);
  65                 if(should != dir)
  66                 {
  67                         if(should)
  68                         {
  69                                 centerprint_atprio(p, CENTERPRIO_SHIELDING, "^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.");
  70                                 // TODO csqc notifier for this
  71                         }
  72                         else
  73                         {
  74                                 centerprint_atprio(p, CENTERPRIO_SHIELDING, "^3You are now free.\n\n^3Feel free to ^1try to capture^3 the flag again\n^3if you think you will succeed.");
  75                                 // TODO csqc notifier for this
  76                         }
  77                         p.ctf_captureshielded = should;
  78                 }
  79         }
  80 }
  81
  82 float ctf_captureshield_customize()
  83 {
  84         if not(other.ctf_captureshielded)
  85                 return FALSE;
  86         if(self.team == other.team)
  87                 return FALSE;
  88         return TRUE;
  89 }
  90
  91 void ctf_captureshield_touch()
  92 {
  93         if not(other.ctf_captureshielded)
  94                 return;
  95         if(self.team == other.team)
  96                 return;
  97         vector mymid;
  98         vector othermid;
  99         mymid = (self.absmin + self.absmax) * 0.5;
 100         othermid = (other.absmin + other.absmax) * 0.5;
 101         Damage(other, self, self, 0, DEATH_HURTTRIGGER, mymid, normalize(othermid - mymid) * captureshield_force);
 102         centerprint_atprio(other, CENTERPRIO_SHIELDING, "^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.");
 103 }
 104
 105 void ctf_flag_spawnstuff()
 106 {
 107         entity e;
 108         e = spawn();
 109         e.enemy = self;
 110         e.team = self.team;
 111         e.touch = ctf_captureshield_touch;
 112         e.customizeentityforclient = ctf_captureshield_customize;
 113         e.classname = "ctf_captureshield";
 114         e.effects = EF_ADDITIVE;
 115         e.movetype = MOVETYPE_NOCLIP;
 116         e.solid = SOLID_TRIGGER;
 117         e.avelocity = '7 0 11';
 118         setorigin(e, self.origin);
 119         setmodel(e, "models/ctf/shield.md3");
 120         e.scale = 0.5;
 121         setsize(e, e.scale * e.mins, e.scale * e.maxs);
 122
 123         waypoint_spawnforitem_force(self, self.origin);
 124         self.nearestwaypointtimeout = 0; // activate waypointing again
 125         self.basewaypoint = self.nearestwaypoint;
 126
 127         if(self.team == COLOR_TEAM1)
 128         {
 129                 WaypointSprite_SpawnFixed("redbase", self.origin + '0 0 61', self, sprite);
 130                 WaypointSprite_UpdateTeamRadar(self.sprite, RADARICON_FLAG, colormapPaletteColor(COLOR_TEAM1 - 1, FALSE));
 131         }
 132         else
 133         {
 134                 WaypointSprite_SpawnFixed("bluebase", self.origin + '0 0 61', self, sprite);
 135                 WaypointSprite_UpdateTeamRadar(self.sprite, RADARICON_FLAG, colormapPaletteColor(COLOR_TEAM2 - 1, FALSE));
 136         }
 137 }
 138
 139 float ctf_score_value(string parameter)
 140 {
 141         if(g_ctf_win_mode != 2)
 142                 return cvar(strcat("g_ctf_personal", parameter));
 143         else
 144                 return cvar(strcat("g_ctf_flag", parameter));
 145 }
 146
 147 void FakeTimeLimit(entity e, float t)
 148 {
 149         msg_entity = e;
 150         WriteByte(MSG_ONE, 3); // svc_updatestat
 151         WriteByte(MSG_ONE, 236); // STAT_TIMELIMIT
 152         if(t < 0)
 153                 WriteCoord(MSG_ONE, cvar("timelimit"));
 154         else
 155                 WriteCoord(MSG_ONE, (t + 1) / 60);
 156 }
 157
 158 float   flagcaptimerecord;
 159 .float  flagpickuptime;
 160 //.float  iscommander;
 161 //.float  ctf_state;
 162
 163 void() FlagThink;
 164 void() FlagTouch;
 165
 166 void place_flag()
 167 {
 168         if(self.classname != "item_flag_team")
 169         {
 170                 backtrace("PlaceFlag a non-flag");
 171                 return;
 172         }
 173
 174         if(!self.t_width)
 175                 self.t_width = 0.1; // frame animation rate
 176         if(!self.t_length)
 177                 self.t_length = 58; // maximum frame
 178
 179         setattachment(self, world, "");
 180         self.mdl = self.model;
 181         self.flags = FL_ITEM;
 182         self.solid = SOLID_TRIGGER;
 183         self.movetype = MOVETYPE_NONE;
 184         self.velocity = '0 0 0';
 185         self.origin_z = self.origin_z + 6;
 186         self.think = FlagThink;
 187         self.touch = FlagTouch;
 188         self.nextthink = time + 0.1;
 189         self.cnt = FLAG_BASE;
 190         self.mangle = self.angles;
 191         self.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP;
 192         //self.effects = self.effects | EF_DIMLIGHT;
 193         if(self.noalign)
 194         {
 195                 self.dropped_origin = self.origin;
 196         }
 197         else
 198         {
 199                 droptofloor();
 200                 self.movetype = MOVETYPE_TOSS;
 201         }
 202
 203         InitializeEntity(self, ctf_flag_spawnstuff, INITPRIO_SETLOCATION);
 204 };
 205
 206 void LogCTF(string mode, float flagteam, entity actor)
 207 {
 208         string s;
 209         if(!cvar("sv_eventlog"))
 210                 return;
 211         s = strcat(":ctf:", mode);
 212         s = strcat(s, ":", ftos(flagteam));
 213         if(actor != world)
 214                 s = strcat(s, ":", ftos(actor.playerid));
 215         GameLogEcho(s);
 216 }
 217
 218 void RegenFlag(entity e)
 219 {
 220         if(e.classname != "item_flag_team")
 221         {
 222                 backtrace("RegenFlag a non-flag");
 223                 return;
 224         }
 225
 226         if(e.waypointsprite_attachedforcarrier)
 227                 WaypointSprite_DetachCarrier(e);
 228
 229         setattachment(e, world, "");
 230         e.damageforcescale = 0;
 231         e.takedamage = DAMAGE_NO;
 232         e.movetype = MOVETYPE_NONE;
 233         if(!e.noalign)
 234                 e.movetype = MOVETYPE_TOSS;
 235         e.velocity = '0 0 0';
 236         e.solid = SOLID_TRIGGER;
 237         // TODO: play a sound here
 238         setorigin(e, e.dropped_origin);
 239         e.angles = e.mangle;
 240         e.cnt = FLAG_BASE;
 241         e.owner = world;
 242         e.flags = FL_ITEM; // clear FL_ONGROUND and any other junk
 243 };
 244
 245 void ReturnFlag(entity e)
 246 {
 247         if(e.classname != "item_flag_team")
 248         {
 249                 backtrace("ReturnFlag a non-flag");
 250                 return;
 251         }
 252
 253         if (e.owner)
 254         if (e.owner.flagcarried == e)
 255         {
 256                 WaypointSprite_DetachCarrier(e.owner);
 257                 e.owner.flagcarried = world;
 258
 259                 if(e.speedrunning)
 260                         FakeTimeLimit(e.owner, -1);
 261         }
 262         e.owner = world;
 263         RegenFlag(e);
 264 };
 265
 266 void DropFlag(entity e, entity penalty_receiver, entity attacker)
 267 {
 268         local entity p;
 269
 270         if(e.classname != "item_flag_team")
 271         {
 272                 backtrace("DropFlag a non-flag");
 273                 return;
 274         }
 275
 276         if(e.speedrunning)
 277         {
 278                 ReturnFlag(e);
 279                 return;
 280         }
 281
 282         if (!e.owner)
 283         {
 284                 dprint("FLAG: drop - no owner?!?!\n");
 285                 return;
 286         }
 287         p = e.owner;
 288         if (p.flagcarried != e)
 289         {
 290                 dprint("FLAG: drop - owner is not carrying this flag??\n");
 291                 return;
 292         }
 293         bprint(p.netname, "^7 lost the ", e.netname, "\n");
 294
 295         if(penalty_receiver)
 296                 UpdateFrags(penalty_receiver, -ctf_score_value("penalty_suicidedrop"));
 297         else
 298                 UpdateFrags(p, -ctf_score_value("penalty_drop"));
 299         PlayerScore_Add(p, SP_CTF_DROPS, +1);
 300         ctf_captureshield_update(p, 0); // shield only
 301         e.playerid = attacker.playerid;
 302         e.ctf_droptime = time;
 303         WaypointSprite_Spawn("flagdropped", 0, 0, e, '0 0 1' * 61, world, COLOR_TEAM1 + COLOR_TEAM2 - e.team, e, waypointsprite_attachedforcarrier, FALSE);
 304
 305         if(p.waypointsprite_attachedforcarrier)
 306         {
 307                 WaypointSprite_Ping(p.waypointsprite_attachedforcarrier);
 308                 WaypointSprite_DetachCarrier(p);
 309         }
 310         else
 311         {
 312                 bprint("\{1}^1Flag carrier had no flag sprite?!?\n");
 313                 backtrace("Flag carrier had no flag sprite?!?");
 314         }
 315         LogCTF("dropped", p.team, p);
 316         sound (self, CHAN_TRIGGER, self.noise4, VOL_BASE, ATTN_NONE);
 317
 318         setattachment(e, world, "");
 319         e.damageforcescale = cvar("g_balance_ctf_damageforcescale");
 320         e.takedamage = DAMAGE_YES;
 321
 322         if (p.flagcarried == e)
 323                 p.flagcarried = world;
 324         e.owner = world;
 325
 326         e.flags = FL_ITEM; // clear FL_ONGROUND and any other junk
 327         e.solid = SOLID_TRIGGER;
 328         e.movetype = MOVETYPE_TOSS;
 329         // setsize(e, '-16 -16 0', '16 16 74');
 330         setorigin(e, p.origin - '0 0 24' + '0 0 37');
 331         e.cnt = FLAG_DROPPED;
 332         e.velocity = '0 0 300';
 333         e.pain_finished = time + cvar("g_ctf_flag_returntime");//30;
 334
 335         trace_startsolid = FALSE;
 336         tracebox(e.origin, e.mins, e.maxs, e.origin, TRUE, e);
 337         if(trace_startsolid)
 338                 dprint("FLAG FALLTHROUGH will happen SOON\n");
 339 };
 340
 341 void AnimateFlag()
 342 {
 343         if(self.delay > time)
 344                 return;
 345         self.delay = time + self.t_width;
 346         if(self.nextthink > self.delay)
 347                 self.nextthink = self.delay;
 348
 349         self.frame = self.frame + 1;
 350         if(self.frame > self.t_length)
 351                 self.frame = 0;
 352 }
 353
 354 void FlagThink()
 355 {
 356         local entity e;
 357
 358         self.nextthink = time + 0.1;
 359
 360         // sorry, we have to reset the flag size if it got squished by something
 361         if(self.mins != FLAG_MIN || self.maxs != FLAG_MAX)
 362         {
 363                 // if we can grow back, grow back
 364                 tracebox(self.origin, FLAG_MIN, FLAG_MAX, self.origin, MOVE_NOMONSTERS, self);
 365                 if(!trace_startsolid)
 366                         setsize(self, FLAG_MIN, FLAG_MAX);
 367         }
 368
 369         if(self == ctf_worldflaglist) // only for the first flag
 370         {
 371                 FOR_EACH_CLIENT(e)
 372                         ctf_captureshield_update(e, 1); // release shield only
 373         }
 374
 375         AnimateFlag();
 376
 377         if(self.speedrunning)
 378         if(self.cnt == FLAG_CARRY)
 379         {
 380                 if(self.owner)
 381                 if(flagcaptimerecord)
 382                 if(time >= self.flagpickuptime + flagcaptimerecord)
 383                 {
 384                         bprint("The ", self.netname, " became impatient after ", ftos_decimals(flagcaptimerecord, 2), " seconds and returned itself\n");
 385
 386                         sound (self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NONE);
 387                         self.owner.impulse = 141; // returning!
 388
 389                         e = self;
 390                         self = self.owner;
 391                         ReturnFlag(e);
 392                         ImpulseCommands();
 393                         self = e;
 394                         return;
 395                 }
 396         }
 397
 398         if (self.cnt == FLAG_BASE)
 399                 return;
 400
 401         if (self.cnt == FLAG_DROPPED)
 402         {
 403                 // flag fallthrough? FIXME remove this if bug is really fixed now
 404                 if(self.origin_z < -131072)
 405                 {
 406                         dprint("FLAG FALLTHROUGH just happened\n");
 407                         self.pain_finished = 0;
 408                 }
 409                 setattachment(self, world, "");
 410                 if (time > self.pain_finished)
 411                 {
 412                         bprint("The ", self.netname, " has returned to base\n");
 413                         sound (self, CHAN_TRIGGER, self.noise3, VOL_BASE, ATTN_NONE);
 414                         LogCTF("returned", self.team, world);
 415                         ReturnFlag(self);
 416                 }
 417                 return;
 418         }
 419
 420         e = self.owner;
 421         if (e.classname != "player" || (e.deadflag) || (e.flagcarried != self))
 422         {
 423                 dprint("CANNOT HAPPEN - player dead and STILL had a flag!\n");
 424                 DropFlag(self, world, world);
 425                 return;
 426         }
 427
 428         if(cvar("g_ctf_allow_drop"))
 429         if(e.BUTTON_USE)
 430                 DropFlag(self, e, world);
 431 };
 432
 433 void flag_cap_ring_spawn(vector org)
 434 {
 435         shockwave_spawn("models/ctf/shockwavetransring.md3", org - '0 0 15', -0.8, 0, 1);
 436 };
 437
 438 void FlagTouch()
 439 {
 440         if(gameover) return;
 441
 442         local float t;
 443         local entity player;
 444         local string s, s0, h0, h1;
 445         if (other.classname != "player")
 446                 return;
 447         if (other.health < 1) // ignore dead players
 448                 return;
 449
 450         if (self.cnt == FLAG_CARRY)
 451                 return;
 452
 453         if (self.cnt == FLAG_BASE)
 454         if (other.team == self.team)
 455         if (other.flagcarried) // he's got a flag
 456         if (other.flagcarried.team != self.team) // capture
 457         {
 458                 if (other.flagcarried == world)
 459                 {
 460                         return;
 461                 }
 462                 if(cvar("g_ctf_captimerecord_always") || player_count - currentbots <= 1) // at most one human
 463                 {
 464                         t = time - other.flagcarried.flagpickuptime;
 465                         s = ftos_decimals(t, 2);
 466                         s0 = ftos_decimals(flagcaptimerecord, 2);
 467                         h0 = db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"));
 468                         h1 = other.netname;
 469                         if(h0 == h1)
 470                                 h0 = "their";
 471                         else
 472                                 h0 = strcat(h0, "^7's"); // h0: display text for previous netname
 473                         if (flagcaptimerecord == 0)
 474                         {
 475                                 bprint(other.netname, "^7 captured the ", other.flagcarried.netname, " in ", s, " seconds\n");
 476                                 flagcaptimerecord = t;
 477                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(t));
 478                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), h1);
 479                                 write_recordmarker(other, time - t, t);
 480                         }
 481                         else if (t < flagcaptimerecord)
 482                         {
 483                                 bprint(other.netname, "^7 captured the ", other.flagcarried.netname, " in ", s, ", breaking ", strcat(h0, " previous record of ", s0, " seconds\n"));
 484                                 flagcaptimerecord = t;
 485                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time"), ftos(t));
 486                                 db_put(ServerProgsDB, strcat(GetMapname(), "/captimerecord/netname"), h1);
 487                                 write_recordmarker(other, time - t, t);
 488                         }
 489                         else
 490                         {
 491                                 bprint(other.netname, "^7 captured the ", other.flagcarried.netname, " in ", s, ", failing to break ", strcat(h0, " record of ", s0, " seconds\n"));
 492                         }
 493                 }
 494                 else
 495                         bprint(other.netname, "^7 captured the ", other.flagcarried.netname, "\n");
 496
 497                 PlayerTeamScore_Add(other, SP_CTF_CAPS, ST_CTF_CAPS, 1);
 498                 LogCTF("capture", other.flagcarried.team, other);
 499                 // give credit to the individual player
 500                 UpdateFrags(other, ctf_score_value("score_capture"));
 501
 502                 if (cvar("g_ctf_flag_capture_effects")) {
 503                         if (other.team == COLOR_TEAM1) { // red team scores effect
 504                                 pointparticles(particleeffectnum("red_ground_quake"), self.origin, '0 0 0', 1);
 505                                 flag_cap_ring_spawn(self.origin);
 506                         }
 507                         if (other.team == COLOR_TEAM2) { // blue team scores effect
 508                                 pointparticles(particleeffectnum("blue_ground_quake"), self.origin, '0 0 0', 1);
 509                                 flag_cap_ring_spawn(self.origin);
 510                         }
 511                 }
 512
 513                 sound (other, CHAN_AUTO, self.noise2, VOL_BASE, ATTN_NONE);
 514                 WaypointSprite_DetachCarrier(other);
 515                 if(self.speedrunning)
 516                         FakeTimeLimit(other, -1);
 517                 RegenFlag (other.flagcarried);
 518                 other.flagcarried = world;
 519                 other.next_take_time = time + 1;
 520         }
 521         if (self.cnt == FLAG_BASE)
 522         if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2) // only red and blue team can steal flags
 523         if (other.team != self.team)
 524         if (!other.flagcarried)
 525         if (!other.ctf_captureshielded)
 526         {
 527                 if (other.next_take_time > time)
 528                         return;
 529
 530                 if (cvar("g_ctf_flag_pickup_effects")) // pickup effect
 531                         pointparticles(particleeffectnum("smoke_ring"), 0.5 * (self.absmin + self.absmax), '0 0 0', 1);
 532
 533                 // pick up
 534                 self.flagpickuptime = time; // used for timing runs
 535                 self.speedrunning = other.speedrunning; // if speedrunning, flag will self-return and teleport the owner back after the record
 536                 if(other.speedrunning)
 537                 if(flagcaptimerecord)
 538                         FakeTimeLimit(other, time + flagcaptimerecord);
 539                 self.solid = SOLID_NOT;
 540                 setorigin(self, self.origin); // relink
 541                 self.owner = other;
 542                 other.flagcarried = self;
 543                 self.cnt = FLAG_CARRY;
 544                 self.angles = '0 0 0';
 545                 bprint(other.netname, "^7 got the ", self.netname, "\n");
 546                 UpdateFrags(other, ctf_score_value("score_pickup_base"));
 547                 self.dropperid = other.playerid;
 548                 PlayerScore_Add(other, SP_CTF_PICKUPS, 1);
 549                 LogCTF("steal", self.team, other);
 550                 sound (other, CHAN_AUTO, self.noise, VOL_BASE, ATTN_NONE);
 551
 552                 FOR_EACH_PLAYER(player)
 553                         if(player.team == self.team)
 554                                 centerprint(player, "The enemy got your flag! Retrieve it!");
 555
 556                 self.movetype = MOVETYPE_NONE;
 557                 setorigin(self, FLAG_CARRY_POS);
 558                 setattachment(self, other, "");
 559                 WaypointSprite_AttachCarrier("flagcarrier", other);
 560                 WaypointSprite_UpdateTeamRadar(other.waypointsprite_attachedforcarrier, RADARICON_FLAGCARRIER, '1 1 0');
 561                 WaypointSprite_Ping(self.sprite);
 562
 563                 return;
 564         }
 565
 566         if (self.cnt == FLAG_DROPPED)
 567         {
 568                 self.flags = FL_ITEM; // clear FL_ONGROUND and any other junk
 569                 if (other.team == self.team || (other.team != COLOR_TEAM1 && other.team != COLOR_TEAM2))
 570                 {
 571                         // return flag
 572                         bprint(other.netname, "^7 returned the ", self.netname, "\n");
 573
 574                         // punish the player who last had it
 575                         FOR_EACH_PLAYER(player)
 576                                 if(player.playerid == self.dropperid)
 577                                 {
 578                                         PlayerScore_Add(player, SP_SCORE, -ctf_score_value("penalty_returned"));
 579                                         ctf_captureshield_update(player, 0); // shield only
 580                                 }
 581
 582                         // punish the team who was last carrying it
 583                         if(self.team == COLOR_TEAM1)
 584                                 TeamScore_AddToTeam(COLOR_TEAM2, ST_SCORE, -ctf_score_value("penalty_returned"));
 585                         else
 586                                 TeamScore_AddToTeam(COLOR_TEAM1, ST_SCORE, -ctf_score_value("penalty_returned"));
 587
 588                         // reward the player who returned it
 589                         if(other.playerid == self.playerid) // is this the guy who killed the FC last?
 590                         {
 591                                 if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2)
 592                                         UpdateFrags(other, ctf_score_value("score_return_by_killer"));
 593                                 else
 594                                         UpdateFrags(other, ctf_score_value("score_return_rogue_by_killer"));
 595                         }
 596                         else
 597                         {
 598                                 if (other.team == COLOR_TEAM1 || other.team == COLOR_TEAM2)
 599                                         UpdateFrags(other, ctf_score_value("score_return"));
 600                                 else
 601                                         UpdateFrags(other, ctf_score_value("score_return_rogue"));
 602                         }
 603                         PlayerScore_Add(other, SP_CTF_RETURNS, 1);
 604                         LogCTF("return", self.team, other);
 605                         sound (other, CHAN_AUTO, self.noise1, VOL_BASE, ATTN_NONE);
 606                         ReturnFlag(self);
 607                 }
 608                 else if (!other.flagcarried && (other.playerid != self.dropperid || time > self.ctf_droptime + cvar("g_balance_ctf_delay_collect")))
 609                 {
 610                         if(self.waypointsprite_attachedforcarrier)
 611                                 WaypointSprite_DetachCarrier(self);
 612
 613                         if (cvar("g_ctf_flag_pickup_effects")) // field pickup effect
 614                                 pointparticles(particleeffectnum("smoke_ring"), 0.5 * (self.absmin + self.absmax), '0 0 0', 1);
 615
 616                         // pick up
 617                         self.solid = SOLID_NOT;
 618                         setorigin(self, self.origin); // relink
 619                         self.owner = other;
 620                         other.flagcarried = self;
 621                         self.cnt = FLAG_CARRY;
 622                         bprint(other.netname, "^7 picked up the ", self.netname, "\n");
 623
 624                         float f;
 625                         f = bound(0, (self.pain_finished - time) / cvar("g_ctf_flag_returntime"), 1);
 626                         //print("factor is ", ftos(f), "\n");
 627                         f = ctf_score_value("score_pickup_dropped_late") * (1-f)
 628                           + ctf_score_value("score_pickup_dropped_early") * f;
 629                         f = floor(f + 0.5);
 630                         self.dropperid = other.playerid;
 631                         //print("score is ", ftos(f), "\n");
 632
 633                         UpdateFrags(other, f);
 634                         PlayerScore_Add(other, SP_CTF_PICKUPS, 1);
 635                         LogCTF("pickup", self.team, other);
 636                         sound (other, CHAN_AUTO, self.noise, VOL_BASE, ATTN_NONE);
 637
 638                         FOR_EACH_PLAYER(player)
 639                                 if(player.team == self.team)
 640                                         centerprint(player, "The enemy got your flag! Retrieve it!");
 641
 642                         self.movetype = MOVETYPE_NONE;  // flag must have MOVETYPE_NONE here, otherwise it will drop through the floor...
 643                         setorigin(self, FLAG_CARRY_POS);
 644                         setattachment(self, other, "");
 645                         self.damageforcescale = 0;
 646                         self.takedamage = DAMAGE_NO;
 647                         WaypointSprite_AttachCarrier("flagcarrier", other);
 648                         WaypointSprite_UpdateTeamRadar(other.waypointsprite_attachedforcarrier, RADARICON_FLAGCARRIER, '1 1 0');
 649                 }
 650         }
 651 };
 652
 653 /*QUAKED spawnfunc_info_player_team1 (1 0 0) (-16 -16 -24) (16 16 24)
 654 CTF Starting point for a player
 655 in team one (Red).
 656
 657 Keys:
 658 "angle"
 659  viewing angle when spawning
 660 */
 661 void spawnfunc_info_player_team1()
 662 {
 663         if(g_assault)
 664         {
 665                 remove(self);
 666                 return;
 667         }
 668         self.team = COLOR_TEAM1; // red
 669         spawnfunc_info_player_deathmatch();
 670 };
 671 //self.team = 4;self.classname = "info_player_start";spawnfunc_info_player_start();};
 672
 673 /*QUAKED spawnfunc_info_player_team2 (1 0 0) (-16 -16 -24) (16 16 24)
 674 CTF Starting point for a player in
 675 team two (Blue).
 676
 677 Keys:
 678 "angle"
 679  viewing angle when spawning
 680 */
 681 void spawnfunc_info_player_team2()
 682 {
 683         if(g_assault)
 684         {
 685                 remove(self);
 686                 return;
 687         }
 688         self.team = COLOR_TEAM2; // blue
 689         spawnfunc_info_player_deathmatch();
 690 };
 691 //self.team = 13;self.classname = "info_player_start";spawnfunc_info_player_start();};
 692
 693 /*QUAKED spawnfunc_info_player_team3 (1 0 0) (-16 -16 -24) (16 16 24)
 694 CTF Starting point for a player in
 695 team three (Yellow).
 696
 697 Keys:
 698 "angle"
 699  viewing angle when spawning
 700 */
 701 void spawnfunc_info_player_team3()
 702 {
 703         if(g_assault)
 704         {
 705                 remove(self);
 706                 return;
 707         }
 708         self.team = COLOR_TEAM3; // yellow
 709         spawnfunc_info_player_deathmatch();
 710 };
 711
 712
 713 /*QUAKED spawnfunc_info_player_team4 (1 0 0) (-16 -16 -24) (16 16 24)
 714 CTF Starting point for a player in
 715 team four (Magenta).
 716
 717 Keys:
 718 "angle"
 719  viewing angle when spawning
 720 */
 721 void spawnfunc_info_player_team4()
 722 {
 723         if(g_assault)
 724         {
 725                 remove(self);
 726                 return;
 727         }
 728         self.team = COLOR_TEAM4; // purple
 729         spawnfunc_info_player_deathmatch();
 730 };
 731
 732 void item_flag_reset()
 733 {
 734         DropFlag(self, world, world);
 735         if(self.waypointsprite_attachedforcarrier)
 736                 WaypointSprite_DetachCarrier(self);
 737         ReturnFlag(self);
 738 }
 739
 740 void item_flag_postspawn()
 741 { // Check CTF Item Flag Post Spawn
 742
 743         // Flag Glow Trail Support
 744         if(cvar("g_ctf_flag_glowtrails"))
 745         { // Provide Flag Glow Trail
 746                 if(self.team == COLOR_TEAM1)
 747                         // Red
 748                         self.glow_color = 251;
 749                 else
 750                 if(self.team == COLOR_TEAM2)
 751                         // Blue
 752                         self.glow_color = 210;
 753
 754                 self.glow_size = 25;
 755                 self.glow_trail = 1;
 756         }
 757 };
 758
 759 /*QUAKED spawnfunc_item_flag_team1 (0 0.5 0.8) (-48 -48 -37) (48 48 37)
 760 CTF flag for team one (Red).
 761 Multiple are allowed.
 762
 763 Keys:
 764 "angle"
 765  Angle the flag will point
 766 (minus 90 degrees)
 767 "model"
 768  model to use, note this needs red and blue as skins 0 and 1
 769  (default models/ctf/flag.md3)
 770 "noise"
 771  sound played when flag is picked up
 772  (default ctf/take.wav)
 773 "noise1"
 774  sound played when flag is returned by a teammate
 775  (default ctf/return.wav)
 776 "noise2"
 777  sound played when flag is captured
 778  (default ctf/redcapture.wav)
 779 "noise3"
 780  sound played when flag is lost in the field and respawns itself
 781  (default ctf/respawn.wav)
 782 */
 783
 784 void spawnfunc_item_flag_team1()
 785 {
 786         if (!g_ctf)
 787         {
 788                 remove(self);
 789                 return;
 790         }
 791
 792         //if(!cvar("teamplay"))
 793         //      cvar_set("teamplay", "3");
 794
 795         // link flag into ctf_worldflaglist
 796         self.ctf_worldflagnext = ctf_worldflaglist;
 797         ctf_worldflaglist = self;
 798
 799         self.classname = "item_flag_team";
 800         if(g_ctf_reverse)
 801         {
 802                 self.team = COLOR_TEAM2; // color 13 team (blue)
 803                 self.items = IT_KEY1; // silver key (bluish enough)
 804         }
 805         else
 806         {
 807                 self.team = COLOR_TEAM1; // color 4 team (red)
 808                 self.items = IT_KEY2; // gold key (redish enough)
 809         }
 810         self.netname = "^1RED^7 flag";
 811         self.target = "###item###";
 812         self.skin = cvar("g_ctf_flag_red_skin");
 813         if(self.spawnflags & 1)
 814                 self.noalign = 1;
 815         if (!self.model)
 816                 self.model = cvar_string("g_ctf_flag_red_model");
 817         if (!self.noise)
 818                 self.noise = "ctf/red_taken.wav";
 819         if (!self.noise1)
 820                 self.noise1 = "ctf/red_returned.wav";
 821         if (!self.noise2)
 822                 self.noise2 = "ctf/red_capture.wav"; // blue team scores by capturing the red flag
 823         if (!self.noise3)
 824                 self.noise3 = "ctf/flag_respawn.wav";
 825         if (!self.noise4)
 826                 self.noise4 = "ctf/red_dropped.wav";
 827         precache_model (self.model);
 828         setmodel (self, self.model); // precision set below
 829         precache_sound (self.noise);
 830         precache_sound (self.noise1);
 831         precache_sound (self.noise2);
 832         precache_sound (self.noise3);
 833         precache_sound (self.noise4);
 834         //setsize(self, '-16 -16 -37', '16 16 37');
 835         setsize(self, FLAG_MIN, FLAG_MAX);
 836         setorigin(self, self.origin + '0 0 37');
 837         self.nextthink = time + 0.2; // start after doors etc
 838         self.think = place_flag;
 839
 840         if(!self.scale)
 841                 self.scale = 0.6;
 842         //if(!self.glow_size)
 843         //      self.glow_size = 50;
 844
 845         self.effects = self.effects | EF_LOWPRECISION;
 846         if(cvar("g_ctf_fullbrightflags"))
 847                 self.effects |= EF_FULLBRIGHT;
 848         if(cvar("g_ctf_dynamiclights"))
 849                 self.effects |= EF_RED;
 850
 851         // From Spidflisk
 852         item_flag_postspawn();
 853
 854         precache_model("models/ctf/shield.md3");
 855         precache_model("models/ctf/shockwavetransring.md3");
 856
 857         self.reset = item_flag_reset;
 858 };
 859
 860 /*QUAKED spawnfunc_item_flag_team2 (0 0.5 0.8) (-48 -48 -24) (48 48 64)
 861 CTF flag for team two (Blue).
 862 Multiple are allowed.
 863
 864 Keys:
 865 "angle"
 866  Angle the flag will point
 867 (minus 90 degrees)
 868 "model"
 869  model to use, note this needs red and blue as skins 0 and 1
 870  (default models/ctf/flag.md3)
 871 "noise"
 872  sound played when flag is picked up
 873  (default ctf/take.wav)
 874 "noise1"
 875  sound played when flag is returned by a teammate
 876  (default ctf/return.wav)
 877 "noise2"
 878  sound played when flag is captured
 879  (default ctf/bluecapture.wav)
 880 "noise3"
 881  sound played when flag is lost in the field and respawns itself
 882  (default ctf/respawn.wav)
 883 */
 884
 885 void spawnfunc_item_flag_team2()
 886 {
 887         if (!g_ctf)
 888         {
 889                 remove(self);
 890                 return;
 891         }
 892         //if(!cvar("teamplay"))
 893         //      cvar_set("teamplay", "3");
 894
 895         // link flag into ctf_worldflaglist
 896         self.ctf_worldflagnext = ctf_worldflaglist;
 897         ctf_worldflaglist = self;
 898
 899         self.classname = "item_flag_team";
 900         if(g_ctf_reverse)
 901         {
 902                 self.team = COLOR_TEAM1; // color 4 team (red)
 903                 self.items = IT_KEY2; // gold key (redish enough)
 904         }
 905         else
 906         {
 907                 self.team = COLOR_TEAM2; // color 13 team (blue)
 908                 self.items = IT_KEY1; // silver key (bluish enough)
 909         }
 910         self.netname = "^4BLUE^7 flag";
 911         self.target = "###item###";
 912         self.skin = cvar("g_ctf_flag_blue_skin");
 913         if(self.spawnflags & 1)
 914                 self.noalign = 1;
 915         if (!self.model)
 916                 self.model = cvar_string("g_ctf_flag_blue_model");
 917         if (!self.noise)
 918                 self.noise = "ctf/blue_taken.wav";
 919         if (!self.noise1)
 920                 self.noise1 = "ctf/blue_returned.wav";
 921         if (!self.noise2)
 922                 self.noise2 = "ctf/blue_capture.wav"; // blue team scores by capturing the red flag
 923         if (!self.noise3)
 924                 self.noise3 = "ctf/flag_respawn.wav";
 925         if (!self.noise4)
 926                 self.noise4 = "ctf/blue_dropped.wav";
 927         precache_model (self.model);
 928         setmodel (self, self.model); // precision set below
 929         precache_sound (self.noise);
 930         precache_sound (self.noise1);
 931         precache_sound (self.noise2);
 932         precache_sound (self.noise3);
 933         precache_sound (self.noise4);
 934         //setsize(self, '-16 -16 -37', '16 16 37');
 935         setsize(self, FLAG_MIN, FLAG_MAX);
 936         setorigin(self, self.origin + '0 0 37');
 937         self.nextthink = time + 0.2; // start after doors etc
 938         self.think = place_flag;
 939
 940         if(!self.scale)
 941                 self.scale = 0.6;
 942         //if(!self.glow_size)
 943         //      self.glow_size = 50;
 944
 945         self.effects = self.effects | EF_LOWPRECISION;
 946         if(cvar("g_ctf_fullbrightflags"))
 947                 self.effects |= EF_FULLBRIGHT;
 948         if(cvar("g_ctf_dynamiclights"))
 949                 self.effects |= EF_BLUE;
 950
 951         // From Spidflisk
 952         item_flag_postspawn();
 953
 954         precache_model("models/ctf/shield.md3");
 955         precache_model("models/ctf/shockwavetransring.md3");
 956
 957         self.reset = item_flag_reset;
 958 };
 959
 960
 961 /*QUAKED spawnfunc_ctf_team (0 .5 .8) (-16 -16 -24) (16 16 32)
 962 Team declaration for CTF gameplay, this allows you to decide what team
 963 names and control point models are used in your map.
 964
 965 Note: If you use spawnfunc_ctf_team entities you must define at least 2!  However, unlike
 966 domination, you don't need to make a blank one too.
 967
 968 Keys:
 969 "netname"
 970  Name of the team (for example Red, Blue, Green, Yellow, Life, Death, Offense, Defense, etc)
 971 "cnt"
 972  Scoreboard color of the team (for example 4 is red and 13 is blue)
 973
 974 */
 975
 976 void spawnfunc_ctf_team()
 977 {
 978         if (!g_ctf)
 979         {
 980                 remove(self);
 981                 return;
 982         }
 983         self.classname = "ctf_team";
 984         self.team = self.cnt + 1;
 985 };
 986
 987 // code from here on is just to support maps that don't have control point and team entities
 988 void ctf_spawnteam (string teamname, float teamcolor)
 989 {
 990         local entity oldself;
 991         oldself = self;
 992         self = spawn();
 993         self.classname = "ctf_team";
 994         self.netname = teamname;
 995         self.cnt = teamcolor;
 996
 997         spawnfunc_ctf_team();
 998
 999         self = oldself;
1000 };
1001
1002 // spawn some default teams if the map is not set up for ctf
1003 void ctf_spawnteams()
1004 {
1005         float numteams;
1006
1007         numteams = 2;//cvar("g_ctf_default_teams");
1008
1009         ctf_spawnteam("Red", COLOR_TEAM1 - 1);
1010         ctf_spawnteam("Blue", COLOR_TEAM2 - 1);
1011 };
1012
1013 void ctf_delayedinit()
1014 {
1015         // if no teams are found, spawn defaults
1016         if (find(world, classname, "ctf_team") == world)
1017                 ctf_spawnteams();
1018
1019         ScoreRules_ctf();
1020 };
1021
1022 void ctf_init()
1023 {
1024         InitializeEntity(world, ctf_delayedinit, INITPRIO_GAMETYPE);
1025         flagcaptimerecord = stof(db_get(ServerProgsDB, strcat(GetMapname(), "/captimerecord/time")));
1026
1027         captureshield_min_negscore = cvar("g_ctf_shield_min_negscore");
1028         captureshield_max_ratio = cvar("g_ctf_shield_max_ratio");
1029         captureshield_force = cvar("g_ctf_shield_force");
1030 };
1031
1032 void ctf_setstatus2(entity flag, float shift)
1033 {
1034         if (flag.cnt == FLAG_CARRY)
1035                 if (flag.owner == self)
1036                         self.items |= shift * 3;
1037                 else
1038                         self.items |= shift * 1;
1039         else if (flag.cnt == FLAG_DROPPED)
1040                 self.items |= shift * 2;
1041         else
1042         {
1043                 // no status bits
1044         }
1045 };
1046
1047 void ctf_setstatus()
1048 {
1049         self.items &~= IT_RED_FLAG_TAKEN;
1050         self.items &~= IT_RED_FLAG_LOST;
1051         self.items &~= IT_BLUE_FLAG_TAKEN;
1052         self.items &~= IT_BLUE_FLAG_LOST;
1053         self.items &~= IT_CTF_SHIELDED;
1054
1055         if (g_ctf) {
1056                 local entity flag;
1057                 float redflags, blueflags;
1058
1059                 if(self.ctf_captureshielded)
1060                         self.items |= IT_CTF_SHIELDED;
1061
1062                 redflags = 0;
1063                 blueflags = 0;
1064
1065                 for (flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext) if(flag.cnt != FLAG_BASE)
1066                 {
1067                         if(flag.items & IT_KEY2) // blue
1068                                 ++redflags;
1069                         else if(flag.items & IT_KEY1) // red
1070                                 ++blueflags;
1071                 }
1072
1073                 // blinking magic: if there is more than one flag, show one of these in a clever way
1074                 if(redflags)
1075                         redflags = mod(floor(time * redflags * 0.75), redflags);
1076                 if(blueflags)
1077                         blueflags = mod(floor(time * blueflags * 0.75), blueflags);
1078
1079                 for (flag = ctf_worldflaglist; flag; flag = flag.ctf_worldflagnext) if(flag.cnt != FLAG_BASE)
1080                 {
1081                         if(flag.items & IT_KEY2) // blue
1082                         {
1083                                 if(--redflags == -1) // happens exactly once (redflags is in 0..count-1, and will --'ed count times)
1084                                         ctf_setstatus2(flag, IT_RED_FLAG_TAKEN);
1085                         }
1086                         else if(flag.items & IT_KEY1) // red
1087                         {
1088                                 if(--blueflags == -1) // happens exactly once
1089                                         ctf_setstatus2(flag, IT_BLUE_FLAG_TAKEN);
1090                         }
1091                 }
1092         }
1093 };
1094 /*
1095 entity(float cteam) ctf_team_has_commander =
1096 {
1097         entity pl;
1098         if(cteam != COLOR_TEAM1 || cteam != COLOR_TEAM2)
1099                 return world;
1100
1101         FOR_EACH_REALPLAYER(pl) {
1102                 if(pl.team == cteam && pl.iscommander) {
1103                         return pl;
1104                 }
1105         }
1106         return world;
1107 };
1108
1109 void(entity e, float st) ctf_setstate =
1110 {
1111         e.ctf_state = st;
1112         ++e.version;
1113 };
1114
1115 void(float cteam) ctf_new_commander =
1116 {
1117         entity pl, plmax;
1118
1119         plmax = world;
1120         FOR_EACH_REALPLAYER(pl) {
1121                 if(pl.team == cteam) {
1122                         if(pl.iscommander) { // don't reassign if alreay there
1123                                 return;
1124                         }
1125                         if(plmax == world || plmax.frags < pl.frags) <<<<<<<<<<<<<<<<< BROKEN in new scoring system
1126                                 plmax = pl;
1127                 }
1128         }
1129         if(plmax == world) {
1130                 bprint(strcat(ColoredTeamName(cteam), " Team has no Commander!\n"));
1131                 return;
1132         }
1133
1134         plmax.iscommander = TRUE;
1135         ctf_setstate(plmax, 3);
1136         sprint(plmax, "^3You're the commander now!\n");
1137         centerprint(plmax, "^3You're the commander now!\n");
1138 };
1139
1140 void() ctf_clientconnect =
1141 {
1142         self.iscommander = FALSE;
1143
1144         if(!self.team || self.classname != "player") {
1145                 ctf_setstate(self, -1);
1146         } else
1147                 ctf_setstate(self, 0);
1148
1149         self.team_saved = self.team;
1150
1151         if(self.team != 0 && self.classname == "player" && !ctf_team_has_commander(self.team)) {
1152                 ctf_new_commander(self.team);
1153         }
1154 };
1155
1156 void() ctf_playerchanged =
1157 {
1158         if(!self.team || self.classname != "player") {
1159                 ctf_setstate(self, -1);
1160         } else if(self.ctf_state < 0 && self.classname == "player") {
1161                 ctf_setstate(self, 0);
1162         }
1163
1164         if(self.iscommander &&
1165            (self.classname != "player" || self.team != self.team_saved)
1166                 )
1167         {
1168                 self.iscommander = FALSE;
1169                 if(self.classname == "player")
1170                         ctf_setstate(self, 0);
1171                 else
1172                         ctf_setstate(self, -1);
1173                 ctf_new_commander(self.team_saved);
1174         }
1175
1176         self.team_saved = self.team;
1177
1178         ctf_new_commander(self.team);
1179 };
1180
1181 void() ctf_clientdisconnect =
1182 {
1183         if(self.iscommander)
1184         {
1185                 ctf_new_commander(self.team);
1186         }
1187 };
1188
1189 entity GetPlayer(string);
1190 float() ctf_clientcommand =
1191 {
1192         entity e;
1193         if(argv(0) == "order") {
1194                 if(!g_ctf) {
1195                         sprint(self, "This command is not supported in this gamemode.\n");
1196                         return TRUE;
1197                 }
1198                 if(!self.iscommander) {
1199                         sprint(self, "^1You are not the commander!\n");
1200                         return TRUE;
1201                 }
1202                 if(argv(2) == "") {
1203                         sprint(self, "Usage: order #player status   - (playernumber as in status)\n");
1204                         return TRUE;
1205                 }
1206                 e = GetPlayer(argv(1));
1207                 if(e == world) {
1208                         sprint(self, "Invalid player.\nUsage: order #player status   - (playernumber as in status)\n");
1209                         return TRUE;
1210                 }
1211                 if(e.team != self.team) {
1212                         sprint(self, "^3You can only give orders to your own team!\n");
1213                         return TRUE;
1214                 }
1215                 if(argv(2) == "attack") {
1216                         sprint(self, strcat("Ordering ", e.netname, " to attack!\n"));
1217                         sprint(e, "^1Attack!\n");
1218                         centerprint(e, "^7You've been ordered to^9\n^1Attack!\n");
1219                         ctf_setstate(e, 1);
1220                 } else if(argv(2) == "defend") {
1221                         sprint(self, strcat("Ordering ", e.netname, " to defend!\n"));
1222                         sprint(e, "^Defend!\n");
1223                         centerprint(e, "^7You've been ordered to^9\n^2Defend!\n");
1224                         ctf_setstate(e, 2);
1225                 } else {
1226                         sprint(self, "^7Invalid command, use ^3attack^7, or ^3defend^7.\n");
1227                 }
1228                 return TRUE;
1229         }
1230         return FALSE;
1231 };
1232 */