// Copyright (c) ZeniMax Media Inc.
// Licensed under the GNU General Public License 2.0.
/*
	xatrix
	gekk.c
*/

#include "../g_local.h"
#include "m_xatrix_gekk.h"

constexpr spawnflags_t SPAWNFLAG_GEKK_CHANT = 8_spawnflag;
constexpr spawnflags_t SPAWNFLAG_GEKK_NOJUMPING = 16_spawnflag;
constexpr spawnflags_t SPAWNFLAG_GEKK_NOSWIM = 32_spawnflag;

static int sound_swing;
static int sound_hit;
static int sound_hit2;
static int sound_speet;
static int loogie_hit;
static int sound_death;
static int sound_pain1;
static int sound_sight;
static int sound_search;
static int sound_step1;
static int sound_step2;
static int sound_step3;
static int sound_thud;
static int sound_chantlow;
static int sound_chantmid;
static int sound_chanthigh;

void gekk_swim(edict_t *self);

void gekk_jump_takeoff(edict_t *self);
void gekk_jump_takeoff2(edict_t *self);
void gekk_check_landing(edict_t *self);
void gekk_stop_skid(edict_t *self);

void water_to_land(edict_t *self);
void land_to_water(edict_t *self);

void gekk_check_underwater(edict_t *self);
void gekk_bite(edict_t *self);

void gekk_hit_left(edict_t *self);
void gekk_hit_right(edict_t *self);

extern const mmove_t gekk_move_attack1;
extern const mmove_t gekk_move_attack2;
extern const mmove_t gekk_move_chant;
extern const mmove_t gekk_move_swim_start;
extern const mmove_t gekk_move_swim_loop;
extern const mmove_t gekk_move_spit;
extern const mmove_t gekk_move_run_start;
extern const mmove_t gekk_move_run;

bool gekk_check_jump(edict_t *self);

//
// CHECKATTACK
//

bool gekk_check_melee(edict_t *self)
{
	if (!self->enemy || self->enemy->health <= 0 || self->monsterinfo.melee_debounce_time > level.time)
		return false;

	return range_to(self, self->enemy) <= RANGE_MELEE;
}

bool gekk_check_jump(edict_t *self)
{
	vec3_t v;
	float  distance;

	// don't jump if there's no way we can reach standing height
	if (self->absmin[2] + 125 < self->enemy->absmin[2])
		return false;

	v[0] = self->s.origin[0] - self->enemy->s.origin[0];
	v[1] = self->s.origin[1] - self->enemy->s.origin[1];
	v[2] = 0;
	distance = v.length();

	if (distance < 100)
	{
		return false;
	}
	if (distance > 100)
	{
		if (frandom() < (self->waterlevel >= WATER_WAIST ? 0.2f : 0.9f))
			return false;
	}

	return true;
}

bool gekk_check_jump_close(edict_t *self)
{
	vec3_t v;
	float  distance;

	v[0] = self->s.origin[0] - self->enemy->s.origin[0];
	v[1] = self->s.origin[1] - self->enemy->s.origin[1];
	v[2] = 0;

	distance = v.length();

	if (distance < 100)
	{
		// don't do this if our head is below their feet
		if (self->absmax[2] <= self->enemy->absmin[2])
			return false;
	}

	return true;
}

MONSTERINFO_CHECKATTACK(gekk_checkattack) (edict_t *self) -> bool
{
	if (!self->enemy || self->enemy->health <= 0)
		return false;

	if (gekk_check_melee(self))
	{
		self->monsterinfo.attack_state = AS_MELEE;
		return true;
	}

	if (self->monsterinfo.attack_state == AS_STRAIGHT && self->monsterinfo.attack_finished > level.time)
	{
		// keep running fool
		return false;
	}

	if (visible(self, self->enemy, false))
	{
		if (gekk_check_jump(self))
		{
			self->monsterinfo.attack_state = AS_MISSILE;
			return true;
		}

		if (gekk_check_jump_close(self) && !(self->flags & FL_SWIM))
		{
			self->monsterinfo.attack_state = AS_MISSILE;
			return true;
		}
	}

	return false;
}

//
// SOUNDS
//

void gekk_step(edict_t *self)
{
	int n = irandom(3);
	if (n == 0)
		gi.sound(self, CHAN_VOICE, sound_step1, 1, ATTN_NORM, 0);
	else if (n == 1)
		gi.sound(self, CHAN_VOICE, sound_step2, 1, ATTN_NORM, 0);
	else
		gi.sound(self, CHAN_VOICE, sound_step3, 1, ATTN_NORM, 0);
}

MONSTERINFO_SIGHT(gekk_sight) (edict_t *self, edict_t *other) -> void
{
	gi.sound(self, CHAN_VOICE, sound_sight, 1, ATTN_NORM, 0);
}

MONSTERINFO_SEARCH(gekk_search) (edict_t *self) -> void
{
	float r;

	if (self->spawnflags.has(SPAWNFLAG_GEKK_CHANT))
	{
		r = frandom();
		if (r < 0.33f)
			gi.sound(self, CHAN_VOICE, sound_chantlow, 1, ATTN_NORM, 0);
		else if (r < 0.66f)
			gi.sound(self, CHAN_VOICE, sound_chantmid, 1, ATTN_NORM, 0);
		else
			gi.sound(self, CHAN_VOICE, sound_chanthigh, 1, ATTN_NORM, 0);
	}
	else
		gi.sound(self, CHAN_VOICE, sound_search, 1, ATTN_NORM, 0);

	self->health += irandom(10, 20);
	if (self->health > self->max_health)
		self->health = self->max_health;

	self->monsterinfo.setskin(self);
}

MONSTERINFO_SETSKIN(gekk_setskin) (edict_t *self) -> void
{
	if (self->health < (self->max_health / 4))
		self->s.skinnum = 2;
	else if (self->health < (self->max_health / 2))
		self->s.skinnum = 1;
	else
		self->s.skinnum = 0;
}

void gekk_swing(edict_t *self)
{
	gi.sound(self, CHAN_VOICE, sound_swing, 1, ATTN_NORM, 0);
}

void gekk_face(edict_t *self)
{
	M_SetAnimation(self, &gekk_move_run);
}

//
// STAND
//

