← Back to branch summary

~ubuntu-branches/ubuntu/precise/openarena/precise

« back to all changes in this revision

Viewing changes to code/game/g_active.c

  • Committer: Bazaar Package Importer
  • Author(s): Bruno "Fuddl" Kleinert
  • Date: 2007-01-20 12:28:09 UTC
  • Revision ID: james.westby@ubuntu.com-20070120122809-2yza5ojt7nqiyiam
Tags: upstream-0.6.0
Import upstream version 0.6.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
code/game/g_active.c
 
1
/*
 
2
===========================================================================
 
3
Copyright (C) 1999-2005 Id Software, Inc.
 
4
 
 
5
This file is part of Quake III Arena source code.
 
6
 
 
7
Quake III Arena source code is free software; you can redistribute it
 
8
and/or modify it under the terms of the GNU General Public License as
 
9
published by the Free Software Foundation; either version 2 of the License,
 
10
or (at your option) any later version.
 
11
 
 
12
Quake III Arena source code is distributed in the hope that it will be
 
13
useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
 
14
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
15
GNU General Public License for more details.
 
16
 
 
17
You should have received a copy of the GNU General Public License
 
18
along with Quake III Arena source code; if not, write to the Free Software
 
19
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
20
===========================================================================
 
21
*/
 
22
//
 
23
 
 
24
#include "g_local.h"
 
25
 
 
26
 
 
27
/*
 
28
===============
 
29
G_DamageFeedback
 
30
 
 
31
Called just before a snapshot is sent to the given player.
 
32
Totals up all damage and generates both the player_state_t
 
33
damage values to that client for pain blends and kicks, and
 
34
global pain sound events for all clients.
 
35
===============
 
36
*/
 
37
void P_DamageFeedback( gentity_t *player ) {
 
38
        gclient_t       *client;
 
39
        float   count;
 
40
        vec3_t  angles;
 
41
 
 
42
        client = player->client;
 
43
        if ( client->ps.pm_type == PM_DEAD ) {
 
44
                return;
 
45
        }
 
46
 
 
47
        // total points of damage shot at the player this frame
 
48
        count = client->damage_blood + client->damage_armor;
 
49
        if ( count == 0 ) {
 
50
                return;         // didn't take any damage
 
51
        }
 
52
 
 
53
        if ( count > 255 ) {
 
54
                count = 255;
 
55
        }
 
56
 
 
57
        // send the information to the client
 
58
 
 
59
        // world damage (falling, slime, etc) uses a special code
 
60
        // to make the blend blob centered instead of positional
 
61
        if ( client->damage_fromWorld ) {
 
62
                client->ps.damagePitch = 255;
 
63
                client->ps.damageYaw = 255;
 
64
 
 
65
                client->damage_fromWorld = qfalse;
 
66
        } else {
 
67
                vectoangles( client->damage_from, angles );
 
68
                client->ps.damagePitch = angles[PITCH]/360.0 * 256;
 
69
                client->ps.damageYaw = angles[YAW]/360.0 * 256;
 
70
        }
 
71
 
 
72
        // play an apropriate pain sound
 
73
        if ( (level.time > player->pain_debounce_time) && !(player->flags & FL_GODMODE) ) {
 
74
                player->pain_debounce_time = level.time + 700;
 
75
                G_AddEvent( player, EV_PAIN, player->health );
 
76
                client->ps.damageEvent++;
 
77
        }
 
78
 
 
79
 
 
80
        client->ps.damageCount = count;
 
81
 
 
82
        //
 
83
        // clear totals
 
84
        //
 
85
        client->damage_blood = 0;
 
86
        client->damage_armor = 0;
 
87
        client->damage_knockback = 0;
 
88
}
 
89
 
 
90
 
 
91
 
 
92
/*
 
93
=============
 
94
P_WorldEffects
 
95
 
 
96
Check for lava / slime contents and drowning
 
97
=============
 
98
*/
 
99
void P_WorldEffects( gentity_t *ent ) {
 
100
        qboolean        envirosuit;
 
101
        int                     waterlevel;
 
102
 
 
103
        if ( ent->client->noclip ) {
 
104
                ent->client->airOutTime = level.time + 12000;   // don't need air
 
105
                return;
 
106
        }
 
107
 
 
108
        waterlevel = ent->waterlevel;
 
109
 
 
110
        envirosuit = ent->client->ps.powerups[PW_BATTLESUIT] > level.time;
 
111
 
 
112
        //
 
113
        // check for drowning
 
114
        //
 
115
        if ( waterlevel == 3 ) {
 
116
                // envirosuit give air
 
117
                if ( envirosuit ) {
 
118
                        ent->client->airOutTime = level.time + 10000;
 
119
                }
 
120
 
 
121
                // if out of air, start drowning
 
122
                if ( ent->client->airOutTime < level.time) {
 
123
                        // drown!
 
124
                        ent->client->airOutTime += 1000;
 
125
                        if ( ent->health > 0 ) {
 
126
                                // take more damage the longer underwater
 
127
                                ent->damage += 2;
 
128
                                if (ent->damage > 15)
 
129
                                        ent->damage = 15;
 
130
 
 
131
                                // play a gurp sound instead of a normal pain sound
 
132
                                if (ent->health <= ent->damage) {
 
133
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex("*drown.wav"));
 
134
                                } else if (rand()&1) {
 
135
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp1.wav"));
 
136
                                } else {
 
137
                                        G_Sound(ent, CHAN_VOICE, G_SoundIndex("sound/player/gurp2.wav"));
 
138
                                }
 
139
 
 
140
                                // don't play a normal pain sound
 
141
                                ent->pain_debounce_time = level.time + 200;
 
142
 
 
143
                                G_Damage (ent, NULL, NULL, NULL, NULL, 
 
144
                                        ent->damage, DAMAGE_NO_ARMOR, MOD_WATER);
 
145
                        }
 
146
                }
 
147
        } else {
 
148
                ent->client->airOutTime = level.time + 12000;
 
149
                ent->damage = 2;
 
150
        }
 
151
 
 
152
        //
 
153
        // check for sizzle damage (move to pmove?)
 
154
        //
 
