Free games for graphing calculators: NumWorks, TI-Nspire CX, Casio fx-CG50 and soon TI-84 Plus CE. Balatro, Celeste, Hollow Knight, Minecraft and more.
C calculatorcalculator-gamescasiochesscrossy-roaddrive-madfx-cg50gamesgeometry-dashgraphing-calculatorndlessnumworksnumworks-appsnumworks-calculatornumworks-gamenumworks-gamestetristi-84-plus-ceti-nspire
/* The monsters, and how each moves, as in Rebirth: health, speed and the
* way it hunts or shoots. Speeds are pixels a frame (the game's units
* halved); a shot goes 3 to 4 a frame. */
#include <string.h>
#include "game.h"
#include "gfx.h"
#include "res.h"
enum {
MV_CHASE, MV_FLY, MV_ATTACK_FLY, MV_POOTER, MV_HORF, MV_HOST, MV_CLOTTY, MV_FLEE, MV_HIVE, MV_CHARGER, MV_GLOBIN,
MV_BOOM_FLY, MV_MAW, MV_HOPPER, MV_LEAPER, MV_SPIDER, MV_KNIGHT, MV_DIP, MV_GUSHER, MV_SKINNY, MV_BONY, MV_BABY,
MV_VIS, MV_EYE, MV_SUCKER, MV_BOIL, MV_SPITTY, MV_BRAIN, MV_NEST, MV_DEATHS_HEAD, MV_MOMS_HAND, MV_GRIMACE,
MV_BAT, MV_IMP, MV_TUMOR, MV_POKY, MV_BURROW, MV_LEECH, MV_TETHER, MV_WALL, MV_GAPING, MV_FATTY, MV_KEEPER,
MV_SWARMER, MV_MULLIGAN, MV_WANDER, MV_BLUE_FLY
};
typedef struct {
const char *name;
uint8_t moves; /* how it moves (MV_*) */
uint8_t hp;
uint8_t r; /* radius */
uint8_t speed; /* tenths of a pixel a frame */
uint8_t flying;
int16_t spr;
} MonInfo;
#define M(n, mv, hp, r, sp, fl, spr) {n, mv, hp, r, sp, fl, spr}
static const MonInfo mons[] = {
[MON_GAPER] = M("GAPER", MV_CHASE, 10, 7, 14, 0, SPR_GAPER),
[MON_FROWNING_GAPER] = M("FROWNING GAPER", MV_CHASE, 10, 7, 12, 0, SPR_FROWNING_GAPER),
[MON_GUSHER] = M("GUSHER", MV_GUSHER, 10, 7, 12, 0, SPR_GUSHER),
[MON_PACER] = M("PACER", MV_WANDER, 10, 7, 14, 0, SPR_PACER),
[MON_HORF] = M("HORF", MV_HORF, 10, 7, 0, 0, SPR_HORF),
[MON_FLY] = M("FLY", MV_FLY, 5, 5, 6, 1, SPR_FLY),
[MON_POOTER] = M("POOTER", MV_POOTER, 8, 6, 8, 1, SPR_POOTER),
[MON_SUPER_POOTER] = M("SUPER POOTER", MV_POOTER, 14, 7, 8, 1, SPR_SUPER_POOTER),
[MON_CLOTTY] = M("CLOTTY", MV_CLOTTY, 15, 8, 10, 0, SPR_CLOTTY),
[MON_CLOT] = M("CLOT", MV_CLOTTY, 13, 7, 10, 0, SPR_CLOT),
[MON_IBLOB] = M("I. BLOB", MV_CLOTTY, 20, 8, 10, 0, SPR_IBLOB),
[MON_MULLIGAN] = M("MULLIGAN", MV_MULLIGAN, 13, 7, 14, 0, SPR_MULLIGAN),
[MON_ATTACK_FLY] = M("ATTACK FLY", MV_ATTACK_FLY, 5, 5, 20, 1, SPR_ATTACK_FLY),
[MON_MAGGOT] = M("MAGGOT", MV_CHARGER, 7, 6, 8, 0, SPR_MAGGOT),
[MON_HIVE] = M("HIVE", MV_HIVE, 25, 9, 10, 0, SPR_HIVE),
[MON_CHARGER] = M("CHARGER", MV_CHARGER, 10, 6, 10, 0, SPR_CHARGER),
[MON_GLOBIN] = M("GLOBIN", MV_GLOBIN, 20, 8, 13, 0, SPR_GLOBIN),
[MON_BOOM_FLY] = M("BOOM FLY", MV_BOOM_FLY, 20, 7, 15, 1, SPR_BOOM_FLY),
[MON_RED_BOOM_FLY] = M("RED BOOM FLY", MV_BOOM_FLY, 20, 7, 15, 1, SPR_RED_BOOM_FLY),
[MON_MAW] = M("MAW", MV_MAW, 15, 7, 8, 1, SPR_MAW),
[MON_RED_MAW] = M("RED MAW", MV_MAW, 25, 7, 8, 1, SPR_RED_MAW),
[MON_HOST] = M("HOST", MV_HOST, 14, 7, 0, 0, SPR_HOST),
[MON_RED_HOST] = M("RED HOST", MV_HOST, 20, 7, 0, 0, SPR_RED_HOST),
[MON_HOPPER] = M("HOPPER", MV_HOPPER, 10, 6, 0, 0, SPR_HOPPER),
[MON_TRITE] = M("TRITE", MV_LEAPER, 10, 6, 0, 0, SPR_TRITE),
[MON_BOIL] = M("BOIL", MV_BOIL, 15, 7, 0, 0, SPR_BOIL),
[MON_SPITTY] = M("SPITTY", MV_SPITTY, 15, 7, 12, 0, SPR_SPITTY),
[MON_BRAIN] = M("BRAIN", MV_BRAIN, 20, 8, 16, 0, SPR_BRAIN),
[MON_LEAPER] = M("LEAPER", MV_LEAPER, 20, 8, 0, 0, SPR_LEAPER),
[MON_MR_MAW] = M("MR. MAW", MV_TETHER, 22, 7, 14, 0, SPR_MR_MAW),
[MON_BABY] = M("BABY", MV_BABY, 12, 7, 0, 1, SPR_BABY),
[MON_ANGELIC_BABY] = M("ANGELIC BABY", MV_BABY, 25, 7, 0, 1, SPR_ANGELIC_BABY),
[MON_VIS] = M("VIS", MV_VIS, 22, 8, 12, 0, SPR_VIS),
[MON_GUTS] = M("GUTS", MV_WALL, 20, 7, 14, 0, SPR_GUTS),
[MON_KNIGHT] = M("KNIGHT", MV_KNIGHT, 12, 7, 10, 0, SPR_KNIGHT),
[MON_SELFLESS_KNIGHT] = M("SELFLESS KNIGHT", MV_KNIGHT, 18, 7, 10, 0, SPR_SELFLESS_KNIGHT),
[MON_LEECH] = M("LEECH", MV_LEECH, 15, 6, 22, 0, SPR_LEECH),
[MON_KAMIKAZE_LEECH] = M("KAMIKAZE LEECH", MV_LEECH, 12, 6, 24, 0, SPR_KAMIKAZE_LEECH),
[MON_PARA_BITE] = M("PARA-BITE", MV_BURROW, 15, 6, 0, 0, SPR_PARA_BITE),
[MON_EYE] = M("EYE", MV_EYE, 20, 7, 0, 0, SPR_EYE),
[MON_BLOODSHOT_EYE] = M("BLOODSHOT EYE", MV_EYE, 25, 7, 0, 0, SPR_BLOODSHOT_EYE),
[MON_SUCKER] = M("SUCKER", MV_SUCKER, 10, 6, 12, 1, SPR_SUCKER),
[MON_SPIT] = M("SPIT", MV_SUCKER, 10, 6, 12, 1, SPR_SPIT),
[MON_EMBRYO] = M("EMBRYO", MV_HOPPER, 10, 6, 0, 0, SPR_EMBRYO),
[MON_MOTER] = M("MOTER", MV_ATTACK_FLY, 12, 6, 14, 1, SPR_MOTER),
[MON_SPIDER] = M("SPIDER", MV_SPIDER, 5, 5, 30, 0, SPR_SPIDER),
[MON_KEEPER] = M("KEEPER", MV_KEEPER, 18, 7, 0, 0, SPR_KEEPER),
[MON_GURGLE] = M("GURGLE", MV_CHASE, 20, 7, 18, 0, SPR_GURGLE),
[MON_WALKING_BOIL] = M("WALKING BOIL", MV_SPITTY, 25, 8, 9, 0, SPR_WALKING_BOIL),
[MON_BUTTLICKER] = M("BUTTLICKER", MV_SPIDER, 20, 7, 22, 0, SPR_BUTTLICKER),
[MON_HANGER] = M("HANGER", MV_POOTER, 20, 7, 10, 1, SPR_HANGER),
[MON_SWARMER] = M("SWARMER", MV_SWARMER, 15, 6, 10, 1, SPR_SWARMER),
[MON_HEART] = M("HEART", MV_FLY, 15, 6, 10, 1, SPR_HEART),
[MON_MASK] = M("MASK", MV_CHARGER, 255, 7, 14, 0, SPR_MASK),
[MON_BIG_SPIDER] = M("BIG SPIDER", MV_SPIDER, 13, 7, 26, 0, SPR_BIG_SPIDER),
[MON_NEST] = M("NEST", MV_NEST, 25, 9, 0, 0, SPR_NEST),
[MON_BABY_LONG_LEGS] = M("BABY LONG LEGS", MV_NEST, 40, 9, 10, 0, SPR_BABY_LONG_LEGS),
[MON_FATTY] = M("FATTY", MV_FATTY, 25, 9, 7, 0, SPR_FATTY),
[MON_PALE_FATTY] = M("PALE FATTY", MV_FATTY, 30, 9, 7, 0, SPR_PALE_FATTY),
[MON_FAT_SACK] = M("FAT SACK", MV_FATTY, 35, 9, 6, 0, SPR_FAT_SACK),
[MON_DEATHS_HEAD] = M("DEATH'S HEAD", MV_DEATHS_HEAD, 255, 7, 18, 1, SPR_DEATHS_HEAD),
[MON_MOMS_HAND] = M("MOM'S HAND", MV_MOMS_HAND, 50, 10, 0, 1, SPR_MOMS_HAND),
[MON_DIP] = M("DIP", MV_DIP, 6, 5, 0, 0, SPR_DIP),
[MON_SQUIRT] = M("SQUIRT", MV_DIP, 15, 8, 0, 0, SPR_SQUIRT),
[MON_SKINNY] = M("SKINNY", MV_SKINNY, 20, 7, 8, 0, SPR_SKINNY),
[MON_BONY] = M("BONY", MV_BONY, 10, 7, 11, 0, SPR_BONY),
[MON_ONE_TOOTH] = M("ONE TOOTH", MV_BAT, 15, 6, 16, 1, SPR_ONE_TOOTH),
[MON_GAPING_MAW] = M("GAPING MAW", MV_GAPING, 30, 8, 0, 1, SPR_GAPING_MAW),
[MON_RAGLING] = M("RAGLING", MV_GLOBIN, 16, 7, 16, 0, SPR_RAGLING),
[MON_NIGHT_CRAWLER] = M("NIGHT CRAWLER", MV_BURROW, 20, 7, 0, 0, SPR_NIGHT_CRAWLER),
[MON_DART_FLY] = M("DART FLY", MV_ATTACK_FLY, 8, 5, 26, 1, SPR_DART_FLY),
[MON_FAT_BAT] = M("FAT BAT", MV_BAT, 25, 8, 12, 1, SPR_FAT_BAT),
[MON_IMP] = M("IMP", MV_IMP, 25, 7, 0, 0, SPR_IMP),
[MON_TUMOR] = M("TUMOR", MV_TUMOR, 20, 7, 6, 1, SPR_TUMOR),
[MON_POKY] = M("POKY", MV_POKY, 255, 7, 20, 0, SPR_POKY),
[MON_STONE_GRIMACE] = M("STONE GRIMACE", MV_GRIMACE, 255, 8, 0, 0, SPR_STONE_GRIMACE),
[MON_CONJOINED_FATTY] = M("CONJOINED FATTY", MV_FATTY, 40, 10, 6, 0, SPR_CONJOINED_FATTY),
[MON_ROUND_WORM] = M("ROUND WORM", MV_BURROW, 15, 6, 0, 0, SPR_ROUND_WORM),
[MON_WALL_CREEP] = M("WALL CREEP", MV_WALL, 15, 7, 12, 0, SPR_WALL_CREEP),
[MON_MEMBRAIN] = M("MEMBRAIN", MV_BRAIN, 45, 10, 10, 0, SPR_MEMBRAIN),
[MON_LUMP] = M("LUMP", MV_BURROW, 20, 7, 0, 0, SPR_LUMP),
[MON_FRED] = M("FRED", MV_BURROW, 30, 8, 0, 0, SPR_FRED),
[MON_HOMUNCULUS] = M("HOMUNCULUS", MV_TETHER, 25, 7, 16, 0, SPR_HOMUNCULUS),
[MON_BEGOTTEN] = M("BEGOTTEN", MV_TETHER, 35, 8, 16, 0, SPR_BEGOTTEN),
[MON_CHUBBER] = M("CHUBBER", MV_VIS, 25, 8, 10, 0, SPR_CHUBBER),
[MON_FLAMING_HOPPER] = M("FLAMING HOPPER", MV_HOPPER, 15, 6, 0, 0, SPR_FLAMING_HOPPER),
[MON_BLUE_FLY] = M("BLUE FLY", MV_BLUE_FLY, 1, 4, 30, 1, SPR_FLY),
};
const char *mon_name(int type) {
if (type >= 0 && type < (int)(sizeof mons / sizeof mons[0]) && mons[type].name) return mons[type].name;
return NULL;
}
void mon_set_sprite(Ent *e) {
if (e->type < sizeof mons / sizeof mons[0] && mons[e->type].name) e->spr = mons[e->type].spr;
}
Ent *mon_spawn(int type, float x, float y) {
if (type >= MON_MONSTRO) {
boss_spawn(type, x, y);
return NULL;
}
if (type < 0 || type >= (int)(sizeof mons / sizeof mons[0]) || !mons[type].name) return NULL;
Ent *e = ent_new(EK_MON, x, y);
if (!e) return NULL;
const MonInfo *m = &mons[type];
e->type = (uint8_t)type;
e->hp = e->maxhp = m->hp == 255 ? 1000 : m->hp * (1 + (fl.stage - 1) * 0.12f);
e->r = m->r;
e->spr = m->spr;
if (m->flying) e->flags |= EF_FLYING;
if (m->hp == 255) e->flags |= EF_INVULN | EF_NOCOUNT;
if (m->moves == MV_HOST) e->flags |= EF_INVULN;
if (m->moves == MV_MOMS_HAND) e->flags |= EF_HIDDEN | EF_NOHIT;
if (m->moves == MV_BURROW) e->flags |= EF_HIDDEN | EF_NOHIT | EF_INVULN;
if (type == MON_BLUE_FLY) e->flags |= EF_FRIEND;
e->t = (int16_t)(20 + rnd(40));
e->a = rndf() * 6.2831853f;
e->c = x, e->b = y; /* (where it began: tethers) */
if (m->moves == MV_CHARGER || m->moves == MV_KNIGHT || m->moves == MV_LEECH || m->moves == MV_WALL || m->moves == MV_VIS)
e->c = (float)rnd(4); /* (for these, the way they go) */
return e;
}
/* ---------------------------------------------------------------- helpers */
static float to_player(Ent *e, float *dx, float *dy) {
float x = pl.x - e->x, y = pl.y - e->y, d = fsqrt(x * x + y * y);
if (d < 0.01f) d = 0.01f;
*dx = x / d, *dy = y / d;
return d;
}
static float spd(Ent *e) {
float s = mons[e->type].speed / 10.0f;
if (e->flags & EF_CHAMPION && e->sub == 1) s *= 1.4f;
return s;
}
static void walk(Ent *e, float dx, float dy, float s, float acc) {
if (e->fear) dx = -dx, dy = -dy;
if (e->confuse) dx = fcos(e->a), dy = fsin(e->a), e->a += 0.1f;
e->vx += (dx * s - e->vx) * acc, e->vy += (dy * s - e->vy) * acc;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r * 0.8f, e->flags & EF_FLYING, false);
}
static bool aligned(Ent *e, float tol) { return absf(pl.x - e->x) < tol || absf(pl.y - e->y) < tol; }
static void shot4(Ent *e, float s, bool diag) {
for (int d = 0; d < 4; d++) {
float ax = DIR_X[d], ay = DIR_Y[d];
if (diag) ax = (d & 1) ? 0.7071f : -0.7071f, ay = (d & 2) ? 0.7071f : -0.7071f;
enemy_shot(e->x, e->y - 6, ax * s, ay * s, 0);
}
}
static int dir_to_player(Ent *e) {
float dx = pl.x - e->x, dy = pl.y - e->y;
if (absf(dx) > absf(dy)) return dx < 0 ? DIR_LEFT : DIR_RIGHT;
return dy < 0 ? DIR_UP : DIR_DOWN;
}
/* ---------------------------------------------------------------- the monsters' minds */
void mon_update(Ent *e) {
const MonInfo *m = &mons[e->type];
float dx, dy, d = to_player(e, &dx, &dy), s = spd(e);
e->t--;
if (e->flags & EF_FRIEND && e->type != MON_BLUE_FLY) { /* (charmed: it goes for the others) */
Ent *o = ent_nearest_monster(e->x, e->y, 400);
if (o) {
float ox = o->x - e->x, oy = o->y - e->y, od = fsqrt(ox * ox + oy * oy) + 0.01f;
walk(e, ox / od, oy / od, s > 0 ? s : 1, 0.2f);
if (od < e->r + o->r) ent_damage(o, 1, 0, 0, 0);
}
return;
}
switch (m->moves) {
case MV_CHASE: { /* walks at him, around what's in the way */
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.15f);
if (e->type == MON_GURGLE && (e->t & 7) == 0) creep_spawn(e->x, e->y, 7, 90, true, 0);
break;
}
case MV_WANDER: case MV_GUSHER: /* headless: wanders, sprays blood now and then */
if (e->t <= 0) e->a = rndf() * 6.2831853f, e->t = (int16_t)(30 + rnd(40));
walk(e, fcos(e->a), fsin(e->a), s, 0.1f);
if (e->vx == 0 || e->vy == 0) e->a += 1.5f;
if (m->moves == MV_GUSHER && rnd(70) == 0) enemy_shot(e->x, e->y - 10, (rndf() - 0.5f) * 3, -1 - rndf() * 2, 0);
break;
case MV_FLY: { /* a lazy buzz towards him */
e->a += (rndf() - 0.5f) * 0.8f;
float wx = dx + fcos(e->a) * 0.9f, wy = dy + fsin(e->a) * 0.9f;
walk(e, wx, wy, s, 0.1f);
break;
}
case MV_ATTACK_FLY: case MV_BLUE_FLY: {
if (m->moves == MV_BLUE_FLY) { /* Isaac's: at the nearest monster, then pop */
Ent *o = ent_nearest_monster(e->x, e->y, 400);
if (!o) {
walk(e, dx * (d > 30 ? 1 : -0.2f), dy * (d > 30 ? 1 : -0.2f), 2, 0.2f);
break;
}
float ox = o->x - e->x, oy = o->y - e->y, od = fsqrt(ox * ox + oy * oy) + 0.01f;
walk(e, ox / od, oy / od, s, 0.25f);
if (od < e->r + o->r) ent_damage(o, pl.damage * 2, 0, 0, 0), e->kind = EK_NONE;
break;
}
e->a += (rndf() - 0.5f) * 0.4f;
walk(e, dx + fcos(e->a) * 0.3f, dy + fsin(e->a) * 0.3f, s, 0.12f);
if (e->type == MON_DART_FLY && e->t <= 0) e->vx = dx * 5, e->vy = dy * 5, e->t = 50;
break;
}
case MV_POOTER: { /* floats this way and that; a shot at him every so often */
e->a += (rndf() - 0.5f) * 0.5f;
walk(e, fcos(e->a) * 0.7f + dx * 0.3f, fsin(e->a) * 0.7f + dy * 0.3f, s, 0.06f);
if (e->t <= 0 && d < 160) {
e->t = (int16_t)(50 + rnd(30));
if (e->type == MON_SUPER_POOTER) {
for (int k = -1; k <= 1; k += 2) enemy_shot(e->x, e->y - 8, dx * 3.5f - dy * k * 0.6f, dy * 3.5f + dx * k * 0.6f, 0);
} else
enemy_shot_at(e->x, e->y - 8, 3.5f);
}
break;
}
case MV_HORF: /* shakes where it is; shoots when he comes near */
if (e->t <= 0 && d < 150) e->t = 45, enemy_shot_at(e->x, e->y - 6, 4);
break;
case MV_HOST: /* a skull, shut: it opens to fire three, then shuts */
if (e->state == 0) {
e->flags |= EF_INVULN;
if (e->t <= 0 && d < 140) e->state = 1, e->t = 30, e->flags &= (uint16_t)~EF_INVULN;
} else {
if (e->t == 18) {
float a = fatan2(dy, dx);
for (int k = -1; k <= 1; k++) enemy_shot(e->x, e->y - 8, fcos(a + k * 0.3f) * 3.6f, fsin(a + k * 0.3f) * 3.6f, 0);
if (e->type == MON_RED_HOST) for (int k = -2; k <= 2; k += 4) enemy_shot(e->x, e->y - 8, fcos(a + k * 0.3f) * 3.6f, fsin(a + k * 0.3f) * 3.6f, 0);
}
if (e->t <= 0) e->state = 0, e->t = (int16_t)(40 + rnd(30));
}
break;
case MV_CLOTTY: { /* blobs about; four shots at once (an I. Blob, eight) */
if (e->t <= 0) {
e->t = (int16_t)(50 + rnd(40));
if (e->type == MON_IBLOB) shot4(e, 3, false), shot4(e, 3, true);
else shot4(e, 3, e->type == MON_CLOT);
e->a = rndf() * 6.2831853f;
}
walk(e, fcos(e->a), fsin(e->a), e->t > 25 ? s : 0, 0.1f);
break;
}
case MV_FLEE: case MV_MULLIGAN: case MV_HIVE: /* runs from him; a hive lets flies out */
walk(e, -dx + fcos(e->a) * 0.4f, -dy + fsin(e->a) * 0.4f, d < 120 ? s : s * 0.3f, 0.1f);
e->a += 0.05f;
if (m->moves == MV_HIVE && e->t <= 0) {
e->t = 80;
int n = 0;
for (int i = 0; i < MAX_ENTS; i++) n += ents[i].kind == EK_MON && ents[i].type == MON_FLY;
if (n < 4) mon_spawn(MON_FLY, e->x, e->y - 6);
}
break;
case MV_CHARGER: case MV_KNIGHT: { /* straight lines; a charge when he is in line */
if (e->state == 0) {
if (e->t <= 0 || (e->vx == 0 && e->vy == 0 && e->t < 40)) e->c = (float)rnd(4), e->t = (int16_t)(30 + rnd(50));
int dd = (int)e->c;
walk(e, DIR_X[dd], DIR_Y[dd], s, 0.3f);
e->frame = 0;
if (e->type != MON_MAGGOT && aligned(e, 8) && d < 200 && grid_line_clear(e->x, e->y, pl.x, pl.y)) {
int pd = dir_to_player(e);
if (e->type == MON_KNIGHT || e->type == MON_SELFLESS_KNIGHT || pd == dd || e->type == MON_CHARGER || e->type == MON_MASK)
e->state = 1, e->c = (float)pd, e->t = 40;
}
} else {
int dd = (int)e->c;
walk(e, DIR_X[dd], DIR_Y[dd], s * 3, 0.4f);
if (e->t <= 0 || (e->vx == 0 && e->vy == 0)) e->state = 0, e->t = 30;
}
if (m->moves == MV_KNIGHT) e->b = e->c; /* (the way its shield faces) */
break;
}
case MV_GLOBIN: /* falls into goo when beaten, gets back up unless hurt again */
if (e->state == 1) {
e->vx = e->vy = 0;
if (e->t <= 0) e->state = 0, e->hp = e->maxhp, e->flags &= (uint16_t)~EF_NOHIT;
break;
}
{
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.15f);
}
break;
case MV_BOOM_FLY: /* bounces about on the diagonals */
if (!e->vx && !e->vy) e->vx = s * (rnd(2) ? 1 : -1), e->vy = s * (rnd(2) ? 1 : -1);
{
float ox = e->vx, oy = e->vy;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, true, false);
if (e->vx == 0) e->vx = -ox;
if (e->vy == 0) e->vy = -oy;
}
break;
case MV_MAW: /* a floating head: drifts at him, shoots when near */
walk(e, dx, dy, s, 0.05f);
if (e->t <= 0 && d < 130) e->t = (int16_t)(60 + rnd(30)), enemy_shot_at(e->x, e->y - 8, 3.5f);
break;
case MV_HOPPER: case MV_LEAPER: { /* hops; a leaper's jump lands on him */
if (e->state == 0) {
e->z = 0;
if (e->t <= 0) {
e->state = 1;
float range = m->moves == MV_LEAPER ? (d < 100 ? d : 100) : 40;
float a = m->moves == MV_LEAPER ? fatan2(dy, dx) : fatan2(dy, dx) + (rndf() - 0.5f) * 2;
e->a = a, e->b = range;
e->t2 = m->moves == MV_LEAPER ? 30 : 16;
e->t3 = e->t2;
e->flags |= m->moves == MV_LEAPER ? EF_NOHIT : 0;
}
} else {
float k = 1 - (float)e->t2 / e->t3;
e->z = -(m->moves == MV_LEAPER ? 60 : 14) * 4 * k * (1 - k);
float step = e->b / e->t3;
e->vx = fcos(e->a) * step, e->vy = fsin(e->a) * step;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r * 0.8f, e->z < -8, false);
if (--e->t2 <= 0) {
e->state = 0, e->z = 0, e->t = (int16_t)(m->moves == MV_LEAPER ? 40 + rnd(30) : 10 + rnd(25));
e->flags &= (uint16_t)~EF_NOHIT;
if (e->type == MON_LEAPER) shot4(e, 3, false);
if (e->type == MON_FLAMING_HOPPER) creep_spawn(e->x, e->y, 8, 60, true, 2);
}
}
break;
}
case MV_SPIDER: /* skitters at him in quick dashes */
if (e->t <= 0) {
e->t = (int16_t)(12 + rnd(20));
float a = fatan2(dy, dx) + (rndf() - 0.5f) * 1.6f;
e->a = a, e->state = (uint8_t)(rnd(3) != 0);
}
walk(e, fcos(e->a), fsin(e->a), e->state ? s : 0, 0.3f);
break;
case MV_DIP: /* slides in spurts */
if (e->t <= 0) {
e->t = (int16_t)(25 + rnd(20));
float a = rndf() * 6.2831853f;
float sp = e->type == MON_SQUIRT ? 4.5f : 3.5f;
e->vx = fcos(a) * sp, e->vy = fsin(a) * sp;
}
e->vx *= 0.9f, e->vy *= 0.9f;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r * 0.8f, false, false);
break;
case MV_SKINNY: /* slow until he hurts it, then it runs */
{
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, e->hp < e->maxhp ? s * 2.2f : s, 0.15f);
}
break;
case MV_BONY: /* walks, throws bones when he is in line */
{
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, d > 60 ? s : 0, 0.15f);
if (e->t <= 0 && aligned(e, 10) && d < 180) {
int pd = dir_to_player(e);
enemy_shot(e->x, e->y - 6, DIR_X[pd] * 4, DIR_Y[pd] * 4, 1);
e->t = 50;
}
}
break;
case MV_BABY: case MV_IMP: /* gone, and back elsewhere; then a shot */
if (e->state == 0) {
if (e->t <= 0) e->state = 1, e->t = 12;
} else if (e->state == 1) {
e->alpha = (uint8_t)(e->t * 2);
if (e->t <= 0) {
for (int k = 0; k < 20; k++) {
float x = ROOM_X + 20 + rnd(220), y = ROOM_Y + 20 + rnd(100);
if (!solid_at(x, y, false) && dist2(x, y, pl.x, pl.y) > 50 * 50) {
e->x = x, e->y = y;
break;
}
}
e->state = 2, e->t = 12;
}
} else {
e->alpha = (uint8_t)(32 - e->t * 2);
if (e->t <= 0) {
e->alpha = 32, e->state = 0, e->t = (int16_t)(40 + rnd(30));
if (m->moves == MV_IMP) shot4(e, 3.5f, false);
else enemy_shot_at(e->x, e->y - 10, 3.5f);
}
}
break;
case MV_VIS: /* walks; a blood beam when he is in line */
if (e->state == 0) {
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.12f);
if (e->t <= 0 && aligned(e, 8) && d < 200) e->state = 1, e->t = 20, e->c = (float)dir_to_player(e);
} else {
e->vx = e->vy = 0;
if (e->t == 8) laser_fire(e->x, e->y - 10, (int)e->c, 7, 0, 14, 0, true);
if (e->t <= 0) e->state = 0, e->t = 70;
}
break;
case MV_EYE: /* stares; a beam (or shots) when he is in line */
if (e->t <= 0 && aligned(e, 9)) {
e->t = 70;
int pd = dir_to_player(e);
if (e->type == MON_EYE) laser_fire(e->x, e->y - 10, pd, 5, 0, 12, 0, true);
else enemy_shot(e->x, e->y - 8, DIR_X[pd] * 4, DIR_Y[pd] * 4, 0), enemy_shot(e->x, e->y - 8, DIR_X[pd] * 3, DIR_Y[pd] * 3, 0);
}
break;
case MV_SUCKER: case MV_SWARMER: /* flies at him */
e->a += (rndf() - 0.5f) * 0.6f;
walk(e, dx + fcos(e->a) * 0.5f, dy + fsin(e->a) * 0.5f, s, 0.08f);
break;
case MV_BOIL: /* grows, then spits a fountain */
if (e->t <= 0 && d < 170) {
e->t = 80;
for (int k = 0; k < 4; k++) {
Tear *t = enemy_shot(e->x, e->y - 8, dx * (2 + rndf()) + (rndf() - 0.5f), dy * (2 + rndf()) + (rndf() - 0.5f), 0);
if (t) t->vz = -2.5f, t->flags |= TF_ARC, t->range = 1e9f;
}
}
break;
case MV_SPITTY: { /* walks at him, spits when in line */
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.12f);
if (e->t <= 0 && aligned(e, 8) && d < 200) {
int pd = dir_to_player(e);
enemy_shot(e->x, e->y - 6, DIR_X[pd] * 4, DIR_Y[pd] * 4, 0);
e->t = 45;
}
break;
}
case MV_BRAIN: /* rolls and bounces, leaving creep */
if (!e->vx && !e->vy) e->vx = s * (rnd(2) ? 1 : -1), e->vy = s * 0.7f * (rnd(2) ? 1 : -1);
{
float ox = e->vx, oy = e->vy;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, false, false);
if (e->vx == 0) e->vx = -ox;
if (e->vy == 0) e->vy = -oy;
}
if ((e->t & 7) == 0) creep_spawn(e->x, e->y, 6, 80, true, 0);
if (e->type == MON_MEMBRAIN && e->t <= 0) e->t = 60, enemy_shots_ring(e->x, e->y - 8, 6, 3, 0);
break;
case MV_NEST: /* spiders come out of it */
if (e->type == MON_BABY_LONG_LEGS) walk(e, dx, dy, d > 70 ? s : 0, 0.1f);
if (e->t <= 0) {
e->t = 100;
int n = 0;
for (int i = 0; i < MAX_ENTS; i++) n += ents[i].kind == EK_MON && ents[i].type == MON_SPIDER;
if (n < 3) mon_spawn(MON_SPIDER, e->x, e->y + 6);
}
break;
case MV_DEATHS_HEAD: /* a skull that bounces about for good (it dies with the room's last monster) */
if (!e->vx && !e->vy) e->vx = s, e->vy = s;
{
float ox = e->vx, oy = e->vy;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, true, false);
if (e->vx == 0) e->vx = -ox;
if (e->vy == 0) e->vy = -oy;
}
if (!ents_alive_monsters()) ent_kill(e), e->kind = EK_NONE;
break;
case MV_MOMS_HAND: /* Mom's hand: a shadow on him, then it comes down; it takes him away */
if (e->state == 0) {
e->flags |= EF_HIDDEN | EF_NOHIT;
if (e->t <= 0) e->state = 1, e->t = 40;
} else if (e->state == 1) {
e->x += (pl.x - e->x) * 0.15f, e->y += (pl.y - e->y) * 0.15f;
if (e->t <= 0) e->state = 2, e->t = 10, e->z = -80;
} else if (e->state == 2) {
e->flags &= (uint16_t)~(EF_HIDDEN | EF_NOHIT);
e->z += 8;
if (e->z >= 0) {
e->z = 0, e->state = 3, e->t = 30;
if (dist2(e->x, e->y, pl.x, pl.y) < 15 * 15 && pl.invuln == 0) {
player_hurt(1, MON_MOMS_HAND);
e->state = 4, e->t = 20; /* got him */
}
}
} else if (e->state == 3) {
if (e->t <= 0) e->state = 0, e->t = 60, e->z = -80;
} else {
pl.x = e->x, pl.y = e->y, e->z -= 4;
if (e->t <= 0) room_teleport(fl.start), e->kind = EK_NONE;
}
break;
case MV_GRIMACE: /* a stone face in a wall: shoots along its line, can't be hurt */
if (e->t <= 0 && aligned(e, 10)) {
e->t = 40;
int pd = dir_to_player(e);
enemy_shot(e->x, e->y - 6, DIR_X[pd] * 4, DIR_Y[pd] * 4, 0);
}
break;
case MV_BAT: /* flits about, then swoops at him */
e->a += (rndf() - 0.5f) * 0.6f;
walk(e, fcos(e->a) * 0.8f + dx * 0.5f, fsin(e->a) * 0.8f + dy * 0.5f, s, 0.1f);
if (e->type == MON_FAT_BAT && e->t <= 0) e->t = 70, enemy_shot_at(e->x, e->y - 8, 3.5f);
break;
case MV_TUMOR: /* floats; spreads shots */
walk(e, fcos(e->a), fsin(e->a), s, 0.05f);
e->a += 0.02f;
if (e->t <= 0 && d < 170) e->t = 70, enemy_shots_ring(e->x, e->y - 8, 5, 3, fatan2(dy, dx));
break;
case MV_POKY: /* spikes that slide back and forth for good */
if (!e->vx && !e->vy) {
if (e->state & 1) e->vy = e->state & 2 ? -s : s;
else e->vx = e->state & 2 ? -s : s;
e->state ^= 2;
}
{
float ox = e->vx, oy = e->vy;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, false, false);
if (ox && !e->vx) e->vx = 0, e->vy = 0;
if (oy && !e->vy) e->vx = 0, e->vy = 0;
}
if (!ents_alive_monsters()) e->kind = EK_NONE;
break;
case MV_BURROW: /* under the floor; comes up near him to shoot, then down again */
if (e->state == 0) {
e->flags |= EF_HIDDEN | EF_NOHIT | EF_INVULN;
if (e->t <= 0) {
for (int k = 0; k < 20; k++) {
float a = rndf() * 6.2831853f, r = 40 + rnd(40);
float x = pl.x + fcos(a) * r, y = pl.y + fsin(a) * r;
if (!solid_at(x, y, false)) {
e->x = x, e->y = y;
break;
}
}
e->state = 1, e->t = 50;
e->flags &= (uint16_t)~(EF_HIDDEN | EF_NOHIT | EF_INVULN);
}
} else {
if (e->t == 30) {
if (e->type == MON_ROUND_WORM) enemy_shot_at(e->x, e->y - 8, 4);
else if (e->type == MON_LUMP) enemy_shots_ring(e->x, e->y - 8, 6, 3, 0);
else if (e->type == MON_PARA_BITE || e->type == MON_NIGHT_CRAWLER) {
int pd = dir_to_player(e);
e->vx = DIR_X[pd] * 2, e->vy = DIR_Y[pd] * 2;
} else
enemy_shot_at(e->x, e->y - 8, 3.5f), enemy_shot_at(e->x + 3, e->y - 8, 3);
}
e->vx *= 0.9f, e->vy *= 0.9f;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, false, false);
if (e->t <= 0) e->state = 0, e->t = (int16_t)(30 + rnd(40));
}
break;
case MV_LEECH: /* races straight at him along a line */
if (e->state == 0 || e->t <= 0) {
e->c = (float)dir_to_player(e), e->state = 1, e->t = 40;
}
{
int dd = (int)e->c;
walk(e, DIR_X[dd], DIR_Y[dd], s, 0.2f);
if (e->vx == 0 && e->vy == 0) e->state = 0;
}
if (e->type == MON_KAMIKAZE_LEECH && d < e->r + 8) explode(e->x, e->y, 30, 20, true, 0), e->kind = EK_NONE;
break;
case MV_TETHER: { /* on a cord from where it began: lunges at him */
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.12f);
float ox = e->x - e->c, oy = e->y - e->b, od = fsqrt(ox * ox + oy * oy);
if (od > 60) e->x = e->c + ox / od * 60, e->y = e->b + oy / od * 60;
if (e->type == MON_MR_MAW && e->t <= 0 && d < 100) e->t = 60, enemy_shot_at(e->x, e->y - 8, 3.5f);
break;
}
case MV_WALL: /* along the walls, shooting across the room */
if (e->t <= 0) e->t = (int16_t)(40 + rnd(40)), e->c = (float)rnd(4);
{
int dd = (int)e->c;
walk(e, DIR_X[dd], DIR_Y[dd], s, 0.2f);
}
if (e->type == MON_WALL_CREEP && (e->t % 30) == 0 && aligned(e, 12)) {
int pd = dir_to_player(e);
enemy_shot(e->x, e->y - 6, DIR_X[pd] * 4, DIR_Y[pd] * 4, 0);
}
break;
case MV_GAPING: /* breathes him in */
if (d < 140) pl.vx -= dx * 0.12f, pl.vy -= dy * 0.12f;
break;
case MV_FATTY: { /* slow; a fat sack lets flies out, a pale one sprays */
float px, py;
path_dir(e->x, e->y, pl.x, pl.y, false, &px, &py);
walk(e, px, py, s, 0.1f);
if (e->type == MON_PALE_FATTY && e->t <= 0 && d < 100) e->t = 80, enemy_shots_ring(e->x, e->y - 10, 6, 2.5f, 0);
if (e->type == MON_FAT_SACK && e->t <= 0) e->t = 120, mon_spawn(MON_ATTACK_FLY, e->x, e->y - 10);
break;
}
case MV_KEEPER: /* hops at him and spits */
if (e->t <= 0) {
e->t = 45;
e->vx = dx * 3, e->vy = dy * 3;
enemy_shot_at(e->x, e->y - 10, 3.5f);
}
e->vx *= 0.88f, e->vy *= 0.88f;
move_ent(&e->x, &e->y, &e->vx, &e->vy, e->r, false, false);
break;
default: break;
}
}
bool mon_on_death(Ent *e) {
switch (e->type) {
case MON_MULLIGAN: case MON_HIVE:
for (int i = 0; i < 3 + rnd(3); i++) mon_spawn(MON_FLY, e->x + rnd(10) - 5, e->y + rnd(10) - 5);
break;
case MON_MOTER:
for (int i = 0; i < 2; i++) mon_spawn(MON_ATTACK_FLY, e->x + i * 6 - 3, e->y);
break;
case MON_BOOM_FLY:
explode(e->x, e->y, 30, 15, true, 0);
break;
case MON_RED_BOOM_FLY:
enemy_shots_ring(e->x, e->y - 8, 6, 3.5f, 0);
break;
case MON_SUCKER:
shot4(e, 3.5f, true);
break;
case MON_SPIT:
creep_spawn(e->x, e->y, 12, 150, true, 1);
break;
case MON_BIG_SPIDER:
for (int i = 0; i < 2; i++) mon_spawn(MON_SPIDER, e->x + i * 8 - 4, e->y);
break;
case MON_SQUIRT:
for (int i = 0; i < 2; i++) mon_spawn(MON_DIP, e->x + i * 8 - 4, e->y);
break;
case MON_CONJOINED_FATTY:
mon_spawn(MON_FATTY, e->x, e->y);
break;
case MON_SWARMER:
mon_spawn(MON_ATTACK_FLY, e->x, e->y);
break;
case MON_GLOBIN: case MON_RAGLING:
if (e->state == 0) { /* down, not dead: unless hurt again soon */
e->state = 1, e->t = 120, e->hp = e->maxhp * 0.3f, e->flags &= (uint16_t)~EF_NOHIT;
decal_blood(e->x, e->y, 6);
return false;
}
break;
case MON_FAT_SACK:
for (int i = 0; i < 2; i++) mon_spawn(MON_ATTACK_FLY, e->x, e->y);
break;
default: break;
}
return true;
}
/* ---------------------------------------------------------------- drawing */
void mon_draw(Ent *e) {
if (e->type >= MON_MONSTRO) {
boss_draw(e);
return;
}
const MonInfo *m = &mons[e->type];
int x = (int)e->x, y = (int)(e->y + e->z), flags = 0;
if (e->flags & EF_HIDDEN) {
if (m->moves == MV_MOMS_HAND && e->state == 1) /* its shadow, coming */
gfx_ellipse(x, (int)e->y, 12, 5, C_BLACK, 16);
else if (m->moves == MV_BURROW)
gfx_ellipse(x, (int)e->y, 5, 2, rgb565(0x3A2010), 16);
return;
}
if (e->vx < -0.1f) flags = GFX_FLIPX;
/* life: bobbing, squashing, wings */
int sx = 256, sy = 256, lift = 0;
if (e->flags & EF_FLYING) lift = 8 + (int)((g_frame + e->x) / 3) % 3;
switch (m->moves) {
case MV_CHASE: case MV_SKINNY: case MV_BONY: case MV_SPITTY: case MV_WANDER: case MV_GUSHER: case MV_FATTY:
case MV_TETHER: case MV_WALL: case MV_KNIGHT: case MV_CHARGER: case MV_VIS:
if (absf(e->vx) + absf(e->vy) > 0.2f) {
int k = (int)((g_frame + (int)e->c) / 3) % 4;
sy = 256 + (k == 1 ? 14 : k == 3 ? -14 : 0), sx = 512 - sy;
}
break;
case MV_HORF: if (e->t < 10) x += (g_frame & 1) ? 1 : -1; break;
case MV_HOST: if (e->state == 0) sy = 170, sx = 256; break;
case MV_CLOTTY: case MV_DIP: case MV_GLOBIN: {
int k = (int)(g_frame / 4 + e->x) % 6;
sy = 256 + (k < 3 ? k : 6 - k) * 10 - 15, sx = 512 - sy;
if (m->moves == MV_GLOBIN && e->state == 1) sy = 90, sx = 380;
break;
}
case MV_BOIL: sx = sy = 200 + (80 - e->t > 0 ? (80 - e->t) : 0); if (sx > 300) sx = sy = 300; break;
case MV_LEAPER: case MV_HOPPER: if (e->state == 0 && e->t < 6) sy = 220, sx = 290; break;
default: break;
}
uint16_t tint = 0;
int amount = 0;
if (e->flash) tint = rgb565(0xFF5050), amount = e->flash > 1 ? 14 : 8;
else if (e->freeze) tint = rgb565(0xC0C0C0), amount = 24;
else if (e->poison) tint = rgb565(0x40C040), amount = 12;
else if (e->flags & EF_CHAMPION) {
static const uint32_t champ[4] = {0xFF2020, 0xFFE020, 0x30C030, 0x202020};
tint = rgb565(champ[e->sub & 3]), amount = 14;
}
if (e->flags & EF_FRIEND && e->type != MON_BLUE_FLY) tint = rgb565(0xFF80C0), amount = 14;
if (e->type == MON_BLUE_FLY) tint = rgb565(0x4080FF), amount = 22;
gfx_sprite_scaled(e->spr, 0, x, y + 3 - lift, sx, sy, flags, tint, amount, e->alpha);
}