void ai_stand_gekk(edict_t *self, float dist)
{
	if (self->spawnflags.has(SPAWNFLAG_GEKK_CHANT))
	{
		ai_move(self, dist);
		if (!self->spawnflags.has(SPAWNFLAG_MONSTER_AMBUSH) && (self->monsterinfo.idle) && (level.time > self->monsterinfo.idle_time))
		{
			if (self->monsterinfo.idle_time)
			{
				self->monsterinfo.idle(self);
				self->monsterinfo.idle_time = level.time + random_time(15_sec, 30_sec);
			}
			else
			{
				self->monsterinfo.idle_time = level.time + random_time(15_sec);
			}
		}
	}
	else
		ai_stand(self, dist);
}

mframe_t gekk_frames_stand[] = {
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk }, // 10

	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk }, // 20

	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk }, // 30

	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },

	{ ai_stand_gekk, 0, gekk_check_underwater },
};
MMOVE_T(gekk_move_stand) = { FRAME_stand_01, FRAME_stand_39, gekk_frames_stand, nullptr };

mframe_t gekk_frames_standunderwater[] = {
	{ ai_stand_gekk, 14 },
	{ ai_stand_gekk, 14 },
	{ ai_stand_gekk, 14 },
	{ ai_stand_gekk, 14 },
	{ ai_stand_gekk, 16 },
	{ ai_stand_gekk, 16 },
	{ ai_stand_gekk, 16 },
	{ ai_stand_gekk, 18 },
	{ ai_stand_gekk, 18 },
	{ ai_stand_gekk, 18 },

	{ ai_stand_gekk, 20 },
	{ ai_stand_gekk, 20 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 24 },
	{ ai_stand_gekk, 24 },
	{ ai_stand_gekk, 26 },
	{ ai_stand_gekk, 26 },
	{ ai_stand_gekk, 24 },
	{ ai_stand_gekk, 24 },

	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 22 },
	{ ai_stand_gekk, 18 },
	{ ai_stand_gekk, 18 },

	{ ai_stand_gekk, 18 },
	{ ai_stand_gekk, 18 }
};

MMOVE_T(gekk_move_standunderwater) = { FRAME_swim_01, FRAME_swim_32, gekk_frames_standunderwater, nullptr };

void gekk_swim_loop(edict_t *self)
{
	self->monsterinfo.aiflags |= AI_ALTERNATE_FLY;
	self->flags |= FL_SWIM;
	M_SetAnimation(self, &gekk_move_swim_loop);
}

mframe_t gekk_frames_swim[] = {
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 16 },
	{ ai_run, 16 },
	{ ai_run, 16 },
	{ ai_run, 18 },
	{ ai_run, 18 },
	{ ai_run, 18 },

	{ ai_run, 20 },
	{ ai_run, 20 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 24 },
	{ ai_run, 24 },
	{ ai_run, 26 },
	{ ai_run, 26 },
	{ ai_run, 24 },
	{ ai_run, 24 },

	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 18 },
	{ ai_run, 18 },

	{ ai_run, 18 },
	{ ai_run, 18 }
};
MMOVE_T(gekk_move_swim_loop) = { FRAME_swim_01, FRAME_swim_32, gekk_frames_swim, gekk_swim_loop };

mframe_t gekk_frames_swim_start[] = {
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 14 },
	{ ai_run, 16 },
	{ ai_run, 16 },
	{ ai_run, 16 },
	{ ai_run, 18 },
	{ ai_run, 18, gekk_hit_left },
	{ ai_run, 18 },

	{ ai_run, 20 },
	{ ai_run, 20 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 24, gekk_hit_right },
	{ ai_run, 24 },
	{ ai_run, 26 },
	{ ai_run, 26 },
	{ ai_run, 24 },
	{ ai_run, 24 },

	{ ai_run, 22, gekk_bite },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 22 },
	{ ai_run, 18 },
	{ ai_run, 18 },

	{ ai_run, 18 },
	{ ai_run, 18 }
};
MMOVE_T(gekk_move_swim_start) = { FRAME_swim_01, FRAME_swim_32, gekk_frames_swim_start, gekk_swim_loop };

void gekk_swim(edict_t *self)
{
	if (gekk_checkattack(self))
	{
		if (self->enemy->waterlevel < WATER_WAIST && frandom() > 0.7f)
			water_to_land(self);
		else
			M_SetAnimation(self, &gekk_move_swim_start);
	}
	else
		M_SetAnimation(self, &gekk_move_swim_start);
}

MONSTERINFO_STAND(gekk_stand) (edict_t *self) -> void
{
	if (self->waterlevel >= WATER_WAIST)
	{
		self->flags |= FL_SWIM;
		self->monsterinfo.aiflags |= AI_ALTERNATE_FLY;
		M_SetAnimation(self, &gekk_move_standunderwater);
	}
	else
		// Don't break out of the chant loop, which is initiated in the spawn function
		if (self->monsterinfo.active_move != &gekk_move_chant)
			M_SetAnimation(self, &gekk_move_stand);
}

void gekk_chant(edict_t *self)
{
	M_SetAnimation(self, &gekk_move_chant);
}

//
// IDLE
//

void gekk_idle_loop(edict_t *self)
{
	if (frandom() > 0.75f && self->health < self->max_health)
		self->monsterinfo.nextframe = FRAME_idle_01;
}

mframe_t gekk_frames_idle[] = {
	{ ai_stand_gekk, 0, gekk_search },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },

	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },

	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },
	{ ai_stand_gekk },

	{ ai_stand_gekk },
	{ ai_stand_gekk, 0, gekk_idle_loop }
};
MMOVE_T(gekk_move_idle) = { FRAME_idle_01, FRAME_idle_32, gekk_frames_idle, gekk_stand };
MMOVE_T(gekk_move_idle2) = { FRAME_idle_01, FRAME_idle_32, gekk_frames_idle, gekk_face };

mframe_t gekk_frames_idle2[] = {
	{ ai_move, 0, gekk_search },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },

	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },

	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },

	{ ai_move },
	{ ai_move, 0, gekk_idle_loop }
};
MMOVE_T(gekk_move_chant) = { FRAME_idle_01, FRAME_idle_32, gekk_frames_idle2, gekk_chant };

MONSTERINFO_IDLE(gekk_idle) (edict_t *self) -> void
{
	if (self->spawnflags.has(SPAWNFLAG_GEKK_NOSWIM) || self->waterlevel < WATER_WAIST)
		M_SetAnimation(self, &gekk_move_idle);
	else
		M_SetAnimation(self, &gekk_move_swim_start);
	// gi.sound (self, CHAN_VOICE, sound_idle, 1, ATTN_IDLE, 0);
}

