change all function declarations (except builtins and data types) to ANSI C-like...
[divverent/nexuiz.git] / data / qcsrc / server / cl_client.qc
1 .float wantswelcomemessage;
2 .string netname_previous;
3
4 void spawnfunc_info_player_survivor (void)
5 {
6         spawnfunc_info_player_deathmatch();
7 }
8
9 void spawnfunc_info_player_start (void)
10 {
11         spawnfunc_info_player_deathmatch();
12 }
13
14 void spawnfunc_info_player_deathmatch (void)
15 {
16         self.classname = "info_player_deathmatch";
17         relocate_spawnpoint();
18 }
19
20 void spawnpoint_use()
21 {
22         if(teams_matter)
23         if(have_team_spawns)
24         {
25                 self.team = activator.team;
26                 some_spawn_has_been_used = 1;
27         }
28 };
29
30 // Returns:
31 //   -1 if a spawn can't be used
32 //   otherwise, a weight of the spawnpoint
33 float Spawn_Score(entity spot, entity playerlist, float teamcheck)
34 {
35         float shortest, thisdist;
36         entity player;
37
38         // filter out spots for the wrong team
39         if(teamcheck)
40         if(spot.team != teamcheck)
41                 return -1;
42
43         // filter out spots for assault
44         if(spot.target != "") {
45                 local entity ent;
46                 ent = find(world, targetname, spot.target);
47                 while(ent) {
48                         if(ent.classname == "target_objective")
49                                 if(ent.health < 0 || ent.health >= ASSAULT_VALUE_INACTIVE)
50                                         return -1;
51                         ent = find(ent, targetname, spot.target);
52                 }
53         }
54
55         player = playerlist;
56         shortest = vlen(world.maxs - world.mins);
57         for(player = playerlist; player; player = player.chain)
58                 if (player != self)
59                 {
60                         thisdist = vlen(player.origin - spot.origin);
61                         if (thisdist < shortest)
62                                 shortest = thisdist;
63                 }
64         return shortest;
65 }
66
67 float spawn_allbad;
68 float spawn_allgood;
69 entity Spawn_FilterOutBadSpots(entity firstspot, entity playerlist, float mindist, float teamcheck)
70 {
71         local entity spot, spotlist, spotlistend;
72         spawn_allgood = TRUE;
73         spawn_allbad = TRUE;
74
75         spotlist = world;
76         spotlistend = world;
77
78         for(spot = firstspot; spot; spot = spot.chain)
79         {
80                 spot.frags = Spawn_Score(spot, playerlist, teamcheck);
81
82                 if(cvar("spawn_debugview"))
83                 {
84                         setmodel(spot, "models/runematch/rune.mdl");
85                         if(spot.frags < mindist)
86                         {
87                                 spot.colormod = '1 0 0';
88                                 spot.scale = 1;
89                         }
90                         else
91                         {
92                                 spot.colormod = '0 1 0';
93                                 spot.scale = spot.frags / mindist;
94                         }
95                 }
96
97                 if(spot.frags >= 0) // spawning allowed here
98                 {
99                         if(spot.frags < mindist)
100                         {
101                                 // too short distance
102                                 spawn_allgood = FALSE;
103                         }
104                         else 
105                         {
106                                 // perfect
107                                 spawn_allbad = FALSE;
108
109                                 if(spotlistend)
110                                         spotlistend.chain = spot;
111                                 spotlistend = spot;
112                                 if(!spotlist)
113                                         spotlist = spot;
114
115                                 /*
116                                 if(teamcheck)
117                                 if(spot.team != teamcheck)
118                                         error("invalid spawn added");
119
120                                 print("added ", etos(spot), "\n");
121                                 */
122                         }
123                 }
124         }
125         if(spotlistend)
126                 spotlistend.chain = world;
127
128         /*
129                 entity e;
130                 if(teamcheck)
131                         for(e = spotlist; e; e = e.chain)
132                         {
133                                 print("seen ", etos(e), "\n");
134                                 if(e.team != teamcheck)
135                                         error("invalid spawn found");
136                         }
137         */
138
139         return spotlist;
140 }
141
142 entity Spawn_WeightedPoint(entity firstspot, float lower, float upper, float exponent)
143 {
144         // weight of a point: bound(lower, mindisttoplayer, upper)^exponent
145         // multiplied by spot.cnt (useful if you distribute many spawnpoints in a small area)
146         local entity spot;
147
148         RandomSelection_Init();
149         for(spot = firstspot; spot; spot = spot.chain)
150                 RandomSelection_Add(spot, 0, pow(bound(lower, spot.frags, upper), exponent) * spot.cnt);
151
152         return RandomSelection_chosen_ent;
153 }
154
155 /*
156 =============
157 SelectSpawnPoint
158
159 Finds a point to respawn
160 =============
161 */
162 entity SelectSpawnPoint (float anypoint)
163 {
164         local float teamcheck;
165         local entity firstspot_new;
166         local entity spot, firstspot, playerlist;
167
168         spot = find (world, classname, "testplayerstart");
169         if (spot)
170                 return spot;
171
172         teamcheck = 0;
173
174         if(!anypoint && have_team_spawns)
175                 teamcheck = self.team;
176
177         // get the list of players
178         playerlist = findchain(classname, "player");
179         // get the entire list of spots
180         firstspot = findchain(classname, "info_player_deathmatch");
181         // filter out the bad ones
182         // (note this returns the original list if none survived)
183         firstspot_new = Spawn_FilterOutBadSpots(firstspot, playerlist, 100, teamcheck);
184         if(!firstspot_new)
185                 firstspot_new = Spawn_FilterOutBadSpots(firstspot, playerlist, -1, teamcheck);
186         firstspot = firstspot_new;
187
188         // there is 50/50 chance of choosing a random spot or the furthest spot
189         // (this means that roughly every other spawn will be furthest, so you
190         // usually won't get fragged at spawn twice in a row)
191         if (arena_roundbased)
192         {
193                 firstspot_new = Spawn_FilterOutBadSpots(firstspot, playerlist, 800, teamcheck);
194                 if(firstspot_new)
195                         firstspot = firstspot_new;
196                 spot = Spawn_WeightedPoint(firstspot, 1, 1, 1);
197         }
198         else if (random() > cvar("g_spawn_furthest"))
199                 spot = Spawn_WeightedPoint(firstspot, 1, 1, 1);
200         else
201                 spot = Spawn_WeightedPoint(firstspot, 1, 5000, 5); // chooses a far far away spawnpoint
202
203         if(cvar("spawn_debugview"))
204         {
205                 print("spot mindistance: ", ftos(spot.frags), "\n");
206
207                 entity e;
208                 if(teamcheck)
209                         for(e = firstspot; e; e = e.chain)
210                                 if(e.team != teamcheck)
211                                         error("invalid spawn found");
212         }
213
214         if (!spot)
215         {
216                 if(cvar("spawn_debug"))
217                         GotoNextMap();
218                 else
219                 {
220                         if(some_spawn_has_been_used)
221                                 return world; // team can't spawn any more, because of actions of other team
222                         else
223                                 error("Cannot find a spawn point - please fix the map!");
224                 }
225         }
226
227         return spot;
228 }
229
230 /*
231 =============
232 CheckPlayerModel
233
234 Checks if the argument string can be a valid playermodel.
235 Returns a valid one in doubt.
236 =============
237 */
238 string FallbackPlayerModel = "models/player/marine.zym";
239 string CheckPlayerModel(string plyermodel) {
240         if(strlen(plyermodel) < 4)
241                 return FallbackPlayerModel;
242         if( substring(plyermodel,0,14) != "models/player/")
243                 return FallbackPlayerModel;
244         else if(cvar("sv_servermodelsonly"))
245         {
246                 if(substring(plyermodel,strlen(plyermodel)-4,4) != ".zym")
247                 if(substring(plyermodel,strlen(plyermodel)-4,4) != ".dpm")
248                 if(substring(plyermodel,strlen(plyermodel)-4,4) != ".md3")
249                 if(substring(plyermodel,strlen(plyermodel)-4,4) != ".psk")
250                         return FallbackPlayerModel;
251                 if(!fexists(plyermodel))
252                         return FallbackPlayerModel;
253         }
254         return plyermodel;
255 }
256
257 /*
258 =============
259 Client_customizeentityforclient
260
261 LOD reduction
262 =============
263 */
264 float Client_customizeentityforclient()
265 {
266 #ifdef ALLOW_VARIABLE_LOD
267         // self: me
268         // other: the player viewing me
269         float distance;
270         float f;
271
272         if(self.flags & FL_NOTARGET) // we don't need LOD for spectators
273                 return TRUE;
274
275         if(other.cvar_cl_playerdetailreduction <= 0)
276         {
277                 if(other.cvar_cl_playerdetailreduction <= -2)
278                         self.modelindex = self.modelindex_lod2;
279                 else if(other.cvar_cl_playerdetailreduction <= -1)
280                         self.modelindex = self.modelindex_lod1;
281                 else
282                         self.modelindex = self.modelindex_lod0;
283         }
284         else
285         {
286                 distance = vlen(self.origin - other.origin);
287                 f = (distance + 100.0) * other.cvar_cl_playerdetailreduction;
288                 if(f > 10000)
289                         self.modelindex = self.modelindex_lod2;
290                 else if(f > 5000)
291                         self.modelindex = self.modelindex_lod1;
292                 else
293                         self.modelindex = self.modelindex_lod0;
294         }
295 #endif
296
297         return TRUE;
298 }
299
300 void UpdatePlayerSounds();
301 void setmodel_lod(entity e, string modelname)
302 {
303 #ifdef ALLOW_VARIABLE_LOD
304         string s;
305
306         // FIXME: this only supports 3-letter extensions
307         s = strcat(substring(modelname, 0, strlen(modelname) - 4), "_1", substring(modelname, 0, strlen(modelname) - 4));
308         if(fexists(s))
309         {
310                 precache_model(s);
311                 setmodel(e, s); // players have high precision
312                 self.modelindex_lod1 = self.modelindex;
313         }
314         else
315                 self.modelindex_lod1 = -1;
316
317         s = strcat(substring(modelname, 0, strlen(modelname) - 4), "_2", substring(modelname, 0, strlen(modelname) - 4));
318         if(fexists(s))
319         {
320                 precache_model(s);
321                 setmodel(e, s); // players have high precision
322                 self.modelindex_lod2 = self.modelindex;
323         }
324         else
325                 self.modelindex_lod2 = -1;
326
327         precache_model(modelname);
328         setmodel(e, modelname); // players have high precision
329         self.modelindex_lod0 = self.modelindex;
330
331         if(self.modelindex_lod1 < 0)
332                 self.modelindex_lod1 = self.modelindex;
333
334         if(self.modelindex_lod2 < 0)
335                 self.modelindex_lod2 = self.modelindex;
336 #else
337         precache_model(modelname);
338         setmodel(e, modelname); // players have high precision
339 #endif
340         player_setupanimsformodel();
341         UpdatePlayerSounds();
342 }
343
344 /*
345 =============
346 PutObserverInServer
347
348 putting a client as observer in the server
349 =============
350 */
351 void PutObserverInServer (void)
352 {
353         entity  spot;
354         spot = SelectSpawnPoint (TRUE);
355         if(!spot)
356                 error("No spawnpoints for observers?!?\n");
357         RemoveGrapplingHook(self); // Wazat's Grappling Hook
358
359         if(clienttype(self) == CLIENTTYPE_REAL)
360         {
361                 msg_entity = self;
362                 WriteByte(MSG_ONE, SVC_SETVIEW);
363                 WriteEntity(MSG_ONE, self);
364         }
365
366         DropAllRunes(self);
367         kh_Key_DropAll(self, TRUE);
368
369         if(self.flagcarried)
370                 DropFlag(self.flagcarried);
371
372         WaypointSprite_PlayerDead();
373
374         DistributeFragsAmongTeam(self, self.team, 1);
375
376         if(self.frags <= 0 && self.frags > -666 && g_lms && self.killcount != -666)
377                 bprint ("^4", self.netname, "^4 has no more lives left\n");
378         else if(self.killcount != -666)
379                 bprint ("^4", self.netname, "^4 is spectating now\n");
380
381         self.spectatortime = time;
382         
383         self.classname = "observer";
384         self.health = -666;
385         self.takedamage = DAMAGE_NO;
386         self.solid = SOLID_NOT;
387         self.movetype = MOVETYPE_NOCLIP;
388         self.flags = FL_CLIENT | FL_NOTARGET;
389         self.armorvalue = 666;
390         self.effects = 0;
391         self.armorvalue = cvar("g_balance_armor_start");
392         self.pauserotarmor_finished = 0;
393         self.pauserothealth_finished = 0;
394         self.pauseregen_finished = 0;
395         self.damageforcescale = 0;
396         self.death_time = 0;
397         self.dead_frame = 0;
398         self.deaths = 0;
399         self.alpha = 0;
400         self.scale = 0;
401         self.fade_time = 0;
402         self.pain_frame = 0;
403         self.pain_finished = 0;
404         self.strength_finished = 0;
405         self.invincible_finished = 0;
406         self.pushltime = 0;
407         self.think = SUB_Null;
408         self.nextthink = 0;
409         self.hook_time = 0;
410         self.runes = 0;
411         self.deadflag = DEAD_NO;
412         self.angles = spot.angles;
413         self.angles_z = 0;
414         self.fixangle = TRUE;
415         self.crouch = FALSE;
416
417         self.view_ofs = PL_VIEW_OFS;
418         setorigin (self, spot.origin);
419         setsize (self, '0 0 0', '0 0 0');
420         self.oldorigin = self.origin;
421         self.items = 0;
422         self.model = "";
423         self.modelindex = 0;
424         self.weapon = 0;
425         self.weaponmodel = "";
426         self.weaponentity = world;
427         self.killcount = -666;
428         self.velocity = '0 0 0';
429         self.avelocity = '0 0 0';
430         self.punchangle = '0 0 0';
431         self.punchvector = '0 0 0';
432         self.oldvelocity = self.velocity;
433         self.customizeentityforclient = Client_customizeentityforclient;
434         self.viewzoom = 1;
435         self.wantswelcomemessage = 1;
436
437         if(g_arena)
438         {
439                 if(self.frags != -2)
440                 {
441                         Spawnqueue_Insert(self);
442                 }
443                 else
444                 {
445                         Spawnqueue_Unmark(self);
446                         Spawnqueue_Remove(self);
447                 }
448         }
449         else if(!g_lms)
450                 self.frags = -666;
451 }
452
453 float RestrictSkin(float s)
454 {
455         if(!teams_matter)
456                 return s;
457         if(s == 6)
458                 return 6;
459         return mod(s, 3);
460 }
461
462 void FixPlayermodel()
463 {
464         local string defaultmodel;
465         local float defaultskin;
466         local vector m1, m2;
467
468         defaultmodel = "";
469
470         if(cvar("sv_defaultcharacter") == 1) {
471                 defaultskin = 0;
472
473                 if(teams_matter)
474                 {
475                         defaultmodel = cvar_string(strcat("sv_defaultplayermodel_", Team_ColorNameLowerCase(self.team)));
476                         defaultskin = cvar(strcat("sv_defaultplayerskin_", Team_ColorNameLowerCase(self.team)));
477                 }
478
479                 if(defaultmodel == "")
480                 {
481                         defaultmodel = cvar_string("sv_defaultplayermodel");
482                         defaultskin = cvar("sv_defaultplayerskin");
483                 }
484         }
485
486         if(defaultmodel != "")
487         {
488                 if (defaultmodel != self.model)
489                 {
490                         m1 = self.mins;
491                         m2 = self.maxs;
492                         setmodel_lod (self, defaultmodel);
493                         setsize (self, m1, m2);
494                 }
495
496                 self.skin = defaultskin;
497         } else {
498                 if (self.playermodel != self.model)
499                 {
500                         self.playermodel = CheckPlayerModel(self.playermodel);
501                         m1 = self.mins;
502                         m2 = self.maxs;
503                         setmodel_lod (self, self.playermodel);
504                         setsize (self, m1, m2);
505                 }
506
507                 self.skin = RestrictSkin(stof(self.playerskin));
508         }
509
510         if(!teams_matter)
511                 if(strlen(cvar_string("sv_defaultplayercolors")))
512                         if(self.clientcolors != cvar("sv_defaultplayercolors"))
513                                 setcolor(self, cvar("sv_defaultplayercolors"));
514 }
515
516 /*
517 =============
518 PutClientInServer
519
520 Called when a client spawns in the server
521 =============
522 */
523 void PutClientInServer (void)
524 {
525         if(clienttype(self) == CLIENTTYPE_BOT)
526         {
527                 self.classname = "player";
528         }
529         else if(clienttype(self) == CLIENTTYPE_REAL)
530         {
531                 msg_entity = self;
532                 WriteByte(MSG_ONE, SVC_SETVIEW);
533                 WriteEntity(MSG_ONE, self);
534         }
535
536         // player is dead and becomes observer
537         if(g_lms && self.frags < 1)
538                 self.classname = "observer";
539
540         if(g_arena)
541         if(!self.spawned)
542                 self.classname = "observer";
543
544         if(self.classname == "player") {
545                 entity  spot;
546
547                 spot = SelectSpawnPoint (FALSE);
548                 if(!spot)
549                 {
550                         centerprint(self, "Sorry, no spawnpoints available!\nHope your team can fix it...");
551                         return; // spawn failed
552                 }
553
554                 RemoveGrapplingHook(self); // Wazat's Grappling Hook
555
556                 self.classname = "player";
557                 self.iscreature = TRUE;
558                 self.movetype = MOVETYPE_WALK;
559                 self.solid = SOLID_SLIDEBOX;
560                 self.flags = FL_CLIENT;
561                 self.takedamage = DAMAGE_AIM;
562                 if(g_minstagib)
563                         self.effects = EF_FULLBRIGHT;
564                 else
565                         self.effects = 0;
566                 self.air_finished = time + 12;
567                 self.dmg = 2;
568
569                 self.ammo_shells = start_ammo_shells;
570                 self.ammo_nails = start_ammo_nails;
571                 self.ammo_rockets = start_ammo_rockets;
572                 self.ammo_cells = start_ammo_cells;
573                 self.health = start_health;
574                 self.armorvalue = start_armorvalue;
575                 self.items = start_items;
576                 self.switchweapon = start_switchweapon;
577                 self.cnt = start_switchweapon;
578                 self.weapon = 0;
579                 self.jump_interval = time;
580
581                 self.spawnshieldtime = time + cvar("g_spawnshieldtime");
582                 self.pauserotarmor_finished = time + cvar("g_balance_pause_armor_rot_spawn");
583                 self.pauserothealth_finished = time + cvar("g_balance_pause_health_rot_spawn");
584                 self.pauseregen_finished = time + cvar("g_balance_pause_health_regen_spawn");
585                 //extend the pause of rotting if client was reset at the beginning of the countdown
586                 if(!cvar("sv_ready_restart_after_countdown") && time < restart_countdown) {
587                         self.spawnshieldtime += RESTART_COUNTDOWN;
588                         self.pauserotarmor_finished += RESTART_COUNTDOWN;
589                         self.pauserothealth_finished += RESTART_COUNTDOWN;
590                         self.pauseregen_finished += RESTART_COUNTDOWN;
591                 }
592                 self.damageforcescale = 2;
593                 self.death_time = 0;
594                 self.dead_frame = 0;
595                 self.alpha = 0;
596                 self.scale = 0;
597                 self.fade_time = 0;
598                 self.pain_frame = 0;
599                 self.pain_finished = 0;
600                 self.strength_finished = 0;
601                 self.invincible_finished = 0;
602                 self.pushltime = 0;
603                 //self.speed_finished = 0;
604                 //self.slowmo_finished = 0;
605                 // players have no think function
606                 self.think = SUB_Null;
607                 self.nextthink = 0;
608                 self.hook_time = 0;
609
610                 self.runes = 0;
611
612                 self.deadflag = DEAD_NO;
613
614                 self.angles = spot.angles;
615
616                 self.angles_z = 0; // never spawn tilted even if the spot says to
617                 self.fixangle = TRUE; // turn this way immediately
618                 self.velocity = '0 0 0';
619                 self.avelocity = '0 0 0';
620                 self.punchangle = '0 0 0';
621                 self.punchvector = '0 0 0';
622                 self.oldvelocity = self.velocity;
623
624                 self.viewzoom = 0.6;
625                 self.has_zoomed = 0;
626
627                 self.customizeentityforclient = Client_customizeentityforclient;
628
629                 self.model = "";
630                 FixPlayermodel();
631
632                 self.crouch = FALSE;
633                 self.view_ofs = PL_VIEW_OFS;
634                 setsize (self, PL_MIN, PL_MAX);
635                 self.spawnorigin = spot.origin;
636                 setorigin (self, spot.origin + '0 0 1' * (1 - self.mins_z - 24));
637                 // don't reset back to last position, even if new position is stuck in solid
638                 self.oldorigin = self.origin;
639
640                 if(g_arena)
641                 {
642                         Spawnqueue_Remove(self);
643                         Spawnqueue_Mark(self);
644                 }
645
646                 self.event_damage = PlayerDamage;
647
648                 self.bot_attack = TRUE;
649
650                 self.statdraintime = time + 5;
651                 self.BUTTON_ATCK = self.BUTTON_JUMP = self.BUTTON_ATCK2 = 0;
652
653                 if(self.killcount == -666) {
654                         self.killcount = 0;
655                         if(!g_arena)
656                         if(!g_lms)
657                                 self.frags = 0;
658                 }
659
660                 self.cnt = WEP_LASER;
661                 self.nixnex_lastchange_id = -1;
662
663                 CL_SpawnWeaponentity();
664                 self.alpha = default_player_alpha;
665                 self.colormod = '1 1 1' * cvar("g_player_brightness");
666                 self.exteriorweaponentity.alpha = default_weapon_alpha;
667
668                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval")*2;
669                 self.lms_traveled_distance = 0;
670                 self.speedrunning = FALSE;
671
672                 if(cvar("spawn_debug"))
673                 {
674                         sprint(self, strcat("spawnpoint origin:  ", vtos(spot.origin), "\n"));
675                         remove(spot);   // usefull for checking if there are spawnpoints, that let drop through the floor
676                 }
677
678                 //stuffcmd(self, "chase_active 0");
679                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
680
681                 if (cvar("g_spawnsound"))
682                         sound (self, CHAN_AUTO, "misc/spawn.wav", 1, ATTN_NORM);
683
684                 if(g_assault) {
685                         if(self.team == assault_attacker_team)
686                                 centerprint(self, "You are attacking!\n");
687                         else
688                                 centerprint(self, "You are defending!\n");
689                 }
690
691         } else if(self.classname == "observer") {
692                 PutObserverInServer ();
693         }
694 }
695
696 /*
697 =============
698 SetNewParms
699 =============
700 */
701 void SetNewParms (void)
702 {
703         // initialize parms for a new player
704         print("SetNewParms\n");
705         parm1 = -(86400 * 366);
706 }
707
708 /*
709 =============
710 SetChangeParms
711 =============
712 */
713 void SetChangeParms (void)
714 {
715         // save parms for level change
716         print("SetChangeParms\n");
717         parm1 = self.parm_idlesince - time;
718 }
719
720 /*
721 =============
722 DecodeLevelParms
723 =============
724 */
725 void DecodeLevelParms (void)
726 {
727         // load parms
728         print("DecodeLevelParms\n");
729         self.parm_idlesince = parm1;
730         if(self.parm_idlesince == -(86400 * 366))
731                 self.parm_idlesince = time;
732 }
733
734 /*
735 =============
736 ClientKill
737
738 Called when a client types 'kill' in the console
739 =============
740 */
741
742 void ClientKill_Now_TeamChange()
743 {
744         if(self.killindicator_teamchange == -1)
745         {
746                 self.team = -1;
747                 JoinBestTeam( self, FALSE, FALSE );
748         }
749         else
750         {
751                 SV_ChangeTeam(self.killindicator_teamchange - 1);
752         }
753 }
754
755 void ClientKill_Now()
756 {
757         if(self.killindicator_teamchange)
758                 ClientKill_Now_TeamChange();
759
760         // in any case:
761         Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
762 }
763 void KillIndicator_Think()
764 {
765         if (!self.owner.modelindex)
766         {
767                 self.owner.killindicator = world;
768                 remove(self);
769                 return;
770         }
771
772         if(self.cnt <= 0)
773         {
774                 self = self.owner;
775                 ClientKill_Now(); // no oldself needed
776                 return;
777         }
778         else
779         {
780                 if(self.cnt <= 10)
781                         setmodel(self, strcat("models/sprites/", ftos(self.cnt), ".spr32"));
782                 if(clienttype(self.owner) == CLIENTTYPE_REAL)
783                 {
784                         if(self.cnt <= 10)
785                                 play2(self.owner, strcat("announcer/robotic/", ftos(self.cnt), ".ogg"));
786                         if(self.owner.killindicator_teamchange)
787                         {
788                                 if(self.owner.killindicator_teamchange == -1)
789                                         centerprint(self.owner, strcat("Changing team in ", ftos(self.cnt), " seconds"));
790                                 else
791                                         centerprint(self.owner, strcat("Changing to ", ColoredTeamName(self.owner.killindicator_teamchange), " in ", ftos(self.cnt), " seconds"));
792                         }
793                         else
794                                 centerprint(self.owner, strcat("^1Suicide in ", ftos(self.cnt), " seconds"));
795                 }
796                 self.nextthink = time + 1;
797                 self.cnt -= 1;
798         }
799 }
800
801 void ClientKill_TeamChange (float targetteam) // 0 = don't change, -1 = auto
802 {
803         float killtime;
804         entity e;
805         killtime = cvar("g_balance_kill_delay");
806
807         self.killindicator_teamchange = targetteam;
808
809         if(!self.killindicator)
810         {
811                 if(killtime <= 0 || !self.modelindex || self.deadflag != DEAD_NO)
812                 {
813                         ClientKill_Now();
814                 }
815                 else
816                 {
817                         self.killindicator = spawn();
818                         self.killindicator.owner = self;
819                         self.killindicator.scale = 0.5;
820                         setattachment(self.killindicator, self, "");
821                         setorigin(self.killindicator, '0 0 52');
822                         self.killindicator.think = KillIndicator_Think;
823                         self.killindicator.nextthink = time + (self.lip) * 0.05;
824                         self.killindicator.cnt = ceil(killtime);
825                         self.killindicator.count = bound(0, ceil(killtime), 10);
826                         sprint(self, strcat("^1You'll be dead in ", ftos(self.killindicator.cnt), " seconds\n"));
827
828                         for(e = world; (e = find(e, classname, "body")) != world; )
829                         {
830                                 if(e.enemy != self)
831                                         continue;
832                                 e.killindicator = spawn();
833                                 e.killindicator.owner = e;
834                                 e.killindicator.scale = 0.5;
835                                 setattachment(e.killindicator, e, "");
836                                 setorigin(e.killindicator, '0 0 52');
837                                 e.killindicator.think = KillIndicator_Think;
838                                 e.killindicator.nextthink = time + (e.lip) * 0.05;
839                                 e.killindicator.cnt = ceil(killtime);
840                         }
841                         self.lip = 0;
842                 }
843         }
844         if(self.killindicator)
845         {
846                 if(targetteam)
847                         self.killindicator.colormod = TeamColor(targetteam);
848                 else
849                         self.killindicator.colormod = '0 0 0';
850         }
851 }
852
853 void ClientKill (void)
854 {
855         ClientKill_TeamChange(0);
856 }
857
858 void DoTeamChange(float destteam)
859 {
860         float t, c0;
861         if(!cvar("teamplay"))
862         {
863                 if(destteam >= 0)
864                         SetPlayerColors(self, destteam);
865                 return;
866         }
867         if(self.classname == "player")
868         if(destteam == -1)
869         {
870                 CheckAllowedTeams(self);
871                 t = FindSmallestTeam(self, TRUE);
872                 switch(self.team)
873                 {
874                         case COLOR_TEAM1: c0 = c1; break;
875                         case COLOR_TEAM2: c0 = c2; break;
876                         case COLOR_TEAM3: c0 = c3; break;
877                         case COLOR_TEAM4: c0 = c4; break;
878                         default:          c0 = 999;
879                 }
880                 switch(t)
881                 {
882                         case 1:
883                                 if(c0 > c1)
884                                         destteam = COLOR_TEAM1;
885                                 break;
886                         case 2:
887                                 if(c0 > c2)
888                                         destteam = COLOR_TEAM2;
889                                 break;
890                         case 3:
891                                 if(c0 > c3)
892                                         destteam = COLOR_TEAM3;
893                                 break;
894                         case 4:
895                                 if(c0 > c4)
896                                         destteam = COLOR_TEAM4;
897                                 break;
898                 }
899                 if(destteam == -1)
900                         return;
901         }
902         if(destteam == self.team && !self.killindicator)
903                 return;
904         ClientKill_TeamChange(destteam);
905 }
906
907 void FixClientCvars(entity e)
908 {
909         // send prediction settings to the client
910         stuffcmd(e, "\nin_bindmap 0 0\n");
911         /*
912          * we no longer need to stuff this. Remove this comment block if you feel 
913          * 2.3 and higher (or was it 2.2.3?) don't need these any more
914         stuffcmd(e, strcat("cl_gravity ", ftos(cvar("sv_gravity")), "\n"));
915         stuffcmd(e, strcat("cl_movement_accelerate ", ftos(cvar("sv_accelerate")), "\n"));
916         stuffcmd(e, strcat("cl_movement_friction ", ftos(cvar("sv_friction")), "\n"));
917         stuffcmd(e, strcat("cl_movement_maxspeed ", ftos(cvar("sv_maxspeed")), "\n"));
918         stuffcmd(e, strcat("cl_movement_airaccelerate ", ftos(cvar("sv_airaccelerate")), "\n"));
919         stuffcmd(e, strcat("cl_movement_maxairspeed ", ftos(cvar("sv_maxairspeed")), "\n"));
920         stuffcmd(e, strcat("cl_movement_stopspeed ", ftos(cvar("sv_stopspeed")), "\n"));
921         stuffcmd(e, strcat("cl_movement_jumpvelocity ", ftos(cvar("sv_jumpvelocity")), "\n"));
922         stuffcmd(e, strcat("cl_movement_stepheight ", ftos(cvar("sv_stepheight")), "\n"));
923         stuffcmd(e, strcat("set cl_movement_friction_on_land ", ftos(cvar("sv_friction_on_land")), "\n"));
924         stuffcmd(e, strcat("set cl_movement_airaccel_qw ", ftos(cvar("sv_airaccel_qw")), "\n"));
925         stuffcmd(e, strcat("set cl_movement_airaccel_sideways_friction ", ftos(cvar("sv_airaccel_sideways_friction")), "\n"));
926         stuffcmd(e, "cl_movement_edgefriction 1\n");
927          */
928 }
929
930 /*
931 =============
932 ClientConnect
933
934 Called when a client connects to the server
935 =============
936 */
937 string ColoredTeamName(float t);
938 void DecodeLevelParms (void);
939 //void dom_player_join_team(entity pl);
940 void ClientConnect (void)
941 {
942         local string s;
943         float wep;
944
945         if(Ban_IsClientBanned(self))
946         {
947                 s = strcat("^1NOTE:^7 banned client ", self.netaddress, " just tried to enter\n");
948                 dropclient(self);
949                 bprint(s);
950                 return;
951         }
952
953         DecodeLevelParms();
954
955         self.classname = "player_joining";
956         self.flags = self.flags | FL_CLIENT;
957         self.version_nagtime = time + 10 + random() * 10;
958
959         if(player_count<0)
960         {
961                 dprint("BUG player count is lower than zero, this cannot happen!\n");
962                 player_count = 0;
963         }
964
965         bot_clientconnect();
966
967         //if(g_domination)
968         //      dom_player_join_team(self);
969
970         //JoinBestTeam(self, FALSE, FALSE);
971
972         if((cvar("sv_spectate") == 1 && !g_lms) || cvar("g_campaign")) {
973                 self.classname = "observer";
974         } else {
975                 self.classname = "player";
976                 campaign_bots_may_start = 1;
977         }
978
979         self.playerid = (playerid_last = playerid_last + 1);
980         if(cvar("sv_eventlog"))
981         {
982                 if(clienttype(self) == CLIENTTYPE_REAL)
983                         s = "player";
984                 else
985                         s = "bot";
986                 GameLogEcho(strcat(":join:", ftos(self.playerid), ":", s, ":", self.netname), TRUE);
987                 s = strcat(":team:", ftos(self.playerid), ":");
988                 s = strcat(s, ftos(self.team));
989                 GameLogEcho(s, FALSE);
990         }
991         self.netname_previous = strzone(self.netname);
992
993         //stuffcmd(self, "set tmpviewsize $viewsize \n");
994
995         bprint ("^4",self.netname);
996         bprint ("^4 connected");
997
998         if(g_domination || g_ctf)
999         {
1000                 bprint(" and joined the ");
1001                 bprint(ColoredTeamName(self.team));
1002         }
1003
1004         bprint("\n");
1005
1006         self.welcomemessage_time = 0;
1007
1008         stuffcmd(self, strcat("exec maps/", mapname, ".cfg\n"));
1009         // TODO: is this being used for anything else than cd tracks?
1010         // Remember: SVC_CDTRACK exists. Maybe it should be used.
1011         //
1012         stuffcmd(self, "cl_particles_reloadeffects\n");
1013
1014         FixClientCvars(self);
1015
1016         // spawnfunc_waypoint sprites
1017         WaypointSprite_InitClient(self);
1018
1019         // Wazat's grappling hook
1020         SetGrappleHookBindings();
1021
1022         // get autoswitch state from player when he toggles it
1023         stuffcmd(self, "alias autoswitch \"set cl_autoswitch $1 ; cmd autoswitch $1\"\n"); // default.cfg-ed in 2.4.1
1024
1025         // get version info from player
1026         stuffcmd(self, "cmd clientversion $gameversion\n");
1027
1028         // send all weapon info strings
1029         stuffcmd(self, "register_bestweapon clear\n"); // clear the Quake stuff
1030         wep = WEP_FIRST;
1031         while (wep <= WEP_LAST)
1032         {
1033                 weapon_action(wep, WR_REGISTER);
1034                 wep = wep + 1;
1035         }
1036
1037         // get other cvars from player
1038         GetCvars(0);
1039
1040         // set cvar for team scoreboard
1041         if (teams_matter)
1042         {
1043                 local float t;
1044                 t = cvar("teamplay");
1045                 // we have to stuff the correct teamplay value because if this is a listen server, this changes the teamplay mode of the server itself, which is bad
1046                 stuffcmd(self, strcat("set teamplay ", ftos(t), "\n"));
1047         }
1048         else
1049                 stuffcmd(self, "set teamplay 0\n");
1050
1051         // notify about available teams
1052         if(teamplay)
1053         {
1054                 CheckAllowedTeams(self);
1055                 t = 0; if(c1 >= 0) t |= 1; if(c2 >= 0) t |= 2; if(c3 >= 0) t |= 4; if(c4 >= 0) t |= 8;
1056                 stuffcmd(self, strcat("set _teams_available ", ftos(t), "\n"));
1057         }
1058         else
1059                 stuffcmd(self, "set _teams_available 0\n");
1060
1061         stuffcmd(self, strcat("set gametype ", ftos(game), "\n"));
1062
1063         if(g_lms)
1064         {
1065                 self.frags = LMS_NewPlayerLives();
1066                 if(!self.frags)
1067                         self.frags = -666;
1068         }
1069         else if(g_arena)
1070         {
1071                 self.classname = "observer";
1072                 Spawnqueue_Insert(self);
1073         }
1074
1075         bot_relinkplayerlist();
1076
1077         self.spectatortime = time;
1078         if(blockSpectators)
1079         {
1080                 sprint(self, strcat("^7You have to become a player within the next ", ftos(cvar("g_maxplayers_spectator_blocktime")), " seconds, otherwise you will be kicked, because spectators aren't allowed at this time!\n"));
1081         }
1082
1083         self.jointime = time;
1084         self.allowedTimeouts = cvar("sv_timeout_number");
1085 }
1086
1087 /*
1088 =============
1089 ClientDisconnect
1090
1091 Called when a client disconnects from the server
1092 =============
1093 */
1094 void(entity e) DropFlag;
1095 .entity chatbubbleentity;
1096 .entity teambubbleentity;
1097 void ClientDisconnect (void)
1098 {
1099         float save;
1100         if(cvar("sv_eventlog"))
1101                 GameLogEcho(strcat(":part:", ftos(self.playerid)), FALSE);
1102         bprint ("^4",self.netname);
1103         bprint ("^4 disconnected\n");
1104
1105         if (self.chatbubbleentity)
1106         {
1107                 remove (self.chatbubbleentity);
1108                 self.chatbubbleentity = world;
1109         }
1110
1111         if (self.teambubbleentity)
1112         {
1113                 remove (self.teambubbleentity);
1114                 self.teambubbleentity = world;
1115         }
1116
1117         if (self.killindicator)
1118         {
1119                 remove (self.killindicator);
1120                 self.killindicator = world;
1121         }
1122
1123         WaypointSprite_PlayerGone();
1124
1125         DropAllRunes(self);
1126         kh_Key_DropAll(self, TRUE);
1127
1128         if(self.flagcarried)
1129                 DropFlag(self.flagcarried);
1130
1131         DistributeFragsAmongTeam(self, self.team, 1);
1132
1133         save = self.flags;
1134         self.flags = self.flags - (self.flags & FL_CLIENT);
1135         bot_relinkplayerlist();
1136         self.flags = save;
1137
1138         // remove laserdot
1139         if(self.weaponentity)
1140                 if(self.weaponentity.lasertarget)
1141                         remove(self.weaponentity.lasertarget);
1142
1143         if(g_arena)
1144         {
1145                 Spawnqueue_Unmark(self);
1146                 Spawnqueue_Remove(self);
1147         }
1148
1149         if(self.netname_previous)
1150                 strunzone(self.netname_previous);
1151
1152         // free cvars
1153         GetCvars(-1);
1154 }
1155
1156 .float BUTTON_CHAT;
1157 void ChatBubbleThink()
1158 {
1159         self.nextthink = time;
1160         if (!self.owner.modelindex || self.owner.chatbubbleentity != self)
1161         {
1162                 self.owner.chatbubbleentity = world;
1163                 remove(self);
1164                 return;
1165         }
1166         setorigin(self, self.owner.origin + '0 0 15' + self.owner.maxs_z * '0 0 1');
1167         if (self.owner.BUTTON_CHAT && !self.owner.deadflag)
1168                 self.model = self.mdl;
1169         else
1170                 self.model = "";
1171 };
1172
1173 void UpdateChatBubble()
1174 {
1175         if (!self.modelindex)
1176                 return;
1177         // spawn a chatbubble entity if needed
1178         if (!self.chatbubbleentity)
1179         {
1180                 self.chatbubbleentity = spawn();
1181                 self.chatbubbleentity.owner = self;
1182                 self.chatbubbleentity.exteriormodeltoclient = self;
1183                 self.chatbubbleentity.think = ChatBubbleThink;
1184                 self.chatbubbleentity.nextthink = time;
1185                 setmodel(self.chatbubbleentity, "models/misc/chatbubble.spr"); // precision set below
1186                 setorigin(self.chatbubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
1187                 self.chatbubbleentity.mdl = self.chatbubbleentity.model;
1188                 self.chatbubbleentity.model = "";
1189                 self.chatbubbleentity.effects = EF_LOWPRECISION;
1190         }
1191 }
1192
1193
1194 void TeamBubbleThink()
1195 {
1196         self.nextthink = time;
1197         if (!self.owner.modelindex || self.owner.teambubbleentity != self)
1198         {
1199                 self.owner.teambubbleentity = world;
1200                 remove(self);
1201                 return;
1202         }
1203 //      setorigin(self, self.owner.origin + '0 0 15' + self.owner.maxs_z * '0 0 1');  // bandwidth hog. setattachment does this now
1204         if (self.owner.BUTTON_CHAT || self.owner.deadflag || self.owner.killindicator)
1205                 self.model = "";
1206         else
1207                 self.model = self.mdl;
1208
1209 };
1210
1211 float() TeamBubble_customizeentityforclient
1212 {
1213         return (self.owner != other && self.owner.team == other.team && other.killcount > -666);
1214 }
1215
1216 void UpdateTeamBubble()
1217 {
1218         if (!self.modelindex || !cvar("teamplay"))
1219                 return;
1220         // spawn a teambubble entity if needed
1221         if (!self.teambubbleentity && cvar("teamplay"))
1222         {
1223                 self.teambubbleentity = spawn();
1224                 self.teambubbleentity.owner = self;
1225                 self.teambubbleentity.exteriormodeltoclient = self;
1226                 self.teambubbleentity.think = TeamBubbleThink;
1227                 self.teambubbleentity.nextthink = time;
1228                 setmodel(self.teambubbleentity, "models/misc/teambubble.spr"); // precision set below
1229 //              setorigin(self.teambubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
1230                 setorigin(self.teambubbleentity, self.teambubbleentity.origin + '0 0 15' + self.maxs_z * '0 0 1');
1231                 setattachment(self.teambubbleentity, self, "");  // sticks to moving player better, also conserves bandwidth
1232                 self.teambubbleentity.mdl = self.teambubbleentity.model;
1233                 self.teambubbleentity.model = self.teambubbleentity.mdl;
1234                 self.teambubbleentity.customizeentityforclient = TeamBubble_customizeentityforclient;
1235                 self.teambubbleentity.effects = EF_LOWPRECISION;
1236         }
1237 }
1238
1239 // LordHavoc: this hack will be removed when proper _pants/_shirt layers are
1240 // added to the model skins
1241 /*void UpdateColorModHack()
1242 {
1243         local float c;
1244         c = self.clientcolors & 15;
1245         // LordHavoc: only bothering to support white, green, red, yellow, blue
1246              if (teamplay == 0) self.colormod = '0 0 0';
1247         else if (c ==  0) self.colormod = '1.00 1.00 1.00';
1248         else if (c ==  3) self.colormod = '0.10 1.73 0.10';
1249         else if (c ==  4) self.colormod = '1.73 0.10 0.10';
1250         else if (c == 12) self.colormod = '1.22 1.22 0.10';
1251         else if (c == 13) self.colormod = '0.10 0.10 1.73';
1252         else self.colormod = '1 1 1';
1253 };*/
1254
1255 void respawn(void)
1256 {
1257         CopyBody(1);
1258         self.effects |= EF_NODRAW; // prevent another CopyBody
1259         PutClientInServer();
1260 }
1261
1262 /**
1263  * When sv_timeout is used this function returs strings like
1264  * "Timeout begins in 2 seconds!\n" or "Timeout ends in 23 seconds!\n".
1265  * Called by centerprint functions
1266  * @param addOneSecond boolean, set to 1 if the welcome-message centerprint asks for the text
1267  */
1268 string getTimeoutText(float addOneSecond) {
1269         if (!cvar("sv_timeout") || !timeoutStatus)
1270                 return "";
1271
1272         local string retStr;
1273         if (timeoutStatus == 1) {
1274                 if (addOneSecond == 1) {
1275                         retStr = strcat("Timeout begins in ", ftos(remainingLeadTime + 1), " seconds!\n");
1276                 }
1277                 else {
1278                         retStr = strcat("Timeout begins in ", ftos(remainingLeadTime), " seconds!\n");
1279                 }
1280                 return retStr;
1281         }
1282         else if (timeoutStatus == 2) {
1283                 if (addOneSecond) {
1284                         retStr = strcat("Timeout ends in ", ftos(remainingTimeoutTime + 1), " seconds!\n");
1285                         //don't show messages like "Timeout ends in 0 seconds"...
1286                         if ((remainingTimeoutTime + 1) > 0)
1287                                 return retStr;
1288                         else
1289                                 return "";
1290                 }
1291                 else {
1292                         retStr = strcat("Timeout ends in ", ftos(remainingTimeoutTime), " seconds!\n");
1293                         //don't show messages like "Timeout ends in 0 seconds"...
1294                         if (remainingTimeoutTime > 0)
1295                                 return retStr;
1296                         else
1297                                 return "";
1298                 }
1299         }
1300         else return "";
1301 }
1302
1303 void player_powerups (void)
1304 {
1305         if (g_minstagib)
1306         {
1307                 if (self.items & IT_STRENGTH)
1308                 {
1309                         if (time > self.strength_finished)
1310                         {
1311                                 if (g_minstagib_invis_alpha > 0)
1312                                 {
1313                                         self.alpha = default_player_alpha;
1314                                         self.exteriorweaponentity.alpha = default_weapon_alpha;
1315                                         self.effects = self.effects | EF_FULLBRIGHT;
1316                                 }
1317                                 else
1318                                 {
1319                                         self.effects -= self.effects & EF_NODRAW;
1320                                 }
1321                                 self.items = self.items - (self.items & IT_STRENGTH);
1322                                 sprint(self, "^3Invisibility has worn off\n");
1323                         }
1324                 }
1325                 else
1326                 {
1327                         if (time < self.strength_finished)
1328                         {
1329                                 if (g_minstagib_invis_alpha > 0)
1330                                 {
1331                                         self.alpha = g_minstagib_invis_alpha;
1332                                         self.exteriorweaponentity.alpha = g_minstagib_invis_alpha;
1333                                         self.effects -= self.effects & EF_FULLBRIGHT;
1334                                 }
1335                                 else
1336                                 {
1337                                         self.effects = self.effects | EF_NODRAW;
1338                                 }
1339                                 self.items = self.items | IT_STRENGTH;
1340                                 sprint(self, "^3You are invisible\n");
1341                         }
1342                 }
1343
1344                 if (self.items & IT_INVINCIBLE)
1345                 {
1346                         if (time > self.invincible_finished)
1347                         {
1348                                 self.items = self.items - (self.items & IT_INVINCIBLE);
1349                                 sprint(self, "^3Speed has worn off\n");
1350                         }
1351                 }
1352                 else
1353                 {
1354                         if (time < self.invincible_finished)
1355                         {
1356                                 self.items = self.items | IT_INVINCIBLE;
1357                                 sprint(self, "^3You are on speed\n");
1358                         }
1359                 }
1360                 return;
1361         }
1362
1363         self.effects = self.effects - (self.effects & (EF_RED | EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT));
1364         if (self.items & IT_STRENGTH)
1365         {
1366                 self.effects = self.effects | (EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT);
1367                 if (time > self.strength_finished)
1368                 {
1369                         self.items = self.items - (self.items & IT_STRENGTH);
1370                         sprint(self, "^3Strength has worn off\n");
1371                 }
1372         }
1373         else
1374         {
1375                 if (time < self.strength_finished)
1376                 {
1377                         self.items = self.items | IT_STRENGTH;
1378                         sprint(self, "^3Strength infuses your weapons with devastating power\n");
1379                 }
1380         }
1381         if (self.items & IT_INVINCIBLE)
1382         {
1383                 self.effects = self.effects | (EF_RED | EF_ADDITIVE | EF_FULLBRIGHT);
1384                 if (time > self.invincible_finished)
1385                 {
1386                         self.items = self.items - (self.items & IT_INVINCIBLE);
1387                         sprint(self, "^3Shield has worn off\n");
1388                 }
1389         }
1390         else
1391         {
1392                 if (time < self.invincible_finished)
1393                 {
1394                         self.items = self.items | IT_INVINCIBLE;
1395                         sprint(self, "^3Shield surrounds you\n");
1396                 }
1397         }
1398
1399         if (cvar("g_fullbrightplayers"))
1400                 self.effects = self.effects | EF_FULLBRIGHT;
1401
1402         // midair gamemode: damage only while in the air
1403         // if in midair mode, being on ground grants temporary invulnerability
1404         // (this is so that multishot weapon don't clear the ground flag on the
1405         // first damage in the frame, leaving the player vulnerable to the
1406         // remaining hits in the same frame)
1407         if (self.flags & FL_ONGROUND)
1408         if (g_midair)
1409                 self.spawnshieldtime = max(self.spawnshieldtime, time + cvar("g_midair_shieldtime"));
1410
1411         if (time < self.spawnshieldtime)
1412                 self.effects = self.effects | (EF_ADDITIVE | EF_FULLBRIGHT);
1413 }
1414
1415 float CalcRegen(float current, float stable, float regenfactor)
1416 {
1417         if(current > stable)
1418                 return current;
1419         else if(current > stable - 0.25) // when close enough, "snap"
1420                 return stable;
1421         else
1422                 return min(stable, current + (stable - current) * regenfactor * frametime);
1423 }
1424
1425 void player_regen (void)
1426 {
1427         float maxh, maxa, limith, limita, max_mod, regen_mod, rot_mod, limit_mod;
1428         maxh = cvar("g_balance_health_stable");
1429         maxa = cvar("g_balance_armor_stable");
1430         limith = cvar("g_balance_health_limit");
1431         limita = cvar("g_balance_armor_limit");
1432
1433         if (g_minstagib || (g_lms && !cvar("g_lms_regenerate")))
1434                 return;
1435
1436         max_mod = regen_mod = rot_mod = limit_mod = 1;
1437
1438         if (self.runes & RUNE_REGEN)
1439         {
1440                 if (self.runes & CURSE_VENOM) // do we have both rune/curse?
1441                 {
1442                         regen_mod = cvar("g_balance_rune_regen_combo_regenrate");
1443                         max_mod = cvar("g_balance_rune_regen_combo_hpmod");
1444                         limit_mod = cvar("g_balance_rune_regen_combo_limitmod");
1445                 }
1446                 else
1447                 {
1448                         regen_mod = cvar("g_balance_rune_regen_regenrate");
1449                         max_mod = cvar("g_balance_rune_regen_hpmod");
1450                         limit_mod = cvar("g_balance_rune_regen_limitmod");
1451                 }
1452         }
1453         else if (self.runes & CURSE_VENOM)
1454         {
1455                 max_mod = cvar("g_balance_curse_venom_hpmod");
1456                 if (self.runes & RUNE_REGEN) // do we have both rune/curse?
1457                         rot_mod = cvar("g_balance_rune_regen_combo_rotrate");
1458                 else
1459                         rot_mod = cvar("g_balance_curse_venom_rotrate");
1460                 limit_mod = cvar("g_balance_curse_venom_limitmod");
1461                 //if (!self.runes & RUNE_REGEN)
1462                 //      rot_mod = cvar("g_balance_curse_venom_rotrate");
1463         }
1464         maxh = maxh * max_mod;
1465         //maxa = maxa * max_mod;
1466         limith = limith * limit_mod;
1467         limita = limita * limit_mod;
1468
1469         if (self.armorvalue > maxa)
1470         {
1471                 if (time > self.pauserotarmor_finished)
1472                 {
1473                         self.armorvalue = max(maxa, self.armorvalue + (maxa - self.armorvalue) * cvar("g_balance_armor_rot") * frametime);
1474                         self.armorvalue = max(maxa, self.armorvalue - cvar("g_balance_armor_rotlinear") * frametime);
1475                 }
1476         }
1477         else if (self.armorvalue < maxa)
1478         {
1479                 if (time > self.pauseregen_finished)
1480                 {
1481                         self.armorvalue = CalcRegen(self.armorvalue, maxa, cvar("g_balance_armor_regen"));
1482                         self.armorvalue = min(maxa, self.armorvalue + cvar("g_balance_armor_regenlinear") * frametime);
1483                 }
1484         }
1485         if (self.health > maxh)
1486         {
1487                 if (time > self.pauserothealth_finished)
1488                 {
1489                         self.health = max(maxh, self.health + (maxh - self.health) * rot_mod*cvar("g_balance_health_rot") * frametime);
1490                         self.health = max(maxh, self.health - rot_mod*cvar("g_balance_health_rotlinear") * frametime);
1491                 }
1492         }
1493         else if (self.health < maxh)
1494         {
1495                 if (time > self.pauseregen_finished)
1496                 {
1497                         self.health = CalcRegen(self.health, maxh, regen_mod * cvar("g_balance_health_regen"));
1498                         self.health = min(maxh, self.health + regen_mod*cvar("g_balance_health_regenlinear") * frametime);
1499                 }
1500         }
1501
1502         if (self.health > limith)
1503                 self.health = limith;
1504         if (self.armorvalue > limita)
1505                 self.armorvalue = limita;
1506
1507         // if player rotted to death...  die!
1508         if(self.health < 1)
1509                 self.event_damage(self, self, 1, DEATH_ROT, self.origin, '0 0 0');
1510 }
1511
1512 /*
1513 ======================
1514 spectate mode routines
1515 ======================
1516 */
1517 void SpectateCopy(entity spectatee) {
1518         self.armortype = spectatee.armortype;
1519         self.armorvalue = spectatee.armorvalue;
1520         self.currentammo = spectatee.currentammo;
1521         self.effects = spectatee.effects;
1522         self.health = spectatee.health;
1523         self.impulse = 0;
1524         self.items = spectatee.items;
1525         self.punchangle = spectatee.punchangle;
1526         self.view_ofs = spectatee.view_ofs;
1527         self.v_angle = spectatee.v_angle;
1528         self.viewzoom = spectatee.viewzoom;
1529         self.velocity = spectatee.velocity;
1530         self.dmg_take = spectatee.dmg_take;
1531         self.dmg_save = spectatee.dmg_save;
1532         self.dmg_inflictor = spectatee.dmg_inflictor;
1533         self.angles = spectatee.v_angle;
1534         self.fixangle = TRUE;
1535         setorigin(self, spectatee.origin);
1536         setsize(self, spectatee.mins, spectatee.maxs);
1537 }
1538
1539 float SpectateUpdate() {
1540         if(!self.enemy)
1541                 return 0;
1542
1543         if (self == self.enemy)
1544                 return 0;
1545         
1546         if(self.enemy.flags & FL_NOTARGET)
1547                 return 0;
1548
1549         SpectateCopy(self.enemy);
1550
1551         return 1;
1552 }
1553
1554 float SpectateNext() {
1555         other = find(self.enemy, classname, "player");
1556         if (!other) {
1557                 other = find(other, classname, "player");
1558         }
1559         if (other) {
1560                 self.enemy = other;
1561         }
1562         if(self.enemy.classname == "player") {
1563                 msg_entity = self;
1564                 WriteByte(MSG_ONE, SVC_SETVIEW);
1565                 WriteEntity(MSG_ONE, self.enemy);
1566                 self.wantswelcomemessage = 1;
1567                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
1568                 if(!SpectateUpdate())
1569                         PutObserverInServer();
1570                 return 1;
1571         } else {
1572                 return 0;
1573         }
1574 }
1575
1576 /*
1577 =============
1578 ShowRespawnCountdown()
1579
1580 Update a respawn countdown display.
1581 =============
1582 */
1583 void ShowRespawnCountdown()
1584 {
1585         float number;
1586         if(self.deadflag == DEAD_NO) // just respawned?
1587                 return;
1588         else
1589         {
1590                 number = ceil(self.death_time - time);
1591                 if(number <= 0)
1592                         return;
1593                 if(number <= self.respawn_countdown)
1594                 {
1595                         self.respawn_countdown = number - 1;
1596                         if(ceil(self.death_time - (time + 0.5)) == number) // only say it if it is the same number even in 0.5s; to prevent overlapping sounds
1597                                 play2(self, strcat("announcer/robotic/", ftos(number), ".ogg"));
1598                 }
1599         }
1600 }
1601
1602 void LeaveSpectatorMode()
1603 {
1604         if(isJoinAllowed()) {
1605                 if(!cvar("teamplay") || cvar("g_campaign") || cvar("g_balance_teams")) {
1606                         self.classname = "player";
1607                         if(cvar("g_campaign") || cvar("g_balance_teams") || cvar("g_balance_teams_force"))
1608                                 JoinBestTeam(self, FALSE, TRUE);
1609                         if(cvar("g_campaign"))
1610                                 campaign_bots_may_start = 1;
1611                         PutClientInServer();
1612                         if(!(self.flags & FL_NOTARGET))
1613                                 bprint ("^4", self.netname, "^4 is playing now\n");
1614                         centerprint(self,"");
1615                         return;
1616                 } else {
1617                         stuffcmd(self,"menu_showteamselect\n");
1618                         return;
1619                 }
1620         }
1621         else {
1622                 //player may not join because of g_maxplayers is set
1623                 centerprint_atprio(self, CENTERPRIO_MAPVOTE, PREVENT_JOIN_TEXT);
1624         }
1625 }
1626
1627 /**
1628  * Determines whether the player is allowed to join. This depends on cvar
1629  * g_maxplayers, if it isn't used this function always return TRUE, otherwise
1630  * it checks whether the number of currently playing players exceeds g_maxplayers.
1631  * @return bool TRUE if the player is allowed to join, false otherwise
1632  */
1633 float isJoinAllowed() {
1634         if (!cvar("g_maxplayers"))
1635                 return TRUE;
1636
1637         local entity e;
1638         local float currentlyPlaying;
1639         FOR_EACH_REALPLAYER(e) {
1640                 if(e.classname == "player")
1641                         currentlyPlaying += 1;
1642         }
1643         if(currentlyPlaying < cvar("g_maxplayers"))
1644                 return TRUE;
1645
1646         return FALSE;
1647 }
1648
1649 /**
1650  * Checks whether the client is an observer or spectator, if so, he will get kicked after
1651  * g_maxplayers_spectator_blocktime seconds
1652  */
1653 void checkSpectatorBlock() {
1654         if(self.classname == "spectator" || self.classname == "observer") {
1655                 if( time > (self.spectatortime + cvar("g_maxplayers_spectator_blocktime")) ) {
1656                         sprint(self, "^7You were kicked from the server because you are spectator and spectators aren't allowed at the moment.\n");
1657                         dropclient(self);
1658                 }
1659         }
1660 }
1661
1662 float vercmp_recursive(string v1, string v2)
1663 {
1664         float dot1, dot2;
1665         string s1, s2;
1666         float r;
1667
1668         dot1 = strstrofs(v1, ".", 0);
1669         dot2 = strstrofs(v2, ".", 0);
1670         if(dot1 == -1)
1671                 s1 = v1;
1672         else
1673                 s1 = substring(v1, 0, dot1);
1674         if(dot2 == -1)
1675                 s2 = v2;
1676         else
1677                 s2 = substring(v2, 0, dot2);
1678
1679         r = stof(s1) - stof(s2);
1680         if(r != 0)
1681                 return r;
1682
1683         r = strcasecmp(s1, s2);
1684         if(r != 0)
1685                 return r;
1686
1687         if(dot1 == -1)
1688                 if(dot2 == -1)
1689                         return 0;
1690                 else
1691                         return -1;
1692         else
1693                 if(dot2 == -1)
1694                         return 1;
1695                 else
1696                         return vercmp_recursive(substring(v1, dot1 + 1, 999), substring(v2, dot2 + 1, 999));
1697 }
1698
1699 float vercmp(string v1, string v2)
1700 {
1701         if(strcasecmp(v1, v2) == 0) // early out check
1702                 return 0;
1703         return vercmp_recursive(v1, v2);
1704 }
1705
1706 void ObserverThink()
1707 {
1708         if (self.flags & FL_JUMPRELEASED) {
1709                 if (self.BUTTON_JUMP && self.version == cvar("gameversion")) {
1710                         self.welcomemessage_time = 0;
1711                         self.flags = self.flags - FL_JUMPRELEASED;
1712                         LeaveSpectatorMode();
1713                         return;
1714                 } else if(self.BUTTON_ATCK && self.version == cvar("gameversion")) {
1715                         self.welcomemessage_time = 0;
1716                         self.flags = self.flags - FL_JUMPRELEASED;
1717                         if(SpectateNext() == 1) {
1718                                 self.classname = "spectator";
1719                         }
1720                 }
1721         } else {
1722                 if (!(self.BUTTON_ATCK || self.BUTTON_JUMP)) {
1723                         self.flags = self.flags | FL_JUMPRELEASED;
1724                 }
1725         }
1726         if(self.BUTTON_ZOOM)
1727                 self.wantswelcomemessage = 0;
1728         if(self.wantswelcomemessage)
1729                 PrintWelcomeMessage(self);
1730 }
1731
1732 void SpectatorThink()
1733 {
1734         if (self.flags & FL_JUMPRELEASED) {
1735                 if (self.BUTTON_JUMP && self.version == cvar("gameversion")) {
1736                         self.welcomemessage_time = 0;
1737                         self.flags = self.flags - FL_JUMPRELEASED;
1738                         LeaveSpectatorMode();
1739                         return;
1740                 } else if(self.BUTTON_ATCK) {
1741                         self.welcomemessage_time = 0;
1742                         self.flags = self.flags - FL_JUMPRELEASED;
1743                         if(SpectateNext() == 1) {
1744                                 self.classname = "spectator";
1745                         } else {
1746                                 self.classname = "observer";
1747                                 PutClientInServer();
1748                         }
1749                 } else if (self.BUTTON_ATCK2) {
1750                         self.welcomemessage_time = 0;
1751                         self.flags = self.flags - FL_JUMPRELEASED;
1752                         self.classname = "observer";
1753                         PutClientInServer();
1754                 } else {
1755                         if(!SpectateUpdate())
1756                                 PutObserverInServer();
1757                 }
1758         } else {
1759                 if (!(self.BUTTON_ATCK || self.BUTTON_ATCK2)) {
1760                         self.flags = self.flags | FL_JUMPRELEASED;
1761                 }
1762         }
1763         if(self.BUTTON_ZOOM)
1764                 self.wantswelcomemessage = 0;
1765         if(self.wantswelcomemessage)
1766                 PrintWelcomeMessage(self);
1767         self.flags = self.flags | FL_CLIENT | FL_NOTARGET;
1768 }
1769
1770 /*
1771 =============
1772 PlayerPreThink
1773
1774 Called every frame for each client before the physics are run
1775 =============
1776 */
1777 void() ctf_setstatus;
1778 .float vote_nagtime;
1779 void PlayerPreThink (void)
1780 {
1781         if(blockSpectators)
1782                 checkSpectatorBlock();
1783         
1784         if(self.netname_previous != self.netname)
1785         {
1786                 if(cvar("sv_eventlog"))
1787                         GameLogEcho(strcat(":name:", ftos(self.playerid), ":", self.netname), TRUE);
1788                 if(self.netname_previous)
1789                         strunzone(self.netname_previous);
1790                 self.netname_previous = strzone(self.netname);
1791         }
1792
1793         // version nagging
1794         if(self.version_nagtime)
1795                 if(self.cvar_g_nexuizversion)
1796                         if(time > self.version_nagtime)
1797                         {
1798                                 if(strstr(self.cvar_g_nexuizversion, "svn", 0) < 0)
1799                                 {
1800                                         if(strstr(cvar_string("g_nexuizversion"), "svn", 0) >= 0)
1801                                         {
1802                                                 dprint("^1NOTE^7 to ", self.netname, "^7 - the server is running ^3Nexuiz ", cvar_string("g_nexuizversion"), " (beta)^7, you have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1\n");
1803                                                 sprint(self, strcat("\{1}^1NOTE: ^7the server is running ^3Nexuiz ", cvar_string("g_nexuizversion"), " (beta)^7, you have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1\n"));
1804                                         }
1805                                         else
1806                                         {
1807                                                 float r;
1808                                                 r = vercmp(self.cvar_g_nexuizversion, cvar_string("g_nexuizversion"));
1809                                                 if(r < 0)
1810                                                 {
1811                                                         dprint("^1NOTE^7 to ", self.netname, "^7 - ^3Nexuiz ", cvar_string("g_nexuizversion"), "^7 is out, and you still have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1 - get the update from ^4http://www.nexuiz.com/^1!\n");
1812                                                         sprint(self, strcat("\{1}^1NOTE: ^3Nexuiz ", cvar_string("g_nexuizversion"), "^7 is out, and you still have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1 - get the update from ^4http://www.nexuiz.com/^1!\n"));
1813                                                 }
1814                                                 else if(r > 0)
1815                                                 {
1816                                                         dprint("^1NOTE^7 to ", self.netname, "^7 - the server is running ^3Nexuiz ", cvar_string("g_nexuizversion"), "^7, you have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1\n");
1817                                                         sprint(self, strcat("\{1}^1NOTE: ^7the server is running ^3Nexuiz ", cvar_string("g_nexuizversion"), "^7, you have ^3Nexuiz ", self.cvar_g_nexuizversion, "^1\n"));
1818                                                 }
1819                                         }
1820                                 }
1821                                 self.version_nagtime = 0;
1822                         }
1823
1824         // vote nagging
1825         if(self.cvar_scr_centertime)
1826                 if(time > self.vote_nagtime)
1827                 {
1828                         VoteNag();
1829                         self.vote_nagtime = time + self.cvar_scr_centertime * 0.6;
1830                 }
1831
1832         // GOD MODE info
1833         if(!(self.flags & FL_GODMODE)) if(self.max_armorvalue)
1834         {
1835                 sprint(self, strcat("godmode saved you ", ftos(self.max_armorvalue), " units of damage, cheater!\n"));
1836                 self.max_armorvalue = 0;
1837         }
1838
1839         if(frametime)
1840                 antilag_record(self);
1841
1842         if(self.classname == "player") {
1843 //              if(self.netname == "Wazat")
1844 //                      bprint(self.classname, "\n");
1845
1846                 CheckRules_Player();
1847
1848                 if(self.BUTTON_INFO)
1849                         PrintWelcomeMessage(self);
1850
1851                 if(g_lms || !cvar("sv_spectate"))
1852                 if((time - self.jointime) <= cvar("welcome_message_time"))
1853                         PrintWelcomeMessage(self);
1854
1855                 if (intermission_running)
1856                 {
1857                         IntermissionThink ();   // otherwise a button could be missed between
1858                         return;                                 // the think tics
1859                 }
1860
1861                 if(self.teleport_time)
1862                 if(time > self.teleport_time)
1863                 {
1864                         self.teleport_time = 0;
1865                         self.effects = self.effects - (self.effects & EF_NODRAW);
1866                         if(self.weaponentity)
1867                                 self.weaponentity.flags = self.weaponentity.flags - (self.weaponentity.flags & EF_NODRAW);
1868                 }
1869
1870                 Nixnex_GiveCurrentWeapon();
1871
1872                 if(frametime > 0) // don't do this in cl_movement frames, just in server ticks
1873                         UpdateSelectedPlayer();
1874
1875                 //don't allow the player to turn around while game is paused!
1876                 if(timeoutStatus == 2) {
1877                         self.v_angle = self.lastV_angle;
1878                         self.angles = self.lastV_angle;
1879                         self.fixangle = TRUE;
1880                 }
1881
1882                 if (self.deadflag != DEAD_NO)
1883                 {
1884                         float button_pressed, force_respawn;
1885                         player_anim();
1886                         button_pressed = (self.BUTTON_ATCK || self.BUTTON_JUMP || self.BUTTON_ATCK2 || self.BUTTON_HOOK || self.BUTTON_USE);
1887                         force_respawn = (g_lms || cvar("g_forced_respawn"));
1888                         if (self.deadflag == DEAD_DYING)
1889                         {
1890                                 if(force_respawn)
1891                                         self.deadflag = DEAD_RESPAWNING;
1892                                 else if(!button_pressed)
1893                                         self.deadflag = DEAD_DEAD;
1894                         }
1895                         else if (self.deadflag == DEAD_DEAD)
1896                         {
1897                                 if(button_pressed)
1898                                         self.deadflag = DEAD_RESPAWNABLE;
1899                         }
1900                         else if (self.deadflag == DEAD_RESPAWNABLE)
1901                         {
1902                                 if(!button_pressed)
1903                                         self.deadflag = DEAD_RESPAWNING;
1904                         }
1905                         else if (self.deadflag == DEAD_RESPAWNING)
1906                         {
1907                                 if(time > self.death_time)
1908                                 {
1909                                         self.death_time = time + 1; // only retry once a second
1910                                         respawn();
1911                                 }
1912                         }
1913                         ShowRespawnCountdown();
1914                         return;
1915                 }
1916
1917                 if(g_lms && !self.deadflag && cvar("g_lms_campcheck_interval"))
1918                 {
1919                         vector dist;
1920
1921                         // calculate player movement (in 2 dimensions only, so jumping on one spot doesn't count as movement)
1922                         dist = self.oldorigin - self.origin;
1923                         dist_z = 0;
1924                         self.lms_traveled_distance += fabs(vlen(dist));
1925
1926                         if((cvar("g_campaign") && !campaign_bots_may_start) || (time < restart_countdown))
1927                         {
1928                                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval")*2;
1929                                 self.lms_traveled_distance = 0;
1930                         }
1931
1932                         if(time > self.lms_nextcheck)
1933                         {
1934                                 //sprint(self, "distance: ", ftos(self.lms_traveled_distance), "\n");
1935                                 if(self.lms_traveled_distance < cvar("g_lms_campcheck_distance"))
1936                                 {
1937                                         centerprint(self, cvar_string("g_lms_campcheck_message"));
1938                                         // FIXME KadaverJack: gibbing player here causes playermodel to bounce around, instead of eye.md3
1939                                         // I wasn't able to find out WHY that happens, so I put a workaround in place that shall prevent players from being gibbed :(
1940                                         Damage(self, self, self, bound(0, cvar("g_lms_campcheck_damage"), self.health + self.armorvalue * cvar("g_balance_armor_blockpercent") + 5), DEATH_CAMP, self.origin, '0 0 0');
1941                                 }
1942                                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval");
1943                                 self.lms_traveled_distance = 0;
1944                         }
1945                 }
1946
1947                 if (self.BUTTON_CROUCH && !self.hook.state)
1948                 {
1949                         if (!self.crouch)
1950                         {
1951                                 self.crouch = TRUE;
1952                                 self.view_ofs = PL_CROUCH_VIEW_OFS;
1953                                 setsize (self, PL_CROUCH_MIN, PL_CROUCH_MAX);
1954                                 player_setanim(self.anim_duck, FALSE, TRUE, TRUE);
1955                         }
1956                 }
1957                 else
1958                 {
1959                         if (self.crouch)
1960                         {
1961                                 tracebox(self.origin, PL_MIN, PL_MAX, self.origin, FALSE, self);
1962                                 if (!trace_startsolid)
1963                                 {
1964                                         self.crouch = FALSE;
1965                                         self.view_ofs = PL_VIEW_OFS;
1966                                         setsize (self, PL_MIN, PL_MAX);
1967                                 }
1968                         }
1969                 }
1970
1971                 FixPlayermodel();
1972
1973                 GrapplingHookFrame();
1974
1975                 W_WeaponFrame();
1976
1977                 {
1978                         float zoomfactor, zoomspeed, zoomdir;
1979                         zoomfactor = self.cvar_cl_zoomfactor;
1980                         if(zoomfactor < 1 || zoomfactor > 16)
1981                                 zoomfactor = 2.5;
1982                         zoomspeed = self.cvar_cl_zoomspeed;
1983                         if(zoomspeed >= 0) // < 0 is instant zoom
1984                                 if(zoomspeed < 0.5 || zoomspeed > 16)
1985                                         zoomspeed = 3.5;
1986
1987                         zoomdir = self.BUTTON_ZOOM;
1988                         if(self.BUTTON_ATCK2)
1989                                 if(self.weapon == WEP_NEX)
1990                                         if(!g_minstagib)
1991                                                 zoomdir = 1;
1992
1993                         if(zoomdir)
1994                                 self.has_zoomed = 1;
1995
1996                         if(self.has_zoomed)
1997                         {
1998                                 if(zoomspeed <= 0) // instant zoom
1999                                 {
2000                                         if(zoomdir)
2001                                                 self.viewzoom = 1 / zoomfactor;
2002                                         else
2003                                                 self.viewzoom = 1;
2004                                 }
2005                                 else
2006                                 {
2007                                         // geometric zoom would be:
2008                                         //   self.viewzoom = bound(1 / zoomfactor, self.viewzoom * pow(zoomfactor, (zoomdir ? -1 : 1) * frametime * zoomspeed), 1);
2009                                         // however, testing showed that arithmetic/harmonic zoom works better
2010                                         if(zoomdir)
2011                                                 // self.viewzoom = 1 / bound(1, 1 / self.viewzoom + (zoomdir ? 1 : -1) * frametime * zoomspeed * (zoomfactor - 1), zoomfactor);
2012                                                 // zoom in = arithmetic: 1x, 2x, 3x, 4x, ..., 8x
2013                                                 self.viewzoom = 1 / bound(1, 1 / self.viewzoom + frametime * zoomspeed * (zoomfactor - 1), zoomfactor);
2014                                         else
2015                                                 // self.viewzoom = bound(1 / zoomfactor, self.viewzoom + (zoomdir ? -1 : 1) * frametime * zoomspeed * (1 - 1 / zoomfactor), 1);
2016                                                 // zoom out = harmonic: 8/1x, 8/2x, 8/3x, 8/4x, ..., 8/8x
2017                                                 self.viewzoom = bound(1 / zoomfactor, self.viewzoom + frametime * zoomspeed * (1 - 1 / zoomfactor), 1);
2018                                 }
2019                         }
2020                         else
2021                                 self.viewzoom = min(1, self.viewzoom + frametime); // spawn zoom-in
2022                 }
2023
2024                 player_powerups();
2025                 player_regen();
2026                 player_anim();
2027
2028                 if (g_minstagib)
2029                         minstagib_ammocheck();
2030
2031                 ctf_setstatus();
2032                 kh_setstatus();
2033
2034                 //self.angles_y=self.v_angle_y + 90;   // temp
2035
2036                 //if (TetrisPreFrame()) return;
2037         } else if(gameover) {
2038                 if (intermission_running)
2039                         IntermissionThink ();   // otherwise a button could be missed between
2040                 return;
2041         } else if(self.classname == "observer") {
2042                 ObserverThink();
2043         } else if(self.classname == "spectator") {
2044                 SpectatorThink();
2045         }
2046 }
2047
2048
2049 /*
2050 =============
2051 PlayerPostThink
2052
2053 Called every frame for each client after the physics are run
2054 =============
2055 */
2056 .float idlekick_lasttimeleft;
2057 void PlayerPostThink (void)
2058 {
2059         // Savage: Check for nameless players
2060         if (strlen(self.netname) < 1) {
2061                 self.netname = "Player";
2062                 stuffcmd(self, "seta _cl_name Player\n");
2063         }
2064
2065         if(sv_maxidle)
2066         {
2067                 float timeleft;
2068                 timeleft = ceil(sv_maxidle - (time - self.parm_idlesince));
2069                 if(timeleft <= 0)
2070                 {
2071                         bprint("^3", self.netname, "^3 was kicked for idling.\n");
2072                         play2(self, "announcer/robotic/terminated.ogg");
2073                         dropclient(self);
2074                         return;
2075                 }
2076                 else if(timeleft <= 10)
2077                 {
2078                         if(timeleft != self.idlekick_lasttimeleft)
2079                         {
2080                                 centerprint_atprio(self, CENTERPRIO_IDLEKICK, strcat("^3Stop idling!\n^3Disconnecting in ", ftos(timeleft), "..."));
2081                                 play2(self, strcat("announcer/robotic/", ftos(timeleft), ".ogg"));
2082                         }
2083                 }
2084                 else
2085                 {
2086                         centerprint_expire(self, CENTERPRIO_IDLEKICK);
2087                 }
2088                 self.idlekick_lasttimeleft = timeleft;
2089         }
2090
2091         if(self.classname == "player") {
2092                 CheckRules_Player();
2093                 UpdateChatBubble();
2094                 UpdateTeamBubble();
2095                 if (self.impulse)
2096                         ImpulseCommands();
2097                 if (intermission_running)
2098                         return;         // intermission or finale
2099
2100                 //PrintWelcomeMessage(self);
2101                 //if (TetrisPostFrame()) return;
2102
2103                 // restart countdown
2104                 if (restart_countdown) {
2105                         if(time < restart_countdown) {
2106                                 if (!cvar("sv_ready_restart_after_countdown"))
2107                                 {
2108                                         self.movetype = MOVETYPE_NONE;          
2109                                         self.velocity = '0 0 0';
2110                                         self.avelocity = '0 0 0';
2111                                         self.movement = '0 0 0';
2112                                 }
2113                         }
2114                         else
2115                         {
2116                                 //allow the player to move again if sv_ready_restart_after_countdown is not used and countdown is over
2117                                 if (!cvar("sv_ready_restart_after_countdown"))
2118                                 {
2119                                         if(self.movetype == MOVETYPE_NONE)
2120                                         {
2121                                                 self.movetype = MOVETYPE_WALK;
2122                                         }
2123                                 }
2124                         }
2125                 }
2126                 
2127         } else if (self.classname == "observer") {
2128                 //do nothing
2129         } else if (self.classname == "spectator") {
2130                 //do nothing
2131         }
2132
2133         Arena_Warmup();
2134 }