155
        if (waterlevel && 
 
156
                (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
 
157
                if (ent->health > 0
 
158
                        && ent->pain_debounce_time <= level.time        ) {
 
159
 
 
160
                        if ( envirosuit ) {
 
161
                                G_AddEvent( ent, EV_POWERUP_BATTLESUIT, 0 );
 
162
                        } else {
 
163
                                if (ent->watertype & CONTENTS_LAVA) {
 
164
                                        G_Damage (ent, NULL, NULL, NULL, NULL, 
 
165
                                                30*waterlevel, 0, MOD_LAVA);
 
166
                                }
 
167
 
 
168
                                if (ent->watertype & CONTENTS_SLIME) {
 
169
                                        G_Damage (ent, NULL, NULL, NULL, NULL, 
 
170
                                                10*waterlevel, 0, MOD_SLIME);
 
171
                                }
 
172
                        }
 
173
                }
 
174
        }
 
175
}
 
176
 
 
177
 
 
178
 
 
179
/*
 
180
===============
 
181
G_SetClientSound
 
182
===============
 
183
*/
 
184
void G_SetClientSound( gentity_t *ent ) {
 
185
#ifdef MISSIONPACK
 
186
        if( ent->s.eFlags & EF_TICKING ) {
 
187
                ent->client->ps.loopSound = G_SoundIndex( "sound/weapons/proxmine/wstbtick.wav");
 
188
        }
 
189
        else
 
190
#endif
 
191
        if (ent->waterlevel && (ent->watertype&(CONTENTS_LAVA|CONTENTS_SLIME)) ) {
 
192
                ent->client->ps.loopSound = level.snd_fry;
 
193
        } else {
 
194
                ent->client->ps.loopSound = 0;
 
195
        }
 
196
}
 
197
 
 
198
 
 
199
 
 
200
//==============================================================
 
201
 
 
202
/*
 
203
==============
 
204
ClientImpacts
 
205
==============
 
206
*/
 
207
void ClientImpacts( gentity_t *ent, pmove_t *pm ) {
 
208
        int             i, j;
 
209
        trace_t trace;
 
210
        gentity_t       *other;
 
211
 
 
212
        memset( &trace, 0, sizeof( trace ) );
 
213
        for (i=0 ; i<pm->numtouch ; i++) {
 
214
                for (j=0 ; j<i ; j++) {
 
215
                        if (pm->touchents[j] == pm->touchents[i] ) {
 
216
                                break;
 
217
                        }
 
218
                }
 
219
                if (j != i) {
 
220
                        continue;       // duplicated
 
221
                }
 
222
                other = &g_entities[ pm->touchents[i] ];
 
223
 
 
224
                if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
 
225
                        ent->touch( ent, other, &trace );
 
226
                }
 
227
 
 
228
                if ( !other->touch ) {
 
229
                        continue;
 
230
                }
 
231
 
 
232
                other->touch( other, ent, &trace );
 
233
        }
 
234
 
 
235
}
 
236
 
 
237
/*
 
238
============
 
239
G_TouchTriggers
 
240
 
 
241
Find all trigger entities that ent's current position touches.
 
242
Spectators will only interact with teleporters.
 
243
============
 
244
*/
 
245
void    G_TouchTriggers( gentity_t *ent ) {
 
246
        int                     i, num;
 
247
        int                     touch[MAX_GENTITIES];
 
248
        gentity_t       *hit;
 
249
        trace_t         trace;
 
250
        vec3_t          mins, maxs;
 
251
        static vec3_t   range = { 40, 40, 52 };
 
252
 
 
253
        if ( !ent->client ) {
 
254
                return;
 
255
        }
 
256
 
 
257
        // dead clients don't activate triggers!
 
258
        if ( ent->client->ps.stats[STAT_HEALTH] <= 0 ) {
 
259
                return;
 
260
        }
 
261
 
 
262
        VectorSubtract( ent->client->ps.origin, range, mins );
 
263
        VectorAdd( ent->client->ps.origin, range, maxs );
 
264
 
 
265
        num = trap_EntitiesInBox( mins, maxs, touch, MAX_GENTITIES );
 
266
 
 
267
        // can't use ent->absmin, because that has a one unit pad
 
268
        VectorAdd( ent->client->ps.origin, ent->r.mins, mins );
 
269
        VectorAdd( ent->client->ps.origin, ent->r.maxs, maxs );
 
270
 
 
271
        for ( i=0 ; i<num ; i++ ) {
 
272
                hit = &g_entities[touch[i]];
 
273
 
 
274
                if ( !hit->touch && !ent->touch ) {
 
275
                        continue;
 
276
                }
 
277
                if ( !( hit->r.contents & CONTENTS_TRIGGER ) ) {
 
278
                        continue;
 
279
                }
 
280
 
 
281
                // ignore most entities if a spectator
 
282
                if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
 
283
                        if ( hit->s.eType != ET_TELEPORT_TRIGGER &&
 
284
                                // this is ugly but adding a new ET_? type will
 
285
                                // most likely cause network incompatibilities
 
286
                                hit->touch != Touch_DoorTrigger) {
 
287
                                continue;
 
288
                        }
 
289
                }
 
290
 
 
291
                // use seperate code for determining if an item is picked up
 
292
                // so you don't have to actually contact its bounding box
 
293
                if ( hit->s.eType == ET_ITEM ) {
 
294
                        if ( !BG_PlayerTouchesItem( &ent->client->ps, &hit->s, level.time ) ) {
 
295
                                continue;
 
296
                        }
 
297
                } else {
 
298
                        if ( !trap_EntityContact( mins, maxs, hit ) ) {
 
299
                                continue;
 
300
                        }
 
301
                }
 
302
 
 
303
                memset( &trace, 0, sizeof(trace) );
 
304
 
 
305
                if ( hit->touch ) {
 
306
                        hit->touch (hit, ent, &trace);
 
307
                }
 
308
 
 
309
                if ( ( ent->r.svFlags & SVF_BOT ) && ( ent->touch ) ) {
 
310
                        ent->touch( ent, hit, &trace );
 
311
                }
 
312
        }
 
313
 
 
314
        // if we didn't touch a jump pad this pmove frame
 
315
        if ( ent->client->ps.jumppad_frame != ent->client->ps.pmove_framecount ) {
 
316
                ent->client->ps.jumppad_frame = 0;
 
317
                ent->client->ps.jumppad_ent = 0;
 
318
        }
 
319
}
 
320
 
 
321
/*
 
322
=================
 
323
SpectatorThink
 
324
=================
 
325
*/
 