//
// WALK
//

mframe_t gekk_frames_walk[] = {
	{ ai_walk, 3.849f, gekk_check_underwater }, // frame 0
	{ ai_walk, 19.606f },						// frame 1
	{ ai_walk, 25.583f },						// frame 2
	{ ai_walk, 34.625f, gekk_step },			// frame 3
	{ ai_walk, 27.365f },						// frame 4
	{ ai_walk, 28.480f },						// frame 5
};

MMOVE_T(gekk_move_walk) = { FRAME_run_01, FRAME_run_06, gekk_frames_walk, nullptr };

MONSTERINFO_WALK(gekk_walk) (edict_t *self) -> void
{
	M_SetAnimation(self, &gekk_move_walk);
}

//
// RUN
//

MONSTERINFO_RUN(gekk_run_start) (edict_t *self) -> void
{
	if (!self->spawnflags.has(SPAWNFLAG_GEKK_NOSWIM) && self->waterlevel >= WATER_WAIST)
	{
		M_SetAnimation(self, &gekk_move_swim_start);
	}
	else
	{
		M_SetAnimation(self, &gekk_move_run_start);
	}
}

void gekk_run(edict_t *self)
{

	if (!self->spawnflags.has(SPAWNFLAG_GEKK_NOSWIM) && self->waterlevel >= WATER_WAIST)
	{
		M_SetAnimation(self, &gekk_move_swim_start);
		return;
	}
	else
	{
		if (self->monsterinfo.aiflags & AI_STAND_GROUND)
			M_SetAnimation(self, &gekk_move_stand);
		else
			M_SetAnimation(self, &gekk_move_run);
	}
}

mframe_t gekk_frames_run[] = {
	{ ai_run, 3.849f, gekk_check_underwater }, // frame 0
	{ ai_run, 19.606f },					   // frame 1
	{ ai_run, 25.583f },					   // frame 2
	{ ai_run, 34.625f, gekk_step },			   // frame 3
	{ ai_run, 27.365f },					   // frame 4
	{ ai_run, 28.480f },					   // frame 5
};
MMOVE_T(gekk_move_run) = { FRAME_run_01, FRAME_run_06, gekk_frames_run, nullptr };

mframe_t gekk_frames_run_st[] = {
	{ ai_run, 0.212f },	 // frame 0
	{ ai_run, 19.753f }, // frame 1
};
MMOVE_T(gekk_move_run_start) = { FRAME_stand_01, FRAME_stand_02, gekk_frames_run_st, gekk_run };

//
// MELEE
//

void gekk_hit_left(edict_t *self)
{
	if (!self->enemy)
		return;

	vec3_t aim = { MELEE_DISTANCE, self->mins[0], 8 };
	if (fire_hit(self, aim, irandom(5, 10), 100))
		gi.sound(self, CHAN_WEAPON, sound_hit, 1, ATTN_NORM, 0);
	else
	{
		gi.sound(self, CHAN_WEAPON, sound_swing, 1, ATTN_NORM, 0);
		self->monsterinfo.melee_debounce_time = level.time + 1.5_sec;
	}
}

void gekk_hit_right(edict_t *self)
{
	if (!self->enemy)
		return;

	vec3_t aim = { MELEE_DISTANCE, self->maxs[0], 8 };
	if (fire_hit(self, aim, irandom(5, 10), 100))
		gi.sound(self, CHAN_WEAPON, sound_hit2, 1, ATTN_NORM, 0);
	else
	{
		gi.sound(self, CHAN_WEAPON, sound_swing, 1, ATTN_NORM, 0);
		self->monsterinfo.melee_debounce_time = level.time + 1.5_sec;
	}
}

void gekk_check_refire(edict_t *self)
{
	if (!self->enemy || !self->enemy->inuse || self->enemy->health <= 0)
		return;

	if (range_to(self, self->enemy) <= RANGE_MELEE &&
		self->monsterinfo.melee_debounce_time <= level.time)
	{
		if (self->s.frame == FRAME_clawatk3_09)
			M_SetAnimation(self, &gekk_move_attack2);
		else if (self->s.frame == FRAME_clawatk5_09)
			M_SetAnimation(self, &gekk_move_attack1);
	}
}

TOUCH(loogie_touch) (edict_t *self, edict_t *other, const trace_t &tr, bool other_touching_self) -> void
{

	if (other == self->owner)
		return;

	if (tr.surface && (tr.surface->flags & SURF_SKY))
	{
		G_FreeEdict(self);
		return;
	}

	if (self->owner->client)
		PlayerNoise(self->owner, self->s.origin, PNOISE_IMPACT);

	if (other->takedamage)
		T_Damage(other, self, self->owner, self->velocity, self->s.origin, tr.plane.normal, self->dmg, 1, DAMAGE_ENERGY, MOD_GEKK);
	
	gi.sound(self, CHAN_AUTO, loogie_hit, 1.0f, ATTN_NORM, 0);

	G_FreeEdict(self);
};

void fire_loogie(edict_t *self, const vec3_t &start, const vec3_t &dir, int damage, int speed)
{
	edict_t *loogie;
	trace_t	 tr;

	loogie = G_Spawn();
	loogie->s.origin = start;
	loogie->s.old_origin = start;
	loogie->s.angles = vectoangles(dir);
	loogie->velocity = dir * speed;
	loogie->movetype = MOVETYPE_FLYMISSILE;
	loogie->clipmask = MASK_PROJECTILE;
	loogie->solid = SOLID_BBOX;
	// Paril: this was originally the wrong effect,
	// but it makes it look more acid-y.
	loogie->s.effects |= EF_BLASTER;
	loogie->s.renderfx |= RF_FULLBRIGHT;
	loogie->s.modelindex = gi.modelindex("models/objects/loogy/tris.md2");
	loogie->owner = self;
	loogie->touch = loogie_touch;
	loogie->nextthink = level.time + 2_sec;
	loogie->think = G_FreeEdict;
	loogie->dmg = damage;
	loogie->svflags |= SVF_PROJECTILE;
	gi.linkentity(loogie);

	tr = gi.traceline(self->s.origin, loogie->s.origin, loogie, MASK_PROJECTILE);
	if (tr.fraction < 1.0f)
	{
		loogie->s.origin = tr.endpos + (tr.plane.normal * 1.f);
		loogie->touch(loogie, tr.ent, tr, false);
	}
}

