1 #include "g_local.h"
2 #include "m_player.h"
3
4 #define FRAME_FIRE_FIRST (FRAME_ACTIVATE_LAST + 1)
5 #define FRAME_IDLE_FIRST (FRAME_FIRE_LAST + 1)
6 #define FRAME_DEACTIVATE_FIRST (FRAME_IDLE_LAST + 1)
7
P_ProjectSource(gclient_t * client,vec3_t point,vec3_t distance,vec3_t forward,vec3_t right,vec3_t result)8 static void P_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
9 {
10 vec3_t _distance;
11
12 VectorCopy (distance, _distance);
13 if (client->pers.hand == LEFT_HANDED)
14 _distance[1] *= -1;
15 else if (client->pers.hand == CENTER_HANDED)
16 _distance[1] = 0;
17 G_ProjectSource (point, _distance, forward, right, result);
18 }
Akimbo_ProjectSource(gclient_t * client,vec3_t point,vec3_t distance,vec3_t forward,vec3_t right,vec3_t result)19 static void Akimbo_ProjectSource (gclient_t *client, vec3_t point, vec3_t distance, vec3_t forward, vec3_t right, vec3_t result)
20 {
21 vec3_t _distance;
22
23 VectorCopy (distance, _distance);
24
25 if (client->current_hand == HAND_OTHER)
26 _distance[1] *= -1;
27
28 G_ProjectSource (point, _distance, forward, right, result);
29 }
30
Akimbo_Weapon_Generic(edict_t * ent,int FRAME_ACTIVATE_LAST,int FRAME_FIRE_LAST,int FRAME_IDLE_LAST,int FRAME_DEACTIVATE_LAST,int FRAME_FIRE_OTHER_FIRST,int FRAME_FIRE_OTHER_LAST,int * pause_frames,int * fire_frames,void (* fire)(edict_t * ent),int ammouse)31 void Akimbo_Weapon_Generic (edict_t *ent,
32 int FRAME_ACTIVATE_LAST,
33 int FRAME_FIRE_LAST,
34 int FRAME_IDLE_LAST,
35 int FRAME_DEACTIVATE_LAST,
36 int FRAME_FIRE_OTHER_FIRST,
37 int FRAME_FIRE_OTHER_LAST,
38 int *pause_frames,
39 int *fire_frames,
40 void (*fire)(edict_t *ent), int ammouse)
41 {
42 int n;
43 int FRAME_FIRE_SECONDARY_FIRST;
44 int FRAME_FIRE_SECONDARY_LAST;
45 qboolean secondary_fire_weapon = false;
46 if(strcmp(ent->client->pers.weapon->classname, "weapon_m4") == 0)
47 {
48 FRAME_FIRE_SECONDARY_FIRST = 26;
49 FRAME_FIRE_SECONDARY_LAST = 27;
50 secondary_fire_weapon = true;
51 }
52 if(strcmp(ent->client->pers.weapon->classname, "weapon_knives") == 0)
53 {
54 FRAME_FIRE_SECONDARY_FIRST = 103;
55 FRAME_FIRE_SECONDARY_LAST = 106;
56 secondary_fire_weapon = true;
57 }
58 if(ent->deadflag || ent->s.modelindex != 255) // VWep animations screw up corpses
59 {
60 return;
61 }
62
63 if (ent->client->weaponstate == WEAPON_DROPPING)
64 {
65 if ((ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST) &&
66 (ent->client->ps.gunindex == gi.modelindex(ent->client->pers.weapon->akimbo_model)))
67 {
68
69 }
70 if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST)
71 {
72 //if(ent->client->akimbo)
73 // ent->client->akimbo = false;
74 MatrixChangeWeapon (ent);
75 return;
76 }
77 else if ((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4)
78 {
79 ent->client->anim_priority = ANIM_REVERSE;
80 if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
81 {
82 ent->s.frame = FRAME_crpain4+1;
83 ent->client->anim_end = FRAME_crpain1;
84 }
85 else
86 {
87 ent->s.frame = FRAME_pain304+1;
88 ent->client->anim_end = FRAME_pain301;
89
90 }
91 }
92
93 ent->client->ps.gunframe++;
94 return;
95 }
96
97 if (ent->client->weaponstate == WEAPON_ACTIVATING)
98 {
99 if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST)
100 {
101 ent->client->weaponstate = WEAPON_READY;
102 ent->client->ps.gunframe = FRAME_IDLE_FIRST;
103 return;
104 }
105
106 ent->client->ps.gunframe++;
107 return;
108 }
109
110 if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING))
111 {
112 ent->client->weaponstate = WEAPON_DROPPING;
113 ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
114
115 if ((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4)
116 {
117 ent->client->anim_priority = ANIM_REVERSE;
118 if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
119 {
120 ent->s.frame = FRAME_crpain4+1;
121 ent->client->anim_end = FRAME_crpain1;
122 }
123 else
124 {
125 ent->s.frame = FRAME_pain304+1;
126 ent->client->anim_end = FRAME_pain301;
127
128 }
129 }
130 return;
131 }
132
133 if (ent->client->weaponstate == WEAPON_READY)
134 {
135 if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) || ent->secondaryfire )
136 {
137 ent->client->latched_buttons &= ~BUTTON_ATTACK;
138 if ((!ent->client->ammo_index) ||
139 ( ent->client->pers.inventory[ent->client->ammo_index] >= ammouse))
140 {
141 // MATRIX
142 if (ent->secondaryfire && secondary_fire_weapon)
143 {
144
145 ent->client->ps.gunframe = FRAME_FIRE_SECONDARY_FIRST;
146 ent->client->current_hand = HAND_DEFAULT;
147 }
148 else if (ent->client->next_hand == HAND_OTHER)
149 {
150 ent->client->current_hand = HAND_OTHER;
151 ent->client->ps.gunframe = FRAME_FIRE_OTHER_FIRST;
152 ent->client->next_hand = HAND_DEFAULT;
153 }
154 else if (ent->client->next_hand == HAND_DEFAULT)
155 {
156
157 ent->client->current_hand = HAND_DEFAULT;
158 ent->client->ps.gunframe = FRAME_FIRE_FIRST;
159 ent->client->next_hand = HAND_OTHER;
160 }
161
162
163
164
165 // MATRIX
166
167 ent->client->weaponstate = WEAPON_FIRING;
168
169 // start the animation
170 ent->client->anim_priority = ANIM_ATTACK;
171 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
172 {
173 ent->s.frame = FRAME_crattak1-1;
174 ent->client->anim_end = FRAME_crattak9;
175 }
176 else
177 {
178 ent->s.frame = FRAME_attack1-1;
179 ent->client->anim_end = FRAME_attack8;
180 }
181 }
182 else
183 {
184 if (level.time >= ent->pain_debounce_time)
185 {
186 gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
187 ent->pain_debounce_time = level.time + 1;
188 }
189 NoAmmoWeaponChange (ent);
190 }
191 }
192 else
193 {
194 if (ent->client->ps.gunframe == FRAME_IDLE_LAST)
195 {
196 ent->client->ps.gunframe = FRAME_IDLE_FIRST;
197 return;
198 }
199
200 if (pause_frames)
201 {
202 for (n = 0; pause_frames[n]; n++)
203 {
204 if (ent->client->ps.gunframe == pause_frames[n])
205 {
206 if (rand()&15)
207 return;
208 }
209 }
210 }
211
212 ent->client->ps.gunframe++;
213 return;
214 }
215 }
216
217 if (ent->client->weaponstate == WEAPON_FIRING)
218 {
219 for (n = 0; fire_frames[n]; n++)
220 {
221 if (ent->client->ps.gunframe == fire_frames[n])
222 {
223 if (ent->client->quad_framenum > level.framenum)
224 gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
225
226 fire (ent);
227 if (ent->client->pers.inventory[ent->client->ammo_index] < 0)
228 ent->client->pers.inventory[ent->client->ammo_index] = 0;
229 break;
230 }
231 }
232 if (!fire_frames[n])
233 ent->client->ps.gunframe++;
234
235 if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1)
236 ent->client->weaponstate = WEAPON_READY;
237 // MATRIX
238 if ((ent->client->current_hand == HAND_OTHER) && (ent->client->ps.gunframe > FRAME_FIRE_OTHER_LAST || ent->client->ps.gunframe > FRAME_FIRE_SECONDARY_LAST ))
239 {
240 ent->client->ps.gunframe = FRAME_IDLE_FIRST+1;
241 ent->client->weaponstate = WEAPON_READY;
242 }
243 if (ent->client->ps.gunframe == FRAME_FIRE_SECONDARY_LAST && secondary_fire_weapon)
244 {
245 ent->client->ps.gunframe = FRAME_IDLE_FIRST+1;
246 ent->client->weaponstate = WEAPON_READY;
247 }
248 // MATRIX
249
250 }
251 }
252 /*
253 ===================
254 kick_attack
255 Actual Melee Weapon
256 ===================
257 */
kick_attack(edict_t * ent,vec3_t start,vec3_t dir,int damage,int kick,int MOD)258 void kick_attack (edict_t *ent, vec3_t start, vec3_t dir, int damage, int kick, int MOD)
259 {
260
261 vec3_t forward, right;
262 vec3_t offset;
263
264 trace_t tr;
265 vec3_t end;
266 float sound;
267
268 if (ent->deadflag || ent->health < 0)
269 return;
270
271 sound = random() * 3;
272 //if (sound>2)
273 // sound=0;
274 if (!(ent->client->ps.pmove.pm_flags & PMF_DUCKED))
275 {
276
277 if(sound >=0)
278 {
279 ent->s.frame = FRAME_flip01-1;
280 ent->client->anim_end = FRAME_flip06;
281 }
282 if(sound>=1)
283 {
284 ent->s.frame = FRAME_wave02;
285 ent->client->anim_end = FRAME_wave08;
286 }
287 if(sound>=2)
288 {
289 ent->client->anim_priority = ANIM_REVERSE;
290 ent->s.frame = FRAME_wave06;
291 ent->client->anim_end = FRAME_wave02;
292 }
293 }
294 AngleVectors (ent->client->v_angle, forward, right, NULL);
295
296 VectorScale (forward, 0, ent->client->kick_origin);
297
298 VectorSet(offset, 0, 0, ent->viewheight-20);
299 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
300
301 VectorMA( start, 80, forward, end );
302
303 tr = gi.trace (ent->s.origin, NULL, NULL, end, ent, MASK_MONSTERSOLID);
304 if (sound >= 0)
305 {
306 gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/throw.wav"), 1, ATTN_NORM, 0);
307 PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
308 }
309 if (sound >= 1)
310 {
311 gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/throw.wav"), 1, ATTN_NORM, 0);
312 PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
313 }
314 if(sound >= 2)
315 {
316 gi.sound(ent, CHAN_WEAPON, gi.soundindex("misc/swish.wav"), 1, ATTN_NORM, 0);
317 PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
318 }
319 // don't need to check for water
320
321 if (tr.fraction < 1.0)
322 {
323 if (tr.ent->takedamage)
324 {
325 // T_Damage (tr.ent, ent, ent, forward, tr.endpos, tr.plane.normal, damage, kick, 0, MOD_UNKNOWN );
326 T_Damage (tr.ent, ent, ent, vec3_origin, tr.endpos, tr.plane.normal, damage, kick, DAMAGE_NO_KNOCKBACK, MOD);
327
328 if (ent->solid != SOLID_NOT )
329 gi.sound(ent, CHAN_AUTO, gi.soundindex("misc/kick.wav"), 1, ATTN_NORM, 0);
330 //PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
331 }
332 }
333
334 }
335 /*
336 ===================
337 Decide_attack
338 Type of attack forr boot. varies with jumping, ducking and standing
339 ===================
340 */
Decide_attack(edict_t * ent)341 void Decide_attack (edict_t *ent)
342 {
343 int damage,kick;
344 vec3_t offset, start;
345 vec3_t dir, right;
346 vec3_t v;
347 qboolean is_quad;
348
349 if (ent->matrixflip == RWALL)//if you're running up a wall
350 {
351 MatrixJump (ent);
352 ent->jumping = true;
353 return;// FEAR - I added this to make it work better
354 //used up kick on flip off wall
355 }
356 if (ent->stamina < 3)
357 return;
358
359 // if ((ent->s.frame > FRAME_flip01) && (ent->s.frame < FRAME_point12))
360 // return;
361
362 if (!ent->groundentity)
363 {
364 if (ent->velocity[2] > 0)
365 ent->velocity[2] += 10;
366 else
367 ent->velocity[2] += 50;
368 }
369
370 is_quad = (ent->client->quad_framenum > level.framenum);
371 //sweep, angled up
372 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
373 {
374 ent->stamina -= 6;
375 kick = 400;
376 damage = 25;
377 if(is_quad)
378 {
379 damage *=4;
380 kick*=4;
381 }
382
383
384 v[PITCH] = ent->client->v_angle[PITCH]-45;
385 v[YAW] = ent->client->v_angle[YAW];
386 v[ROLL] = ent->client->v_angle[ROLL];
387
388 AngleVectors (v, dir, right, NULL);
389
390 VectorScale (dir, -2, ent->client->kick_origin);
391 VectorSet(offset, 8, 8, ent->viewheight-16);
392 P_ProjectSource (ent->client, ent->s.origin, offset, dir, right, start);
393
394 if(ent->kungfu_framenum > level.time)
395 KungFu_l33t_Skillz (ent, damage, kick, MOD_SWEEP);
396 else
397 kick_attack (ent, start, dir , damage, kick, MOD_SWEEP);
398 }
399 else if (!ent->groundentity)
400 {
401 if(ent->velocity[2] > -100)
402 {
403 if(ent->velocity[2] < 0)
404 ent->velocity[2]=+10;
405 else
406 ent->velocity[2]+=40;
407 }
408 ent->stamina -= 8;
409 damage = 20;
410 kick = 300;
411 if(is_quad)
412 {
413 damage *=4;
414 kick*=4;
415 }
416 v[PITCH] = ent->client->v_angle[PITCH]+45;
417 v[YAW] = ent->client->v_angle[YAW];
418 v[ROLL] = ent->client->v_angle[ROLL];
419
420 AngleVectors (v, dir, right, NULL);
421
422 VectorScale (dir, -2, ent->client->kick_origin);
423 VectorSet(offset, 8, 8, ent->viewheight-16);
424 P_ProjectSource (ent->client, ent->s.origin, offset, dir, right, start);
425
426 if(ent->kungfu_framenum > level.time)
427 KungFu_l33t_Skillz (ent, damage, kick, MOD_HOVER);
428 else
429 kick_attack (ent, start, dir , damage, kick, MOD_HOVER);
430 }
431 else
432 {
433 ent->stamina -= 6;
434 damage = 20;
435 kick = 400;
436 if(is_quad)
437 {
438 damage *=4;
439 kick*=4;
440 }
441
442 VectorScale (dir, -2, ent->client->kick_origin);
443 VectorSet(offset, 8, 8, ent->viewheight-16);
444 P_ProjectSource (ent->client, ent->s.origin, offset, dir, right, start);
445
446 if(ent->kungfu_framenum > level.time)
447 KungFu_l33t_Skillz (ent, damage, kick, MOD_KICK);
448 else
449 kick_attack (ent, start, dir , damage, kick, MOD_KICK);
450 }
451
452 }
453
454
KungFu_l33t_Skillz(edict_t * ent,int damage,int kick,int mod)455 void KungFu_l33t_Skillz (edict_t *ent, int damage, int kick, int mod)//kungfu auto aiming
456 {
457 edict_t *enemy;
458 edict_t *ignore = ent;
459 vec3_t start;
460 vec3_t end;
461 vec3_t dir;
462 vec3_t point;
463 trace_t tr;
464
465 //enemy = findradius (enemy, ent->s.origin, 48);
466
467 while ((enemy = findradius(NULL, ent->s.origin, 256)) != NULL)
468 {
469 if (enemy == ent)
470 continue;
471
472 if (!enemy->takedamage)
473 continue;
474
475 if (!(enemy->svflags & SVF_MONSTER) && (!enemy->client) && (strcmp(enemy->classname, "misc_explobox") != 0))
476 continue;
477
478 VectorMA (enemy->absmin, 0.5, enemy->size, point);
479
480 VectorSubtract (point, ent->s.origin, dir);
481 VectorNormalize (dir);
482
483 VectorCopy (ent->s.origin, start);
484 VectorMA (start, 2048, dir, end);
485
486 tr = gi.trace (start, NULL, NULL, end, ignore, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_DEADMONSTER);
487
488 if ((tr.ent->takedamage) && !(tr.ent->flags & FL_IMMUNE_LASER) && (tr.ent != ent->owner))
489 T_Damage (tr.ent, ent, ent->owner, dir, tr.endpos, vec3_origin, damage, 1, DAMAGE_ENERGY, mod);
490
491 //if (!tr.ent)
492 // continue;
493
494 //kick_attack (ent, start, dir, damage, kick, mod);
495 }
496
497 }
498
499
500 void target_laser_think (edict_t *self);
LineThink(edict_t * self)501 void LineThink (edict_t *self)
502 {
503 target_laser_think(self);
504
505 self->think = LineThink;
506 self->nextthink = level.time + FRAMETIME;
507
508 if (!(self->owner->client->buttons) & BUTTON_ATTACK)
509 {
510 //self->think = G_FreeEdict;
511 //self->nextthink = level.time + FRAMETIME;
512 VectorCopy(vec3_origin, self->s.origin);
513 VectorCopy(vec3_origin, self->s.old_origin);
514 VectorCopy(vec3_origin, self->movedir);
515 }
516 }
517 // draws a translucent line from spos to epos
DrawLine(edict_t * owner,vec3_t spos,vec3_t epos)518 edict_t *DrawLine(edict_t *owner, vec3_t spos, vec3_t epos)
519 {
520 edict_t *beam;
521
522 beam = G_Spawn();
523
524 beam->owner = owner;
525 beam->spawnflags = 1 | 4;
526 beam->classname = "path_beam";
527
528 beam->movetype = MOVETYPE_NONE;
529 beam->solid = SOLID_NOT;
530 beam->s.renderfx |= RF_BEAM|RF_TRANSLUCENT;
531 beam->s.modelindex = 1; // must be non-zero
532 beam->activator = owner;
533 // set the beam diameter
534 beam->s.frame = 2;// The thinest it can be
535 // set the color (red)
536 if (owner->client->resp.team == TEAM_RED)
537 beam->s.skinnum = 0xf2f2f0f0;// RED
538 else if (owner->client->resp.team == TEAM_BLUE)
539 beam->s.skinnum = 0xf3f3f1f1;// BLUE
540 else
541 beam->s.skinnum = 0xf2f2f0f0;// red
542
543 VectorSet (beam->mins, -1, -1, -1);
544 VectorSet (beam->maxs, 1, 1, 1);
545
546 beam->spawnflags |= 0x80000001;
547 beam->svflags &= ~SVF_NOCLIENT;
548 beam->flags |= FL_TEAMSLAVE;
549
550 VectorCopy(spos, beam->s.origin);
551 VectorCopy(epos, beam->s.old_origin);
552
553 VectorSubtract(epos, spos, beam->movedir);
554 // VectorNormalize2(beam->movedir, beam->movedir);
555
556 beam->dmg = 0;
557 beam->enemy = NULL;
558
559 beam->think = LineThink;//target_laser_think;
560 beam->nextthink = level.time + FRAMETIME;
561 beam->think(beam);
562
563 gi.linkentity (beam);
564
565 return beam;
566 }
MatrixDrawBeam(edict_t * ent)567 void MatrixDrawBeam(edict_t *ent)
568 {
569 vec3_t start, end, offset, f, r, u, dir;
570 // float distance;
571
572 // VectorCopy (ent->s.origin, start);
573 AngleVectors (ent->client->v_angle, f, r, NULL);
574 VectorSet(offset, 0, 7, ent->viewheight-8);
575 P_ProjectSource (ent->client, ent->s.origin, offset, f, r, start);
576
577
578 VectorMA (start, 8192, f, end);
579
580 if (!ent->beam)
581 ent->beam = DrawLine(ent, start, end);
582 else
583 {
584 VectorCopy(start, ent->beam->s.origin);
585 VectorCopy(end, ent->beam->s.old_origin);
586
587 VectorSubtract(end, start, ent->beam->movedir);
588 }
589
590 }
591
592
MatrixChuckShells(edict_t * ent,int model)593 void MatrixChuckShells(edict_t *ent, int model)
594 {
595 edict_t *gun;
596 vec3_t start, end, offset, forward, right, up;
597
598 if(shellsoff->value)
599 return;
600 AngleVectors (ent->client->v_angle, forward, right, NULL);
601 VectorSet(offset, 8, 8, ent->viewheight-8);
602 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
603
604 gun = G_Spawn();
605
606
607 VectorCopy(start, gun->s.origin);
608 VectorSet(gun->avelocity, (100+200*crandom()), (100+200*crandom()), (100+200*crandom()));
609
610 VectorScale (right, 200, right);
611 VectorInverse(right);
612 VectorScale (forward, 300, gun->velocity);
613 VectorAdd(right, gun->velocity, gun->velocity);
614 gun->velocity[2] += 600;
615 VectorNormalize(gun->velocity);
616 VectorScale(gun->velocity, 200, gun->velocity);
617
618 gun->velocity[0] += crandom()*20;
619 gun->velocity[1] += crandom()*20;
620 gun->movetype = MOVETYPE_TOSS;
621 gun->nextthink = level.time + 2;
622 gun->think = G_FreeEdict;
623 gun->s.modelindex = model;//gi.modelindex(model"models/objects/shell1/tris.md2"); also shell2
624 //shell 1 = small bore casing
625 //shell 2 = red shotgun casing
626 gi.linkentity (gun);
627 }
MatrixChuckGun(edict_t * ent)628 void MatrixChuckGun(edict_t *ent)
629 {
630 edict_t *gun;
631
632 gun = G_Spawn();
633
634 VectorCopy(ent->s.origin, gun->s.origin);
635 VectorSet(gun->avelocity, 0, 800*crandom() - 400, 0);//spin around y axis.
636 gun->s.angles[ROLL] = 60;
637 gun->velocity[2] = 200;
638 gun->velocity[0] = 200*crandom()-100;
639 gun->velocity[1] = 200*crandom()-100;
640
641
642 gun->movetype = MOVETYPE_TOSS;
643 gun->nextthink = level.time + 15;
644 gun->think = G_FreeEdict;
645 gi.setmodel (gun, ent->client->pers.weapon->world_model);
646 gi.linkentity (gun);
647 }
648
649
650 /*
651 =================
652 MatrixNoAmmoWeaponChange
653 =================
654 */
MatrixNoAmmoWeaponChange(edict_t * ent)655 void MatrixNoAmmoWeaponChange (edict_t *ent)
656 {
657 ent->client->newweapon = FindItem ("Fists of Fury");
658 //ent->client->pers.weapon->view_model = ent->client->newweapon->view_model;
659 ent->client->akimbo =false;
660
661 }
662
663 /*
664 ===============
665 MatrixChangeWeapon
666
667 The old weapon has been dropped all the way, so make the new one
668 current
669 ===============
670 */
MatrixChangeWeapon(edict_t * ent)671 void MatrixChangeWeapon (edict_t *ent)
672 {
673 int i;
674 if (ent->client->pers.inventory[ITEM_INDEX(ent->client->newweapon)] < 1)
675 MatrixNoAmmoWeaponChange(ent);
676 ent->client->pers.lastweapon = ent->client->pers.weapon;
677 ent->client->pers.weapon = ent->client->newweapon;
678 ent->client->newweapon = NULL;
679 ent->client->machinegun_shots = 0;
680
681 // set visible model
682 if (ent->s.modelindex == 255)
683 {
684 if (ent->client->pers.weapon)
685 i = ((ent->client->pers.weapon->weapmodel & 0xff) << 8);
686 else
687 i = 0;
688 ent->s.skinnum = (ent - g_edicts - 1) | i;
689 }
690
691 if (!ent->client->pers.weapon)
692 { // dead
693 ent->client->ps.gunindex = 0;
694 return;
695 }
696
697 ent->client->weaponstate = WEAPON_ACTIVATING;
698 ent->client->ps.gunframe = 0;
699
700 if(ent->client->pers.weapon->akimbo_model)
701 ent->client->akimbo = true;
702
703 if(ent->client->akimbo)
704 ent->client->ps.gunindex = gi.modelindex(ent->client->pers.weapon->akimbo_model);
705 else
706 ent->client->ps.gunindex = gi.modelindex(ent->client->pers.weapon->view_model);
707 //SKULL
708 /* Don't display weapon if chasetoggle is on */
709 if (ent->client->chasetoggle)
710 ent->client->ps.gunindex = 0;
711 //END
712
713 ent->client->anim_priority = ANIM_PAIN;
714 if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
715 {
716 ent->s.frame = FRAME_crpain1;
717 ent->client->anim_end = FRAME_crpain4;
718 }
719 else
720 {
721 ent->s.frame = FRAME_pain301;
722 ent->client->anim_end = FRAME_pain304;
723
724 }
725 }
726 #define FRAME_FIRE_FIRST (FRAME_ACTIVATE_LAST + 1)
727 #define FRAME_IDLE_FIRST (FRAME_FIRE_LAST + 1)
728 #define FRAME_DEACTIVATE_FIRST (FRAME_IDLE_LAST + 1)
729
MatrixWeaponGeneric(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))730 void MatrixWeaponGeneric (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))
731 {
732 int n;
733
734 if(ent->deadflag || ent->s.modelindex != 255) // VWep animations screw up corpses
735 return;
736
737 if (ent->client->weaponstate == WEAPON_DROPPING)
738 {
739 if (ent->client->ps.gunframe == FRAME_DEACTIVATE_LAST)
740 {
741 // CHUCK AND EMPTY
742 MatrixChuckGun(ent);
743 ent->left_in_clip = 0;
744 ent->client->pers.inventory[ITEM_INDEX(ent->client->pers.weapon)]--;
745 MatrixChangeWeapon (ent);
746 return;
747 }
748 else if ((FRAME_DEACTIVATE_LAST - ent->client->ps.gunframe) == 4)
749 {
750 ent->client->anim_priority = ANIM_REVERSE;
751 if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
752 {
753 ent->s.frame = FRAME_crpain4+1;
754 ent->client->anim_end = FRAME_crpain1;
755 }
756 else
757 {
758 ent->s.frame = FRAME_wave08;
759 ent->client->anim_end = FRAME_wave01;
760
761 }
762 }
763
764 ent->client->ps.gunframe++;
765 return;
766 }
767
768 if (ent->client->weaponstate == WEAPON_ACTIVATING)
769 {
770 if (ent->client->ps.gunframe == FRAME_ACTIVATE_LAST)
771 {
772 /* int ammo;
773 ammo = FindItem(ent->client->pers.weapon->ammo)->quantity;
774 if (ammo)
775 ent->left_in_clip += ammo;
776 */
777 ent->client->weaponstate = WEAPON_READY;
778 ent->client->ps.gunframe = FRAME_IDLE_FIRST;
779 return;
780 }
781
782 ent->client->ps.gunframe++;
783 return;
784 }
785
786 if ((ent->client->newweapon) && (ent->client->weaponstate != WEAPON_FIRING))
787 {
788 ent->client->weaponstate = WEAPON_DROPPING;
789 ent->client->ps.gunframe = FRAME_DEACTIVATE_FIRST;
790
791 if ((FRAME_DEACTIVATE_LAST - FRAME_DEACTIVATE_FIRST) < 4)
792 {
793 ent->client->anim_priority = ANIM_REVERSE;
794 if(ent->client->ps.pmove.pm_flags & PMF_DUCKED)
795 {
796 ent->s.frame = FRAME_crpain4+1;
797 ent->client->anim_end = FRAME_crpain1;
798 }
799 else
800 {
801 ent->s.frame = FRAME_wave08;
802 ent->client->anim_end = FRAME_wave01;
803
804 }
805 }
806 return;
807 }
808
809 if (ent->client->weaponstate == WEAPON_READY)
810 {
811 if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) || ent->secondaryfire )
812 {
813 ent->client->latched_buttons &= ~BUTTON_ATTACK;
814 if (ent->left_in_clip > 0)
815 {
816 ent->client->ps.gunframe = FRAME_FIRE_FIRST;
817 ent->client->weaponstate = WEAPON_FIRING;
818 if ( !((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) || ent->secondaryfire && (ent->velocity))
819
820 // start the animation
821 ent->client->anim_priority = ANIM_ATTACK;
822 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
823 {
824 ent->s.frame = FRAME_crattak1-1;
825 ent->client->anim_end = FRAME_crattak9;
826 }
827 else
828 {
829 ent->s.frame = FRAME_attack1-1;
830 ent->client->anim_end = FRAME_attack8;
831 }
832 }
833 else
834 {
835 if (level.time >= ent->pain_debounce_time)
836 {
837 gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
838 ent->pain_debounce_time = level.time + 1;
839 }
840 MatrixNoAmmoWeaponChange (ent);
841 }
842 }
843 else
844 {
845 if (ent->client->ps.gunframe == FRAME_IDLE_LAST)
846 {
847 ent->client->ps.gunframe = FRAME_IDLE_FIRST;
848 return;
849 }
850
851 if (pause_frames)
852 {
853 for (n = 0; pause_frames[n]; n++)
854 {
855 if (ent->client->ps.gunframe == pause_frames[n])
856 {
857 if (rand()&15)
858 return;
859 }
860 }
861 }
862
863 ent->client->ps.gunframe++;
864 return;
865 }
866 }
867
868 if (ent->client->weaponstate == WEAPON_FIRING)
869 {
870 for (n = 0; fire_frames[n]; n++)
871 {
872 if (ent->client->ps.gunframe == fire_frames[n])
873 {
874 if (ent->client->quad_framenum > level.framenum)
875 gi.sound(ent, CHAN_ITEM, gi.soundindex("items/damage3.wav"), 1, ATTN_NORM, 0);
876
877 fire (ent);
878 break;
879 }
880 }
881
882 if (!fire_frames[n])
883 ent->client->ps.gunframe++;
884
885 if (ent->client->ps.gunframe == FRAME_IDLE_FIRST+1)
886 ent->client->weaponstate = WEAPON_READY;
887 }
888 }
889 //----------------------------------------------------------------------------------------//
890 //---------------------------- Matrix Weapons ---------------------------------//
891 //----------------------------------------------------------------------------------------//
892
Matrix_Sniper_Fire(edict_t * ent)893 void Matrix_Sniper_Fire (edict_t *ent)
894 {
895 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
896 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
897 vec3_t start,end, blag;
898 vec3_t forward, right;
899 vec3_t offset;
900 int damage;
901 int kick;
902 trace_t tr;
903
904 //sniper scope test:
905 AngleVectors (ent->client->v_angle, forward, right, NULL);
906 VectorSet(offset, 0, 7, ent->viewheight-8);
907 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
908
909 if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
910 {
911 AngleVectors (ent->client->v_angle, forward, NULL, NULL);
912 VectorMA(ent->s.origin, 1500, forward, blag);
913 VectorSet(offset, 0, 7, ent->viewheight-8);
914 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
915 tr = gi.trace(start, vec3_origin, vec3_origin, blag, ent, MASK_MONSTERSOLID);
916
917 if (!laseroff->value)
918 {
919 gi.WriteByte (svc_temp_entity);
920 gi.WriteByte (TE_BFG_LASER);
921 gi.WritePosition (start);
922 gi.WritePosition (tr.endpos);
923 gi.multicast (tr.endpos, MULTICAST_PHS);
924 }
925
926 if(ent->forwardbuttons || ent->strafebuttons)
927 {
928 ent->client->ps.fov = 90;
929 return;
930 }
931 else
932 {
933
934
935 Matrix_SniperZoom (ent);
936 return;
937 }
938 }
939
940
941 //fix for secondary fire.
942 if (deathmatch->value)
943 { // normal damage is too extreme in dm
944 //damage = 120;
945 damage = damage_sniper->value;
946 kick = 400;
947
948 // gi.cprintf (ent, PRINT_HIGH, "Damage done:%i\n", damage);
949 }
950 else
951 {
952 // normal damage is too extreme in dm - grr i don't care :p
953 damage = damage_sniper->value;
954 kick = 400;
955 }
956
957 ent->client->ps.fov = 90;
958
959 if (is_quad)
960 {
961 damage *= 4;
962 kick *= 4;
963 }
964
965 //SKULL
966 if (ent->client->use)
967 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
968 else
969 //END
970 AngleVectors (ent->client->v_angle, forward, right, NULL);
971
972 VectorScale (forward, -3, ent->client->kick_origin);
973 ent->client->kick_angles[0] = -3;
974
975 VectorSet(offset, 0, 7, ent->viewheight-8);
976 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
977 fire_bullet(ent, start, forward, damage, kick, 0,0, MOD_SNIPER);
978 gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/sniprfire.wav"), 1, ATTN_IDLE, 0);
979
980 // send muzzle flash
981 gi.WriteByte (svc_muzzleflash);
982 //SKULL
983 if (ent->client->use)
984 gi.WriteShort (ent->client->oldplayer-g_edicts);
985 else
986 gi.WriteShort (ent-g_edicts);
987 //END
988 gi.WriteByte (MZ_AK_MK23 | is_silenced);
989 //SKULL
990 //if (ent->client->oldplayer)
991 if (ent->client->use)
992 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
993 else
994 gi.multicast (ent->s.origin, MULTICAST_PVS);
995
996 //END
997
998 ent->client->ps.gunframe++;
999 PlayerNoise(ent, start, PNOISE_WEAPON);
1000
1001 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1002 {
1003 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_sniper->value;
1004 // ent->left_in_clip--;
1005 }
1006 }
Matrix_Sniper(edict_t * ent)1007 void Matrix_Sniper (edict_t *ent)
1008 {
1009 // FORTRESS MODEL
1010 // static int pause_frames[] = {56, 0};
1011 // static int fire_frames[] = {24, 0};
1012
1013 // Weapon_Generic(ent, 23, 28, 49, 53, pause_frames, fire_frames, Matrix_Sniper_Fire);
1014 static int pause_frames[] = {21, 40};
1015 static int fire_frames[] = {9, 0};
1016
1017 Weapon_Generic (ent, 8, 21, 41, 50, pause_frames, fire_frames, Matrix_Sniper_Fire, ammo_sniper->value);
1018 }
1019
Matrix_ak_92f_Fire(edict_t * ent)1020 void Matrix_ak_92f_Fire (edict_t *ent)
1021 {
1022 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
1023 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1024
1025 }
Matrix_ak_92f(edict_t * ent)1026 void Matrix_ak_92f (edict_t *ent)
1027 {
1028 static int pause_frames[] = {23, 45, 0};
1029 static int fire_frames[] = {4, 5, 0};
1030
1031 Weapon_Generic (ent, 3, 5, 45, 49, pause_frames, fire_frames, Matrix_ak_92f_Fire);
1032 }
1033
Matrix_ak_mk23_Fire(edict_t * ent)1034 void Matrix_ak_mk23_Fire (edict_t *ent)
1035 {
1036 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
1037 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1038 int i;
1039 vec3_t start;
1040 vec3_t forward, right;
1041 vec3_t angles;
1042 int damage = damage_mk23->value;
1043 int kick = 2;
1044 vec3_t offset;
1045
1046
1047 if (is_quad)
1048 {
1049 damage *= 4;
1050 kick *= 4;
1051 }
1052
1053 // get start / end positions
1054 //SKULL
1055 if (ent->client->use)
1056 VectorAdd (ent->client->oldplayer->s.angles, ent->client->kick_angles, angles);
1057 else
1058 //END
1059
1060 VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
1061
1062 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index]> ammo_mk23->value *2)
1063 {
1064
1065
1066 AngleVectors (ent->client->v_angle, forward, right, NULL);
1067 VectorSet(offset, 0, -8, ent->viewheight-8);
1068 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1069 fire_bullet (ent, start, forward, damage, kick, 500, 500, MOD_AK_MK23);
1070 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1071
1072 AngleVectors (ent->client->v_angle, forward, right, NULL);
1073 VectorSet(offset, 0, 8, ent->viewheight-8);
1074 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1075 fire_bullet (ent, start, forward, damage, kick, 1000, 500, MOD_AK_MK23);
1076 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1077
1078 ent->client->pers.inventory[ent->client->ammo_index]-=ammo_mk23->value;
1079
1080 }
1081 else
1082 {
1083 AngleVectors (angles, forward, right, NULL);
1084 VectorSet(offset, 0, 8, ent->viewheight-8);
1085 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1086
1087 fire_bullet (ent, start, forward, damage, kick, 20, 20, MOD_AK_MK23);
1088 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1089 }
1090 // fire_streak (ent, start, forward, damage);
1091 // fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
1092
1093 gi.WriteByte (svc_muzzleflash);
1094 if (ent->client->use)
1095 gi.WriteShort (ent->client->oldplayer-g_edicts);
1096 else
1097 gi.WriteShort (ent-g_edicts);
1098 //END
1099 gi.WriteByte (MZ_AK_MK23 | is_silenced);
1100 //SKULL
1101 //if (ent->client->oldplayer)
1102 if (ent->client->use)
1103 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1104 else
1105 gi.multicast (ent->s.origin, MULTICAST_PVS);
1106
1107 PlayerNoise(ent, start, PNOISE_WEAPON);
1108
1109 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1110 {
1111 MatrixChuckShells(ent,gi.modelindex("models/objects/shell1/tris.md2"));
1112 // ent->left_in_clip--;
1113 ent->client->pers.inventory[ent->client->ammo_index]-=ammo_mk23->value;
1114 }
1115 ent->client->ps.gunframe++;
1116 }
1117 /*void Matrix_ak_mk23 (edict_t *ent)
1118 {
1119 static int pause_frames[] = {0};
1120 static int fire_frames[] = {4, 8, 0};
1121
1122 Weapon_Generic (ent, 4, 9, 31, 34, pause_frames, fire_frames, Matrix_ak_mk23_Fire);
1123 }*/
1124
1125
Matrix_pistols(edict_t * ent)1126 void Matrix_pistols (edict_t *ent)
1127 {
1128 if (ent->client->akimbo)
1129 {
1130 static int pause_frames[] = {19, 32, 0};
1131 static int fire_frames[] = {9, 40, 0};
1132 Akimbo_Weapon_Generic (ent, 8, 10, 36, 39, 40, 41, pause_frames, fire_frames, Matrix_ak_mk23_Fire, ammo_mk23->value);
1133
1134 }
1135 else
1136 {
1137 static int pause_frames[] = {0};
1138 static int fire_frames[] = {10, 0};
1139
1140 Weapon_Generic (ent, 9, 12, 41, 43, pause_frames, fire_frames, Matrix_ak_mk23_Fire, ammo_mk23->value);
1141 }
1142 }
1143
Matrix_m4_Fire(edict_t * ent)1144 void Matrix_m4_Fire (edict_t *ent)
1145 {
1146 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
1147 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1148 int i;
1149 vec3_t start;
1150 vec3_t forward, right;
1151 vec3_t angles;
1152 int damage = damage_m4->value;
1153 int kick = 2;
1154 int kickback;
1155 vec3_t offset;
1156
1157
1158 if (is_quad)
1159 {
1160 damage *= 4;
1161 kick *= 4;
1162 }
1163 if (!(ent->client->buttons & BUTTON_ATTACK) && !ent->secondaryfire)
1164 {
1165 ent->client->ps.gunframe++;
1166 ent->client->machinegun_shots = 0;
1167 return;
1168 }
1169
1170 //Calculate the kick angles
1171 for (i=1 ; i<3 ; i++)
1172 {
1173 ent->client->kick_origin[i] = crandom() * 0.25;
1174 ent->client->kick_angles[i] = crandom() * 0.5;
1175 }
1176 ent->client->kick_origin[0] = crandom() * 0.35;
1177 ent->client->kick_angles[0] = ent->client->machinegun_shots * -.7;
1178 // get start / end positions
1179 //SKULL
1180 if (ent->client->use)
1181 VectorAdd (ent->client->oldplayer->s.angles, ent->client->kick_angles, angles);
1182 else
1183 //END
1184
1185 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index]> ammo_m4->value *2)
1186 {
1187
1188
1189 AngleVectors (ent->client->v_angle, forward, right, NULL);
1190 VectorSet(offset, 0, -8, ent->viewheight-5);
1191 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1192 fire_bullet (ent, start, forward, damage, kick, 1000, 500, MOD_HYPERBLASTER);
1193 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/m4a1fire.wav"), 1, ATTN_IDLE, 0);
1194
1195 AngleVectors (ent->client->v_angle, forward, right, NULL);
1196 VectorSet(offset, 0, 8, ent->viewheight-5);
1197 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1198 fire_bullet (ent, start, forward, damage, kick, 1000, 500, MOD_HYPERBLASTER);
1199 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/m4a1fire.wav"), 1, ATTN_IDLE, 0);
1200
1201 kickback = kick*1.2;
1202 KickBack(ent, forward, kickback);
1203
1204 ent->client->pers.inventory[ent->client->ammo_index] -= ammo_m4->value;
1205
1206 }
1207 else
1208 {
1209 VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
1210 AngleVectors (angles, forward, right, NULL);
1211 VectorSet(offset, 0, 8, ent->viewheight-5);
1212 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1213
1214 fire_bullet (ent, start, forward, damage, kick, 20, 20, MOD_HYPERBLASTER);
1215 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/m4a1fire.wav"), 1, ATTN_IDLE, 0);
1216 kickback = kick;
1217 KickBack(ent, forward, kickback);
1218 //m4's have huge kickback which knock you physically backwards
1219 }
1220 // fire_streak (ent, start, forward, damage);
1221 // fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
1222
1223 gi.WriteByte (svc_muzzleflash);
1224
1225 if (ent->client->use)
1226 gi.WriteShort (ent->client->oldplayer-g_edicts);
1227 else
1228 gi.WriteShort (ent-g_edicts);
1229 //END
1230 gi.WriteByte (MZ_AK_MK23 | is_silenced);
1231 //SKULL
1232 //if (ent->client->oldplayer)
1233 if (ent->client->use)
1234 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1235 else
1236 gi.multicast (ent->s.origin, MULTICAST_PVS);
1237
1238 PlayerNoise(ent, start, PNOISE_WEAPON);
1239
1240 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1241 {
1242
1243 ent->client->pers.inventory[ent->client->ammo_index] -= ammo_m4->value;;
1244 MatrixChuckShells(ent,gi.modelindex("models/objects/shell1/tris.md2"));
1245
1246 }
1247 ent->client->ps.gunframe++;
1248 }
Matrix_m4(edict_t * ent)1249 void Matrix_m4 (edict_t *ent)
1250 {
1251
1252 if (ent->client->akimbo)
1253 {
1254 static int pause_frames[] = {0};
1255 static int fire_frames[] = {13, 14, 24, 25, 26, 27, 0};
1256
1257 Akimbo_Weapon_Generic (ent, 12, 14, 21, 23, 24, 25, pause_frames, fire_frames, Matrix_m4_Fire, ammo_m4->value);
1258
1259 }
1260 else
1261 {
1262 static int pause_frames[] = {13, 24, 39};
1263 static int fire_frames[] = {11, 12, 0};
1264
1265 Weapon_Generic (ent, 10, 12, 39, 44, pause_frames, fire_frames, Matrix_m4_Fire, ammo_m4->value);
1266 }
1267
1268 }
1269
Matrix_mp5_Fire(edict_t * ent)1270 void Matrix_mp5_Fire (edict_t *ent)
1271 {
1272 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
1273 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1274 int i;
1275 vec3_t start;
1276 vec3_t forward, right;
1277 vec3_t angles;
1278 int damage = damage_mp5->value;
1279 int kick = 2;
1280 vec3_t offset;
1281
1282
1283 if (is_quad)
1284 {
1285 damage *= 4;
1286 kick *= 4;
1287 }
1288
1289 // get start / end positions
1290 //SKULL
1291 if (ent->client->use)
1292 VectorAdd (ent->client->oldplayer->s.angles, ent->client->kick_angles, angles);
1293 else
1294 //END
1295
1296 VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
1297
1298 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index]> ammo_mp5->value *2)
1299 {
1300
1301
1302 AngleVectors (ent->client->v_angle, forward, right, NULL);
1303 VectorSet(offset, 0, -8, ent->viewheight-8);
1304 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1305 fire_bullet (ent, start, forward, damage, kick, 500, 500, MOD_HYPERBLASTER);
1306 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mp5fire1.wav"), 1, ATTN_IDLE, 0);
1307
1308 AngleVectors (ent->client->v_angle, forward, right, NULL);
1309 VectorSet(offset, 0, 8, ent->viewheight-8);
1310 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1311 fire_bullet (ent, start, forward, damage, kick, 1000, 500, MOD_HYPERBLASTER);
1312 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mp5fire1.wav"), 1, ATTN_IDLE, 0);
1313
1314 ent->client->pers.inventory[ent->client->ammo_index]-=ammo_mp5->value;
1315
1316 }
1317 else
1318 {
1319 AngleVectors (angles, forward, right, NULL);
1320 VectorSet(offset, 0, 8, ent->viewheight-8);
1321 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1322
1323 fire_bullet (ent, start, forward, damage, kick, 20, 20, MOD_HYPERBLASTER);
1324 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mp5fire1.wav"), 1, ATTN_IDLE, 0);
1325 }
1326 // fire_streak (ent, start, forward, damage);
1327 // fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
1328
1329 gi.WriteByte (svc_muzzleflash);
1330 if (ent->client->use)
1331 gi.WriteShort (ent->client->oldplayer-g_edicts);
1332 else
1333 gi.WriteShort (ent-g_edicts);
1334 //END
1335 gi.WriteByte (MZ_AK_MK23 | is_silenced);
1336 //SKULL
1337 //if (ent->client->oldplayer)
1338 if (ent->client->use)
1339 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1340 else
1341 gi.multicast (ent->s.origin, MULTICAST_PVS);
1342
1343 PlayerNoise(ent, start, PNOISE_WEAPON);
1344
1345 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1346 {
1347 MatrixChuckShells(ent,gi.modelindex("models/objects/shell1/tris.md2"));
1348 // ent->left_in_clip--;
1349 ent->client->pers.inventory[ent->client->ammo_index]-=ammo_mp5->value;
1350 }
1351 ent->client->ps.gunframe++;
1352 }
1353
Matrix_mp5(edict_t * ent)1354 void Matrix_mp5 (edict_t *ent)
1355 {
1356
1357
1358 if (ent->client->akimbo)
1359 {
1360 static int pause_frames[] = { 8, 40};
1361 static int fire_frames[] = { 6, 7, 49, 50};
1362
1363 Akimbo_Weapon_Generic (ent, 5, 7, 42, 48, 49, 50, pause_frames, fire_frames, Matrix_mp5_Fire, ammo_mp5->value);
1364
1365 }
1366 else
1367 {
1368 static int pause_frames[] = {13, 24, 39};
1369 static int fire_frames[] = {11, 12, 0};
1370
1371 Weapon_Generic (ent, 10, 12, 47, 51, pause_frames, fire_frames, Matrix_mp5_Fire, ammo_mp5->value);
1372 }
1373 }
1374
1375
Matrix_SMC_Fire(edict_t * ent)1376 void Matrix_SMC_Fire (edict_t *ent)
1377 {
1378 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1379 int i;
1380 int shots;
1381 vec3_t start;
1382 vec3_t forward, right, up;
1383 float r, u;
1384 vec3_t offset;
1385 int damage;
1386 int kick = 2;
1387
1388
1389 damage = damage_smc->value;
1390
1391 if (ent->client->ps.gunframe == 5)
1392 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnu1a.wav"), 1, ATTN_IDLE, 0);
1393
1394 if ((ent->client->ps.gunframe == 14) && !(ent->client->buttons & BUTTON_ATTACK))
1395 {
1396 ent->client->ps.gunframe = 32;
1397 ent->client->weapon_sound = 0;
1398 return;
1399 }
1400 else if ((ent->client->ps.gunframe == 21) && (ent->client->buttons & BUTTON_ATTACK)
1401 && ent->client->pers.inventory[ent->client->ammo_index])
1402 {
1403 ent->client->ps.gunframe = 15;
1404 }
1405 else
1406 {
1407 ent->client->ps.gunframe++;
1408 }
1409
1410 if (ent->client->ps.gunframe == 22)
1411 {
1412 ent->client->weapon_sound = 0;
1413 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/chngnd1a.wav"), 1, ATTN_IDLE, 0);
1414 }
1415 else
1416 {
1417 ent->client->weapon_sound = gi.soundindex("weapons/chngnl1a.wav");
1418 }
1419
1420 ent->client->anim_priority = ANIM_ATTACK;
1421 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
1422 {
1423 ent->s.frame = FRAME_crattak1 - (ent->client->ps.gunframe & 1);
1424 ent->client->anim_end = FRAME_crattak9;
1425 }
1426 else
1427 {
1428 ent->s.frame = FRAME_attack1 - (ent->client->ps.gunframe & 1);
1429 ent->client->anim_end = FRAME_attack8;
1430 }
1431
1432 if (ent->client->ps.gunframe <= 9)
1433 shots = 1;
1434 else if (ent->client->ps.gunframe <= 14)
1435 {
1436 if (ent->client->buttons & BUTTON_ATTACK)
1437 shots = 2;
1438 else
1439 shots = 1;
1440 }
1441 else
1442 shots = 2;
1443
1444 if(ent->secondaryfire)
1445 {
1446 shots *= 2;
1447 if (ent->client->pers.inventory[ent->client->ammo_index] < shots * ammo_smc->value)
1448 shots = ent->client->pers.inventory[ent->client->ammo_index] / ammo_smc->value;
1449 }
1450 else
1451 {
1452 if (ent->client->pers.inventory[ent->client->ammo_index] < shots * ammo_smc->value)
1453 shots = ent->client->pers.inventory[ent->client->ammo_index] / ammo_smc->value;
1454 }
1455
1456 if (!shots)
1457 {
1458 if (level.time >= ent->pain_debounce_time)
1459 {
1460 gi.sound(ent, CHAN_VOICE, gi.soundindex("weapons/noammo.wav"), 1, ATTN_NORM, 0);
1461 ent->pain_debounce_time = level.time + 1;
1462 }
1463 NoAmmoWeaponChange (ent);
1464 return;
1465 }
1466
1467
1468
1469 for (i=0 ; i<3 ; i++)
1470 {
1471 ent->client->kick_origin[i] = crandom() * 0.35;
1472 ent->client->kick_angles[i] = crandom() * 0.7;
1473 }
1474
1475 for (i=0 ; i<shots ; i++)
1476 {
1477 // get start / end positions
1478 //SKULL
1479 if (ent->client->use)
1480 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
1481 else
1482 //END
1483 AngleVectors (ent->client->v_angle, forward, right, up);
1484 r = 7 + crandom()*4;
1485 u = crandom()*4;
1486 VectorSet(offset, 0, r, u + ent->viewheight-8);
1487 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1488
1489
1490
1491 if(ent->secondaryfire)
1492 {
1493 fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD*6, DEFAULT_BULLET_VSPREAD*6, MOD_CHAINGUN);
1494 fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD*4, DEFAULT_BULLET_VSPREAD*4, MOD_CHAINGUN);
1495 ent->client->pers.inventory[ent->client->ammo_index] -= ammo_smc->value;
1496 }
1497 else
1498 fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD/2, DEFAULT_BULLET_VSPREAD/2, MOD_CHAINGUN);
1499 }
1500
1501 // send muzzle flash
1502 gi.WriteByte (svc_muzzleflash);
1503 //SKULL
1504 if (ent->client->oldplayer)
1505 gi.WriteShort (ent->client->oldplayer-g_edicts);
1506 else
1507 gi.WriteShort (ent-g_edicts);
1508 //END
1509 gi.WriteByte ((MZ_CHAINGUN1 + shots - 1) | is_silenced);
1510 //SKULL
1511 if (ent->client->oldplayer)
1512 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1513 else
1514 gi.multicast (ent->s.origin, MULTICAST_PVS);
1515 //END
1516
1517 PlayerNoise(ent, start, PNOISE_WEAPON);
1518
1519 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1520 ent->client->pers.inventory[ent->client->ammo_index] -= shots * ammo_smc->value;
1521 }
Matrix_SMC(edict_t * ent)1522 void Matrix_SMC (edict_t *ent)
1523 {
1524 static int pause_frames[] = {38, 43, 51, 61, 0};
1525 static int fire_frames[] = {5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 0};
1526
1527 Weapon_Generic (ent, 4, 31, 61, 64, pause_frames, fire_frames, Matrix_SMC_Fire, ammo_smc->value);
1528
1529 }
Matrix_Knives_Fire(edict_t * ent)1530 void Matrix_Knives_Fire (edict_t *ent)
1531 {
1532 vec3_t forward, right;
1533 vec3_t offset, start;
1534 trace_t tr;
1535 vec3_t end;
1536 gitem_t *item;
1537 int damage = damage_knife->value;
1538
1539 AngleVectors (ent->client->v_angle, forward, right, NULL);
1540 VectorScale (forward, 0, ent->client->kick_origin);
1541 VectorSet(offset, 0, 0, ent->viewheight-4);
1542 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1543
1544 VectorMA( start, 40, forward, end );
1545
1546 tr = gi.trace (ent->s.origin, NULL, NULL, end, ent, MASK_MONSTERSOLID);
1547
1548 if(ent->secondaryfire)
1549 {
1550 // do throwing stuff here
1551
1552
1553
1554 // throwing sound
1555 gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/throw.wav"), 1, ATTN_NORM, 0);
1556
1557
1558 // below is exact code from action for how it sets the knife up
1559 AngleVectors (ent->client->v_angle, forward, right, NULL);
1560 VectorSet(offset, 24, 8, ent->viewheight-8);
1561 VectorAdd (offset, vec3_origin, offset);
1562 forward[2] += .17;
1563
1564 // zucc using old style because the knife coming straight out looks
1565 // pretty stupid
1566
1567
1568 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1569
1570 item = FindItem("Gung Ho Knives");
1571 ent->client->pers.inventory[ITEM_INDEX(item)]-=ammo_knife->value;
1572
1573
1574 // zucc was at 1250, dropping speed to 1200
1575 knife_throw (ent, start, forward, damage, 1200);
1576
1577 ent->client->pers.inventory[ent->client->ammo_index] -= ammo_knife->value;
1578 ent->client->ps.gunframe++;
1579 return;
1580 }
1581 else if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
1582 {
1583 AngleVectors (ent->client->v_angle, forward, right, NULL);
1584 VectorScale (forward, 0, ent->client->kick_origin);
1585 VectorSet(offset, 0, 0, ent->viewheight-4);
1586 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1587
1588 VectorMA( start, 40, forward, end );
1589
1590 tr = gi.trace (ent->s.origin, NULL, NULL, end, ent, MASK_MONSTERSOLID);
1591
1592 VectorSubtract(ent->s.origin, end, end);
1593 VectorNormalize(end);
1594
1595 if(tr.fraction<1 && tr.ent->takedamage)
1596 {
1597 T_Damage (tr.ent, ent, ent, end, tr.ent->s.origin, tr.ent->s.origin, damage_knife->value, 100, 1, MOD_KNIFE);
1598 gi.sound(ent, CHAN_WEAPON, gi.soundindex("weapons/stab.wav"), 1, ATTN_NORM, 0);
1599 }
1600 else return;
1601
1602
1603 }
1604
1605 ent->client->ps.gunframe++;
1606
1607 }
1608
Matrix_Knives(edict_t * ent)1609 void Matrix_Knives (edict_t *ent)
1610 {
1611 static int pause_frames[] = {13, 24, 51};
1612 static int fire_frames[] = {6, 103, 0};
1613
1614 Weapon_Generic (ent, 5, 12, 52, 59, pause_frames, fire_frames, Matrix_Knives_Fire, ammo_knife->value);
1615 }
Matrix_Pumps_Fire(edict_t * ent)1616 void Matrix_Pumps_Fire (edict_t *ent)
1617 {
1618 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1619 vec3_t start;
1620 vec3_t forward, right;
1621 vec3_t offset;
1622 int damage = damage_pumps->value;
1623 int kick = 8;
1624
1625 if (ent->client->ps.gunframe == 9)
1626 {
1627 ent->client->ps.gunframe++;
1628 return;
1629 }
1630
1631 //SKULL
1632 if (ent->client->use)
1633 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
1634 else
1635 //END
1636 AngleVectors (ent->client->v_angle, forward, right, NULL);
1637
1638 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index]> ammo_pumps->value * 2)
1639 {
1640
1641
1642 AngleVectors (ent->client->v_angle, forward, right, NULL);
1643 VectorSet(offset, 0, -8, ent->viewheight-8);
1644 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1645 fire_shotgun (ent, start, forward, damage, kick, 1200, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
1646
1647 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/shotgf1b.wav"), 1, ATTN_IDLE, 0);
1648
1649
1650 AngleVectors (ent->client->v_angle, forward, right, NULL);
1651 VectorSet(offset, 0, 8, ent->viewheight-8);
1652 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1653 fire_shotgun (ent, start, forward, damage, kick, 1200, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
1654
1655 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/shotgf1b.wav"),1, ATTN_IDLE, 0);
1656 VectorScale (forward, -10, ent->client->kick_origin);
1657 ent->client->kick_angles[0] = -10;
1658
1659 }
1660 else
1661 {
1662 VectorScale (forward, -2, ent->client->kick_origin);
1663 ent->client->kick_angles[0] = -2;
1664
1665 VectorSet(offset, 0, 8, ent->viewheight-6);
1666 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1667
1668 fire_shotgun (ent, start, forward, damage, kick, 500, 500, DEFAULT_DEATHMATCH_SHOTGUN_COUNT, MOD_SHOTGUN);
1669 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/shotgf1b.wav"), 1, ATTN_IDLE, 0);
1670 }
1671
1672 // send muzzle flash
1673 gi.WriteByte (svc_muzzleflash);
1674 //SKULL
1675 // if (ent->client->oldplayer)
1676 // gi.WriteShort (ent->client->oldplayer-g_edicts);
1677 // else
1678 gi.WriteShort (ent-g_edicts);
1679 //END
1680 gi.WriteByte (MZ_AK_MK23 | is_silenced);
1681 //SKULL
1682 // if (ent->client->oldplayer)
1683 // gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1684 // else
1685 gi.multicast (ent->s.origin, MULTICAST_PVS);
1686 //END
1687
1688 ent->client->ps.gunframe++;
1689 PlayerNoise(ent, start, PNOISE_WEAPON);
1690
1691 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1692 {
1693 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index]> ammo_pumps->value *2)
1694 {
1695 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_pumps->value;
1696 MatrixChuckShells(ent,gi.modelindex("models/objects/shell2/tris.md2"));
1697 }
1698 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_pumps->value;
1699 MatrixChuckShells(ent,gi.modelindex("models/objects/shell2/tris.md2"));
1700
1701 }
1702
1703 }
Matrix_Pumps(edict_t * ent)1704 void Matrix_Pumps (edict_t *ent)
1705 {
1706
1707
1708 if (ent->client->akimbo)
1709 {
1710 static int pause_frames[] = {0};
1711 static int fire_frames[] = {8, 53, 0};
1712
1713 Akimbo_Weapon_Generic (ent, 7, 15, 35, 41, 53, 60, pause_frames, fire_frames, Matrix_Pumps_Fire, ammo_pumps->value);
1714
1715 }
1716 else
1717 {
1718 static int pause_frames[] = {16, 24, 37};
1719 static int fire_frames[] = {8, 0};
1720
1721 Weapon_Generic (ent, 7, 15, 35, 41, pause_frames, fire_frames, Matrix_Pumps_Fire, ammo_pumps->value);
1722 }
1723 }
1724
1725
Matrix_Fists_Fire(edict_t * ent)1726 void Matrix_Fists_Fire (edict_t *ent)
1727 {
1728
1729 vec3_t forward, right;
1730 vec3_t offset, start;
1731 trace_t tr;
1732 vec3_t end;
1733
1734
1735 AngleVectors (ent->client->v_angle, forward, right, NULL);
1736 VectorScale (forward, 0, ent->client->kick_origin);
1737 VectorSet(offset, 0, 0, ent->viewheight-4);
1738 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1739
1740 VectorMA( start, 40, forward, end );
1741
1742 tr = gi.trace (ent->s.origin, NULL, NULL, end, ent, MASK_MONSTERSOLID);
1743
1744 VectorSubtract(end, ent->s.origin, end);
1745 VectorNormalize(end);
1746
1747 if ( ((ent->client->latched_buttons|ent->client->buttons) & BUTTON_ATTACK) )
1748 {
1749 if(tr.fraction<1 && tr.ent->takedamage)
1750 {
1751 T_Damage (tr.ent, ent, ent, end, tr.ent->s.origin, tr.ent->s.origin, damage_fist->value, 500, 1, MOD_HOOK);
1752 gi.sound(ent, CHAN_AUTO, gi.soundindex("misc/kick.wav"), 1, ATTN_NORM, 0);
1753 PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
1754
1755 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
1756 {
1757 ent->client->anim_priority = ANIM_REVERSE;
1758 ent->s.frame = FRAME_crattak1-1;
1759 ent->client->anim_end = FRAME_crattak3;
1760 }
1761 else
1762 {
1763 ent->client->anim_priority = ANIM_REVERSE;
1764 ent->s.frame = FRAME_wave08;
1765 ent->client->anim_end = FRAME_wave01;
1766 }
1767
1768 }
1769 else return;
1770
1771 }
1772 else
1773 {
1774 T_Damage (tr.ent, ent, ent, end, tr.ent->s.origin, tr.ent->s.origin, damage_fist->value/5, 10, 1, MOD_HOOK);
1775 //ent->client->ps.gunframe = 18;
1776 if(tr.fraction<1 && tr.ent->takedamage)
1777 {
1778 gi.sound(ent, CHAN_AUTO, gi.soundindex("misc/kick.wav"), 1, ATTN_NORM, 0);
1779 PlayerNoise(ent, ent->s.origin, PNOISE_SELF);
1780 }
1781 }
1782 swoosh (ent);//swoosh noise
1783
1784 ent->client->ps.gunframe++;
1785 }
Matrix_Fists(edict_t * ent)1786 void Matrix_Fists (edict_t *ent)
1787 {
1788 static int pause_frames[] = {21, 24, 51};
1789 static int fire_frames[] = {6, 0};
1790
1791 Weapon_Generic (ent, 5, 20, 52, 58, pause_frames, fire_frames, Matrix_Fists_Fire, 0);
1792
1793 }
1794
Matrix_Deserts_Fire(edict_t * ent)1795 void Matrix_Deserts_Fire (edict_t *ent)
1796 {
1797 qboolean is_quad = (ent->client->quad_framenum > level.framenum);
1798 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1799 int i;
1800 vec3_t start;
1801 vec3_t forward, right;
1802 vec3_t angles;
1803 int damage = damage_deserts->value;
1804 int kick = 2;
1805 vec3_t offset;
1806
1807
1808 if (is_quad)
1809 {
1810 damage *= 4;
1811 kick *= 4;
1812 }
1813
1814 // get start / end positions
1815 //SKULL
1816 if (ent->client->use)
1817 VectorAdd (ent->client->oldplayer->s.angles, ent->client->kick_angles, angles);
1818 else
1819 //END
1820
1821 VectorAdd (ent->client->v_angle, ent->client->kick_angles, angles);
1822
1823 if(ent->secondaryfire && ent->client->akimbo && ent->client->pers.inventory[ent->client->ammo_index] > ammo_deserts->value * 2)
1824 {
1825
1826
1827 AngleVectors (ent->client->v_angle, forward, right, NULL);
1828 VectorSet(offset, 0, -8, ent->viewheight-8);
1829 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1830 fire_bullet (ent, start, forward, damage, kick, 500, 500, MOD_AK_MK23);
1831 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1832
1833 MatrixChuckShells(ent,gi.modelindex("models/objects/shell1/tris.md2"));
1834
1835 AngleVectors (ent->client->v_angle, forward, right, NULL);
1836 VectorSet(offset, 0, 8, ent->viewheight-8);
1837 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1838 fire_bullet (ent, start, forward, damage, kick, 1000, 500, MOD_AK_MK23);
1839 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1840
1841 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_deserts->value;
1842
1843 }
1844 else
1845 {
1846 AngleVectors (angles, forward, right, NULL);
1847 VectorSet(offset, 0, 8, ent->viewheight-8);
1848 Akimbo_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1849
1850 fire_bullet (ent, start, forward, damage, kick, 20, 20, MOD_AK_MK23);
1851 gi.sound(ent, CHAN_AUTO, gi.soundindex("weapons/mk23fire.wav"), 1, ATTN_IDLE, 0);
1852 }
1853 // fire_streak (ent, start, forward, damage);
1854 // fire_bullet (ent, start, forward, damage, kick, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MOD_MACHINEGUN);
1855
1856 gi.WriteByte (svc_muzzleflash);
1857 //SKULL
1858 if (ent->client->use)
1859 gi.WriteShort (ent->client->oldplayer-g_edicts);
1860 else
1861 gi.WriteShort (ent-g_edicts);
1862 //END
1863 gi.WriteByte (MZ_AK_MK23 | is_silenced);
1864 //SKULL
1865 //if (ent->client->oldplayer)
1866 if (ent->client->use)
1867 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1868 else
1869 gi.multicast (ent->s.origin, MULTICAST_PVS);
1870
1871 PlayerNoise(ent, start, PNOISE_WEAPON);
1872
1873 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
1874 {
1875 MatrixChuckShells(ent,gi.modelindex("models/objects/shell1/tris.md2"));
1876 // ent->left_in_clip--;
1877 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_deserts->value;
1878 }
1879
1880 ent->client->ps.gunframe++;
1881 }
Matrix_Deserts(edict_t * ent)1882 void Matrix_Deserts (edict_t *ent)
1883 {
1884
1885
1886 if (ent->client->akimbo)
1887 {
1888 static int pause_frames[] = {19, 32, 0};
1889 static int fire_frames[] = {9, 40, 0};
1890 Akimbo_Weapon_Generic (ent, 8, 11, 36, 39, 40, 42, pause_frames, fire_frames, Matrix_Deserts_Fire, ammo_deserts->value);
1891
1892 }
1893 else
1894 {
1895 static int pause_frames[] = {0};
1896 static int fire_frames[] = {10, 0};
1897
1898 Weapon_Generic (ent, 9, 13, 41, 43, pause_frames, fire_frames, Matrix_Deserts_Fire, ammo_deserts->value);
1899 }
1900 }
1901
Matrix_SSMRack_Fire(edict_t * ent)1902 void Matrix_SSMRack_Fire (edict_t *ent)
1903 {
1904 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
1905 vec3_t offset, start;
1906 vec3_t forward, right;
1907 vec3_t babang;
1908 int damage, i;
1909 float damage_radius;
1910 int radius_damage;
1911
1912 damage = fabs(radiusdamage_rack->value - 20);
1913 radius_damage = radiusdamage_rack->value;
1914 damage_radius = damageradius_rack->value;
1915
1916
1917
1918 //SKULL
1919 if (ent->client->use)
1920 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
1921 else
1922 //END
1923 AngleVectors (ent->client->v_angle, forward, right, NULL);
1924
1925 VectorScale (forward, -2, ent->client->kick_origin);
1926 ent->client->kick_angles[0] = -1;
1927
1928 VectorSet(offset, 8, 8, ent->viewheight-8);
1929 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1930
1931 if (ent->client->pers.inventory[ent->client->ammo_index] < 50)
1932 {
1933 ent->client->ps.gunframe++;
1934 return;
1935 }
1936
1937 if(ent->secondaryfire)
1938 {
1939
1940 damage = fabs(radiusdamage_rack->value - 40);
1941 radius_damage = fabs(radiusdamage_rack->value - 40);
1942 damage_radius = fabs(damageradius_rack->value - 20);
1943
1944
1945 if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value * 4)
1946 {
1947 fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);
1948 matrix_fire_rocket (ent, start, forward, damage, 400, damage_radius, radius_damage);
1949 }
1950 else if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value * 3 && ent->client->pers.inventory[ent->client->ammo_index] < ammo_rack->value * 4)
1951 matrix_fire_rocket (ent, start, forward, damage, 400, damage_radius, radius_damage);
1952 else if(ent->client->pers.inventory[ent->client->ammo_index]>=ammo_rack->value * 2 && ent->client->pers.inventory[ent->client->ammo_index]< ammo_rack->value * 3)
1953 {
1954 for(i=0;i<2;i++)
1955 {
1956 VectorCopy(ent->client->v_angle, babang);
1957 babang[0] += crandom() * 3;
1958 babang[1] += crandom() * 3;
1959
1960 AngleVectors (babang, forward, right, NULL);
1961 VectorScale (forward, -2, ent->client->kick_origin);
1962
1963 VectorSet(offset, 8, 8, ent->viewheight-8);
1964 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
1965 fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);
1966 }
1967 }
1968 else
1969 if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value)
1970 fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);
1971
1972
1973 }
1974 else
1975 if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value)
1976 fire_rocket (ent, start, forward, damage, 650, damage_radius, radius_damage);
1977
1978 KickBack(ent, forward, 10);
1979
1980 // send muzzle flash
1981 gi.WriteByte (svc_muzzleflash);
1982
1983 //if (ent->client->oldplayer)
1984 if (ent->client->use)
1985 gi.WriteShort (ent->client->oldplayer-g_edicts);
1986 else
1987 gi.WriteShort (ent-g_edicts);
1988 //END
1989 gi.WriteByte (MZ_ROCKET | is_silenced);
1990 //SKULL
1991 //if (ent->client->oldplayer)
1992 if (ent->client->use)
1993 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
1994 else
1995 gi.multicast (ent->s.origin, MULTICAST_PVS);
1996 //SKULL
1997
1998
1999
2000
2001 ent->client->ps.gunframe++;
2002
2003 if(ent->client->pers.inventory[ent->client->ammo_index] < ammo_rack->value)
2004 NoAmmoWeaponChange (ent);
2005
2006 PlayerNoise(ent, ent->s.origin, PNOISE_WEAPON);
2007
2008 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
2009 {
2010 if(ent->secondaryfire)
2011 {
2012 if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value
2013 && ent->client->pers.inventory[ent->client->ammo_index]< ammo_rack->value * 2)
2014 ent->client->pers.inventory[ent->client->ammo_index] -=ammo_rack->value;
2015 if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value * 2
2016 && ent->client->pers.inventory[ent->client->ammo_index]< ammo_rack->value * 3)
2017 ent->client->pers.inventory[ent->client->ammo_index] -=ammo_rack->value * 2;
2018 else if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value * 3
2019 && ent->client->pers.inventory[ent->client->ammo_index]< ammo_rack->value * 4)
2020 ent->client->pers.inventory[ent->client->ammo_index] -=ammo_rack->value * 3;
2021 else if(ent->client->pers.inventory[ent->client->ammo_index]>= ammo_rack->value * 4)
2022 ent->client->pers.inventory[ent->client->ammo_index] -=ammo_rack->value * 4;
2023 }
2024 else
2025 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_rack->value;
2026 }
2027 }
2028
Matrix_SSMRack(edict_t * ent)2029 void Matrix_SSMRack (edict_t *ent)
2030 {
2031 static int pause_frames[] = {25, 33, 42, 50, 0};
2032 static int fire_frames[] = {5, 0};
2033
2034 Weapon_Generic (ent, 4, 12, 50, 54, pause_frames, fire_frames, Matrix_SSMRack_Fire, ammo_rack->value);
2035 }
2036
weapon_grenade_fire(edict_t * ent)2037 void weapon_grenade_fire (edict_t *ent)
2038 {
2039 vec3_t offset;
2040 vec3_t forward, right;
2041 vec3_t start;
2042 int damage = radiusdamage_grenade->value;
2043 float timer;
2044 int speed;
2045 float radius;
2046 qboolean held = false;
2047 radius = damageradius_grenade->value;
2048
2049 if(ent->client->pers.inventory[ent->client->ammo_index] < ammo_grenade->value)
2050 {
2051 ent->client->ps.gunframe = 40;
2052 ent->client->weaponstate = WEAPON_DROPPING;
2053 NoAmmoWeaponChange (ent);
2054 return;
2055 }
2056
2057 if ( (ent->client->buttons) & BUTTON_ATTACK)
2058 {
2059 if(ent->client->ps.fov >= 130)
2060 ent->client->ps.fov = 130;
2061 else
2062 ent->client->ps.fov += 4;
2063
2064 return;
2065 }
2066 speed = (ent->client->ps.fov - 90) * 60;
2067 ent->client->ps.fov = 90;
2068
2069 VectorSet(offset, 8, 8, ent->viewheight-8);
2070 //SKULL
2071 if (ent->client->use)
2072 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
2073 else
2074 //END
2075 AngleVectors (ent->client->v_angle, forward, right, NULL);
2076 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
2077
2078 timer = 1;
2079 if(ent->client->pers.inventory[ent->client->ammo_index] >= ammo_grenade->value)
2080 fire_grenade2 (ent, start, forward, damage, speed, timer, radius, held);
2081
2082 if (! ( (int)dmflags->value & DF_INFINITE_AMMO ) )
2083 ent->client->pers.inventory[ent->client->ammo_index]-= ammo_grenade->value;
2084
2085 ent->client->grenade_time = level.time;
2086
2087 if(ent->deadflag || ent->s.modelindex != 255) // VWep animations screw up corpses
2088 {
2089 return;
2090 }
2091
2092 if (ent->health <= 0)
2093 return;
2094
2095 if (ent->client->ps.pmove.pm_flags & PMF_DUCKED)
2096 {
2097 ent->client->anim_priority = ANIM_ATTACK;
2098 ent->s.frame = FRAME_crattak1-1;
2099 ent->client->anim_end = FRAME_crattak3;
2100 }
2101 else
2102 {
2103 ent->client->anim_priority = ANIM_REVERSE;
2104 ent->s.frame = FRAME_wave08;
2105 ent->client->anim_end = FRAME_wave01;
2106 }
2107 ent->client->ps.gunframe ++;
2108 }
2109
Weapon_Grenade(edict_t * ent)2110 void Weapon_Grenade (edict_t *ent)
2111 {
2112
2113 static int pause_frames[] = {20, 24, 30, 0};
2114 static int fire_frames[] = {8, 0};
2115
2116 Weapon_Generic (ent, 7, 15, 39, 41, pause_frames, fire_frames, weapon_grenade_fire, ammo_grenade->value);
2117 }
weapon_kuml_fire(edict_t * ent)2118 void weapon_kuml_fire (edict_t *ent)
2119 {
2120 byte is_silenced = (ent->client->silencer_shots) ? MZ_SILENCED : 0;
2121 vec3_t start;
2122 vec3_t forward, right;
2123 vec3_t offset;
2124 vec3_t v;
2125 int damage = 6;
2126 int kick = 12;
2127
2128 //SKULL
2129 if (ent->client->use)
2130 AngleVectors (ent->client->oldplayer->s.angles, forward, right, NULL);
2131 else
2132 //END
2133 AngleVectors (ent->client->v_angle, forward, right, NULL);
2134
2135 VectorScale (forward, -2, ent->client->kick_origin);
2136 ent->client->kick_angles[0] = -2;
2137
2138 VectorSet(offset, 0, 8, ent->viewheight-8);
2139 P_ProjectSource (ent->client, ent->s.origin, offset, forward, right, start);
2140
2141
2142
2143 //SKULL
2144 if (ent->client->use)
2145 {
2146 v[PITCH] = ent->client->oldplayer->s.angles[PITCH];
2147 v[YAW] = ent->client->oldplayer->s.angles[YAW] - 5;
2148 v[ROLL] = ent->client->oldplayer->s.angles[ROLL];
2149 }
2150 else
2151 {
2152 v[PITCH] = ent->client->v_angle[PITCH];
2153 v[YAW] = ent->client->v_angle[YAW] - 5;
2154 v[ROLL] = ent->client->v_angle[ROLL];
2155 }
2156 AngleVectors (v, forward, NULL, NULL);
2157 fire_kuml (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);
2158 if (ent->client->use)
2159 v[YAW] = ent->client->oldplayer->s.angles[YAW] + 5;
2160 else
2161 //END
2162 v[YAW] = ent->client->v_angle[YAW] + 5;
2163 AngleVectors (v, forward, NULL, NULL);
2164 fire_kuml (ent, start, forward, damage, kick, DEFAULT_SHOTGUN_HSPREAD, DEFAULT_SHOTGUN_VSPREAD, DEFAULT_SSHOTGUN_COUNT/2, MOD_SSHOTGUN);
2165
2166 // send muzzle flash
2167 gi.WriteByte (svc_muzzleflash);
2168 //SKULL
2169 if (ent->client->use)
2170 gi.WriteShort (ent->client->oldplayer-g_edicts);
2171 else
2172 gi.WriteShort (ent-g_edicts);
2173 //END
2174 gi.WriteByte (MZ_SSHOTGUN | is_silenced);
2175 //SKULL
2176 if (ent->client->use)
2177 gi.multicast (ent->client->oldplayer->s.origin, MULTICAST_PVS);
2178 else
2179 gi.multicast (ent->s.origin, MULTICAST_PVS);
2180 //END
2181
2182 ent->client->ps.gunframe++;
2183 PlayerNoise(ent, start, PNOISE_WEAPON);
2184 }
2185
Weapon_Kuml(edict_t * ent)2186 void Weapon_Kuml (edict_t *ent)
2187 {
2188 static int pause_frames[] = {29, 42, 57, 0};
2189 static int fire_frames[] = {7, 0};
2190
2191 Weapon_Generic (ent, 6, 17, 57, 61, pause_frames, fire_frames, weapon_kuml_fire, 0);
2192 }
2193