326
void SpectatorThink( gentity_t *ent, usercmd_t *ucmd ) {
 
327
        pmove_t pm;
 
328
        gclient_t       *client;
 
329
 
 
330
        client = ent->client;
 
331
 
 
332
        if ( client->sess.spectatorState != SPECTATOR_FOLLOW ) {
 
333
                client->ps.pm_type = PM_SPECTATOR;
 
334
                client->ps.speed = 400; // faster than normal
 
335
 
 
336
                // set up for pmove
 
337
                memset (&pm, 0, sizeof(pm));
 
338
                pm.ps = &client->ps;
 
339
                pm.cmd = *ucmd;
 
340
                pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;       // spectators can fly through bodies
 
341
                pm.trace = trap_Trace;
 
342
                pm.pointcontents = trap_PointContents;
 
343
 
 
344
                // perform a pmove
 
345
                Pmove (&pm);
 
346
                // save results of pmove
 
347
                VectorCopy( client->ps.origin, ent->s.origin );
 
348
 
 
349
                G_TouchTriggers( ent );
 
350
                trap_UnlinkEntity( ent );
 
351
        }
 
352
 
 
353
        client->oldbuttons = client->buttons;
 
354
        client->buttons = ucmd->buttons;
 
355
 
 
356
        // attack button cycles through spectators
 
357
        if ( ( client->buttons & BUTTON_ATTACK ) && ! ( client->oldbuttons & BUTTON_ATTACK ) ) {
 
358
                Cmd_FollowCycle_f( ent, 1 );
 
359
        }
 
360
}
 
361
 
 
362
 
 
363
 
 
364
/*
 
365
=================
 
366
ClientInactivityTimer
 
367
 
 
368
Returns qfalse if the client is dropped
 
369
=================
 
370
*/
 
371
qboolean ClientInactivityTimer( gclient_t *client ) {
 
372
        if ( ! g_inactivity.integer ) {
 
373
                // give everyone some time, so if the operator sets g_inactivity during
 
374
                // gameplay, everyone isn't kicked
 
375
                client->inactivityTime = level.time + 60 * 1000;
 
376
                client->inactivityWarning = qfalse;
 
377
        } else if ( client->pers.cmd.forwardmove || 
 
378
                client->pers.cmd.rightmove || 
 
379
                client->pers.cmd.upmove ||
 
380
                (client->pers.cmd.buttons & BUTTON_ATTACK) ) {
 
381
                client->inactivityTime = level.time + g_inactivity.integer * 1000;
 
382
                client->inactivityWarning = qfalse;
 
383
        } else if ( !client->pers.localClient ) {
 
384
                if ( level.time > client->inactivityTime ) {
 
385
                        trap_DropClient( client - level.clients, "Dropped due to inactivity" );
 
386
                        return qfalse;
 
387
                }
 
388
                if ( level.time > client->inactivityTime - 10000 && !client->inactivityWarning ) {
 
389
                        client->inactivityWarning = qtrue;
 
390
                        trap_SendServerCommand( client - level.clients, "cp \"Ten seconds until inactivity drop!\n\"" );
 
391
                }
 
392
        }
 
393
        return qtrue;
 
394
}
 
395
 
 
396
/*
 
397
==================
 
398
ClientTimerActions
 
399
 
 
400
Actions that happen once a second
 
401
==================
 
402
*/
 
403
void ClientTimerActions( gentity_t *ent, int msec ) {
 
404
        gclient_t       *client;
 
405
#ifdef MISSIONPACK
 
406
        int                     maxHealth;
 
407
#endif
 
408
 
 
409
        client = ent->client;
 
410
        client->timeResidual += msec;
 
411
 
 
412
        while ( client->timeResidual >= 1000 ) {
 
413
                client->timeResidual -= 1000;
 
414
 
 
415
                // regenerate
 
416
#ifdef MISSIONPACK
 
417
                if( bg_itemlist[client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
 
418
                        maxHealth = client->ps.stats[STAT_MAX_HEALTH] / 2;
 
419
                }
 
420
                else if ( client->ps.powerups[PW_REGEN] ) {
 
421
                        maxHealth = client->ps.stats[STAT_MAX_HEALTH];
 
422
                }
 
423
                else {
 
424
                        maxHealth = 0;
 
425
                }
 
426
                if( maxHealth ) {
 
427
                        if ( ent->health < maxHealth ) {
 
428
                                ent->health += 15;
 
429
                                if ( ent->health > maxHealth * 1.1 ) {
 
430
                                        ent->health = maxHealth * 1.1;
 
431
                                }
 
432
                                G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
 
433
                        } else if ( ent->health < maxHealth * 2) {
 
434
                                ent->health += 5;
 
435
                                if ( ent->health > maxHealth * 2 ) {
 
436
                                        ent->health = maxHealth * 2;
 
437
                                }
 
438
                                G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
 
439
                        }
 
440
#else
 
441
                if ( client->ps.powerups[PW_REGEN] ) {
 
442
                        if ( ent->health < client->ps.stats[STAT_MAX_HEALTH]) {
 
443
                                ent->health += 15;
 
444
                                if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] * 1.1 ) {
 
445
                                        ent->health = client->ps.stats[STAT_MAX_HEALTH] * 1.1;
 
446
                                }
 
447
                                G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
 
448
                        } else if ( ent->health < client->ps.stats[STAT_MAX_HEALTH] * 2) {
 
449
                                ent->health += 5;
 
450
                                if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] * 2 ) {
 
451
                                        ent->health = client->ps.stats[STAT_MAX_HEALTH] * 2;
 
452
                                }
 
453
                                G_AddEvent( ent, EV_POWERUP_REGEN, 0 );
 
454
                        }
 
455
#endif
 
456
                } else {
 
457
                        // count down health when over max
 
458
                        if ( ent->health > client->ps.stats[STAT_MAX_HEALTH] ) {
 
459
                                ent->health--;
 
460
                        }
 
461
                }
 
462
 
 
463
                // count down armor when over max
 
464
                if ( client->ps.stats[STAT_ARMOR] > client->ps.stats[STAT_MAX_HEALTH] ) {
 
465
                        client->ps.stats[STAT_ARMOR]--;
 
466
                }
 
467
        }
 
468
#ifdef MISSIONPACK
 