void loogie(edict_t *self)
{
	vec3_t start;
	vec3_t forward, right, up;
	vec3_t end;
	vec3_t dir;
	vec3_t gekkoffset = { -18, -0.8f, 24 };

	if (!self->enemy || self->enemy->health <= 0)
		return;

	AngleVectors(self->s.angles, forward, right, up);
	start = M_ProjectFlashSource(self, gekkoffset, forward, right);

	start += (up * 2);

	end = self->enemy->s.origin;
	end[2] += self->enemy->viewheight;
	dir = end - start;
	dir.normalize();

	fire_loogie(self, start, dir, 5, 550);

	gi.sound(self, CHAN_BODY, sound_speet, 1.0f, ATTN_NORM, 0);
}

void reloogie(edict_t *self)
{
	if (frandom() > 0.8f && self->health < self->max_health)
	{
		M_SetAnimation(self, &gekk_move_idle2);
		return;
	}

	if (self->enemy->health >= 0)
		if (frandom() > 0.7f && (range_to(self, self->enemy) <= RANGE_NEAR))
			M_SetAnimation(self, &gekk_move_spit);
}

mframe_t gekk_frames_spit[] = {
	{ ai_charge },
	{ ai_charge },
	{ ai_charge },
	{ ai_charge },
	{ ai_charge },

	{ ai_charge, 0, loogie },
	{ ai_charge, 0, reloogie }
};
MMOVE_T(gekk_move_spit) = { FRAME_spit_01, FRAME_spit_07, gekk_frames_spit, gekk_run_start };

mframe_t gekk_frames_attack1[] = {
	{ ai_charge },
	{ ai_charge },
	{ ai_charge },

	{ ai_charge, 0, gekk_hit_left },
	{ ai_charge },
	{ ai_charge },

	{ ai_charge },
	{ ai_charge },
	{ ai_charge, 0, gekk_check_refire }
};
MMOVE_T(gekk_move_attack1) = { FRAME_clawatk3_01, FRAME_clawatk3_09, gekk_frames_attack1, gekk_run_start };

mframe_t gekk_frames_attack2[] = {
	{ ai_charge },
	{ ai_charge },
	{ ai_charge, 0, gekk_hit_left },

	{ ai_charge },
	{ ai_charge },
	{ ai_charge, 0, gekk_hit_right },

	{ ai_charge },
	{ ai_charge },
	{ ai_charge, 0, gekk_check_refire }
};
MMOVE_T(gekk_move_attack2) = { FRAME_clawatk5_01, FRAME_clawatk5_09, gekk_frames_attack2, gekk_run_start };

void gekk_check_underwater(edict_t *self)
{
	if (!self->spawnflags.has(SPAWNFLAG_GEKK_NOSWIM) && self->waterlevel >= WATER_WAIST)
		land_to_water(self);
}

mframe_t gekk_frames_leapatk[] = {
	{ ai_charge },								// frame 0
	{ ai_charge, -0.387f },						// frame 1
	{ ai_charge, -1.113f },						// frame 2
	{ ai_charge, -0.237f },						// frame 3
	{ ai_charge, 6.720f, gekk_jump_takeoff },	// frame 4  last frame on ground
	{ ai_charge, 6.414f },						// frame 5  leaves ground
	{ ai_charge, 0.163f },						// frame 6
	{ ai_charge, 28.316f },						// frame 7
	{ ai_charge, 24.198f },						// frame 8
	{ ai_charge, 31.742f },						// frame 9
	{ ai_charge, 35.977f, gekk_check_landing }, // frame 10  last frame in air
	{ ai_charge, 12.303f, gekk_stop_skid },		// frame 11  feet back on ground
	{ ai_charge, 20.122f, gekk_stop_skid },		// frame 12
	{ ai_charge, -1.042f, gekk_stop_skid },		// frame 13
	{ ai_charge, 2.556f, gekk_stop_skid },		// frame 14
	{ ai_charge, 0.544f, gekk_stop_skid },		// frame 15
	{ ai_charge, 1.862f, gekk_stop_skid },		// frame 16
	{ ai_charge, 1.224f, gekk_stop_skid },		// frame 17

	{ ai_charge, -0.457f, gekk_check_underwater }, // frame 18
};
MMOVE_T(gekk_move_leapatk) = { FRAME_leapatk_01, FRAME_leapatk_19, gekk_frames_leapatk, gekk_run_start };

mframe_t gekk_frames_leapatk2[] = {
	{ ai_charge },								// frame 0
	{ ai_charge, -0.387f },						// frame 1
	{ ai_charge, -1.113f },						// frame 2
	{ ai_charge, -0.237f },						// frame 3
	{ ai_charge, 6.720f, gekk_jump_takeoff2 },	// frame 4  last frame on ground
	{ ai_charge, 6.414f },						// frame 5  leaves ground
	{ ai_charge, 0.163f },						// frame 6
	{ ai_charge, 28.316f },						// frame 7
	{ ai_charge, 24.198f },						// frame 8
	{ ai_charge, 31.742f },						// frame 9
	{ ai_charge, 35.977f, gekk_check_landing }, // frame 10  last frame in air
	{ ai_charge, 12.303f, gekk_stop_skid },		// frame 11  feet back on ground
	{ ai_charge, 20.122f, gekk_stop_skid },		// frame 12
	{ ai_charge, -1.042f, gekk_stop_skid },		// frame 13
	{ ai_charge, 2.556f, gekk_stop_skid },		// frame 14
	{ ai_charge, 0.544f, gekk_stop_skid },		// frame 15
	{ ai_charge, 1.862f, gekk_stop_skid },		// frame 16
	{ ai_charge, 1.224f, gekk_stop_skid },		// frame 17

	{ ai_charge, -0.457f, gekk_check_underwater }, // frame 18
};
MMOVE_T(gekk_move_leapatk2) = { FRAME_leapatk_01, FRAME_leapatk_19, gekk_frames_leapatk2, gekk_run_start };

void gekk_bite(edict_t *self)
{
	if (!self->enemy)
		return;

	vec3_t aim = { MELEE_DISTANCE, 0, 0 };
	fire_hit(self, aim, 5, 0);
}

void gekk_preattack(edict_t *self)
{
	// underwater attack sound
	// gi.sound (self, CHAN_WEAPON, something something underwater sound, 1, ATTN_NORM, 0);
	return;
}

