data/qcsrc/server/keyhunt.qc

   1 #define FOR_EACH_KH_KEY(v) for(v = kh_worldkeylist; v; v = v.kh_worldkeynext )
   2
   3 // #define KH_PLAYER_USE_ATTACHMENT
   4 // #define KH_PLAYER_USE_CARRIEDMODEL
   5 // #define KH_KEY_ATTACHMENT_DEBUG
   6
   7 #ifdef KH_PLAYER_USE_ATTACHMENT
   8 vector KH_PLAYER_ATTACHMENT_DIST_ROTATED = '0 -4 0';
   9 vector KH_PLAYER_ATTACHMENT_DIST = '4 0 0';
  10 vector KH_PLAYER_ATTACHMENT = '0 0 0';
  11 vector KH_PLAYER_ATTACHMENT_ANGLES = '0 0 0';
  12 string KH_PLAYER_ATTACHMENT_BONE = "";
  13 #else
  14 float KH_KEY_ZSHIFT = 22;
  15 float KH_KEY_XYDIST = 24;
  16 float KH_KEY_XYSPEED = 45;
  17 #endif
  18 float KH_KEY_WP_ZSHIFT = 20;
  19
  20 vector KH_KEY_MIN = '-10 -10 -46';
  21 vector KH_KEY_MAX = '10 10 3';
  22 float KH_KEY_BRIGHTNESS = 2;
  23
  24 string kh_Controller_Waitmsg;
  25 float kh_no_radar_circles;
  26
  27 // kh_state
  28 //     bits 0-7: player's key status
  29 //     bits 8-15: general key status
  30 .float kh_state;
  31 .float siren_time;  //  time delay the siren
  32 //.float stuff_time;  //  time delay to stuffcmd a cvar
  33
  34 float test[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
  35 //test[0] = status of dropped keys, test[1 - 16] = player #
  36 //replace 17 with cvar("maxplayers") or similar !!!!!!!!!
  37 //for(i = 0; i < maxplayers; ++i)
  38 //      test[i] = "0";
  39
  40 float kh_Team_ByID(float t)
  41 {
  42         if(t == 0) return COLOR_TEAM1;
  43         if(t == 1) return COLOR_TEAM2;
  44         if(t == 2) return COLOR_TEAM3;
  45         if(t == 3) return COLOR_TEAM4;
  46         return 0;
  47 }
  48
  49 entity kh_worldkeylist;
  50 .entity kh_worldkeynext;
  51 entity kh_controller;
  52 float kh_tracking_enabled;
  53 float kh_teams;
  54 float kh_interferemsg_time, kh_interferemsg_team;
  55 .entity kh_next, kh_prev; // linked list
  56 .float kh_droptime;
  57 .float kh_dropperteam;
  58 .entity kh_previous_owner;
  59 .float kh_previous_owner_playerid;
  60
  61 string kh_sound_capture = "kh/capture.wav";
  62 string kh_sound_destroy = "kh/destroy.wav";
  63 string kh_sound_drop = "kh/drop.wav";
  64 string kh_sound_collect = "kh/collect.wav";
  65 string kh_sound_alarm = "kh/alarm.wav";  // the new siren/alarm
  66
  67 float kh_key_dropped, kh_key_carried;
  68
  69 void kh_Controller_SetThink(float t, string msg, kh_Think_t func)  // runs occasionaly
  70 {
  71         kh_Controller_Thinkfunc = func;
  72         kh_controller.cnt = ceil(t);
  73         if(kh_Controller_Waitmsg != "")
  74                 strunzone(kh_Controller_Waitmsg);
  75         if(msg == "")
  76                 kh_Controller_Waitmsg = "";
  77         else
  78                 kh_Controller_Waitmsg = strzone(msg);
  79         if(t == 0)
  80                 kh_controller.nextthink = time; // force
  81 }
  82
  83 void kh_Controller_Think()  // called a lot
  84 {
  85         entity e;
  86         if(intermission_running)
  87                 return;
  88         if(self.cnt > 0)
  89         {
  90                 if(kh_Controller_Waitmsg != "")
  91                 {
  92                         string s;
  93                         if(substring(kh_Controller_Waitmsg, strlen(kh_Controller_Waitmsg)-1, 1) == " ")
  94                                 s = strcat(kh_Controller_Waitmsg, ftos(self.cnt));
  95                         else
  96                                 s = kh_Controller_Waitmsg;
  97
  98                         //dprint(s, "\n");
  99
 100                         FOR_EACH_PLAYER(e)
 101                                 if(clienttype(e) == CLIENTTYPE_REAL)
 102                                         centerprint_atprio(e, CENTERPRIO_SPAM, s);
 103                 }
 104                 self.cnt -= 1;
 105         }
 106         else if(self.cnt == 0)
 107         {
 108                 self.cnt -= 1;
 109                 kh_Controller_Thinkfunc();
 110         }
 111         self.nextthink = time + 1;
 112 }
 113
 114 // frags f: take from cvar * f
 115 // frags 0: no frags
 116 void kh_Scores_Event(entity player, entity key, string what, float frags_player, float frags_owner)  // update the score when a key is captured
 117 {
 118         string s;
 119         if(intermission_running)
 120                 return;
 121         if(frags_player)
 122                 UpdateFrags(player, frags_player);
 123         if(key && key.owner && frags_owner)
 124                 UpdateFrags(key.owner, frags_owner);
 125         if(!cvar("sv_eventlog"))  //output extra info to the console or text file
 126                 return;
 127         s = strcat(":keyhunt:", what, ":", ftos(player.playerid));
 128         s = strcat(s, ":", ftos(frags_player));
 129         if(key && key.owner)
 130                 s = strcat(s, ":", ftos(key.owner.playerid));
 131         else
 132                 s = strcat(s, ":0");
 133         s = strcat(s, ":", ftos(frags_owner), ":");
 134         if(key)
 135                 s = strcat(s, key.netname);
 136         GameLogEcho(s);
 137 }
 138
 139 vector kh_AttachedOrigin(entity e)  // runs when a team captures the flag, it can run 2 or 3 times.
 140 {
 141         if(e.tag_entity)
 142         {
 143                 makevectors(e.tag_entity.angles);
 144                 return e.tag_entity.origin + e.origin_x * v_forward - e.origin_y * v_right + e.origin_z * v_up;
 145         }
 146         else
 147                 return e.origin;
 148 }
 149
 150 void kh_Key_Attach(entity key)  // runs when a player picks up a key and several times when a key is assigned to a player at the start of a round
 151 {
 152 #ifdef KH_PLAYER_USE_ATTACHMENT
 153         entity first;
 154         first = key.owner.kh_next;
 155         if(key == first)
 156         {
 157                 setattachment(key, key.owner, KH_PLAYER_ATTACHMENT_BONE);
 158                 if(key.kh_next)
 159                 {
 160                         setattachment(key.kh_next, key, "");
 161                         setorigin(key, key.kh_next.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 162                         setorigin(key.kh_next, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
 163                         key.kh_next.angles = '0 0 0';
 164                 }
 165                 else
 166                         setorigin(key, KH_PLAYER_ATTACHMENT);
 167                 key.angles = KH_PLAYER_ATTACHMENT_ANGLES;
 168         }
 169         else
 170         {
 171                 setattachment(key, key.kh_prev, "");
 172                 if(key.kh_next)
 173                         setattachment(key.kh_next, key, "");
 174                 setorigin(key, KH_PLAYER_ATTACHMENT_DIST_ROTATED);
 175                 setorigin(first, first.origin - 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 176                 key.angles = '0 0 0';
 177         }
 178 #else
 179         setattachment(key, key.owner, "");
 180         setorigin(key, '0 0 1' * KH_KEY_ZSHIFT);  // fixing x, y in think
 181         key.angles_y -= key.owner.angles_y;
 182 #endif
 183         key.flags = 0;
 184         key.solid = SOLID_NOT;
 185         key.movetype = MOVETYPE_NONE;
 186         key.team = key.owner.team;
 187         key.nextthink = time;
 188         key.damageforcescale = 0;
 189         key.takedamage = DAMAGE_NO;
 190         key.modelindex = kh_key_carried;
 191 }
 192
 193 void kh_Key_Detach(entity key) // runs every time a key is dropped or lost. Runs several times times when all the keys are captured
 194 {
 195         float i;
 196         i = test[key.owner.playerid];
 197                 if(key.netname == "^1red key")
 198                         i -= 1;
 199                 if(key.netname == "^4blue key")
 200                         i -= 2;
 201                 if(key.netname == "^3yellow key")
 202                         i -= 4;
 203                 if(key.netname == "^6pink key")
 204                         i -= 8;
 205         test[key.owner.playerid] = i;
 206
 207         kh_show_temp();
 208         if(key.owner)
 209                 key.owner.kh_state = (key.owner.kh_state | 255) - 255 + test[key.owner.playerid];
 210         //key.owner.kh_state += test[key.owner.playerid];
 211
 212 #ifdef KH_PLAYER_USE_ATTACHMENT
 213         entity first;
 214         first = key.owner.kh_next;
 215         if(key == first)
 216         {
 217                 if(key.kh_next)
 218                 {
 219                         setattachment(key.kh_next, key.owner, KH_PLAYER_ATTACHMENT_BONE);
 220                         setorigin(key.kh_next, key.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 221                         key.kh_next.angles = KH_PLAYER_ATTACHMENT_ANGLES;
 222                 }
 223         }
 224         else
 225         {
 226                 if(key.kh_next)
 227                         setattachment(key.kh_next, key.kh_prev, "");
 228                 setorigin(first, first.origin + 0.5 * KH_PLAYER_ATTACHMENT_DIST);
 229         }
 230         // in any case:
 231         setattachment(key, world, "");
 232         setorigin(key, key.owner.origin + '0 0 1' * (PL_MIN_z - KH_KEY_MIN_z));
 233         key.angles = key.owner.angles;
 234 #else
 235         setorigin(key, key.owner.origin + key.origin_z * '0 0 1');
 236         setattachment(key, world, "");
 237         key.angles_y += key.owner.angles_y;
 238 #endif
 239         key.flags = FL_ITEM;
 240         key.solid = SOLID_TRIGGER;
 241         key.movetype = MOVETYPE_TOSS;
 242         key.pain_finished = time + cvar("g_balance_keyhunt_delay_return");
 243         key.damageforcescale = cvar("g_balance_keyhunt_damageforcescale");
 244         key.takedamage = DAMAGE_YES;
 245         // let key.team stay
 246         key.modelindex = kh_key_dropped;
 247         key.kh_previous_owner = key.owner;
 248         key.kh_previous_owner_playerid = key.owner.playerid;
 249 }
 250
 251 void kh_Key_AssignTo(entity key, entity player)  // runs every time a key is picked up or assigned. Runs prior to kh_key_attach
 252 {
 253         entity k;
 254         float ownerteam0, ownerteam;
 255         if(key.owner == player)
 256                 return;
 257
 258         ownerteam0 = kh_Key_AllOwnedByWhichTeam();
 259
 260         if(key.owner)
 261         {
 262                 kh_Key_Detach(key);
 263
 264                 // remove from linked list
 265                 if(key.kh_next)
 266                         key.kh_next.kh_prev = key.kh_prev;
 267                 key.kh_prev.kh_next = key.kh_next;
 268                 key.kh_next = world;
 269                 key.kh_prev = world;
 270
 271                 if(key.owner.kh_next == world)
 272                 {
 273                         // No longer a key carrier
 274                         if(!kh_no_radar_circles)
 275                                 WaypointSprite_Ping(key.owner.waypointsprite_attachedforcarrier);
 276                         WaypointSprite_DetachCarrier(key.owner);
 277                 }
 278         }
 279
 280         key.owner = player;
 281
 282         if(player)
 283         {
 284                 // insert into linked list
 285                 key.kh_next = player.kh_next;
 286                 key.kh_prev = player;
 287                 player.kh_next = key;
 288                 if(key.kh_next)
 289                         key.kh_next.kh_prev = key;
 290
 291                 float i;
 292                 i = test[key.owner.playerid];
 293                         if(key.netname == "^1red key")
 294                                 i += 1;
 295                         if(key.netname == "^4blue key")
 296                                 i += 2;
 297                         if(key.netname == "^3yellow key")
 298                                 i += 4;
 299                         if(key.netname == "^6pink key")
 300                                 i += 8;
 301                 test[key.owner.playerid] = i;
 302
 303                 kh_Key_Attach(key);
 304
 305                 if(key.kh_next == world)
 306                 {
 307                         // player is now a key carrier
 308                         WaypointSprite_AttachCarrier("", player);
 309                         player.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_KeyCarrier_waypointsprite_visible_for_player;
 310                         WaypointSprite_UpdateRule(player.waypointsprite_attachedforcarrier, player.team, SPRITERULE_TEAMPLAY);
 311                         if(player.team == COLOR_TEAM1)
 312                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, "keycarrier-red", "keycarrier-friend", "keycarrier-red");
 313                         else if(player.team == COLOR_TEAM2)
 314                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, "keycarrier-blue", "keycarrier-friend", "keycarrier-blue");
 315                         else if(player.team == COLOR_TEAM3)
 316                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, "keycarrier-yellow", "keycarrier-friend", "keycarrier-yellow");
 317                         else if(player.team == COLOR_TEAM4)
 318                                 WaypointSprite_UpdateSprites(player.waypointsprite_attachedforcarrier, "keycarrier-pink", "keycarrier-friend", "keycarrier-pink");
 319                         WaypointSprite_UpdateTeamRadar(player.waypointsprite_attachedforcarrier, RADARICON_FLAGCARRIER, colormapPaletteColor(player.team - 1, 0));
 320                         if(!kh_no_radar_circles)
 321                                 WaypointSprite_Ping(player.waypointsprite_attachedforcarrier);
 322                 }
 323         }
 324
 325         // moved that here, also update if there's no player
 326         kh_show_temp();
 327         if(key.owner)
 328                 key.owner.kh_state = (key.owner.kh_state | 255) - 255 + test[key.owner.playerid];
 329
 330         key.pusher = world;
 331
 332         ownerteam = kh_Key_AllOwnedByWhichTeam();
 333         if(ownerteam != ownerteam0)
 334         {
 335                 if(ownerteam != -1)
 336                 {
 337                         kh_interferemsg_time = time + 0.2;
 338                         kh_interferemsg_team = player.team;
 339
 340                         // audit all key carrier sprites, update them to RUN HERE
 341                         FOR_EACH_KH_KEY(k)
 342                         {
 343                                 if(k.owner)
 344                                         WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, k.owner.waypointsprite_attachedforcarrier.model1, "keycarrier-finish", k.owner.waypointsprite_attachedforcarrier.model3);
 345                         }
 346                 }
 347                 else
 348                 {
 349                         kh_interferemsg_time = 0;
 350
 351                         // audit all key carrier sprites, update them to RUN HERE
 352                         FOR_EACH_KH_KEY(k)
 353                         {
 354                                 if(k.owner)
 355                                         WaypointSprite_UpdateSprites(k.owner.waypointsprite_attachedforcarrier, k.owner.waypointsprite_attachedforcarrier.model1, "keycarrier-friend", k.owner.waypointsprite_attachedforcarrier.model3);
 356                         }
 357                 }
 358         }
 359 }
 360
 361 void kh_Key_Damage(entity inflictor, entity attacker, float damage, float deathtype, vector hitloc, vector force)
 362 {
 363         if(self.owner)
 364                 return;
 365         if(vlen(force) <= 0)
 366                 return;
 367         if(time > self.pushltime)
 368                 if(attacker.classname == "player")
 369                         self.team = attacker.team;
 370 }
 371
 372 void key_reset()
 373 {
 374         kh_Key_AssignTo(self, world);
 375         kh_Key_Remove(self);
 376 }
 377
 378 void kh_Key_Spawn(entity initial_owner, float angle)  // runs every time a new flag is created, ie after all the keys have been collected
 379 {
 380         entity key;
 381         key = spawn();
 382         key.classname = STR_ITEM_KH_KEY;
 383         key.touch = kh_Key_Touch;
 384         key.think = kh_Key_Think;
 385         key.nextthink = time;
 386         key.items = IT_KEY1 | IT_KEY2;
 387         key.cnt = angle;
 388         key.angles = '0 360 0' * random();
 389         key.event_damage = kh_Key_Damage;
 390         key.takedamage = DAMAGE_YES;
 391         key.modelindex = kh_key_dropped;
 392         key.model = "key";
 393         key.kh_dropperteam = 0;
 394         key.dphitcontentsmask = DPCONTENTS_SOLID | DPCONTENTS_BODY | DPCONTENTS_PLAYERCLIP;
 395         setsize(key, KH_KEY_MIN, KH_KEY_MAX);
 396         key.colormod = TeamColor(initial_owner.team) * KH_KEY_BRIGHTNESS;
 397         key.reset = key_reset;
 398
 399         switch(initial_owner.team)
 400         {
 401                 case COLOR_TEAM1:
 402                         key.netname = "^1red key";
 403                         break;
 404                 case COLOR_TEAM2:
 405                         key.netname = "^4blue key";
 406                         break;
 407                 case COLOR_TEAM3:
 408                         key.netname = "^3yellow key";
 409                         break;
 410                 case COLOR_TEAM4:
 411                         key.netname = "^6pink key";
 412                         break;
 413                 default:
 414                         key.netname = "NETGIER key";
 415                         break;
 416         }
 417
 418         // link into key list
 419         key.kh_worldkeynext = kh_worldkeylist;
 420         kh_worldkeylist = key;
 421
 422         centerprint(initial_owner, strcat("You are starting with the ", key.netname, "\n"));  // message to player at start of round
 423
 424         WaypointSprite_Spawn("key-dropped", 0, 0, key, '0 0 1' * KH_KEY_WP_ZSHIFT, world, key.team, key, waypointsprite_attachedforcarrier, FALSE);
 425         key.waypointsprite_attachedforcarrier.waypointsprite_visible_for_player = kh_Key_waypointsprite_visible_for_player;
 426         WaypointSprite_UpdateTeamRadar(key.waypointsprite_attachedforcarrier, RADARICON_FLAG, '0 1 1');
 427
 428         kh_Key_AssignTo(key, initial_owner);
 429 }
 430
 431 void kh_Key_Remove(entity key)  // runs after when all the keys have been collected or when a key has been dropped for more than X seconds
 432 {
 433         entity o;
 434         o = key.owner;
 435         kh_Key_AssignTo(key, world);
 436         if(o) // it was attached
 437                 WaypointSprite_Kill(key.waypointsprite_attachedforcarrier);
 438         else // it was dropped
 439                 WaypointSprite_DetachCarrier(key);
 440
 441         // remove key from key list
 442         if (kh_worldkeylist == key)
 443                 kh_worldkeylist = kh_worldkeylist.kh_worldkeynext;
 444         else
 445         {
 446                 o = kh_worldkeylist;
 447                 while (o)
 448                 {
 449                         if (o.kh_worldkeynext == key)
 450                         {
 451                                 o.kh_worldkeynext = o.kh_worldkeynext.kh_worldkeynext;
 452                                 break;
 453                         }
 454                         o = o.kh_worldkeynext;
 455                 }
 456         }
 457
 458         remove(key);
 459 }
 460
 461 // -1 when no team completely owns all keys yet
 462 float kh_Key_AllOwnedByWhichTeam()  // constantly called. check to see if all the keys are owned by the same team
 463 {
 464         entity key;
 465         float teem;
 466         float keys;
 467
 468         teem = -1;
 469         keys = kh_teams;
 470         FOR_EACH_KH_KEY(key)
 471         {
 472                 if(!key.owner)
 473                         return -1;
 474                 if(teem == -1)
 475                         teem = key.team;
 476                 else if(teem != key.team)
 477                         return -1;
 478                 --keys;
 479         }
 480         if(keys != 0)
 481                 return -1;
 482         return teem;
 483 }
 484
 485 void kh_Key_Collect(entity key, entity player)  //a player picks up a dropped key
 486 {
 487         sound(player, CHAN_AUTO, kh_sound_collect, VOL_BASE, ATTN_NORM);
 488
 489         if(key.kh_dropperteam != player.team)
 490         {
 491                 kh_Scores_Event(player, key, "collect", cvar("g_balance_keyhunt_score_collect"), 0);
 492                 PlayerScore_Add(player, SP_KH_PICKUPS, 1);
 493         }
 494         key.kh_dropperteam = 0;
 495         bprint(player.netname, "^7 picked up the ", key.netname, "\n");
 496
 497         kh_Key_AssignTo(key, player); // this also updates .kh_state
 498 }
 499
 500 void kh_Key_DropAll(entity player, float suicide) // runs whenever a player dies
 501 {
 502         entity key;
 503         entity mypusher;
 504         if(player.kh_next)
 505         {
 506                 mypusher = world;
 507                 if(player.pusher)
 508                         if(time < player.pushltime)
 509                                 mypusher = player.pusher;
 510                 while((key = player.kh_next))
 511                 {
 512                         kh_Scores_Event(player, key, "losekey", 0, 0);
 513                         PlayerScore_Add(player, SP_KH_LOSSES, 1);
 514                         bprint(player.netname, "^7 died and lost the ", key.netname, "\n");
 515                         kh_Key_AssignTo(key, world);
 516                         makevectors('-1 0 0' * (45 + 45 * random()) + '0 360 0' * random());
 517                         key.velocity = W_CalculateProjectileVelocity(player.velocity, cvar("g_balance_keyhunt_dropvelocity") * v_forward);
 518                         key.pusher = mypusher;
 519                         key.pushltime = time + cvar("g_balance_keyhunt_protecttime");
 520                         if(suicide)
 521                                 key.kh_dropperteam = player.team;
 522                 }
 523                 sound(player, CHAN_AUTO, kh_sound_drop, VOL_BASE, ATTN_NORM);
 524         }
 525 }
 526
 527 void kh_Key_Touch()  // runs many, many times when a key has been dropped and can be picked up
 528 {
 529         if(intermission_running)
 530                 return;
 531
 532         if(self.owner) // already carried
 533                 return;
 534         if(other.classname != "player")
 535                 return;
 536         if(other.deadflag != DEAD_NO)
 537                 return;
 538         if(other == self.enemy)
 539                 if(time < self.kh_droptime + cvar("g_balance_keyhunt_delay_collect"))
 540                         return;  // you just dropped it!
 541         kh_Key_Collect(self, other);
 542 }
 543
 544 void kh_Key_Think()  // runs all the time
 545 {
 546         entity head;
 547         //entity player;  // needed by FOR_EACH_PLAYER
 548
 549         if(intermission_running)
 550                 return;
 551         /*
 552         if(time > self.stuff_time)
 553         {
 554                 FOR_EACH_PLAYER(player)
 555                         player.kh_state = test[0]*256 + (player.kh_state&255);
 556
 557                 self.stuff_time = time + 1;  // repeat in 1 second
 558         }
 559         */
 560
 561 #ifdef KH_KEY_ATTACHMENT_DEBUG
 562         if(self.kh_prev == self.owner)
 563         {
 564                 if(cvar_string("_angles") != "")
 565                 {
 566                         self.angles = stov(cvar_string("_angles"));
 567                         setorigin(self, stov(cvar_string("_origin")));
 568                 }
 569         }
 570 #endif
 571
 572         if(self.owner)
 573         {
 574 #ifndef KH_PLAYER_USE_ATTACHMENT
 575                 makevectors('0 1 0' * (self.cnt + mod(time, 360) * KH_KEY_XYSPEED));
 576                 setorigin(self, v_forward * KH_KEY_XYDIST + '0 0 1' * self.origin_z);
 577 #endif
 578
 579                 if(self.owner.BUTTON_USE)
 580                 if(time >= self.owner.kh_droptime + cvar("g_balance_keyhunt_delay_drop"))
 581                 {
 582                         self.owner.kh_droptime = time;
 583                         self.kh_droptime = time;  // prevent collecting this one for some time
 584                         self.enemy = self.owner;
 585                         self.pusher = world;
 586                         kh_Scores_Event(self.owner, self, "dropkey", 0, 0);
 587                         bprint(self.owner.netname, "^7 dropped the ", self.netname, "\n");
 588                         sound(self.owner, CHAN_AUTO, kh_sound_drop, VOL_BASE, ATTN_NORM);
 589                         makevectors(self.owner.v_angle);
 590                         self.velocity = W_CalculateProjectileVelocity(self.owner.velocity, cvar("g_balance_keyhunt_throwvelocity") * v_forward);
 591                         kh_Key_AssignTo(self, world);
 592                         self.pushltime = time + cvar("g_balance_keyhunt_protecttime");
 593                         self.kh_dropperteam = self.team;
 594                 }
 595         }
 596
 597         // if in nodrop or time over, end the round
 598         if(!self.owner)
 599                 if(time > self.pain_finished)
 600                         kh_LoserTeam(self.team, self);
 601
 602         if(self.owner)
 603         if(kh_Key_AllOwnedByWhichTeam() != -1)
 604         {
 605                 if(self.siren_time < time)
 606                 {
 607                         sound(self.owner, CHAN_AUTO, kh_sound_alarm, VOL_BASE, ATTN_NORM);  // play a simple alarm
 608                         self.siren_time = time + 2.5;  // repeat every 2.5 seconds
 609                 }
 610
 611                 entity key;
 612                 vector p;
 613                 p = self.owner.origin;
 614                 FOR_EACH_KH_KEY(key)
 615                         if(vlen(key.owner.origin - p) > cvar("g_balance_keyhunt_maxdist"))
 616                                 goto not_winning;
 617                 kh_WinnerTeam(self.team);
 618 :not_winning
 619         }
 620
 621         if(kh_interferemsg_time && time > kh_interferemsg_time)
 622         {
 623                 kh_interferemsg_time = 0;
 624                 FOR_EACH_PLAYER(head)
 625                 {
 626                         if(head.team == kh_interferemsg_team)
 627                                 if(head.kh_next)
 628                                         centerprint(head, "All keys are in your team's hands!\n\nMeet the other key carriers ^1NOW^7!");
 629                                 else
 630                                         centerprint(head, "All keys are in your team's hands!\n\nHelp the key carriers to meet!");
 631                         else
 632                                 centerprint(head, strcat("All keys are in the ", ColoredTeamName(kh_interferemsg_team), "^7's hands!\n\nInterfere ^1NOW^7!"));
 633                 }
 634         }
 635
 636         self.nextthink = time + 0.05;
 637 }
 638
 639 void kh_WinnerTeam(float teem)  // runs when a team wins
 640 {
 641         // all key carriers get some points
 642         vector firstorigin, lastorigin, midpoint;
 643         float first;
 644         entity key;
 645         float score;
 646         score = (kh_teams - 1) * cvar("g_balance_keyhunt_score_capture");
 647         DistributeEvenly_Init(score, kh_teams);
 648         // twice the score for 3 team games, three times the score for 4 team games!
 649         // note: for a win by destroying the key, this should NOT be applied
 650         FOR_EACH_KH_KEY(key)
 651         {
 652                 float f;
 653                 f = DistributeEvenly_Get(1);
 654                 kh_Scores_Event(key.owner, key, "capture", f, 0);
 655                 PlayerTeamScore_Add(key.owner, SP_KH_CAPS, ST_KH_CAPS, 1);
 656         }
 657
 658         first = TRUE;
 659         FOR_EACH_KH_KEY(key)
 660                 if(key.owner.kh_next == key)
 661                 {
 662                         if(!first)
 663                                 bprint("^7, ");
 664                         bprint(key.owner.netname);
 665                         first = FALSE;
 666                 }
 667         bprint("^7 captured the keys for the ", ColoredTeamName(teem), "\n");
 668
 669         first = TRUE;
 670         midpoint = '0 0 0';
 671         FOR_EACH_KH_KEY(key)
 672         {
 673                 vector thisorigin;
 674
 675                 thisorigin = kh_AttachedOrigin(key);
 676                 //dprint("Key origin: ", vtos(thisorigin), "\n");
 677                 midpoint += thisorigin;
 678
 679                 if(!first)
 680                         te_lightning2(world, lastorigin, thisorigin);
 681                 lastorigin = thisorigin;
 682                 if(first)
 683                         firstorigin = thisorigin;
 684                 first = FALSE;
 685         }
 686         if(kh_teams > 2)
 687         {
 688                 te_lightning2(world, lastorigin, firstorigin);
 689         }
 690         midpoint = midpoint * (1 / kh_teams);
 691         te_customflash(midpoint, 1000, 1, TeamColor(teem) * 0.5 + '0.5 0.5 0.5');  // make the color >=0.5 in each component
 692
 693         play2all(kh_sound_capture);
 694         kh_FinishRound();
 695 }
 696
 697 void kh_LoserTeam(float teem, entity lostkey)  // runs when a player pushes a flag carrier off the map
 698 {
 699         entity player, key, attacker;
 700         float players;
 701         float keys;
 702         float f;
 703
 704         attacker = world;
 705         if(lostkey.pusher)
 706                 if(lostkey.pusher.team != teem)
 707                         if(lostkey.pusher.classname == "player")
 708                                 attacker = lostkey.pusher;
 709
 710         players = keys = 0;
 711
 712         if(attacker)
 713         {
 714                 if(lostkey.kh_previous_owner)
 715                         kh_Scores_Event(lostkey.kh_previous_owner, world, "pushed", 0, -cvar("g_balance_keyhunt_score_push"));
 716                         // don't actually GIVE him the -nn points, just log
 717                 kh_Scores_Event(attacker, world, "push", cvar("g_balance_keyhunt_score_push"), 0);
 718                 PlayerScore_Add(attacker, SP_KH_PUSHES, 1);
 719                 centerprint(attacker, "Your push is the best!");
 720                 bprint("The ", ColoredTeamName(teem), "^7 could not take care of the ", lostkey.netname, "^7 when ", attacker.netname, "^7 came\n");
 721         }
 722         else
 723         {
 724                 float of, fragsleft, i, j, thisteam;
 725                 of = cvar("g_balance_keyhunt_score_destroyed_ownfactor");
 726
 727                 FOR_EACH_PLAYER(player)
 728                         if(player.team != teem)
 729                                 ++players;
 730
 731                 FOR_EACH_KH_KEY(key)
 732                         if(key.owner && key.team != teem)
 733                                 ++keys;
 734
 735                 if(lostkey.kh_previous_owner)
 736                         kh_Scores_Event(lostkey.kh_previous_owner, world, "destroyed", 0, -cvar("g_balance_keyhunt_score_destroyed"));
 737                         // don't actually GIVE him the -nn points, just log
 738
 739                 if(lostkey.kh_previous_owner.playerid == lostkey.kh_previous_owner_playerid)
 740                         PlayerScore_Add(lostkey.kh_previous_owner, SP_KH_DESTROYS, 1);
 741
 742                 DistributeEvenly_Init(cvar("g_balance_keyhunt_score_destroyed"), keys * of + players);
 743
 744                 FOR_EACH_KH_KEY(key)
 745                         if(key.owner && key.team != teem)
 746                         {
 747                                 f = DistributeEvenly_Get(of);
 748                                 kh_Scores_Event(key.owner, world, "destroyed_holdingkey", f, 0);
 749                         }
 750
 751                 fragsleft = DistributeEvenly_Get(players);
 752
 753                 // Now distribute these among all other teams...
 754                 j = kh_teams - 1;
 755                 for(i = 0; i < kh_teams; ++i)
 756                 {
 757                         thisteam = kh_Team_ByID(i);
 758                         if(thisteam == teem) // bad boy, no cookie - this WILL happen
 759                                 continue;
 760
 761                         players = 0;
 762                         FOR_EACH_PLAYER(player)
 763                                 if(player.team == thisteam)
 764                                         ++players;
 765
 766                         DistributeEvenly_Init(fragsleft, j);
 767                         fragsleft = DistributeEvenly_Get(j - 1);
 768                         DistributeEvenly_Init(DistributeEvenly_Get(1), players);
 769
 770                         FOR_EACH_PLAYER(player)
 771                                 if(player.team == thisteam)
 772                                 {
 773                                         f = DistributeEvenly_Get(1);
 774                                         kh_Scores_Event(player, world, "destroyed", f, 0);
 775                                 }
 776
 777                         --j;
 778                 }
 779
 780                 bprint("The ", ColoredTeamName(teem), "^7 could not take care of the ", lostkey.netname, "\n");
 781         }
 782         play2all(kh_sound_destroy);
 783         te_tarexplosion(lostkey.origin);
 784
 785         kh_FinishRound();
 786 }
 787
 788 void kh_FinishRound()  // runs when a team captures the keys
 789 {
 790         // prepare next round
 791         kh_interferemsg_time = 0;
 792         entity key;
 793
 794         kh_no_radar_circles = TRUE;
 795         FOR_EACH_KH_KEY(key)
 796                 kh_Key_Remove(key);
 797         kh_no_radar_circles = FALSE;
 798
 799         kh_Controller_SetThink(cvar("g_balance_keyhunt_delay_round"), "Round starts in ", kh_StartRound);
 800 }
 801
 802 string kh_CheckEnoughPlayers()  // checks enough player are present, runs after every completed round
 803 {
 804         float i, players, teem;
 805         entity player;
 806         string result;
 807         result = "";
 808
 809         // find a random player per team
 810         for(i = 0; i < kh_teams; ++i)
 811         {
 812                 teem = kh_Team_ByID(i);
 813                 players = 0;
 814                 FOR_EACH_PLAYER(player)
 815                         if(player.deadflag == DEAD_NO)
 816                                 if(!player.BUTTON_CHAT)
 817                                         if(player.team == teem)
 818                                                 ++players;
 819                 if(players == 0)
 820                 {
 821                         if(result != "")
 822                                 result = strcat(result, ", ");
 823                         result = strcat(result, ColoredTeamName(teem));
 824                 }
 825         }
 826         return result;
 827 }
 828
 829 void kh_WaitForPlayers()  // delay start of the round until enough players are present
 830 {
 831         string teams_missing;
 832
 833         if(time < game_starttime)
 834         {
 835                 kh_Controller_SetThink(game_starttime - time + 0.1, "", kh_WaitForPlayers);
 836                 return;
 837         }
 838
 839         teams_missing = kh_CheckEnoughPlayers();
 840         if(teams_missing == "")
 841                 kh_Controller_SetThink(cvar("g_balance_keyhunt_delay_round"), "Round starts in ", kh_StartRound);
 842         else
 843                 kh_Controller_SetThink(1, strcat("Waiting for players to join...\n\nNeed active players for: ", teams_missing), kh_WaitForPlayers);
 844 }
 845
 846 void kh_StartRound()  // runs at the start of each round
 847 {
 848         string teams_missing;
 849         float i, players, teem;
 850         entity player;
 851
 852         if(time < game_starttime)
 853         {
 854                 kh_Controller_SetThink(game_starttime - time + 0.1, "", kh_WaitForPlayers);
 855                 return;
 856         }
 857
 858         teams_missing = kh_CheckEnoughPlayers();
 859         if(teams_missing != "")
 860         {
 861                 kh_Controller_SetThink(1, strcat("Waiting for players to join...\n\nNeed active players for: ", teams_missing), kh_WaitForPlayers);
 862                 return;
 863         }
 864
 865         FOR_EACH_PLAYER(player)
 866                 if(clienttype(player) == CLIENTTYPE_REAL)
 867                         centerprint_expire(player, CENTERPRIO_SPAM);
 868
 869         for(i = 0; i < kh_teams; ++i)
 870         {
 871                 teem = kh_Team_ByID(i);
 872                 players = 0;
 873                 entity my_player;
 874                 FOR_EACH_PLAYER(player)
 875                         if(player.deadflag == DEAD_NO)
 876                                 if(!player.BUTTON_CHAT)
 877                                         if(player.team == teem)
 878                                         {
 879                                                 ++players;
 880                                                 if(random() * players <= 1)
 881                                                         my_player = player;
 882                                         }
 883                 kh_Key_Spawn(my_player, 360 * i / kh_teams);
 884                 //kh_Key_Spawn(my_player, 360 * i / kh_teams);
 885                 //kh_Key_Spawn(my_player, 360 * i / kh_teams);
 886         }
 887
 888         kh_tracking_enabled = FALSE;
 889         kh_Controller_SetThink(cvar("g_balance_keyhunt_delay_tracking"), "Scanning frequency range...", kh_EnableTrackingDevice);
 890 }
 891
 892 void kh_setstatus()  // runs all the time
 893 {
 894         if(kh_teams)
 895         {
 896                 float kh_KEY;
 897                 kh_KEY = (IT_RED_FLAG_TAKEN | IT_RED_FLAG_LOST | IT_BLUE_FLAG_TAKEN | IT_BLUE_FLAG_LOST);  // the one impossible combination
 898                 if(self.kh_next)
 899                         self.items = self.items | kh_KEY;
 900                 else
 901                         self.items = self.items - (self.items & kh_KEY);
 902         }
 903 }
 904
 905 void kh_EnableTrackingDevice()  // runs after each round
 906 {
 907         entity player;
 908
 909         FOR_EACH_PLAYER(player)
 910                 if(clienttype(player) == CLIENTTYPE_REAL)
 911                         centerprint_expire(player, CENTERPRIO_SPAM);
 912
 913         kh_tracking_enabled = TRUE;
 914 }
 915
 916 float kh_Key_waypointsprite_visible_for_player(entity e) // ??
 917 {
 918         if(!kh_tracking_enabled)
 919                 return FALSE;
 920         if(!self.owner)
 921                 return TRUE;
 922         if(!self.owner.owner)
 923                 return TRUE;
 924         return FALSE;  // draw only when key is not owned
 925 }
 926
 927 float kh_KeyCarrier_waypointsprite_visible_for_player(entity e)  // runs all the time
 928 {
 929         if(e.classname != "player" || self.team != e.team)
 930                 if(!kh_tracking_enabled)
 931                         return FALSE;
 932
 933         return TRUE;
 934 }
 935
 936 float kh_HandleFrags(entity attacker, entity targ, float f)  // adds to the player score
 937 {
 938         if(attacker == targ)
 939                 return f;
 940
 941         if(targ.kh_next)
 942         {
 943                 if(attacker.team == targ.team)
 944                 {
 945                         entity k;
 946                         float nk;
 947                         nk = 0;
 948                         for(k = targ.kh_next; k != world; k = k.kh_next)
 949                                 ++nk;
 950                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", -nk * cvar("g_balance_keyhunt_score_collect"), 0);
 951                 }
 952                 else
 953                 {
 954                         kh_Scores_Event(attacker, targ.kh_next, "carrierfrag", cvar("g_balance_keyhunt_score_carrierfrag")-1, 0);
 955                         PlayerScore_Add(attacker, SP_KH_KCKILLS, 1);
 956                         // the frag gets added later
 957                 }
 958         }
 959
 960         return f;
 961 }
 962
 963 void kh_init()  // sets up th KH environment
 964 {
 965         precache_sound(kh_sound_capture);
 966         precache_sound(kh_sound_destroy);
 967         precache_sound(kh_sound_drop);
 968         precache_sound(kh_sound_collect);
 969         precache_sound(kh_sound_alarm);  // the new siren
 970
 971 #ifdef KH_PLAYER_USE_CARRIEDMODEL
 972         precache_model("models/keyhunt/key-carried.md3");
 973 #endif
 974         precache_model("models/keyhunt/key.md3");
 975
 976         // setup variables
 977         kh_teams = cvar("g_keyhunt_teams_override");
 978         if(kh_teams < 2)
 979                 kh_teams = cvar("g_keyhunt_teams");
 980         kh_teams = bound(2, kh_teams, 4);
 981
 982         // make a KH entity for controlling the game
 983         kh_controller = spawn();
 984         kh_controller.think = kh_Controller_Think;
 985         kh_Controller_SetThink(0, "", kh_WaitForPlayers);
 986
 987         setmodel(kh_controller, "models/keyhunt/key.md3");
 988         kh_key_dropped = kh_controller.modelindex;
 989         /*
 990         dprint(vtos(kh_controller.mins));
 991         dprint(vtos(kh_controller.maxs));
 992         dprint("\n");
 993         */
 994 #ifdef KH_PLAYER_USE_CARRIEDMODEL
 995         setmodel(kh_controller, "models/keyhunt/key-carried.md3");
 996         kh_key_carried = kh_controller.modelindex;
 997 #else
 998         kh_key_carried = kh_key_dropped;
 999 #endif
1000
1001         kh_controller.model = "";
1002         kh_controller.modelindex = 0;
1003
1004         addstat(STAT_KH_KEYS, AS_INT, kh_state);
1005
1006         ScoreRules_kh(kh_teams);
1007 }
1008
1009 void kh_finalize()
1010 {
1011         // to be called before intermission
1012         kh_FinishRound();
1013         remove(kh_controller);
1014         kh_controller = world;
1015 }
1016
1017 /**
1018  * kh_show_temp originally by victim.
1019  * changed it to use the kh_state stat var
1020  * Updates the general key stat bits for each player
1021  */
1022 void kh_show_temp()
1023 {
1024         entity player;
1025         float i, j;
1026
1027         j = 0;  // reset/blank j
1028         for(i=1; i<17; ++i)  // replace 17 with cvar("maxplayers"); !!!!!!!!!
1029                 j += test[i];
1030
1031         test[0] = j;
1032
1033         j *= 256;
1034         FOR_EACH_PLAYER(player)
1035                 player.kh_state = j + (player.kh_state & 255); // update the general key bits
1036 }