mirror of
https://github.com/id-Software/quake2-rerelease-dll.git
synced 2025-02-14 15:51:42 +00:00
720 lines
17 KiB
C++
720 lines
17 KiB
C++
// Copyright (c) ZeniMax Media Inc.
|
|
// Licensed under the GNU General Public License 2.0.
|
|
/*
|
|
==============================================================================
|
|
|
|
jorg
|
|
|
|
==============================================================================
|
|
*/
|
|
|
|
#include "g_local.h"
|
|
#include "m_boss31.h"
|
|
#include "m_flash.h"
|
|
|
|
void SP_monster_makron(edict_t *self);
|
|
|
|
static int sound_pain1;
|
|
static int sound_pain2;
|
|
static int sound_pain3;
|
|
static int sound_idle;
|
|
static int sound_death;
|
|
static int sound_search1;
|
|
static int sound_search2;
|
|
static int sound_search3;
|
|
static int sound_attack1, sound_attack1_loop, sound_attack1_end;
|
|
static int sound_attack2, sound_bfg_fire;
|
|
static int sound_firegun;
|
|
static int sound_step_left;
|
|
static int sound_step_right;
|
|
static int sound_death_hit;
|
|
|
|
void MakronToss(edict_t *self);
|
|
|
|
void jorg_attack1_end_sound(edict_t *self)
|
|
{
|
|
if (self->monsterinfo.weapon_sound)
|
|
{
|
|
gi.sound(self, CHAN_WEAPON, sound_attack1_end, 1, ATTN_NORM, 0);
|
|
self->monsterinfo.weapon_sound = 0;
|
|
}
|
|
}
|
|
|
|
MONSTERINFO_SEARCH(jorg_search) (edict_t *self) -> void
|
|
{
|
|
float r;
|
|
|
|
r = frandom();
|
|
|
|
if (r <= 0.3f)
|
|
gi.sound(self, CHAN_VOICE, sound_search1, 1, ATTN_NORM, 0);
|
|
else if (r <= 0.6f)
|
|
gi.sound(self, CHAN_VOICE, sound_search2, 1, ATTN_NORM, 0);
|
|
else
|
|
gi.sound(self, CHAN_VOICE, sound_search3, 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
void jorg_dead(edict_t *self);
|
|
void jorgBFG(edict_t *self);
|
|
void jorg_firebullet(edict_t *self);
|
|
void jorg_reattack1(edict_t *self);
|
|
void jorg_attack1(edict_t *self);
|
|
void jorg_idle(edict_t *self);
|
|
void jorg_step_left(edict_t *self);
|
|
void jorg_step_right(edict_t *self);
|
|
void jorg_death_hit(edict_t *self);
|
|
|
|
//
|
|
// stand
|
|
//
|
|
|
|
mframe_t jorg_frames_stand[] = {
|
|
{ ai_stand, 0, jorg_idle },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand }, // 10
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand }, // 20
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand }, // 30
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand, 19 },
|
|
{ ai_stand, 11, jorg_step_left },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand, 6 },
|
|
{ ai_stand, 9, jorg_step_right },
|
|
{ ai_stand }, // 40
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand },
|
|
{ ai_stand, -2, nullptr },
|
|
{ ai_stand, -17, jorg_step_left },
|
|
{ ai_stand },
|
|
{ ai_stand, -12 }, // 50
|
|
{ ai_stand, -14, jorg_step_right } // 51
|
|
};
|
|
MMOVE_T(jorg_move_stand) = { FRAME_stand01, FRAME_stand51, jorg_frames_stand, nullptr };
|
|
|
|
void jorg_idle (edict_t *self)
|
|
{
|
|
gi.sound(self, CHAN_VOICE, sound_idle, 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
void jorg_death_hit(edict_t *self)
|
|
{
|
|
gi.sound(self, CHAN_BODY, sound_death_hit, 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
void jorg_step_left(edict_t *self)
|
|
{
|
|
gi.sound(self, CHAN_BODY, sound_step_left, 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
void jorg_step_right(edict_t *self)
|
|
{
|
|
gi.sound(self, CHAN_BODY, sound_step_right, 1, ATTN_NORM, 0);
|
|
}
|
|
|
|
MONSTERINFO_STAND(jorg_stand) (edict_t *self) -> void
|
|
{
|
|
M_SetAnimation(self, &jorg_move_stand);
|
|
|
|
jorg_attack1_end_sound(self);
|
|
}
|
|
|
|
mframe_t jorg_frames_run[] = {
|
|
{ ai_run, 17, jorg_step_left },
|
|
{ ai_run },
|
|
{ ai_run },
|
|
{ ai_run },
|
|
{ ai_run, 12 },
|
|
{ ai_run, 8 },
|
|
{ ai_run, 10 },
|
|
{ ai_run, 33, jorg_step_right },
|
|
{ ai_run },
|
|
{ ai_run },
|
|
{ ai_run },
|
|
{ ai_run, 9 },
|
|
{ ai_run, 9 },
|
|
{ ai_run, 9 }
|
|
};
|
|
MMOVE_T(jorg_move_run) = { FRAME_walk06, FRAME_walk19, jorg_frames_run, nullptr };
|
|
|
|
//
|
|
// walk
|
|
//
|
|
#if 0
|
|
mframe_t jorg_frames_start_walk[] = {
|
|
{ ai_walk, 5 },
|
|
{ ai_walk, 6 },
|
|
{ ai_walk, 7 },
|
|
{ ai_walk, 9 },
|
|
{ ai_walk, 15 }
|
|
};
|
|
MMOVE_T(jorg_move_start_walk) = { FRAME_walk01, FRAME_walk05, jorg_frames_start_walk, nullptr };
|
|
#endif
|
|
|
|
mframe_t jorg_frames_walk[] = {
|
|
{ ai_walk, 17 },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk, 12 },
|
|
{ ai_walk, 8 },
|
|
{ ai_walk, 10 },
|
|
{ ai_walk, 33 },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk, 9 },
|
|
{ ai_walk, 9 },
|
|
{ ai_walk, 9 }
|
|
};
|
|
MMOVE_T(jorg_move_walk) = { FRAME_walk06, FRAME_walk19, jorg_frames_walk, nullptr };
|
|
|
|
#if 0
|
|
mframe_t jorg_frames_end_walk[] = {
|
|
{ ai_walk, 11 },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk },
|
|
{ ai_walk, 8 },
|
|
{ ai_walk, -8 }
|
|
};
|
|
MMOVE_T(jorg_move_end_walk) = { FRAME_walk20, FRAME_walk25, jorg_frames_end_walk, nullptr };
|
|
#endif
|
|
|
|
MONSTERINFO_WALK(jorg_walk) (edict_t *self) -> void
|
|
{
|
|
M_SetAnimation(self, &jorg_move_walk);
|
|
}
|
|
|
|
MONSTERINFO_RUN(jorg_run) (edict_t *self) -> void
|
|
{
|
|
if (self->monsterinfo.aiflags & AI_STAND_GROUND)
|
|
M_SetAnimation(self, &jorg_move_stand);
|
|
else
|
|
M_SetAnimation(self, &jorg_move_run);
|
|
|
|
jorg_attack1_end_sound(self);
|
|
}
|
|
|
|
mframe_t jorg_frames_pain3[] = {
|
|
{ ai_move, -28 },
|
|
{ ai_move, -6 },
|
|
{ ai_move, -3, jorg_step_left },
|
|
{ ai_move, -9 },
|
|
{ ai_move, 0, jorg_step_right },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, -7 },
|
|
{ ai_move, 1 },
|
|
{ ai_move, -11 },
|
|
{ ai_move, -4 },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, 10 },
|
|
{ ai_move, 11 },
|
|
{ ai_move },
|
|
{ ai_move, 10 },
|
|
{ ai_move, 3 },
|
|
{ ai_move, 10 },
|
|
{ ai_move, 7, jorg_step_left },
|
|
{ ai_move, 17 },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, 0, jorg_step_right }
|
|
};
|
|
MMOVE_T(jorg_move_pain3) = { FRAME_pain301, FRAME_pain325, jorg_frames_pain3, jorg_run };
|
|
|
|
mframe_t jorg_frames_pain2[] = {
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move }
|
|
};
|
|
MMOVE_T(jorg_move_pain2) = { FRAME_pain201, FRAME_pain203, jorg_frames_pain2, jorg_run };
|
|
|
|
mframe_t jorg_frames_pain1[] = {
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move }
|
|
};
|
|
MMOVE_T(jorg_move_pain1) = { FRAME_pain101, FRAME_pain103, jorg_frames_pain1, jorg_run };
|
|
|
|
mframe_t jorg_frames_death1[] = {
|
|
{ ai_move, 0, BossExplode },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, -2 },
|
|
{ ai_move, -5 },
|
|
{ ai_move, -8 },
|
|
{ ai_move, -15, jorg_step_left },
|
|
{ ai_move }, // 10
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, -11 },
|
|
{ ai_move, -25 },
|
|
{ ai_move, -10, jorg_step_right },
|
|
{ ai_move },
|
|
{ ai_move }, // 20
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, -21 },
|
|
{ ai_move, -10 },
|
|
{ ai_move, -16, jorg_step_left },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move }, // 30
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, 22 },
|
|
{ ai_move, 33, jorg_step_left },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, 28 },
|
|
{ ai_move, 28, jorg_step_right },
|
|
{ ai_move },
|
|
{ ai_move }, // 40
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move, -19 },
|
|
{ ai_move, 0, jorg_death_hit },
|
|
{ ai_move },
|
|
{ ai_move } // 50
|
|
};
|
|
MMOVE_T(jorg_move_death) = { FRAME_death01, FRAME_death50, jorg_frames_death1, jorg_dead };
|
|
|
|
mframe_t jorg_frames_attack2[] = {
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge, 0, jorgBFG },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move }
|
|
};
|
|
MMOVE_T(jorg_move_attack2) = { FRAME_attak201, FRAME_attak213, jorg_frames_attack2, jorg_run };
|
|
|
|
mframe_t jorg_frames_start_attack1[] = {
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge },
|
|
{ ai_charge }
|
|
};
|
|
MMOVE_T(jorg_move_start_attack1) = { FRAME_attak101, FRAME_attak108, jorg_frames_start_attack1, jorg_attack1 };
|
|
|
|
mframe_t jorg_frames_attack1[] = {
|
|
{ ai_charge, 0, jorg_firebullet },
|
|
{ ai_charge, 0, jorg_firebullet },
|
|
{ ai_charge, 0, jorg_firebullet },
|
|
{ ai_charge, 0, jorg_firebullet },
|
|
{ ai_charge, 0, jorg_firebullet },
|
|
{ ai_charge, 0, jorg_firebullet }
|
|
};
|
|
MMOVE_T(jorg_move_attack1) = { FRAME_attak109, FRAME_attak114, jorg_frames_attack1, jorg_reattack1 };
|
|
|
|
mframe_t jorg_frames_end_attack1[] = {
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move },
|
|
{ ai_move }
|
|
};
|
|
MMOVE_T(jorg_move_end_attack1) = { FRAME_attak115, FRAME_attak118, jorg_frames_end_attack1, jorg_run };
|
|
|
|
void jorg_reattack1(edict_t *self)
|
|
{
|
|
if (visible(self, self->enemy))
|
|
{
|
|
if (frandom() < 0.9f)
|
|
M_SetAnimation(self, &jorg_move_attack1);
|
|
else
|
|
{
|
|
M_SetAnimation(self, &jorg_move_end_attack1);
|
|
jorg_attack1_end_sound(self);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
M_SetAnimation(self, &jorg_move_end_attack1);
|
|
jorg_attack1_end_sound(self);
|
|
}
|
|
}
|
|
|
|
void jorg_attack1(edict_t *self)
|
|
{
|
|
M_SetAnimation(self, &jorg_move_attack1);
|
|
}
|
|
|
|
PAIN(jorg_pain) (edict_t *self, edict_t *other, float kick, int damage, const mod_t &mod) -> void
|
|
{
|
|
if (level.time < self->pain_debounce_time)
|
|
return;
|
|
|
|
// Lessen the chance of him going into his pain frames if he takes little damage
|
|
if (mod.id != MOD_CHAINFIST)
|
|
{
|
|
if (damage <= 40)
|
|
if (frandom() <= 0.6f)
|
|
return;
|
|
|
|
/*
|
|
If he's entering his attack1 or using attack1, lessen the chance of him
|
|
going into pain
|
|
*/
|
|
|
|
if ((self->s.frame >= FRAME_attak101) && (self->s.frame <= FRAME_attak108))
|
|
if (frandom() <= 0.005f)
|
|
return;
|
|
|
|
if ((self->s.frame >= FRAME_attak109) && (self->s.frame <= FRAME_attak114))
|
|
if (frandom() <= 0.00005f)
|
|
return;
|
|
|
|
if ((self->s.frame >= FRAME_attak201) && (self->s.frame <= FRAME_attak208))
|
|
if (frandom() <= 0.005f)
|
|
return;
|
|
}
|
|
|
|
self->pain_debounce_time = level.time + 3_sec;
|
|
|
|
bool do_pain3 = false;
|
|
|
|
if (damage > 50)
|
|
{
|
|
if (damage <= 100)
|
|
{
|
|
gi.sound(self, CHAN_VOICE, sound_pain2, 1, ATTN_NORM, 0);
|
|
}
|
|
else
|
|
{
|
|
if (frandom() <= 0.3f)
|
|
{
|
|
do_pain3 = true;
|
|
gi.sound(self, CHAN_VOICE, sound_pain3, 1, ATTN_NORM, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!M_ShouldReactToPain(self, mod))
|
|
return; // no pain anims in nightmare
|
|
|
|
jorg_attack1_end_sound(self);
|
|
|
|
if (damage <= 50)
|
|
M_SetAnimation(self, &jorg_move_pain1);
|
|
else if (damage <= 100)
|
|
M_SetAnimation(self, &jorg_move_pain2);
|
|
else if (do_pain3)
|
|
M_SetAnimation(self, &jorg_move_pain3);
|
|
}
|
|
|
|
MONSTERINFO_SETSKIN(jorg_setskin) (edict_t *self) -> void
|
|
{
|
|
if (self->health < (self->max_health / 2))
|
|
self->s.skinnum = 1;
|
|
else
|
|
self->s.skinnum = 0;
|
|
}
|
|
|
|
void jorgBFG(edict_t *self)
|
|
{
|
|
vec3_t forward, right;
|
|
vec3_t start;
|
|
vec3_t dir;
|
|
vec3_t vec;
|
|
|
|
AngleVectors(self->s.angles, forward, right, nullptr);
|
|
start = M_ProjectFlashSource(self, monster_flash_offset[MZ2_JORG_BFG_1], forward, right);
|
|
|
|
vec = self->enemy->s.origin;
|
|
vec[2] += self->enemy->viewheight;
|
|
dir = vec - start;
|
|
dir.normalize();
|
|
gi.sound(self, CHAN_WEAPON, sound_bfg_fire, 1, ATTN_NORM, 0);
|
|
monster_fire_bfg(self, start, dir, 50, 300, 100, 200, MZ2_JORG_BFG_1);
|
|
}
|
|
|
|
void jorg_firebullet_right(edict_t *self)
|
|
{
|
|
vec3_t forward, right, start;
|
|
AngleVectors(self->s.angles, forward, right, nullptr);
|
|
start = M_ProjectFlashSource(self, monster_flash_offset[MZ2_JORG_MACHINEGUN_R1], forward, right);
|
|
PredictAim(self, self->enemy, start, 0, false, -0.2f, &forward, nullptr);
|
|
monster_fire_bullet(self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MZ2_JORG_MACHINEGUN_R1);
|
|
}
|
|
|
|
void jorg_firebullet_left(edict_t *self)
|
|
{
|
|
vec3_t forward, right, start;
|
|
AngleVectors(self->s.angles, forward, right, nullptr);
|
|
start = M_ProjectFlashSource(self, monster_flash_offset[MZ2_JORG_MACHINEGUN_L1], forward, right);
|
|
PredictAim(self, self->enemy, start, 0, false, 0.2f, &forward, nullptr);
|
|
monster_fire_bullet(self, start, forward, 6, 4, DEFAULT_BULLET_HSPREAD, DEFAULT_BULLET_VSPREAD, MZ2_JORG_MACHINEGUN_L1);
|
|
}
|
|
|
|
void jorg_firebullet(edict_t *self)
|
|
{
|
|
jorg_firebullet_left(self);
|
|
jorg_firebullet_right(self);
|
|
};
|
|
|
|
MONSTERINFO_ATTACK(jorg_attack) (edict_t *self) -> void
|
|
{
|
|
if (frandom() <= 0.75f)
|
|
{
|
|
gi.sound(self, CHAN_WEAPON, sound_attack1, 1, ATTN_NORM, 0);
|
|
self->monsterinfo.weapon_sound = gi.soundindex("boss3/w_loop.wav");
|
|
M_SetAnimation(self, &jorg_move_start_attack1);
|
|
}
|
|
else
|
|
{
|
|
gi.sound(self, CHAN_VOICE, sound_attack2, 1, ATTN_NORM, 0);
|
|
M_SetAnimation(self, &jorg_move_attack2);
|
|
}
|
|
}
|
|
|
|
void jorg_dead(edict_t *self)
|
|
{
|
|
gi.WriteByte(svc_temp_entity);
|
|
gi.WriteByte(TE_EXPLOSION1_BIG);
|
|
gi.WritePosition(self->s.origin);
|
|
gi.multicast(self->s.origin, MULTICAST_PHS, false);
|
|
|
|
self->s.sound = 0;
|
|
self->s.skinnum /= 2;
|
|
|
|
ThrowGibs(self, 500, {
|
|
{ 2, "models/objects/gibs/sm_meat/tris.md2" },
|
|
{ 2, "models/objects/gibs/sm_metal/tris.md2", GIB_METALLIC },
|
|
{ "models/monsters/boss3/jorg/gibs/chest.md2", GIB_SKINNED },
|
|
{ 2, "models/monsters/boss3/jorg/gibs/foot.md2", GIB_SKINNED },
|
|
{ 2, "models/monsters/boss3/jorg/gibs/gun.md2", GIB_SKINNED | GIB_UPRIGHT },
|
|
{ 2, "models/monsters/boss3/jorg/gibs/thigh.md2", GIB_SKINNED | GIB_UPRIGHT },
|
|
{ "models/monsters/boss3/jorg/gibs/spine.md2", GIB_SKINNED | GIB_UPRIGHT },
|
|
{ 4, "models/monsters/boss3/jorg/gibs/tube.md2", GIB_SKINNED },
|
|
{ 6, "models/monsters/boss3/jorg/gibs/spike.md2", GIB_SKINNED },
|
|
{ "models/monsters/boss3/jorg/gibs/head.md2", GIB_SKINNED | GIB_METALLIC | GIB_HEAD }
|
|
});
|
|
|
|
MakronToss(self);
|
|
}
|
|
|
|
DIE(jorg_die) (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, const vec3_t &point, const mod_t &mod) -> void
|
|
{
|
|
gi.sound(self, CHAN_VOICE, sound_death, 1, ATTN_NORM, 0);
|
|
jorg_attack1_end_sound(self);
|
|
self->deadflag = true;
|
|
self->takedamage = false;
|
|
self->count = 0;
|
|
M_SetAnimation(self, &jorg_move_death);
|
|
}
|
|
|
|
MONSTERINFO_CHECKATTACK(Jorg_CheckAttack) (edict_t *self) -> bool
|
|
{
|
|
vec3_t spot1, spot2;
|
|
vec3_t temp;
|
|
float chance;
|
|
trace_t tr;
|
|
float enemy_yaw;
|
|
|
|
if (self->enemy->health > 0)
|
|
{
|
|
// see if any entities are in the way of the shot
|
|
spot1 = self->s.origin;
|
|
spot1[2] += self->viewheight;
|
|
spot2 = self->enemy->s.origin;
|
|
spot2[2] += self->enemy->viewheight;
|
|
|
|
tr = gi.traceline(spot1, spot2, self, CONTENTS_SOLID | CONTENTS_MONSTER | CONTENTS_PLAYER | CONTENTS_SLIME | CONTENTS_LAVA);
|
|
|
|
// do we have a clear shot?
|
|
if (tr.ent != self->enemy && !(tr.ent->svflags & SVF_PLAYER))
|
|
return false;
|
|
}
|
|
|
|
float enemy_range = range_to(self, self->enemy);
|
|
temp = self->enemy->s.origin - self->s.origin;
|
|
enemy_yaw = vectoyaw(temp);
|
|
|
|
self->ideal_yaw = enemy_yaw;
|
|
|
|
// melee attack
|
|
if (enemy_range <= RANGE_MELEE)
|
|
{
|
|
if (self->monsterinfo.melee)
|
|
self->monsterinfo.attack_state = AS_MELEE;
|
|
else
|
|
self->monsterinfo.attack_state = AS_MISSILE;
|
|
return true;
|
|
}
|
|
|
|
// missile attack
|
|
if (!self->monsterinfo.attack)
|
|
return false;
|
|
|
|
if (level.time < self->monsterinfo.attack_finished)
|
|
return false;
|
|
|
|
if (enemy_range > RANGE_MID)
|
|
return false;
|
|
|
|
if (self->monsterinfo.aiflags & AI_STAND_GROUND)
|
|
{
|
|
chance = 0.4f;
|
|
}
|
|
else if (enemy_range <= RANGE_MELEE)
|
|
{
|
|
chance = 0.8f;
|
|
}
|
|
else if (enemy_range <= RANGE_NEAR)
|
|
{
|
|
chance = 0.4f;
|
|
}
|
|
else
|
|
{
|
|
chance = 0.2f;
|
|
}
|
|
|
|
if (frandom() < chance)
|
|
{
|
|
self->monsterinfo.attack_state = AS_MISSILE;
|
|
self->monsterinfo.attack_finished = level.time + random_time(2_sec);
|
|
return true;
|
|
}
|
|
|
|
if (self->flags & FL_FLY)
|
|
{
|
|
if (frandom() < 0.3f)
|
|
self->monsterinfo.attack_state = AS_SLIDING;
|
|
else
|
|
self->monsterinfo.attack_state = AS_STRAIGHT;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void MakronPrecache();
|
|
|
|
/*QUAKED monster_jorg (1 .5 0) (-80 -80 0) (90 90 140) Ambush Trigger_Spawn Sight
|
|
*/
|
|
void SP_monster_jorg(edict_t *self)
|
|
{
|
|
if ( !M_AllowSpawn( self ) ) {
|
|
G_FreeEdict( self );
|
|
return;
|
|
}
|
|
|
|
sound_pain1 = gi.soundindex("boss3/bs3pain1.wav");
|
|
sound_pain2 = gi.soundindex("boss3/bs3pain2.wav");
|
|
sound_pain3 = gi.soundindex("boss3/bs3pain3.wav");
|
|
sound_death = gi.soundindex("boss3/bs3deth1.wav");
|
|
sound_attack1 = gi.soundindex("boss3/bs3atck1.wav");
|
|
sound_attack1_loop = gi.soundindex("boss3/bs3atck1_loop.wav");
|
|
sound_attack1_end = gi.soundindex("boss3/bs3atck1_end.wav");
|
|
sound_attack2 = gi.soundindex("boss3/bs3atck2.wav");
|
|
sound_search1 = gi.soundindex("boss3/bs3srch1.wav");
|
|
sound_search2 = gi.soundindex("boss3/bs3srch2.wav");
|
|
sound_search3 = gi.soundindex("boss3/bs3srch3.wav");
|
|
sound_idle = gi.soundindex("boss3/bs3idle1.wav");
|
|
sound_step_left = gi.soundindex("boss3/step1.wav");
|
|
sound_step_right = gi.soundindex("boss3/step2.wav");
|
|
sound_firegun = gi.soundindex("boss3/xfire.wav");
|
|
sound_death_hit = gi.soundindex("boss3/d_hit.wav");
|
|
sound_bfg_fire = gi.soundindex("makron/bfg_fire.wav");
|
|
|
|
MakronPrecache();
|
|
|
|
self->movetype = MOVETYPE_STEP;
|
|
self->solid = SOLID_BBOX;
|
|
self->s.modelindex = gi.modelindex("models/monsters/boss3/jorg/tris.md2");
|
|
self->s.modelindex2 = gi.modelindex("models/monsters/boss3/rider/tris.md2");
|
|
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/chest.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/foot.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/gun.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/head.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/spike.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/spine.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/thigh.md2");
|
|
gi.modelindex("models/monsters/boss3/jorg/gibs/tube.md2");
|
|
|
|
self->mins = { -80, -80, 0 };
|
|
self->maxs = { 80, 80, 140 };
|
|
|
|
self->health = 8000 * st.health_multiplier;
|
|
self->gib_health = -2000;
|
|
self->mass = 1000;
|
|
|
|
self->pain = jorg_pain;
|
|
self->die = jorg_die;
|
|
self->monsterinfo.stand = jorg_stand;
|
|
self->monsterinfo.walk = jorg_walk;
|
|
self->monsterinfo.run = jorg_run;
|
|
self->monsterinfo.dodge = nullptr;
|
|
self->monsterinfo.attack = jorg_attack;
|
|
self->monsterinfo.search = jorg_search;
|
|
self->monsterinfo.melee = nullptr;
|
|
self->monsterinfo.sight = nullptr;
|
|
self->monsterinfo.checkattack = Jorg_CheckAttack;
|
|
self->monsterinfo.setskin = jorg_setskin;
|
|
gi.linkentity(self);
|
|
|
|
M_SetAnimation(self, &jorg_move_stand);
|
|
self->monsterinfo.scale = MODEL_SCALE;
|
|
|
|
walkmonster_start(self);
|
|
// PMM
|
|
self->monsterinfo.aiflags |= AI_IGNORE_SHOTS;
|
|
// pmm
|
|
self->monsterinfo.aiflags |= AI_DOUBLE_TROUBLE;
|
|
}
|