mframe_t gekk_frames_attack[] = {
	{ ai_charge, 16, gekk_preattack },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16, gekk_bite },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16, gekk_bite },

	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16, gekk_hit_left },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16 },
	{ ai_charge, 16, gekk_hit_right },
	{ ai_charge, 16 },

	{ ai_charge, 16 }
};
MMOVE_T(gekk_move_attack) = { FRAME_attack_01, FRAME_attack_21, gekk_frames_attack, gekk_run_start };

MONSTERINFO_MELEE(gekk_melee) (edict_t *self) -> void
{
	if (self->waterlevel >= WATER_WAIST)
	{
		M_SetAnimation(self, &gekk_move_attack);
	}
	else
	{
		float r = frandom();

		if (r > 0.66f)
			M_SetAnimation(self, &gekk_move_attack1);
		else
			M_SetAnimation(self, &gekk_move_attack2);
	}
}

//
// ATTACK
//

TOUCH(gekk_jump_touch) (edict_t *self, edict_t *other, const trace_t &tr, bool other_touching_self) -> void
{
	if (self->health <= 0)
	{
		self->touch = nullptr;
		return;
	}

	if (self->style == 1 && other->takedamage)
	{
		if (self->velocity.length() > 200)
		{
			vec3_t point;
			vec3_t normal;
			int	   damage;

			normal = self->velocity;
			normal.normalize();
			point = self->s.origin + (normal * self->maxs[0]);
			damage = irandom(10, 20);
			T_Damage(other, self, self, self->velocity, point, normal, damage, damage, DAMAGE_NONE, MOD_GEKK);
			self->style = 0;
		}
	}

	if (!M_CheckBottom(self))
	{
		if (self->groundentity)
		{
			self->monsterinfo.nextframe = FRAME_leapatk_11;
			self->touch = nullptr;
		}
		return;
	}

	self->touch = nullptr;
}

void gekk_jump_takeoff(edict_t *self)
{
	vec3_t forward;

	gi.sound(self, CHAN_VOICE, sound_sight, 1, ATTN_NORM, 0);
	AngleVectors(self->s.angles, forward, nullptr, nullptr);
	self->s.origin[2] += 1;

	// high jump
	if (gekk_check_jump(self))
	{
		self->velocity = forward * 700;
		self->velocity[2] = 250;
	}
	else
	{
		self->velocity = forward * 250;
		self->velocity[2] = 400;
	}

	self->groundentity = nullptr;
	self->monsterinfo.aiflags |= AI_DUCKED;
	self->monsterinfo.attack_finished = level.time + 3_sec;
	self->touch = gekk_jump_touch;
	self->style = 1;
}

void gekk_jump_takeoff2(edict_t *self)
{
	vec3_t forward;

	gi.sound(self, CHAN_VOICE, sound_sight, 1, ATTN_NORM, 0);
	AngleVectors(self->s.angles, forward, nullptr, nullptr);
	self->s.origin[2] = self->enemy->s.origin[2];

	if (gekk_check_jump(self))
	{
		self->velocity = forward * 300;
		self->velocity[2] = 250;
	}
	else
	{
		self->velocity = forward * 150;
		self->velocity[2] = 300;
	}

	self->groundentity = nullptr;
	self->monsterinfo.aiflags |= AI_DUCKED;
	self->monsterinfo.attack_finished = level.time + 3_sec;
	self->touch = gekk_jump_touch;
	self->style = 1;
}

void gekk_stop_skid(edict_t *self)
{
	if (self->groundentity)
		self->velocity = {};
}

void gekk_check_landing(edict_t *self)
{
	if (self->groundentity)
	{
		gi.sound(self, CHAN_WEAPON, sound_thud, 1, ATTN_NORM, 0);
		self->monsterinfo.attack_finished = 0_ms;

		if (self->monsterinfo.unduck)
			self->monsterinfo.unduck(self);

		self->velocity = {};
		return;
	}

	// Paril: allow them to "pull" up ledges
	vec3_t fwd;
	AngleVectors(self->s.angles, fwd, nullptr, nullptr);

	if (fwd.dot(self->velocity) < 200)
		self->velocity += (fwd * 200.f);

	// note to self
	// causing skid
	if (level.time > self->monsterinfo.attack_finished)
		self->monsterinfo.nextframe = FRAME_leapatk_11;
	else
	{
		self->monsterinfo.nextframe = FRAME_leapatk_12;
	}
}

MONSTERINFO_ATTACK(gekk_attack) (edict_t *self) -> void
{
	float r = range_to(self, self->enemy);

	if (self->flags & FL_SWIM)
	{
		if (self->enemy && self->enemy->waterlevel >= WATER_WAIST && r <= RANGE_NEAR)
			return;

		self->flags &= ~FL_SWIM;
		self->monsterinfo.aiflags &= ~AI_ALTERNATE_FLY;
		M_SetAnimation(self, &gekk_move_leapatk);
		self->monsterinfo.nextframe = FRAME_leapatk_05;
	}
	else
	{
		if (r >= RANGE_MID) {
			if (frandom() > 0.5f) {
				M_SetAnimation(self, &gekk_move_spit);
			} else {
				M_SetAnimation(self, &gekk_move_run_start);
				self->monsterinfo.attack_finished = level.time + 2_sec;
			}
		} else if (frandom() > 0.7f) {
			M_SetAnimation(self, &gekk_move_spit);
		} else {
			if (self->spawnflags.has(SPAWNFLAG_GEKK_NOJUMPING) || frandom() > 0.7f) {
				M_SetAnimation(self, &gekk_move_run_start);
				self->monsterinfo.attack_finished = level.time + 1.4_sec;
			} else {
				M_SetAnimation(self, &gekk_move_leapatk);
			}
		}
	}
}

//
// PAIN
//

mframe_t gekk_frames_pain[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
};
MMOVE_T(gekk_move_pain) = { FRAME_pain_01, FRAME_pain_06, gekk_frames_pain, gekk_run_start };

mframe_t gekk_frames_pain1[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
	{ ai_move }, // frame 6
	{ ai_move }, // frame 7
	{ ai_move }, // frame 8
	{ ai_move }, // frame 9

	{ ai_move, 0, gekk_check_underwater }
};
MMOVE_T(gekk_move_pain1) = { FRAME_pain3_01, FRAME_pain3_11, gekk_frames_pain1, gekk_run_start };

