![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to p_weapon.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_weapon.c CVS log | Up to [Quake II] / quake2 / ctf |
1.1 root 1: // g_weapon.c
2:
3: #include "g_local.h"
4: #include "m_player.h"
5:
6:
7: static qboolean is_quad;
8: static byte is_silenced;
9:
10:
11: void weapon_grenade_fire (edict_t *ent, qboolean held);
12:
13:
14: void P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
15: {
16: vec3_t _distance;
17:
18: VectorCopy (distance, _distance);
19: if (client->pers.hand == LEFT_HANDED)
20: _distance[1] *= -1;
21: else if (client->pers.hand == CENTER_HANDED)
22: _distance[1] = 0;
23: G_ProjectSource (point, _distance, forward, right, result);
24: }
25:
26:
27: /*
28: ===============
29: PlayerNoise
30:
31: Each player can have two noise objects associated with it:
32: a personal noise (jumping, pain, weapon firing), and a weapon
33: target noise (bullet wall impacts)
34:
35: Monsters that don't directly see the player can move
36: to a noise in hopes of seeing the player from there.
37: ===============
38: */
39: void PlayerNoise(edict_t *who, vec3_t where, int type)
40: {
41: edict_t *noise;
42:
43: if (type == PNOISE_WEAPON)
44: {
45: if (who->client->silencer_shots)
46: {
47: who->client->silencer_shots--;
48: return;
49: }
50: }
51:
52: if (deathmatch->value)
53: return;
54:
55: if (who->flags & FL_NOTARGET)
56: return;
57:
58:
59: if (!who->mynoise)
60: {
61: noise = G_Spawn();
62: noise->classname = "player_noise";
63: VectorSet (noise->mins, -8, -8, -8);
64: VectorSet (noise->maxs, 8, 8, 8);
65: noise->owner = who;
66: noise->svflags = SVF_NOCLIENT;
67: who->mynoise = noise;
68:
69: noise = G_Spawn();
70: noise->classname = "player_noise";
71: VectorSet (noise->mins, -8, -8, -8);
72: VectorSet (noise->maxs, 8, 8, 8);
73: noise->owner = who;
74: noise->svflags = SVF_NOCLIENT;
75: who->mynoise2 = noise;
76: }
77:
78: if (type == PNOISE_SELF || type == PNOISE_WEAPON)
79: {
80: noise = who->mynoise;
81: level.sound_entity = noise;
82: level.sound_entity_framenum = level.framenum;
83: }
84: else // type == PNOISE_IMPACT
85: {
86: noise = who->mynoise2;
87: level.sound2_entity = noise;
88: level.sound2_entity_framenum = level.framenum;
89: }
90:
91: VectorCopy (where, noise->s.origin);
92: VectorSubtract (where, noise->maxs, noise->absmin);
93: VectorAdd (where, noise->maxs, noise->absmax);
94: noise->teleport_time = level.time;
95: gi.linkentity (noise);
96: }
97:
98:
99: qboolean Pickup_Weapon (edict_t *ent, edict_t *other)
100: {
101: int index;
102: gitem_t *ammo;
103:
104: index = ITEM_INDEX(ent->item);
105:
106: if ( ( ((int)(dmflags->value) & DF_WEAPONS_STAY) || coop->value)
107: && other->client->pers.inventory[index])
108: {
109: if (!(ent->spawnflags & (DROPPED_ITEM | DROPPED_PLAYER_ITEM) ) )
110: return false; // leave the weapon for others to pickup
111: }
112:
113: other->client->pers.inventory[index]++;
114:
115: if (!(ent->spawnflags & DROPPED_ITEM) )
116: {
117: // give them some ammo with it
118: ammo = FindItem (ent->item->ammo);
119: if ( (int)dmflags->value & DF_INFINITE_AMMO )
120: Add_Ammo (other, ammo, 1000);
121: else
122: Add_Ammo (other, ammo, ammo->quantity);
123:
124: if (! (ent->spawnflags & DROPPED_PLAYER_ITEM) )
125: {
126: if (deathmatch->value)
127: {
128: if ((int)(dmflags->value) & DF_WEAPONS_STAY)
129: ent->flags |= FL_RESPAWN;
130: else
131: SetRespawn (ent, 30);
132: }
133: if (coop->value)
134: ent->flags |= FL_RESPAWN;
135: }
136: }
137:
138: if (other->client->pers.weapon != ent->item &&
139: (other->client->pers.inventory[index] == 1) &&
140: ( !deathmatch->value || other->client->pers.weapon == FindItem("blaster") ) )
141: other->client->newweapon = ent->item;
142:
143: return true;
144: }
145:
146:
147: /*
148: ===============
149: ChangeWeapon
150:
151: The old weapon has been dropped all the way, so make the new one
152: current
153: ===============
154: */
155: void ChangeWeapon (edict_t *ent)
156: {
157: int i;
158:
159: if (ent->client->grenade_time)
160: {
161: ent->client->grenade_time = level.time;
162: ent->client->weapon_sound = 0;
163: weapon_grenade_fire (ent, false);
164: ent->client->grenade_time = 0;
165: }
166:
167: ent->client->pers.lastweapon = ent->client->pers.weapon;
168: ent->client->pers.weapon = ent->client->newweapon;
169: ent->client->newweapon = NULL;
170: ent->client->machinegun_shots = 0;
171:
172: // set visible model
173: if (ent->s.modelindex == 255) {
174: if (ent->client->pers.weapon)
175: i = ((ent->client->pers.weapon->weapmodel & 0xff) << 8);
176: else
177: i = 0;
178: ent->s.skinnum = (ent - g_edicts - 1) | i;
179: }
180:
181: if (ent->client->pers.weapon && ent->client->pers.weapon->ammo)
182: ent->client->ammo_index = ITEM_INDEX(FindItem(ent->client->pers.weapon->ammo));
183: else
184: ent->client->ammo_index = 0;
185:
186: if (!ent->client->pers.weapon)
187: { // dead
188: ent->client->ps.gunindex = 0;
189: return;
190: }
191:
192: ent->client->weaponstate = WEAPON_ACTIVATING;
193: ent->client->ps.gunframe = 0;
194: ent->client->ps.gunindex = gi.modelindex(ent->client->pers.weapon->view_model);
195:
196: ent->client->anim_priority = ANIM_PAIN;
197: if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
198: {
199: ent->s.frame = FRAME_crpain1;
200: ent->client->anim_end = FRAME_crpain4;
201: }
202: else
203: {
204: ent->s.frame = FRAME_pain301;
205: ent->client->anim_end = FRAME_pain304;
206:
207: }
208: }
209:
210: /*
211: =================
212: NoAmmoWeaponChange
213: =================
214: */
215: void NoAmmoWeaponChange (edict_t *ent)
216: {
217: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("slugs"))]
218: && ent->client->pers.inventory[ITEM_INDEX(FindItem("railgun"))] )
219: {
220: ent->client->newweapon = FindItem ("railgun");
221: return;
222: }
223: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("cells"))]
224: && ent->client->pers.inventory[ITEM_INDEX(FindItem("hyperblaster"))] )
225: {
226: ent->client->newweapon = FindItem ("hyperblaster");
227: return;
228: }
229: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
230: && ent->client->pers.inventory[ITEM_INDEX(FindItem("chaingun"))] )
231: {
232: ent->client->newweapon = FindItem ("chaingun");
233: return;
234: }
235: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("bullets"))]
236: && ent->client->pers.inventory[ITEM_INDEX(FindItem("machinegun"))] )
237: {
238: ent->client->newweapon = FindItem ("machinegun");
239: return;
240: }
241: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))] > 1
242: && ent->client->pers.inventory[ITEM_INDEX(FindItem("super shotgun"))] )
243: {
244: ent->client->newweapon = FindItem ("super shotgun");
245: return;
246: }
247: if ( ent->client->pers.inventory[ITEM_INDEX(FindItem("shells"))]
248: && ent->client->pers.inventory[ITEM_INDEX(FindItem("shotgun"))] )
249: {
250: ent->client->newweapon = FindItem ("shotgun");
251: return;
252: }
253: ent->client->newweapon = FindItem ("blaster");
254: }
255:
256: /*
257: =================
258: Think_Weapon
259:
260: Called by ClientBeginServerFrame and ClientThink
261: =================
262: */
263: void Think_Weapon (edict_t *ent)
264: {
265: // if just died, put the weapon away
266: if (ent->health < 1)
267: {
268: ent->client->newweapon = NULL;
269: ChangeWeapon (ent);
270: }
271:
272: // call active weapon think routine
273: if (ent->client->pers.weapon && ent->client->pers.weapon->weaponthink)
274: {
275: is_quad = (ent->client->quad_framenum > level.framenum);
276: if (ent->client->silencer_shots)
277: is_silenced = MZ_SILENCED;
278: else
279: is_silenced = 0;
280: ent->client->pers.weapon->weaponthink (ent);
281: }
282: }
283:
284:
285: /*
286: ================
287: Use_Weapon
288:
289: Make the weapon ready if there is ammo
290: ================
291: */
292: void Use_Weapon (edict_t *ent, gitem_t *item)
293: {
294: int ammo_index;
295: gitem_t *ammo_item;
296:
297: // see if we're already using it
298: if (item == ent->client->pers.weapon)
299: return;
300:
301: if (item->ammo && !g_select_empty->value && !(item->flags & IT_AMMO))
302: {
303: ammo_item = FindItem(item->ammo);
304: ammo_index = ITEM_INDEX(ammo_item);
305:
306: if (!ent->client->pers.inventory[ammo_index])
307: {
308: gi.cprintf (ent, PRINT_HIGH, "No %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
309: return;
310: }
311:
312: if (ent->client->pers.inventory[ammo_index] < item->quantity)
313: {
314: gi.cprintf (ent, PRINT_HIGH, "Not enough %s for %s.\n", ammo_item->pickup_name, item->pickup_name);
315: return;
316: }
317: }
318:
319: // change to this weapon when down
320: ent->client->newweapon = item;
321: }
322:
323:
324:
325: /*
326: ================
327: Drop_Weapon
328: ================
329: */
330: void Drop_Weapon (edict_t *ent, gitem_t *item)
331: {
332: int index;
333:
334: if ((int)(dmflags->value) & DF_WEAPONS_STAY)
335: return;
336:
337: index = ITEM_INDEX(item);
338: // see if we're already using it
339: if ( ((item == ent->client->pers.weapon) || (item == ent->client->newweapon))&& (ent->client->pers.inventory[index] == 1) )
340: {
341: gi.cprintf (ent, PRINT_HIGH, "Can't drop current weapon\n");
342: return;
343: }
344:
345: Drop_Item (ent, item);
346: ent->client->pers.inventory[index]--;
347: }
348:
349:
350: /*
351: ================
352: Weapon_Generic
353:
354: A generic function to handle the basics of weapon thinking
355: ================
356: */
357: #define FRAME_FIRE_FIRST (FRAME_ACTIVATE_LAST + 1)
358: #define FRAME_IDLE_FIRST (FRAME_FIRE_LAST + 1)
359: #define FRAME_DEACTIVATE_FIRST (FRAME_IDLE_LAST + 1)
360:
361: static void Weapon_Generic2 (edict_t *ent, int FRAME_ACTIVATE_LAST, int FRAME_FIRE_LAST, int FRAME_IDLE_LAST, int FRAME_DEACTIVATE_LAST, int *pause_frames, int *fire_frames, void (*fire)(edict_t *ent))
362: {
363: int n;
364:
365: if(ent->deadflag || ent->s.modelindex != 255) // VWep animations screw up corpses
366: {
367: return;
368: }
369:
370: if (ent->client->weaponstate == WEAPON_DROPPING)
371: {
372: if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST)
373: {
374: ChangeWeapon (ent);
375: return;
376: }
377: else if ((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4)
378: {
379: ent->client->anim_priority = ANIM_REVERSE;
380: if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
381: {
382: ent->s.frame = FRAME_crpain4+1;
383: ent->client->anim_end = FRAME_crpain1;
384: }
385: else
386: {
387: ent->s.frame = FRAME_pain304+1;
388: ent->client->anim_end = FRAME_pain301;
389:
390: }
391: }
392:
393: ent->client->ps.gunframe++;
394: return;
395: }
396:
397: if (ent->client->weaponstate == WEAPON_ACTIVATING)
398: {
399: if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST || instantweap->value)
400: {
401: ent->client->weaponstate = WEAPON_READY;
402: ent->client->ps.gunframe = FRAME_IDLE_FIRST;
403: // we go recursive here to instant ready the weapon
404: Weapon_Generic2 (ent, FRAME_ACTIVATE_LAST, FRAME_FIRE_LAST,
405: FRAME_IDLE_LAST, FRAME_DEACTIVATE_LAST, pause_frames,
406: fire_frames, fire);
407: return;
408: }
409:
410: ent->client->ps.gunframe++;
411: return;
412: }
413:
414: if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING))
415: {
416: ent->client->weaponstate = WEAPON_DROPPING;
417: if (instantweap->value) {
418: ChangeWeapon(ent);
419: return;
420: } else
421: ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
422:
423: if ((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4)
424: {
425: ent->client->anim_priority = ANIM_REVERSE;
426: if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
427: {
428: ent->s.frame = FRAME_crpain4+1;
429: ent->client->anim_end = FRAME_crpain1;
430: }
431: else
432: {
433: ent->s.frame = FRAME_pain304+1;
434: ent->client->anim_end = FRAME_pain301;
435:
436: }
437: }
438: return;
439: }
440:
441: if (ent->client->weaponstate == WEAPON_READY)
442: {
443: if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
444: {
445: ent->client->latched_buttons &= ~BUTTON_ATTACK;
446: if ((!ent->client->ammo_index) ||
447: ( ent->client->pers.inventory[ent->client->ammo_index] >= ent->client->pers.weapon->quantity))
448: {
449: ent->client->ps.gunframe = FRAME_FIRE_FIRST;
450: ent->client->weaponstate = WEAPON_FIRING;
451:
452: // start the animation
453: ent->client->anim_priority = ANIM_ATTACK;
454: if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
455: {
456: ent->s.frame = FRAME_crattak1-1;
457: ent->client->anim_end = FRAME_crattak9;
458: }
459: else
460: {
461: ent->s.frame = FRAME_attack1-1;
462: ent->client->anim_end = FRAME_attack8;
463: }
464: }
465: else
466: {
467: if (level.time >= ent->pain_debounce_time)
468: {
469: gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
470: ent->pain_debounce_time = level.time + 1;
471: }
472: NoAmmoWeaponChange (ent);
473: }
474: }
475: else
476: {
477: if (ent->client->ps.gunframe == FRAME_IDLE_LAST)
478: {
479: ent->client->ps.gunframe = FRAME_IDLE_FIRST;
480: return;
481: }
482:
483: if (pause_frames)
484: {
485: for (n = 0; pause_frames[n]; n++)
486: {
487: if (ent->client->ps.gunframe == pause_frames[n])
488: {
489: if (rand()&15)
490: return;
491: }
492: }
493: }
494:
495: ent->client->ps.gunframe++;
496: return;
497: }
498: }
499:
500: if (ent->client->weaponstate == WEAPON_FIRING)
501: {
502: for (n = 0; fire_frames[n]; n++)
503: {
504: if (ent->client->ps.gunframe == fire_frames[n])
505: {
506: //ZOID
507: if (!CTFApplyStrengthSound(ent))
508: //ZOID
509: if (ent->client->quad_framenum > level.framenum)
510: gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
511: //ZOID
512: CTFApplyHasteSound(ent);
513: //ZOID
514:
515: fire (ent);
516: break;
517: }
518: }
519:
520: if (!fire_frames[n])
521: ent->client->ps.gunframe++;
522:
523: if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1)
524: ent->client->weaponstate = WEAPON_READY;
525: }
526: }
527:
528: //ZOID
529: void Weapon_Generic (edict_t *ent, int FRAME_ACTIVATE_LAST, int FRAME_FIRE_LAST, int FRAME_IDLE_LAST, int FRAME_DEACTIVATE_LAST, int *pause_frames, int *fire_frames, void (*fire)(edict_t *ent))
530: {
531: int oldstate = ent->client->weaponstate;
532:
533: Weapon_Generic2 (ent, FRAME_ACTIVATE_LAST, FRAME_FIRE_LAST,
534: FRAME_IDLE_LAST, FRAME_DEACTIVATE_LAST, pause_frames,
535: fire_frames, fire);
536:
537: // run the weapon frame again if hasted
538: if (stricmp(ent->client->pers.weapon->pickup_name, "Grapple") == 0 &&
539: ent->client->weaponstate == WEAPON_FIRING)
540: return;
541:
542: if ((CTFApplyHaste(ent) ||
543: (Q_stricmp(ent->client->pers.weapon->pickup_name, "Grapple") == 0 &&
544: ent->client->weaponstate != WEAPON_FIRING))
545: && oldstate == ent->client->weaponstate) {
546: Weapon_Generic2 (ent, FRAME_ACTIVATE_LAST, FRAME_FIRE_LAST,
547: FRAME_IDLE_LAST, FRAME_DEACTIVATE_LAST, pause_frames,
548: fire_frames, fire);
549: }
550: }
551: //ZOID
552:
553: /*
554: ======================================================================
555:
556: GRENADE
557:
558: ======================================================================
559: */
560:
561: #define GRENADE_TIMER 3.0
562: #define GRENADE_MINSPEED 400
563: #define GRENADE_MAXSPEED 800
564:
565: void weapon_grenade_fire (edict_t *ent, qboolean held)
566: {
567: vec3_t offset;
568: vec3_t forward, right;
569: vec3_t start;
570: int damage = 125;
571: float timer;
572: int speed;
573: float radius;
574:
575: radius = damage+40;
576: if (is_quad)
577: damage *= 4;
578:
579: VectorSet(offset, 8, 8, ent->viewheight-8);
580: AngleVectors (ent->client->v_angle, forward, right, NULL);
581: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
582:
583: timer = ent->client->grenade_time - level.time;
584: speed = GRENADE_MINSPEED + (GRENADE_TIMER - timer) * ((GRENADE_MAXSPEED - GRENADE_MINSPEED) / GRENADE_TIMER);
585: fire_grenade2 (ent, start, forward, damage, speed, timer, radius, held);
586:
587: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
588: ent->client->pers.inventory[ent->client->ammo_index]--;
589:
590: ent->client->grenade_time = level.time + 1.0;
591:
592: if(ent->deadflag || ent->s.modelindex != 255) // VWep animations screw up corpses
593: {
594: return;
595: }
596:
597: if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
598: {
599: ent->client->anim_priority = ANIM_ATTACK;
600: ent->s.frame = FRAME_crattak1-1;
601: ent->client->anim_end = FRAME_crattak3;
602: }
603: else
604: {
605: ent->client->anim_priority = ANIM_REVERSE;
606: ent->s.frame = FRAME_wave08;
607: ent->client->anim_end = FRAME_wave01;
608: }
609: }
610:
611: void Weapon_Grenade (edict_t *ent)
612: {
613: if ((ent->client->newweapon) && (ent->client->weaponstate == WEAPON_READY))
614: {
615: ChangeWeapon (ent);
616: return;
617: }
618:
619: if (ent->client->weaponstate == WEAPON_ACTIVATING)
620: {
621: ent->client->weaponstate = WEAPON_READY;
622: ent->client->ps.gunframe = 16;
623: return;
624: }
625:
626: if (ent->client->weaponstate == WEAPON_READY)
627: {
628: if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
629: {
630: ent->client->latched_buttons &= ~BUTTON_ATTACK;
631: if (ent->client->pers.inventory[ent->client->ammo_index])
632: {
633: ent->client->ps.gunframe = 1;
634: ent->client->weaponstate = WEAPON_FIRING;
635: ent->client->grenade_time = 0;
636: }
637: else
638: {
639: if (level.time >= ent->pain_debounce_time)
640: {
641: gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
642: ent->pain_debounce_time = level.time + 1;
643: }
644: NoAmmoWeaponChange (ent);
645: }
646: return;
647: }
648:
649: if ((ent->client->ps.gunframe == 29) || (ent->client->ps.gunframe == 34) || (ent->client->ps.gunframe == 39) || (ent->client->ps.gunframe == 48))
650: {
651: if (rand()&15)
652: return;
653: }
654:
655: if (++ent->client->ps.gunframe > 48)
656: ent->client->ps.gunframe = 16;
657: return;
658: }
659:
660: if (ent->client->weaponstate == WEAPON_FIRING)
661: {
662: if (ent->client->ps.gunframe == 5)
663: gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/hgrena1b.wav"), 1, ATTN_NORM, 0);
664:
665: if (ent->client->ps.gunframe == 11)
666: {
667: if (!ent->client->grenade_time)
668: {
669: ent->client->grenade_time = level.time + GRENADE_TIMER + 0.2;
670: ent->client->weapon_sound = gi.soundindex("weapons/hgrenc1b.wav");
671: }
672:
673: // they waited too long, detonate it in their hand
674: if (!ent->client->grenade_blew_up && level.time >= ent->client->grenade_time)
675: {
676: ent->client->weapon_sound = 0;
677: weapon_grenade_fire (ent, true);
678: ent->client->grenade_blew_up = true;
679: }
680:
681: if (ent->client->buttons & BUTTON_ATTACK)
682: return;
683:
684: if (ent->client->grenade_blew_up)
685: {
686: if (level.time >= ent->client->grenade_time)
687: {
688: ent->client->ps.gunframe = 15;
689: ent->client->grenade_blew_up = false;
690: }
691: else
692: {
693: return;
694: }
695: }
696: }
697:
698: if (ent->client->ps.gunframe == 12)
699: {
700: ent->client->weapon_sound = 0;
701: weapon_grenade_fire (ent, false);
702: }
703:
704: if ((ent->client->ps.gunframe == 15) && (level.time < ent->client->grenade_time))
705: return;
706:
707: ent->client->ps.gunframe++;
708:
709: if (ent->client->ps.gunframe == 16)
710: {
711: ent->client->grenade_time = 0;
712: ent->client->weaponstate = WEAPON_READY;
713: }
714: }
715: }
716:
717: /*
718: ======================================================================
719:
720: GRENADE LAUNCHER
721:
722: ======================================================================
723: */
724:
725: void weapon_grenadelauncher_fire (edict_t *ent)
726: {
727: vec3_t offset;
728: vec3_t forward, right;
729: vec3_t start;
730: int damage = 120;
731: float radius;
732:
733: radius = damage+40;
734: if (is_quad)
735: damage *= 4;
736:
737: VectorSet(offset, 8, 8, ent->viewheight-8);
738: AngleVectors (ent->client->v_angle, forward, right, NULL);
739: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
740:
741: VectorScale (forward, -2, ent->client->kick_origin);
742: ent->client->kick_angles[0] = -1;
743:
744: fire_grenade (ent, start, forward, damage, 600, 2.5, radius);
745:
746: gi.WriteByte (svc_muzzleflash);
747: gi.WriteShort (ent-g_edicts);
748: gi.WriteByte (MZ_GRENADE | is_silenced);
749: gi.multicast (ent->s.origin, MULTICAST_PVS);
750:
751: ent->client->ps.gunframe++;
752:
753: PlayerNoise(ent, start, PNOISE_WEAPON);
754:
755: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
756: ent->client->pers.inventory[ent->client->ammo_index]--;
757: }
758:
759: void Weapon_GrenadeLauncher (edict_t *ent)
760: {
761: static int pause_frames[] = {34, 51, 59, 0};
762: static int fire_frames[] = {6, 0};
763:
764: Weapon_Generic (ent, 5, 16, 59, 64, pause_frames, fire_frames, weapon_grenadelauncher_fire);
765: }
766:
767: /*
768: ======================================================================
769:
770: ROCKET
771:
772: ======================================================================
773: */
774:
775: void Weapon_RocketLauncher_Fire (edict_t *ent)
776: {
777: vec3_t offset, start;
778: vec3_t forward, right;
779: int damage;
780: float damage_radius;
781: int radius_damage;
782:
783: damage = 100 + (int)(random() * 20.0);
784: radius_damage = 120;
785: damage_radius = 120;
786: if (is_quad)
787: {
788: damage *= 4;
789: radius_damage *= 4;
790: }
791:
792: AngleVectors (ent->client->v_angle, forward, right, NULL);
793:
794: VectorScale (forward, -2, ent->client->kick_origin);
795: ent->client->kick_angles[0] = -1;
796:
797: VectorSet(offset, 8, 8, ent->viewheight-8);
798: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
799: fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);
800:
801: // send muzzle flash
802: gi.WriteByte (svc_muzzleflash);
803: gi.WriteShort (ent-g_edicts);
804: gi.WriteByte (MZ_ROCKET | is_silenced);
805: gi.multicast (ent->s.origin, MULTICAST_PVS);
806:
807: ent->client->ps.gunframe++;
808:
809: PlayerNoise(ent, start, PNOISE_WEAPON);
810:
811: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
812: ent->client->pers.inventory[ent->client->ammo_index]--;
813: }
814:
815: void Weapon_RocketLauncher (edict_t *ent)
816: {
817: static int pause_frames[] = {25, 33, 42, 50, 0};
818: static int fire_frames[] = {5, 0};
819:
820: Weapon_Generic (ent, 4, 12, 50, 54, pause_frames, fire_frames, Weapon_RocketLauncher_Fire);
821: }
822:
823:
824: /*
825: ======================================================================
826:
827: BLASTER / HYPERBLASTER
828:
829: ======================================================================
830: */
831:
832: void Blaster_Fire (edict_t *ent, vec3_t g_offset, int damage, qboolean hyper, int effect)
833: {
834: vec3_t forward, right;
835: vec3_t start;
836: vec3_t offset;
837:
838: if (is_quad)
839: damage *= 4;
840: AngleVectors (ent->client->v_angle, forward, right, NULL);
841: VectorSet(offset, 24, 8, ent->viewheight-8);
842: VectorAdd (offset, g_offset, offset);
843: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
844:
845: VectorScale (forward, -2, ent->client->kick_origin);
846: ent->client->kick_angles[0] = -1;
847:
848: fire_blaster (ent, start, forward, damage, 1000, effect, hyper);
849:
850: // send muzzle flash
851: gi.WriteByte (svc_muzzleflash);
852: gi.WriteShort (ent-g_edicts);
853: if (hyper)
854: gi.WriteByte (MZ_HYPERBLASTER | is_silenced);
855: else
856: gi.WriteByte (MZ_BLASTER | is_silenced);
857: gi.multicast (ent->s.origin, MULTICAST_PVS);
858:
859: PlayerNoise(ent, start, PNOISE_WEAPON);
860: }
861:
862:
863: void Weapon_Blaster_Fire (edict_t *ent)
864: {
865: int damage;
866:
867: if (deathmatch->value)
868: damage = 15;
869: else
870: damage = 10;
871: Blaster_Fire (ent, vec3_origin, damage, false, EF_BLASTER);
872: ent->client->ps.gunframe++;
873: }
874:
875: void Weapon_Blaster (edict_t *ent)
876: {
877: static int pause_frames[] = {19, 32, 0};
878: static int fire_frames[] = {5, 0};
879:
880: Weapon_Generic (ent, 4, 8, 52, 55, pause_frames, fire_frames, Weapon_Blaster_Fire);
881: }
882:
883:
884: void Weapon_HyperBlaster_Fire (edict_t *ent)
885: {
886: float rotation;
887: vec3_t offset;
888: int effect;
889: int damage;
890:
891: ent->client->weapon_sound = gi.soundindex("weapons/hyprbl1a.wav");
892:
893: if (!(ent->client->buttons & BUTTON_ATTACK))
894: {
895: ent->client->ps.gunframe++;
896: }
897: else
898: {
899: if (! ent->client->pers.inventory[ent->client->ammo_index] )
900: {
901: if (level.time >= ent->pain_debounce_time)
902: {
903: gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
904: ent->pain_debounce_time = level.time + 1;
905: }
906: NoAmmoWeaponChange (ent);
907: }
908: else
909: {
910: rotation = (ent->client->ps.gunframe - 5) * 2*M_PI/6;
911: offset[0] = -4 * sin(rotation);
912: offset[1] = 0;
913: offset[2] = 4 * cos(rotation);
914:
915: if ((ent->client->ps.gunframe == 6) || (ent->client->ps.gunframe == 9))
916: effect = EF_HYPERBLASTER;
917: else
918: effect = 0;
919: if (deathmatch->value)
920: damage = 15;
921: else
922: damage = 20;
923: Blaster_Fire (ent, offset, damage, true, effect);
924: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
925: ent->client->pers.inventory[ent->client->ammo_index]--;
926:
927: ent->client->anim_priority = ANIM_ATTACK;
928: if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
929: {
930: ent->s.frame = FRAME_crattak1 - 1;
931: ent->client->anim_end = FRAME_crattak9;
932: }
933: else
934: {
935: ent->s.frame = FRAME_attack1 - 1;
936: ent->client->anim_end = FRAME_attack8;
937: }
938: }
939:
940: ent->client->ps.gunframe++;
941: if (ent->client->ps.gunframe == 12 && ent->client->pers.inventory[ent->client->ammo_index])
942: ent->client->ps.gunframe = 6;
943: }
944:
945: if (ent->client->ps.gunframe == 12)
946: {
947: gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/hyprbd1a.wav"), 1, ATTN_NORM, 0);
948: ent->client->weapon_sound = 0;
949: }
950:
951: }
952:
953: void Weapon_HyperBlaster (edict_t *ent)
954: {
955: static int pause_frames[] = {0};
956: static int fire_frames[] = {6, 7, 8, 9, 10, 11, 0};
957:
958: Weapon_Generic (ent, 5, 20, 49, 53, pause_frames, fire_frames, Weapon_HyperBlaster_Fire);
959: }
960:
961: /*
962: ======================================================================
963:
964: MACHINEGUN / CHAINGUN
965:
966: ======================================================================
967: */
968:
969: void Machinegun_Fire (edict_t *ent)
970: {
971: int i;
972: vec3_t start;
973: vec3_t forward, right;
974: vec3_t angles;
975: int damage = 8;
976: int kick = 2;
977: vec3_t offset;
978:
979: if (!(ent->client->buttons & BUTTON_ATTACK))
980: {
981: ent->client->machinegun_shots = 0;
982: ent->client->ps.gunframe++;
983: return;
984: }
985:
986: if (ent->client->ps.gunframe == 5)
987: ent->client->ps.gunframe = 4;
988: else
989: ent->client->ps.gunframe = 5;
990:
991: if (ent->client->pers.inventory[ent->client->ammo_index] < 1)
992: {
993: ent->client->ps.gunframe = 6;
994: if (level.time >= ent->pain_debounce_time)
995: {
996: gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
997: ent->pain_debounce_time = level.time + 1;
998: }
999: NoAmmoWeaponChange (ent);
1000: return;
1001: }
1002:
1003: if (is_quad)
1004: {
1005: damage *= 4;
1006: kick *= 4;
1007: }
1008:
1009: for (i=1 ; i<3 ; i++)
1010: {
1011: ent->client->kick_origin[i] = crandom() * 0.35;
1012: ent->client->kick_angles[i] = crandom() * 0.7;
1013: }
1014: ent->client->kick_origin[0] = crandom() * 0.35;
1015: ent->client->kick_angles[0] = ent->client->machinegun_shots * -1.5;
1016:
1017: // raise the gun as it is firing
1018: if (!deathmatch->value)
1019: {
1020: ent->client->machinegun_shots++;
1021: if (ent->client->machinegun_shots > 9)
1022: ent->client->machinegun_shots = 9;
1023: }
1024:
1025: // get start / end positions
1026: VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
1027: AngleVectors (angles, forward, right, NULL);
1028: VectorSet(offset, 0, 8, ent->viewheight-8);
1029: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1030: fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
1031:
1032: gi.WriteByte (svc_muzzleflash);
1033: gi.WriteShort (ent-g_edicts);
1034: gi.WriteByte (MZ_MACHINEGUN | is_silenced);
1035: gi.multicast (ent->s.origin, MULTICAST_PVS);
1036:
1037: PlayerNoise(ent, start, PNOISE_WEAPON);
1038:
1039: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1040: ent->client->pers.inventory[ent->client->ammo_index]--;
1041:
1042: ent->client->anim_priority = ANIM_ATTACK;
1043: if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
1044: {
1045: ent->s.frame = FRAME_crattak1 - (int) (random()+0.25);
1046: ent->client->anim_end = FRAME_crattak9;
1047: }
1048: else
1049: {
1050: ent->s.frame = FRAME_attack1 - (int) (random()+0.25);
1051: ent->client->anim_end = FRAME_attack8;
1052: }
1053: }
1054:
1055: void Weapon_Machinegun (edict_t *ent)
1056: {
1057: static int pause_frames[] = {23, 45, 0};
1058: static int fire_frames[] = {4, 5, 0};
1059:
1060: Weapon_Generic (ent, 3, 5, 45, 49, pause_frames, fire_frames, Machinegun_Fire);
1061: }
1062:
1063: void Chaingun_Fire (edict_t *ent)
1064: {
1065: int i;
1066: int shots;
1067: vec3_t start;
1068: vec3_t forward, right, up;
1069: float r, u;
1070: vec3_t offset;
1071: int damage;
1072: int kick = 2;
1073:
1074: if (deathmatch->value)
1075: damage = 6;
1076: else
1077: damage = 8;
1078:
1079: if (ent->client->ps.gunframe == 5)
1080: gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0);
1081:
1082: if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK))
1083: {
1084: ent->client->ps.gunframe = 32;
1085: ent->client->weapon_sound = 0;
1086: return;
1087: }
1088: else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK)
1089: && ent->client->pers.inventory[ent->client->ammo_index])
1090: {
1091: ent->client->ps.gunframe = 15;
1092: }
1093: else
1094: {
1095: ent->client->ps.gunframe++;
1096: }
1097:
1098: if (ent->client->ps.gunframe == 22)
1099: {
1100: ent->client->weapon_sound = 0;
1101: gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0);
1102: }
1103: else
1104: {
1105: ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav");
1106: }
1107:
1108: ent->client->anim_priority = ANIM_ATTACK;
1109: if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
1110: {
1111: ent->s.frame = FRAME_crattak1 - (ent->client->ps.gunframe & 1);
1112: ent->client->anim_end = FRAME_crattak9;
1113: }
1114: else
1115: {
1116: ent->s.frame = FRAME_attack1 - (ent->client->ps.gunframe & 1);
1117: ent->client->anim_end = FRAME_attack8;
1118: }
1119:
1120: if (ent->client->ps.gunframe <= 9)
1121: shots = 1;
1122: else if (ent->client->ps.gunframe <= 14)
1123: {
1124: if (ent->client->buttons & BUTTON_ATTACK)
1125: shots = 2;
1126: else
1127: shots = 1;
1128: }
1129: else
1130: shots = 3;
1131:
1132: if (ent->client->pers.inventory[ent->client->ammo_index] < shots)
1133: shots = ent->client->pers.inventory[ent->client->ammo_index];
1134:
1135: if (!shots)
1136: {
1137: if (level.time >= ent->pain_debounce_time)
1138: {
1139: gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
1140: ent->pain_debounce_time = level.time + 1;
1141: }
1142: NoAmmoWeaponChange (ent);
1143: return;
1144: }
1145:
1146: if (is_quad)
1147: {
1148: damage *= 4;
1149: kick *= 4;
1150: }
1151:
1152: for (i=0 ; i<3 ; i++)
1153: {
1154: ent->client->kick_origin[i] = crandom() * 0.35;
1155: ent->client->kick_angles[i] = crandom() * 0.7;
1156: }
1157:
1158: for (i=0 ; i<shots ; i++)
1159: {
1160: // get start / end positions
1161: AngleVectors (ent->client->v_angle, forward, right, up);
1162: r = 7 + crandom()*4;
1163: u = crandom()*4;
1164: VectorSet(offset, 0, r, u + ent->viewheight-8);
1165: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1166:
1167: fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_CHAINGUN);
1168: }
1169:
1170: // send muzzle flash
1171: gi.WriteByte (svc_muzzleflash);
1172: gi.WriteShort (ent-g_edicts);
1173: gi.WriteByte ((MZ_CHAINGUN1 + shots - 1) | is_silenced);
1174: gi.multicast (ent->s.origin, MULTICAST_PVS);
1175:
1176: PlayerNoise(ent, start, PNOISE_WEAPON);
1177:
1178: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1179: ent->client->pers.inventory[ent->client->ammo_index] -= shots;
1180: }
1181:
1182:
1183: void Weapon_Chaingun (edict_t *ent)
1184: {
1185: static int pause_frames[] = {38, 43, 51, 61, 0};
1186: static int fire_frames[] = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0};
1187:
1188: Weapon_Generic (ent, 4, 31, 61, 64, pause_frames, fire_frames, Chaingun_Fire);
1189: }
1190:
1191:
1192: /*
1193: ======================================================================
1194:
1195: SHOTGUN / SUPERSHOTGUN
1196:
1197: ======================================================================
1198: */
1199:
1200: void weapon_shotgun_fire (edict_t *ent)
1201: {
1202: vec3_t start;
1203: vec3_t forward, right;
1204: vec3_t offset;
1205: int damage = 4;
1206: int kick = 8;
1207:
1208: if (ent->client->ps.gunframe == 9)
1209: {
1210: ent->client->ps.gunframe++;
1211: return;
1212: }
1213:
1214: AngleVectors (ent->client->v_angle, forward, right, NULL);
1215:
1216: VectorScale (forward, -2, ent->client->kick_origin);
1217: ent->client->kick_angles[0] = -2;
1218:
1219: VectorSet(offset, 0, 8, ent->viewheight-8);
1220: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1221:
1222: if (is_quad)
1223: {
1224: damage *= 4;
1225: kick *= 4;
1226: }
1227:
1228: if (deathmatch->value)
1229: fire_shotgun (ent, start, forward, damage, kick, 500, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
1230: else
1231: fire_shotgun (ent, start, forward, damage, kick, 500, 500, DEFAULT_SHOTGUN_COUNT, MOD_SHOTGUN);
1232:
1233: // send muzzle flash
1234: gi.WriteByte (svc_muzzleflash);
1235: gi.WriteShort (ent-g_edicts);
1236: gi.WriteByte (MZ_SHOTGUN | is_silenced);
1237: gi.multicast (ent->s.origin, MULTICAST_PVS);
1238:
1239: ent->client->ps.gunframe++;
1240: PlayerNoise(ent, start, PNOISE_WEAPON);
1241:
1242: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1243: ent->client->pers.inventory[ent->client->ammo_index]--;
1244: }
1245:
1246: void Weapon_Shotgun (edict_t *ent)
1247: {
1248: static int pause_frames[] = {22, 28, 34, 0};
1249: static int fire_frames[] = {8, 9, 0};
1250:
1251: Weapon_Generic (ent, 7, 18, 36, 39, pause_frames, fire_frames, weapon_shotgun_fire);
1252: }
1253:
1254:
1255: void weapon_supershotgun_fire (edict_t *ent)
1256: {
1257: vec3_t start;
1258: vec3_t forward, right;
1259: vec3_t offset;
1260: vec3_t v;
1261: int damage = 6;
1262: int kick = 12;
1263:
1264: AngleVectors (ent->client->v_angle, forward, right, NULL);
1265:
1266: VectorScale (forward, -2, ent->client->kick_origin);
1267: ent->client->kick_angles[0] = -2;
1268:
1269: VectorSet(offset, 0, 8, ent->viewheight-8);
1270: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1271:
1272: if (is_quad)
1273: {
1274: damage *= 4;
1275: kick *= 4;
1276: }
1277:
1278: v[PITCH] = ent->client->v_angle[PITCH];
1279: v[YAW] = ent->client->v_angle[YAW] - 5;
1280: v[ROLL] = ent->client->v_angle[ROLL];
1281: AngleVectors (v, forward, NULL, NULL);
1282: fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);
1283: v[YAW] = ent->client->v_angle[YAW] + 5;
1284: AngleVectors (v, forward, NULL, NULL);
1285: fire_shotgun (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);
1286:
1287: // send muzzle flash
1288: gi.WriteByte (svc_muzzleflash);
1289: gi.WriteShort (ent-g_edicts);
1290: gi.WriteByte (MZ_SSHOTGUN | is_silenced);
1291: gi.multicast (ent->s.origin, MULTICAST_PVS);
1292:
1293: ent->client->ps.gunframe++;
1294: PlayerNoise(ent, start, PNOISE_WEAPON);
1295:
1296: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1297: ent->client->pers.inventory[ent->client->ammo_index] -= 2;
1298: }
1299:
1300: void Weapon_SuperShotgun (edict_t *ent)
1301: {
1302: static int pause_frames[] = {29, 42, 57, 0};
1303: static int fire_frames[] = {7, 0};
1304:
1305: Weapon_Generic (ent, 6, 17, 57, 61, pause_frames, fire_frames, weapon_supershotgun_fire);
1306: }
1307:
1308:
1309:
1310: /*
1311: ======================================================================
1312:
1313: RAILGUN
1314:
1315: ======================================================================
1316: */
1317:
1318: void weapon_railgun_fire (edict_t *ent)
1319: {
1320: vec3_t start;
1321: vec3_t forward, right;
1322: vec3_t offset;
1323: int damage;
1324: int kick;
1325:
1326: if (deathmatch->value)
1327: { // normal damage is too extreme in dm
1328: damage = 100;
1329: kick = 200;
1330: }
1331: else
1332: {
1333: damage = 150;
1334: kick = 250;
1335: }
1336:
1337: if (is_quad)
1338: {
1339: damage *= 4;
1340: kick *= 4;
1341: }
1342:
1343: AngleVectors (ent->client->v_angle, forward, right, NULL);
1344:
1345: VectorScale (forward, -3, ent->client->kick_origin);
1346: ent->client->kick_angles[0] = -3;
1347:
1348: VectorSet(offset, 0, 7, ent->viewheight-8);
1349: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1350: fire_rail (ent, start, forward, damage, kick);
1351:
1352: // send muzzle flash
1353: gi.WriteByte (svc_muzzleflash);
1354: gi.WriteShort (ent-g_edicts);
1355: gi.WriteByte (MZ_RAILGUN | is_silenced);
1356: gi.multicast (ent->s.origin, MULTICAST_PVS);
1357:
1358: ent->client->ps.gunframe++;
1359: PlayerNoise(ent, start, PNOISE_WEAPON);
1360:
1361: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1362: ent->client->pers.inventory[ent->client->ammo_index]--;
1363: }
1364:
1365:
1366: void Weapon_Railgun (edict_t *ent)
1367: {
1368: static int pause_frames[] = {56, 0};
1369: static int fire_frames[] = {4, 0};
1370:
1371: Weapon_Generic (ent, 3, 18, 56, 61, pause_frames, fire_frames, weapon_railgun_fire);
1372: }
1373:
1374:
1375: /*
1376: ======================================================================
1377:
1378: BFG10K
1379:
1380: ======================================================================
1381: */
1382:
1383: void weapon_bfg_fire (edict_t *ent)
1384: {
1385: vec3_t offset, start;
1386: vec3_t forward, right;
1387: int damage;
1388: float damage_radius = 1000;
1389:
1390: if (deathmatch->value)
1391: damage = 200;
1392: else
1393: damage = 500;
1394:
1395: if (ent->client->ps.gunframe == 9)
1396: {
1397: // send muzzle flash
1398: gi.WriteByte (svc_muzzleflash);
1399: gi.WriteShort (ent-g_edicts);
1400: gi.WriteByte (MZ_BFG | is_silenced);
1401: gi.multicast (ent->s.origin, MULTICAST_PVS);
1402:
1403: ent->client->ps.gunframe++;
1404:
1405: PlayerNoise(ent, start, PNOISE_WEAPON);
1406: return;
1407: }
1408:
1409: // cells can go down during windup (from power armor hits), so
1410: // check again and abort firing if we don't have enough now
1411: if (ent->client->pers.inventory[ent->client->ammo_index] < 50)
1412: {
1413: ent->client->ps.gunframe++;
1414: return;
1415: }
1416:
1417: if (is_quad)
1418: damage *= 4;
1419:
1420: AngleVectors (ent->client->v_angle, forward, right, NULL);
1421:
1422: VectorScale (forward, -2, ent->client->kick_origin);
1423:
1424: // make a big pitch kick with an inverse fall
1425: ent->client->v_dmg_pitch = -40;
1426: ent->client->v_dmg_roll = crandom()*8;
1427: ent->client->v_dmg_time = level.time + DAMAGE_TIME;
1428:
1429: VectorSet(offset, 8, 8, ent->viewheight-8);
1430: P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1431: fire_bfg (ent, start, forward, damage, 400, damage_radius);
1432:
1433: ent->client->ps.gunframe++;
1434:
1435: PlayerNoise(ent, start, PNOISE_WEAPON);
1436:
1437: if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1438: ent->client->pers.inventory[ent->client->ammo_index] -= 50;
1439: }
1440:
1441: void Weapon_BFG (edict_t *ent)
1442: {
1443: static int pause_frames[] = {39, 45, 50, 55, 0};
1444: static int fire_frames[] = {9, 17, 0};
1445:
1446: Weapon_Generic (ent, 8, 32, 55, 58, pause_frames, fire_frames, weapon_bfg_fire);
1447: }
1448:
1449:
1450: //======================================================================
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.