![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to p_client.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Quake II] / quake2 / ctf|
Return to p_client.c CVS log | Up to [Quake II] / quake2 / ctf |
1.1 root 1: #include "g_local.h"
2: #include "m_player.h"
3:
4: void ClientUserinfoChanged (edict_t *ent, char *userinfo);
5:
6: void SP_misc_teleporter_dest (edict_t *ent);
7:
8: //
9: // Gross, ugly, disgustuing hack section
10: //
11:
12: // this function is an ugly as hell hack to fix some map flaws
13: //
14: // the coop spawn spots on some maps are SNAFU. There are coop spots
15: // with the wrong targetname as well as spots with no name at all
16: //
17: // we use carnal knowledge of the maps to fix the coop spot targetnames to match
18: // that of the nearest named single player spot
19:
20: static void SP_FixCoopSpots (edict_t *self)
21: {
22: edict_t *spot;
23: vec3_t d;
24:
25: spot = NULL;
26:
27: while(1)
28: {
29: spot = G_Find(spot, FOFS(classname), "info_player_start");
30: if (!spot)
31: return;
32: if (!spot->targetname)
33: continue;
34: VectorSubtract(self->s.origin, spot->s.origin, d);
35: if (VectorLength(d) < 384)
36: {
37: if ((!self->targetname) || stricmp(self->targetname, spot->targetname) != 0)
38: {
39: // gi.dprintf("FixCoopSpots changed %s at %s targetname from %s to %s\n", self->classname, vtos(self->s.origin), self->targetname, spot->targetname);
40: self->targetname = spot->targetname;
41: }
42: return;
43: }
44: }
45: }
46:
47: // now if that one wasn't ugly enough for you then try this one on for size
48: // some maps don't have any coop spots at all, so we need to create them
49: // where they should have been
50:
51: static void SP_CreateCoopSpots (edict_t *self)
52: {
53: edict_t *spot;
54:
55: if(stricmp(level.mapname, "security") == 0)
56: {
57: spot = G_Spawn();
58: spot->classname = "info_player_coop";
59: spot->s.origin[0] = 188 - 64;
60: spot->s.origin[1] = -164;
61: spot->s.origin[2] = 80;
62: spot->targetname = "jail3";
63: spot->s.angles[1] = 90;
64:
65: spot = G_Spawn();
66: spot->classname = "info_player_coop";
67: spot->s.origin[0] = 188 + 64;
68: spot->s.origin[1] = -164;
69: spot->s.origin[2] = 80;
70: spot->targetname = "jail3";
71: spot->s.angles[1] = 90;
72:
73: spot = G_Spawn();
74: spot->classname = "info_player_coop";
75: spot->s.origin[0] = 188 + 128;
76: spot->s.origin[1] = -164;
77: spot->s.origin[2] = 80;
78: spot->targetname = "jail3";
79: spot->s.angles[1] = 90;
80:
81: return;
82: }
83: }
84:
85:
86: /*QUAKED info_player_start (1 0 0) (-16 -16 -24) (16 16 32)
87: The normal starting point for a level.
88: */
89: void SP_info_player_start(edict_t *self)
90: {
91: if (!coop->value)
92: return;
93: if(stricmp(level.mapname, "security") == 0)
94: {
95: // invoke one of our gross, ugly, disgusting hacks
96: self->think = SP_CreateCoopSpots;
97: self->nextthink = level.time + FRAMETIME;
98: }
99: }
100:
101: /*QUAKED info_player_deathmatch (1 0 1) (-16 -16 -24) (16 16 32)
102: potential spawning position for deathmatch games
103: */
104: void SP_info_player_deathmatch(edict_t *self)
105: {
106: if (!deathmatch->value)
107: {
108: G_FreeEdict (self);
109: return;
110: }
111: SP_misc_teleporter_dest (self);
112: }
113:
114: /*QUAKED info_player_coop (1 0 1) (-16 -16 -24) (16 16 32)
115: potential spawning position for coop games
116: */
117:
118: void SP_info_player_coop(edict_t *self)
119: {
120: if (!coop->value)
121: {
122: G_FreeEdict (self);
123: return;
124: }
125:
126: if((stricmp(level.mapname, "jail2") == 0) ||
127: (stricmp(level.mapname, "jail4") == 0) ||
128: (stricmp(level.mapname, "mine1") == 0) ||
129: (stricmp(level.mapname, "mine2") == 0) ||
130: (stricmp(level.mapname, "mine3") == 0) ||
131: (stricmp(level.mapname, "mine4") == 0) ||
132: (stricmp(level.mapname, "lab") == 0) ||
133: (stricmp(level.mapname, "boss1") == 0) ||
134: (stricmp(level.mapname, "fact3") == 0) ||
135: (stricmp(level.mapname, "biggun") == 0) ||
136: (stricmp(level.mapname, "space") == 0) ||
137: (stricmp(level.mapname, "command") == 0) ||
138: (stricmp(level.mapname, "power2") == 0) ||
139: (stricmp(level.mapname, "strike") == 0))
140: {
141: // invoke one of our gross, ugly, disgusting hacks
142: self->think = SP_FixCoopSpots;
143: self->nextthink = level.time + FRAMETIME;
144: }
145: }
146:
147:
148: /*QUAKED info_player_intermission (1 0 1) (-16 -16 -24) (16 16 32)
149: The deathmatch intermission point will be at one of these
150: Use 'angles' instead of 'angle', so you can set pitch or roll as well as yaw. 'pitch yaw roll'
151: */
152: void SP_info_player_intermission(void)
153: {
154: }
155:
156:
157: //=======================================================================
158:
159:
160: void player_pain (edict_t *self, edict_t *other, float kick, int damage)
161: {
162: // player pain is handled at the end of the frame in P_DamageFeedback
163: }
164:
165:
166: qboolean IsFemale (edict_t *ent)
167: {
168: char *info;
169:
170: if (!ent->client)
171: return false;
172:
173: info = Info_ValueForKey (ent->client->pers.userinfo, "skin");
174: if (info[0] == 'f' || info[0] == 'F')
175: return true;
176: return false;
177: }
178:
179:
180: void ClientObituary (edict_t *self, edict_t *inflictor, edict_t *attacker)
181: {
182: int mod;
183: char *message;
184: char *message2;
185: qboolean ff;
186:
187:
188: if (coop->value && attacker->client)
189: meansOfDeath |= MOD_FRIENDLY_FIRE;
190:
191: if (deathmatch->value || coop->value)
192: {
193: ff = meansOfDeath & MOD_FRIENDLY_FIRE;
194: mod = meansOfDeath & ~MOD_FRIENDLY_FIRE;
195: message = NULL;
196: message2 = "";
197:
198: switch (mod)
199: {
200: case MOD_SUICIDE:
201: message = "suicides";
202: break;
203: case MOD_FALLING:
204: message = "cratered";
205: break;
206: case MOD_CRUSH:
207: message = "was squished";
208: break;
209: case MOD_WATER:
210: message = "sank like a rock";
211: break;
212: case MOD_SLIME:
213: message = "melted";
214: break;
215: case MOD_LAVA:
216: message = "does a back flip into the lava";
217: break;
218: case MOD_EXPLOSIVE:
219: case MOD_BARREL:
220: message = "blew up";
221: break;
222: case MOD_EXIT:
223: message = "found a way out";
224: break;
225: case MOD_TARGET_LASER:
226: message = "saw the light";
227: break;
228: case MOD_TARGET_BLASTER:
229: message = "got blasted";
230: break;
231: case MOD_BOMB:
232: case MOD_SPLASH:
233: case MOD_TRIGGER_HURT:
234: message = "was in the wrong place";
235: break;
236: }
237: if (attacker == self)
238: {
239: switch (mod)
240: {
241: case MOD_HELD_GRENADE:
242: message = "tried to put the pin back in";
243: break;
244: case MOD_HG_SPLASH:
245: case MOD_G_SPLASH:
246: if (IsFemale(self))
247: message = "tripped on her own grenade";
248: else
249: message = "tripped on his own grenade";
250: break;
251: case MOD_R_SPLASH:
252: if (IsFemale(self))
253: message = "blew herself up";
254: else
255: message = "blew himself up";
256: break;
257: case MOD_BFG_BLAST:
258: message = "should have used a smaller gun";
259: break;
260: default:
261: if (IsFemale(self))
262: message = "killed herself";
263: else
264: message = "killed himself";
265: break;
266: }
267: }
268: if (message)
269: {
270: gi.bprintf (PRINT_MEDIUM, "%s %s.\n", self->client->pers.netname, message);
271: if (deathmatch->value)
272: self->client->resp.score--;
273: self->enemy = NULL;
274: return;
275: }
276:
277: self->enemy = attacker;
278: if (attacker && attacker->client)
279: {
280: switch (mod)
281: {
282: case MOD_BLASTER:
283: message = "was blasted by";
284: break;
285: case MOD_SHOTGUN:
286: message = "was gunned down by";
287: break;
288: case MOD_SSHOTGUN:
289: message = "was blown away by";
290: message2 = "'s super shotgun";
291: break;
292: case MOD_MACHINEGUN:
293: message = "was machinegunned by";
294: break;
295: case MOD_CHAINGUN:
296: message = "was cut in half by";
297: message2 = "'s chaingun";
298: break;
299: case MOD_GRENADE:
300: message = "was popped by";
301: message2 = "'s grenade";
302: break;
303: case MOD_G_SPLASH:
304: message = "was shredded by";
305: message2 = "'s shrapnel";
306: break;
307: case MOD_ROCKET:
308: message = "ate";
309: message2 = "'s rocket";
310: break;
311: case MOD_R_SPLASH:
312: message = "almost dodged";
313: message2 = "'s rocket";
314: break;
315: case MOD_HYPERBLASTER:
316: message = "was melted by";
317: message2 = "'s hyperblaster";
318: break;
319: case MOD_RAILGUN:
320: message = "was railed by";
321: break;
322: case MOD_BFG_LASER:
323: message = "saw the pretty lights from";
324: message2 = "'s BFG";
325: break;
326: case MOD_BFG_BLAST:
327: message = "was disintegrated by";
328: message2 = "'s BFG blast";
329: break;
330: case MOD_BFG_EFFECT:
331: message = "couldn't hide from";
332: message2 = "'s BFG";
333: break;
334: case MOD_HANDGRENADE:
335: message = "caught";
336: message2 = "'s handgrenade";
337: break;
338: case MOD_HG_SPLASH:
339: message = "didn't see";
340: message2 = "'s handgrenade";
341: break;
342: case MOD_HELD_GRENADE:
343: message = "feels";
344: message2 = "'s pain";
345: break;
346: case MOD_TELEFRAG:
347: message = "tried to invade";
348: message2 = "'s personal space";
349: break;
350: //ZOID
351: case MOD_GRAPPLE:
352: message = "was caught by";
353: message2 = "'s grapple";
354: break;
355: //ZOID
356:
357: }
358: if (message)
359: {
360: gi.bprintf (PRINT_MEDIUM,"%s %s %s%s\n", self->client->pers.netname, message, attacker->client->pers.netname, message2);
361: if (deathmatch->value)
362: {
363: if (ff)
364: attacker->client->resp.score--;
365: else
366: attacker->client->resp.score++;
367: }
368: return;
369: }
370: }
371: }
372:
373: gi.bprintf (PRINT_MEDIUM,"%s died.\n", self->client->pers.netname);
374: if (deathmatch->value)
375: self->client->resp.score--;
376: }
377:
378:
379: void Touch_Item (edict_t *ent, edict_t *other, cplane_t *plane, csurface_t *surf);
380:
381: void TossClientWeapon (edict_t *self)
382: {
383: gitem_t *item;
384: edict_t *drop;
385: qboolean quad;
386: float spread;
387:
388: if (!deathmatch->value)
389: return;
390:
391: item = self->client->pers.weapon;
392: if (! self->client->pers.inventory[self->client->ammo_index] )
393: item = NULL;
394: if (item && (strcmp (item->pickup_name, "Blaster") == 0))
395: item = NULL;
396:
397: if (!((int)(dmflags->value) & DF_QUAD_DROP))
398: quad = false;
399: else
400: quad = (self->client->quad_framenum > (level.framenum + 10));
401:
402: if (item && quad)
403: spread = 22.5;
404: else
405: spread = 0.0;
406:
407: if (item)
408: {
409: self->client->v_angle[YAW] -= spread;
410: drop = Drop_Item (self, item);
411: self->client->v_angle[YAW] += spread;
412: drop->spawnflags = DROPPED_PLAYER_ITEM;
413: }
414:
415: if (quad)
416: {
417: self->client->v_angle[YAW] += spread;
418: drop = Drop_Item (self, FindItemByClassname ("item_quad"));
419: self->client->v_angle[YAW] -= spread;
420: drop->spawnflags |= DROPPED_PLAYER_ITEM;
421:
422: drop->touch = Touch_Item;
423: drop->nextthink = level.time + (self->client->quad_framenum - level.framenum) * FRAMETIME;
424: drop->think = G_FreeEdict;
425: }
426: }
427:
428:
429: /*
430: ==================
431: LookAtKiller
432: ==================
433: */
434: void LookAtKiller (edict_t *self, edict_t *inflictor, edict_t *attacker)
435: {
436: vec3_t dir;
437:
438: if (attacker && attacker != world && attacker != self)
439: {
440: VectorSubtract (attacker->s.origin, self->s.origin, dir);
441: }
442: else if (inflictor && inflictor != world && inflictor != self)
443: {
444: VectorSubtract (inflictor->s.origin, self->s.origin, dir);
445: }
446: else
447: {
448: self->client->killer_yaw = self->s.angles[YAW];
449: return;
450: }
451:
452: if (dir[0])
453: self->client->killer_yaw = 180/M_PI*atan2(dir[1], dir[0]);
454: else {
455: self->client->killer_yaw = 0;
456: if (dir[1] > 0)
457: self->client->killer_yaw = 90;
458: else if (dir[1] < 0)
459: self->client->killer_yaw = -90;
460: }
461: if (self->client->killer_yaw < 0)
462: self->client->killer_yaw += 360;
463: }
464:
465: /*
466: ==================
467: player_die
468: ==================
469: */
470: void player_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
471: {
472: int n;
473:
474: VectorClear (self->avelocity);
475:
476: self->takedamage = DAMAGE_YES;
477: self->movetype = MOVETYPE_TOSS;
478:
479: self->s.modelindex2 = 0; // remove linked weapon model
480: //ZOID
481: self->s.modelindex3 = 0; // remove linked ctf flag
482: //ZOID
483:
484: self->s.angles[0] = 0;
485: self->s.angles[2] = 0;
486:
487: self->s.sound = 0;
488: self->client->weapon_sound = 0;
489:
490: self->maxs[2] = -8;
491:
492: // self->solid = SOLID_NOT;
493: self->svflags |= SVF_DEADMONSTER;
494:
495: if (!self->deadflag)
496: {
497: self->client->respawn_time = level.time + 1.0;
498: LookAtKiller (self, inflictor, attacker);
499: self->client->ps.pmove.pm_type = PM_DEAD;
500: ClientObituary (self, inflictor, attacker);
501: //ZOID
502: // if at start and same team, clear
503: if (ctf->value && meansOfDeath == MOD_TELEFRAG &&
504: self->client->resp.ctf_state < 2 &&
505: self->client->resp.ctf_team == attacker->client->resp.ctf_team) {
506: attacker->client->resp.score--;
507: self->client->resp.ctf_state = 0;
508: }
509:
510: CTFFragBonuses(self, inflictor, attacker);
511: //ZOID
512: TossClientWeapon (self);
513: //ZOID
514: CTFPlayerResetGrapple(self);
515: CTFDeadDropFlag(self);
516: CTFDeadDropTech(self);
517: //ZOID
518: if (deathmatch->value && !self->client->showscores)
519: Cmd_Help_f (self); // show scores
520: }
521:
522: // remove powerups
523: self->client->quad_framenum = 0;
524: self->client->invincible_framenum = 0;
525: self->client->breather_framenum = 0;
526: self->client->enviro_framenum = 0;
527:
528: // clear inventory
529: memset(self->client->pers.inventory, 0, sizeof(self->client->pers.inventory));
530:
531: if (self->health < -40)
532: { // gib
533: gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
534: for (n= 0; n < 4; n++)
535: ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
536: ThrowClientHead (self, damage);
537: //ZOID
538: self->client->anim_priority = ANIM_DEATH;
539: self->client->anim_end = 0;
540: //ZOID
541: self->takedamage = DAMAGE_NO;
542: }
543: else
544: { // normal death
545: if (!self->deadflag)
546: {
547: static int i;
548:
549: i = (i+1)%3;
550: // start a death animation
551: self->client->anim_priority = ANIM_DEATH;
552: if (self->client->ps.pmove.pm_flags & PMF_DUCKED)
553: {
554: self->s.frame = FRAME_crdeath1-1;
555: self->client->anim_end = FRAME_crdeath5;
556: }
557: else switch (i)
558: {
559: case 0:
560: self->s.frame = FRAME_death101-1;
561: self->client->anim_end = FRAME_death106;
562: break;
563: case 1:
564: self->s.frame = FRAME_death201-1;
565: self->client->anim_end = FRAME_death206;
566: break;
567: case 2:
568: self->s.frame = FRAME_death301-1;
569: self->client->anim_end = FRAME_death308;
570: break;
571: }
572: gi.sound (self, CHAN_VOICE, gi.soundindex(va("*death%i.wav", (rand()%4)+1)), 1, ATTN_NORM, 0);
573: }
574: }
575:
576: self->deadflag = DEAD_DEAD;
577:
578: gi.linkentity (self);
579: }
580:
581: //=======================================================================
582:
583: /*
584: ==============
585: InitClientPersistant
586:
587: This is only called when the game first initializes in single player,
588: but is called after each death and level change in deathmatch
589: ==============
590: */
591: void InitClientPersistant (gclient_t *client)
592: {
593: gitem_t *item;
594:
595: memset (&client->pers, 0, sizeof(client->pers));
596:
597: item = FindItem("Blaster");
598: client->pers.selected_item = ITEM_INDEX(item);
599: client->pers.inventory[client->pers.selected_item] = 1;
600:
601: client->pers.weapon = item;
602: //ZOID
603: client->pers.lastweapon = item;
604: //ZOID
605:
606: //ZOID
607: item = FindItem("Grapple");
608: client->pers.inventory[ITEM_INDEX(item)] = 1;
609: //ZOID
610:
611: client->pers.health = 100;
612: client->pers.max_health = 100;
613:
614: client->pers.max_bullets = 200;
615: client->pers.max_shells = 100;
616: client->pers.max_rockets = 50;
617: client->pers.max_grenades = 50;
618: client->pers.max_cells = 200;
619: client->pers.max_slugs = 50;
620:
621: client->pers.connected = true;
622: }
623:
624:
625: void InitClientResp (gclient_t *client)
626: {
627: //ZOID
628: int ctf_team = client->resp.ctf_team;
629: qboolean id_state = client->resp.id_state;
630: //ZOID
631:
632: memset (&client->resp, 0, sizeof(client->resp));
633:
634: //ZOID
635: client->resp.ctf_team = ctf_team;
636: client->resp.id_state = id_state;
637: //ZOID
638:
639: client->resp.enterframe = level.framenum;
640: client->resp.coop_respawn = client->pers;
641:
642: //ZOID
643: if (ctf->value && client->resp.ctf_team < CTF_TEAM1)
644: CTFAssignTeam(client);
645: //ZOID
646: }
647:
648: /*
649: ==================
650: SaveClientData
651:
652: Some information that should be persistant, like health,
653: is still stored in the edict structure, so it needs to
654: be mirrored out to the client structure before all the
655: edicts are wiped.
656: ==================
657: */
658: void SaveClientData (void)
659: {
660: int i;
661: edict_t *ent;
662:
663: for (i=0 ; i<game.maxclients ; i++)
664: {
665: ent = &g_edicts[1+i];
666: if (!ent->inuse)
667: continue;
668: game.clients[i].pers.health = ent->health;
669: game.clients[i].pers.max_health = ent->max_health;
670: game.clients[i].pers.powerArmorActive = (ent->flags & FL_POWER_ARMOR);
671: if (coop->value)
672: game.clients[i].pers.score = ent->client->resp.score;
673: }
674: }
675:
676: void FetchClientEntData (edict_t *ent)
677: {
678: ent->health = ent->client->pers.health;
679: ent->max_health = ent->client->pers.max_health;
680: if (ent->client->pers.powerArmorActive)
681: ent->flags |= FL_POWER_ARMOR;
682: if (coop->value)
683: ent->client->resp.score = ent->client->pers.score;
684: }
685:
686:
687:
688: /*
689: =======================================================================
690:
691: SelectSpawnPoint
692:
693: =======================================================================
694: */
695:
696: /*
697: ================
698: PlayersRangeFromSpot
699:
700: Returns the distance to the nearest player from the given spot
701: ================
702: */
703: float PlayersRangeFromSpot (edict_t *spot)
704: {
705: edict_t *player;
706: float bestplayerdistance;
707: vec3_t v;
708: int n;
709: float playerdistance;
710:
711:
712: bestplayerdistance = 9999999;
713:
714: for (n = 1; n <= maxclients->value; n++)
715: {
716: player = &g_edicts[n];
717:
718: if (!player->inuse)
719: continue;
720:
721: if (player->health <= 0)
722: continue;
723:
724: VectorSubtract (spot->s.origin, player->s.origin, v);
725: playerdistance = VectorLength (v);
726:
727: if (playerdistance < bestplayerdistance)
728: bestplayerdistance = playerdistance;
729: }
730:
731: return bestplayerdistance;
732: }
733:
734: /*
735: ================
736: SelectRandomDeathmatchSpawnPoint
737:
738: go to a random point, but NOT the two points closest
739: to other players
740: ================
741: */
742: edict_t *SelectRandomDeathmatchSpawnPoint (void)
743: {
744: edict_t *spot, *spot1, *spot2;
745: int count = 0;
746: int selection;
747: float range, range1, range2;
748:
749: spot = NULL;
750: range1 = range2 = 99999;
751: spot1 = spot2 = NULL;
752:
753: while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
754: {
755: count++;
756: range = PlayersRangeFromSpot(spot);
757: if (range < range1)
758: {
759: range1 = range;
760: spot1 = spot;
761: }
762: else if (range < range2)
763: {
764: range2 = range;
765: spot2 = spot;
766: }
767: }
768:
769: if (!count)
770: return NULL;
771:
772: if (count <= 2)
773: {
774: spot1 = spot2 = NULL;
775: }
776: else
777: count -= 2;
778:
779: selection = rand() % count;
780:
781: spot = NULL;
782: do
783: {
784: spot = G_Find (spot, FOFS(classname), "info_player_deathmatch");
785: if (spot == spot1 || spot == spot2)
786: selection++;
787: } while(selection--);
788:
789: return spot;
790: }
791:
792: /*
793: ================
794: SelectFarthestDeathmatchSpawnPoint
795:
796: ================
797: */
798: edict_t *SelectFarthestDeathmatchSpawnPoint (void)
799: {
800: edict_t *bestspot;
801: float bestdistance, bestplayerdistance;
802: edict_t *spot;
803:
804:
805: spot = NULL;
806: bestspot = NULL;
807: bestdistance = 0;
808: while ((spot = G_Find (spot, FOFS(classname), "info_player_deathmatch")) != NULL)
809: {
810: bestplayerdistance = PlayersRangeFromSpot (spot);
811:
812: if (bestplayerdistance > bestdistance)
813: {
814: bestspot = spot;
815: bestdistance = bestplayerdistance;
816: }
817: }
818:
819: if (bestspot)
820: {
821: return bestspot;
822: }
823:
824: // if there is a player just spawned on each and every start spot
825: // we have no choice to turn one into a telefrag meltdown
826: spot = G_Find (NULL, FOFS(classname), "info_player_deathmatch");
827:
828: return spot;
829: }
830:
831: edict_t *SelectDeathmatchSpawnPoint (void)
832: {
833: if ( (int)(dmflags->value) & DF_SPAWN_FARTHEST)
834: return SelectFarthestDeathmatchSpawnPoint ();
835: else
836: return SelectRandomDeathmatchSpawnPoint ();
837: }
838:
839:
840: edict_t *SelectCoopSpawnPoint (edict_t *ent)
841: {
842: int index;
843: edict_t *spot = NULL;
844: char *target;
845:
846: index = ent->client - game.clients;
847:
848: // player 0 starts in normal player spawn point
849: if (!index)
850: return NULL;
851:
852: spot = NULL;
853:
854: // assume there are four coop spots at each spawnpoint
855: while (1)
856: {
857: spot = G_Find (spot, FOFS(classname), "info_player_coop");
858: if (!spot)
859: return NULL; // we didn't have enough...
860:
861: target = spot->targetname;
862: if (!target)
863: target = "";
864: if ( Q_stricmp(game.spawnpoint, target) == 0 )
865: { // this is a coop spawn point for one of the clients here
866: index--;
867: if (!index)
868: return spot; // this is it
869: }
870: }
871:
872:
873: return spot;
874: }
875:
876:
877: /*
878: ===========
879: SelectSpawnPoint
880:
881: Chooses a player start, deathmatch start, coop start, etc
882: ============
883: */
884: void SelectSpawnPoint (edict_t *ent, vec3_t origin, vec3_t angles)
885: {
886: edict_t *spot = NULL;
887:
888: if (deathmatch->value)
889: //ZOID
890: if (ctf->value)
891: spot = SelectCTFSpawnPoint(ent);
892: else
893: //ZOID
894: spot = SelectDeathmatchSpawnPoint ();
895: else if (coop->value)
896: spot = SelectCoopSpawnPoint (ent);
897:
898: // find a single player start spot
899: if (!spot)
900: {
901: while ((spot = G_Find (spot, FOFS(classname), "info_player_start")) != NULL)
902: {
903: if (!game.spawnpoint[0] && !spot->targetname)
904: break;
905:
906: if (!game.spawnpoint[0] || !spot->targetname)
907: continue;
908:
909: if (Q_stricmp(game.spawnpoint, spot->targetname) == 0)
910: break;
911: }
912:
913: if (!spot)
914: {
915: if (!game.spawnpoint[0])
916: { // there wasn't a spawnpoint without a target, so use any
917: spot = G_Find (spot, FOFS(classname), "info_player_start");
918: }
919: if (!spot)
920: gi.error ("Couldn't find spawn point %s\n", game.spawnpoint);
921: }
922: }
923:
924: VectorCopy (spot->s.origin, origin);
925: origin[2] += 9;
926: VectorCopy (spot->s.angles, angles);
927: }
928:
929: //======================================================================
930:
931:
932: void InitBodyQue (void)
933: {
934: int i;
935: edict_t *ent;
936:
937: level.body_que = 0;
938: for (i=0; i<BODY_QUEUE_SIZE ; i++)
939: {
940: ent = G_Spawn();
941: ent->classname = "bodyque";
942: }
943: }
944:
945: void body_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
946: {
947: int n;
948:
949: if (self->health < -40)
950: {
951: gi.sound (self, CHAN_BODY, gi.soundindex ("misc/udeath.wav"), 1, ATTN_NORM, 0);
952: for (n= 0; n < 4; n++)
953: ThrowGib (self, "models/objects/gibs/sm_meat/tris.md2", damage, GIB_ORGANIC);
954: self->s.origin[2] -= 48;
955: ThrowClientHead (self, damage);
956: self->takedamage = DAMAGE_NO;
957: }
958: }
959:
960: void CopyToBodyQue (edict_t *ent)
961: {
962: edict_t *body;
963:
964:
965: // grab a body que and cycle to the next one
966: body = &g_edicts[(int)maxclients->value + level.body_que + 1];
967: level.body_que = (level.body_que + 1) % BODY_QUEUE_SIZE;
968:
969: // FIXME: send an effect on the removed body
970:
971: gi.unlinkentity (ent);
972:
973: gi.unlinkentity (body);
974: body->s = ent->s;
975: body->s.number = body - g_edicts;
976:
977: body->svflags = ent->svflags;
978: VectorCopy (ent->mins, body->mins);
979: VectorCopy (ent->maxs, body->maxs);
980: VectorCopy (ent->absmin, body->absmin);
981: VectorCopy (ent->absmax, body->absmax);
982: VectorCopy (ent->size, body->size);
983: body->solid = ent->solid;
984: body->clipmask = ent->clipmask;
985: body->owner = ent->owner;
986: body->movetype = ent->movetype;
987:
988: body->die = body_die;
989: body->takedamage = DAMAGE_YES;
990:
991: gi.linkentity (body);
992: }
993:
994:
995: void respawn (edict_t *self)
996: {
997: if (deathmatch->value || coop->value)
998: {
999: if (self->movetype != MOVETYPE_NOCLIP)
1000: CopyToBodyQue (self);
1001: self->svflags &= ~SVF_NOCLIENT;
1002: PutClientInServer (self);
1003:
1004: // add a teleportation effect
1005: self->s.event = EV_PLAYER_TELEPORT;
1006:
1007: // hold in place briefly
1008: self->client->ps.pmove.pm_flags = PMF_TIME_TELEPORT;
1009: self->client->ps.pmove.pm_time = 14;
1010:
1011: self->client->respawn_time = level.time;
1012:
1013: return;
1014: }
1015:
1016: // restart the entire server
1017: gi.AddCommandString ("menu_loadgame\n");
1018: }
1019:
1020: //==============================================================
1021:
1022:
1023: /*
1024: ===========
1025: PutClientInServer
1026:
1027: Called when a player connects to a server or respawns in
1028: a deathmatch.
1029: ============
1030: */
1031: void PutClientInServer (edict_t *ent)
1032: {
1033: vec3_t mins = {-16, -16, -24};
1034: vec3_t maxs = {16, 16, 32};
1035: int index;
1036: vec3_t spawn_origin, spawn_angles;
1037: gclient_t *client;
1038: int i;
1039: client_persistant_t saved;
1040: client_respawn_t resp;
1041:
1042: // find a spawn point
1043: // do it before setting health back up, so farthest
1044: // ranging doesn't count this client
1045: SelectSpawnPoint (ent, spawn_origin, spawn_angles);
1046:
1047: index = ent-g_edicts-1;
1048: client = ent->client;
1049:
1050: // deathmatch wipes most client data every spawn
1051: if (deathmatch->value)
1052: {
1053: char userinfo[MAX_INFO_STRING];
1054:
1055: resp = client->resp;
1056: memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
1057: InitClientPersistant (client);
1058: ClientUserinfoChanged (ent, userinfo);
1059: }
1060: else if (coop->value)
1061: {
1062: int n;
1063: char userinfo[MAX_INFO_STRING];
1064:
1065: resp = client->resp;
1066: memcpy (userinfo, client->pers.userinfo, sizeof(userinfo));
1067: // this is kind of ugly, but it's how we want to handle keys in coop
1068: for (n = 0; n < MAX_ITEMS; n++)
1069: {
1070: if (itemlist[n].flags & IT_KEY)
1071: resp.coop_respawn.inventory[n] = client->pers.inventory[n];
1072: }
1073: client->pers = resp.coop_respawn;
1074: ClientUserinfoChanged (ent, userinfo);
1075: if (resp.score > client->pers.score)
1076: client->pers.score = resp.score;
1077: }
1078: else
1079: {
1080: memset (&resp, 0, sizeof(resp));
1081: }
1082:
1083: // clear everything but the persistant data
1084: saved = client->pers;
1085: memset (client, 0, sizeof(*client));
1086: client->pers = saved;
1087: if (client->pers.health <= 0)
1088: InitClientPersistant(client);
1089: client->resp = resp;
1090:
1091: // copy some data from the client to the entity
1092: FetchClientEntData (ent);
1093:
1094: // clear entity values
1095: ent->groundentity = NULL;
1096: ent->client = &game.clients[index];
1097: ent->takedamage = DAMAGE_AIM;
1098: ent->movetype = MOVETYPE_WALK;
1099: ent->viewheight = 22;
1100: ent->inuse = true;
1101: ent->classname = "player";
1102: ent->mass = 200;
1103: ent->solid = SOLID_BBOX;
1104: ent->deadflag = DEAD_NO;
1105: ent->air_finished = level.time + 12;
1106: ent->clipmask = MASK_PLAYERSOLID;
1107: ent->model = "players/male/tris.md2";
1108: ent->pain = player_pain;
1109: ent->die = player_die;
1110: ent->waterlevel = 0;
1111: ent->watertype = 0;
1112: ent->flags &= ~FL_NO_KNOCKBACK;
1113: ent->svflags &= ~SVF_DEADMONSTER;
1114:
1115: VectorCopy (mins, ent->mins);
1116: VectorCopy (maxs, ent->maxs);
1117: VectorClear (ent->velocity);
1118:
1119: // clear playerstate values
1120: memset (&ent->client->ps, 0, sizeof(client->ps));
1121:
1122: client->ps.pmove.origin[0] = spawn_origin[0]*8;
1123: client->ps.pmove.origin[1] = spawn_origin[1]*8;
1124: client->ps.pmove.origin[2] = spawn_origin[2]*8;
1125: //ZOID
1126: client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION;
1127: //ZOID
1128:
1129: if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
1130: {
1131: client->ps.fov = 90;
1132: }
1133: else
1134: {
1135: client->ps.fov = atoi(Info_ValueForKey(client->pers.userinfo, "fov"));
1136: if (client->ps.fov < 1)
1137: client->ps.fov = 90;
1138: else if (client->ps.fov > 160)
1139: client->ps.fov = 160;
1140: }
1141:
1142: client->ps.gunindex = gi.modelindex(client->pers.weapon->view_model);
1143:
1144: // clear entity state values
1145: ent->s.effects = 0;
1146: ent->s.skinnum = ent - g_edicts - 1;
1147: ent->s.modelindex = 255; // will use the skin specified model
1148: ent->s.modelindex2 = 255; // custom gun model
1149: // sknum is player num and weapon number
1150: // weapon number will be added in changeweapon
1151: ent->s.skinnum = ent - g_edicts - 1;
1152:
1153: ent->s.frame = 0;
1154: VectorCopy (spawn_origin, ent->s.origin);
1155: ent->s.origin[2] += 1; // make sure off ground
1156: VectorCopy (ent->s.origin, ent->s.old_origin);
1157:
1158: // set the delta angle
1159: for (i=0 ; i<3 ; i++)
1160: client->ps.pmove.delta_angles[i] = ANGLE2SHORT(spawn_angles[i] - client->resp.cmd_angles[i]);
1161:
1162: ent->s.angles[PITCH] = 0;
1163: ent->s.angles[YAW] = spawn_angles[YAW];
1164: ent->s.angles[ROLL] = 0;
1165: VectorCopy (ent->s.angles, client->ps.viewangles);
1166: VectorCopy (ent->s.angles, client->v_angle);
1167:
1168: //ZOID
1169: if (CTFStartClient(ent))
1170: return;
1171: //ZOID
1172:
1173: if (!KillBox (ent))
1174: { // could't spawn in?
1175: }
1176:
1177: gi.linkentity (ent);
1178:
1179: // force the current weapon up
1180: client->newweapon = client->pers.weapon;
1181: ChangeWeapon (ent);
1182: }
1183:
1184: /*
1185: =====================
1186: ClientBeginDeathmatch
1187:
1188: A client has just connected to the server in
1189: deathmatch mode, so clear everything out before starting them.
1190: =====================
1191: */
1192: void ClientBeginDeathmatch (edict_t *ent)
1193: {
1194: G_InitEdict (ent);
1195:
1196: InitClientResp (ent->client);
1197:
1198: // locate ent at a spawn point
1199: PutClientInServer (ent);
1200:
1201: // send effect
1202: gi.WriteByte (svc_muzzleflash);
1203: gi.WriteShort (ent-g_edicts);
1204: gi.WriteByte (MZ_LOGIN);
1205: gi.multicast (ent->s.origin, MULTICAST_PVS);
1206:
1207: gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
1208:
1209: // make sure all view stuff is valid
1210: ClientEndServerFrame (ent);
1211: }
1212:
1213:
1214: /*
1215: ===========
1216: ClientBegin
1217:
1218: called when a client has finished connecting, and is ready
1219: to be placed into the game. This will happen every level load.
1220: ============
1221: */
1222: void ClientBegin (edict_t *ent)
1223: {
1224: int i;
1225:
1226: ent->client = game.clients + (ent - g_edicts - 1);
1227:
1228: if (deathmatch->value)
1229: {
1230: ClientBeginDeathmatch (ent);
1231: return;
1232: }
1233:
1234: // if there is already a body waiting for us (a loadgame), just
1235: // take it, otherwise spawn one from scratch
1236: if (ent->inuse == true)
1237: {
1238: // the client has cleared the client side viewangles upon
1239: // connecting to the server, which is different than the
1240: // state when the game is saved, so we need to compensate
1241: // with deltaangles
1242: for (i=0 ; i<3 ; i++)
1243: ent->client->ps.pmove.delta_angles[i] = ANGLE2SHORT(ent->client->ps.viewangles[i]);
1244: }
1245: else
1246: {
1247: // a spawn point will completely reinitialize the entity
1248: // except for the persistant data that was initialized at
1249: // ClientConnect() time
1250: G_InitEdict (ent);
1251: ent->classname = "player";
1252: InitClientResp (ent->client);
1253: PutClientInServer (ent);
1254: }
1255:
1256: if (level.intermissiontime)
1257: {
1258: MoveClientToIntermission (ent);
1259: }
1260: else
1261: {
1262: // send effect if in a multiplayer game
1263: if (game.maxclients > 1)
1264: {
1265: gi.WriteByte (svc_muzzleflash);
1266: gi.WriteShort (ent-g_edicts);
1267: gi.WriteByte (MZ_LOGIN);
1268: gi.multicast (ent->s.origin, MULTICAST_PVS);
1269:
1270: gi.bprintf (PRINT_HIGH, "%s entered the game\n", ent->client->pers.netname);
1271: }
1272: }
1273:
1274: // make sure all view stuff is valid
1275: ClientEndServerFrame (ent);
1276: }
1277:
1278: /*
1279: ===========
1280: ClientUserInfoChanged
1281:
1282: called whenever the player updates a userinfo variable.
1283:
1284: The game can override any of the settings in place
1285: (forcing skins or names, etc) before copying it off.
1286: ============
1287: */
1288: void ClientUserinfoChanged (edict_t *ent, char *userinfo)
1289: {
1290: char *s;
1291: int playernum;
1292:
1293: // check for malformed or illegal info strings
1294: if (!Info_Validate(userinfo))
1295: {
1296: strcpy (userinfo, "\\name\\badinfo\\skin\\male/grunt");
1297: }
1298:
1299: // set name
1300: s = Info_ValueForKey (userinfo, "name");
1301: strncpy (ent->client->pers.netname, s, sizeof(ent->client->pers.netname)-1);
1302:
1303: // set skin
1304: s = Info_ValueForKey (userinfo, "skin");
1305:
1306: playernum = ent-g_edicts-1;
1307:
1308: // combine name and skin into a configstring
1309: //ZOID
1310: if (ctf->value)
1311: CTFAssignSkin(ent, s);
1312: else
1313: //ZOID
1314: gi.configstring (CS_PLAYERSKINS+playernum, va("%s\\%s", ent->client->pers.netname, s) );
1315:
1316: // fov
1317: if (deathmatch->value && ((int)dmflags->value & DF_FIXED_FOV))
1318: {
1319: ent->client->ps.fov = 90;
1320: }
1321: else
1322: {
1323: ent->client->ps.fov = atoi(Info_ValueForKey(userinfo, "fov"));
1324: if (ent->client->ps.fov < 1)
1325: ent->client->ps.fov = 90;
1326: else if (ent->client->ps.fov > 160)
1327: ent->client->ps.fov = 160;
1328: }
1329:
1330: // handedness
1331: s = Info_ValueForKey (userinfo, "hand");
1332: if (strlen(s))
1333: {
1334: ent->client->pers.hand = atoi(s);
1335: }
1336:
1337: // save off the userinfo in case we want to check something later
1338: strncpy (ent->client->pers.userinfo, userinfo, sizeof(ent->client->pers.userinfo)-1);
1339: }
1340:
1341:
1342: /*
1343: ===========
1344: ClientConnect
1345:
1346: Called when a player begins connecting to the server.
1347: The game can refuse entrance to a client by returning false.
1348: If the client is allowed, the connection process will continue
1349: and eventually get to ClientBegin()
1350: Changing levels will NOT cause this to be called again, but
1351: loadgames will.
1352: ============
1353: */
1354: qboolean ClientConnect (edict_t *ent, char *userinfo)
1355: {
1356: char *value;
1357:
1358: // check to see if they are on the banned IP list
1359: value = Info_ValueForKey (userinfo, "ip");
1360:
1361: // check for a password
1362: value = Info_ValueForKey (userinfo, "password");
1363: if (*password->string && strcmp(password->string, "none") &&
1364: strcmp(password->string, value)) {
1365: Info_SetValueForKey(userinfo, "rejmsg", "Password required or incorrect.");
1366: return false;
1367: }
1368:
1369: // they can connect
1370: ent->client = game.clients + (ent - g_edicts - 1);
1371:
1372: // if there is already a body waiting for us (a loadgame), just
1373: // take it, otherwise spawn one from scratch
1374: if (ent->inuse == false)
1375: {
1376: // clear the respawning variables
1377: //ZOID -- force team join
1378: ent->client->resp.ctf_team = -1;
1379: ent->client->resp.id_state = false;
1380: //ZOID
1381: InitClientResp (ent->client);
1382: if (!game.autosaved || !ent->client->pers.weapon)
1383: InitClientPersistant (ent->client);
1384: }
1385:
1386: ClientUserinfoChanged (ent, userinfo);
1387:
1388: if (game.maxclients > 1)
1389: gi.dprintf ("%s connected\n", ent->client->pers.netname);
1390:
1391: ent->client->pers.connected = true;
1392: return true;
1393: }
1394:
1395: /*
1396: ===========
1397: ClientDisconnect
1398:
1399: Called when a player drops from the server.
1400: Will not be called between levels.
1401: ============
1402: */
1403: void ClientDisconnect (edict_t *ent)
1404: {
1405: int playernum;
1406:
1407: if (!ent->client)
1408: return;
1409:
1410: gi.bprintf (PRINT_HIGH, "%s disconnected\n", ent->client->pers.netname);
1411:
1412: //ZOID
1413: CTFDeadDropFlag(ent);
1414: CTFDeadDropTech(ent);
1415: //ZOID
1416:
1417: // send effect
1418: gi.WriteByte (svc_muzzleflash);
1419: gi.WriteShort (ent-g_edicts);
1420: gi.WriteByte (MZ_LOGOUT);
1421: gi.multicast (ent->s.origin, MULTICAST_PVS);
1422:
1423: gi.unlinkentity (ent);
1424: ent->s.modelindex = 0;
1425: ent->solid = SOLID_NOT;
1426: ent->inuse = false;
1427: ent->classname = "disconnected";
1428: ent->client->pers.connected = false;
1429:
1430: playernum = ent-g_edicts-1;
1431: gi.configstring (CS_PLAYERSKINS+playernum, "");
1432: }
1433:
1434:
1435: //==============================================================
1436:
1437:
1438: edict_t *pm_passent;
1439:
1440: // pmove doesn't need to know about passent and contentmask
1441: trace_t PM_trace (vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end)
1442: {
1443: if (pm_passent->health > 0)
1444: return gi.trace (start, mins, maxs, end, pm_passent, MASK_PLAYERSOLID);
1445: else
1446: return gi.trace (start, mins, maxs, end, pm_passent, MASK_DEADSOLID);
1447: }
1448:
1449: unsigned CheckBlock (void *b, int c)
1450: {
1451: int v,i;
1452: v = 0;
1453: for (i=0 ; i<c ; i++)
1454: v+= ((byte *)b)[i];
1455: return v;
1456: }
1457: void PrintPmove (pmove_t *pm)
1458: {
1459: unsigned c1, c2;
1460:
1461: c1 = CheckBlock (&pm->s, sizeof(pm->s));
1462: c2 = CheckBlock (&pm->cmd, sizeof(pm->cmd));
1463: Com_Printf ("sv %3i:%i %i\n", pm->cmd.impulse, c1, c2);
1464: }
1465:
1466: /*
1467: ==============
1468: ClientThink
1469:
1470: This will be called once for each client frame, which will
1471: usually be a couple times for each server frame.
1472: ==============
1473: */
1474: void ClientThink (edict_t *ent, usercmd_t *ucmd)
1475: {
1476: gclient_t *client;
1477: edict_t *other;
1478: int i, j;
1479: pmove_t pm;
1480:
1481: level.current_entity = ent;
1482: client = ent->client;
1483:
1484: if (level.intermissiontime)
1485: {
1486: client->ps.pmove.pm_type = PM_FREEZE;
1487: // can exit intermission after five seconds
1488: if (level.time > level.intermissiontime + 5.0
1489: && (ucmd->buttons & BUTTON_ANY) )
1490: level.exitintermission = true;
1491: return;
1492: }
1493:
1494: pm_passent = ent;
1495:
1496: //ZOID
1497: if (ent->client->chase_target) {
1498: client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
1499: client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
1500: client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
1501: return;
1502: }
1503: //ZOID
1504:
1505: // set up for pmove
1506: memset (&pm, 0, sizeof(pm));
1507:
1508: if (ent->movetype == MOVETYPE_NOCLIP)
1509: client->ps.pmove.pm_type = PM_SPECTATOR;
1510: else if (ent->s.modelindex != 255)
1511: client->ps.pmove.pm_type = PM_GIB;
1512: else if (ent->deadflag)
1513: client->ps.pmove.pm_type = PM_DEAD;
1514: else
1515: client->ps.pmove.pm_type = PM_NORMAL;
1516:
1517: client->ps.pmove.gravity = sv_gravity->value;
1518: pm.s = client->ps.pmove;
1519:
1520: for (i=0 ; i<3 ; i++)
1521: {
1522: pm.s.origin[i] = ent->s.origin[i]*8;
1523: pm.s.velocity[i] = ent->velocity[i]*8;
1524: }
1525:
1526: if (memcmp(&client->old_pmove, &pm.s, sizeof(pm.s)))
1527: {
1528: pm.snapinitial = true;
1529: // gi.dprintf ("pmove changed!\n");
1530: }
1531:
1532: pm.cmd = *ucmd;
1533:
1534: pm.trace = PM_trace; // adds default parms
1535: pm.pointcontents = gi.pointcontents;
1536:
1537: // perform a pmove
1538: gi.Pmove (&pm);
1539:
1540: // save results of pmove
1541: client->ps.pmove = pm.s;
1542: client->old_pmove = pm.s;
1543:
1544: for (i=0 ; i<3 ; i++)
1545: {
1546: ent->s.origin[i] = pm.s.origin[i]*0.125;
1547: ent->velocity[i] = pm.s.velocity[i]*0.125;
1548: }
1549:
1550: VectorCopy (pm.mins, ent->mins);
1551: VectorCopy (pm.maxs, ent->maxs);
1552:
1553: client->resp.cmd_angles[0] = SHORT2ANGLE(ucmd->angles[0]);
1554: client->resp.cmd_angles[1] = SHORT2ANGLE(ucmd->angles[1]);
1555: client->resp.cmd_angles[2] = SHORT2ANGLE(ucmd->angles[2]);
1556:
1557: if (ent->groundentity && !pm.groundentity && (pm.cmd.upmove >= 10) && (pm.waterlevel == 0))
1558: {
1559: gi.sound(ent, CHAN_VOICE, gi.soundindex("*jump1.wav"), 1, ATTN_NORM, 0);
1560: PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
1561: }
1562:
1563: ent->viewheight = pm.viewheight;
1564: ent->waterlevel = pm.waterlevel;
1565: ent->watertype = pm.watertype;
1566: ent->groundentity = pm.groundentity;
1567: if (pm.groundentity)
1568: ent->groundentity_linkcount = pm.groundentity->linkcount;
1569:
1570: if (ent->deadflag)
1571: {
1572: client->ps.viewangles[ROLL] = 40;
1573: client->ps.viewangles[PITCH] = -15;
1574: client->ps.viewangles[YAW] = client->killer_yaw;
1575: }
1576: else
1577: {
1578: VectorCopy (pm.viewangles, client->v_angle);
1579: VectorCopy (pm.viewangles, client->ps.viewangles);
1580: }
1581:
1582: //ZOID
1583: if (client->ctf_grapple)
1584: CTFGrapplePull(client->ctf_grapple);
1585: //ZOID
1586:
1587: gi.linkentity (ent);
1588:
1589: if (ent->movetype != MOVETYPE_NOCLIP)
1590: G_TouchTriggers (ent);
1591:
1592: // touch other objects
1593: for (i=0 ; i<pm.numtouch ; i++)
1594: {
1595: other = pm.touchents[i];
1596: for (j=0 ; j<i ; j++)
1597: if (pm.touchents[j] == other)
1598: break;
1599: if (j != i)
1600: continue; // duplicated
1601: if (!other->touch)
1602: continue;
1603: other->touch (other, ent, NULL, NULL);
1604: }
1605:
1606:
1607: client->oldbuttons = client->buttons;
1608: client->buttons = ucmd->buttons;
1609: client->latched_buttons |= client->buttons & ~client->oldbuttons;
1610:
1611: // save light level the player is standing on for
1612: // monster sighting AI
1613: ent->light_level = ucmd->lightlevel;
1614:
1615: // fire weapon from final position if needed
1616: if (client->latched_buttons & BUTTON_ATTACK
1617: //ZOID
1618: && ent->movetype != MOVETYPE_NOCLIP
1619: //ZOID
1620: )
1621: {
1622: if (!client->weapon_thunk)
1623: {
1624: client->weapon_thunk = true;
1625: Think_Weapon (ent);
1626: }
1627: }
1628:
1629: //ZOID
1630: //regen tech
1631: CTFApplyRegeneration(ent);
1632: //ZOID
1633:
1634: //ZOID
1635: for (i = 1; i <= maxclients->value; i++) {
1636: other = g_edicts + i;
1637: if (other->inuse && other->client->chase_target == ent)
1638: UpdateChaseCam(other);
1639: }
1640:
1641: if (client->menudirty && client->menutime <= level.time) {
1642: PMenu_Do_Update(ent);
1643: gi.unicast (ent, true);
1644: client->menutime = level.time;
1645: client->menudirty = false;
1646: }
1647: //ZOID
1648: }
1649:
1650:
1651: /*
1652: ==============
1653: ClientBeginServerFrame
1654:
1655: This will be called once for each server frame, before running
1656: any other entities in the world.
1657: ==============
1658: */
1659: void ClientBeginServerFrame (edict_t *ent)
1660: {
1661: gclient_t *client;
1662: int buttonMask;
1663:
1664: if (level.intermissiontime)
1665: return;
1666:
1667: client = ent->client;
1668:
1669: // run weapon animations if it hasn't been done by a ucmd_t
1670: if (!client->weapon_thunk
1671: //ZOID
1672: && ent->movetype != MOVETYPE_NOCLIP
1673: //ZOID
1674: )
1675: Think_Weapon (ent);
1676: else
1677: client->weapon_thunk = false;
1678:
1679: if (ent->deadflag)
1680: {
1681: // wait for any button just going down
1682: if ( level.time > client->respawn_time)
1683: {
1684: // in deathmatch, only wait for attack button
1685: if (deathmatch->value)
1686: buttonMask = BUTTON_ATTACK;
1687: else
1688: buttonMask = -1;
1689:
1690: if ( ( client->latched_buttons & buttonMask ) ||
1691: (deathmatch->value && ((int)dmflags->value & DF_FORCE_RESPAWN) ) ||
1692: CTFMatchOn())
1693: {
1694: respawn(ent);
1695: client->latched_buttons = 0;
1696: }
1697: }
1698: return;
1699: }
1700:
1701: // add player trail so monsters can follow
1702: if (!deathmatch->value)
1703: if (!visible (ent, PlayerTrail_LastSpot() ) )
1704: PlayerTrail_Add (ent->s.old_origin);
1705:
1706: client->latched_buttons = 0;
1707: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.