1 /*
2 ==============================================================================
3
4 carrier
5
6 ==============================================================================
7 */
8
9 // self->timestamp used for frame calculations in grenade & spawn code
10 // self->wait used to prevent rapid refire of rocket launcher
11
12 #include "g_local.h"
13 #include "m_carrier.h"
14
15 #define CARRIER_ROCKET_TIME 2 // number of seconds between rocket shots
16 #define CARRIER_ROCKET_SPEED 750
17 #define NUM_FLYERS_SPAWNED 6 // max # of flyers he can spawn
18
19 #define RAIL_FIRE_TIME 3
20
21 void BossExplode (edict_t *self);
22 void Grenade_Explode (edict_t *ent);
23
24 qboolean infront (edict_t *self, edict_t *other);
25 qboolean inback (edict_t *self, edict_t *other);
26 qboolean below (edict_t *self, edict_t *other);
27 void drawbbox (edict_t *self);
28
29 //char *ED_NewString (char *string);
30 void ED_CallSpawn (edict_t *ent);
31
32 static int sound_pain1;
33 static int sound_pain2;
34 static int sound_pain3;
35 static int sound_death;
36 //static int sound_search1;
37 static int sound_sight;
38 static int sound_rail;
39 static int sound_spawn;
40
41 float orig_yaw_speed;
42
43 vec3_t flyer_mins = {-16, -16, -24};
44 vec3_t flyer_maxs = {16, 16, 16};
45
46 extern mmove_t flyer_move_attack2, flyer_move_attack3, flyer_move_kamikaze;
47
48
49 void carrier_run (edict_t *self);
50 void carrier_stand (edict_t *self);
51 void carrier_dead (edict_t *self);
52 void carrier_attack (edict_t *self);
53 void carrier_attack_mg (edict_t *self);
54 void carrier_reattack_mg (edict_t *self);
55 void carrier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point);
56
57 void carrier_attack_gren (edict_t *self);
58 void carrier_reattack_gren (edict_t *self);
59
60 void carrier_start_spawn (edict_t *self);
61 void carrier_spawn_check (edict_t *self);
62 void carrier_prep_spawn (edict_t *self);
63
64 void CarrierMachineGunHold (edict_t *self);
65 void CarrierRocket (edict_t *self);
66
67
carrier_sight(edict_t * self,edict_t * other)68 void carrier_sight (edict_t *self, edict_t *other)
69 {
70 gi.sound (self, CHAN_VOICE, sound_sight, 1, ATTN_NORM, 0);
71 }
72
73 // code starts here
74 //void carrier_search (edict_t *self)
75 //{
76 // if (random() < 0.5)
77 // gi.sound (self, CHAN_VOICE, sound_search1, 1, ATTN_NONE, 0);
78 //}
79
80 //
81 // this is the smarts for the rocket launcher in coop
82 //
83 // if there is a player behind/below the carrier, and we can shoot, and we can trace a LOS to them ..
84 // pick one of the group, and let it rip
CarrierCoopCheck(edict_t * self)85 void CarrierCoopCheck (edict_t *self)
86 {
87 // no more than 4 players in coop, so..
88 edict_t *targets[4];
89 int num_targets = 0, target, player;
90 edict_t *ent;
91 trace_t tr;
92
93 // if we're not in coop, this is a noop
94 if (!coop || !coop->value)
95 return;
96 // if we are, and we have recently fired, bail
97 if (self->wait > level.time)
98 return;
99
100 memset (targets, 0, 4*sizeof(edict_t *));
101
102 // cycle through players
103 for (player = 1; player <= game.maxclients; player++)
104 {
105 ent = &g_edicts[player];
106 if (!ent->inuse)
107 continue;
108 if (!ent->client)
109 continue;
110 if (inback(self, ent) || below(self, ent))
111 {
112 tr = gi.trace (self->s.origin, NULL, NULL, ent->s.origin, self, MASK_SOLID);
113 if (tr.fraction == 1.0)
114 {
115 // if ((g_showlogic) && (g_showlogic->value))
116 // gi.dprintf ("Carrier: found a player who I can shoot\n");
117 targets[num_targets++] = ent;
118 }
119 }
120 }
121
122 if (!num_targets)
123 return;
124
125 // get a number from 0 to (num_targets-1)
126 target = random() * num_targets;
127
128 // just in case we got a 1.0 from random
129 if (target == num_targets)
130 target--;
131
132 // make sure to prevent rapid fire rockets
133 self->wait = level.time + CARRIER_ROCKET_TIME;
134
135 // save off the real enemy
136 ent = self->enemy;
137 // set the new guy as temporary enemy
138 self->enemy = targets[target];
139 CarrierRocket (self);
140 // put the real enemy back
141 self->enemy = ent;
142
143 // we're done
144 return;
145 }
146
CarrierGrenade(edict_t * self)147 void CarrierGrenade (edict_t *self)
148 {
149 vec3_t start;
150 vec3_t forward, right, up;
151 vec3_t aim;
152 int flash_number;
153 float direction; // from lower left to upper right, or lower right to upper left
154 float spreadR, spreadU;
155 int mytime;
156
157 CarrierCoopCheck(self);
158
159 if (!self->enemy)
160 return;
161
162 if (random() < 0.5)
163 direction = -1.0;
164 else
165 direction = 1.0;
166
167 mytime = (int)((level.time - self->timestamp)/0.4);
168
169 if (mytime == 0)
170 {
171 spreadR = 0.15 * direction;
172 // spreadU = 0.1 * direction;
173 spreadU = 0.1 - 0.1 * direction;
174 }
175 else if (mytime == 1)
176 {
177 spreadR = 0;
178 // spreadU = 0;
179 spreadU = 0.1;
180 }
181 else if (mytime == 2)
182 {
183 spreadR = -0.15 * direction;
184 // spreadU = -0.1 * direction;
185 spreadU = 0.1 - -0.1 * direction;
186 }
187 else if (mytime == 3)
188 {
189 spreadR = 0;
190 // spreadU = 0;
191 spreadU = 0.1;
192 }
193 else
194 {
195 // error, shoot straight
196 // if ((g_showlogic) && (g_showlogic->value))
197 // gi.dprintf ("CarrierGrenade: bad time %2.2f %2.2f\n", level.time, self->timestamp);
198 spreadR = 0;
199 spreadU = 0;
200 }
201
202 AngleVectors (self->s.angles, forward, right, up);
203 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_GRENADE], forward, right, start);
204
205 VectorSubtract (self->enemy->s.origin, start, aim);
206 VectorNormalize (aim);
207
208 VectorMA (aim, spreadR, right, aim);
209 VectorMA (aim, spreadU, up, aim);
210
211 if(aim[2] > 0.15)
212 aim[2] = 0.15;
213 else if(aim[2] < -0.5)
214 aim[2] = -0.5;
215
216 flash_number = MZ2_GUNNER_GRENADE_1;
217 monster_fire_grenade (self, start, aim, 50, 600, flash_number);
218 }
219
CarrierPredictiveRocket(edict_t * self)220 void CarrierPredictiveRocket (edict_t *self)
221 {
222 vec3_t forward, right;
223 vec3_t start;
224 vec3_t dir;
225
226 // if ((g_showlogic) && (g_showlogic->value))
227 // gi.dprintf("predictive fire\n");
228
229 AngleVectors (self->s.angles, forward, right, NULL);
230
231 //1
232 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_1], forward, right, start);
233 PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, -0.3, dir, NULL);
234 monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_1);
235
236 //2
237 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_2], forward, right, start);
238 PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, -0.15, dir, NULL);
239 monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_2);
240
241 //3
242 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_3], forward, right, start);
243 PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, 0, dir, NULL);
244 monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_3);
245
246 //4
247 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_4], forward, right, start);
248 PredictAim (self->enemy, start, CARRIER_ROCKET_SPEED, false, 0.15, dir, NULL);
249 monster_fire_rocket (self, start, dir, 50, CARRIER_ROCKET_SPEED, MZ2_CARRIER_ROCKET_4);
250 }
251
CarrierRocket(edict_t * self)252 void CarrierRocket (edict_t *self)
253 {
254 vec3_t forward, right;
255 vec3_t start;
256 vec3_t dir;
257 vec3_t vec;
258
259 if(self->enemy)
260 {
261 if(self->enemy->client && random() < 0.5)
262 {
263 CarrierPredictiveRocket(self);
264 return;
265 }
266 }
267 else
268 return;
269
270 AngleVectors (self->s.angles, forward, right, NULL);
271
272 //1
273 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_1], forward, right, start);
274 VectorCopy (self->enemy->s.origin, vec);
275 // vec[2] += self->enemy->viewheight;
276 vec[2] -= 15;
277 VectorSubtract (vec, start, dir);
278 VectorNormalize (dir);
279 VectorMA (dir, 0.4, right, dir);
280 VectorNormalize (dir);
281 monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_1);
282
283 //2
284 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_2], forward, right, start);
285 VectorCopy (self->enemy->s.origin, vec);
286 // vec[2] += self->enemy->viewheight;
287 VectorSubtract (vec, start, dir);
288 VectorNormalize (dir);
289 VectorMA (dir, 0.025, right, dir);
290 VectorNormalize (dir);
291 monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_2);
292
293 //3
294 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_3], forward, right, start);
295 VectorCopy (self->enemy->s.origin, vec);
296 // vec[2] += self->enemy->viewheight;
297 VectorSubtract (vec, start, dir);
298 VectorNormalize (dir);
299 VectorMA (dir, -0.025, right, dir);
300 VectorNormalize (dir);
301 monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_3);
302
303 //4
304 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_ROCKET_4], forward, right, start);
305 VectorCopy (self->enemy->s.origin, vec);
306 // vec[2] += self->enemy->viewheight;
307 vec[2] -= 15;
308 VectorSubtract (vec, start, dir);
309 VectorNormalize (dir);
310 VectorMA (dir, -0.4, right, dir);
311 VectorNormalize (dir);
312 monster_fire_rocket (self, start, dir, 50, 500, MZ2_CARRIER_ROCKET_4);
313
314 //5
315 // G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_BOSS2_ROCKET_4], forward, right, start);
316 // VectorCopy (self->enemy->s.origin, vec);
317 // vec[2] += self->enemy->viewheight;
318 // VectorSubtract (vec, start, dir);
319 // VectorNormalize (dir);
320 // monster_fire_rocket (self, start, dir, 50, 500, MZ2_BOSS2_ROCKET_2);
321 }
322
carrier_firebullet_right(edict_t * self)323 void carrier_firebullet_right (edict_t *self)
324 {
325 vec3_t forward, right, target;
326 vec3_t start;
327 int flashnum;
328
329 // if we're in manual steering mode, it means we're leaning down .. use the lower shot
330 if (self->monsterinfo.aiflags & AI_MANUAL_STEERING)
331 flashnum = MZ2_CARRIER_MACHINEGUN_R2;
332 else
333 flashnum = MZ2_CARRIER_MACHINEGUN_R1;
334
335 AngleVectors (self->s.angles, forward, right, NULL);
336 G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
337
338 // VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
339 VectorMA (self->enemy->s.origin, 0.2, self->enemy->velocity, target);
340 target[2] += self->enemy->viewheight;
341 /*
342 gi.WriteByte (svc_temp_entity);
343 gi.WriteByte (TE_DEBUGTRAIL);
344 gi.WritePosition (start);
345 gi.WritePosition (target);
346 gi.multicast (start, MULTICAST_ALL);
347 */
348 VectorSubtract (target, start, forward);
349 VectorNormalize (forward);
350
351 monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD*3, DEFAULT_BULLET_VSPREAD, flashnum);
352 }
353
carrier_firebullet_left(edict_t * self)354 void carrier_firebullet_left (edict_t *self)
355 {
356 vec3_t forward, right, target;
357 vec3_t start;
358 int flashnum;
359
360 // if we're in manual steering mode, it means we're leaning down .. use the lower shot
361 if (self->monsterinfo.aiflags & AI_MANUAL_STEERING)
362 flashnum = MZ2_CARRIER_MACHINEGUN_L2;
363 else
364 flashnum = MZ2_CARRIER_MACHINEGUN_L1;
365
366 AngleVectors (self->s.angles, forward, right, NULL);
367 G_ProjectSource (self->s.origin, monster_flash_offset[flashnum], forward, right, start);
368
369 // VectorMA (self->enemy->s.origin, 0.2, self->enemy->velocity, target);
370 VectorMA (self->enemy->s.origin, -0.2, self->enemy->velocity, target);
371
372 target[2] += self->enemy->viewheight;
373 VectorSubtract (target, start, forward);
374 /*
375 gi.WriteByte (svc_temp_entity);
376 gi.WriteByte (TE_DEBUGTRAIL);
377 gi.WritePosition (start);
378 gi.WritePosition (target);
379 gi.multicast (start, MULTICAST_ALL);
380 */
381 VectorNormalize (forward);
382
383 monster_fire_bullet (self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD*3, DEFAULT_BULLET_VSPREAD, flashnum);
384 }
385
CarrierMachineGun(edict_t * self)386 void CarrierMachineGun (edict_t *self)
387 {
388 CarrierCoopCheck(self);
389 if (self->enemy)
390 carrier_firebullet_left(self);
391 if (self->enemy)
392 carrier_firebullet_right(self);
393 }
394
CarrierSpawn(edict_t * self)395 void CarrierSpawn (edict_t *self)
396 {
397 vec3_t f, r, offset, startpoint, spawnpoint;
398 edict_t *ent;
399 int mytime;
400
401 // VectorSet (offset, 105, 0, -30); // real distance needed is (sqrt (56*56*2) + sqrt(16*16*2)) or 101.8
402 VectorSet (offset, 105, 0, -58); // real distance needed is (sqrt (56*56*2) + sqrt(16*16*2)) or 101.8
403 AngleVectors (self->s.angles, f, r, NULL);
404
405 G_ProjectSource (self->s.origin, offset, f, r, startpoint);
406
407 // the +0.1 is because level.time is sometimes a little low
408 mytime = (int)((level.time + 0.1 - self->timestamp)/0.5);
409 // if ((g_showlogic) && (g_showlogic->value))
410 // gi.dprintf ("mytime = %d, (%2.2f)\n", mytime, level.time - self->timestamp);
411
412 if (FindSpawnPoint (startpoint, flyer_mins, flyer_maxs, spawnpoint, 32))
413 {
414 // the second flier should be a kamikaze flyer
415 if (mytime != 2)
416 ent = CreateMonster (spawnpoint, self->s.angles, "monster_flyer");
417 else
418 ent = CreateMonster (spawnpoint, self->s.angles, "monster_kamikaze");
419
420 if (!ent)
421 return;
422
423 gi.sound (self, CHAN_BODY, sound_spawn, 1, ATTN_NONE, 0);
424
425 self->monsterinfo.monster_slots--;
426 // if ((g_showlogic) && (g_showlogic->value))
427 // gi.dprintf ("carrier: post-spawn : %d slots left\n", self->monsterinfo.monster_slots);
428
429 ent->nextthink = level.time;
430 ent->think (ent);
431
432 ent->monsterinfo.aiflags |= AI_SPAWNED_CARRIER|AI_DO_NOT_COUNT|AI_IGNORE_SHOTS;
433 ent->monsterinfo.commander = self;
434
435 if ((self->enemy->inuse) && (self->enemy->health > 0))
436 {
437 ent->enemy = self->enemy;
438 FoundTarget (ent);
439 if (mytime == 1)
440 {
441 ent->monsterinfo.lefty = 0;
442 ent->monsterinfo.attack_state = AS_SLIDING;
443 ent->monsterinfo.currentmove = &flyer_move_attack3;
444 }
445 else if (mytime == 2)
446 {
447 ent->monsterinfo.lefty = 0;
448 ent->monsterinfo.attack_state = AS_STRAIGHT;
449 ent->monsterinfo.currentmove = &flyer_move_kamikaze;
450 ent->mass = 100;
451 ent->monsterinfo.aiflags |= AI_CHARGING;
452 }
453 else if (mytime == 3)
454 {
455 ent->monsterinfo.lefty = 1;
456 ent->monsterinfo.attack_state = AS_SLIDING;
457 ent->monsterinfo.currentmove = &flyer_move_attack3;
458 }
459 // else if ((g_showlogic) && (g_showlogic->value))
460 // gi.dprintf ("carrier: unexpected time %d!\n", mytime);
461 }
462 }
463 }
464
carrier_prep_spawn(edict_t * self)465 void carrier_prep_spawn (edict_t *self)
466 {
467 CarrierCoopCheck(self);
468 self->monsterinfo.aiflags |= AI_MANUAL_STEERING;
469 self->timestamp = level.time;
470 self->yaw_speed = 10;
471 CarrierMachineGun(self);
472 }
473
carrier_spawn_check(edict_t * self)474 void carrier_spawn_check (edict_t *self)
475 {
476 // gi.dprintf ("times - %2.2f %2.2f\n", level.time, self->timestamp);
477 CarrierCoopCheck(self);
478 CarrierMachineGun(self);
479 CarrierSpawn (self);
480
481 if (level.time > (self->timestamp + 1.1)) // 0.5 seconds per flyer. this gets three
482 {
483 self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
484 self->yaw_speed = orig_yaw_speed;
485 return;
486 }
487 else
488 self->monsterinfo.nextframe = FRAME_spawn08;
489 }
490
carrier_ready_spawn(edict_t * self)491 void carrier_ready_spawn (edict_t *self)
492 {
493 float current_yaw;
494 vec3_t offset, f, r, startpoint, spawnpoint;
495
496 CarrierCoopCheck(self);
497 CarrierMachineGun(self);
498
499 current_yaw = anglemod(self->s.angles[YAW]);
500
501 // gi.dprintf ("yaws = %2.2f %2.2f\n", current_yaw, self->ideal_yaw);
502
503 if (fabs(current_yaw - self->ideal_yaw) > 0.1)
504 {
505 self->monsterinfo.aiflags |= AI_HOLD_FRAME;
506 self->timestamp += FRAMETIME;
507 return;
508 }
509
510 self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
511
512 VectorSet (offset, 105,0,-58);
513 AngleVectors (self->s.angles, f, r, NULL);
514 G_ProjectSource (self->s.origin, offset, f, r, startpoint);
515 if (FindSpawnPoint (startpoint, flyer_mins, flyer_maxs, spawnpoint, 32))
516 {
517 SpawnGrow_Spawn (spawnpoint, 0);
518 }
519 }
520
carrier_start_spawn(edict_t * self)521 void carrier_start_spawn (edict_t *self)
522 {
523 int mytime;
524 float enemy_yaw;
525 vec3_t temp;
526 // vec3_t offset, f, r, startpoint;
527
528 CarrierCoopCheck(self);
529 if (!orig_yaw_speed)
530 orig_yaw_speed = self->yaw_speed;
531
532 if (!self->enemy)
533 return;
534
535 mytime = (int)((level.time - self->timestamp)/0.5);
536
537 VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
538 enemy_yaw = vectoyaw2(temp);
539
540 // note that the offsets are based on a forward of 105 from the end angle
541 if (mytime == 0)
542 {
543 self->ideal_yaw = anglemod(enemy_yaw - 30);
544 // VectorSet (offset, 90.9, 52.5, 0);
545 }
546 else if (mytime == 1)
547 {
548 self->ideal_yaw = anglemod(enemy_yaw);
549 // VectorSet (offset, 90.9, -52.5, 0);
550 }
551 else if (mytime == 2)
552 {
553 self->ideal_yaw = anglemod(enemy_yaw + 30);
554 // VectorSet (offset, 90.9, -52.5, 0);
555 }
556 // else if ((g_showlogic) && (g_showlogic->value))
557 // gi.dprintf ("carrier: bad spawntime\n");
558
559 CarrierMachineGun (self);
560 }
561
562 mframe_t carrier_frames_stand [] =
563 {
564 // ai_stand, 0, drawbbox,
565 ai_stand, 0, NULL,
566 ai_stand, 0, NULL,
567 ai_stand, 0, NULL,
568 ai_stand, 0, NULL,
569 ai_stand, 0, NULL,
570 ai_stand, 0, NULL,
571 ai_stand, 0, NULL,
572 ai_stand, 0, NULL,
573 ai_stand, 0, NULL,
574 ai_stand, 0, NULL,
575 ai_stand, 0, NULL,
576 ai_stand, 0, NULL,
577 ai_stand, 0, NULL
578 };
579 mmove_t carrier_move_stand = {FRAME_search01, FRAME_search13, carrier_frames_stand, NULL};
580
581 mframe_t carrier_frames_walk [] =
582 {
583 // ai_walk, 12, drawbbox,
584 ai_walk, 4, NULL,
585 ai_walk, 4, NULL,
586 ai_walk, 4, NULL,
587 ai_walk, 4, NULL,
588 ai_walk, 4, NULL,
589 ai_walk, 4, NULL,
590 ai_walk, 4, NULL,
591 ai_walk, 4, NULL,
592 ai_walk, 4, NULL,
593 ai_walk, 4, NULL,
594 ai_walk, 4, NULL,
595 ai_walk, 4, NULL,
596 ai_walk, 4, NULL
597 };
598 mmove_t carrier_move_walk = {FRAME_search01, FRAME_search13, carrier_frames_walk, NULL};
599
600
601 mframe_t carrier_frames_run [] =
602 {
603 // ai_run, 12, drawbbox,
604 ai_run, 6, CarrierCoopCheck,
605 ai_run, 6, CarrierCoopCheck,
606 ai_run, 6, CarrierCoopCheck,
607 ai_run, 6, CarrierCoopCheck,
608 ai_run, 6, CarrierCoopCheck,
609 ai_run, 6, CarrierCoopCheck,
610 ai_run, 6, CarrierCoopCheck,
611 ai_run, 6, CarrierCoopCheck,
612 ai_run, 6, CarrierCoopCheck,
613 ai_run, 6, CarrierCoopCheck,
614 ai_run, 6, CarrierCoopCheck,
615 ai_run, 6, CarrierCoopCheck,
616 ai_run, 6, CarrierCoopCheck
617 };
618 mmove_t carrier_move_run = {FRAME_search01, FRAME_search13, carrier_frames_run, NULL};
619
620 mframe_t carrier_frames_attack_pre_mg [] =
621 {
622 ai_charge, 4, CarrierCoopCheck,
623 ai_charge, 4, CarrierCoopCheck,
624 ai_charge, 4, CarrierCoopCheck,
625 ai_charge, 4, CarrierCoopCheck,
626 ai_charge, 4, CarrierCoopCheck,
627 ai_charge, 4, CarrierCoopCheck,
628 ai_charge, 4, CarrierCoopCheck,
629 ai_charge, 4, carrier_attack_mg
630 };
631 mmove_t carrier_move_attack_pre_mg = {FRAME_firea01, FRAME_firea08, carrier_frames_attack_pre_mg, NULL};
632
633
634 // Loop this
635 mframe_t carrier_frames_attack_mg [] =
636 {
637 ai_charge, -2, CarrierMachineGun,
638 ai_charge, -2, CarrierMachineGun,
639 ai_charge, -2, carrier_reattack_mg
640 /*
641 ai_charge, 0, CarrierMachineGunHold,
642 // ai_charge, 0, CarrierMachineGun,
643 ai_charge, 0, CarrierMachineGun,
644 ai_charge, 0, carrier_reattack_mg
645 */
646 };
647 mmove_t carrier_move_attack_mg = {FRAME_firea09, FRAME_firea11, carrier_frames_attack_mg, NULL};
648
649 mframe_t carrier_frames_attack_post_mg [] =
650 {
651 ai_charge, 4, CarrierCoopCheck,
652 ai_charge, 4, CarrierCoopCheck,
653 ai_charge, 4, CarrierCoopCheck,
654 ai_charge, 4, CarrierCoopCheck
655 };
656 mmove_t carrier_move_attack_post_mg = {FRAME_firea12, FRAME_firea15, carrier_frames_attack_post_mg, carrier_run};
657
658 mframe_t carrier_frames_attack_pre_gren [] =
659 {
660 ai_charge, 4, CarrierCoopCheck,
661 ai_charge, 4, CarrierCoopCheck,
662 ai_charge, 4, CarrierCoopCheck,
663 ai_charge, 4, CarrierCoopCheck,
664 ai_charge, 4, CarrierCoopCheck,
665 ai_charge, 4, carrier_attack_gren
666 };
667 mmove_t carrier_move_attack_pre_gren = {FRAME_fireb01, FRAME_fireb06, carrier_frames_attack_pre_gren, NULL};
668
669 mframe_t carrier_frames_attack_gren [] =
670 {
671 ai_charge, -15, CarrierGrenade,
672 ai_charge, 4, CarrierCoopCheck,
673 ai_charge, 4, CarrierCoopCheck,
674 ai_charge, 4, carrier_reattack_gren
675 };
676 mmove_t carrier_move_attack_gren = {FRAME_fireb07, FRAME_fireb10, carrier_frames_attack_gren, NULL};
677
678 mframe_t carrier_frames_attack_post_gren [] =
679 {
680 ai_charge, 4, CarrierCoopCheck,
681 ai_charge, 4, CarrierCoopCheck,
682 ai_charge, 4, CarrierCoopCheck,
683 ai_charge, 4, CarrierCoopCheck,
684 ai_charge, 4, CarrierCoopCheck,
685 ai_charge, 4, CarrierCoopCheck
686 };
687 mmove_t carrier_move_attack_post_gren = {FRAME_fireb11, FRAME_fireb16, carrier_frames_attack_post_gren, carrier_run};
688
689 mframe_t carrier_frames_attack_rocket [] =
690 {
691 ai_charge, 15, CarrierRocket
692 };
693 mmove_t carrier_move_attack_rocket = {FRAME_fireb01, FRAME_fireb01, carrier_frames_attack_rocket, carrier_run};
694
CarrierRail(edict_t * self)695 void CarrierRail (edict_t *self)
696 {
697 vec3_t start;
698 vec3_t dir;
699 vec3_t forward, right;
700
701 CarrierCoopCheck(self);
702 AngleVectors (self->s.angles, forward, right, NULL);
703 G_ProjectSource (self->s.origin, monster_flash_offset[MZ2_CARRIER_RAILGUN], forward, right, start);
704
705 // calc direction to where we targeted
706 VectorSubtract (self->pos1, start, dir);
707 VectorNormalize (dir);
708
709 monster_fire_railgun (self, start, dir, 50, 100, MZ2_CARRIER_RAILGUN);
710 self->monsterinfo.attack_finished = level.time + RAIL_FIRE_TIME;
711 }
712
CarrierSaveLoc(edict_t * self)713 void CarrierSaveLoc (edict_t *self)
714 {
715 CarrierCoopCheck(self);
716 VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
717 self->pos1[2] += self->enemy->viewheight;
718 };
719
720 mframe_t carrier_frames_attack_rail [] =
721 {
722 ai_charge, 2, CarrierCoopCheck,
723 ai_charge, 2, CarrierSaveLoc,
724 ai_charge, 2, CarrierCoopCheck,
725 ai_charge, -20, CarrierRail,
726 ai_charge, 2, CarrierCoopCheck,
727 ai_charge, 2, CarrierCoopCheck,
728 ai_charge, 2, CarrierCoopCheck,
729 ai_charge, 2, CarrierCoopCheck,
730 ai_charge, 2, CarrierCoopCheck
731 };
732 mmove_t carrier_move_attack_rail = {FRAME_search01, FRAME_search09, carrier_frames_attack_rail, carrier_run};
733
734 mframe_t carrier_frames_spawn [] =
735 {
736 ai_charge, -2, CarrierMachineGun,
737 ai_charge, -2, CarrierMachineGun,
738 ai_charge, -2, CarrierMachineGun,
739 ai_charge, -2, CarrierMachineGun,
740 ai_charge, -2, CarrierMachineGun,
741 ai_charge, -2, CarrierMachineGun,
742 ai_charge, -2, carrier_prep_spawn, // 7 - end of wind down
743 ai_charge, -2, carrier_start_spawn, // 8 - start of spawn
744 ai_charge, -2, carrier_ready_spawn,
745 ai_charge, -2, CarrierMachineGun,
746 ai_charge, -2, CarrierMachineGun,
747 ai_charge, -10, carrier_spawn_check, //12 - actual spawn
748 ai_charge, -2, CarrierMachineGun, //13 - begin of wind down
749 ai_charge, -2, CarrierMachineGun,
750 ai_charge, -2, CarrierMachineGun,
751 ai_charge, -2, CarrierMachineGun,
752 ai_charge, -2, CarrierMachineGun,
753 ai_charge, -2, carrier_reattack_mg //18 - end of wind down
754 };
755 mmove_t carrier_move_spawn = {FRAME_spawn01, FRAME_spawn18, carrier_frames_spawn, NULL};
756
757 mframe_t carrier_frames_pain_heavy [] =
758 {
759 ai_move, 0, NULL,
760 ai_move, 0, NULL,
761 ai_move, 0, NULL,
762 ai_move, 0, NULL,
763 ai_move, 0, NULL,
764 ai_move, 0, NULL,
765 ai_move, 0, NULL,
766 ai_move, 0, NULL,
767 ai_move, 0, NULL,
768 ai_move, 0, NULL
769 };
770 mmove_t carrier_move_pain_heavy = {FRAME_death01, FRAME_death10, carrier_frames_pain_heavy, carrier_run};
771
772 mframe_t carrier_frames_pain_light [] =
773 {
774 ai_move, 0, NULL,
775 ai_move, 0, NULL,
776 ai_move, 0, NULL,
777 ai_move, 0, NULL
778 };
779 mmove_t carrier_move_pain_light = {FRAME_spawn01, FRAME_spawn04, carrier_frames_pain_light, carrier_run};
780
781 mframe_t carrier_frames_death [] =
782 {
783 ai_move, 0, NULL,
784 ai_move, 0, NULL,
785 ai_move, 0, NULL,
786 ai_move, 0, NULL,
787 ai_move, 0, NULL,
788 ai_move, 0, NULL,
789 ai_move, 0, NULL,
790 ai_move, 0, NULL,
791 ai_move, 0, NULL,
792 ai_move, 0, NULL,
793 ai_move, 0, NULL,
794 ai_move, 0, NULL,
795 ai_move, 0, NULL,
796 ai_move, 0, NULL,
797 ai_move, 0, NULL,
798 ai_move, 0, BossExplode
799 };
800 mmove_t carrier_move_death = {FRAME_death01, FRAME_death16, carrier_frames_death, carrier_dead};
801
carrier_stand(edict_t * self)802 void carrier_stand (edict_t *self)
803 {
804 // gi.dprintf ("carrier stand\n");
805 self->monsterinfo.currentmove = &carrier_move_stand;
806 }
807
carrier_run(edict_t * self)808 void carrier_run (edict_t *self)
809 {
810
811 // gi.dprintf ("carrier run - %2.2f - %s \n", level.time, self->enemy->classname);
812 self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
813
814 if (self->monsterinfo.aiflags & AI_STAND_GROUND)
815 self->monsterinfo.currentmove = &carrier_move_stand;
816 else
817 self->monsterinfo.currentmove = &carrier_move_run;
818 }
819
carrier_walk(edict_t * self)820 void carrier_walk (edict_t *self)
821 {
822 self->monsterinfo.currentmove = &carrier_move_walk;
823 }
824
CarrierMachineGunHold(edict_t * self)825 void CarrierMachineGunHold (edict_t *self)
826 {
827 // self->monsterinfo.aiflags |= AI_HOLD_FRAME;
828 // self->yaw_speed = 0;
829 // self->monsterinfo.currentmove = &carrier_move_attack_mg;
830 CarrierMachineGun (self);
831 }
832
carrier_attack(edict_t * self)833 void carrier_attack (edict_t *self)
834 {
835 vec3_t vec;
836 float range, luck;
837 qboolean enemy_inback, enemy_infront, enemy_below;
838
839 // gi.dprintf ("carrier attack\n");
840
841 self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
842
843 if ((!self->enemy) || (!self->enemy->inuse))
844 return;
845
846 enemy_inback = inback(self, self->enemy);
847 enemy_infront = infront (self, self->enemy);
848 enemy_below = below (self, self->enemy);
849
850 if (self->bad_area)
851 {
852 if ((enemy_inback) || (enemy_below))
853 self->monsterinfo.currentmove = &carrier_move_attack_rocket;
854 else if ((random() < 0.1) || (level.time < self->monsterinfo.attack_finished))
855 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
856 else
857 {
858 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
859 self->monsterinfo.currentmove = &carrier_move_attack_rail;
860 }
861 return;
862 }
863
864 if (self->monsterinfo.attack_state == AS_BLIND)
865 {
866 self->monsterinfo.currentmove = &carrier_move_spawn;
867 return;
868 }
869
870 if (!enemy_inback && !enemy_infront && !enemy_below) // to side and not under
871 {
872 if ((random() < 0.1) || (level.time < self->monsterinfo.attack_finished))
873 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
874 else
875 {
876 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
877 self->monsterinfo.currentmove = &carrier_move_attack_rail;
878 }
879 return;
880 }
881
882 /* if ((g_showlogic) && (g_showlogic->value))
883 {
884 gi.dprintf ("checking enemy ..");
885 if (enemy_inback)
886 gi.dprintf (" in back\n");
887 else if (enemy_infront)
888 gi.dprintf (" in front\n");
889 else
890 gi.dprintf (" inaccessible\n");
891 }
892 */
893 if (enemy_infront)
894 {
895 VectorSubtract (self->enemy->s.origin, self->s.origin, vec);
896 range = VectorLength (vec);
897 if (range <= 125)
898 {
899 if ((random() < 0.8) || (level.time < self->monsterinfo.attack_finished))
900 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
901 else
902 {
903 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
904 self->monsterinfo.currentmove = &carrier_move_attack_rail;
905 }
906 }
907 else if (range < 600)
908 {
909 luck = random();
910 if (self->monsterinfo.monster_slots > 2)
911 {
912 if (luck <= 0.20)
913 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
914 else if (luck <= 0.40)
915 self->monsterinfo.currentmove = &carrier_move_attack_pre_gren;
916 else if ((luck <= 0.7) && !(level.time < self->monsterinfo.attack_finished))
917 {
918 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
919 self->monsterinfo.currentmove = &carrier_move_attack_rail;
920 }
921 else
922 self->monsterinfo.currentmove = &carrier_move_spawn;
923 }
924 else
925 {
926 if (luck <= 0.30)
927 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
928 else if (luck <= 0.65)
929 self->monsterinfo.currentmove = &carrier_move_attack_pre_gren;
930 else if (level.time >= self->monsterinfo.attack_finished)
931 {
932 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
933 self->monsterinfo.currentmove = &carrier_move_attack_rail;
934 }
935 else
936 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
937 }
938 }
939 else // won't use grenades at this range
940 {
941 luck = random();
942 if (self->monsterinfo.monster_slots > 2)
943 {
944 if (luck < 0.3)
945 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
946 else if ((luck < 0.65) && !(level.time < self->monsterinfo.attack_finished))
947 {
948 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
949 VectorCopy (self->enemy->s.origin, self->pos1); //save for aiming the shot
950 self->pos1[2] += self->enemy->viewheight;
951 self->monsterinfo.currentmove = &carrier_move_attack_rail;
952 }
953 else
954 self->monsterinfo.currentmove = &carrier_move_spawn;
955 }
956 else
957 {
958 if ((luck < 0.45) || (level.time < self->monsterinfo.attack_finished))
959 self->monsterinfo.currentmove = &carrier_move_attack_pre_mg;
960 else
961 {
962 gi.sound (self, CHAN_WEAPON, sound_rail, 1, ATTN_NORM, 0);
963 self->monsterinfo.currentmove = &carrier_move_attack_rail;
964 }
965 }
966 }
967 }
968 else if ((enemy_below) || (enemy_inback))
969 {
970 self->monsterinfo.currentmove = &carrier_move_attack_rocket;
971 }
972 }
973
carrier_attack_mg(edict_t * self)974 void carrier_attack_mg (edict_t *self)
975 {
976 CarrierCoopCheck(self);
977 self->monsterinfo.currentmove = &carrier_move_attack_mg;
978 }
979
carrier_reattack_mg(edict_t * self)980 void carrier_reattack_mg (edict_t *self)
981 {
982 CarrierCoopCheck(self);
983 if ( infront(self, self->enemy) )
984 if (random() <= 0.5)
985 if ((random() < 0.7) || (self->monsterinfo.monster_slots <= 2))
986 self->monsterinfo.currentmove = &carrier_move_attack_mg;
987 else
988 self->monsterinfo.currentmove = &carrier_move_spawn;
989 else
990 self->monsterinfo.currentmove = &carrier_move_attack_post_mg;
991 else
992 self->monsterinfo.currentmove = &carrier_move_attack_post_mg;
993 }
994
995
carrier_attack_gren(edict_t * self)996 void carrier_attack_gren (edict_t *self)
997 {
998 // gi.dprintf ("carrier_attack_gren - %2.2f\n",level.time);
999 CarrierCoopCheck(self);
1000 self->timestamp = level.time;
1001 self->monsterinfo.currentmove = &carrier_move_attack_gren;
1002 }
1003
carrier_reattack_gren(edict_t * self)1004 void carrier_reattack_gren (edict_t *self)
1005 {
1006 CarrierCoopCheck(self);
1007 // gi.dprintf ("carrier_reattack - %2.2f", level.time);
1008 if ( infront(self, self->enemy) )
1009 if (self->timestamp + 1.3 > level.time ) // four grenades
1010 {
1011 // gi.dprintf (" attacking\n");
1012 self->monsterinfo.currentmove = &carrier_move_attack_gren;
1013 return;
1014 }
1015 // gi.dprintf ("not attacking\n");
1016 self->monsterinfo.currentmove = &carrier_move_attack_post_gren;
1017 }
1018
1019
carrier_pain(edict_t * self,edict_t * other,float kick,int damage)1020 void carrier_pain (edict_t *self, edict_t *other, float kick, int damage)
1021 {
1022 qboolean changed = false;
1023
1024 if (self->health < (self->max_health / 2))
1025 self->s.skinnum = 1;
1026
1027 if (skill->value == 3)
1028 return; // no pain anims in nightmare
1029
1030 // gi.dprintf ("carrier pain\n");
1031 if (level.time < self->pain_debounce_time)
1032 return;
1033
1034 self->pain_debounce_time = level.time + 5;
1035
1036 if (damage < 10)
1037 {
1038 gi.sound (self, CHAN_VOICE, sound_pain3, 1, ATTN_NONE, 0);
1039 }
1040 else if (damage < 30)
1041 {
1042 gi.sound (self, CHAN_VOICE, sound_pain1, 1, ATTN_NONE, 0);
1043 if (random() < 0.5)
1044 {
1045 changed = true;
1046 self->monsterinfo.currentmove = &carrier_move_pain_light;
1047 }
1048 }
1049 else
1050 {
1051 gi.sound (self, CHAN_VOICE, sound_pain2, 1, ATTN_NONE, 0);
1052 self->monsterinfo.currentmove = &carrier_move_pain_heavy;
1053 changed = true;
1054 }
1055
1056 // if we changed frames, clean up our little messes
1057 if (changed)
1058 {
1059 self->monsterinfo.aiflags &= ~AI_HOLD_FRAME;
1060 self->monsterinfo.aiflags &= ~AI_MANUAL_STEERING;
1061 self->yaw_speed = orig_yaw_speed;
1062 }
1063 }
1064
carrier_dead(edict_t * self)1065 void carrier_dead (edict_t *self)
1066 {
1067 VectorSet (self->mins, -56, -56, 0);
1068 VectorSet (self->maxs, 56, 56, 80);
1069 self->movetype = MOVETYPE_TOSS;
1070 self->svflags |= SVF_DEADMONSTER;
1071 self->nextthink = 0;
1072 gi.linkentity (self);
1073 }
1074
carrier_die(edict_t * self,edict_t * inflictor,edict_t * attacker,int damage,vec3_t point)1075 void carrier_die (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, vec3_t point)
1076 {
1077 gi.sound (self, CHAN_VOICE, sound_death, 1, ATTN_NONE, 0);
1078 self->deadflag = DEAD_DEAD;
1079 self->takedamage = DAMAGE_NO;
1080 self->count = 0;
1081 self->monsterinfo.currentmove = &carrier_move_death;
1082 }
1083
Carrier_CheckAttack(edict_t * self)1084 qboolean Carrier_CheckAttack (edict_t *self)
1085 {
1086 vec3_t spot1, spot2;
1087 vec3_t temp;
1088 float chance;
1089 trace_t tr;
1090 qboolean enemy_infront, enemy_inback, enemy_below;
1091 int enemy_range;
1092 float enemy_yaw;
1093
1094 if (self->enemy->health > 0)
1095 {
1096 // see if any entities are in the way of the shot
1097 VectorCopy (self->s.origin, spot1);
1098 spot1[2] += self->viewheight;
1099 VectorCopy (self->enemy->s.origin, spot2);
1100 spot2[2] += self->enemy->viewheight;
1101
1102 tr = gi.trace (spot1, NULL, NULL, spot2, self, CONTENTS_SOLID|CONTENTS_MONSTER|CONTENTS_SLIME|CONTENTS_LAVA);
1103
1104 // do we have a clear shot?
1105 if (tr.ent != self->enemy)
1106 {
1107 // go ahead and spawn stuff if we're mad a a client
1108 if (self->enemy->client && self->monsterinfo.monster_slots > 2)
1109 {
1110 self->monsterinfo.attack_state = AS_BLIND;
1111 return true;
1112 }
1113
1114 // PGM - we want them to go ahead and shoot at info_notnulls if they can.
1115 if(self->enemy->solid != SOLID_NOT || tr.fraction < 1.0) //PGM
1116 return false;
1117 }
1118 }
1119
1120 enemy_infront = infront(self, self->enemy);
1121 enemy_inback = inback(self, self->enemy);
1122 enemy_below = below (self, self->enemy);
1123
1124 enemy_range = range(self, self->enemy);
1125 VectorSubtract (self->enemy->s.origin, self->s.origin, temp);
1126 enemy_yaw = vectoyaw2(temp);
1127
1128 self->ideal_yaw = enemy_yaw;
1129
1130 // PMM - shoot out the back if appropriate
1131 if ((enemy_inback) || (!enemy_infront && enemy_below))
1132 {
1133 // this is using wait because the attack is supposed to be independent
1134 if (level.time >= self->wait)
1135 {
1136 self->wait = level.time + CARRIER_ROCKET_TIME;
1137 self->monsterinfo.attack(self);
1138 if (random() < 0.6)
1139 self->monsterinfo.attack_state = AS_SLIDING;
1140 else
1141 self->monsterinfo.attack_state = AS_STRAIGHT;
1142 return true;
1143 }
1144 }
1145
1146 // melee attack
1147 if (enemy_range == RANGE_MELEE)
1148 {
1149 self->monsterinfo.attack_state = AS_MISSILE;
1150 return true;
1151 }
1152
1153 // if (level.time < self->monsterinfo.attack_finished)
1154 // return false;
1155
1156 if (self->monsterinfo.aiflags & AI_STAND_GROUND)
1157 {
1158 chance = 0.4;
1159 }
1160 else if (enemy_range == RANGE_MELEE)
1161 {
1162 chance = 0.8;
1163 }
1164 else if (enemy_range == RANGE_NEAR)
1165 {
1166 chance = 0.8;
1167 }
1168 else if (enemy_range == RANGE_MID)
1169 {
1170 chance = 0.8;
1171 }
1172 else if (enemy_range == RANGE_FAR)
1173 {
1174 chance = 0.5;
1175 }
1176
1177 // PGM - go ahead and shoot every time if it's a info_notnull
1178 if ((random () < chance) || (self->enemy->solid == SOLID_NOT))
1179 {
1180 self->monsterinfo.attack_state = AS_MISSILE;
1181 // self->monsterinfo.attack_finished = level.time + 2*random();
1182 return true;
1183 }
1184
1185 if (self->flags & FL_FLY)
1186 {
1187 if (random() < 0.6)
1188 self->monsterinfo.attack_state = AS_SLIDING;
1189 else
1190 self->monsterinfo.attack_state = AS_STRAIGHT;
1191 }
1192
1193 return false;
1194 }
1195
CarrierPrecache()1196 void CarrierPrecache ()
1197 {
1198 gi.soundindex ("flyer/flysght1.wav");
1199 gi.soundindex ("flyer/flysrch1.wav");
1200 gi.soundindex ("flyer/flypain1.wav");
1201 gi.soundindex ("flyer/flypain2.wav");
1202 gi.soundindex ("flyer/flyatck2.wav");
1203 gi.soundindex ("flyer/flyatck1.wav");
1204 gi.soundindex ("flyer/flydeth1.wav");
1205 gi.soundindex ("flyer/flyatck3.wav");
1206 gi.soundindex ("flyer/flyidle1.wav");
1207 gi.soundindex ("weapons/rockfly.wav");
1208 gi.soundindex ("infantry/infatck1.wav");
1209 gi.soundindex ("gunner/gunatck3.wav");
1210 gi.soundindex ("weapons/grenlb1b.wav");
1211 gi.soundindex ("tank/rocket.wav");
1212
1213 gi.modelindex ("models/monsters/flyer/tris.md2");
1214 gi.modelindex ("models/objects/rocket/tris.md2");
1215 gi.modelindex ("models/objects/debris2/tris.md2");
1216 gi.modelindex ("models/objects/grenade/tris.md2");
1217 gi.modelindex("models/items/spawngro/tris.md2");
1218 gi.modelindex("models/items/spawngro2/tris.md2");
1219 gi.modelindex ("models/objects/gibs/sm_metal/tris.md2");
1220 gi.modelindex ("models/objects/gibs/gear/tris.md2");
1221 }
1222
1223
1224 /*QUAKED monster_carrier (1 .5 0) (-56 -56 -44) (56 56 44) Ambush Trigger_Spawn Sight
1225 */
SP_monster_carrier(edict_t * self)1226 void SP_monster_carrier (edict_t *self)
1227 {
1228 if (deathmatch->value)
1229 {
1230 G_FreeEdict (self);
1231 return;
1232 }
1233
1234 sound_pain1 = gi.soundindex ("carrier/pain_md.wav");
1235 sound_pain2 = gi.soundindex ("carrier/pain_lg.wav");
1236 sound_pain3 = gi.soundindex ("carrier/pain_sm.wav");
1237 sound_death = gi.soundindex ("carrier/death.wav");
1238 // sound_search1 = gi.soundindex ("bosshovr/bhvunqv1.wav");
1239 sound_rail = gi.soundindex ("gladiator/railgun.wav");
1240 sound_sight = gi.soundindex ("carrier/sight.wav");
1241 sound_spawn = gi.soundindex ("medic_commander/monsterspawn1.wav");
1242
1243 self->s.sound = gi.soundindex ("bosshovr/bhvengn1.wav");
1244
1245 self->movetype = MOVETYPE_STEP;
1246 self->solid = SOLID_BBOX;
1247 self->s.modelindex = gi.modelindex ("models/monsters/carrier/tris.md2");
1248 VectorSet (self->mins, -56, -56, -44);
1249 VectorSet (self->maxs, 56, 56, 44);
1250
1251 // 2000 - 4000 health
1252 self->health = max (2000, 2000 + 1000*((skill->value)-1));
1253 // add health in coop (500 * skill)
1254 if (coop->value)
1255 self->health += 500*(skill->value);
1256
1257 self->gib_health = -200;
1258 self->mass = 1000;
1259
1260 self->yaw_speed = 15;
1261 orig_yaw_speed = self->yaw_speed;
1262 // self->yaw_speed = 1;
1263
1264 self->flags |= FL_IMMUNE_LASER;
1265 self->monsterinfo.aiflags |= AI_IGNORE_SHOTS;
1266
1267 self->pain = carrier_pain;
1268 self->die = carrier_die;
1269
1270 self->monsterinfo.melee = NULL;
1271 self->monsterinfo.stand = carrier_stand;
1272 self->monsterinfo.walk = carrier_walk;
1273 self->monsterinfo.run = carrier_run;
1274 self->monsterinfo.attack = carrier_attack;
1275 // self->monsterinfo.search = carrier_search;
1276 self->monsterinfo.sight = carrier_sight;
1277 self->monsterinfo.checkattack = Carrier_CheckAttack;
1278 gi.linkentity (self);
1279
1280 self->monsterinfo.currentmove = &carrier_move_stand;
1281 self->monsterinfo.scale = MODEL_SCALE;
1282
1283 CarrierPrecache();
1284
1285 flymonster_start (self);
1286
1287 self->monsterinfo.attack_finished = 0;
1288 switch ((int)skill->value)
1289 {
1290 case 0:
1291 self->monsterinfo.monster_slots = 3;
1292 break;
1293 case 1:
1294 case 2:
1295 self->monsterinfo.monster_slots = 6;
1296 break;
1297 case 3:
1298 self->monsterinfo.monster_slots = 9;
1299 break;
1300 default:
1301 self->monsterinfo.monster_slots = 6;
1302 break;
1303 }
1304 }
1305
1306