qcsrc/server/cl_client.qc

   1 #include "waypointsprites.qh"
   2
   3 #include "cl_impulse.qh"
   4 #include "cl_player.qh"
   5 #include "ent_cs.qh"
   6 #include "g_subs.qh"
   7 #include "ipban.qh"
   8 #include "miscfunctions.qh"
   9 #include "portals.qh"
  10 #include "teamplay.qh"
  11 #include "playerdemo.qh"
  12 #include "secret.qh"
  13
  14 #include "bot/bot.qh"
  15 #include "bot/navigation.qh"
  16
  17 #include "weapons/hitplot.qh"
  18 #include "weapons/weaponsystem.qh"
  19
  20 #include "../common/net_notice.qh"
  21
  22 #include "../common/monsters/sv_monsters.qh"
  23
  24 #include "../warpzonelib/server.qh"
  25
  26 float c1, c2, c3, c4;
  27
  28 void send_CSQC_teamnagger() {
  29         WriteByte(MSG_BROADCAST, SVC_TEMPENTITY);
  30         WriteByte(MSG_BROADCAST, TE_CSQC_TEAMNAGGER);
  31 }
  32
  33 float ClientData_Send(entity to, int sf)
  34 {
  35         if(to != self.owner)
  36         {
  37                 error("wtf");
  38                 return false;
  39         }
  40
  41         entity e;
  42
  43         e = to;
  44         if(IS_SPEC(to))
  45                 e = to.enemy;
  46
  47         sf = 0;
  48
  49         if(e.race_completed)
  50                 sf |= 1; // forced scoreboard
  51         if(to.spectatee_status)
  52                 sf |= 2; // spectator ent number follows
  53         if(e.zoomstate)
  54                 sf |= 4; // zoomed
  55         if(e.porto_v_angle_held)
  56                 sf |= 8; // angles held
  57
  58         WriteByte(MSG_ENTITY, ENT_CLIENT_CLIENTDATA);
  59         WriteByte(MSG_ENTITY, sf);
  60
  61         if(sf & 2)
  62                 WriteByte(MSG_ENTITY, to.spectatee_status);
  63
  64         if(sf & 8)
  65         {
  66                 WriteAngle(MSG_ENTITY, e.v_angle.x);
  67                 WriteAngle(MSG_ENTITY, e.v_angle.y);
  68         }
  69
  70         return true;
  71 }
  72
  73 void ClientData_Attach()
  74 {
  75         Net_LinkEntity(self.clientdata = spawn(), false, 0, ClientData_Send);
  76         self.clientdata.drawonlytoclient = self;
  77         self.clientdata.owner = self;
  78 }
  79
  80 void ClientData_Detach()
  81 {
  82         remove(self.clientdata);
  83         self.clientdata = world;
  84 }
  85
  86 void ClientData_Touch(entity e)
  87 {
  88         e.clientdata.SendFlags = 1;
  89
  90         // make it spectatable
  91         entity e2;
  92         FOR_EACH_REALCLIENT(e2)
  93         {
  94                 if(e2 != e)
  95                         if(IS_SPEC(e2))
  96                                 if(e2.enemy == e)
  97                                         e2.clientdata.SendFlags = 1;
  98         }
  99 }
 100
 101 .string netname_previous;
 102
 103 void SetSpectator(entity player, entity spectatee);
 104
 105
 106 /*
 107 =============
 108 CheckPlayerModel
 109
 110 Checks if the argument string can be a valid playermodel.
 111 Returns a valid one in doubt.
 112 =============
 113 */
 114 string FallbackPlayerModel;
 115 string CheckPlayerModel(string plyermodel) {
 116         if(FallbackPlayerModel != cvar_defstring("_cl_playermodel"))
 117         {
 118                 // note: we cannot summon Don Strunzone here, some player may
 119                 // still have the model string set. In case anyone manages how
 120                 // to change a cvar default, we'll have a small leak here.
 121                 FallbackPlayerModel = strzone(cvar_defstring("_cl_playermodel"));
 122         }
 123         // only in right path
 124         if( substring(plyermodel,0,14) != "models/player/")
 125                 return FallbackPlayerModel;
 126         // only good file extensions
 127         if(substring(plyermodel,-4,4) != ".zym")
 128         if(substring(plyermodel,-4,4) != ".dpm")
 129         if(substring(plyermodel,-4,4) != ".iqm")
 130         if(substring(plyermodel,-4,4) != ".md3")
 131         if(substring(plyermodel,-4,4) != ".psk")
 132                 return FallbackPlayerModel;
 133         // forbid the LOD models
 134         if(substring(plyermodel, -9,5) == "_lod1")
 135                 return FallbackPlayerModel;
 136         if(substring(plyermodel, -9,5) == "_lod2")
 137                 return FallbackPlayerModel;
 138         if(plyermodel != strtolower(plyermodel))
 139                 return FallbackPlayerModel;
 140         // also, restrict to server models
 141         if(autocvar_sv_servermodelsonly)
 142         {
 143                 if(!fexists(plyermodel))
 144                         return FallbackPlayerModel;
 145         }
 146         return plyermodel;
 147 }
 148
 149 void setplayermodel(entity e, string modelname)
 150 {
 151         precache_model(modelname);
 152         setmodel(e, modelname);
 153         player_setupanimsformodel();
 154         UpdatePlayerSounds();
 155 }
 156
 157 /*
 158 =============
 159 PutObserverInServer
 160
 161 putting a client as observer in the server
 162 =============
 163 */
 164 void FixPlayermodel();
 165 void PutObserverInServer (void)
 166 {
 167         entity  spot;
 168     self.hud = HUD_NORMAL;
 169
 170         if(IS_PLAYER(self)) { pointparticles(particleeffectnum("spawn_event_neutral"), self.origin, '0 0 0', 1); }
 171
 172         spot = SelectSpawnPoint (true);
 173         if(!spot)
 174                 error("No spawnpoints for observers?!?\n");
 175         RemoveGrapplingHook(self); // Wazat's Grappling Hook
 176
 177         if(IS_REAL_CLIENT(self))
 178         {
 179                 msg_entity = self;
 180                 WriteByte(MSG_ONE, SVC_SETVIEW);
 181                 WriteEntity(MSG_ONE, self);
 182         }
 183
 184         self.frags = FRAGS_SPECTATOR;
 185
 186         MUTATOR_CALLHOOK(MakePlayerObserver);
 187
 188         Portal_ClearAll(self);
 189
 190         Unfreeze(self);
 191
 192         if(self.alivetime)
 193         {
 194                 if(!warmup_stage)
 195                         PS_GR_P_ADDVAL(self, PLAYERSTATS_ALIVETIME, time - self.alivetime);
 196                 self.alivetime = 0;
 197         }
 198
 199         if(self.vehicle)
 200                 vehicles_exit(VHEF_RELEASE);
 201
 202         WaypointSprite_PlayerDead();
 203
 204         if (!g_ca)  // don't reset teams when moving a ca player to the spectators
 205                 self.team = -1;  // move this as it is needed to log the player spectating in eventlog
 206
 207         if(self.killcount != -666)
 208         {
 209                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_QUIT_SPECTATE, self.netname);
 210                 if(autocvar_g_chat_nospectators == 1 || (cvar("g_warmup") && !(warmup_stage || gameover) && autocvar_g_chat_nospectators == 2))
 211                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_CHAT_NOSPECTATORS);
 212
 213                 if(self.just_joined == false) {
 214                         LogTeamchange(self.playerid, -1, 4);
 215                 } else
 216                         self.just_joined = false;
 217         }
 218
 219         PlayerScore_Clear(self); // clear scores when needed
 220
 221         accuracy_resend(self);
 222
 223         self.spectatortime = time;
 224
 225         self.classname = "observer";
 226         self.iscreature = false;
 227         self.teleportable = TELEPORT_SIMPLE;
 228         self.damagedbycontents = false;
 229         self.health = -666;
 230         self.takedamage = DAMAGE_NO;
 231         self.solid = SOLID_NOT;
 232         self.movetype = MOVETYPE_FLY_WORLDONLY; // user preference is controlled by playerprethink
 233         self.flags = FL_CLIENT | FL_NOTARGET;
 234         self.armorvalue = 666;
 235         self.effects = 0;
 236         self.armorvalue = autocvar_g_balance_armor_start;
 237         self.pauserotarmor_finished = 0;
 238         self.pauserothealth_finished = 0;
 239         self.pauseregen_finished = 0;
 240         self.damageforcescale = 0;
 241         self.death_time = 0;
 242         self.respawn_flags = 0;
 243         self.respawn_time = 0;
 244         self.stat_respawn_time = 0;
 245         self.alpha = 0;
 246         self.scale = 0;
 247         self.fade_time = 0;
 248         self.pain_frame = 0;
 249         self.pain_finished = 0;
 250         self.strength_finished = 0;
 251         self.invincible_finished = 0;
 252         self.superweapons_finished = 0;
 253         self.pushltime = 0;
 254         self.istypefrag = 0;
 255         self.think = func_null;
 256         self.nextthink = 0;
 257         self.hook_time = 0;
 258         self.deadflag = DEAD_NO;
 259         self.angles = spot.angles;
 260         self.angles_z = 0;
 261         self.fixangle = true;
 262         self.crouch = false;
 263         self.revival_time = 0;
 264
 265         setorigin (self, (spot.origin + PL_VIEW_OFS)); // offset it so that the spectator spawns higher off the ground, looks better this way
 266         self.prevorigin = self.origin;
 267         self.items = 0;
 268         self.weapons = '0 0 0';
 269         self.model = "";
 270         FixPlayermodel();
 271         setmodel(self, "null");
 272         self.drawonlytoclient = self;
 273
 274         setsize (self, PL_CROUCH_MIN, PL_CROUCH_MAX); // give the spectator some space between walls for MOVETYPE_FLY_WORLDONLY
 275         self.view_ofs = '0 0 0'; // so that your view doesn't go into the ceiling with MOVETYPE_FLY_WORLDONLY, previously "PL_VIEW_OFS"
 276
 277         self.weapon = 0;
 278         self.weaponname = "";
 279         self.switchingweapon = 0;
 280         self.weaponmodel = "";
 281         self.weaponentity = world;
 282         self.exteriorweaponentity = world;
 283         self.killcount = -666;
 284         self.velocity = '0 0 0';
 285         self.avelocity = '0 0 0';
 286         self.punchangle = '0 0 0';
 287         self.punchvector = '0 0 0';
 288         self.oldvelocity = self.velocity;
 289         self.fire_endtime = -1;
 290         self.event_damage = func_null;
 291 }
 292
 293 .float model_randomizer;
 294 void FixPlayermodel()
 295 {
 296         string defaultmodel;
 297         float defaultskin, chmdl, oldskin, n, i;
 298         vector m1, m2;
 299
 300         defaultmodel = "";
 301         defaultskin = 0;
 302         chmdl = false;
 303
 304         if(autocvar_sv_defaultcharacter == 1)
 305         {
 306                 if(teamplay)
 307                 {
 308                         string s;
 309                         s = Static_Team_ColorName_Lower(self.team);
 310                         if(s != "neutral")
 311                         {
 312                                 defaultmodel = cvar_string(strcat("sv_defaultplayermodel_", s));
 313                                 defaultskin = cvar(strcat("sv_defaultplayerskin_", s));
 314                         }
 315                 }
 316
 317                 if(defaultmodel == "")
 318                 {
 319                         defaultmodel = autocvar_sv_defaultplayermodel;
 320                         defaultskin = autocvar_sv_defaultplayerskin;
 321                 }
 322
 323                 n = tokenize_console(defaultmodel);
 324                 if(n > 0)
 325                 {
 326                         defaultmodel = argv(floor(n * self.model_randomizer));
 327                         // However, do NOT randomize if the player-selected model is in the list.
 328                         for (i = 0; i < n; ++i)
 329                                 if ((argv(i) == self.playermodel && defaultskin == stof(self.playerskin)) || argv(i) == strcat(self.playermodel, ":", self.playerskin))
 330                                         defaultmodel = argv(i);
 331                 }
 332
 333                 i = strstrofs(defaultmodel, ":", 0);
 334                 if(i >= 0)
 335                 {
 336                         defaultskin = stof(substring(defaultmodel, i+1, -1));
 337                         defaultmodel = substring(defaultmodel, 0, i);
 338                 }
 339         }
 340
 341         if(defaultmodel != "")
 342         {
 343                 if (defaultmodel != self.model)
 344                 {
 345                         m1 = self.mins;
 346                         m2 = self.maxs;
 347                         setplayermodel (self, defaultmodel);
 348                         setsize (self, m1, m2);
 349                         chmdl = true;
 350                 }
 351
 352                 oldskin = self.skin;
 353                 self.skin = defaultskin;
 354         } else {
 355                 if (self.playermodel != self.model || self.playermodel == "")
 356                 {
 357                         self.playermodel = CheckPlayerModel(self.playermodel); // this is never "", so no endless loop
 358                         m1 = self.mins;
 359                         m2 = self.maxs;
 360                         setplayermodel (self, self.playermodel);
 361                         setsize (self, m1, m2);
 362                         chmdl = true;
 363                 }
 364
 365                 oldskin = self.skin;
 366                 self.skin = stof(self.playerskin);
 367         }
 368
 369         if(chmdl || oldskin != self.skin) // model or skin has changed
 370         {
 371                 self.species = player_getspecies(); // update species
 372                 UpdatePlayerSounds(); // update skin sounds
 373         }
 374
 375         if(!teamplay)
 376                 if(strlen(autocvar_sv_defaultplayercolors))
 377                         if(self.clientcolors != stof(autocvar_sv_defaultplayercolors))
 378                                 setcolor(self, stof(autocvar_sv_defaultplayercolors));
 379 }
 380
 381 /*
 382 =============
 383 PutClientInServer
 384
 385 Called when a client spawns in the server
 386 =============
 387 */
 388 void PutClientInServer (void)
 389 {
 390         if(IS_BOT_CLIENT(self))
 391                 self.classname = "player";
 392         else if(IS_REAL_CLIENT(self))
 393         {
 394                 msg_entity = self;
 395                 WriteByte(MSG_ONE, SVC_SETVIEW);
 396                 WriteEntity(MSG_ONE, self);
 397         }
 398
 399         SetSpectator(self, world);
 400
 401         // reset player keys
 402         self.itemkeys = 0;
 403
 404         MUTATOR_CALLHOOK(PutClientInServer);
 405
 406         if(gameover)
 407                 self.classname = "observer";
 408
 409         if(IS_PLAYER(self))
 410         {
 411                 entity spot, oldself;
 412                 float j;
 413
 414                 accuracy_resend(self);
 415
 416                 if(self.team < 0)
 417                         JoinBestTeam(self, false, true);
 418
 419                 spot = SelectSpawnPoint (false);
 420                 if(!spot)
 421                 {
 422                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_JOIN_NOSPAWNS);
 423                         return; // spawn failed
 424                 }
 425
 426                 RemoveGrapplingHook(self); // Wazat's Grappling Hook
 427
 428                 self.classname = "player";
 429                 self.wasplayer = true;
 430                 self.iscreature = true;
 431                 self.teleportable = TELEPORT_NORMAL;
 432                 self.damagedbycontents = true;
 433                 self.movetype = MOVETYPE_WALK;
 434                 self.solid = SOLID_SLIDEBOX;
 435                 self.dphitcontentsmask = DPCONTENTS_BODY | DPCONTENTS_SOLID;
 436                 if(autocvar_g_playerclip_collisions)
 437                         self.dphitcontentsmask |= DPCONTENTS_PLAYERCLIP;
 438                 if(IS_BOT_CLIENT(self) && autocvar_g_botclip_collisions)
 439                         self.dphitcontentsmask |= DPCONTENTS_BOTCLIP;
 440                 self.frags = FRAGS_PLAYER;
 441                 if(INDEPENDENT_PLAYERS)
 442                         MAKE_INDEPENDENT_PLAYER(self);
 443                 self.flags = FL_CLIENT;
 444                 if(autocvar__notarget)
 445                         self.flags |= FL_NOTARGET;
 446                 self.takedamage = DAMAGE_AIM;
 447                 self.effects = 0;
 448                 self.effects |= EF_TELEPORT_BIT | EF_RESTARTANIM_BIT;
 449                 self.air_finished = time + 12;
 450                 self.dmg = 2;
 451                 if(WEP_CVAR(vortex, charge))
 452                 {
 453                         if(WEP_CVAR_SEC(vortex, chargepool))
 454                                 self.vortex_chargepool_ammo = 1;
 455                         self.vortex_charge = WEP_CVAR(vortex, charge_start);
 456                 }
 457
 458                 if(warmup_stage)
 459                 {
 460                         self.ammo_shells = warmup_start_ammo_shells;
 461                         self.ammo_nails = warmup_start_ammo_nails;
 462                         self.ammo_rockets = warmup_start_ammo_rockets;
 463                         self.ammo_cells = warmup_start_ammo_cells;
 464                         self.ammo_plasma = warmup_start_ammo_plasma;
 465                         self.ammo_fuel = warmup_start_ammo_fuel;
 466                         self.health = warmup_start_health;
 467                         self.armorvalue = warmup_start_armorvalue;
 468                         self.weapons = WARMUP_START_WEAPONS;
 469                 }
 470                 else
 471                 {
 472                         self.ammo_shells = start_ammo_shells;
 473                         self.ammo_nails = start_ammo_nails;
 474                         self.ammo_rockets = start_ammo_rockets;
 475                         self.ammo_cells = start_ammo_cells;
 476                         self.ammo_plasma = start_ammo_plasma;
 477                         self.ammo_fuel = start_ammo_fuel;
 478                         self.health = start_health;
 479                         self.armorvalue = start_armorvalue;
 480                         self.weapons = start_weapons;
 481                 }
 482
 483                 if(self.weapons & WEPSET_SUPERWEAPONS)
 484                         self.superweapons_finished = time + autocvar_g_balance_superweapons_time;
 485                 else
 486                         self.superweapons_finished = 0;
 487
 488                 if(g_weaponarena_random) // WEAPONTODO: more stuff that should be in a mutator. also: rename those cvars
 489                 {
 490                         if(g_weaponarena_random_with_blaster)
 491                                 self.weapons &= ~WEPSET_BLASTER;
 492                         W_RandomWeapons(self, g_weaponarena_random);
 493                         if(g_weaponarena_random_with_blaster)
 494                                 self.weapons |= WEPSET_BLASTER;
 495                 }
 496
 497                 self.items = start_items;
 498
 499                 self.spawnshieldtime = time + autocvar_g_spawnshieldtime;
 500                 self.pauserotarmor_finished = time + autocvar_g_balance_pause_armor_rot_spawn;
 501                 self.pauserothealth_finished = time + autocvar_g_balance_pause_health_rot_spawn;
 502                 self.pauserotfuel_finished = time + autocvar_g_balance_pause_fuel_rot_spawn;
 503                 self.pauseregen_finished = time + autocvar_g_balance_pause_health_regen_spawn;
 504                 //extend the pause of rotting if client was reset at the beginning of the countdown
 505                 if(!autocvar_sv_ready_restart_after_countdown && time < game_starttime) { // TODO why is this cvar NOTted?
 506                         self.spawnshieldtime += game_starttime - time;
 507                         self.pauserotarmor_finished += game_starttime - time;
 508                         self.pauserothealth_finished += game_starttime - time;
 509                         self.pauseregen_finished += game_starttime - time;
 510                 }
 511                 self.damageforcescale = 2;
 512                 self.death_time = 0;
 513                 self.respawn_flags = 0;
 514                 self.respawn_time = 0;
 515                 self.stat_respawn_time = 0;
 516                 self.scale = 0;
 517                 self.fade_time = 0;
 518                 self.pain_frame = 0;
 519                 self.pain_finished = 0;
 520                 self.strength_finished = 0;
 521                 self.invincible_finished = 0;
 522                 self.pushltime = 0;
 523                 // players have no think function
 524                 self.think = func_null;
 525                 self.nextthink = 0;
 526                 self.hook_time = 0;
 527                 self.dmg_team = 0;
 528                 self.ballistics_density = autocvar_g_ballistics_density_player;
 529
 530                 self.metertime = 0;
 531
 532                 self.deadflag = DEAD_NO;
 533
 534                 self.angles = spot.angles;
 535
 536                 self.angles_z = 0; // never spawn tilted even if the spot says to
 537                 if(IS_BOT_CLIENT(self))
 538                         self.v_angle = self.angles;
 539                 self.fixangle = true; // turn this way immediately
 540                 self.velocity = '0 0 0';
 541                 self.avelocity = '0 0 0';
 542                 self.punchangle = '0 0 0';
 543                 self.punchvector = '0 0 0';
 544                 self.oldvelocity = self.velocity;
 545                 self.fire_endtime = -1;
 546                 self.revival_time = 0;
 547
 548                 entity spawnevent = spawn();
 549                 spawnevent.owner = self;
 550                 Net_LinkEntity(spawnevent, false, 0.5, SpawnEvent_Send);
 551
 552                 // Cut off any still running player sounds.
 553                 stopsound(self, CH_PLAYER_SINGLE);
 554
 555                 self.model = "";
 556                 FixPlayermodel();
 557                 self.drawonlytoclient = world;
 558
 559                 self.crouch = false;
 560                 self.view_ofs = PL_VIEW_OFS;
 561                 setsize (self, PL_MIN, PL_MAX);
 562                 self.spawnorigin = spot.origin;
 563                 setorigin (self, spot.origin + '0 0 1' * (1 - self.mins.z - 24));
 564                 // don't reset back to last position, even if new position is stuck in solid
 565                 self.oldorigin = self.origin;
 566                 self.prevorigin = self.origin;
 567                 self.lastrocket = world; // stop rocket guiding, no revenge from the grave!
 568                 self.lastteleporttime = time; // prevent insane speeds due to changing origin
 569         self.hud = HUD_NORMAL;
 570
 571                 self.event_damage = PlayerDamage;
 572
 573                 self.bot_attack = true;
 574                 self.monster_attack = true;
 575
 576                 self.spider_slowness = 0;
 577
 578                 self.BUTTON_ATCK = self.BUTTON_JUMP = self.BUTTON_ATCK2 = 0;
 579
 580                 if(self.killcount == -666) {
 581                         PlayerScore_Clear(self);
 582                         self.killcount = 0;
 583                 }
 584
 585                 CL_SpawnWeaponentity();
 586                 self.alpha = default_player_alpha;
 587                 self.colormod = '1 1 1' * autocvar_g_player_brightness;
 588                 self.exteriorweaponentity.alpha = default_weapon_alpha;
 589
 590                 self.speedrunning = false;
 591
 592                 //stuffcmd(self, "chase_active 0");
 593                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
 594
 595                 target_voicescript_clear(self);
 596
 597                 // reset fields the weapons may use
 598                 for (j = WEP_FIRST; j <= WEP_LAST; ++j)
 599                 {
 600                         WEP_ACTION(j, WR_RESETPLAYER);
 601
 602                         // all weapons must be fully loaded when we spawn
 603                         entity e = get_weaponinfo(j);
 604                         if(e.spawnflags & WEP_FLAG_RELOADABLE) // prevent accessing undefined cvars
 605                                 self.(weapon_load[j]) = e.reloading_ammo;
 606                 }
 607
 608                 oldself = self;
 609                 self = spot;
 610                         activator = oldself;
 611                                 string s;
 612                                 s = self.target;
 613                                 self.target = string_null;
 614                                 SUB_UseTargets();
 615                                 self.target = s;
 616                         activator = world;
 617                 self = oldself;
 618
 619                 Unfreeze(self);
 620
 621                 spawn_spot = spot;
 622                 MUTATOR_CALLHOOK(PlayerSpawn);
 623
 624                 if(autocvar_spawn_debug)
 625                 {
 626                         sprint(self, strcat("spawnpoint origin:  ", vtos(spot.origin), "\n"));
 627                         remove(spot);   // usefull for checking if there are spawnpoints, that let drop through the floor
 628                 }
 629
 630                 self.switchweapon = w_getbestweapon(self);
 631                 self.cnt = -1; // W_LastWeapon will not complain
 632                 self.weapon = 0;
 633                 self.weaponname = "";
 634                 self.switchingweapon = 0;
 635
 636                 if(!warmup_stage)
 637                         if(!self.alivetime)
 638                                 self.alivetime = time;
 639
 640                 antilag_clear(self);
 641         }
 642         else if(IS_OBSERVER(self))
 643         {
 644                 PutObserverInServer ();
 645         }
 646 }
 647
 648 .float ebouncefactor, ebouncestop; // electro's values
 649 // TODO do we need all these fields, or should we stop autodetecting runtime
 650 // changes and just have a console command to update this?
 651 float ClientInit_SendEntity(entity to, float sf)
 652 {
 653         WriteByte(MSG_ENTITY, ENT_CLIENT_INIT);
 654         WriteByte(MSG_ENTITY, g_nexball_meter_period * 32);
 655         WriteInt24_t(MSG_ENTITY, compressShotOrigin(hook_shotorigin[0]));
 656         WriteInt24_t(MSG_ENTITY, compressShotOrigin(hook_shotorigin[1]));
 657         WriteInt24_t(MSG_ENTITY, compressShotOrigin(hook_shotorigin[2]));
 658         WriteInt24_t(MSG_ENTITY, compressShotOrigin(hook_shotorigin[3]));
 659         WriteInt24_t(MSG_ENTITY, compressShotOrigin(arc_shotorigin[0]));
 660         WriteInt24_t(MSG_ENTITY, compressShotOrigin(arc_shotorigin[1]));
 661         WriteInt24_t(MSG_ENTITY, compressShotOrigin(arc_shotorigin[2]));
 662         WriteInt24_t(MSG_ENTITY, compressShotOrigin(arc_shotorigin[3]));
 663
 664         if(sv_foginterval && world.fog != "")
 665                 WriteString(MSG_ENTITY, world.fog);
 666         else
 667                 WriteString(MSG_ENTITY, "");
 668         WriteByte(MSG_ENTITY, self.count * 255.0); // g_balance_armor_blockpercent
 669         WriteCoord(MSG_ENTITY, self.bouncefactor); // g_balance_mortar_bouncefactor // WEAPONTODO
 670         WriteCoord(MSG_ENTITY, self.bouncestop); // g_balance_mortar_bouncestop
 671         WriteCoord(MSG_ENTITY, self.ebouncefactor); // g_balance_mortar_bouncefactor
 672         WriteCoord(MSG_ENTITY, self.ebouncestop); // g_balance_mortar_bouncestop
 673         WriteByte(MSG_ENTITY, WEP_CVAR(vortex, secondary)); // client has to know if it should zoom or not // WEAPONTODO
 674         WriteByte(MSG_ENTITY, WEP_CVAR(rifle, secondary)); // client has to know if it should zoom or not // WEAPONTODO
 675         WriteByte(MSG_ENTITY, serverflags); // client has to know if it should zoom or not
 676         WriteByte(MSG_ENTITY, WEP_CVAR(minelayer, limit)); // minelayer max mines // WEAPONTODO
 677         WriteByte(MSG_ENTITY, WEP_CVAR_SEC(hagar, load_max)); // hagar max loadable rockets // WEAPONTODO
 678         WriteCoord(MSG_ENTITY, autocvar_g_trueaim_minrange);
 679         WriteByte(MSG_ENTITY, WEP_CVAR(porto, secondary)); // WEAPONTODO
 680         return true;
 681 }
 682
 683 void ClientInit_CheckUpdate()
 684 {
 685         self.nextthink = time;
 686         if(self.count != autocvar_g_balance_armor_blockpercent)
 687         {
 688                 self.count = autocvar_g_balance_armor_blockpercent;
 689                 self.SendFlags |= 1;
 690         }
 691         if(self.bouncefactor != autocvar_g_balance_mortar_bouncefactor) // WEAPONTODO
 692         {
 693                 self.bouncefactor = autocvar_g_balance_mortar_bouncefactor;
 694                 self.SendFlags |= 1;
 695         }
 696         if(self.bouncestop != autocvar_g_balance_mortar_bouncestop)
 697         {
 698                 self.bouncestop = autocvar_g_balance_mortar_bouncestop;
 699                 self.SendFlags |= 1;
 700         }
 701         if(self.ebouncefactor != autocvar_g_balance_electro_secondary_bouncefactor)
 702         {
 703                 self.ebouncefactor = autocvar_g_balance_electro_secondary_bouncefactor;
 704                 self.SendFlags |= 1;
 705         }
 706         if(self.ebouncestop != autocvar_g_balance_electro_secondary_bouncestop)
 707         {
 708                 self.ebouncestop = autocvar_g_balance_electro_secondary_bouncestop;
 709                 self.SendFlags |= 1;
 710         }
 711 }
 712
 713 void ClientInit_Spawn()
 714 {
 715         entity o;
 716         entity e;
 717         e = spawn();
 718         e.classname = "clientinit";
 719         e.think = ClientInit_CheckUpdate;
 720         Net_LinkEntity(e, false, 0, ClientInit_SendEntity);
 721
 722         o = self;
 723         self = e;
 724         ClientInit_CheckUpdate();
 725         self = o;
 726 }
 727
 728 /*
 729 =============
 730 SetNewParms
 731 =============
 732 */
 733 void SetNewParms (void)
 734 {
 735         // initialize parms for a new player
 736         parm1 = -(86400 * 366);
 737 }
 738
 739 /*
 740 =============
 741 SetChangeParms
 742 =============
 743 */
 744 void SetChangeParms (void)
 745 {
 746         // save parms for level change
 747         parm1 = self.parm_idlesince - time;
 748 }
 749
 750 /*
 751 =============
 752 DecodeLevelParms
 753 =============
 754 */
 755 void DecodeLevelParms (void)
 756 {
 757         // load parms
 758         self.parm_idlesince = parm1;
 759         if(self.parm_idlesince == -(86400 * 366))
 760                 self.parm_idlesince = time;
 761
 762         // whatever happens, allow 60 seconds of idling directly after connect for map loading
 763         self.parm_idlesince = max(self.parm_idlesince, time - sv_maxidle + 60);
 764 }
 765
 766 /*
 767 =============
 768 ClientKill
 769
 770 Called when a client types 'kill' in the console
 771 =============
 772 */
 773
 774 .float clientkill_nexttime;
 775 void ClientKill_Now_TeamChange()
 776 {
 777         if(self.killindicator_teamchange == -1)
 778         {
 779                 JoinBestTeam( self, false, true );
 780         }
 781         else if(self.killindicator_teamchange == -2)
 782         {
 783                 if(blockSpectators)
 784                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_SPECTATE_WARNING, autocvar_g_maxplayers_spectator_blocktime);
 785                 PutObserverInServer();
 786         }
 787         else
 788                 SV_ChangeTeam(self.killindicator_teamchange - 1);
 789         self.killindicator_teamchange = 0;
 790 }
 791
 792 void ClientKill_Now()
 793 {
 794         if(self.vehicle)
 795         {
 796             vehicles_exit(VHEF_RELEASE);
 797             if(!self.killindicator_teamchange)
 798             {
 799             self.vehicle_health = -1;
 800             Damage(self, self, self, 1 , DEATH_KILL, self.origin, '0 0 0');
 801             }
 802         }
 803
 804         if(self.killindicator && !wasfreed(self.killindicator))
 805                 remove(self.killindicator);
 806
 807         self.killindicator = world;
 808
 809         if(self.killindicator_teamchange)
 810                 ClientKill_Now_TeamChange();
 811
 812         if(IS_PLAYER(self))
 813                 Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
 814
 815         // now I am sure the player IS dead
 816 }
 817 void KillIndicator_Think()
 818 {
 819         if (gameover)
 820         {
 821                 self.owner.killindicator = world;
 822                 remove(self);
 823                 return;
 824         }
 825
 826         if (self.owner.alpha < 0 && !self.owner.vehicle)
 827         {
 828                 self.owner.killindicator = world;
 829                 remove(self);
 830                 return;
 831         }
 832
 833         if(self.cnt <= 0)
 834         {
 835                 self = self.owner;
 836                 ClientKill_Now(); // no oldself needed
 837                 return;
 838         }
 839     else if(g_cts && self.health == 1) // health == 1 means that it's silent
 840     {
 841         self.nextthink = time + 1;
 842         self.cnt -= 1;
 843     }
 844         else
 845         {
 846                 if(self.cnt <= 10)
 847                         setmodel(self, strcat("models/sprites/", ftos(self.cnt), ".spr32"));
 848                 if(IS_REAL_CLIENT(self.owner))
 849                 {
 850                         if(self.cnt <= 10)
 851                                 { Send_Notification(NOTIF_ONE, self.owner, MSG_ANNCE, Announcer_PickNumber(CNT_KILL, self.cnt)); }
 852                 }
 853                 self.nextthink = time + 1;
 854                 self.cnt -= 1;
 855         }
 856 }
 857
 858 float clientkilltime;
 859 void ClientKill_TeamChange (float targetteam) // 0 = don't change, -1 = auto, -2 = spec
 860 {
 861         float killtime;
 862         float starttime;
 863         entity e;
 864
 865         if (gameover)
 866                 return;
 867
 868         killtime = autocvar_g_balance_kill_delay;
 869
 870         if(g_race_qualifying || g_cts)
 871                 killtime = 0;
 872
 873     if(g_cts && self.killindicator && self.killindicator.health == 1) // self.killindicator.health == 1 means that the kill indicator was spawned by CTS_ClientKill
 874     {
 875                 remove(self.killindicator);
 876                 self.killindicator = world;
 877
 878         ClientKill_Now(); // allow instant kill in this case
 879         return;
 880     }
 881
 882         self.killindicator_teamchange = targetteam;
 883
 884     if(!self.killindicator)
 885         {
 886                 if(self.deadflag == DEAD_NO)
 887                 {
 888                         killtime = max(killtime, self.clientkill_nexttime - time);
 889                         self.clientkill_nexttime = time + killtime + autocvar_g_balance_kill_antispam;
 890                 }
 891
 892                 if(killtime <= 0 || !IS_PLAYER(self) || self.deadflag != DEAD_NO)
 893                 {
 894                         ClientKill_Now();
 895                 }
 896                 else
 897                 {
 898                         starttime = max(time, clientkilltime);
 899
 900                         self.killindicator = spawn();
 901                         self.killindicator.owner = self;
 902                         self.killindicator.scale = 0.5;
 903                         setattachment(self.killindicator, self, "");
 904                         setorigin(self.killindicator, '0 0 52');
 905                         self.killindicator.think = KillIndicator_Think;
 906                         self.killindicator.nextthink = starttime + (self.lip) * 0.05;
 907                         clientkilltime = max(clientkilltime, self.killindicator.nextthink + 0.05);
 908                         self.killindicator.cnt = ceil(killtime);
 909                         self.killindicator.count = bound(0, ceil(killtime), 10);
 910                         //sprint(self, strcat("^1You'll be dead in ", ftos(self.killindicator.cnt), " seconds\n"));
 911
 912                         for(e = world; (e = find(e, classname, "body")) != world; )
 913                         {
 914                                 if(e.enemy != self)
 915                                         continue;
 916                                 e.killindicator = spawn();
 917                                 e.killindicator.owner = e;
 918                                 e.killindicator.scale = 0.5;
 919                                 setattachment(e.killindicator, e, "");
 920                                 setorigin(e.killindicator, '0 0 52');
 921                                 e.killindicator.think = KillIndicator_Think;
 922                                 e.killindicator.nextthink = starttime + (e.lip) * 0.05;
 923                                 clientkilltime = max(clientkilltime, e.killindicator.nextthink + 0.05);
 924                                 e.killindicator.cnt = ceil(killtime);
 925                         }
 926                         self.lip = 0;
 927                 }
 928         }
 929         if(self.killindicator)
 930         {
 931                 if(targetteam == 0) // just die
 932                 {
 933                         self.killindicator.colormod = '0 0 0';
 934                         if(IS_REAL_CLIENT(self))
 935                         if(self.killindicator.cnt > 0)
 936                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_TEAMCHANGE_SUICIDE, self.killindicator.cnt);
 937                 }
 938                 else if(targetteam == -1) // auto
 939                 {
 940                         self.killindicator.colormod = '0 1 0';
 941                         if(IS_REAL_CLIENT(self))
 942                         if(self.killindicator.cnt > 0)
 943                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_TEAMCHANGE_AUTO, self.killindicator.cnt);
 944                 }
 945                 else if(targetteam == -2) // spectate
 946                 {
 947                         self.killindicator.colormod = '0.5 0.5 0.5';
 948                         if(IS_REAL_CLIENT(self))
 949                         if(self.killindicator.cnt > 0)
 950                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_TEAMCHANGE_SPECTATE, self.killindicator.cnt);
 951                 }
 952                 else
 953                 {
 954                         self.killindicator.colormod = Team_ColorRGB(targetteam);
 955                         if(IS_REAL_CLIENT(self))
 956                         if(self.killindicator.cnt > 0)
 957                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, APP_TEAM_NUM_4(targetteam, CENTER_TEAMCHANGE_), self.killindicator.cnt);
 958                 }
 959         }
 960
 961 }
 962
 963 void ClientKill (void)
 964 {
 965         if(gameover) return;
 966         if(self.player_blocked) return;
 967         if(self.frozen) return;
 968
 969         ClientKill_TeamChange(0);
 970 }
 971
 972 void CTS_ClientKill (entity e) // silent version of ClientKill, used when player finishes a CTS run. Useful to prevent cheating by running back to the start line and starting out with more speed
 973 {
 974     e.killindicator = spawn();
 975     e.killindicator.owner = e;
 976     e.killindicator.think = KillIndicator_Think;
 977     e.killindicator.nextthink = time + (e.lip) * 0.05;
 978     e.killindicator.cnt = ceil(autocvar_g_cts_finish_kill_delay);
 979     e.killindicator.health = 1; // this is used to indicate that it should be silent
 980     e.lip = 0;
 981 }
 982
 983 void FixClientCvars(entity e)
 984 {
 985         // send prediction settings to the client
 986         stuffcmd(e, "\nin_bindmap 0 0\n");
 987         if(g_race || g_cts)
 988                 stuffcmd(e, "cl_cmd settemp cl_movecliptokeyboard 2\n");
 989         if(autocvar_g_antilag == 3) // client side hitscan
 990                 stuffcmd(e, "cl_cmd settemp cl_prydoncursor_notrace 0\n");
 991         if(autocvar_sv_gentle)
 992                 stuffcmd(e, "cl_cmd settemp cl_gentle 1\n");
 993 }
 994
 995 float PlayerInIDList(entity p, string idlist)
 996 {
 997         float n, i;
 998         string s;
 999
1000         // NOTE: we do NOT check crypto_idfp_signed here, an unsigned ID is fine too for this
1001         if (!p.crypto_idfp)
1002                 return 0;
1003
1004         // this function allows abbreviated player IDs too!
1005         n = tokenize_console(idlist);
1006         for(i = 0; i < n; ++i)
1007         {
1008                 s = argv(i);
1009                 if(s == substring(p.crypto_idfp, 0, strlen(s)))
1010                         return 1;
1011         }
1012
1013         return 0;
1014 }
1015
1016 #ifdef DP_EXT_PRECONNECT
1017 /*
1018 =============
1019 ClientPreConnect
1020
1021 Called once (not at each match start) when a client begins a connection to the server
1022 =============
1023 */
1024 void ClientPreConnect (void)
1025 {
1026         if(autocvar_sv_eventlog)
1027         {
1028                 GameLogEcho(sprintf(":connect:%d:%d:%s",
1029                         self.playerid,
1030                         num_for_edict(self),
1031                         ((IS_REAL_CLIENT(self)) ? self.netaddress : "bot")
1032                 ));
1033         }
1034 }
1035 #endif
1036
1037 /*
1038 =============
1039 ClientConnect
1040
1041 Called when a client connects to the server
1042 =============
1043 */
1044 void DecodeLevelParms (void);
1045 //void dom_player_join_team(entity pl);
1046 void set_dom_state(entity e);
1047 void ClientConnect (void)
1048 {
1049         float t;
1050
1051         if(IS_CLIENT(self))
1052         {
1053                 print("Warning: ClientConnect, but already connected!\n");
1054                 return;
1055         }
1056
1057         if(Ban_MaybeEnforceBanOnce(self))
1058                 return;
1059
1060         DecodeLevelParms();
1061
1062 #ifdef WATERMARK
1063         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_WATERMARK, WATERMARK);
1064 #endif
1065
1066         self.classname = "player_joining";
1067
1068         self.flags = FL_CLIENT;
1069         self.version_nagtime = time + 10 + random() * 10;
1070
1071         if(player_count<0)
1072         {
1073                 dprint("BUG player count is lower than zero, this cannot happen!\n");
1074                 player_count = 0;
1075         }
1076
1077         if(IS_REAL_CLIENT(self)) { PlayerStats_PlayerBasic_CheckUpdate(self); }
1078
1079         PlayerScore_Attach(self);
1080         ClientData_Attach();
1081         accuracy_init(self);
1082
1083         bot_clientconnect();
1084
1085         playerdemo_init();
1086
1087         anticheat_init();
1088
1089         // identify the right forced team
1090         if(autocvar_g_campaign)
1091         {
1092                 if(IS_REAL_CLIENT(self)) // only players, not bots
1093                 {
1094                         switch(autocvar_g_campaign_forceteam)
1095                         {
1096                                 case 1: self.team_forced = NUM_TEAM_1; break;
1097                                 case 2: self.team_forced = NUM_TEAM_2; break;
1098                                 case 3: self.team_forced = NUM_TEAM_3; break;
1099                                 case 4: self.team_forced = NUM_TEAM_4; break;
1100                                 default: self.team_forced = 0;
1101                         }
1102                 }
1103         }
1104         else if(PlayerInIDList(self, autocvar_g_forced_team_red))
1105                 self.team_forced = NUM_TEAM_1;
1106         else if(PlayerInIDList(self, autocvar_g_forced_team_blue))
1107                 self.team_forced = NUM_TEAM_2;
1108         else if(PlayerInIDList(self, autocvar_g_forced_team_yellow))
1109                 self.team_forced = NUM_TEAM_3;
1110         else if(PlayerInIDList(self, autocvar_g_forced_team_pink))
1111                 self.team_forced = NUM_TEAM_4;
1112         else if(autocvar_g_forced_team_otherwise == "red")
1113                 self.team_forced = NUM_TEAM_1;
1114         else if(autocvar_g_forced_team_otherwise == "blue")
1115                 self.team_forced = NUM_TEAM_2;
1116         else if(autocvar_g_forced_team_otherwise == "yellow")
1117                 self.team_forced = NUM_TEAM_3;
1118         else if(autocvar_g_forced_team_otherwise == "pink")
1119                 self.team_forced = NUM_TEAM_4;
1120         else if(autocvar_g_forced_team_otherwise == "spectate")
1121                 self.team_forced = -1;
1122         else if(autocvar_g_forced_team_otherwise == "spectator")
1123                 self.team_forced = -1;
1124         else
1125                 self.team_forced = 0;
1126
1127         if(!teamplay)
1128                 if(self.team_forced > 0)
1129                         self.team_forced = 0;
1130
1131         JoinBestTeam(self, false, false); // if the team number is valid, keep it
1132
1133         if((autocvar_sv_spectate == 1) || autocvar_g_campaign || self.team_forced < 0) {
1134                 self.classname = "observer";
1135         } else {
1136                 if(teamplay)
1137                 {
1138                         if(autocvar_g_balance_teams)
1139                         {
1140                                 self.classname = "player";
1141                                 campaign_bots_may_start = 1;
1142                         }
1143                         else
1144                         {
1145                                 self.classname = "observer"; // do it anyway
1146                         }
1147                 }
1148                 else
1149                 {
1150                         self.classname = "player";
1151                         campaign_bots_may_start = 1;
1152                 }
1153         }
1154
1155         self.playerid = (playerid_last = playerid_last + 1);
1156
1157         PlayerStats_GameReport_AddEvent(sprintf("kills-%d", self.playerid));
1158
1159     if(IS_BOT_CLIENT(self))
1160         PlayerStats_GameReport_AddPlayer(self);
1161
1162         if(autocvar_sv_eventlog)
1163                 GameLogEcho(strcat(":join:", ftos(self.playerid), ":", ftos(num_for_edict(self)), ":", ((IS_REAL_CLIENT(self)) ? self.netaddress : "bot"), ":", self.netname));
1164
1165         LogTeamchange(self.playerid, self.team, 1);
1166
1167         self.just_joined = true;  // stop spamming the eventlog with additional lines when the client connects
1168
1169         self.netname_previous = strzone(self.netname);
1170
1171         if(IS_PLAYER(self) && teamplay)
1172                 Send_Notification(NOTIF_ALL, world, MSG_INFO, APP_TEAM_ENT_4(self, INFO_JOIN_CONNECT_TEAM_), self.netname);
1173         else
1174                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_JOIN_CONNECT, self.netname);
1175
1176         stuffcmd(self, strcat(clientstuff, "\n"));
1177         stuffcmd(self, "cl_particles_reloadeffects\n"); // TODO do we still need this?
1178
1179         FixClientCvars(self);
1180
1181         // spawnfunc_waypoint sprites
1182         WaypointSprite_InitClient(self);
1183
1184         // Wazat's grappling hook
1185         SetGrappleHookBindings();
1186
1187         // Jetpack binds
1188         stuffcmd(self, "alias +jetpack +button10\n");
1189         stuffcmd(self, "alias -jetpack -button10\n");
1190
1191         // get version info from player
1192         stuffcmd(self, "cmd clientversion $gameversion\n");
1193
1194         // get other cvars from player
1195         GetCvars(0);
1196
1197         // notify about available teams
1198         if(teamplay)
1199         {
1200                 CheckAllowedTeams(self);
1201                 t = 0; if(c1 >= 0) t |= 1; if(c2 >= 0) t |= 2; if(c3 >= 0) t |= 4; if(c4 >= 0) t |= 8;
1202                 stuffcmd(self, strcat("set _teams_available ", ftos(t), "\n"));
1203         }
1204         else
1205                 stuffcmd(self, "set _teams_available 0\n");
1206
1207         attach_entcs();
1208
1209         bot_relinkplayerlist();
1210
1211         self.spectatortime = time;
1212         if(blockSpectators)
1213         {
1214                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_SPECTATE_WARNING, autocvar_g_maxplayers_spectator_blocktime);
1215         }
1216
1217         self.jointime = time;
1218         self.allowed_timeouts = autocvar_sv_timeout_number;
1219
1220         if(IS_REAL_CLIENT(self))
1221         {
1222                 if(!autocvar_g_campaign)
1223                 {
1224                         self.motd_actived_time = -1;
1225                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_MOTD, getwelcomemessage());
1226                 }
1227
1228                 if(autocvar_g_bugrigs || (g_weaponarena_weapons == WEPSET_TUBA))
1229                         stuffcmd(self, "cl_cmd settemp chase_active 1\n");
1230         }
1231
1232         if(!sv_foginterval && world.fog != "")
1233                 stuffcmd(self, strcat("\nfog ", world.fog, "\nr_fog_exp2 0\nr_drawfog 1\n"));
1234
1235         W_HitPlotOpen(self);
1236
1237         if(autocvar_sv_teamnagger && !(autocvar_bot_vs_human && (c3==-1 && c4==-1)) && !g_ca && !g_cts && !g_race) // teamnagger is currently bad for ca, race & cts
1238                 send_CSQC_teamnagger();
1239
1240         CheatInitClient();
1241
1242         CSQCMODEL_AUTOINIT();
1243
1244         self.model_randomizer = random();
1245
1246         if(IS_REAL_CLIENT(self))
1247                 sv_notice_join();
1248
1249         for (entity e = world; (e = findfloat(e, init_for_player_needed, 1)); ) {
1250                 entity oldself = self;
1251                 self = e;
1252                 e.init_for_player(oldself);
1253                 self = oldself;
1254         }
1255
1256         MUTATOR_CALLHOOK(ClientConnect);
1257 }
1258 /*
1259 =============
1260 ClientDisconnect
1261
1262 Called when a client disconnects from the server
1263 =============
1264 */
1265 .entity chatbubbleentity;
1266 void ReadyCount();
1267 void ClientDisconnect (void)
1268 {
1269         if(self.vehicle)
1270             vehicles_exit(VHEF_RELEASE);
1271
1272         if (!IS_CLIENT(self))
1273         {
1274                 print("Warning: ClientDisconnect without ClientConnect\n");
1275                 return;
1276         }
1277
1278         PlayerStats_GameReport_FinalizePlayer(self);
1279
1280         if(IS_PLAYER(self)) { pointparticles(particleeffectnum("spawn_event_neutral"), self.origin, '0 0 0', 1); }
1281
1282         CheatShutdownClient();
1283
1284         W_HitPlotClose(self);
1285
1286         anticheat_report();
1287         anticheat_shutdown();
1288
1289         playerdemo_shutdown();
1290
1291         bot_clientdisconnect();
1292
1293         if(self.entcs)
1294                 detach_entcs();
1295
1296         if(autocvar_sv_eventlog)
1297                 GameLogEcho(strcat(":part:", ftos(self.playerid)));
1298
1299         Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_QUIT_DISCONNECT, self.netname);
1300
1301         MUTATOR_CALLHOOK(ClientDisconnect);
1302
1303         Portal_ClearAll(self);
1304
1305         Unfreeze(self);
1306
1307         RemoveGrapplingHook(self);
1308
1309         // Here, everything has been done that requires this player to be a client.
1310
1311         self.flags &= ~FL_CLIENT;
1312
1313         if (self.chatbubbleentity)
1314                 remove (self.chatbubbleentity);
1315
1316         if (self.killindicator)
1317                 remove (self.killindicator);
1318
1319         WaypointSprite_PlayerGone();
1320
1321         bot_relinkplayerlist();
1322
1323         accuracy_free(self);
1324         ClientData_Detach();
1325         PlayerScore_Detach(self);
1326
1327         if(self.netname_previous)
1328                 strunzone(self.netname_previous);
1329         if(self.clientstatus)
1330                 strunzone(self.clientstatus);
1331         if(self.weaponorder_byimpulse)
1332                 strunzone(self.weaponorder_byimpulse);
1333
1334         ClearPlayerSounds();
1335
1336         if(self.personal)
1337                 remove(self.personal);
1338
1339         self.playerid = 0;
1340         ReadyCount();
1341
1342         // free cvars
1343         GetCvars(-1);
1344 }
1345
1346 .float BUTTON_CHAT;
1347 void ChatBubbleThink()
1348 {
1349         self.nextthink = time;
1350         if ((self.owner.alpha < 0) || self.owner.chatbubbleentity != self)
1351         {
1352                 if(self.owner) // but why can that ever be world?
1353                         self.owner.chatbubbleentity = world;
1354                 remove(self);
1355                 return;
1356         }
1357         if ((self.owner.BUTTON_CHAT && !self.owner.deadflag)
1358 #ifdef TETRIS
1359                 || self.owner.tetris_on
1360 #endif
1361         )
1362                 self.model = self.mdl;
1363         else
1364                 self.model = "";
1365 }
1366
1367 void UpdateChatBubble()
1368 {
1369         if (self.alpha < 0)
1370                 return;
1371         // spawn a chatbubble entity if needed
1372         if (!self.chatbubbleentity)
1373         {
1374                 self.chatbubbleentity = spawn();
1375                 self.chatbubbleentity.owner = self;
1376                 self.chatbubbleentity.exteriormodeltoclient = self;
1377                 self.chatbubbleentity.think = ChatBubbleThink;
1378                 self.chatbubbleentity.nextthink = time;
1379                 setmodel(self.chatbubbleentity, "models/misc/chatbubble.spr"); // precision set below
1380                 //setorigin(self.chatbubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
1381                 setorigin(self.chatbubbleentity, '0 0 15' + self.maxs.z * '0 0 1');
1382                 setattachment(self.chatbubbleentity, self, "");  // sticks to moving player better, also conserves bandwidth
1383                 self.chatbubbleentity.mdl = self.chatbubbleentity.model;
1384                 self.chatbubbleentity.model = "";
1385                 self.chatbubbleentity.effects = EF_LOWPRECISION;
1386         }
1387 }
1388
1389
1390 // LordHavoc: this hack will be removed when proper _pants/_shirt layers are
1391 // added to the model skins
1392 /*void UpdateColorModHack()
1393 {
1394         float c;
1395         c = self.clientcolors & 15;
1396         // LordHavoc: only bothering to support white, green, red, yellow, blue
1397              if (!teamplay) self.colormod = '0 0 0';
1398         else if (c ==  0) self.colormod = '1.00 1.00 1.00';
1399         else if (c ==  3) self.colormod = '0.10 1.73 0.10';
1400         else if (c ==  4) self.colormod = '1.73 0.10 0.10';
1401         else if (c == 12) self.colormod = '1.22 1.22 0.10';
1402         else if (c == 13) self.colormod = '0.10 0.10 1.73';
1403         else self.colormod = '1 1 1';
1404 }*/
1405
1406 void respawn(void)
1407 {
1408         if(self.alpha >= 0 && autocvar_g_respawn_ghosts)
1409         {
1410                 self.solid = SOLID_NOT;
1411                 self.takedamage = DAMAGE_NO;
1412                 self.movetype = MOVETYPE_FLY;
1413                 self.velocity = '0 0 1' * autocvar_g_respawn_ghosts_speed;
1414                 self.avelocity = randomvec() * autocvar_g_respawn_ghosts_speed * 3 - randomvec() * autocvar_g_respawn_ghosts_speed * 3;
1415                 self.effects |= CSQCMODEL_EF_RESPAWNGHOST;
1416                 pointparticles(particleeffectnum("respawn_ghost"), self.origin, '0 0 0', 1);
1417                 if(autocvar_g_respawn_ghosts_maxtime)
1418                         SUB_SetFade (self, time + autocvar_g_respawn_ghosts_maxtime / 2 + random () * (autocvar_g_respawn_ghosts_maxtime - autocvar_g_respawn_ghosts_maxtime / 2), 1.5);
1419         }
1420
1421         CopyBody(1);
1422
1423         self.effects |= EF_NODRAW; // prevent another CopyBody
1424         PutClientInServer();
1425 }
1426
1427 void play_countdown(float finished, string samp)
1428 {
1429         if(IS_REAL_CLIENT(self))
1430                 if(floor(finished - time - frametime) != floor(finished - time))
1431                         if(finished - time < 6)
1432                                 sound (self, CH_INFO, samp, VOL_BASE, ATTEN_NORM);
1433 }
1434
1435 void player_powerups (void)
1436 {
1437         // add a way to see what the items were BEFORE all of these checks for the mutator hook
1438         olditems = self.items;
1439
1440         if((self.items & IT_USING_JETPACK) && !self.deadflag && !gameover)
1441                 self.modelflags |= MF_ROCKET;
1442         else
1443                 self.modelflags &= ~MF_ROCKET;
1444
1445         self.effects &= ~(EF_RED | EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT | EF_FLAME | EF_NODEPTHTEST);
1446
1447         if((self.alpha < 0 || self.deadflag) && !self.vehicle) // don't apply the flags if the player is gibbed
1448                 return;
1449
1450         Fire_ApplyDamage(self);
1451         Fire_ApplyEffect(self);
1452
1453         if (!g_instagib)
1454         {
1455                 if (self.items & IT_STRENGTH)
1456                 {
1457                         play_countdown(self.strength_finished, "misc/poweroff.wav");
1458                         self.effects = self.effects | (EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT);
1459                         if (time > self.strength_finished)
1460                         {
1461                                 self.items = self.items - (self.items & IT_STRENGTH);
1462                                 //Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_POWERDOWN_STRENGTH, self.netname);
1463                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_POWERDOWN_STRENGTH);
1464                         }
1465                 }
1466                 else
1467                 {
1468                         if (time < self.strength_finished)
1469                         {
1470                                 self.items = self.items | IT_STRENGTH;
1471                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_POWERUP_STRENGTH, self.netname);
1472                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_POWERUP_STRENGTH);
1473                         }
1474                 }
1475                 if (self.items & IT_INVINCIBLE)
1476                 {
1477                         play_countdown(self.invincible_finished, "misc/poweroff.wav");
1478                         self.effects = self.effects | (EF_RED | EF_ADDITIVE | EF_FULLBRIGHT);
1479                         if (time > self.invincible_finished)
1480                         {
1481                                 self.items = self.items - (self.items & IT_INVINCIBLE);
1482                                 //Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_POWERDOWN_SHIELD, self.netname);
1483                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_POWERDOWN_SHIELD);
1484                         }
1485                 }
1486                 else
1487                 {
1488                         if (time < self.invincible_finished)
1489                         {
1490                                 self.items = self.items | IT_INVINCIBLE;
1491                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_POWERUP_SHIELD, self.netname);
1492                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_POWERUP_SHIELD);
1493                         }
1494                 }
1495                 if (self.items & IT_SUPERWEAPON)
1496                 {
1497                         if (!(self.weapons & WEPSET_SUPERWEAPONS))
1498                         {
1499                                 self.superweapons_finished = 0;
1500                                 self.items = self.items - (self.items & IT_SUPERWEAPON);
1501                                 //Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_SUPERWEAPON_LOST, self.netname);
1502                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_SUPERWEAPON_LOST);
1503                         }
1504                         else if (self.items & IT_UNLIMITED_SUPERWEAPONS)
1505                         {
1506                                 // don't let them run out
1507                         }
1508                         else
1509                         {
1510                                 play_countdown(self.superweapons_finished, "misc/poweroff.wav");
1511                                 if (time > self.superweapons_finished)
1512                                 {
1513                                         self.items = self.items - (self.items & IT_SUPERWEAPON);
1514                                         self.weapons &= ~WEPSET_SUPERWEAPONS;
1515                                         //Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_SUPERWEAPON_BROKEN, self.netname);
1516                                         Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_SUPERWEAPON_BROKEN);
1517                                 }
1518                         }
1519                 }
1520                 else if(self.weapons & WEPSET_SUPERWEAPONS)
1521                 {
1522                         if (time < self.superweapons_finished || (self.items & IT_UNLIMITED_SUPERWEAPONS))
1523                         {
1524                                 self.items = self.items | IT_SUPERWEAPON;
1525                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_SUPERWEAPON_PICKUP, self.netname);
1526                                 Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_SUPERWEAPON_PICKUP);
1527                         }
1528                         else
1529                         {
1530                                 self.superweapons_finished = 0;
1531                                 self.weapons &= ~WEPSET_SUPERWEAPONS;
1532                         }
1533                 }
1534                 else
1535                 {
1536                         self.superweapons_finished = 0;
1537                 }
1538         }
1539
1540         if(autocvar_g_nodepthtestplayers)
1541                 self.effects = self.effects | EF_NODEPTHTEST;
1542
1543         if(autocvar_g_fullbrightplayers)
1544                 self.effects = self.effects | EF_FULLBRIGHT;
1545
1546         if (time >= game_starttime)
1547         if (time < self.spawnshieldtime)
1548                 self.effects = self.effects | (EF_ADDITIVE | EF_FULLBRIGHT);
1549
1550         MUTATOR_CALLHOOK(PlayerPowerups);
1551 }
1552
1553 float CalcRegen(float current, float stable, float regenfactor, float regenframetime)
1554 {
1555         if(current > stable)
1556                 return current;
1557         else if(current > stable - 0.25) // when close enough, "snap"
1558                 return stable;
1559         else
1560                 return min(stable, current + (stable - current) * regenfactor * regenframetime);
1561 }
1562
1563 float CalcRot(float current, float stable, float rotfactor, float rotframetime)
1564 {
1565         if(current < stable)
1566                 return current;
1567         else if(current < stable + 0.25) // when close enough, "snap"
1568                 return stable;
1569         else
1570                 return max(stable, current + (stable - current) * rotfactor * rotframetime);
1571 }
1572
1573 float CalcRotRegen(float current, float regenstable, float regenfactor, float regenlinear, float regenframetime, float rotstable, float rotfactor, float rotlinear, float rotframetime, float limit)
1574 {
1575         if(current > rotstable)
1576         {
1577                 if(rotframetime > 0)
1578                 {
1579                         current = CalcRot(current, rotstable, rotfactor, rotframetime);
1580                         current = max(rotstable, current - rotlinear * rotframetime);
1581                 }
1582         }
1583         else if(current < regenstable)
1584         {
1585                 if(regenframetime > 0)
1586                 {
1587                         current = CalcRegen(current, regenstable, regenfactor, regenframetime);
1588                         current = min(regenstable, current + regenlinear * regenframetime);
1589                 }
1590         }
1591
1592         if(current > limit)
1593                 current = limit;
1594
1595         return current;
1596 }
1597
1598 void player_regen (void)
1599 {
1600         float max_mod, regen_mod, rot_mod, limit_mod;
1601         max_mod = regen_mod = rot_mod = limit_mod = 1;
1602         regen_mod_max = max_mod;
1603         regen_mod_regen = regen_mod;
1604         regen_mod_rot = rot_mod;
1605         regen_mod_limit = limit_mod;
1606         if(!MUTATOR_CALLHOOK(PlayerRegen))
1607         if(!self.frozen)
1608         {
1609                 float minh, mina, maxh, maxa, limith, limita;
1610                 maxh = autocvar_g_balance_health_rotstable;
1611                 maxa = autocvar_g_balance_armor_rotstable;
1612                 minh = autocvar_g_balance_health_regenstable;
1613                 mina = autocvar_g_balance_armor_regenstable;
1614                 limith = autocvar_g_balance_health_limit;
1615                 limita = autocvar_g_balance_armor_limit;
1616
1617                 max_mod = regen_mod_max;
1618                 regen_mod = regen_mod_regen;
1619                 rot_mod = regen_mod_rot;
1620                 limit_mod = regen_mod_limit;
1621
1622                 maxh = maxh * max_mod;
1623                 minh = minh * max_mod;
1624                 limith = limith * limit_mod;
1625                 limita = limita * limit_mod;
1626
1627                 self.armorvalue = CalcRotRegen(self.armorvalue, mina, autocvar_g_balance_armor_regen, autocvar_g_balance_armor_regenlinear, regen_mod * frametime * (time > self.pauseregen_finished), maxa, autocvar_g_balance_armor_rot, autocvar_g_balance_armor_rotlinear, rot_mod * frametime * (time > self.pauserotarmor_finished), limita);
1628                 self.health = CalcRotRegen(self.health, minh, autocvar_g_balance_health_regen, autocvar_g_balance_health_regenlinear, regen_mod * frametime * (time > self.pauseregen_finished), maxh, autocvar_g_balance_health_rot, autocvar_g_balance_health_rotlinear, rot_mod * frametime * (time > self.pauserothealth_finished), limith);
1629         }
1630
1631         // if player rotted to death...  die!
1632         // check this outside above checks, as player may still be able to rot to death
1633         if(self.health < 1)
1634         {
1635                 if(self.vehicle)
1636                         vehicles_exit(VHEF_RELEASE);
1637                 self.event_damage(self, self, 1, DEATH_ROT, self.origin, '0 0 0');
1638         }
1639
1640         if (!(self.items & IT_UNLIMITED_WEAPON_AMMO))
1641         {
1642                 float minf, maxf, limitf;
1643
1644                 maxf = autocvar_g_balance_fuel_rotstable;
1645                 minf = autocvar_g_balance_fuel_regenstable;
1646                 limitf = autocvar_g_balance_fuel_limit;
1647
1648                 self.ammo_fuel = CalcRotRegen(self.ammo_fuel, minf, autocvar_g_balance_fuel_regen, autocvar_g_balance_fuel_regenlinear, frametime * (time > self.pauseregen_finished) * ((self.items & IT_FUEL_REGEN) != 0), maxf, autocvar_g_balance_fuel_rot, autocvar_g_balance_fuel_rotlinear, frametime * (time > self.pauserotfuel_finished), limitf);
1649         }
1650 }
1651
1652 float zoomstate_set;
1653 void SetZoomState(float z)
1654 {
1655         if(z != self.zoomstate)
1656         {
1657                 self.zoomstate = z;
1658                 ClientData_Touch(self);
1659         }
1660         zoomstate_set = 1;
1661 }
1662
1663 void GetPressedKeys(void) {
1664         MUTATOR_CALLHOOK(GetPressedKeys);
1665         if (self.movement.x > 0) // get if movement keys are pressed
1666         {       // forward key pressed
1667                 self.pressedkeys |= KEY_FORWARD;
1668                 self.pressedkeys &= ~KEY_BACKWARD;
1669         }
1670         else if (self.movement.x < 0)
1671         {       // backward key pressed
1672                 self.pressedkeys |= KEY_BACKWARD;
1673                 self.pressedkeys &= ~KEY_FORWARD;
1674         }
1675         else
1676         {       // no x input
1677                 self.pressedkeys &= ~KEY_FORWARD;
1678                 self.pressedkeys &= ~KEY_BACKWARD;
1679         }
1680
1681         if (self.movement.y > 0)
1682         {       // right key pressed
1683                 self.pressedkeys |= KEY_RIGHT;
1684                 self.pressedkeys &= ~KEY_LEFT;
1685         }
1686         else if (self.movement.y < 0)
1687         {       // left key pressed
1688                 self.pressedkeys |= KEY_LEFT;
1689                 self.pressedkeys &= ~KEY_RIGHT;
1690         }
1691         else
1692         {       // no y input
1693                 self.pressedkeys &= ~KEY_RIGHT;
1694                 self.pressedkeys &= ~KEY_LEFT;
1695         }
1696
1697         if (self.BUTTON_JUMP) // get if jump and crouch keys are pressed
1698                 self.pressedkeys |= KEY_JUMP;
1699         else
1700                 self.pressedkeys &= ~KEY_JUMP;
1701         if (self.BUTTON_CROUCH)
1702                 self.pressedkeys |= KEY_CROUCH;
1703         else
1704                 self.pressedkeys &= ~KEY_CROUCH;
1705
1706         if (self.BUTTON_ATCK)
1707                 self.pressedkeys |= KEY_ATCK;
1708         else
1709                 self.pressedkeys &= ~KEY_ATCK;
1710         if (self.BUTTON_ATCK2)
1711                 self.pressedkeys |= KEY_ATCK2;
1712         else
1713                 self.pressedkeys &= ~KEY_ATCK2;
1714 }
1715
1716 /*
1717 ======================
1718 spectate mode routines
1719 ======================
1720 */
1721
1722 void SpectateCopy(entity spectatee) {
1723         other = spectatee;
1724         MUTATOR_CALLHOOK(SpectateCopy);
1725         self.armortype = spectatee.armortype;
1726         self.armorvalue = spectatee.armorvalue;
1727         self.ammo_cells = spectatee.ammo_cells;
1728         self.ammo_plasma = spectatee.ammo_plasma;
1729         self.ammo_shells = spectatee.ammo_shells;
1730         self.ammo_nails = spectatee.ammo_nails;
1731         self.ammo_rockets = spectatee.ammo_rockets;
1732         self.ammo_fuel = spectatee.ammo_fuel;
1733         self.clip_load = spectatee.clip_load;
1734         self.clip_size = spectatee.clip_size;
1735         self.effects = spectatee.effects & EFMASK_CHEAP; // eat performance
1736         self.health = spectatee.health;
1737         self.impulse = 0;
1738         self.items = spectatee.items;
1739         self.last_pickup = spectatee.last_pickup;
1740         self.hit_time = spectatee.hit_time;
1741         self.metertime = spectatee.metertime;
1742         self.strength_finished = spectatee.strength_finished;
1743         self.invincible_finished = spectatee.invincible_finished;
1744         self.pressedkeys = spectatee.pressedkeys;
1745         self.weapons = spectatee.weapons;
1746         self.switchweapon = spectatee.switchweapon;
1747         self.switchingweapon = spectatee.switchingweapon;
1748         self.weapon = spectatee.weapon;
1749         self.vortex_charge = spectatee.vortex_charge;
1750         self.vortex_chargepool_ammo = spectatee.vortex_chargepool_ammo;
1751         self.hagar_load = spectatee.hagar_load;
1752         self.arc_heat_percent = spectatee.arc_heat_percent;
1753         self.minelayer_mines = spectatee.minelayer_mines;
1754         self.punchangle = spectatee.punchangle;
1755         self.view_ofs = spectatee.view_ofs;
1756         self.velocity = spectatee.velocity;
1757         self.dmg_take = spectatee.dmg_take;
1758         self.dmg_save = spectatee.dmg_save;
1759         self.dmg_inflictor = spectatee.dmg_inflictor;
1760         self.v_angle = spectatee.v_angle;
1761         self.angles = spectatee.v_angle;
1762         self.frozen = spectatee.frozen;
1763         self.revive_progress = spectatee.revive_progress;
1764         if(!self.BUTTON_USE)
1765                 self.fixangle = true;
1766         setorigin(self, spectatee.origin);
1767         setsize(self, spectatee.mins, spectatee.maxs);
1768         SetZoomState(spectatee.zoomstate);
1769
1770     anticheat_spectatecopy(spectatee);
1771         self.hud = spectatee.hud;
1772         if(spectatee.vehicle)
1773     {
1774         self.fixangle = false;
1775         //self.velocity = spectatee.vehicle.velocity;
1776         self.vehicle_health = spectatee.vehicle_health;
1777         self.vehicle_shield = spectatee.vehicle_shield;
1778         self.vehicle_energy = spectatee.vehicle_energy;
1779         self.vehicle_ammo1 = spectatee.vehicle_ammo1;
1780         self.vehicle_ammo2 = spectatee.vehicle_ammo2;
1781         self.vehicle_reload1 = spectatee.vehicle_reload1;
1782         self.vehicle_reload2 = spectatee.vehicle_reload2;
1783
1784         msg_entity = self;
1785
1786         WriteByte (MSG_ONE, SVC_SETVIEWANGLES);
1787             WriteAngle(MSG_ONE,  spectatee.v_angle.x);
1788             WriteAngle(MSG_ONE,  spectatee.v_angle.y);
1789             WriteAngle(MSG_ONE,  spectatee.v_angle.z);
1790
1791         //WriteByte (MSG_ONE, SVC_SETVIEW);
1792         //    WriteEntity(MSG_ONE, self);
1793         //makevectors(spectatee.v_angle);
1794         //setorigin(self, spectatee.origin - v_forward * 400 + v_up * 300);*/
1795     }
1796 }
1797
1798 float SpectateUpdate()
1799 {
1800         if(!self.enemy)
1801             return 0;
1802
1803         if(!IS_PLAYER(self.enemy) || self == self.enemy)
1804         {
1805                 SetSpectator(self, world);
1806                 return 0;
1807         }
1808
1809         SpectateCopy(self.enemy);
1810
1811         return 1;
1812 }
1813
1814 float SpectateSet()
1815 {
1816         if(self.enemy.classname != "player")
1817                 return false;
1818         /*if(self.enemy.vehicle)
1819         {
1820
1821                 msg_entity = self;
1822                 WriteByte(MSG_ONE, SVC_SETVIEW);
1823                 WriteEntity(MSG_ONE, self.enemy);
1824                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
1825
1826                 self.movetype = MOVETYPE_NONE;
1827                 accuracy_resend(self);
1828         }
1829         else
1830         {*/
1831                 msg_entity = self;
1832                 WriteByte(MSG_ONE, SVC_SETVIEW);
1833                 WriteEntity(MSG_ONE, self.enemy);
1834                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
1835                 self.movetype = MOVETYPE_NONE;
1836                 accuracy_resend(self);
1837
1838                 if(!SpectateUpdate())
1839                         PutObserverInServer();
1840         //}
1841         return true;
1842 }
1843
1844 void SetSpectator(entity player, entity spectatee)
1845 {
1846         entity old_spectatee = player.enemy;
1847
1848         player.enemy = spectatee;
1849
1850         // WEAPONTODO
1851         // these are required to fix the spectator bug with arc
1852         if(old_spectatee && old_spectatee.arc_beam) { old_spectatee.arc_beam.SendFlags |= ARC_SF_SETTINGS; }
1853         if(player.enemy && player.enemy.arc_beam) { player.enemy.arc_beam.SendFlags |= ARC_SF_SETTINGS; }
1854 }
1855
1856 float Spectate(entity pl)
1857 {
1858         if(g_ca && !autocvar_g_ca_spectate_enemies && self.caplayer)
1859         if(pl.team != self.team)
1860                 return 0;
1861
1862         SetSpectator(self, pl);
1863         return SpectateSet();
1864 }
1865
1866 // Returns next available player to spectate if g_ca_spectate_enemies == 0
1867 entity CA_SpectateNext(entity start) {
1868         if (start.team == self.team) {
1869                 return start;
1870         }
1871
1872         other = start;
1873         // continue from current player
1874         while(other && other.team != self.team) {
1875                 other = find(other, classname, "player");
1876         }
1877
1878         if (!other) {
1879                 // restart from begining
1880                 other = find(other, classname, "player");
1881                 while(other && other.team != self.team) {
1882                         other = find(other, classname, "player");
1883                 }
1884         }
1885
1886         return other;
1887 }
1888
1889 float SpectateNext()
1890 {
1891         other = find(self.enemy, classname, "player");
1892
1893         if (g_ca && !autocvar_g_ca_spectate_enemies && self.caplayer) {
1894                 // CA and ca players when spectating enemies is forbidden
1895                 other = CA_SpectateNext(other);
1896         } else {
1897                 // other modes and ca spectators or spectating enemies is allowed
1898                 if (!other)
1899                         other = find(other, classname, "player");
1900         }
1901
1902         if(other) { SetSpectator(self, other); }
1903
1904         return SpectateSet();
1905 }
1906
1907 float SpectatePrev()
1908 {
1909         // NOTE: chain order is from the highest to the lower entnum (unlike find)
1910         other = findchain(classname, "player");
1911         if (!other) // no player
1912                 return false;
1913
1914         entity first = other;
1915         // skip players until current spectated player
1916         if(self.enemy)
1917         while(other && other != self.enemy)
1918                 other = other.chain;
1919
1920         if (g_ca && !autocvar_g_ca_spectate_enemies && self.caplayer)
1921         {
1922                 do { other = other.chain; }
1923                 while(other && other.team != self.team);
1924
1925                 if (!other)
1926                 {
1927                         other = first;
1928                         while(other.team != self.team)
1929                                 other = other.chain;
1930                         if(other == self.enemy)
1931                                 return true;
1932                 }
1933         }
1934         else
1935         {
1936                 if(other.chain)
1937                         other = other.chain;
1938                 else
1939                         other = first;
1940         }
1941         SetSpectator(self, other);
1942         return SpectateSet();
1943 }
1944
1945 /*
1946 =============
1947 ShowRespawnCountdown()
1948
1949 Update a respawn countdown display.
1950 =============
1951 */
1952 void ShowRespawnCountdown()
1953 {
1954         float number;
1955         if(self.deadflag == DEAD_NO) // just respawned?
1956                 return;
1957         else
1958         {
1959                 number = ceil(self.respawn_time - time);
1960                 if(number <= 0)
1961                         return;
1962                 if(number <= self.respawn_countdown)
1963                 {
1964                         self.respawn_countdown = number - 1;
1965                         if(ceil(self.respawn_time - (time + 0.5)) == number) // only say it if it is the same number even in 0.5s; to prevent overlapping sounds
1966                                 { Send_Notification(NOTIF_ONE, self, MSG_ANNCE, Announcer_PickNumber(CNT_RESPAWN, number)); }
1967                 }
1968         }
1969 }
1970
1971 void LeaveSpectatorMode()
1972 {
1973         if(self.caplayer)
1974                 return;
1975         if(nJoinAllowed(self))
1976         {
1977                 if(!teamplay || autocvar_g_campaign || autocvar_g_balance_teams || (self.wasplayer && autocvar_g_changeteam_banned) || self.team_forced > 0)
1978                 {
1979                         self.classname = "player";
1980                         nades_RemoveBonus(self);
1981
1982                         if(autocvar_g_campaign || autocvar_g_balance_teams)
1983                                 { JoinBestTeam(self, false, true); }
1984
1985                         if(autocvar_g_campaign)
1986                                 { campaign_bots_may_start = 1; }
1987
1988                         Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_PREVENT_JOIN);
1989
1990                         PutClientInServer();
1991
1992                         if(IS_PLAYER(self)) { Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_JOIN_PLAY, self.netname); }
1993                 }
1994                 else
1995                         stuffcmd(self, "menu_showteamselect\n");
1996         }
1997         else
1998         {
1999                 // Player may not join because g_maxplayers is set
2000                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_JOIN_PREVENT);
2001         }
2002 }
2003
2004 /**
2005  * Determines whether the player is allowed to join. This depends on cvar
2006  * g_maxplayers, if it isn't used this function always return true, otherwise
2007  * it checks whether the number of currently playing players exceeds g_maxplayers.
2008  * @return int number of free slots for players, 0 if none
2009  */
2010 float nJoinAllowed(entity ignore) {
2011         if(!ignore)
2012         // this is called that way when checking if anyone may be able to join (to build qcstatus)
2013         // so report 0 free slots if restricted
2014         {
2015                 if(autocvar_g_forced_team_otherwise == "spectate")
2016                         return 0;
2017                 if(autocvar_g_forced_team_otherwise == "spectator")
2018                         return 0;
2019         }
2020
2021         if(self.team_forced < 0)
2022                 return 0; // forced spectators can never join
2023
2024         // TODO simplify this
2025         entity e;
2026         float totalClients = 0;
2027         FOR_EACH_CLIENT(e)
2028                 if(e != ignore)
2029                         totalClients += 1;
2030
2031         if (!autocvar_g_maxplayers)
2032                 return maxclients - totalClients;
2033
2034         float currentlyPlaying = 0;
2035         FOR_EACH_REALCLIENT(e)
2036                 if(IS_PLAYER(e) || e.caplayer)
2037                         currentlyPlaying += 1;
2038
2039         if(currentlyPlaying < autocvar_g_maxplayers)
2040                 return min(maxclients - totalClients, autocvar_g_maxplayers - currentlyPlaying);
2041
2042         return 0;
2043 }
2044
2045 /**
2046  * Checks whether the client is an observer or spectator, if so, he will get kicked after
2047  * g_maxplayers_spectator_blocktime seconds
2048  */
2049 void checkSpectatorBlock() {
2050         if(IS_SPEC(self) || IS_OBSERVER(self))
2051         if(!self.caplayer)
2052         if(IS_REAL_CLIENT(self))
2053         {
2054                 if( time > (self.spectatortime + autocvar_g_maxplayers_spectator_blocktime) ) {
2055                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_QUIT_KICK_SPECTATING);
2056                         dropclient(self);
2057                 }
2058         }
2059 }
2060
2061 void PrintWelcomeMessage()
2062 {
2063         if(self.motd_actived_time == 0)
2064         {
2065                 if (autocvar_g_campaign) {
2066                         if ((IS_PLAYER(self) && self.BUTTON_INFO) || (!IS_PLAYER(self))) {
2067                                 self.motd_actived_time = time;
2068                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_MOTD, campaign_message);
2069                         }
2070                 } else {
2071                         if (self.BUTTON_INFO) {
2072                                 self.motd_actived_time = time;
2073                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_MOTD, getwelcomemessage());
2074                         }
2075                 }
2076         }
2077         else if(self.motd_actived_time > 0) // showing MOTD or campaign message
2078         {
2079                 if (autocvar_g_campaign) {
2080                         if (self.BUTTON_INFO)
2081                                 self.motd_actived_time = time;
2082                         else if ((time - self.motd_actived_time > 2) && IS_PLAYER(self)) { // hide it some seconds after BUTTON_INFO has been released
2083                                 self.motd_actived_time = 0;
2084                                 Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_MOTD);
2085                         }
2086                 } else {
2087                         if (self.BUTTON_INFO)
2088                                 self.motd_actived_time = time;
2089                         else if (time - self.motd_actived_time > 2) { // hide it some seconds after BUTTON_INFO has been released
2090                                 self.motd_actived_time = 0;
2091                                 Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_MOTD);
2092                         }
2093                 }
2094         }
2095         else //if(self.motd_actived_time < 0) // just connected, motd is active
2096         {
2097                 if(self.BUTTON_INFO) // BUTTON_INFO hides initial MOTD
2098                         self.motd_actived_time = -2; // wait until BUTTON_INFO gets released
2099                 else if(self.motd_actived_time == -2 || IS_PLAYER(self))
2100                 {
2101                         // instanctly hide MOTD
2102                         self.motd_actived_time = 0;
2103                         Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_MOTD);
2104                 }
2105         }
2106 }
2107
2108 void ObserverThink()
2109 {
2110         float prefered_movetype;
2111         if (self.flags & FL_JUMPRELEASED) {
2112                 if (self.BUTTON_JUMP && !self.version_mismatch) {
2113                         self.flags &= ~FL_JUMPRELEASED;
2114                         self.flags |= FL_SPAWNING;
2115                 } else if(self.BUTTON_ATCK && !self.version_mismatch) {
2116                         self.flags &= ~FL_JUMPRELEASED;
2117                         if(SpectateNext()) {
2118                                 self.classname = "spectator";
2119                         }
2120                 } else {
2121                         prefered_movetype = ((!self.BUTTON_USE ? self.cvar_cl_clippedspectating : !self.cvar_cl_clippedspectating) ? MOVETYPE_FLY_WORLDONLY : MOVETYPE_NOCLIP);
2122                         if (self.movetype != prefered_movetype)
2123                                 self.movetype = prefered_movetype;
2124                 }
2125         } else {
2126                 if (!(self.BUTTON_ATCK || self.BUTTON_JUMP)) {
2127                         self.flags |= FL_JUMPRELEASED;
2128                         if(self.flags & FL_SPAWNING)
2129                         {
2130                                 self.flags &= ~FL_SPAWNING;
2131                                 LeaveSpectatorMode();
2132                                 return;
2133                         }
2134                 }
2135         }
2136 }
2137
2138 void SpectatorThink()
2139 {
2140         if (self.flags & FL_JUMPRELEASED) {
2141                 if (self.BUTTON_JUMP && !self.version_mismatch) {
2142                         self.flags &= ~FL_JUMPRELEASED;
2143                         self.flags |= FL_SPAWNING;
2144                 } else if(self.BUTTON_ATCK || self.impulse == 10 || self.impulse == 15 || self.impulse == 18 || (self.impulse >= 200 && self.impulse <= 209)) {
2145                         self.flags &= ~FL_JUMPRELEASED;
2146                         if(SpectateNext()) {
2147                                 self.classname = "spectator";
2148                         } else {
2149                                 self.classname = "observer";
2150                                 PutClientInServer();
2151                         }
2152                         self.impulse = 0;
2153                 } else if(self.impulse == 12 || self.impulse == 16  || self.impulse == 19 || (self.impulse >= 220 && self.impulse <= 229)) {
2154                         self.flags &= ~FL_JUMPRELEASED;
2155                         if(SpectatePrev()) {
2156                                 self.classname = "spectator";
2157                         } else {
2158                                 self.classname = "observer";
2159                                 PutClientInServer();
2160                         }
2161                         self.impulse = 0;
2162                 } else if (self.BUTTON_ATCK2) {
2163                         self.flags &= ~FL_JUMPRELEASED;
2164                         self.classname = "observer";
2165                         PutClientInServer();
2166                 } else {
2167                         if(!SpectateUpdate())
2168                                 PutObserverInServer();
2169                 }
2170         } else {
2171                 if (!(self.BUTTON_ATCK || self.BUTTON_ATCK2)) {
2172                         self.flags |= FL_JUMPRELEASED;
2173                         if(self.flags & FL_SPAWNING)
2174                         {
2175                                 self.flags &= ~FL_SPAWNING;
2176                                 LeaveSpectatorMode();
2177                                 return;
2178                         }
2179                 }
2180                 if(!SpectateUpdate())
2181                         PutObserverInServer();
2182         }
2183
2184         self.flags |= FL_CLIENT | FL_NOTARGET;
2185 }
2186
2187 void vehicles_enter (entity pl, entity veh);
2188 void PlayerUseKey()
2189 {
2190         if (!IS_PLAYER(self))
2191                 return;
2192
2193         if(self.vehicle)
2194         {
2195                 if(!gameover)
2196                 {
2197                         vehicles_exit(VHEF_NORMAL);
2198                         return;
2199                 }
2200         }
2201         else if(autocvar_g_vehicles_enter)
2202         {
2203                 if(!self.frozen)
2204                 if(self.deadflag == DEAD_NO)
2205                 if(!gameover)
2206                 {
2207                         entity head, closest_target = world;
2208                         head = WarpZone_FindRadius(self.origin, autocvar_g_vehicles_enter_radius, TRUE);
2209
2210                         while(head) // find the closest acceptable target to enter
2211                         {
2212                                 if(head.vehicle_flags & VHF_ISVEHICLE)
2213                                 if(head.deadflag == DEAD_NO)
2214                                 if(!head.owner || ((head.vehicle_flags & VHF_MULTISLOT) && SAME_TEAM(head.owner, self)))
2215                                 if(head.takedamage != DAMAGE_NO)
2216                                 {
2217                                         if(closest_target)
2218                                         {
2219                                                 if(vlen(self.origin - head.origin) < vlen(self.origin - closest_target.origin))
2220                                                 { closest_target = head; }
2221                                         }
2222                                         else { closest_target = head; }
2223                                 }
2224
2225                                 head = head.chain;
2226                         }
2227
2228                         if(closest_target) { vehicles_enter(self, closest_target); return; }
2229                 }
2230         }
2231
2232         // a use key was pressed; call handlers
2233         MUTATOR_CALLHOOK(PlayerUseKey);
2234 }
2235
2236 float isInvisibleString(string s)
2237 {
2238         float i, n, c;
2239         s = strdecolorize(s);
2240         for((i = 0), (n = strlen(s)); i < n; ++i)
2241         {
2242                 c = str2chr(s, i);
2243                 switch(c)
2244                 {
2245                         case 0:
2246                         case 32: // space
2247                                 break;
2248                         case 192: // charmap space
2249                                 if (!autocvar_utf8_enable)
2250                                         break;
2251                                 return false;
2252                         case 160: // space in unicode fonts
2253                         case 0xE000 + 192: // utf8 charmap space
2254                                 if (autocvar_utf8_enable)
2255                                         break;
2256                         default:
2257                                 return false;
2258                 }
2259         }
2260         return true;
2261 }
2262
2263 /*
2264 =============
2265 PlayerPreThink
2266
2267 Called every frame for each client before the physics are run
2268 =============
2269 */
2270 .float usekeypressed;
2271 void() nexball_setstatus;
2272 .float last_vehiclecheck;
2273 .int items_added;
2274 void PlayerPreThink (void)
2275 {
2276         WarpZone_PlayerPhysics_FixVAngle();
2277
2278         self.stat_game_starttime = game_starttime;
2279         self.stat_round_starttime = round_starttime;
2280         self.stat_allow_oldvortexbeam = autocvar_g_allow_oldvortexbeam;
2281         self.stat_leadlimit = autocvar_leadlimit;
2282
2283         if(frametime)
2284         {
2285                 // physics frames: update anticheat stuff
2286                 anticheat_prethink();
2287         }
2288
2289         if(blockSpectators && frametime)
2290                 // WORKAROUND: only use dropclient in server frames (frametime set). Never use it in cl_movement frames (frametime zero).
2291                 checkSpectatorBlock();
2292
2293         zoomstate_set = 0;
2294
2295         // Savage: Check for nameless players
2296         if (isInvisibleString(self.netname)) {
2297                 string new_name = strzone(strcat("Player@", self.netaddress));
2298                 if(autocvar_sv_eventlog)
2299                         GameLogEcho(strcat(":name:", ftos(self.playerid), ":", new_name));
2300                 if(self.netname_previous)
2301                         strunzone(self.netname_previous);
2302                 self.netname_previous = strzone(new_name);
2303                 self.netname = self.netname_previous;
2304                 // stuffcmd(self, strcat("name ", self.netname, "\n"));
2305         } else if(self.netname_previous != self.netname) {
2306                 if(autocvar_sv_eventlog)
2307                         GameLogEcho(strcat(":name:", ftos(self.playerid), ":", self.netname));
2308                 if(self.netname_previous)
2309                         strunzone(self.netname_previous);
2310                 self.netname_previous = strzone(self.netname);
2311         }
2312
2313         // version nagging
2314         if(self.version_nagtime)
2315                 if(self.cvar_g_xonoticversion)
2316                         if(time > self.version_nagtime)
2317                         {
2318                                 // don't notify git users
2319                                 if(strstr(self.cvar_g_xonoticversion, "git", 0) < 0 && strstr(self.cvar_g_xonoticversion, "autobuild", 0) < 0)
2320                                 {
2321                                         if(strstr(autocvar_g_xonoticversion, "git", 0) >= 0 || strstr(autocvar_g_xonoticversion, "autobuild", 0) >= 0)
2322                                         {
2323                                                 // notify release users if connecting to git
2324                                                 dprint("^1NOTE^7 to ", self.netname, "^7 - the server is running ^3Xonotic ", autocvar_g_xonoticversion, " (beta)^7, you have ^3Xonotic ", self.cvar_g_xonoticversion, "^1\n");
2325                                                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_VERSION_BETA, autocvar_g_xonoticversion, self.cvar_g_xonoticversion);
2326                                         }
2327                                         else
2328                                         {
2329                                                 float r;
2330                                                 r = vercmp(self.cvar_g_xonoticversion, autocvar_g_xonoticversion);
2331                                                 if(r < 0)
2332                                                 {
2333                                                         // give users new version
2334                                                         dprint("^1NOTE^7 to ", self.netname, "^7 - ^3Xonotic ", autocvar_g_xonoticversion, "^7 is out, and you still have ^3Xonotic ", self.cvar_g_xonoticversion, "^1 - get the update from ^4http://www.xonotic.org/^1!\n");
2335                                                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_VERSION_OUTDATED, autocvar_g_xonoticversion, self.cvar_g_xonoticversion);
2336                                                 }
2337                                                 else if(r > 0)
2338                                                 {
2339                                                         // notify users about old server version
2340                                                         print("^1NOTE^7 to ", self.netname, "^7 - the server is running ^3Xonotic ", autocvar_g_xonoticversion, "^7, you have ^3Xonotic ", self.cvar_g_xonoticversion, "^1\n");
2341                                                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_VERSION_OLD, autocvar_g_xonoticversion, self.cvar_g_xonoticversion);
2342                                                 }
2343                                         }
2344                                 }
2345                                 self.version_nagtime = 0;
2346                         }
2347
2348         // GOD MODE info
2349         if(!(self.flags & FL_GODMODE)) if(self.max_armorvalue)
2350         {
2351                 Send_Notification(NOTIF_ONE_ONLY, self, MSG_INFO, INFO_GODMODE_OFF, self.max_armorvalue);
2352                 self.max_armorvalue = 0;
2353         }
2354
2355 #ifdef TETRIS
2356         if (TetrisPreFrame())
2357                 return;
2358 #endif
2359
2360         if(self.frozen == 2)
2361         {
2362                 self.revive_progress = bound(0, self.revive_progress + frametime * self.revive_speed, 1);
2363                 self.health = max(1, self.revive_progress * start_health);
2364                 self.iceblock.alpha = bound(0.2, 1 - self.revive_progress, 1);
2365
2366                 if(self.revive_progress >= 1)
2367                         Unfreeze(self);
2368         }
2369         else if(self.frozen == 3)
2370         {
2371                 self.revive_progress = bound(0, self.revive_progress - frametime * self.revive_speed, 1);
2372                 self.health = max(0, autocvar_g_nades_ice_health + (start_health-autocvar_g_nades_ice_health) * self.revive_progress );
2373
2374                 if(self.health < 1)
2375                 {
2376                         if(self.vehicle)
2377                                 vehicles_exit(VHEF_RELEASE);
2378                         self.event_damage(self, self.frozen_by, 1, DEATH_NADE_ICE_FREEZE, self.origin, '0 0 0');
2379                 }
2380                 else if ( self.revive_progress <= 0 )
2381                         Unfreeze(self);
2382         }
2383
2384         MUTATOR_CALLHOOK(PlayerPreThink);
2385
2386         if(autocvar_g_vehicles_enter)
2387         if(time > self.last_vehiclecheck)
2388         if(IS_PLAYER(self))
2389         if(!gameover)
2390         if(!self.frozen)
2391         if(!self.vehicle)
2392         if(self.deadflag == DEAD_NO)
2393         {
2394                 entity veh;
2395                 for(veh = world; (veh = findflags(veh, vehicle_flags, VHF_ISVEHICLE)); )
2396                 if(vlen(veh.origin - self.origin) < autocvar_g_vehicles_enter_radius)
2397                 if(veh.deadflag == DEAD_NO)
2398                 if(veh.takedamage != DAMAGE_NO)
2399                 if((veh.vehicle_flags & VHF_MULTISLOT) && SAME_TEAM(veh.owner, self))
2400                         Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_VEHICLE_ENTER_GUNNER);
2401                 else if(!veh.owner)
2402                 if(!veh.team || SAME_TEAM(self, veh))
2403                         Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_VEHICLE_ENTER);
2404                 else if(autocvar_g_vehicles_steal)
2405                         Send_Notification(NOTIF_ONE, self, MSG_CENTER, CENTER_VEHICLE_ENTER_STEAL);
2406
2407                 self.last_vehiclecheck = time + 1;
2408         }
2409
2410         if(!self.cvar_cl_newusekeysupported) // FIXME remove this - it was a stupid idea to begin with, we can JUST use the button
2411         {
2412                 if(self.BUTTON_USE && !self.usekeypressed)
2413                         PlayerUseKey();
2414                 self.usekeypressed = self.BUTTON_USE;
2415         }
2416
2417         if(IS_REAL_CLIENT(self))
2418                 PrintWelcomeMessage();
2419
2420         if(IS_PLAYER(self))
2421         {
2422
2423                 CheckRules_Player();
2424
2425                 if (intermission_running)
2426                 {
2427                         IntermissionThink ();   // otherwise a button could be missed between
2428                         return;                                 // the think tics
2429                 }
2430
2431                 //don't allow the player to turn around while game is paused!
2432                 if(timeout_status == TIMEOUT_ACTIVE) {
2433                         // FIXME turn this into CSQC stuff
2434                         self.v_angle = self.lastV_angle;
2435                         self.angles = self.lastV_angle;
2436                         self.fixangle = true;
2437                 }
2438
2439                 if(frametime)
2440                 {
2441                         if(self.weapon == WEP_VORTEX && WEP_CVAR(vortex, charge))
2442                         {
2443                                 self.weaponentity_glowmod_x = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_red_half * min(1, self.vortex_charge / WEP_CVAR(vortex, charge_animlimit));
2444                                 self.weaponentity_glowmod_y = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_green_half * min(1, self.vortex_charge / WEP_CVAR(vortex, charge_animlimit));
2445                                 self.weaponentity_glowmod_z = autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_blue_half * min(1, self.vortex_charge / WEP_CVAR(vortex, charge_animlimit));
2446
2447                                 if(self.vortex_charge > WEP_CVAR(vortex, charge_animlimit))
2448                                 {
2449                                         self.weaponentity_glowmod_x = self.weaponentity_glowmod.x + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_red_full * (self.vortex_charge - WEP_CVAR(vortex, charge_animlimit)) / (1 - WEP_CVAR(vortex, charge_animlimit));
2450                                         self.weaponentity_glowmod_y = self.weaponentity_glowmod.y + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_green_full * (self.vortex_charge - WEP_CVAR(vortex, charge_animlimit)) / (1 - WEP_CVAR(vortex, charge_animlimit));
2451                                         self.weaponentity_glowmod_z = self.weaponentity_glowmod.z + autocvar_g_weapon_charge_colormod_hdrmultiplier * autocvar_g_weapon_charge_colormod_blue_full * (self.vortex_charge - WEP_CVAR(vortex, charge_animlimit)) / (1 - WEP_CVAR(vortex, charge_animlimit));
2452                                 }
2453                         }
2454                         else
2455                                 self.weaponentity_glowmod = colormapPaletteColor(self.clientcolors & 0x0F, true) * 2;
2456
2457                         player_powerups();
2458                 }
2459
2460                 if (self.deadflag != DEAD_NO)
2461                 {
2462                         if(self.personal && g_race_qualifying)
2463                         {
2464                                 if(time > self.respawn_time)
2465                                 {
2466                                         self.respawn_time = time + 1; // only retry once a second
2467                                         self.stat_respawn_time = self.respawn_time;
2468                                         respawn();
2469                                         self.impulse = 141;
2470                                 }
2471                         }
2472                         else
2473                         {
2474                                 float button_pressed;
2475                                 if(frametime)
2476                                         player_anim();
2477                                 button_pressed = (self.BUTTON_ATCK || self.BUTTON_JUMP || self.BUTTON_ATCK2 || self.BUTTON_HOOK || self.BUTTON_USE);
2478
2479                                 if (self.deadflag == DEAD_DYING)
2480                                 {
2481                                         if((self.respawn_flags & RESPAWN_FORCE) && !autocvar_g_respawn_delay_max)
2482                                                 self.deadflag = DEAD_RESPAWNING;
2483                                         else if(!button_pressed)
2484                                                 self.deadflag = DEAD_DEAD;
2485                                 }
2486                                 else if (self.deadflag == DEAD_DEAD)
2487                                 {
2488                                         if(button_pressed)
2489                                                 self.deadflag = DEAD_RESPAWNABLE;
2490                                         else if(time >= self.respawn_time_max && (self.respawn_flags & RESPAWN_FORCE))
2491                                                 self.deadflag = DEAD_RESPAWNING;
2492                                 }
2493                                 else if (self.deadflag == DEAD_RESPAWNABLE)
2494                                 {
2495                                         if(!button_pressed)
2496                                                 self.deadflag = DEAD_RESPAWNING;
2497                                 }
2498                                 else if (self.deadflag == DEAD_RESPAWNING)
2499                                 {
2500                                         if(time > self.respawn_time)
2501                                         {
2502                                                 self.respawn_time = time + 1; // only retry once a second
2503                                                 self.respawn_time_max = self.respawn_time;
2504                                                 respawn();
2505                                         }
2506                                 }
2507
2508                                 ShowRespawnCountdown();
2509
2510                                 if(self.respawn_flags & RESPAWN_SILENT)
2511                                         self.stat_respawn_time = 0;
2512                                 else if((self.respawn_flags & RESPAWN_FORCE) && autocvar_g_respawn_delay_max)
2513                                         self.stat_respawn_time = self.respawn_time_max;
2514                                 else
2515                                         self.stat_respawn_time = self.respawn_time;
2516                         }
2517
2518                         // if respawning, invert stat_respawn_time to indicate this, the client translates it
2519                         if(self.deadflag == DEAD_RESPAWNING && self.stat_respawn_time > 0)
2520                                 self.stat_respawn_time *= -1;
2521
2522                         return;
2523                 }
2524
2525                 self.prevorigin = self.origin;
2526
2527                 float do_crouch = self.BUTTON_CROUCH;
2528                 if(self.hook.state)
2529                         do_crouch = 0;
2530                 if(self.vehicle)
2531                         do_crouch = 0;
2532                 if(self.frozen)
2533                         do_crouch = 0;
2534
2535                 // WEAPONTODO: THIS SHIT NEEDS TO GO EVENTUALLY
2536                 // It cannot be predicted by the engine!
2537                 if((self.weapon == WEP_SHOCKWAVE || self.weapon == WEP_SHOTGUN) && self.weaponentity.wframe == WFRAME_FIRE2 && time < self.weapon_nextthink)
2538                         do_crouch = 0;
2539
2540                 if (do_crouch)
2541                 {
2542                         if (!self.crouch)
2543                         {
2544                                 self.crouch = true;
2545                                 self.view_ofs = PL_CROUCH_VIEW_OFS;
2546                                 setsize (self, PL_CROUCH_MIN, PL_CROUCH_MAX);
2547                                 // setanim(self, self.anim_duck, false, true, true); // this anim is BROKEN anyway
2548                         }
2549                 }
2550                 else
2551                 {
2552                         if (self.crouch)
2553                         {
2554                                 tracebox(self.origin, PL_MIN, PL_MAX, self.origin, false, self);
2555                                 if (!trace_startsolid)
2556                                 {
2557                                         self.crouch = false;
2558                                         self.view_ofs = PL_VIEW_OFS;
2559                                         setsize (self, PL_MIN, PL_MAX);
2560                                 }
2561                         }
2562                 }
2563
2564                 FixPlayermodel();
2565
2566                 GrapplingHookFrame();
2567
2568                 // LordHavoc: allow firing on move frames (sub-ticrate), this gives better timing on slow servers
2569                 //if(frametime)
2570                 {
2571                         self.items &= ~self.items_added;
2572
2573                         W_WeaponFrame();
2574
2575                         self.items_added = 0;
2576                         if(self.items & IT_JETPACK)
2577                                 if(self.items & IT_FUEL_REGEN || self.ammo_fuel >= 0.01)
2578                                         self.items_added |= IT_FUEL;
2579
2580                         self.items |= self.items_added;
2581                 }
2582
2583                 player_regen();
2584
2585                 // WEAPONTODO: Add a weapon request for this
2586                 // rot vortex charge to the charge limit
2587                 if(WEP_CVAR(vortex, charge_rot_rate) && self.vortex_charge > WEP_CVAR(vortex, charge_limit) && self.vortex_charge_rottime < time)
2588                         self.vortex_charge = bound(WEP_CVAR(vortex, charge_limit), self.vortex_charge - WEP_CVAR(vortex, charge_rot_rate) * frametime / W_TICSPERFRAME, 1);
2589
2590                 if(frametime)
2591                         player_anim();
2592
2593                 // secret status
2594                 secrets_setstatus();
2595
2596                 // monsters status
2597                 monsters_setstatus();
2598
2599                 self.dmg_team = max(0, self.dmg_team - autocvar_g_teamdamage_resetspeed * frametime);
2600
2601                 //self.angles_y=self.v_angle_y + 90;   // temp
2602         } else if(gameover) {
2603                 if (intermission_running)
2604                         IntermissionThink ();   // otherwise a button could be missed between
2605                 return;
2606         } else if(IS_OBSERVER(self)) {
2607                 ObserverThink();
2608         } else if(IS_SPEC(self)) {
2609                 SpectatorThink();
2610         }
2611
2612         // WEAPONTODO: Add weapon request for this
2613         if(!zoomstate_set)
2614                 SetZoomState(self.BUTTON_ZOOM || self.BUTTON_ZOOMSCRIPT || (self.BUTTON_ATCK2 && self.weapon == WEP_VORTEX) || (self.BUTTON_ATCK2 && self.weapon == WEP_RIFLE && WEP_CVAR(rifle, secondary) == 0)); // WEAPONTODO
2615
2616         float oldspectatee_status;
2617         oldspectatee_status = self.spectatee_status;
2618         if(IS_SPEC(self))
2619                 self.spectatee_status = num_for_edict(self.enemy);
2620         else if(IS_OBSERVER(self))
2621                 self.spectatee_status = num_for_edict(self);
2622         else
2623                 self.spectatee_status = 0;
2624         if(self.spectatee_status != oldspectatee_status)
2625         {
2626                 ClientData_Touch(self);
2627         }
2628
2629         if(self.teamkill_soundtime)
2630         if(time > self.teamkill_soundtime)
2631         {
2632                 self.teamkill_soundtime = 0;
2633
2634                 entity oldpusher, oldself;
2635
2636                 oldself = self; self = self.teamkill_soundsource;
2637                 oldpusher = self.pusher; self.pusher = oldself;
2638
2639                 PlayerSound(playersound_teamshoot, CH_VOICE, VOICETYPE_LASTATTACKER_ONLY);
2640
2641                 self.pusher = oldpusher;
2642                 self = oldself;
2643         }
2644
2645         if(self.taunt_soundtime)
2646         if(time > self.taunt_soundtime)
2647         {
2648                 self.taunt_soundtime = 0;
2649                 PlayerSound(playersound_taunt, CH_VOICE, VOICETYPE_AUTOTAUNT);
2650         }
2651
2652         target_voicescript_next(self);
2653
2654         // WEAPONTODO: Move into weaponsystem somehow
2655         // if a player goes unarmed after holding a loaded weapon, empty his clip size and remove the crosshair ammo ring
2656         if(!self.weapon)
2657                 self.clip_load = self.clip_size = 0;
2658 }
2659
2660 /*
2661 =============
2662 PlayerPostThink
2663
2664 Called every frame for each client after the physics are run
2665 =============
2666 */
2667 .float idlekick_lasttimeleft;
2668 void PlayerPostThink (void)
2669 {
2670         if(sv_maxidle > 0 && frametime) // WORKAROUND: only use dropclient in server frames (frametime set). Never use it in cl_movement frames (frametime zero).
2671         if(IS_PLAYER(self) || sv_maxidle_spectatorsareidle)
2672         {
2673                 if (time - self.parm_idlesince < 1) // instead of (time == self.parm_idlesince) to support sv_maxidle <= 10
2674                 {
2675                         if(self.idlekick_lasttimeleft)
2676                         {
2677                                 self.idlekick_lasttimeleft = 0;
2678                                 Kill_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER_CPID, CPID_IDLING);
2679                         }
2680                 }
2681                 else
2682                 {
2683                         float timeleft;
2684                         timeleft = ceil(sv_maxidle - (time - self.parm_idlesince));
2685                         if(timeleft == min(10, sv_maxidle - 1)) // - 1 to support sv_maxidle <= 10
2686                         {
2687                                 if(!self.idlekick_lasttimeleft)
2688                                         Send_Notification(NOTIF_ONE_ONLY, self, MSG_CENTER, CENTER_DISCONNECT_IDLING, timeleft);
2689                         }
2690                         if(timeleft <= 0)
2691                         {
2692                                 Send_Notification(NOTIF_ALL, world, MSG_INFO, INFO_QUIT_KICK_IDLING, self.netname);
2693                                 dropclient(self);
2694                                 return;
2695                         }
2696                         else if(timeleft <= 10)
2697                         {
2698                                 if(timeleft != self.idlekick_lasttimeleft)
2699                                         { Send_Notification(NOTIF_ONE, self, MSG_ANNCE, Announcer_PickNumber(CNT_IDLE, timeleft)); }
2700                                 self.idlekick_lasttimeleft = timeleft;
2701                         }
2702                 }
2703         }
2704
2705 #ifdef TETRIS
2706         if(self.impulse == 100)
2707                 ImpulseCommands();
2708         if (!TetrisPostFrame())
2709         {
2710 #endif
2711
2712         CheatFrame();
2713
2714         //CheckPlayerJump();
2715
2716         if(IS_PLAYER(self)) {
2717                 CheckRules_Player();
2718                 UpdateChatBubble();
2719                 if (self.impulse)
2720                         ImpulseCommands();
2721                 if (intermission_running)
2722                         return;         // intermission or finale
2723                 GetPressedKeys();
2724         }
2725
2726 #ifdef TETRIS
2727         }
2728 #endif
2729
2730         /*
2731         float i;
2732         for(i = 0; i < 1000; ++i)
2733         {
2734                 vector end;
2735                 end = self.origin + '0 0 1024' + 512 * randomvec();
2736                 tracebox(self.origin, self.mins, self.maxs, end, MOVE_NORMAL, self);
2737                 if(trace_fraction < 1)
2738                 if(!(trace_dphitq3surfaceflags & Q3SURFACEFLAG_NOIMPACT))
2739                 {
2740                         print("I HIT SOLID: ", vtos(self.origin), " -> ", vtos(end), "\n");
2741                         break;
2742                 }
2743         }
2744         */
2745
2746         if(self.waypointsprite_attachedforcarrier)
2747                 WaypointSprite_UpdateHealth(self.waypointsprite_attachedforcarrier, '1 0 0' * healtharmor_maxdamage(self.health, self.armorvalue, autocvar_g_balance_armor_blockpercent, DEATH_WEAPON));
2748
2749         playerdemo_write();
2750
2751         CSQCMODEL_AUTOUPDATE();
2752 }