469
        if( bg_itemlist[client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_AMMOREGEN ) {
 
470
                int w, max, inc, t, i;
 
471
    int weapList[]={WP_MACHINEGUN,WP_SHOTGUN,WP_GRENADE_LAUNCHER,WP_ROCKET_LAUNCHER,WP_LIGHTNING,WP_RAILGUN,WP_PLASMAGUN,WP_BFG,WP_NAILGUN,WP_PROX_LAUNCHER,WP_CHAINGUN};
 
472
    int weapCount = sizeof(weapList) / sizeof(int);
 
473
                //
 
474
    for (i = 0; i < weapCount; i++) {
 
475
                  w = weapList[i];
 
476
 
 
477
                  switch(w) {
 
478
                          case WP_MACHINEGUN: max = 50; inc = 4; t = 1000; break;
 
479
                          case WP_SHOTGUN: max = 10; inc = 1; t = 1500; break;
 
480
                          case WP_GRENADE_LAUNCHER: max = 10; inc = 1; t = 2000; break;
 
481
                          case WP_ROCKET_LAUNCHER: max = 10; inc = 1; t = 1750; break;
 
482
                          case WP_LIGHTNING: max = 50; inc = 5; t = 1500; break;
 
483
                          case WP_RAILGUN: max = 10; inc = 1; t = 1750; break;
 
484
                          case WP_PLASMAGUN: max = 50; inc = 5; t = 1500; break;
 
485
                          case WP_BFG: max = 10; inc = 1; t = 4000; break;
 
486
                          case WP_NAILGUN: max = 10; inc = 1; t = 1250; break;
 
487
                          case WP_PROX_LAUNCHER: max = 5; inc = 1; t = 2000; break;
 
488
                          case WP_CHAINGUN: max = 100; inc = 5; t = 1000; break;
 
489
                          default: max = 0; inc = 0; t = 1000; break;
 
490
                  }
 
491
                  client->ammoTimes[w] += msec;
 
492
                  if ( client->ps.ammo[w] >= max ) {
 
493
                          client->ammoTimes[w] = 0;
 
494
                  }
 
495
                  if ( client->ammoTimes[w] >= t ) {
 
496
                          while ( client->ammoTimes[w] >= t )
 
497
                                  client->ammoTimes[w] -= t;
 
498
                          client->ps.ammo[w] += inc;
 
499
                          if ( client->ps.ammo[w] > max ) {
 
500
                                  client->ps.ammo[w] = max;
 
501
                          }
 
502
                  }
 
503
    }
 
504
        }
 
505
#endif
 
506
}
 
507
 
 
508
/*
 
509
====================
 
510
ClientIntermissionThink
 
511
====================
 
512
*/
 
513
void ClientIntermissionThink( gclient_t *client ) {
 
514
        client->ps.eFlags &= ~EF_TALK;
 
515
        client->ps.eFlags &= ~EF_FIRING;
 
516
 
 
517
        // the level will exit when everyone wants to or after timeouts
 
518
 
 
519
        // swap and latch button actions
 
520
        client->oldbuttons = client->buttons;
 
521
        client->buttons = client->pers.cmd.buttons;
 
522
        if ( client->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) & ( client->oldbuttons ^ client->buttons ) ) {
 
523
                // this used to be an ^1 but once a player says ready, it should stick
 
524
                client->readyToExit = 1;
 
525
        }
 
526
}
 
527
 
 
528
 
 
529
/*
 
530
================
 
531
ClientEvents
 
532
 
 
533
Events will be passed on to the clients for presentation,
 
534
but any server game effects are handled here
 
535
================
 
536
*/
 
537
void ClientEvents( gentity_t *ent, int oldEventSequence ) {
 
538
        int             i, j;
 
539
        int             event;
 
540
        gclient_t *client;
 
541
        int             damage;
 
542
        vec3_t  dir;
 
543
        vec3_t  origin, angles;
 
544
//      qboolean        fired;
 
545
        gitem_t *item;
 
546
        gentity_t *drop;
 
547
 
 
548
        client = ent->client;
 
549
 
 
550
        if ( oldEventSequence < client->ps.eventSequence - MAX_PS_EVENTS ) {
 
551
                oldEventSequence = client->ps.eventSequence - MAX_PS_EVENTS;
 
552
        }
 
553
        for ( i = oldEventSequence ; i < client->ps.eventSequence ; i++ ) {
 
554
                event = client->ps.events[ i & (MAX_PS_EVENTS-1) ];
 
555
 
 
556
                switch ( event ) {
 
557
                case EV_FALL_MEDIUM:
 
558
                case EV_FALL_FAR:
 
559
                        if ( ent->s.eType != ET_PLAYER ) {
 
560
                                break;          // not in the player model
 
561
                        }
 
562
                        if ( g_dmflags.integer & DF_NO_FALLING ) {
 
563
                                break;
 
564
                        }
 
565
                        if ( event == EV_FALL_FAR ) {
 
566
                                damage = 10;
 
567
                        } else {
 
568
                                damage = 5;
 
569
                        }
 
570
                        VectorSet (dir, 0, 0, 1);
 
571
                        ent->pain_debounce_time = level.time + 200;     // no normal pain sound
 
572
                        G_Damage (ent, NULL, NULL, NULL, NULL, damage, 0, MOD_FALLING);
 
573
                        break;
 
574
 
 
575
                case EV_FIRE_WEAPON:
 
576
                        FireWeapon( ent );
 
577
                        break;
 
578
 
 
579
                case EV_USE_ITEM1:              // teleporter
 
580
                        // drop flags in CTF
 
581
                        item = NULL;
 
582
                        j = 0;
 
583
 
 
584
                        if ( ent->client->ps.powerups[ PW_REDFLAG ] ) {
 
585
                                item = BG_FindItemForPowerup( PW_REDFLAG );
 
586
                                j = PW_REDFLAG;
 
587
                        } else if ( ent->client->ps.powerups[ PW_BLUEFLAG ] ) {
 
588
                                item = BG_FindItemForPowerup( PW_BLUEFLAG );
 
589
                                j = PW_BLUEFLAG;
 
590
                        } else if ( ent->client->ps.powerups[ PW_NEUTRALFLAG ] ) {
 
591
                                item = BG_FindItemForPowerup( PW_NEUTRALFLAG );
 
592
                                j = PW_NEUTRALFLAG;
 
593
                        }
 
594
 
 
595
                        if ( item ) {
 
596
                                drop = Drop_Item( ent, item, 0 );
 
597
                                // decide how many seconds it has left
 
598
                                drop->count = ( ent->client->ps.powerups[ j ] - level.time ) / 1000;
 
599
                                if ( drop->count < 1 ) {
 
600
                                        drop->count = 1;
 
601
                                }
 
602
 
 
603
                                ent->client->ps.powerups[ j ] = 0;
 
604
                        }
 
605
 
 
606
#ifdef MISSIONPACK
 
607
                        if ( g_gametype.integer == GT_HARVESTER ) {
 
608
                                if ( ent->client->ps.generic1 > 0 ) {
 
609
                                        if ( ent->client->sess.sessionTeam == TEAM_RED ) {
 
610
                                                item = BG_FindItem( "Blue Cube" );
 
611
                                        } else {
 
612
                                                item = BG_FindItem( "Red Cube" );
 
613
                                        }
 
614
                                        if ( item ) {
 
615
                                                for ( j = 0; j < ent->client->ps.generic1; j++ ) {
 
616
                                                        drop = Drop_Item( ent, item, 0 );
 
617
                                                        if ( ent->client->sess.sessionTeam == TEAM_RED ) {
 
618
                                                                drop->spawnflags = TEAM_BLUE;
 
619
                                                        } else {
 
620
                                                                drop->spawnflags = TEAM_RED;
 
621
                                                        }
 
622
                                                }
 
623
                                        }
 
624
                                        ent->client->ps.generic1 = 0;
 
625
                                }
 
626
                        }
 
627
#endif
 
628
                        SelectSpawnPoint( ent->client->ps.origin, origin, angles );
 
629
                        TeleportPlayer( ent, origin, angles );
 
630
                        break;
 
631
 
 
632
                case EV_USE_ITEM2:              // medkit
 
633
                        ent->health = ent->client->ps.stats[STAT_MAX_HEALTH] + 25;
 
634
 
 
635
                        break;
 
636
 
 
637
#ifdef MISSIONPACK
 
638
                case EV_USE_ITEM3:              // kamikaze
 
639
                        // make sure the invulnerability is off
 
640
                        ent->client->invulnerabilityTime = 0;
 
641
                        // start the kamikze
 
642
                        G_StartKamikaze( ent );
 
643
                        break;
 
644
 
 
645
                case EV_USE_ITEM4:              // portal
 
646
                        if( ent->client->portalID ) {
 
647
                                DropPortalSource( ent );
 
648
                        }
 
649
                        else {
 
650
                                DropPortalDestination( ent );
 
651
                        }
 
652
                        break;
 
653
                case EV_USE_ITEM5:              // invulnerability
 
654
                        ent->client->invulnerabilityTime = level.time + 10000;
 
655
                        break;
 
656
#endif
 
657
 
 
658
                default:
 
659
                        break;
 
660
                }
 
661
        }
 
662
 
 
663
}
 