mframe_t gekk_frames_pain2[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
	{ ai_move }, // frame 6
	{ ai_move }, // frame 7
	{ ai_move }, // frame 8
	{ ai_move }, // frame 9

	{ ai_move }, // frame 10
	{ ai_move }, // frame 11
	{ ai_move, 0, gekk_check_underwater },
};
MMOVE_T(gekk_move_pain2) = { FRAME_pain4_01, FRAME_pain4_13, gekk_frames_pain2, gekk_run_start };

PAIN(gekk_pain) (edict_t *self, edict_t *other, float kick, int damage, const mod_t &mod) -> void
{
	float r;

	if (self->spawnflags.has(SPAWNFLAG_GEKK_CHANT))
	{
		self->spawnflags &= ~SPAWNFLAG_GEKK_CHANT;
		return;
	}

	if (level.time < self->pain_debounce_time)
		return;

	self->pain_debounce_time = level.time + 3_sec;

	gi.sound(self, CHAN_VOICE, sound_pain1, 1, ATTN_NORM, 0);

	if (self->waterlevel >= WATER_WAIST)
	{
		if (!(self->flags & FL_SWIM))
		{
			self->monsterinfo.aiflags |= AI_ALTERNATE_FLY;
			self->flags |= FL_SWIM;
		}

		if (M_ShouldReactToPain(self, mod)) // no pain anims in nightmare
			M_SetAnimation(self, &gekk_move_pain);
	}
	else if (M_ShouldReactToPain(self, mod)) // no pain anims in nightmare
	{
		r = frandom();

		if (r > 0.5f)
			M_SetAnimation(self, &gekk_move_pain1);
		else
			M_SetAnimation(self, &gekk_move_pain2);
	}
}

//
// DEATH
//

void gekk_dead(edict_t *self)
{
	self->mins = { -16, -16, -24 };
	self->maxs = { 16, 16, -8 };
	monster_dead(self);
}

void gekk_gib(edict_t *self, int damage)
{
	gi.sound(self, CHAN_VOICE, gi.soundindex("misc/udeath.wav"), 1, ATTN_NORM, 0);

	ThrowGibs(self, damage, {
		{ "models/objects/gekkgib/pelvis/tris.md2", GIB_ACID },
		{ 2, "models/objects/gekkgib/arm/tris.md2", GIB_ACID },
		{ "models/objects/gekkgib/torso/tris.md2", GIB_ACID },
		{ "models/objects/gekkgib/claw/tris.md2", GIB_ACID },
		{ 2, "models/objects/gekkgib/leg/tris.md2", GIB_ACID },
		{ "models/objects/gekkgib/head/tris.md2", GIB_ACID | GIB_HEAD }
	});
}

void gekk_gibfest(edict_t *self)
{
	gekk_gib(self, 20);
	self->deadflag = true;
}

void isgibfest(edict_t *self)
{
	if (frandom() > 0.9f)
		gekk_gibfest(self);
}

static void gekk_shrink(edict_t *self)
{
	self->maxs[2] = 0;
	self->svflags |= SVF_DEADMONSTER;
	gi.linkentity(self);
}

mframe_t gekk_frames_death1[] = {
	{ ai_move, -5.151f },			   // frame 0
	{ ai_move, -12.223f },			   // frame 1
	{ ai_move, -11.484f },			   // frame 2
	{ ai_move, -17.952f },			   // frame 3
	{ ai_move, -6.953f },			   // frame 4
	{ ai_move, -7.393f, gekk_shrink }, // frame 5
	{ ai_move, -10.713f },			   // frame 6
	{ ai_move, -17.464f },			   // frame 7
	{ ai_move, -11.678f },			   // frame 8
	{ ai_move, -11.678f }			   // frame 9
};
MMOVE_T(gekk_move_death1) = { FRAME_death1_01, FRAME_death1_10, gekk_frames_death1, gekk_dead };

mframe_t gekk_frames_death3[] = {
	{ ai_move },					 // frame 0
	{ ai_move, 0.022f },			 // frame 1
	{ ai_move, 0.169f },			 // frame 2
	{ ai_move, -0.710f },			 // frame 3
	{ ai_move, -13.446f },			 // frame 4
	{ ai_move, -7.654f, isgibfest }, // frame 5
	{ ai_move, -31.951f },			 // frame 6
};
MMOVE_T(gekk_move_death3) = { FRAME_death3_01, FRAME_death3_07, gekk_frames_death3, gekk_dead };

mframe_t gekk_frames_death4[] = {
	{ ai_move, 5.103f },			   // frame 0
	{ ai_move, -4.808f },			   // frame 1
	{ ai_move, -10.509f },			   // frame 2
	{ ai_move, -9.899f },			   // frame 3
	{ ai_move, 4.033f, isgibfest },	   // frame 4
	{ ai_move, -5.197f },			   // frame 5
	{ ai_move, -0.919f },			   // frame 6
	{ ai_move, -8.821f },			   // frame 7
	{ ai_move, -5.626f },			   // frame 8
	{ ai_move, -8.865f, isgibfest },   // frame 9
	{ ai_move, -0.845f },			   // frame 10
	{ ai_move, 1.986f },			   // frame 11
	{ ai_move, 0.170f },			   // frame 12
	{ ai_move, 1.339f, isgibfest },	   // frame 13
	{ ai_move, -0.922f },			   // frame 14
	{ ai_move, 0.818f },			   // frame 15
	{ ai_move, -1.288f },			   // frame 16
	{ ai_move, -1.408f, isgibfest },   // frame 17
	{ ai_move, -7.787f },			   // frame 18
	{ ai_move, -3.995f },			   // frame 19
	{ ai_move, -4.604f },			   // frame 20
	{ ai_move, -1.715f, isgibfest },   // frame 21
	{ ai_move, -0.564f },			   // frame 22
	{ ai_move, -0.597f },			   // frame 23
	{ ai_move, 0.074f },			   // frame 24
	{ ai_move, -0.309f, isgibfest },   // frame 25
	{ ai_move, -0.395f },			   // frame 26
	{ ai_move, -0.501f },			   // frame 27
	{ ai_move, -0.325f },			   // frame 28
	{ ai_move, -0.931f, isgibfest },   // frame 29
	{ ai_move, -1.433f },			   // frame 30
	{ ai_move, -1.626f },			   // frame 31
	{ ai_move, 4.680f },			   // frame 32
	{ ai_move, 0.560f },			   // frame 33
	{ ai_move, -0.549f, gekk_gibfest } // frame 34
};
MMOVE_T(gekk_move_death4) = { FRAME_death4_01, FRAME_death4_35, gekk_frames_death4, gekk_dead };

