]> icculus.org git repositories - divverent/nexuiz.git/blob - data/qcsrc/server/cl_client.qc
teamchange frag transfer to team mates; say_team
[divverent/nexuiz.git] / data / qcsrc / server / cl_client.qc
1 void info_player_start (void)
2 {
3         self.classname = "info_player_deathmatch";
4         relocate_spawnpoint();
5 }
6
7 void info_player_deathmatch (void)
8 {
9         relocate_spawnpoint();
10 }
11
12 float spawn_allbad;
13 float spawn_allgood;
14 entity Spawn_FilterOutBadSpots(entity firstspot, entity playerlist, float mindist, float teamcheck)
15 {
16         local entity spot, player, nextspot, previousspot, newfirstspot;
17         local float pcount;
18         spot = firstspot;
19         newfirstspot = world;
20         previousspot = world;
21         spawn_allgood = TRUE;
22         spawn_allbad = TRUE;
23         while (spot)
24         {
25                 nextspot = spot.chain;
26                 // count team mismatches as bad spots
27                 if (spot.team == teamcheck)
28                 {
29                         pcount = 0;
30                         player = playerlist;
31                         while (player)
32                         {
33                                 if (player != self)
34                                 if (vlen(player.origin - spot.origin) < mindist)
35                                         pcount = pcount + 1;
36                                 player = player.chain;
37                         }
38                         if (!pcount)
39                         {
40                                 spawn_allbad = FALSE;
41                                 if (newfirstspot)
42                                         previousspot.chain = spot;
43                                 else
44                                         newfirstspot = spot;
45                                 previousspot = spot;
46                                 spot.chain = world;
47                         }
48                         else
49                                 spawn_allgood = FALSE;
50                 }
51                 spot = nextspot;
52         }
53         // if we couldn't find ANY good points, return the original list
54         if (!newfirstspot)
55                 newfirstspot = firstspot;
56         return newfirstspot;
57 }
58
59 entity Spawn_RandomPoint(entity firstspot)
60 {
61         local entity spot;
62         local float numspots;
63         // count number of spots
64         numspots = 0;
65         spot = firstspot;
66         while (spot)
67         {
68                 numspots = numspots + 1;
69                 spot = spot.chain;
70         }
71         // pick a random one
72         numspots = numspots * random();
73         spot = firstspot;
74         while (spot.chain && numspots >= 1)
75         {
76                 numspots = numspots - 1;
77                 spot = spot.chain;
78         }
79         return spot;
80 }
81
82 entity Spawn_FurthestPoint(entity firstspot, entity playerlist)
83 {
84         local entity best, spot, player;
85         local float bestrating, rating;
86         best = world;
87         bestrating = -1000000;
88         spot = firstspot;
89         while (spot)
90         {
91                 rating = 1000000000;
92                 player = playerlist;
93                 while (player)
94                 {
95                         if (player != self)
96                                 rating = min(rating, vlen(player.origin - spot.origin));
97                         player = player.chain;
98                 }
99                 rating = rating + random() * 16;
100                 if (bestrating < rating)
101                 {
102                         best = spot;
103                         bestrating = rating;
104                 }
105                 spot = spot.chain;
106         }
107         return best;
108 }
109
110 /*
111 =============
112 SelectSpawnPoint
113
114 Finds a point to respawn
115 =============
116 */
117 entity SelectSpawnPoint (float anypoint)
118 {
119         local float teamcheck;
120         local entity spot, firstspot, playerlist;
121
122         spot = find (world, classname, "testplayerstart");
123         if (spot)
124                 return spot;
125
126         teamcheck = 0;
127
128         if(!anypoint && cvar("g_ctf") )
129                 teamcheck = self.team;
130
131         // get the list of players
132         playerlist = findchain(classname, "player");
133         // get the entire list of spots
134         firstspot = findchain(classname, "info_player_deathmatch");
135         // filter out the bad ones
136         // (note this returns the original list if none survived)
137         firstspot = Spawn_FilterOutBadSpots(firstspot, playerlist, 100, teamcheck);
138
139         // there is 50/50 chance of choosing a random spot or the furthest spot
140         // (this means that roughly every other spawn will be furthest, so you
141         // usually won't get fragged at spawn twice in a row)
142         if (arena_roundbased)
143         {
144                 firstspot = Spawn_FilterOutBadSpots(firstspot, playerlist, 800, teamcheck);
145                 spot = Spawn_RandomPoint(firstspot);
146         }
147         else if (random() > 0.5 || spawn_allbad || spawn_allgood)
148                 spot = Spawn_RandomPoint(firstspot);
149         else
150                 spot = Spawn_FurthestPoint(firstspot, playerlist);
151
152         if (!spot)
153         {
154                 if(cvar("spawn_debug"))
155                         GotoNextMap();
156                 else
157                         error ("PutClientInServer: no start points on level");
158         }
159
160         return spot;
161 }
162
163 /*
164 =============
165 CheckPlayerModel
166
167 Checks if the argument string can be a valid playermodel.
168 Returns a valid one in doubt.
169 =============
170 */
171 string FallbackPlayerModel = "models/player/marine.zym";
172 string CheckPlayerModel(string plyermodel) {
173         if(strlen(plyermodel) < 4)
174                 return FallbackPlayerModel;
175         if( substring(plyermodel,0,14) != "models/player/")
176                 return FallbackPlayerModel;
177         else if(cvar("sv_servermodelsonly"))
178         {
179                 if(substring(plyermodel,strlen(plyermodel)-4,4) != ".zym")
180                         return FallbackPlayerModel;
181                 if(!fexists(plyermodel))
182                         return FallbackPlayerModel;
183         }
184         return plyermodel;
185 }
186
187 /*
188 =============
189 Client_customizeentityforclient
190
191 LOD reduction
192 =============
193 */
194 float Client_customizeentityforclient()
195 {
196 #ifdef ALLOW_VARIABLE_LOD
197         // self: me
198         // other: the player viewing me
199         float distance;
200         float f;
201
202         if(self.flags & FL_NOTARGET) // we don't need LOD for spectators
203                 return TRUE;
204
205         if(other.cvar_cl_playerdetailreduction <= 0)
206         {
207                 if(other.cvar_cl_playerdetailreduction <= -2)
208                         self.modelindex = self.modelindex_lod2;
209                 else if(other.cvar_cl_playerdetailreduction <= -1)
210                         self.modelindex = self.modelindex_lod1;
211                 else
212                         self.modelindex = self.modelindex_lod0;
213         }
214         else
215         {
216                 distance = vlen(self.origin - other.origin);
217                 f = (distance + 100.0) * other.cvar_cl_playerdetailreduction;
218                 if(f > 10000)
219                         self.modelindex = self.modelindex_lod2;
220                 else if(f > 5000)
221                         self.modelindex = self.modelindex_lod1;
222                 else
223                         self.modelindex = self.modelindex_lod0;
224         }
225 #endif
226
227         return TRUE;
228 }
229
230 void setmodel_lod(entity e, string modelname)
231 {
232 #ifdef ALLOW_VARIABLE_LOD
233         string s;
234
235         s = strcat(substring(modelname, 0, strlen(modelname) - 4), "_1.zym");
236         if(fexists(s))
237         {
238                 precache_model(s);
239                 setmodel(e, s);
240                 self.modelindex_lod1 = self.modelindex;
241         }
242         else
243                 self.modelindex_lod1 = -1;
244
245         s = strcat(substring(modelname, 0, strlen(modelname) - 4), "_2.zym");
246         if(fexists(s))
247         {
248                 precache_model(s);
249                 setmodel(e, s);
250                 self.modelindex_lod2 = self.modelindex;
251         }
252         else
253                 self.modelindex_lod2 = -1;
254
255         precache_model(modelname);
256         setmodel(e, modelname);
257         self.modelindex_lod0 = self.modelindex;
258
259         if(self.modelindex_lod1 < 0)
260                 self.modelindex_lod1 = self.modelindex;
261
262         if(self.modelindex_lod2 < 0)
263                 self.modelindex_lod2 = self.modelindex;
264 #else
265         precache_model(modelname);
266         setmodel(e, modelname);
267 #endif
268 }
269
270 /*
271 =============
272 PutObserverInServer
273
274 putting a client as observer in the server
275 =============
276 */
277 void PutObserverInServer (void)
278 {
279         entity  spot;
280         spot = SelectSpawnPoint (FALSE);
281         RemoveGrapplingHook(self); // Wazat's Grappling Hook
282
283         if(clienttype(self) == CLIENTTYPE_REAL)
284         {
285                 msg_entity = self;
286                 WriteByte(MSG_ONE, SVC_SETVIEW);
287                 WriteEntity(MSG_ONE, self);
288         }
289
290         if (cvar("g_runematch"))
291                 DropAllRunes(self);
292
293         DistributeFragsAmongTeam(self, self.team, 1);
294
295         if(self.frags <= 0 && self.frags > -666 && cvar("g_lms") && self.killcount != -666)
296                 bprint (strcat("^4", self.netname, "^4 has no more lives left\n"));
297         else if(self.killcount != -666)
298                 bprint (strcat("^4", self.netname, "^4 is spectating now\n"));
299
300         self.classname = "observer";
301         self.health = -666;
302         self.takedamage = DAMAGE_NO;
303         self.solid = SOLID_NOT;
304         self.movetype = MOVETYPE_NOCLIP;
305         self.flags = FL_CLIENT | FL_NOTARGET;
306         self.armorvalue = 666;
307         self.effects = 0;
308         self.armorvalue = cvar("g_balance_armor_start");
309         self.pauserotarmor_finished = 0;
310         self.pauserothealth_finished = 0;
311         self.pauseregen_finished = 0;
312         self.damageforcescale = 0;
313         self.death_time = 0;
314         self.dead_time = 0;
315         self.dead_frame = 0;
316         self.die_frame = 0;
317         self.deaths = 0;
318         self.alpha = 0;
319         self.scale = 0;
320         self.fade_time = 0;
321         self.pain_frame = 0;
322         self.pain_finished = 0;
323         self.strength_finished = 0;
324         self.invincible_finished = 0;
325         self.pushltime = 0;
326         self.think = SUB_Null;
327         self.nextthink = 0;
328         self.hook_time = 0;
329         self.runes = 0;
330         self.deadflag = DEAD_NO;
331         self.angles = spot.angles;
332         self.angles_z = 0;
333         self.fixangle = TRUE;
334         self.crouch = FALSE;
335
336         self.view_ofs = PL_VIEW_OFS;
337         setorigin (self, spot.origin);
338         setsize (self, '0 0 0', '0 0 0');
339         self.oldorigin = self.origin;
340         self.items = 0;
341         self.model = "";
342         self.modelindex = 0;
343         self.weapon = 0;
344         self.weaponmodel = "";
345         self.weaponentity = world;
346         self.killcount = -666;
347         self.velocity = '0 0 0';
348         self.avelocity = '0 0 0';
349         self.punchangle = '0 0 0';
350         self.punchvector = '0 0 0';
351         self.oldvelocity = self.velocity;
352         self.customizeentityforclient = Client_customizeentityforclient;
353
354         if(cvar("g_arena"))
355         {
356                 if(self.frags != -2)
357                 {
358                         Spawnqueue_Insert(self);
359                 }
360                 else
361                 {
362                         Spawnqueue_Unmark(self);
363                         Spawnqueue_Remove(self);
364                 }
365         }
366         else if(!cvar("g_lms"))
367                 self.frags = -666;
368 }
369
370
371 /*
372 =============
373 PutClientInServer
374
375 Called when a client spawns in the server
376 =============
377 */
378 void PutClientInServer (void)
379 {
380         if(clienttype(self) == CLIENTTYPE_BOT)
381         {
382                 self.classname = "player";
383         }
384         else if(clienttype(self) == CLIENTTYPE_REAL)
385         {
386                 msg_entity = self;
387                 WriteByte(MSG_ONE, SVC_SETVIEW);
388                 WriteEntity(MSG_ONE, self);
389         }
390
391         // player is dead and becomes observer
392         if(cvar("g_lms") && self.frags < 1)
393                 self.classname = "observer";
394
395         if(cvar("g_arena"))
396         if(!self.spawned)
397                 self.classname = "observer";
398
399         if(self.classname == "player") {
400                 entity  spot;
401
402                 spot = SelectSpawnPoint (FALSE);
403
404                 RemoveGrapplingHook(self); // Wazat's Grappling Hook
405
406                 self.classname = "player";
407                 self.iscreature = TRUE;
408                 self.movetype = MOVETYPE_WALK;
409                 self.solid = SOLID_SLIDEBOX;
410                 self.flags = FL_CLIENT;
411                 self.takedamage = DAMAGE_AIM;
412                 self.effects = 0;
413                 self.health = cvar("g_balance_health_start");
414                 self.armorvalue = cvar("g_balance_armor_start");
415                 self.spawnshieldtime = time + cvar("g_spawnshieldtime");
416                 self.pauserotarmor_finished = time + cvar("g_balance_pause_armor_rot_spawn");
417                 self.pauserothealth_finished = time + cvar("g_balance_pause_health_rot_spawn");
418                 self.pauseregen_finished = time + cvar("g_balance_pause_health_regen_spawn");
419                 self.damageforcescale = 2;
420                 self.death_time = 0;
421                 self.dead_time = 0;
422                 self.dead_frame = 0;
423                 self.die_frame = 0;
424                 self.alpha = 0;
425                 self.scale = 0;
426                 self.fade_time = 0;
427                 self.pain_frame = 0;
428                 self.pain_finished = 0;
429                 self.strength_finished = 0;
430                 self.invincible_finished = 0;
431                 self.pushltime = 0;
432                 //self.speed_finished = 0;
433                 //self.slowmo_finished = 0;
434                 // players have no think function
435                 self.think = SUB_Null;
436                 self.nextthink = 0;
437                 self.weapon = 0;
438                 self.switchweapon = 0;
439                 self.hook_time = 0;
440
441                 self.runes = 0;
442
443                 self.deadflag = DEAD_NO;
444
445                 self.angles = spot.angles;
446
447                 self.angles_z = 0; // never spawn tilted even if the spot says to
448                 self.fixangle = TRUE; // turn this way immediately
449                 self.velocity = '0 0 0';
450                 self.avelocity = '0 0 0';
451                 self.punchangle = '0 0 0';
452                 self.punchvector = '0 0 0';
453                 self.oldvelocity = self.velocity;
454
455                 self.viewzoom = 0.6;
456
457                 self.customizeentityforclient = Client_customizeentityforclient;
458
459                 if(cvar("sv_defaultcharacter") == 1 && !teams_matter) {
460                         local string defaultmodel;
461                         defaultmodel = CheckPlayerModel(cvar_string("sv_defaultplayermodel"));
462                         setmodel_lod (self, defaultmodel);
463                         self.skin = stof(cvar_string("sv_defaultplayerskin"));
464                 } else {
465                         self.playermodel = CheckPlayerModel(self.playermodel);
466                         setmodel_lod (self, self.playermodel);
467                         self.skin = stof(self.playerskin);
468
469                 }
470
471                 self.crouch = FALSE;
472                 self.view_ofs = PL_VIEW_OFS;
473                 setsize (self, PL_MIN, PL_MAX);
474                 self.spawnorigin = spot.origin;
475                 setorigin (self, spot.origin + '0 0 1' * (1 - self.mins_z - 24));
476                 // don't reset back to last position, even if new position is stuck in solid
477                 self.oldorigin = self.origin;
478
479                 if(cvar("g_lms"))
480                 {
481                         self.ammo_shells = cvar("g_lms_start_ammo_shells");
482                         self.ammo_nails = cvar("g_lms_start_ammo_nails");
483                         self.ammo_rockets = cvar("g_lms_start_ammo_rockets");
484                         self.ammo_cells = cvar("g_lms_start_ammo_cells");
485                         self.health = cvar("g_lms_start_health");
486                         self.armorvalue = cvar("g_lms_start_armor");
487                 }
488                 else if (cvar("g_use_ammunition")) {
489                         self.ammo_shells = cvar("g_start_ammo_shells");
490                         self.ammo_nails = cvar("g_start_ammo_nails");
491                         self.ammo_rockets = cvar("g_start_ammo_rockets");
492                         self.ammo_cells = cvar("g_start_ammo_cells");
493                 } else {
494                         self.ammo_shells = 999;
495                         self.ammo_nails = 999;
496                         self.ammo_rockets = 999;
497                         self.ammo_cells = 999;
498                 }
499
500                 self.items = 0;
501                 if (cvar("g_start_weapon_laser") || cvar("g_lms"))
502                 {
503                         self.items = self.items | IT_LASER;
504                         self.switchweapon = WEP_LASER;
505                 }
506                 if (cvar("g_start_weapon_shotgun") || cvar("g_lms"))
507                 {
508                         self.items = self.items | IT_SHOTGUN;
509                         self.switchweapon = WEP_SHOTGUN;
510                 }
511                 if (cvar("g_start_weapon_uzi") || cvar("g_lms"))
512                 {
513                         self.items = self.items | IT_UZI;
514                         self.switchweapon = WEP_UZI;
515                 }
516                 if (cvar("g_start_weapon_grenadelauncher") || cvar("g_lms"))
517                 {
518                         self.items = self.items | IT_GRENADE_LAUNCHER;
519                         self.switchweapon = WEP_GRENADE_LAUNCHER;
520                 }
521                 if (cvar("g_start_weapon_electro") || cvar("g_lms"))
522                 {
523                         self.items = self.items | IT_ELECTRO;
524                         self.switchweapon = WEP_ELECTRO;
525                 }
526                 if (cvar("g_start_weapon_crylink") || cvar("g_lms"))
527                 {
528                         self.items = self.items | IT_CRYLINK;
529                         self.switchweapon = WEP_CRYLINK;
530                 }
531                 if (cvar("g_start_weapon_nex") || cvar("g_lms"))
532                 {
533                         self.items = self.items | IT_NEX;
534                         self.switchweapon = WEP_NEX;
535                 }
536                 if (cvar("g_start_weapon_hagar") || cvar("g_lms"))
537                 {
538                         self.items = self.items | IT_HAGAR;
539                         self.switchweapon = WEP_HAGAR;
540                 }
541                 if (cvar("g_start_weapon_rocketlauncher") || cvar("g_lms"))
542                 {
543                         self.items = self.items | IT_ROCKET_LAUNCHER;
544                         self.switchweapon = WEP_ROCKET_LAUNCHER;
545                 }
546
547                 if(cvar("g_instagib"))
548                 {
549                         self.items = IT_NEX;
550                         self.switchweapon = WEP_NEX;
551                         self.ammo_cells = 999;
552                 }
553
554                 if(cvar("g_rocketarena"))
555                 {
556                         self.items = IT_ROCKET_LAUNCHER;
557                         self.switchweapon = WEP_ROCKET_LAUNCHER;
558                         self.ammo_rockets = 999;
559                 }
560
561                 if(cvar("g_nixnex"))
562                 {
563                         self.items = 0;
564                         // will be done later
565                 }
566
567                 if(cvar("g_minstagib"))
568                 {
569                         self.health = 100;
570                         self.armorvalue = 0;
571                         self.items = IT_NEX;
572                         self.switchweapon = WEP_NEX;
573                         self.ammo_cells = cvar("g_minstagib_ammo_start");
574                         self.extralives = 0;
575                         self.jump_interval = time;
576                 }
577
578                 if(cvar("g_arena"))
579                 {
580                         Spawnqueue_Remove(self);
581                         Spawnqueue_Mark(self);
582                 }
583
584                 self.event_damage = PlayerDamage;
585
586                 self.bot_attack = TRUE;
587
588                 self.statdraintime = time + 5;
589                 self.button0 = self.button1 = self.button2 = self.button3 = 0;
590
591                 if(self.killcount == -666) {
592                         self.killcount = 0;
593                         if(!cvar("g_arena"))
594                         if(!cvar("g_lms"))
595                                 self.frags = 0;
596                 }
597
598                 self.cnt = WEP_LASER;
599                 self.nixnex_lastchange_id = -1;
600
601                 CL_SpawnWeaponentity();
602                 self.alpha = default_player_alpha;
603                 self.exteriorweaponentity.alpha = default_player_alpha;
604
605                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval")*2;
606                 self.lms_traveled_distance = 0;
607
608                 if(cvar("spawn_debug"))
609                 {
610                                 sprint(self, strcat("spawnpoint origin:  ", vtos(spot.origin), "\n"));
611                                 remove(spot);   // usefull for checking if there are spawnpoints, that let drop through the floor
612                 }
613
614                 //stuffcmd(self, "chase_active 0");
615                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
616         } else if(self.classname == "observer") {
617                 PutObserverInServer ();
618         }
619 }
620
621 /*
622 =============
623 SetNewParms
624 =============
625 */
626 void SetNewParms (void)
627 {
628
629 }
630
631 /*
632 =============
633 SetChangeParms
634 =============
635 */
636 void SetChangeParms (void)
637 {
638
639 }
640
641 /*
642 =============
643 ClientKill
644
645 Called when a client types 'kill' in the console
646 =============
647 */
648 void ClientKill (void)
649 {
650         Damage(self, self, self, 100000, DEATH_KILL, self.origin, '0 0 0');
651 }
652
653 /*
654 =============
655 ClientConnect
656
657 Called when a client connects to the server
658 =============
659 */
660 string ColoredTeamName(float t);
661 //void dom_player_join_team(entity pl);
662 void ClientConnect (void)
663 {
664         self.classname = "player_joining";
665         self.flags = self.flags | FL_CLIENT;
666
667         if(player_count<0) player_count = 0;
668
669         bot_clientconnect();
670
671         //if(cvar("g_domination"))
672         //      dom_player_join_team(self);
673
674         //JoinBestTeam(self, FALSE);
675
676         if((cvar("sv_spectate") == 1 && !cvar("g_lms")) || cvar("g_campaign")) {
677                 self.classname = "observer";
678         } else {
679                 self.classname = "player";
680                 campaign_bots_may_start = 1;
681         }
682
683         self.playerid = (playerid_last = playerid_last + 1);
684         if(cvar("sv_eventlog"))
685         {
686                 string s;
687                 if(clienttype(self) == CLIENTTYPE_REAL)
688                         s = "player";
689                 else
690                         s = "bot";
691                 GameLogEcho(strcat(":join:", ftos(self.playerid), ":", s, ":", self.netname), TRUE);
692                 s = strcat(":team:", ftos(self.playerid), ":");
693                 s = strcat(s, ftos(self.team));
694                 GameLogEcho(s, FALSE);
695         }
696
697         //stuffcmd(self, "set tmpviewsize $viewsize \n");
698
699         bprint ("^4",self.netname);
700         bprint ("^4 connected");
701
702         if(cvar("g_domination") || cvar("g_ctf"))
703         {
704                 bprint(" and joined the ");
705                 bprint(ColoredTeamName(self.team));
706         }
707
708         bprint("\n");
709
710         self.welcomemessage_time = time + cvar("welcome_message_time");
711         self.welcomemessage_time2 = 0;
712
713         stuffcmd(self, strcat("exec maps/", mapname, ".cfg\n"));
714         // send prediction settings to the client
715         stuffcmd(self, strcat("cl_movement_accelerate ", ftos(cvar("sv_accelerate")), "\n"));
716         stuffcmd(self, strcat("cl_movement_friction ", ftos(cvar("sv_friction")), "\n"));
717         stuffcmd(self, strcat("cl_movement_maxspeed ", ftos(cvar("sv_maxspeed")), "\n"));
718         stuffcmd(self, strcat("cl_movement_airaccelerate ", ftos(cvar("sv_airaccelerate")), "\n"));
719         stuffcmd(self, strcat("cl_movement_maxairspeed ", ftos(cvar("sv_maxairspeed")), "\n"));
720         stuffcmd(self, strcat("cl_movement_stopspeed ", ftos(cvar("sv_stopspeed")), "\n"));
721         stuffcmd(self, strcat("cl_movement_jumpvelocity ", ftos(cvar("g_balance_jumpheight")), "\n"));
722         stuffcmd(self, strcat("cl_movement_stepheight ", ftos(cvar("sv_stepheight")), "\n"));
723         stuffcmd(self, strcat("set cl_movement_friction_on_land ", ftos(cvar("sv_friction_on_land")), "\n"));
724         stuffcmd(self, strcat("set cl_movement_airaccel_qw ", ftos(cvar("sv_airaccel_qw")), "\n"));
725         stuffcmd(self, strcat("set cl_movement_airaccel_sideways_friction ", ftos(cvar("sv_airaccel_sideways_friction")), "\n"));
726         stuffcmd(self, strcat("cl_movement_edgefriction 0\n"));
727         // Wazat's grappling hook
728         SetGrappleHookBindings();
729
730         // get autoswitch state from player
731         stuffcmd(self, "alias autoswitch \"set cl_autoswitch $1; cmd autoswitch $1\"\n");
732         stuffcmd(self, "cmd autoswitch $cl_autoswitch\n");
733
734         // get version info from player
735         stuffcmd(self, "cmd clientversion $gameversion\n");
736
737         // get other cvars from player
738         GetCvars(0);
739
740         // set cvar for team scoreboard
741         if (teams_matter)
742         {
743                 local float t;
744                 t = cvar("teamplay");
745                 // 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
746                 stuffcmd(self, strcat("set teamplay ", ftos(t), "\n"));
747         }
748         else
749                 stuffcmd(self, strcat("set teamplay 0\n"));
750
751         if(cvar("g_lms"))
752         {
753                 self.frags = cvar("fraglimit");
754                 // no fraglimit was set, so player gets 999 lives
755                 if(self.frags < 1)
756                         self.frags = 999;
757
758                 // disallow player to join after the worst player has lost g_lms_last_join lives
759                 // if "g_lms_join_anytime" new players spawn with same amount of lives as the worst active player
760                 if(((cvar("fraglimit") - cvar("g_lms_last_join")) > lms_lowest_lives && !cvar("g_lms_join_anytime")) || lms_lowest_lives < 1)
761                 {
762                         self.frags = -666;
763                         lms_dead_count += 1;
764                 }
765                 else if(cvar("fraglimit") > lms_lowest_lives)
766                 {
767                         self.frags = lms_lowest_lives;
768                 }
769         }
770         else if(cvar("g_arena"))
771         {
772                 self.classname = "observer";
773                 Spawnqueue_Insert(self);
774         }
775
776         bot_relinkplayerlist();
777
778         self.jointime = time;
779 }
780
781 /*
782 =============
783 ClientDisconnect
784
785 Called when a client disconnects from the server
786 =============
787 */
788 void(entity e) DropFlag;
789 .entity chatbubbleentity;
790 .entity teambubbleentity;
791 void ClientDisconnect (void)
792 {
793         float save;
794         if(cvar("sv_eventlog"))
795                 GameLogEcho(strcat(":part:", ftos(self.playerid)), FALSE);
796         bprint ("^4",self.netname);
797         bprint ("^4 disconnected\n");
798
799         if (self.chatbubbleentity)
800         {
801                 remove (self.chatbubbleentity);
802                 self.chatbubbleentity = world;
803         }
804
805         if (self.teambubbleentity)
806         {
807                 remove (self.teambubbleentity);
808                 self.teambubbleentity = world;
809         }
810
811         DropAllRunes(self);
812
813         if(self.flagcarried)
814                 DropFlag(self.flagcarried);
815
816         DistributeFragsAmongTeam(self, self.team, 1);
817
818         save = self.flags;
819         self.flags = self.flags - (self.flags & FL_CLIENT);
820         bot_relinkplayerlist();
821         self.flags = save;
822
823         // remove laserdot
824         if(self.weaponentity)
825                 if(self.weaponentity.lasertarget)
826                         remove(self.weaponentity.lasertarget);
827
828         // player was dead, decrease dead count
829         if(cvar("g_lms") && self.frags < 1)
830                 lms_dead_count -= 1;
831         else if(cvar("g_arena"))
832         {
833                 Spawnqueue_Unmark(self);
834                 Spawnqueue_Remove(self);
835         }
836 }
837
838 .float buttonchat;
839 void() ChatBubbleThink =
840 {
841         self.nextthink = time;
842         if (!self.owner.modelindex || self.owner.chatbubbleentity != self)
843         {
844                 self.owner.chatbubbleentity = world;
845                 remove(self);
846                 return;
847         }
848         setorigin(self, self.owner.origin + '0 0 15' + self.owner.maxs_z * '0 0 1');
849         if (self.owner.buttonchat && !self.owner.deadflag)
850                 self.model = self.mdl;
851         else
852                 self.model = "";
853 };
854
855 void() UpdateChatBubble =
856 {
857         if (!self.modelindex)
858                 return;
859         // spawn a chatbubble entity if needed
860         if (!self.chatbubbleentity)
861         {
862                 self.chatbubbleentity = spawn();
863                 self.chatbubbleentity.owner = self;
864                 self.chatbubbleentity.exteriormodeltoclient = self;
865                 self.chatbubbleentity.think = ChatBubbleThink;
866                 self.chatbubbleentity.nextthink = time;
867                 setmodel(self.chatbubbleentity, "models/misc/chatbubble.spr");
868                 setorigin(self.chatbubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
869                 self.chatbubbleentity.mdl = self.chatbubbleentity.model;
870                 self.chatbubbleentity.model = "";
871         }
872 }
873
874
875 void() TeamBubbleThink =
876 {
877         self.nextthink = time;
878         if (!self.owner.modelindex || self.owner.teambubbleentity != self)
879         {
880                 self.owner.teambubbleentity = world;
881                 remove(self);
882                 return;
883         }
884 //      setorigin(self, self.owner.origin + '0 0 15' + self.owner.maxs_z * '0 0 1');  // bandwidth hog. setattachment does this now
885         if (self.owner.buttonchat || self.owner.deadflag)
886                 self.model = "";
887         else
888                 self.model = self.mdl;
889
890 };
891
892 float() ChatBubble_customizeentityforclient = {return (self.owner.team == other.team && other.killcount > -666);};
893
894 void() UpdateTeamBubble =
895 {
896         if (!self.modelindex || !cvar("teamplay"))
897                 return;
898         // spawn a teambubble entity if needed
899         if (!self.teambubbleentity && cvar("teamplay"))
900         {
901                 self.teambubbleentity = spawn();
902                 self.teambubbleentity.owner = self;
903                 self.teambubbleentity.exteriormodeltoclient = self;
904                 self.teambubbleentity.think = TeamBubbleThink;
905                 self.teambubbleentity.nextthink = time;
906                 setmodel(self.teambubbleentity, "models/misc/teambubble.spr");
907 //              setorigin(self.teambubbleentity, self.origin + '0 0 15' + self.maxs_z * '0 0 1');
908                 setorigin(self.teambubbleentity, self.teambubbleentity.origin + '0 0 15' + self.maxs_z * '0 0 1');
909                 setattachment(self.teambubbleentity, self, "");  // sticks to moving player better, also conserves bandwidth
910                 self.teambubbleentity.mdl = self.teambubbleentity.model;
911                 self.teambubbleentity.model = self.teambubbleentity.mdl;
912                 self.teambubbleentity.customizeentityforclient = ChatBubble_customizeentityforclient;
913         }
914 }
915
916 // LordHavoc: this hack will be removed when proper _pants/_shirt layers are
917 // added to the model skins
918 /*void() UpdateColorModHack =
919 {
920         local float c;
921         c = self.clientcolors & 15;
922         // LordHavoc: only bothering to support white, green, red, yellow, blue
923              if (teamplay == 0) self.colormod = '0 0 0';
924         else if (c ==  0) self.colormod = '1.00 1.00 1.00';
925         else if (c ==  3) self.colormod = '0.10 1.73 0.10';
926         else if (c ==  4) self.colormod = '1.73 0.10 0.10';
927         else if (c == 12) self.colormod = '1.22 1.22 0.10';
928         else if (c == 13) self.colormod = '0.10 0.10 1.73';
929         else self.colormod = '1 1 1';
930 };*/
931
932 /*
933 =============
934 PlayerJump
935
936 When you press the jump key
937 =============
938 */
939 void PlayerJump (void)
940 {
941         float mjumpheight;
942
943         mjumpheight = cvar("g_balance_jumpheight");
944         if (self.waterlevel >= 2)
945         {
946                 if (self.watertype == CONTENT_WATER)
947                         self.velocity_z = 200;
948                 else if (self.watertype == CONTENT_SLIME)
949                         self.velocity_z = 80;
950                 else
951                         self.velocity_z = 50;
952
953                 return;
954         }
955
956
957         if (!(self.flags & FL_ONGROUND))
958                 return;
959
960         if (!(self.flags & FL_JUMPRELEASED))
961                 return;
962
963         if(cvar("g_runematch"))
964         {
965                 if(self.runes & RUNE_SPEED)
966                 {
967                         if(self.runes & CURSE_SLOW)
968                                 mjumpheight = mjumpheight * cvar("g_balance_rune_speed_combo_jumpheight");
969                         else
970                                 mjumpheight = mjumpheight * cvar("g_balance_rune_speed_jumpheight");
971                 }
972                 else if(self.runes & CURSE_SLOW)
973                 {
974                         mjumpheight = mjumpheight * cvar("g_balance_curse_slow_jumpheight");
975                 }
976         }
977
978         if(cvar("g_minstagib") && (self.items & IT_INVINCIBLE))
979         {
980                 mjumpheight = mjumpheight * cvar("g_balance_rune_speed_jumpheight");
981         }
982
983         self.velocity_z = self.velocity_z + mjumpheight;
984         self.oldvelocity_z = self.velocity_z;
985
986         self.flags = self.flags - FL_ONGROUND;
987         self.flags = self.flags - FL_JUMPRELEASED;
988 }
989
990 void() CheckWaterJump =
991 {
992         local vector start, end;
993
994 // check for a jump-out-of-water
995         makevectors (self.angles);
996         start = self.origin;
997         start_z = start_z + 8;
998         v_forward_z = 0;
999         normalize(v_forward);
1000         end = start + v_forward*24;
1001         traceline (start, end, TRUE, self);
1002         if (trace_fraction < 1)
1003         {       // solid at waist
1004                 start_z = start_z + self.maxs_z - 8;
1005                 end = start + v_forward*24;
1006                 self.movedir = trace_plane_normal * -50;
1007                 traceline (start, end, TRUE, self);
1008                 if (trace_fraction == 1)
1009                 {       // open at eye level
1010                         self.flags = self.flags | FL_WATERJUMP;
1011                         self.velocity_z = 225;
1012                         self.flags = self.flags - (self.flags & FL_JUMPRELEASED);
1013                         self.teleport_time = time + 2;  // safety net
1014                         return;
1015                 }
1016         }
1017 };
1018
1019
1020 void respawn(void)
1021 {
1022         CopyBody(1);
1023         PutClientInServer();
1024 }
1025
1026 void player_powerups (void)
1027 {
1028         if (cvar("g_minstagib"))
1029         {
1030                 self.effects = EF_FULLBRIGHT;
1031                 if (self.items & IT_STRENGTH)
1032                 {
1033                         if (time > self.strength_finished)
1034                         {
1035                                 self.alpha = default_player_alpha;
1036                                 self.exteriorweaponentity.alpha = default_player_alpha;
1037                                 self.items = self.items - (self.items & IT_STRENGTH);
1038                                 sprint(self, "^3Invisibility has worn off\n");
1039                         }
1040                 }
1041                 else
1042                 {
1043                         if (time < self.strength_finished)
1044                         {
1045                                 self.alpha = cvar("g_minstagib_invis_alpha");
1046                                 self.exteriorweaponentity.alpha = cvar("g_minstagib_invis_alpha");
1047                                 self.items = self.items | IT_STRENGTH;
1048                                 sprint(self, "^3You are invisible\n");
1049                         }
1050                 }
1051
1052                 if (self.items & IT_INVINCIBLE)
1053                 {
1054                         if (time > self.invincible_finished)
1055                         {
1056                                 self.items = self.items - (self.items & IT_INVINCIBLE);
1057                                 sprint(self, "^3Speed has worn off\n");
1058                         }
1059                 }
1060                 else
1061                 {
1062                         if (time < self.invincible_finished)
1063                         {
1064                                 self.items = self.items | IT_INVINCIBLE;
1065                                 sprint(self, "^3You are on speed\n");
1066                         }
1067                 }
1068                 return;
1069         }
1070
1071         self.effects = self.effects - (self.effects & (EF_RED | EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT));
1072         if (self.items & IT_STRENGTH)
1073         {
1074                 self.effects = self.effects | (EF_BLUE | EF_ADDITIVE | EF_FULLBRIGHT);
1075                 if (time > self.strength_finished)
1076                 {
1077                         self.items = self.items - (self.items & IT_STRENGTH);
1078                         sprint(self, "^3Strength has worn off\n");
1079                 }
1080         }
1081         else
1082         {
1083                 if (time < self.strength_finished)
1084                 {
1085                         self.items = self.items | IT_STRENGTH;
1086                         sprint(self, "^3Strength infuses your weapons with devastating power\n");
1087                 }
1088         }
1089         if (self.items & IT_INVINCIBLE)
1090         {
1091                 self.effects = self.effects | (EF_RED | EF_ADDITIVE | EF_FULLBRIGHT);
1092                 if (time > self.invincible_finished)
1093                 {
1094                         self.items = self.items - (self.items & IT_INVINCIBLE);
1095                         sprint(self, "^3Shield has worn off\n");
1096                 }
1097         }
1098         else
1099         {
1100                 if (time < self.invincible_finished)
1101                 {
1102                         self.items = self.items | IT_INVINCIBLE;
1103                         sprint(self, "^3Shield surrounds you\n");
1104                 }
1105         }
1106
1107         if (cvar("g_fullbrightplayers"))
1108                 self.effects = self.effects | EF_FULLBRIGHT;
1109
1110         // midair gamemode: damage only while in the air
1111         // if in midair mode, being on ground grants temporary invulnerability
1112         // (this is so that multishot weapon don't clear the ground flag on the
1113         // first damage in the frame, leaving the player vulnerable to the
1114         // remaining hits in the same frame)
1115         if (self.flags & FL_ONGROUND)
1116         if (cvar("g_midair"))
1117                 self.spawnshieldtime = max(self.spawnshieldtime, time + cvar("g_midair_shieldtime"));
1118
1119         if (time < self.spawnshieldtime)
1120                 self.effects = self.effects | (EF_ADDITIVE | EF_FULLBRIGHT);
1121 }
1122
1123 void player_regen (void)
1124 {
1125         float maxh, maxa, limith, limita, max_mod, regen_mod, rot_mod, limit_mod;
1126         maxh = cvar("g_balance_health_stable");
1127         maxa = cvar("g_balance_armor_stable");
1128         limith = cvar("g_balance_health_limit");
1129         limita = cvar("g_balance_armor_limit");
1130
1131         if (cvar("g_minstagib") || (cvar("g_lms") && !cvar("g_lms_regenerate")))
1132                 return;
1133
1134         if(cvar("g_runematch"))
1135         {
1136                 max_mod = regen_mod = rot_mod = limit_mod = 1;
1137                 if (self.runes & RUNE_REGEN)
1138                 {
1139                         if (self.runes & CURSE_VENOM) // do we have both rune/curse?
1140                         {
1141                                 regen_mod = cvar("g_balance_rune_regen_combo_regenrate");
1142                                 max_mod = cvar("g_balance_rune_regen_combo_hpmod");
1143                                 limit_mod = cvar("g_balance_rune_regen_combo_limitmod");
1144                         }
1145                         else
1146                         {
1147                                 regen_mod = cvar("g_balance_rune_regen_regenrate");
1148                                 max_mod = cvar("g_balance_rune_regen_hpmod");
1149                                 limit_mod = cvar("g_balance_rune_regen_limitmod");
1150                         }
1151                 }
1152                 else if (self.runes & CURSE_VENOM)
1153                 {
1154                         max_mod = cvar("g_balance_curse_venom_hpmod");
1155                         if (self.runes & RUNE_REGEN) // do we have both rune/curse?
1156                                 rot_mod = cvar("g_balance_rune_regen_combo_rotrate");
1157                         else
1158                                 rot_mod = cvar("g_balance_curse_venom_rotrate");
1159                         limit_mod = cvar("g_balance_curse_venom_limitmod");
1160                         //if (!self.runes & RUNE_REGEN)
1161                         //      rot_mod = cvar("g_balance_curse_venom_rotrate");
1162                 }
1163                 maxh = maxh * max_mod;
1164                 //maxa = maxa * max_mod;
1165
1166                 if (time > self.pauserotarmor_finished)
1167                 {
1168                         if (self.armorvalue > maxa)
1169                                 self.armorvalue = bound(0, self.armorvalue + (maxa - self.armorvalue) * cvar("g_balance_armor_rot") * frametime, 1000);
1170                 }
1171                 if (time > self.pauserothealth_finished)
1172                 {
1173                         if (self.health > maxh)
1174                                 self.health = bound(0, self.health + (maxh - self.health) * rot_mod*cvar("g_balance_health_rot") * frametime, 1000);
1175                 }
1176                 if (time > self.pauseregen_finished)
1177                 {
1178                         if (self.health < maxh)
1179                                 self.health = bound(0, self.health + (maxh- self.health) * regen_mod*cvar("g_balance_health_regen") * frametime  + 0.001, 1000);
1180                         if (self.armorvalue < maxa)
1181                                 self.armorvalue = bound(0, self.armorvalue + (maxa - self.armorvalue) * cvar("g_balance_armor_regen") * frametime  + 0.001, 1000);
1182                 }
1183         }
1184         else
1185         {
1186                 if (time > self.pauserothealth_finished)
1187                 if (self.health > maxh)
1188                         self.health = bound(0, self.health + (maxh - self.health) * cvar("g_balance_health_rot") * frametime, 1000);
1189                 if (time > self.pauserotarmor_finished)
1190                 if (self.armorvalue > maxa)
1191                         self.armorvalue = bound(0, self.armorvalue + (maxa - self.armorvalue) * cvar("g_balance_armor_rot") * frametime, 1000);
1192                 if (time > self.pauseregen_finished)
1193                 {
1194                         if (self.health < maxh)
1195                                  self.health = bound(0, self.health + (maxh - self.health) * cvar("g_balance_health_regen") * frametime + 0.001, 1000);
1196                         if (self.armorvalue < maxa)
1197                                 self.armorvalue = bound(0, self.armorvalue + (maxa - self.armorvalue) * cvar("g_balance_armor_regen") * frametime + 0.001, 1000);
1198                 }
1199         }
1200
1201         if (self.health > limith)
1202                 self.health = limith;
1203         if(self.health < 1)
1204                 self.event_damage(self, self, 1, DEATH_ROT, self.origin, '0 0 0');
1205         if (self.armorvalue > limita)
1206                 self.armorvalue = limita;
1207 }
1208
1209 /*
1210 ======================
1211 spectate mode routines
1212 ======================
1213 */
1214 void SpectateCopy(entity spectatee) {
1215         self.armortype = spectatee.armortype;
1216         self.armorvalue = spectatee.armorvalue;
1217         self.currentammo = spectatee.currentammo;
1218         self.effects = spectatee.effects;
1219         self.health = spectatee.health;
1220         self.impulse = 0;
1221         self.items = spectatee.items;
1222         self.punchangle = spectatee.punchangle;
1223         self.view_ofs = spectatee.view_ofs;
1224         self.v_angle = spectatee.v_angle;
1225         self.viewzoom = spectatee.viewzoom;
1226         setorigin(self, spectatee.origin);
1227         setsize(self, spectatee.mins, spectatee.maxs);
1228 }
1229
1230 void SpectateUpdate() {
1231         if(!self.enemy)
1232                         PutObserverInServer();
1233
1234         if (self != self.enemy) {
1235                 if(self.enemy.flags & FL_NOTARGET)
1236                         PutObserverInServer();
1237                 SpectateCopy(self.enemy);
1238                 self.dmg_take = self.enemy.dmg_take;
1239                 self.dmg_save = self.enemy.dmg_save;
1240                 self.dmg_inflictor = self.enemy.dmg_inflictor;
1241                 self.fixangle = TRUE;
1242                 self.angles = self.enemy.v_angle;
1243                 //msg_entity = self;
1244                 //WriteByte(MSG_ONE, SVC_SETANGLE);
1245                 //WriteAngle(MSG_ONE, self.enemy.v_angle_x);
1246                 //WriteAngle(MSG_ONE, self.enemy.v_angle_y);
1247                 //WriteAngle(MSG_ONE, self.enemy.v_angle_z);
1248         }
1249 }
1250
1251 float SpectateNext() {
1252         other = find(self.enemy, classname, "player");
1253         if (!other) {
1254                 other = find(other, classname, "player");
1255         }
1256         if (other) {
1257                 self.enemy = other;
1258         }
1259         if(self.enemy.classname == "player") {
1260                 msg_entity = self;
1261                 WriteByte(MSG_ONE, SVC_SETVIEW);
1262                 WriteEntity(MSG_ONE, self.enemy);
1263                 //stuffcmd(self, "set viewsize $tmpviewsize \n");
1264                 SpectateUpdate();
1265                 return 1;
1266         } else {
1267                 return 0;
1268         }
1269 }
1270
1271 /*
1272 =============
1273 PlayerPreThink
1274
1275 Called every frame for each client before the physics are run
1276 =============
1277 */
1278 void PlayerPreThink (void)
1279 {
1280         if(self.classname == "player") {
1281                 local vector m1, m2;
1282
1283 //              if(self.netname == "Wazat")
1284 //                      bprint(strcat(self.classname, "\n"));
1285
1286                 CheckRules_Player();
1287
1288                 Nixnex_GiveCurrentWeapon();
1289
1290                 if(self.button7)
1291                         PrintWelcomeMessage(self);
1292
1293                 if(cvar("g_lms") || !cvar("sv_spectate"))
1294                 if((time - self.jointime) <= cvar("welcome_message_time"))
1295                         PrintWelcomeMessage(self);
1296
1297                 if (intermission_running)
1298                 {
1299                         IntermissionThink ();   // otherwise a button could be missed between
1300                         return;                                 // the think tics
1301                 }
1302
1303                 if (self.deadflag != DEAD_NO)
1304                 {
1305                         player_anim();
1306                         if (self.deadflag == DEAD_DYING)
1307                         {
1308                                 if (time > self.dead_time)
1309                                         self.deadflag = DEAD_DEAD;
1310                         }
1311                         else if (self.deadflag == DEAD_DEAD)
1312                         {
1313                                 if (cvar("g_lms") || cvar("g_arena") || cvar("g_forced_respawn"))
1314                                         self.deadflag = DEAD_RESPAWNABLE;
1315                                 else if (!self.button0 && !self.button2 && !self.button3)
1316                                         self.deadflag = DEAD_RESPAWNABLE;
1317                         }
1318                         else if (self.deadflag == DEAD_RESPAWNABLE)
1319                         {
1320                                 if (self.button0  ||
1321                                     self.button2  ||
1322                                     self.button3  ||
1323                                     self.button4  ||
1324                                     self.button5  ||
1325                                     self.button6  ||
1326                                     self.button7  ||
1327                                     self.button8  ||
1328                                     self.buttonuse ||
1329                                     cvar("g_lms") ||
1330                                     cvar("g_forced_respawn"))
1331                                         respawn();
1332                         }
1333                         return;
1334                 }
1335
1336                 if(cvar("g_lms") && !self.deadflag && cvar("g_lms_campcheck_interval"))
1337                 {
1338                         vector dist;
1339
1340                         // calculate player movement (in 2 dimensions only, so jumping on one spot doesn't count as movement)
1341                         dist = self.oldorigin - self.origin;
1342                         dist_z = 0;
1343                         self.lms_traveled_distance += fabs(vlen(dist));
1344
1345                         if(cvar("g_campaign"))
1346                         if(!campaign_bots_may_start)
1347                         {
1348                                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval")*2;
1349                                 self.lms_traveled_distance = 0;
1350                         }
1351
1352                         if(time > self.lms_nextcheck)
1353                         {
1354                                 //sprint(self, "distance: ", ftos(self.lms_traveled_distance), "\n");
1355                                 if(self.lms_traveled_distance < cvar("g_lms_campcheck_distance"))
1356                                 {
1357                                         centerprint(self, cvar_string("g_lms_campcheck_message"));
1358                                         // FIXME KadaverJack: gibbing player here causes playermodel to bounce around, instead of eye.md3
1359                                         // I wasn't able to find out WHY that happens, so I put a workaround in place that shall prevent players from being gibbed :(
1360                                         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');
1361                                 }
1362                                 self.lms_nextcheck = time + cvar("g_lms_campcheck_interval");
1363                                 self.lms_traveled_distance = 0;
1364                         }
1365                 }
1366
1367                 if (self.button5 && !self.hook.state)
1368                 {
1369                         if (!self.crouch)
1370                         {
1371                                 self.crouch = TRUE;
1372                                 self.view_ofs = PL_CROUCH_VIEW_OFS;
1373                                 setsize (self, PL_CROUCH_MIN, PL_CROUCH_MAX);
1374                         }
1375                 }
1376                 else
1377                 {
1378                         if (self.crouch)
1379                         {
1380                                 tracebox(self.origin, PL_MIN, PL_MAX, self.origin, FALSE, self);
1381                                 if (!trace_startsolid)
1382                                 {
1383                                         self.crouch = FALSE;
1384                                         self.view_ofs = PL_VIEW_OFS;
1385                                         setsize (self, PL_MIN, PL_MAX);
1386                                 }
1387                         }
1388                 }
1389
1390                 if(cvar("sv_defaultcharacter") == 1 && !teams_matter) {
1391                         local string defaultmodel;
1392                         defaultmodel = CheckPlayerModel(cvar_string("sv_defaultplayermodel"));
1393
1394                         if (defaultmodel != self.model)
1395                         {
1396                                 m1 = self.mins;
1397                                 m2 = self.maxs;
1398                                 setmodel_lod (self, defaultmodel);
1399                                 setsize (self, m1, m2);
1400                         }
1401
1402                         if (self.skin != cvar("sv_defaultplayerskin"))
1403                                 self.skin = cvar("sv_defaultplayerskin");
1404                 } else {
1405                         if (self.playermodel != self.model)
1406                         {
1407                                 self.playermodel = CheckPlayerModel(self.playermodel);
1408                                 m1 = self.mins;
1409                                 m2 = self.maxs;
1410                                 setmodel_lod (self, self.playermodel);
1411                                 setsize (self, m1, m2);
1412                         }
1413
1414                         if (self.skin != stof(self.playerskin))
1415                                 self.skin = stof(self.playerskin);
1416                 }
1417                 // Savage: Check for nameless players
1418                 if (strlen(self.netname) < 1) {
1419                         self.netname = "Player";
1420                         stuffcmd(self, "name Player\n");
1421                 }
1422
1423                 GrapplingHookFrame();
1424
1425                 W_WeaponFrame();
1426
1427                 if (self.button4 || (self.weapon == WEP_NEX && self.button3))
1428                 {
1429                         if (cvar("g_minstagib") && self.button3)
1430                         {
1431                                 if (self.jump_interval <= (time + 0.1))
1432                                 {
1433                                         self.jump_interval = time + 1;
1434                                         W_Laser_Attack();
1435                                 }
1436                         }
1437                         else if (self.viewzoom > 0.4)
1438                                 self.viewzoom = max (0.4, self.viewzoom - frametime * 2);
1439                 }
1440                 else if (self.viewzoom < 1.0)
1441                         self.viewzoom = min (1.0, self.viewzoom + frametime);
1442
1443
1444                 if (self.button2)
1445                         PlayerJump ();
1446                 else
1447                         self.flags = self.flags | FL_JUMPRELEASED;
1448
1449                 player_powerups();
1450                 player_regen();
1451                 player_anim();
1452
1453                 if (cvar("g_minstagib"))
1454                         minstagib_ammocheck();
1455
1456                 //self.angles_y=self.v_angle_y + 90;   // temp
1457
1458                 if (self.waterlevel == 2)
1459                         CheckWaterJump ();
1460
1461                 //if (TetrisPreFrame()) return;
1462         } else if(gameover) {
1463                 if (intermission_running)
1464                         IntermissionThink ();   // otherwise a button could be missed between
1465                 return;
1466         } else if(self.classname == "observer") {
1467
1468                 if (self.flags & FL_JUMPRELEASED) {
1469                         if (self.button2 && self.version == cvar("gameversion")) {
1470                                 if(!cvar("teamplay") || cvar("g_campaign") || cvar("g_balance_teams")) {
1471                                         self.flags = self.flags & !FL_JUMPRELEASED;
1472                                         self.classname = "player";
1473                                         if(cvar("g_campaign") || cvar("g_balance_teams"))
1474                                                 JoinBestTeam(self, 0);
1475                                         if(cvar("g_campaign"))
1476                                                 campaign_bots_may_start = 1;
1477                                         PutClientInServer();
1478                                         if(self.flags & !FL_NOTARGET)
1479                                                 bprint (strcat("^4", self.netname, "^4 is playing now\n"));
1480                                         centerprint(self,"");
1481                                         return;
1482                                 } else {
1483                                         self.flags = self.flags & !FL_JUMPRELEASED;
1484                                         stuffcmd(self,"menu_showteamselect\n");
1485                                         return;
1486                                 }
1487                         } else if(self.button0 && self.version == cvar("gameversion")) {
1488                                 self.flags = self.flags & !FL_JUMPRELEASED;
1489                                 if(SpectateNext() == 1) {
1490                                         self.classname = "spectator";
1491                                 }
1492                         }
1493                 } else {
1494                         if (!(self.button0 || self.button2)) {
1495                                 self.flags = self.flags | FL_JUMPRELEASED;
1496                         }
1497                 }
1498                 PrintWelcomeMessage(self);
1499         } else if(self.classname == "spectator") {
1500                 if (self.flags & FL_JUMPRELEASED) {
1501                         if (self.button2 && self.version == cvar("gameversion")) {
1502                                 if(!cvar("teamplay") || cvar("g_campaign") || cvar("g_balance_teams")) {
1503                                         self.flags = self.flags & !FL_JUMPRELEASED;
1504                                         self.classname = "player";
1505                                         if(!cvar("g_lms"))
1506                                                 bprint (strcat("^4", self.netname, "^4 is playing now\n"));
1507
1508                                         if(cvar("g_campaign") || cvar("g_balance_teams"))
1509                                                 JoinBestTeam(self, 0);
1510                                         if(cvar("g_campaign"))
1511                                                 campaign_bots_may_start = 1;
1512                                         PutClientInServer();
1513                                         centerprint(self,"");
1514                                         return;
1515                                 } else {
1516                                         self.flags = self.flags & !FL_JUMPRELEASED;
1517                                         stuffcmd(self,"menu_showteamselect\n");
1518                                         return;
1519                                 }
1520                         } else if(self.button0) {
1521                                 self.flags = self.flags & !FL_JUMPRELEASED;
1522                                 if(SpectateNext() == 1) {
1523                                         self.classname = "spectator";
1524                                 } else {
1525                                         self.classname = "observer";
1526                                         PutClientInServer();
1527                                 }
1528                         } else if (self.button3) {
1529                                 self.flags = self.flags & !FL_JUMPRELEASED;
1530                                 self.classname = "observer";
1531                                 PutClientInServer();
1532                         } else {
1533                                 SpectateUpdate();
1534                         }
1535                 } else {
1536                         if (!(self.button0 || self.button3)) {
1537                                 self.flags = self.flags | FL_JUMPRELEASED;
1538                         }
1539                 }
1540                 PrintWelcomeMessage(self);
1541                 self.flags = self.flags | FL_CLIENT | FL_NOTARGET;
1542         }
1543 }
1544
1545
1546 /*
1547 =============
1548 PlayerPostThink
1549
1550 Called every frame for each client after the physics are run
1551 =============
1552 */
1553 void PlayerPostThink (void)
1554 {
1555         if(self.classname == "player") {
1556                 CheckRules_Player();
1557                 UpdateChatBubble();
1558                 UpdateTeamBubble();
1559                 if (self.deadflag == DEAD_NO)
1560                 if (self.impulse)
1561                         ImpulseCommands ();
1562                 if (intermission_running)
1563                         return;         // intermission or finale
1564
1565                 //PrintWelcomeMessage(self);
1566                 //if (TetrisPostFrame()) return;
1567         } else if (self.classname == "observer") {
1568                 //do nothing
1569         } else if (self.classname == "spectator") {
1570                 //do nothing
1571         }
1572         Arena_Warmup();
1573 }