664
 
 
665
#ifdef MISSIONPACK
 
666
/*
 
667
==============
 
668
StuckInOtherClient
 
669
==============
 
670
*/
 
671
static int StuckInOtherClient(gentity_t *ent) {
 
672
        int i;
 
673
        gentity_t       *ent2;
 
674
 
 
675
        ent2 = &g_entities[0];
 
676
        for ( i = 0; i < MAX_CLIENTS; i++, ent2++ ) {
 
677
                if ( ent2 == ent ) {
 
678
                        continue;
 
679
                }
 
680
                if ( !ent2->inuse ) {
 
681
                        continue;
 
682
                }
 
683
                if ( !ent2->client ) {
 
684
                        continue;
 
685
                }
 
686
                if ( ent2->health <= 0 ) {
 
687
                        continue;
 
688
                }
 
689
                //
 
690
                if (ent2->r.absmin[0] > ent->r.absmax[0])
 
691
                        continue;
 
692
                if (ent2->r.absmin[1] > ent->r.absmax[1])
 
693
                        continue;
 
694
                if (ent2->r.absmin[2] > ent->r.absmax[2])
 
695
                        continue;
 
696
                if (ent2->r.absmax[0] < ent->r.absmin[0])
 
697
                        continue;
 
698
                if (ent2->r.absmax[1] < ent->r.absmin[1])
 
699
                        continue;
 
700
                if (ent2->r.absmax[2] < ent->r.absmin[2])
 
701
                        continue;
 
702
                return qtrue;
 
703
        }
 
704
        return qfalse;
 
705
}
 
706
#endif
 
707
 
 
708
void BotTestSolid(vec3_t origin);
 
709
 
 
710
/*
 
711
==============
 
712
SendPendingPredictableEvents
 
713
==============
 
714
*/
 
715
void SendPendingPredictableEvents( playerState_t *ps ) {
 
716
        gentity_t *t;
 
717
        int event, seq;
 
718
        int extEvent, number;
 
719
 
 
720
        // if there are still events pending
 
721
        if ( ps->entityEventSequence < ps->eventSequence ) {
 
722
                // create a temporary entity for this event which is sent to everyone
 
723
                // except the client who generated the event
 
724
                seq = ps->entityEventSequence & (MAX_PS_EVENTS-1);
 
725
                event = ps->events[ seq ] | ( ( ps->entityEventSequence & 3 ) << 8 );
 
726
                // set external event to zero before calling BG_PlayerStateToEntityState
 
727
                extEvent = ps->externalEvent;
 
728
                ps->externalEvent = 0;
 
729
                // create temporary entity for event
 
730
                t = G_TempEntity( ps->origin, event );
 
731
                number = t->s.number;
 
732
                BG_PlayerStateToEntityState( ps, &t->s, qtrue );
 
733
                t->s.number = number;
 
734
                t->s.eType = ET_EVENTS + event;
 
735
                t->s.eFlags |= EF_PLAYER_EVENT;
 
736
                t->s.otherEntityNum = ps->clientNum;
 
737
                // send to everyone except the client who generated the event
 
738
                t->r.svFlags |= SVF_NOTSINGLECLIENT;
 
739
                t->r.singleClient = ps->clientNum;
 
740
                // set back external event
 
741
                ps->externalEvent = extEvent;
 
742
        }
 
743
}
 
744
 
 
745
/*
 
746
==============
 
747
ClientThink
 
748
 
 
749
This will be called once for each client frame, which will
 
750
usually be a couple times for each server frame on fast clients.
 
751
 
 
752
If "g_synchronousClients 1" is set, this will be called exactly
 
753
once for each server frame, which makes for smooth demo recording.
 
754
==============
 
755
*/
 