mframe_t gekk_frames_wdeath[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
	{ ai_move }, // frame 6
	{ ai_move }, // frame 7
	{ ai_move }, // frame 8
	{ ai_move }, // frame 9
	{ ai_move }, // frame 10
	{ ai_move }, // frame 11
	{ ai_move }, // frame 12
	{ ai_move }, // frame 13
	{ ai_move }, // frame 14
	{ ai_move }, // frame 15
	{ ai_move }, // frame 16
	{ ai_move }, // frame 17
	{ ai_move }, // frame 18
	{ ai_move }, // frame 19
	{ ai_move }, // frame 20
	{ ai_move }, // frame 21
	{ ai_move }, // frame 22
	{ ai_move }, // frame 23
	{ ai_move }, // frame 24
	{ ai_move }, // frame 25
	{ ai_move }, // frame 26
	{ ai_move }, // frame 27
	{ ai_move }, // frame 28
	{ ai_move }, // frame 29
	{ ai_move }, // frame 30
	{ ai_move }, // frame 31
	{ ai_move }, // frame 32
	{ ai_move }, // frame 33
	{ ai_move }, // frame 34
	{ ai_move }, // frame 35
	{ ai_move }, // frame 36
	{ ai_move }, // frame 37
	{ ai_move }, // frame 38
	{ ai_move }, // frame 39
	{ ai_move }, // frame 40
	{ ai_move }, // frame 41
	{ ai_move }, // frame 42
	{ ai_move }, // frame 43
	{ ai_move }	 // frame 44
};
MMOVE_T(gekk_move_wdeath) = { FRAME_wdeath_01, FRAME_wdeath_45, gekk_frames_wdeath, gekk_dead };

DIE(gekk_die) (edict_t *self, edict_t *inflictor, edict_t *attacker, int damage, const vec3_t &point, const mod_t &mod) -> void
{
	float r;

	if (M_CheckGib(self, mod))
	{
		gekk_gib(self, damage);
		self->deadflag = true;
		return;
	}

	if (self->deadflag)
		return;

	gi.sound(self, CHAN_VOICE, sound_death, 1, ATTN_NORM, 0);
	self->deadflag = true;
	self->takedamage = true;

	if (self->waterlevel >= WATER_WAIST)
	{
		gekk_shrink(self);
		M_SetAnimation(self, &gekk_move_wdeath);
	}
	else
	{
		r = frandom();
		if (r > 0.66f)
			M_SetAnimation(self, &gekk_move_death1);
		else if (r > 0.33f)
			M_SetAnimation(self, &gekk_move_death3);
		else
			M_SetAnimation(self, &gekk_move_death4);
	}
}

/*
	duck
*/
mframe_t gekk_frames_lduck[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
	{ ai_move }, // frame 6
	{ ai_move }, // frame 7
	{ ai_move }, // frame 8
	{ ai_move }, // frame 9

	{ ai_move }, // frame 10
	{ ai_move }, // frame 11
	{ ai_move }	 // frame 12
};
MMOVE_T(gekk_move_lduck) = { FRAME_lduck_01, FRAME_lduck_13, gekk_frames_lduck, gekk_run_start };

mframe_t gekk_frames_rduck[] = {
	{ ai_move }, // frame 0
	{ ai_move }, // frame 1
	{ ai_move }, // frame 2
	{ ai_move }, // frame 3
	{ ai_move }, // frame 4
	{ ai_move }, // frame 5
	{ ai_move }, // frame 6
	{ ai_move }, // frame 7
	{ ai_move }, // frame 8
	{ ai_move }, // frame 9
	{ ai_move }, // frame 10
	{ ai_move }, // frame 11
	{ ai_move }	 // frame 12
};
MMOVE_T(gekk_move_rduck) = { FRAME_rduck_01, FRAME_rduck_13, gekk_frames_rduck, gekk_run_start };

MONSTERINFO_DODGE(gekk_dodge) (edict_t *self, edict_t *attacker, gtime_t eta, trace_t *tr, bool gravity) -> void
{
	// [Paril-KEX] this dodge is bad
#if 0
	float r;

	r = frandom();
	if (r > 0.25f)
		return;

	if (!self->enemy)
		self->enemy = attacker;

	if (self->waterlevel)
	{
		M_SetAnimation(self, &gekk_move_attack);
		return;
	}

	if (skill->integer == 0)
	{
		r = frandom();
		if (r > 0.5f)
			M_SetAnimation(self, &gekk_move_lduck);
		else
			M_SetAnimation(self, &gekk_move_rduck);
		return;
	}

	self->monsterinfo.pausetime = level.time + eta + 300_ms;
	r = frandom();

	if (skill->integer == 1)
	{
		if (r > 0.33f)
		{
			r = frandom();
			if (r > 0.5f)
				M_SetAnimation(self, &gekk_move_lduck);
			else
				M_SetAnimation(self, &gekk_move_rduck);
		}
		else
		{
			r = frandom();
			if (r > 0.66f)
				M_SetAnimation(self, &gekk_move_attack1);
			else
				M_SetAnimation(self, &gekk_move_attack2);
		}
		return;
	}

	if (skill->integer == 2)
	{
		if (r > 0.66f)
		{
			r = frandom();
			if (r > 0.5f)
				M_SetAnimation(self, &gekk_move_lduck);
			else
				M_SetAnimation(self, &gekk_move_rduck);
		}
		else
		{
			r = frandom();
			if (r > 0.66f)
				M_SetAnimation(self, &gekk_move_attack1);
			else
				M_SetAnimation(self, &gekk_move_attack2);
		}
		return;
	}

	r = frandom();
	if (r > 0.66f)
		M_SetAnimation(self, &gekk_move_attack1);
	else
		M_SetAnimation(self, &gekk_move_attack2);
#endif
}

//
// SPAWN
//

static void gekk_set_fly_parameters(edict_t *self)
{
	self->monsterinfo.fly_thrusters = false;
	self->monsterinfo.fly_acceleration = 25.f;
	self->monsterinfo.fly_speed = 150.f;
	// only melee, so get in close
	self->monsterinfo.fly_min_distance = 10.f;
	self->monsterinfo.fly_max_distance = 10.f;
}


//================
// ROGUE
void gekk_jump_down(edict_t *self)
{
	vec3_t forward, up;

	AngleVectors(self->s.angles, forward, nullptr, up);
	self->velocity += (forward * 100);
	self->velocity += (up * 300);
}

void gekk_jump_up(edict_t *self)
{
	vec3_t forward, up;

	AngleVectors(self->s.angles, forward, nullptr, up);
	self->velocity += (forward * 200);
	self->velocity += (up * 450);
}

void gekk_jump_wait_land(edict_t *self)
{
	if (!monster_jump_finished(self) && self->groundentity == nullptr)
		self->monsterinfo.nextframe = self->s.frame;
	else
		self->monsterinfo.nextframe = self->s.frame + 1;
}

mframe_t gekk_frames_jump_up[] = {
	{ ai_move, -8, gekk_jump_up },
	{ ai_move, -8 },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move, 0, gekk_jump_wait_land },
	{ ai_move }
};
MMOVE_T(gekk_move_jump_up) = { FRAME_leapatk_04, FRAME_leapatk_11, gekk_frames_jump_up, gekk_run };

mframe_t gekk_frames_jump_down[] = {
	{ ai_move, 0, gekk_jump_down },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move },
	{ ai_move, 0, gekk_jump_wait_land },
	{ ai_move }
};
MMOVE_T(gekk_move_jump_down) = { FRAME_leapatk_04, FRAME_leapatk_11, gekk_frames_jump_down, gekk_run };

void gekk_jump_updown(edict_t *self, blocked_jump_result_t result)
{
	if (!self->enemy)
		return;

	if (result == blocked_jump_result_t::JUMP_JUMP_UP)
		M_SetAnimation(self, &gekk_move_jump_up);
	else
		M_SetAnimation(self, &gekk_move_jump_down);
}

/*
===
Blocked
===
*/
MONSTERINFO_BLOCKED(gekk_blocked) (edict_t *self, float dist) -> bool
{
	if (auto result = blocked_checkjump(self, dist); result != blocked_jump_result_t::NO_JUMP)
	{
		if (result != blocked_jump_result_t::JUMP_TURN)
			gekk_jump_updown(self, result);
		return true;
	}

	if (blocked_checkplat(self, dist))
		return true;

	return false;
}
// ROGUE
//================

/*QUAKED monster_gekk (1 .5 0) (-16 -16 -24) (16 16 24) Ambush Trigger_Spawn Sight Chant NoJumping
 */
void SP_monster_gekk(edict_t *self)
{
	if ( !M_AllowSpawn( self ) ) {
		G_FreeEdict( self );
		return;
	}

	sound_swing = gi.soundindex("gek/gk_atck1.wav");
	sound_hit = gi.soundindex("gek/gk_atck2.wav");
	sound_hit2 = gi.soundindex("gek/gk_atck3.wav");
	sound_speet = gi.soundindex("gek/gk_atck4.wav");
	loogie_hit = gi.soundindex("gek/loogie_hit.wav");
	sound_death = gi.soundindex("gek/gk_deth1.wav");
	sound_pain1 = gi.soundindex("gek/gk_pain1.wav");
	sound_sight = gi.soundindex("gek/gk_sght1.wav");
	sound_search = gi.soundindex("gek/gk_idle1.wav");
	sound_step1 = gi.soundindex("gek/gk_step1.wav");
	sound_step2 = gi.soundindex("gek/gk_step2.wav");
	sound_step3 = gi.soundindex("gek/gk_step3.wav");
	sound_thud = gi.soundindex("mutant/thud1.wav");

	sound_chantlow = gi.soundindex("gek/gek_low.wav");
	sound_chantmid = gi.soundindex("gek/gek_mid.wav");
	sound_chanthigh = gi.soundindex("gek/gek_high.wav");

	self->movetype = MOVETYPE_STEP;
	self->solid = SOLID_BBOX;
	self->s.modelindex = gi.modelindex("models/monsters/gekk/tris.md2");
	self->mins = { -18, -18, -24 };
	self->maxs = { 18, 18, 24 };

	gi.modelindex("models/objects/gekkgib/pelvis/tris.md2");
	gi.modelindex("models/objects/gekkgib/arm/tris.md2");
	gi.modelindex("models/objects/gekkgib/torso/tris.md2");
	gi.modelindex("models/objects/gekkgib/claw/tris.md2");
	gi.modelindex("models/objects/gekkgib/leg/tris.md2");
	gi.modelindex("models/objects/gekkgib/head/tris.md2");

	self->health = 125 * st.health_multiplier;
	self->gib_health = -30;
	self->mass = 300;

	self->pain = gekk_pain;
	self->die = gekk_die;

	self->monsterinfo.stand = gekk_stand;

	self->monsterinfo.walk = gekk_walk;
	self->monsterinfo.run = gekk_run_start;
	self->monsterinfo.dodge = gekk_dodge;
	self->monsterinfo.attack = gekk_attack;
	self->monsterinfo.melee = gekk_melee;
	self->monsterinfo.sight = gekk_sight;
	self->monsterinfo.search = gekk_search;
	self->monsterinfo.idle = gekk_idle;
	self->monsterinfo.checkattack = gekk_checkattack;
	self->monsterinfo.setskin = gekk_setskin;

	gi.linkentity(self);

	M_SetAnimation(self, &gekk_move_stand);

	self->monsterinfo.scale = MODEL_SCALE;
	
	walkmonster_start(self);

	if (self->spawnflags.has(SPAWNFLAG_GEKK_CHANT))
		M_SetAnimation(self, &gekk_move_chant);

	self->monsterinfo.can_jump = !(self->spawnflags & SPAWNFLAG_GEKK_NOJUMPING);
	self->monsterinfo.drop_height = 256;
	self->monsterinfo.jump_height = 68;
	self->monsterinfo.blocked = gekk_blocked;

	gekk_set_fly_parameters(self);
}

void water_to_land(edict_t *self)
{
	self->monsterinfo.aiflags &= ~AI_ALTERNATE_FLY;
	self->flags &= ~FL_SWIM;
	self->yaw_speed = 20;
	self->viewheight = 25;

	M_SetAnimation(self, &gekk_move_leapatk2);

	self->mins = { -18, -18, -24 };
	self->maxs = { 18, 18, 24 };
}

void land_to_water(edict_t *self)
{
	self->monsterinfo.aiflags |= AI_ALTERNATE_FLY;
	self->flags |= FL_SWIM;
	self->yaw_speed = 10;
	self->viewheight = 10;

	M_SetAnimation(self, &gekk_move_swim_start);

	self->mins = { -18, -18, -24 };
	self->maxs = { 18, 18, 16 };
}