756
void ClientThink_real( gentity_t *ent ) {
 
757
        gclient_t       *client;
 
758
        pmove_t         pm;
 
759
        int                     oldEventSequence;
 
760
        int                     msec;
 
761
        usercmd_t       *ucmd;
 
762
 
 
763
        client = ent->client;
 
764
 
 
765
        // don't think if the client is not yet connected (and thus not yet spawned in)
 
766
        if (client->pers.connected != CON_CONNECTED) {
 
767
                return;
 
768
        }
 
769
        // mark the time, so the connection sprite can be removed
 
770
        ucmd = &ent->client->pers.cmd;
 
771
 
 
772
        // sanity check the command time to prevent speedup cheating
 
773
        if ( ucmd->serverTime > level.time + 200 ) {
 
774
                ucmd->serverTime = level.time + 200;
 
775
//              G_Printf("serverTime <<<<<\n" );
 
776
        }
 
777
        if ( ucmd->serverTime < level.time - 1000 ) {
 
778
                ucmd->serverTime = level.time - 1000;
 
779
//              G_Printf("serverTime >>>>>\n" );
 
780
        } 
 
781
 
 
782
        msec = ucmd->serverTime - client->ps.commandTime;
 
783
        // following others may result in bad times, but we still want
 
784
        // to check for follow toggles
 
785
        if ( msec < 1 && client->sess.spectatorState != SPECTATOR_FOLLOW ) {
 
786
                return;
 
787
        }
 
788
        if ( msec > 200 ) {
 
789
                msec = 200;
 
790
        }
 
791
 
 
792
        if ( pmove_msec.integer < 8 ) {
 
793
                trap_Cvar_Set("pmove_msec", "8");
 
794
        }
 
795
        else if (pmove_msec.integer > 33) {
 
796
                trap_Cvar_Set("pmove_msec", "33");
 
797
        }
 
798
 
 
799
        if ( pmove_fixed.integer || client->pers.pmoveFixed ) {
 
800
                ucmd->serverTime = ((ucmd->serverTime + pmove_msec.integer-1) / pmove_msec.integer) * pmove_msec.integer;
 
801
                //if (ucmd->serverTime - client->ps.commandTime <= 0)
 
802
                //      return;
 
803
        }
 
804
 
 
805
        //
 
806
        // check for exiting intermission
 
807
        //
 
808
        if ( level.intermissiontime ) {
 
809
                ClientIntermissionThink( client );
 
810
                return;
 
811
        }
 
812
 
 
813
        // spectators don't do much
 
814
        if ( client->sess.sessionTeam == TEAM_SPECTATOR ) {
 
815
                if ( client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
 
816
                        return;
 
817
                }
 
818
                SpectatorThink( ent, ucmd );
 
819
                return;
 
820
        }
 
821
 
 
822
        // check for inactivity timer, but never drop the local client of a non-dedicated server
 
823
        if ( !ClientInactivityTimer( client ) ) {
 
824
                return;
 
825
        }
 
826
 
 
827
        // clear the rewards if time
 
828
        if ( level.time > client->rewardTime ) {
 
829
                client->ps.eFlags &= ~(EF_AWARD_IMPRESSIVE | EF_AWARD_EXCELLENT | EF_AWARD_GAUNTLET | EF_AWARD_ASSIST | EF_AWARD_DEFEND | EF_AWARD_CAP );
 
830
        }
 
831
 
 
832
        if ( client->noclip ) {
 
833
                client->ps.pm_type = PM_NOCLIP;
 
834
        } else if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
 
835
                client->ps.pm_type = PM_DEAD;
 
836
        } else {
 
837
                client->ps.pm_type = PM_NORMAL;
 
838
        }
 
839
 
 
840
        client->ps.gravity = g_gravity.value;
 
841
 
 
842
        // set speed
 
843
        client->ps.speed = g_speed.value;
 
844
 
 
845
#ifdef MISSIONPACK
 
846
        if( bg_itemlist[client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_SCOUT ) {
 
847
                client->ps.speed *= 1.5;
 
848
        }
 
849
        else
 
850
#endif
 
851
        if ( client->ps.powerups[PW_HASTE] ) {
 
852
                client->ps.speed *= 1.3;
 
853
        }
 
854
 
 
855
        // Let go of the hook if we aren't firing
 
856
        if ( client->ps.weapon == WP_GRAPPLING_HOOK &&
 
857
                client->hook && !( ucmd->buttons & BUTTON_ATTACK ) ) {
 
858
                Weapon_HookFree(client->hook);
 
859
        }
 
860
 
 
861
        // set up for pmove
 
862
        oldEventSequence = client->ps.eventSequence;
 
863
 
 
864
        memset (&pm, 0, sizeof(pm));
 
865
 
 
866
        // check for the hit-scan gauntlet, don't let the action
 
867
        // go through as an attack unless it actually hits something
 
868
        if ( client->ps.weapon == WP_GAUNTLET && !( ucmd->buttons & BUTTON_TALK ) &&
 
869
                ( ucmd->buttons & BUTTON_ATTACK ) && client->ps.weaponTime <= 0 ) {
 
870
                pm.gauntletHit = CheckGauntletAttack( ent );
 
871
        }
 
872
 
 
873
        if ( ent->flags & FL_FORCE_GESTURE ) {
 
874
                ent->flags &= ~FL_FORCE_GESTURE;
 
875
                ent->client->pers.cmd.buttons |= BUTTON_GESTURE;
 
876
        }
 
877
 
 
878
#ifdef MISSIONPACK
 
879
        // check for invulnerability expansion before doing the Pmove
 
880
        if (client->ps.powerups[PW_INVULNERABILITY] ) {
 
881
                if ( !(client->ps.pm_flags & PMF_INVULEXPAND) ) {
 
882
                        vec3_t mins = { -42, -42, -42 };
 
883
                        vec3_t maxs = { 42, 42, 42 };
 
884
                        vec3_t oldmins, oldmaxs;
 
885
 
 
886
                        VectorCopy (ent->r.mins, oldmins);
 
887
                        VectorCopy (ent->r.maxs, oldmaxs);
 
888
                        // expand
 
889
                        VectorCopy (mins, ent->r.mins);
 
890
                        VectorCopy (maxs, ent->r.maxs);
 
891
                        trap_LinkEntity(ent);
 
892
                        // check if this would get anyone stuck in this player
 
893
                        if ( !StuckInOtherClient(ent) ) {
 
894
                                // set flag so the expanded size will be set in PM_CheckDuck
 
895
                                client->ps.pm_flags |= PMF_INVULEXPAND;
 
896
                        }
 
897
                        // set back
 
898
                        VectorCopy (oldmins, ent->r.mins);
 
899
                        VectorCopy (oldmaxs, ent->r.maxs);
 
900
                        trap_LinkEntity(ent);
 
901
                }
 
902
        }
 
903
#endif
 
904
 
 
905
        pm.ps = &client->ps;
 
906
        pm.cmd = *ucmd;
 
907
        if ( pm.ps->pm_type == PM_DEAD ) {
 
908
                pm.tracemask = MASK_PLAYERSOLID & ~CONTENTS_BODY;
 
909
        }
 
910
        else if ( ent->r.svFlags & SVF_BOT ) {
 
911
                pm.tracemask = MASK_PLAYERSOLID | CONTENTS_BOTCLIP;
 
912
        }
 
913
        else {
 
914
                pm.tracemask = MASK_PLAYERSOLID;
 
915
        }
 
916
        pm.trace = trap_Trace;
 
917
        pm.pointcontents = trap_PointContents;
 
918
        pm.debugLevel = g_debugMove.integer;
 
919
        pm.noFootsteps = ( g_dmflags.integer & DF_NO_FOOTSTEPS ) > 0;
 
920
 
 
921
        pm.pmove_fixed = pmove_fixed.integer | client->pers.pmoveFixed;
 
922
        pm.pmove_msec = pmove_msec.integer;
 
923
 
 
924
        VectorCopy( client->ps.origin, client->oldOrigin );
 
925
 
 
926
#ifdef MISSIONPACK
 
927
                if (level.intermissionQueued != 0 && g_singlePlayer.integer) {
 
928
                        if ( level.time - level.intermissionQueued >= 1000  ) {
 
929
                                pm.cmd.buttons = 0;
 
930
                                pm.cmd.forwardmove = 0;
 
931
                                pm.cmd.rightmove = 0;
 
932
                                pm.cmd.upmove = 0;
 
933
                                if ( level.time - level.intermissionQueued >= 2000 && level.time - level.intermissionQueued <= 2500 ) {
 
934
                                        trap_SendConsoleCommand( EXEC_APPEND, "centerview\n");
 
935
                                }
 
936
                                ent->client->ps.pm_type = PM_SPINTERMISSION;
 
937
                        }
 
938
                }
 
939
                Pmove (&pm);
 
940
#else
 
941
                Pmove (&pm);
 
942
#endif
 
943
 
 
944
        // save results of pmove
 
945
        if ( ent->client->ps.eventSequence != oldEventSequence ) {
 
946
                ent->eventTime = level.time;
 
947
        }
 
948
        if (g_smoothClients.integer) {
 
949
                BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
 
950
        }
 
951
        else {
 
952
                BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
 
953
        }
 
954
        SendPendingPredictableEvents( &ent->client->ps );
 
955
 
 
956
        if ( !( ent->client->ps.eFlags & EF_FIRING ) ) {
 
957
                client->fireHeld = qfalse;              // for grapple
 
958
        }
 
959
 
 
960
        // use the snapped origin for linking so it matches client predicted versions
 
961
        VectorCopy( ent->s.pos.trBase, ent->r.currentOrigin );
 
962
 
 
963
        VectorCopy (pm.mins, ent->r.mins);
 
964
        VectorCopy (pm.maxs, ent->r.maxs);
 
965
 
 
966
        ent->waterlevel = pm.waterlevel;
 
967
        ent->watertype = pm.watertype;
 
968
 
 
969
        // execute client events
 
970
        ClientEvents( ent, oldEventSequence );
 
971
 
 
972
        // link entity now, after any personal teleporters have been used
 
973
        trap_LinkEntity (ent);
 
974
        if ( !ent->client->noclip ) {
 
975
                G_TouchTriggers( ent );
 
976
        }
 
977
 
 
978
        // NOTE: now copy the exact origin over otherwise clients can be snapped into solid
 
979
        VectorCopy( ent->client->ps.origin, ent->r.currentOrigin );
 
980
 
 
981
        //test for solid areas in the AAS file
 
982
        BotTestAAS(ent->r.currentOrigin);
 
983
 
 
984
        // touch other objects
 
985
        ClientImpacts( ent, &pm );
 
986
 
 
987
        // save results of triggers and client events
 
988
        if (ent->client->ps.eventSequence != oldEventSequence) {
 
989
                ent->eventTime = level.time;
 
990
        }
 
991
 
 
992
        // swap and latch button actions
 
993
        client->oldbuttons = client->buttons;
 
994
        client->buttons = ucmd->buttons;
 
995
        client->latched_buttons |= client->buttons & ~client->oldbuttons;
 
996
 
 
997
        // check for respawning
 
998
        if ( client->ps.stats[STAT_HEALTH] <= 0 ) {
 
999
                // wait for the attack button to be pressed
 
1000
                if ( level.time > client->respawnTime ) {
 
1001
                        // forcerespawn is to prevent users from waiting out powerups
 
1002
                        if ( g_forcerespawn.integer > 0 && 
 
1003
                                ( level.time - client->respawnTime ) > g_forcerespawn.integer * 1000 ) {
 
1004
                                respawn( ent );
 
1005
                                return;
 
1006
                        }
 
1007
                
 
1008
                        // pressing attack or use is the normal respawn method
 
1009
                        if ( ucmd->buttons & ( BUTTON_ATTACK | BUTTON_USE_HOLDABLE ) ) {
 
1010
                                respawn( ent );
 
1011
                        }
 
1012
                }
 
1013
                return;
 
1014
        }
 
1015
 
 
1016
        // perform once-a-second actions
 
1017
        ClientTimerActions( ent, msec );
 
1018
}
 
1019
 
 
1020
/*
 
1021
==================
 
1022
ClientThink
 
1023
 
 
1024
A new command has arrived from the client
 
1025
==================
 
1026
*/
 
1027
void ClientThink( int clientNum ) {
 
1028
        gentity_t *ent;
 
1029
 
 
1030
        ent = g_entities + clientNum;
 
1031
        trap_GetUsercmd( clientNum, &ent->client->pers.cmd );
 
1032
 
 
1033
        // mark the time we got info, so we can display the
 
1034
        // phone jack if they don't get any for a while
 
1035
        ent->client->lastCmdTime = level.time;
 
1036
 
 
1037
        if ( !(ent->r.svFlags & SVF_BOT) && !g_synchronousClients.integer ) {
 
1038
                ClientThink_real( ent );
 
1039
        }
 
1040
}
 
1041
 
 
1042
 
 
1043
void G_RunClient( gentity_t *ent ) {
 
1044
        if ( !(ent->r.svFlags & SVF_BOT) && !g_synchronousClients.integer ) {
 
1045
                return;
 
1046
        }
 
1047
        ent->client->pers.cmd.serverTime = level.time;
 
1048
        ClientThink_real( ent );
 
1049
}
 
1050
 
 
1051
 
 
1052
/*
 
1053
==================
 
1054
SpectatorClientEndFrame
 
1055
 
 
1056
==================
 
1057
*/
 
1058
void SpectatorClientEndFrame( gentity_t *ent ) {
 
1059
        gclient_t       *cl;
 
1060
 
 
1061
        // if we are doing a chase cam or a remote view, grab the latest info
 
1062
        if ( ent->client->sess.spectatorState == SPECTATOR_FOLLOW ) {
 
1063
                int             clientNum, flags;
 
1064
 
 
1065
                clientNum = ent->client->sess.spectatorClient;
 
1066
 
 
1067
                // team follow1 and team follow2 go to whatever clients are playing
 
1068
                if ( clientNum == -1 ) {
 
1069
                        clientNum = level.follow1;
 
1070
                } else if ( clientNum == -2 ) {
 
1071
                        clientNum = level.follow2;
 
1072
                }
 
1073
                if ( clientNum >= 0 ) {
 
1074
                        cl = &level.clients[ clientNum ];
 
1075
                        if ( cl->pers.connected == CON_CONNECTED && cl->sess.sessionTeam != TEAM_SPECTATOR ) {
 
1076
                                flags = (cl->ps.eFlags & ~(EF_VOTED | EF_TEAMVOTED)) | (ent->client->ps.eFlags & (EF_VOTED | EF_TEAMVOTED));
 
1077
                                ent->client->ps = cl->ps;
 
1078
                                ent->client->ps.pm_flags |= PMF_FOLLOW;
 
1079
                                ent->client->ps.eFlags = flags;
 
1080
                                return;
 
1081
                        } else {
 
1082
                                // drop them to free spectators unless they are dedicated camera followers
 
1083
                                if ( ent->client->sess.spectatorClient >= 0 ) {
 
1084
                                        ent->client->sess.spectatorState = SPECTATOR_FREE;
 
1085
                                        ClientBegin( ent->client - level.clients );
 
1086
                                }
 
1087
                        }
 
1088
                }
 
1089
        }
 
1090
 
 
1091
        if ( ent->client->sess.spectatorState == SPECTATOR_SCOREBOARD ) {
 
1092
                ent->client->ps.pm_flags |= PMF_SCOREBOARD;
 
1093
        } else {
 
1094
                ent->client->ps.pm_flags &= ~PMF_SCOREBOARD;
 
1095
        }
 
1096
}
 
1097
 
 
1098
/*
 
1099
==============
 
1100
ClientEndFrame
 
1101
 
 
1102
Called at the end of each server frame for each connected client
 
1103
A fast client will have multiple ClientThink for each ClientEdFrame,
 
1104
while a slow client may have multiple ClientEndFrame between ClientThink.
 
1105
==============
 
1106
*/
 
1107
void ClientEndFrame( gentity_t *ent ) {
 
1108
        int                     i;
 
1109
        clientPersistant_t      *pers;
 
1110
 
 
1111
        if ( ent->client->sess.sessionTeam == TEAM_SPECTATOR ) {
 
1112
                SpectatorClientEndFrame( ent );
 
1113
                return;
 
1114
        }
 
1115
 
 
1116
        pers = &ent->client->pers;
 
1117
 
 
1118
        // turn off any expired powerups
 
1119
        for ( i = 0 ; i < MAX_POWERUPS ; i++ ) {
 
1120
                if ( ent->client->ps.powerups[ i ] < level.time ) {
 
1121
                        ent->client->ps.powerups[ i ] = 0;
 
1122
                }
 
1123
        }
 
1124
 
 
1125
#ifdef MISSIONPACK
 
1126
        // set powerup for player animation
 
1127
        if( bg_itemlist[ent->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_GUARD ) {
 
1128
                ent->client->ps.powerups[PW_GUARD] = level.time;
 
1129
        }
 
1130
        if( bg_itemlist[ent->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_SCOUT ) {
 
1131
                ent->client->ps.powerups[PW_SCOUT] = level.time;
 
1132
        }
 
1133
        if( bg_itemlist[ent->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_DOUBLER ) {
 
1134
                ent->client->ps.powerups[PW_DOUBLER] = level.time;
 
1135
        }
 
1136
        if( bg_itemlist[ent->client->ps.stats[STAT_PERSISTANT_POWERUP]].giTag == PW_AMMOREGEN ) {
 
1137
                ent->client->ps.powerups[PW_AMMOREGEN] = level.time;
 
1138
        }
 
1139
        if ( ent->client->invulnerabilityTime > level.time ) {
 
1140
                ent->client->ps.powerups[PW_INVULNERABILITY] = level.time;
 
1141
        }
 
1142
#endif
 
1143
 
 
1144
        // save network bandwidth
 
1145
#if 0
 
1146
        if ( !g_synchronousClients->integer && ent->client->ps.pm_type == PM_NORMAL ) {
 
1147
                // FIXME: this must change eventually for non-sync demo recording
 
1148
                VectorClear( ent->client->ps.viewangles );
 
1149
        }
 
1150
#endif
 
1151
 
 
1152
        //
 
1153
        // If the end of unit layout is displayed, don't give
 
1154
        // the player any normal movement attributes
 
1155
        //
 
1156
        if ( level.intermissiontime ) {
 
1157
                return;
 
1158
        }
 
1159
 
 
1160
        // burn from lava, etc
 
1161
        P_WorldEffects (ent);
 
1162
 
 
1163
        // apply all the damage taken this frame
 
1164
        P_DamageFeedback (ent);
 
1165
 
 
1166
        // add the EF_CONNECTION flag if we haven't gotten commands recently
 
1167
        if ( level.time - ent->client->lastCmdTime > 1000 ) {
 
1168
                ent->s.eFlags |= EF_CONNECTION;
 
1169
        } else {
 
1170
                ent->s.eFlags &= ~EF_CONNECTION;
 
1171
        }
 
1172
 
 
1173
        ent->client->ps.stats[STAT_HEALTH] = ent->health;       // FIXME: get rid of ent->health...
 
1174
 
 
1175
        G_SetClientSound (ent);
 
1176
 
 
1177
        // set the latest infor
 
1178
        if (g_smoothClients.integer) {
 
1179
                BG_PlayerStateToEntityStateExtraPolate( &ent->client->ps, &ent->s, ent->client->ps.commandTime, qtrue );
 
1180
        }
 
1181
        else {
 
1182
                BG_PlayerStateToEntityState( &ent->client->ps, &ent->s, qtrue );
 
1183
        }
 
1184
        SendPendingPredictableEvents( &ent->client->ps );
 
1185
 
 
1186
        // set the bit for the reachability area the client is currently in
 
1187
//      i = trap_AAS_PointReachabilityAreaIndex( ent->client->ps.origin );
 
1188
//      ent->client->areabits[i >> 3] |= 1 << (i & 7);
 
1189
}
 
1190
 
 
1191