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
/* Entities: what the rooms hold (their records: tools/pack_ce.py Chapter.entity), after src/entities.c and berry.c,
* which port the game's own classes. Platforms move whole pixels and carry or push Madeline as Monocle's Solids do. */
#include "ce.h"
#include "fconst.h"
Ent *g_ents;
int g_nents;
static int trig_ox, trig_oy;
/* a record: u8 type, u8 size, s16 x, y, u16 w, h, u16 id, u8 nodes, (s16 x, y) each, u8 flags, u8 n, u16 vals */
#define REC_X(r) S16((r) + 2)
#define REC_Y(r) S16((r) + 4)
#define REC_W(r) (int)R16((r) + 6)
#define REC_H(r) (int)R16((r) + 8)
#define REC_ID(r) (int)R16((r) + 10)
#define REC_NODES(r) ((r)[12])
static const uint8_t *rec_node(const uint8_t *r, int i) { return r + 13 + 4 * i; }
static int rec_flags(const uint8_t *r) { return r[13 + 4 * r[12]]; }
static int rec_nvals(const uint8_t *r) { return r[14 + 4 * r[12]]; }
static int rec_val(const uint8_t *r, int i) { return (int)R16(r + 15 + 4 * r[12] + 2 * i); }
static bool kinds_stale = true;
Ent *ent_new(int type, int x, int y) {
Ent *e = NULL;
for (int i = 0; i < g_nents; i++)
if (g_ents[i].type == 255) { e = &g_ents[i]; break; }
if (!e) {
if (g_nents >= MAX_ENTS) return NULL;
e = &g_ents[g_nents++];
}
memset(e, 0, sizeof *e);
kinds_stale = true;
e->type = (uint8_t)type;
e->flags = EF_ACTIVE | EF_VISIBLE | EF_COLLIDABLE;
e->room = (uint8_t)g_level.slot;
e->x = x, e->y = y;
return e;
}
/* the entities of a kind (EF_SOLID, EF_JUMPTHRU...: a flag they are made with), in order: a count, then their
* indices; made again after entities come or go */
static uint8_t kinds[2][1 + MAX_ENTS];
const uint8_t *ents_kind(int flag) {
if (kinds_stale) {
kinds[0][0] = kinds[1][0] = 0;
for (int i = 0; i < g_nents; i++) {
const Ent *e = &g_ents[i];
if (e->type == 255) continue;
if (e->flags & EF_SOLID) kinds[0][++kinds[0][0]] = (uint8_t)i;
if (e->flags & EF_JUMPTHRU) kinds[1][++kinds[1][0]] = (uint8_t)i;
}
kinds_stale = false;
}
return kinds[flag == EF_SOLID ? 0 : 1];
}
void ents_kinds_stale(void) { kinds_stale = true; }
void ent_free(Ent *e) {
kinds_stale = true;
for (int k = 0; k < 2; k++) /* what it drew goes */
if (e->bb[k][0] < e->bb[k][2]) draw_gone_buf(k, e->bb[k][0], e->bb[k][1], e->bb[k][2], e->bb[k][3]);
e->type = 255;
e->flags = 0;
while (g_nents && g_ents[g_nents - 1].type == 255) g_nents--;
}
static void box(Ent *e, int w, int h, int x, int y) { e->hw = (int16_t)w, e->hh = (int16_t)h, e->hx = (int16_t)x, e->hy = (int16_t)y; }
bool rect_hits(int l, int t, int r, int b, const Ent *o) {
return r > e_left(o) && b > e_top(o) && l < e_right(o) && t < e_bottom(o);
}
bool ent_collide_at(const Ent *e, int x, int y, const Ent *o) {
int l = x + e->hx, t = y + e->hy;
return rect_hits(l, t, l + e->hw, t + e->hh, o);
}
/* ---------------------------------------------------------------- Madeline and the platforms */
extern bool player_riding(const Ent *s), player_riding_jumpthru(const Ent *j);
extern void player_push_h(int move, Ent *pusher), player_push_v(int move, Ent *pusher);
extern void player_carry_h(int move), player_carry_v(int move);
extern void player_set_lift(f32 lx, f32 ly);
extern bool player_climbing(void);
static Ent *pl(void) { return g_player.e && !g_player.dead ? g_player.e : NULL; }
static bool player_on_top(const Ent *s) { Ent *p = pl(); return p && ent_collide_at(s, s->x, s->y - 1, p); }
static bool player_climbing_on(const Ent *s) {
Ent *p = pl();
if (!p || !player_climbing()) return false;
return g_player.facing < 0 ? ent_collide_at(s, s->x + 1, s->y, p) : ent_collide_at(s, s->x - 1, s->y, p);
}
static void movers_move(Ent *p, int dx, int dy) { /* StaticMovers ride along */
for (int i = 0; i < g_nents; i++)
if (g_ents[i].type != 255 && g_ents[i].ptr == p && g_ents[i].type < 64) g_ents[i].x += dx, g_ents[i].y += dy;
}
static void solid_move_h_exact(Ent *s, int move) {
Ent *p = pl();
bool rider = p && (s->flags & EF_COLLIDABLE) && player_riding(s);
s->x += move;
movers_move(s, move, 0);
if (!(s->flags & EF_COLLIDABLE) || !p) return;
if (ent_collide_at(s, s->x, s->y, p)) {
int mv = move > 0 ? e_right(s) - e_left(p) : e_left(s) - e_right(p);
s->flags &= ~EF_COLLIDABLE;
player_push_h(mv, s);
player_set_lift(s->liftx, s->lifty);
s->flags |= EF_COLLIDABLE;
} else if (rider) {
s->flags &= ~EF_COLLIDABLE;
player_carry_h(move);
player_set_lift(s->liftx, s->lifty);
s->flags |= EF_COLLIDABLE;
}
}
static void solid_move_v_exact(Ent *s, int move) {
Ent *p = pl();
bool rider = p && (s->flags & EF_COLLIDABLE) && player_riding(s);
s->y += move;
movers_move(s, 0, move);
if (!(s->flags & EF_COLLIDABLE) || !p) return;
if (ent_collide_at(s, s->x, s->y, p)) {
int mv = move > 0 ? e_bottom(s) - e_top(p) : e_top(s) - e_bottom(p);
s->flags &= ~EF_COLLIDABLE;
player_push_v(mv, s);
player_set_lift(s->liftx, s->lifty);
s->flags |= EF_COLLIDABLE;
} else if (rider) {
s->flags &= ~EF_COLLIDABLE;
player_carry_v(move);
player_set_lift(s->liftx, s->lifty);
s->flags |= EF_COLLIDABLE;
}
}
/* Platform.MoveH/MoveV (amount: px, a float), the lift speed amount / DT unless given */
static void plat_move_h(Ent *s, f32 amount) {
s->liftx = f_div(amount, F_DT);
s->remx = f_add(s->remx, amount);
int n = f_round(s->remx);
if (n) s->remx = f_sub(s->remx, f_int(n)), solid_move_h_exact(s, n);
}
static void plat_move_v(Ent *s, f32 amount) {
s->lifty = f_div(amount, F_DT);
s->remy = f_add(s->remy, amount);
int n = f_round(s->remy);
if (n) s->remy = f_sub(s->remy, f_int(n)), solid_move_v_exact(s, n);
}
/* MoveVCollideSolids: down until something solid (or a jump-through) is in the way */
static bool plat_fall(Ent *s, f32 amount) {
s->lifty = f_div(amount, F_DT);
s->remy = f_add(s->remy, amount);
int n = f_round(s->remy);
if (!n) return false;
s->remy = f_sub(s->remy, f_int(n));
int sg = isign(n), moved = 0;
bool hit = false;
while (n) {
if (solid_at(e_left(s), e_top(s) + moved + sg, e_right(s), e_bottom(s) + moved + sg, s) ||
(sg > 0 && jumpthru_first_outside(s, s->x, s->y + moved + sg))) {
hit = true;
break;
}
moved += sg, n -= sg;
}
if (moved) solid_move_v_exact(s, moved);
return hit;
}
static void shake_update(Ent *s) { /* Platform.Shake: a new offset every 0.04 s while shaking */
if (s->sub & 0x80) {
if (g_level.frame % 2 == 0) s->a2 = (int16_t)(rndn(3) - 1), s->a3 = (int16_t)(rndn(3) - 1);
if (s->a1 > 0 && (s->a1 -= DTU) <= 0) s->sub &= 0x7F, s->a2 = s->a3 = 0;
}
}
static void shake_start(Ent *s, int time) { s->sub |= 0x80, s->a1 = (int16_t)time; }
static void shake_stop(Ent *s) { s->sub &= 0x7F, s->a2 = s->a3 = 0; }
/* ---------------------------------------------------------------- the leader (strawberries follow Madeline) */
#define MAX_FOLLOW 8
#define PAST 41
static int pastx[PAST], pasty[PAST], npast;
static Ent *fol[MAX_FOLLOW];
static int nfol;
static int fol_delay[MAX_FOLLOW];
static int fol_index(const Ent *e) {
for (int i = 0; i < nfol; i++)
if (fol[i] == e) return i;
return -1;
}
static void leader_update(void) {
Ent *p = g_player.e;
if (!p) return;
int x = p->x, y = p->y - 8;
if (g_level.frame % 2 == 0 && (npast == 0 || iabs(x - pastx[0]) + iabs(y - pasty[0]) >= 3)) { /* every 0.02 s */
memmove(pastx + 1, pastx, sizeof pastx - sizeof pastx[0]);
memmove(pasty + 1, pasty, sizeof pasty - sizeof pasty[0]);
pastx[0] = x, pasty[0] = y;
if (npast < PAST) npast++;
}
for (int i = 0, k = 5; i < nfol && k < npast; i++, k += 5) {
if (fol_delay[i] > 0) { fol_delay[i] -= DTU; continue; }
Ent *f = fol[i]; /* 1 - 0.01 ^ dt of the way, in 1/256 px */
f->t0 += (int)(((int32_t)(pastx[k] * 256 - f->t0) * 1210) >> 14);
f->t1 += (int)(((int32_t)(pasty[k] * 256 - f->t1) * 1210) >> 14);
f->x = f->t0 >> 8, f->y = f->t1 >> 8;
}
}
static void leader_lose(Ent *e) {
int i = fol_index(e);
if (i < 0) return;
memmove(fol + i, fol + i + 1, sizeof(Ent *) * (size_t)(nfol - i - 1));
memmove(fol_delay + i, fol_delay + i + 1, sizeof(int) * (size_t)(nfol - i - 1));
nfol--;
}
/* ---------------------------------------------------------------- strawberries */
enum { BERRY_GOLD = 1, BERRY_GHOST = 2, BERRY_WINGED = 4, BERRY_FLYING = 8, BERRY_COLLECTED = 16, BERRY_HOME = 32 };
typedef struct { uint16_t room_id; uint8_t index; } BerryKey;
extern bool save_has_berry(int chapter, int index);
extern void save_add_berry(int chapter, int index, bool golden);
extern int g_berries_now; /* this go's strawberries (the HUD) */
static void points_new(int x, int y, int index, bool ghost);
static int berry_anim(Ent *e, int which) { /* 0 idle, 1 collect, 2 flap */
int base = (e->sub & BERRY_GOLD) ? A_goldberry_idle : (e->sub & BERRY_GHOST) ? A_ghostberry_idle : A_strawberry_idle;
return base + (which == 0 ? 0 : which == 1 ? (A_strawberry_collect - A_strawberry_idle) : (A_strawberry_flap - A_strawberry_idle));
}
static void anim_step(Ent *e) { /* a0 anim, a1 frame, t3 timer (time units); a1 = -1: done */
const uint8_t *an = anim(e->a0);
int delay = (int)R16(an + 2);
if (!delay || e->a1 < 0) return;
e->t3 += DTU;
while (e->t3 >= delay && e->a1 >= 0) {
e->t3 -= delay;
if (e->a1 + 1 < an[0]) e->a1++;
else if (an[4] != 255) e->a0 = an[4], e->a1 = 0;
else if (an[1] & 1) e->a1 = 0;
else e->a1 = -1;
}
}
static int anim_sprite(const Ent *e) {
const uint8_t *an = anim(e->a0);
int f = e->a1 < 0 ? an[0] - 1 : imin(e->a1, an[0] - 1);
return (int)R16(an + 6 + 2 * f);
}
static void anim_play(Ent *e, int a) {
if (e->a0 == a && e->a1 >= 0) return;
e->a0 = (int16_t)a, e->a1 = 0, e->t3 = 0;
}
static void berry_collect(Ent *e) {
if (e->sub & BERRY_COLLECTED) return;
e->sub |= BERRY_COLLECTED;
int index = 0;
if (fol_index(e) >= 0) {
index = g_player.strawb_index++;
g_player.strawb_reset = TIM(2.5f);
leader_lose(e);
}
save_add_berry(g_level.chapter, rec_val(e->rec, 2), e->sub & BERRY_GOLD);
g_berries_now++;
e->t2 = index;
e->depth = -32000;
anim_play(e, berry_anim(e, 1));
}
static void berry_update(Ent *e) {
if (!(e->sub & BERRY_COLLECTED)) {
e->a2 = (int16_t)(e->a2 + 174); /* the wobble: 4 radians a second (16384ths of a turn) */
int f = fol_index(e);
if (f >= 0 && fol_delay[f] <= 0 && f == 0) {
Player *p = &g_player;
bool ok = !p->dead && ((e->sub & BERRY_GOLD) ? g_level.completed : p->on_safe_ground);
if (ok) {
if ((e->a3 += DTU) > TIM(.15f)) berry_collect(e);
} else if (e->a3 > 0)
e->a3 = 0;
} else if (e->sub & BERRY_WINGED) {
e->t1 += e->t2; /* flap speed, speed units */
int n = round_mu(e->t1, e->t2);
e->y += n, e->t1 -= n * MU;
if (e->sub & BERRY_FLYING) {
if (e->y < g_level.rooms[e->room].y - 16) { ent_free(e); return; }
e->t2 = imax(e->t2 - 1200 / 6, SPD(-200)) ;
} else {
e->t2 = approach(e->t2, SPD(20), 170);
int sy = e->rec ? g_level.rooms[e->room].y + REC_Y(e->rec) : e->y;
e->y = iclamp(e->y, sy - 5, sy + 5);
}
}
}
anim_step(e);
if ((e->sub & BERRY_COLLECTED) && e->a1 < 0) {
points_new(e->x, e->y, e->t2, e->sub & BERRY_GHOST);
ent_free(e);
}
}
static void berry_touch(Ent *e) {
if (fol_index(e) >= 0 || (e->sub & BERRY_COLLECTED) || nfol >= MAX_FOLLOW) return;
if (e->sub & BERRY_WINGED) e->sub &= ~(BERRY_WINGED | BERRY_FLYING), anim_play(e, berry_anim(e, 0));
fol[nfol] = e, fol_delay[nfol] = TIM(.3f), nfol++;
e->t0 = e->x * 256, e->t1 = e->y * 256;
e->depth = -32000;
}
static void berry_render(Ent *e) {
int y = e->y + ((e->sub & (BERRY_WINGED | BERRY_COLLECTED)) || fol_index(e) >= 0 ? 0 : sin15(((uint16_t)e->a2 >> 4) & 1023) * 2 / 32768);
const uint8_t *s = sprite(anim_sprite(e));
draw_sprite(s, e->x - s[0] / 2, y - s[1] / 2, 0);
}
/* the dash makes winged ones fly off */
void ents_on_dash(void) {
for (int i = 0; i < g_nents; i++) {
Ent *e = &g_ents[i];
if ((e->type == ET_strawberry || e->type == ET_goldenBerry) && (e->sub & BERRY_WINGED) && !(e->sub & BERRY_FLYING) &&
fol_index(e) < 0)
e->sub |= BERRY_FLYING, e->t2 = SPD(-200), e->depth = -32000;
}
}
/* the end of the chapter: what follows is collected */
void ents_collect_berries(void) {
while (nfol) berry_collect(fol[0]);
}
/* a death: the followers go home */
void ents_lose_followers(void) { nfol = 0, npast = 0; }
/* StrawberryPoints: "1000" and up, rising */
static void points_new(int x, int y, int index, bool ghost) {
Ent *e = ent_new(ET_strawberry, x, y);
if (!e) return;
e->type = 200;
e->room = 2;
e->flags = EF_ACTIVE | EF_VISIBLE;
e->depth = -32700;
e->a0 = (int16_t)(A_strawberry_fade0 + imin(index, 5));
(void)ghost;
}
static void points_update(Ent *e) {
e->t1 -= SPD(8);
int n = round_mu(e->t1, -1);
e->y += n, e->t1 -= n * MU;
e->x = iclamp(e->x, g_camx + 8, g_camx + 312), e->y = iclamp(e->y, g_camy + 8, g_camy + 172);
anim_step(e);
if (e->a1 < 0) ent_free(e);
}
/* ---------------------------------------------------------------- spikes */
static void spikes_touch(Ent *e) {
Player *p = &g_player;
switch (e->type) {
case ET_spikesUp: if (!f_negative(p->sy) && e_bottom(p->e) <= e_bottom(e)) player_die(0, -1); break;
case ET_spikesDown: if (!f_pos(p->sy)) player_die(0, 1); break;
case ET_spikesLeft: if (!f_negative(p->sx)) player_die(-1, 0); break;
case ET_spikesRight: if (!f_pos(p->sx)) player_die(1, 0); break;
}
}
static void spikes_render(Ent *e) {
const uint8_t *r = e->rec;
int n = rec_nvals(r), x = e->x + e->a2, y = e->y + e->a3;
if (e->ptr) x += ((Ent *)e->ptr)->a2, y += ((Ent *)e->ptr)->a3;
for (int j = 0; j < n; j++) {
const uint8_t *s = csprite(rec_val(r, j));
int fw = s[0], fh = s[1];
switch (e->type) {
case ET_spikesUp: draw_sprite(s, x + j * 8 + 4 - fw / 2, y + 1 - fh, 0); break;
case ET_spikesDown: draw_sprite(s, x + j * 8 + 4 - fw / 2, y - 1, 0); break;
case ET_spikesRight: draw_sprite(s, x - 1, y + j * 8 + 4 - fh / 2, 0); break;
case ET_spikesLeft: draw_sprite(s, x + 1 - fw, y + j * 8 + 4 - fh / 2, 0); break;
}
}
}
/* ---------------------------------------------------------------- tiles in a row or a box */
static void tiles_render(Ent *e, int first, int cols, int n, int ox, int oy) {
for (int i = 0; i < n; i++) draw_tile(rec_val(e->rec, first + i), e->x + ox + (i % cols) * 8, e->y + oy + (i / cols) * 8);
}
/* ---------------------------------------------------------------- spring */
static const uint8_t SPRING_SEQ[] = {0, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 4, 5};
static void spring_touch(Ent *e) {
if (e->type == ET_spring) {
if (f_negative(g_player.sy)) return;
player_super_bounce(e_top(e));
} else if (e->type == ET_wallSpringLeft)
player_side_bounce(1, e_right(e), e->y);
else
player_side_bounce(-1, e_left(e), e->y);
e->a0 = 1, e->t0 = 0; /* the animation */
e->t1 = 256; /* the wiggle */
}
static void spring_update(Ent *e) {
if (e->a0) {
e->t0 += DTU;
while (e->t0 >= TIM(.07f) && e->a0) {
e->t0 -= TIM(.07f);
if (++e->a0 > (int)sizeof SPRING_SEQ) e->a0 = 0;
}
}
if (e->t1 > 0) e->t1 = imax(e->t1 - 256 * DTU / TIM(1), 0);
}
static void spring_render(Ent *e) {
int f = e->a0 ? SPRING_SEQ[e->a0 - 1] : 0;
const uint8_t *s = sprite(S_objects_spring_00 + f);
int x = e->x, y = e->y;
if (e->ptr) x += ((Ent *)e->ptr)->a2, y += ((Ent *)e->ptr)->a3;
if (e->type == ET_spring) draw_sprite(s, x - 8, y - 16, 0);
else { /* on a wall: turned a quarter (the sprite is 16 x 16, its bottom against the wall) */
static uint8_t buf[6 + 16 * (1 + 16 * 3)];
(void)buf;
draw_sprite(s, e->type == ET_wallSpringLeft ? x - 8 : x - 8, y - 8, e->type == ET_wallSpringRight ? DF_FLIPX : 0);
}
}
/* ---------------------------------------------------------------- refill */
static void refill_touch(Ent *e) {
if (!player_use_refill(rec_flags(e->rec) & 1)) return;
e->flags &= ~EF_COLLIDABLE;
e->t0 = TIM(2.5f); /* respawn */
e->sub = 1;
level_freeze(TIM(.05f));
}
static void refill_update(Ent *e) {
if (e->sub == 1) e->sub = 2;
else if (e->sub == 2) {
level_shake(TIM(.3f) / DTU);
e->sub = 3;
e->depth = 8999;
if (rec_flags(e->rec) & 2) { ent_free(e); return; }
}
if (e->t0 > 0) {
e->t0 -= DTU;
if (e->t0 <= 0 && !(e->flags & EF_COLLIDABLE)) e->flags |= EF_COLLIDABLE, e->sub = 0, e->depth = -100;
}
e->t1 += DTU; /* frames: 0.1 s each */
e->t2 += DTU; /* the sine: 0.6 a second */
}
static void refill_render(Ent *e) {
if (e->sub >= 3 && !(e->flags & EF_COLLIDABLE)) {
draw_sprite(sprite(S_objects_refill_outline), e->x - 8, e->y - 8, 0);
return;
}
int y = e->y + sin15(e->t2 * 1024 / 1000) * 2 / 32768; /* SineWave(0.6) */
int f = e->t1 / TIM(.1f) % 5;
draw_sprite(sprite(S_objects_refill_idle00 + f), e->x - 8, y - 8, 0);
int fl = e->t1 % TIM(2); /* a flash every 2 s */
if (fl < 6 * TIM(.05f)) draw_sprite(sprite(S_objects_refill_flash00 + fl / TIM(.05f)), e->x - 8, y - 8, 0);
}
/* ---------------------------------------------------------------- crumble block */
/* sub: 0 waiting, 1 shaking (t0 particles left), 2 falling soon, 3 gone; t1 timer; a0 the player was on top */
static void crumble_update(Ent *e) {
switch (e->sub & 0x7F) {
case 0: {
bool top = player_on_top(e);
if (!top && !player_climbing_on(e)) break;
e->a0 = top;
e->t0 = top ? 1 : 3;
e->t1 = TIM(.2f);
e->t2 = top ? TIM(.6f) : TIM(1); /* the shake */
e->sub = 1;
break;
}
case 1:
if ((e->t1 -= DTU) > 0) break;
if (--e->t0) { e->t1 = TIM(.2f); break; }
e->t1 = TIM(.4f), e->sub = 2;
if (e->a0 && !player_on_top(e)) goto fall;
break;
case 2:
e->t1 -= DTU;
if (e->t1 <= 0 || (e->a0 && !player_on_top(e))) goto fall;
break;
case 3: /* back after 2 s, when nothing is in its way */
if ((e->t1 -= DTU) > 0) break;
if (pl() && ent_collide_at(e, e->x, e->y, pl())) break;
e->flags |= EF_COLLIDABLE;
e->sub = 0, e->t3 = 0;
break;
}
if (e->t2 > 0) e->t2 -= DTU;
if (e->sub == 3 || e->t3 < 0) e->t3 += DTU;
return;
fall:
e->flags &= ~EF_COLLIDABLE;
e->sub = 3, e->t1 = TIM(2), e->t3 = 0;
}
static void crumble_render(Ent *e) {
int n = rec_nvals(e->rec) / 2;
if (e->sub == 3) { /* the pieces fall (0.4 s, each group of four 0.05 s after the last), then the outline */
for (int i = 0; i < n; i++) {
int t = e->t3 - (i % 4) * TIM(.05f);
if (t < 0) t = 0;
if (t >= TIM(.4f)) continue;
int k = t * 256 / TIM(.4f), fall = k * k / 256 * k / 256 * (((e->x + i * 8) * 7 % 3 + 1) * 12) / 256;
draw_tile(rec_val(e->rec, i), e->x + i * 8, e->y + fall);
}
if (e->t3 > TIM(.25f)) tiles_render(e, n, n, n, 0, 0);
return;
}
for (int i = 0; i < n; i++) { /* shaking: each piece a pixel off at random (from the frame: drawing twice gives the same) */
int sx = 0, sy = 0;
if (e->t2 > 0) {
unsigned h = ((unsigned)g_level.frame * 37u + (unsigned)i * 11u + (unsigned)e->x) * 0x9E37u;
sx = (int)(h >> 9 & 0xFF) % 3 - 1, sy = (int)(h >> 3 & 0xFF) % 3 - 1;
}
draw_tile(rec_val(e->rec, i), e->x + i * 8 + sx, e->y + sy);
}
}
/* ---------------------------------------------------------------- falling block */
static bool fall_check(Ent *e) { return (rec_flags(e->rec) & 1) ? (pl() && player_riding(e)) : player_on_top(e); }
static void falling_update(Ent *e) {
shake_update(e);
switch (e->sub & 0x7F) {
case 0:
if (e->a0 || fall_check(e)) e->sub = (uint8_t)((e->sub & 0x80) | 1);
break;
case 1:
shake_start(e, 0);
e->t0 = TIM(.2f);
e->sub = 0x82;
break;
case 2:
if ((e->t0 -= DTU) > 0) break;
e->t0 = TIM(.4f);
e->sub = 0x83;
/* fall through */
case 3: {
bool wait = e->a0 || fall_check(e);
if (!wait && (rec_flags(e->rec) & 1) && pl()) wait = ent_collide_at(e, e->x - 1, e->y, pl()) || ent_collide_at(e, e->x + 1, e->y, pl());
if (e->t0 > 0 && wait) {
e->t0 -= DTU;
break;
}
shake_stop(e);
e->ptr2 = 0;
e->sub = 4;
break;
}
case 4: {
Room *rm = &g_level.rooms[e->room];
e->ptr2 = f_approach(e->ptr2, F_MaxFall, f_mul(F_DuckFriction, F_DT)); /* Approach(speed, 160, 500 * DT) */
if (plat_fall(e, f_mul(e->ptr2, F_DT))) {
level_dir_shake(0, 1, TIM(.3f) / DTU);
shake_start(e, 0);
e->t0 = TIM(.2f);
e->sub = 0x85;
break;
}
if (e_top(e) > rm->y + rm->h + 16 || (e_top(e) > rm->y + rm->h - 1 && solid_at(e_left(e), e_top(e) + 1, e_right(e), e_bottom(e) + 1, e))) {
for (int i = 0; i < g_nents; i++)
if (g_ents[i].ptr == e) ent_free(&g_ents[i]);
ent_free(e);
}
break;
}
case 5:
if ((e->t0 -= DTU) > 0) break;
shake_stop(e);
if (tiles_solid(e_left(e), e_bottom(e), e_right(e), e_bottom(e) + 1)) {
e->sub = 7;
e->flags |= EF_SAFE;
break;
}
e->sub = 6, e->t0 = 0;
/* fall through */
case 6:
if ((e->t0 -= DTU) > 0) break;
if (solid_at(e_left(e), e_top(e) + 1, e_right(e), e_bottom(e) + 1, e) || jumpthru_first_outside(e, e->x, e->y + 1)) {
e->t0 = TIM(.1f);
break;
}
e->sub = 1;
break;
}
}
static void block_render(Ent *e) { tiles_render(e, 0, REC_W(e->rec) / 8, rec_nvals(e->rec), e->a2, e->a3); }
/* ---------------------------------------------------------------- dash block: breaks when dashed into */
void ents_dash_into(Ent *hit, int dx, int dy, bool *rebound) {
*rebound = false;
if (!hit || hit->type != ET_dashBlock || !(rec_flags(hit->rec) & 2)) return;
(void)dx, (void)dy;
level_shake(TIM(.2f) / DTU);
ent_free(hit);
*rebound = true;
}
/* ---------------------------------------------------------------- fake walls: fade when entered */
static void fakewall_update(Ent *e) {
Ent *p = pl();
bool in = p && ent_collide_at(e, e->x, e->y, p);
if (e->type == ET_coverupWall) {
e->t0 = approach(e->t0, in ? 0 : 256, 256 * 4 * DTU / TIM(1));
return;
}
if (e->sub) {
e->t0 = approach(e->t0, 0, 256 * 2 * DTU / TIM(1));
if (e->t0 <= 0) ent_free(e);
} else if (in)
e->sub = 1;
}
static void fakewall_render(Ent *e) {
/* no blending at 8 bits: shown while more than half there, then gone (fades in a frame or two) */
if (e->t0 > 128) block_render(e);
}
/* ---------------------------------------------------------------- jump-through */
static void jumpthru_render(Ent *e) { tiles_render(e, 0, 64, rec_nvals(e->rec), 0, 0); }
/* ---------------------------------------------------------------- zip mover */
/* sub: step (bit 7: shaking); t0 the frame of its move (its Ease.SineIn: ZIP_OUT and ZIP_BACK, worked out as the game
* works them, in tools/fconst.py), t1 a wait; a0 its light */
static const f32 zip_out[ZIP_OUT_N] = ZIP_OUT, zip_back[ZIP_BACK_N] = ZIP_BACK;
static void zip_moveto(Ent *e, bool back, f32 pct) { /* Platform.MoveTo(Vector2.Lerp(from, to, pct)) */
Room *rm = &g_level.rooms[e->room];
f32 sx = f_int(rm->x + REC_X(e->rec)), sy = f_int(rm->y + REC_Y(e->rec));
const uint8_t *n = rec_node(e->rec, 0);
f32 tx = f_int(rm->x + S16(n)), ty = f_int(rm->y + S16(n + 2));
f32 x = back ? f_lerp(tx, sx, pct) : f_lerp(sx, tx, pct), y = back ? f_lerp(ty, sy, pct) : f_lerp(sy, ty, pct);
plat_move_h(e, f_sub(x, f_add(f_int(e->x), e->remx)));
plat_move_v(e, f_sub(y, f_add(f_int(e->y), e->remy)));
}
#define ZIP_PATH 201 /* (its path: ropes and cogs, an entity of its own behind it) */
#define F_4096 0x45800000ul
static void zip_update(Ent *e) {
shake_update(e);
e->liftx = e->lifty = 0;
int st = e->sub & 0x7F;
switch (st) {
case 0:
if (!(pl() && player_riding(e))) break;
shake_start(e, TIM(.1f));
e->t1 = TIM(.1f), st = 1;
break;
case 1:
if ((e->t1 -= DTU) > 0) break;
e->a0 = 3, e->t0 = 0, st = 2;
break;
case 2: /* there in half a second, Ease.SineIn */
zip_moveto(e, false, zip_out[e->t0]);
e->a1 = (int16_t)f_round(f_mul(zip_out[e->t0], F_4096)); /* (its percent, in 4096ths) */
if (++e->t0 >= ZIP_OUT_N) {
shake_start(e, TIM(.2f));
level_shake(TIM(.3f) / DTU);
e->t1 = TIM(.5f), st = 3;
}
break;
case 3:
if ((e->t1 -= DTU) > 0) break;
e->a0 = 2, e->t0 = 0, st = 4;
break;
case 4: /* back in two seconds */
zip_moveto(e, true, zip_back[e->t0]);
e->a1 = (int16_t)(4096 - f_round(f_mul(zip_back[e->t0], F_4096)));
if (++e->t0 >= ZIP_BACK_N) {
shake_start(e, TIM(.2f));
e->a0 = 1, e->t1 = TIM(.5f), st = 5;
}
break;
case 5:
if ((e->t1 -= DTU) > 0) break;
st = 0;
break;
}
e->sub = (uint8_t)((e->sub & 0x80) | st);
}
/* ZipMover.Render: black inside, cogs turning in it (12 frames; every other one the other way, at half brightness;
* those on the sides cut so they stay inside), the block's edges, the light on top. Its pictures: the record's values
* (tools/pack_ce.py zip_sprites). a1: its percent (4096ths) */
static void zip_render(Ent *e) {
int x = e->x + e->a2, y = e->y + e->a3, w = e->hw, h = e->hh, p = e->a1;
draw_rect(x + 1, y + 1, w - 2, h - 2, BLACK);
int blk = rec_val(e->rec, 0), inner = rec_val(e->rec, 2);
int c0 = g_clip_x0, c1 = g_clip_x1, r0 = g_clip_y0, r1 = g_clip_y1;
g_clip_x0 = imax(c0, x + 1 - g_camx), g_clip_x1 = imin(c1, x + w - 1 - g_camx);
g_clip_y0 = imax(r0, y + 1 - g_camy), g_clip_y1 = imin(r1, y + h - 1 - g_camy);
if (g_clip_x0 < g_clip_x1 && g_clip_y0 < g_clip_y1) {
int num = 1, k = 0;
for (int i = 4; i <= h - 4; i += 8) {
int num3 = num;
for (int j = 4; j <= w - 4; j += 8, k++) {
/* frame: (pi / 3 a cog + num percent 4 pi) / (pi / 2), its fraction in twelfths */
int f = fdiv(8 * k * 4096 + num * 96 * p, 4096) % 12;
if (f < 0) f += 12;
int lx = j <= 4 ? j - 5 : j >= w - 4 ? j - 7 : j - 6, ly = i <= 4 ? i - 5 : i >= h - 4 ? i - 7 : i - 6;
draw_sprite(csprite(inner + f + (num < 0 ? 12 : 0)), x + lx, y + ly, 0);
num = -num;
}
if (num3 == num) num = -num;
}
}
g_clip_x0 = c0, g_clip_x1 = c1, g_clip_y0 = r0, g_clip_y1 = r1;
for (int k = 0; k * 8 < w; k++)
for (int l = 0; l * 8 < h; l++) {
int a = k == 0 ? 0 : k * 8 + 8 != w ? 1 : 2, b = l == 0 ? 0 : l * 8 + 8 != h ? 1 : 2;
if (a != 1 || b != 1) draw_sprite(csprite(blk + a + 3 * b), x + k * 8, y + l * 8, 0);
}
draw_sprite(csprite(rec_val(e->rec, 1) + e->a0), x + w / 2 - 4, y, 0);
}
/* ---------------------------------------------------------------- pictures: checkpoint, memorial, bonfire */
/* a picture with its bottom middle at the place, or its frames in turn (values: first sprite, frames, time a frame) */
static void picture_render(Ent *e) {
int n = rec_val(e->rec, 1), f = n > 1 ? (int)(g_level.frame * DTU / (unsigned)rec_val(e->rec, 2) % (unsigned)n) : 0;
const uint8_t *sp = csprite(rec_val(e->rec, 0) + f);
draw_sprite(sp, e->x - sp[0] / 2, e->y - sp[1], 0);
}
/* ---------------------------------------------------------------- wire */
/* Wire: a curve from its place to its node sagging 24 px in the middle (SimpleCurve, its control point there: no wind
* in this chapter), drawn as 16 lines in its colour (WIRE: 595866) */
static void wire_render(Ent *e) {
Room *rm = &g_level.rooms[e->room];
const uint8_t *n = rec_node(e->rec, 0);
int bx = rm->x + REC_X(e->rec), by = rm->y + REC_Y(e->rec), ex = rm->x + S16(n), ey = rm->y + S16(n + 2);
int cx = bx + ex, cy = by + ey + 48; /* (the control point in half pixels) */
int px = bx, py = by;
for (int i = 1; i <= 16; i++) { /* (1 - t)^2 b + 2 (1 - t) t c + t^2 e, t = i / 16, in 1/512 px */
int u = 16 - i;
int qx = (u * u * 2 * bx + 2 * u * i * cx + i * i * 2 * ex + 256) >> 9;
int qy = (u * u * 2 * by + 2 * u * i * cy + i * i * 2 * ey + 256) >> 9;
draw_line(px, py, qx, qy, (uint8_t)e->a0);
px = qx, py = qy;
}
}
/* ZipMoverPathRenderer (depth 5000): the two ropes with their teeth moving along them, a cog at each end turning a
* full turn as it goes; all once more in black a pixel lower first, and a black frame round the block after */
static void zippath_lines(Ent *path, Ent *z, int fx, int fy, int tx, int ty, int off, bool black) {
if (!path->t2) { /* (its length and direction, once) */
int dx = tx - fx, dy = ty - fy;
path->t2 = isqrt24(dx * dx + dy * dy) + 1;
path->t0 = path->t2 > 1 ? dx * 256 / (path->t2 - 1) : 0, path->t1 = path->t2 > 1 ? dy * 256 / (path->t2 - 1) : 0;
}
int len = path->t2 - 1, ux = path->t0, uy = path->t1; /* (1/256 px) */
int px = -uy, py = ux; /* Perpendicular */
int ax = fx * 256 + px * 3, ay = (fy + off) * 256 + py * 3, bx = fx * 256 - px * 4, by = (fy + off) * 256 - py * 4;
int ex = (tx - fx) * 256, ey = (ty - fy) * 256;
uint8_t rope = black ? BLACK : ROPE, light = black ? BLACK : ROPE_LIGHT;
#define PX(v) (((v) + 128) >> 8)
draw_line(PX(ax), PX(ay), PX(ax + ex), PX(ay + ey), rope);
draw_line(PX(bx), PX(by), PX(bx + ex), PX(by + ey), rope);
/* the teeth: 2 px every 4 along each, starting 4 - (percent 8 pi) % 4 in */
int n = 1024 - (int)((long)z->a1 * 1608 / 1024 % 1024); /* (1/256 px) */
for (; n < len * 256; n += 1024) {
int sx = ax + px + (ux * n >> 8), sy = ay + py + (uy * n >> 8);
int qx = bx + ex - (ux * n >> 8), qy = by + ey - (uy * n >> 8);
draw_line(PX(sx), PX(sy), PX(sx + ux * 2), PX(sy + uy * 2), light);
draw_line(PX(qx), PX(qy), PX(qx - ux * 2), PX(qy - uy * 2), light);
}
#undef PX
int cog = rec_val(z->rec, 3) + ((z->a1 + 64) >> 7 & 31) + (black ? 32 : 0);
draw_sprite(csprite(cog), fx - 9, fy + off - 9, 0);
draw_sprite(csprite(cog), tx - 9, ty + off - 9, 0);
}
static void zippath_render(Ent *e) {
Ent *z = e->ptr;
Room *rm = &g_level.rooms[z->room];
const uint8_t *n = rec_node(z->rec, 0);
int w = z->hw, h = z->hh;
int fx = rm->x + REC_X(z->rec) + w / 2, fy = rm->y + REC_Y(z->rec) + h / 2;
int tx = rm->x + S16(n) + w / 2, ty = rm->y + S16(n + 2) + h / 2;
zippath_lines(e, z, fx, fy, tx, ty, 1, true);
zippath_lines(e, z, fx, fy, tx, ty, 0, false);
draw_rect(z->x + z->a2 - 1, z->y + z->a3 - 1, w + 2, h + 2, BLACK);
}
/* ---------------------------------------------------------------- triggers */
static void trig_enter(Ent *e) {
switch (e->type - 64) {
case TT_cameraOffsetTrigger:
g_level.cam_offx = (int16_t)rec_val(e->rec, 0), g_level.cam_offy = (int16_t)rec_val(e->rec, 1);
break;
case TT_changeRespawnTrigger: {
const uint8_t *n = REC_NODES(e->rec) ? rec_node(e->rec, 0) : NULL;
int tx = n ? g_level.rooms[e->room].x + S16(n) : e->x + e->hw / 2, ty = n ? g_level.rooms[e->room].y + S16(n + 2) : e->y + e->hh / 2;
if (!solid_at(tx, ty - 4, tx + 1, ty - 3, NULL)) g_level.respawn_x = e->t0, g_level.respawn_y = e->t1;
(void)tx;
break;
}
case TT_eventTrigger:
if (rec_val(e->rec, 0) == EV_end_city) {
extern void game_chapter_end(void);
game_chapter_end();
}
break;
}
}
static void trig_stay(Ent *e) {
if (e->type - 64 != TT_cameraTargetTrigger) return;
Ent *p = g_player.e;
int px = (e_left(p) + e_right(p)) / 2, py = (e_top(p) + e_bottom(p)) / 2;
int l = e_left(e), r = e_right(e), t = e_top(e), b = e_bottom(e), cx = (l + r) / 2, cy = (t + b) / 2;
#define CMAP(v, a, bb) iclamp(((v) - (a)) * 256 / ((bb) - (a)), 0, 256)
int k;
switch (rec_val(e->rec, 1)) {
case 1: k = CMAP(px, l, r); break;
case 2: k = CMAP(px, r, l); break;
case 3: k = CMAP(py, t, b); break;
case 4: k = CMAP(py, b, t); break;
case 5: k = imin(CMAP(px, l, cx), CMAP(px, r, cx)); break;
case 6: k = imin(CMAP(py, t, cy), CMAP(py, b, cy)); break;
default: k = 256;
}
#undef CMAP
const uint8_t *n = rec_node(e->rec, 0);
extern int g_anchor_x, g_anchor_y, g_anchor_lerp;
extern uint8_t g_anchor_ignore;
g_anchor_x = g_level.rooms[e->room].x + S16(n) - 160, g_anchor_y = g_level.rooms[e->room].y + S16(n + 2) - 90;
g_anchor_lerp = iclamp(rec_val(e->rec, 0) * k / 256, 0, 256);
g_anchor_ignore = (uint8_t)(rec_flags(e->rec) & 3); /* 1 x only (ignore y), 2 y only (ignore x) */
}
static void trig_leave(Ent *e) {
if (e->type - 64 != TT_cameraTargetTrigger) return;
for (int i = 0; i < g_nents; i++)
if (&g_ents[i] != e && g_ents[i].type == 64 + TT_cameraTargetTrigger && (g_ents[i].sub & 1)) return;
extern int g_anchor_lerp;
g_anchor_lerp = 0;
}
/* ---------------------------------------------------------------- spawning a room */
static Ent *spawn(const uint8_t *r, int slot, bool trigger) {
Room *rm = &g_level.rooms[slot];
int type = r[0], x = rm->x + REC_X(r), y = rm->y + REC_Y(r), w = REC_W(r), h = REC_H(r);
if (trigger) {
Ent *e = ent_new(64 + type, x, y);
if (!e) return NULL;
e->rec = r, e->room = (uint8_t)slot;
e->flags = EF_ACTIVE | EF_TRIGGER | EF_COLLIDABLE;
box(e, w, h, 0, 0);
if (type == TT_changeRespawnTrigger) { /* the spawn point nearest its node (or middle) */
const uint8_t *n = REC_NODES(r) ? rec_node(r, 0) : NULL;
int tx = n ? rm->x + S16(n) : x + w / 2, ty = n ? rm->y + S16(n + 2) : y + h / 2;
const uint8_t *p = rm->ents;
int best = -1;
int32_t bd = 0;
p++;
for (int i = 0; i < rm->ents[0]; i++, p += p[1]) {
if (p[0] != ET_player) continue;
int sx = rm->x + S16(p + 2), sy = rm->y + S16(p + 4);
int32_t d = (int32_t)(sx - tx) * (sx - tx) + (int32_t)(sy - ty) * (sy - ty);
if (best < 0 || d < bd) best = i, bd = d, e->t0 = sx, e->t1 = sy;
}
}
return e;
}
Ent *e = ent_new(type, x, y);
if (!e) return NULL;
e->rec = r, e->room = (uint8_t)slot;
int fl = rec_flags(r);
switch (type) {
case ET_player: ent_free(e); return NULL;
case ET_spikesUp: box(e, w, 3, 0, -3), e->depth = -1, e->flags |= EF_PCOLLIDE; break;
case ET_spikesDown: box(e, w, 3, 0, 0), e->depth = -1, e->flags |= EF_PCOLLIDE; break;
case ET_spikesLeft: box(e, 3, h, -3, 0), e->depth = -1, e->flags |= EF_PCOLLIDE; break;
case ET_spikesRight: box(e, 3, h, 0, 0), e->depth = -1, e->flags |= EF_PCOLLIDE; break;
case ET_jumpThru: box(e, w, 5, 0, 0), e->depth = -60, e->flags |= EF_JUMPTHRU | EF_SAFE; break;
case ET_strawberry:
case ET_goldenBerry:
box(e, 14, 14, -7, -7), e->depth = -100, e->flags |= EF_PCOLLIDE;
if (type == ET_goldenBerry) e->sub |= BERRY_GOLD;
else if (save_has_berry(g_level.chapter, rec_val(r, 2))) e->sub |= BERRY_GHOST;
if (fl & 1) e->sub |= BERRY_WINGED;
e->a0 = (int16_t)berry_anim(e, (fl & 1) ? 2 : 0);
break;
case ET_refill: box(e, 16, 16, -8, -8), e->depth = -100, e->flags |= EF_PCOLLIDE; break;
case ET_spring: box(e, 16, 6, -8, -6), e->depth = -8501, e->flags |= EF_PCOLLIDE; break;
case ET_wallSpringLeft: box(e, 6, 16, 0, -8), e->depth = -8501, e->flags |= EF_PCOLLIDE; break;
case ET_wallSpringRight: box(e, 6, 16, -6, -8), e->depth = -8501, e->flags |= EF_PCOLLIDE; break;
case ET_crumbleBlock: box(e, w, 8, 0, 0), e->flags |= EF_SOLID; break;
case ET_fallingBlock: box(e, w, h, 0, 0), e->flags |= EF_SOLID, e->depth = (fl & 2) ? 5000 : 0; break;
case ET_dashBlock: box(e, w, h, 0, 0), e->flags |= EF_SOLID, e->depth = -12999; break;
case ET_fakeWall: box(e, w, h, 0, 0), e->flags &= ~EF_COLLIDABLE, e->depth = -13000, e->t0 = 256; break;
case ET_coverupWall: box(e, w, h, 0, 0), e->flags &= ~EF_COLLIDABLE, e->depth = -13000, e->t0 = 256; break;
case ET_checkpoint: case ET_memorial: case ET_bonfire: { /* (Checkpoint 9990, Memorial 100, the campfire -5) */
const uint8_t *sp = csprite(rec_val(r, 0));
e->flags = EF_VISIBLE, e->depth = type == ET_checkpoint ? 9990 : type == ET_memorial ? 100 : -5;
box(e, sp[0], sp[1], -sp[0] / 2, -sp[1]);
break;
}
case ET_wire: { /* (its box round the curve: both ends, and the sag) */
const uint8_t *n = rec_node(r, 0);
int ex = rm->x + S16(n), ey = rm->y + S16(n + 2);
e->flags = EF_VISIBLE, e->depth = (fl & 1) ? -8500 : 2000, e->a0 = WIRE;
box(e, iabs(ex - x) + 1, iabs(ey - y) + 26, imin(ex, x) - x, imin(ey, y) - y);
break;
}
case ET_zipMover: {
box(e, w, h, 0, 0), e->flags |= EF_SOLID, e->depth = -9999, e->a0 = 1;
Ent *p = ent_new(ZIP_PATH, x, y); /* (its box round both ends, for leaving it out when far) */
if (p) {
const uint8_t *n = rec_node(r, 0);
int tx = rm->x + S16(n), ty = rm->y + S16(n + 2);
p->flags = EF_VISIBLE, p->room = (uint8_t)slot, p->depth = 5000, p->ptr = e;
box(p, iabs(tx - x) + w, iabs(ty - y) + h, imin(tx, x) - x, imin(ty, y) - y);
}
break;
}
default:
e->flags = EF_ACTIVE | EF_VISIBLE; /* scenery not drawn yet */
e->type = 100;
break;
}
return e;
}
/* StaticMover: spikes and springs stuck to a solid move with it */
static void attach_movers(int slot) {
for (int i = 0; i < g_nents; i++) {
Ent *m = &g_ents[i];
if (m->room != slot || !((m->type >= ET_spikesUp && m->type <= ET_spikesRight) || m->type == ET_spring ||
m->type == ET_wallSpringLeft || m->type == ET_wallSpringRight))
continue;
int dx = 0, dy = 0;
switch (m->type) {
case ET_spikesUp: case ET_spring: dy = 1; break;
case ET_spikesDown: dy = -1; break;
case ET_spikesLeft: case ET_wallSpringRight: dx = 1; break;
case ET_spikesRight: case ET_wallSpringLeft: dx = -1; break;
}
for (int j = 0; j < g_nents; j++) {
Ent *s = &g_ents[j];
if (s->room != slot || !(s->flags & EF_SOLID) || s->type == 255) continue;
if (ent_collide_at(m, m->x + dx, m->y + dy, s) && !ent_collide_at(m, m->x, m->y, s)) {
m->ptr = s;
if (m->type >= ET_spring) m->depth = (int16_t)(s->depth + 1);
break;
}
}
}
}
void ents_spawn_room(int slot) {
Room *rm = &g_level.rooms[slot];
const uint8_t *p = rm->ents;
int n = *p++;
for (int i = 0; i < n; i++, p += p[1]) spawn(p, slot, false);
p = rm->trigs;
n = *p++;
for (int i = 0; i < n; i++, p += p[1]) spawn(p, slot, true);
attach_movers(slot);
(void)trig_ox, (void)trig_oy;
}
void ents_remove_room(int slot) {
for (int i = 0; i < g_nents; i++) {
Ent *e = &g_ents[i];
if (e->type != 255 && e->room == slot && fol_index(e) < 0) ent_free(e);
}
}
void ents_clear(void) {
g_nents = 0;
nfol = npast = 0;
}
/* ---------------------------------------------------------------- the frame */
void ents_update(void) {
for (int i = 0; i < g_nents; i++) {
Ent *e = &g_ents[i];
if (e->type == 255 || !(e->flags & EF_ACTIVE)) continue;
BENCH(11);
switch (e->type) {
case ET_player: player_update(); BENCH(12); break;
case ET_strawberry: case ET_goldenBerry: berry_update(e); break;
case ET_spring: case ET_wallSpringLeft: case ET_wallSpringRight: spring_update(e); break;
case ET_refill: refill_update(e); break;
case ET_crumbleBlock: crumble_update(e); break;
case ET_fallingBlock: falling_update(e); break;
case ET_fakeWall: case ET_coverupWall: fakewall_update(e); break;
case ET_zipMover: zip_update(e); break;
case 200: points_update(e); break;
}
BENCH(13);
}
leader_update();
extern void player_after_update(void);
player_after_update();
BENCH(14);
}
/* PlayerCollider and triggers: what Madeline (her hurt box) touches */
void ents_player_touch(Ent *p) {
for (int i = 0; i < g_nents && !g_player.dead; i++) {
Ent *e = &g_ents[i];
if (e->type == 255 || !(e->flags & EF_COLLIDABLE)) continue;
bool hit = ent_collide_at(p, p->x, p->y, e);
if (e->flags & EF_TRIGGER) {
if (hit) {
if (!(e->sub & 1)) e->sub |= 1, trig_enter(e);
trig_stay(e);
} else if (e->sub & 1)
e->sub &= ~1, trig_leave(e);
continue;
}
if (!hit || !(e->flags & EF_PCOLLIDE)) continue;
switch (e->type) {
case ET_spikesUp: case ET_spikesDown: case ET_spikesLeft: case ET_spikesRight: spikes_touch(e); break;
case ET_strawberry: case ET_goldenBerry: berry_touch(e); break;
case ET_spring: case ET_wallSpringLeft: case ET_wallSpringRight: spring_touch(e); break;
case ET_refill: refill_touch(e); break;
}
}
}
static void ent_draw(Ent *e) {
switch (e->type) {
case ET_player: player_render(); break;
case ET_spikesUp: case ET_spikesDown: case ET_spikesLeft: case ET_spikesRight: spikes_render(e); break;
case ET_jumpThru: jumpthru_render(e); break;
case ET_strawberry: case ET_goldenBerry: berry_render(e); break;
case ET_spring: case ET_wallSpringLeft: case ET_wallSpringRight: spring_render(e); break;
case ET_refill: refill_render(e); break;
case ET_crumbleBlock: crumble_render(e); break;
case ET_fallingBlock: case ET_dashBlock: block_render(e); break;
case ET_fakeWall: case ET_coverupWall: fakewall_render(e); break;
case ET_zipMover: zip_render(e); break;
case ZIP_PATH: zippath_render(e); break;
case ET_wire: wire_render(e); break;
case ET_checkpoint: case ET_memorial: case ET_bonfire: picture_render(e); break;
case 200: {
const uint8_t *s = sprite(anim_sprite(e));
draw_sprite(s, e->x - s[0] / 2, e->y - s[1] / 2, 0);
break;
}
}
}
int g_cull_buf = -1;
/* back to front: higher depths first, then the order they came in */
static uint8_t order[MAX_ENTS], norder;
/* roughly on the view: what each draws stays within 48 px of its box (Madeline's hair and death go further: she is
* always in) */
static bool ent_near(const Ent *e) {
if (e->type == ET_player) return true;
int l = e->x + e->hx - g_camx, t = e->y + e->hy - g_camy;
return l < VIEW_W + 48 && t < VIEW_H + 48 && l + e->hw > -48 && t + e->hh > -48;
}
void ents_order(void) {
norder = 0;
for (int i = 0; i < g_nents; i++) {
Ent *e = &g_ents[i];
if (e->type == 255 || !(e->flags & EF_VISIBLE) || !ent_near(e)) continue;
int k = norder++, d = e->depth;
while (k > 0 && g_ents[order[k - 1]].depth < d) order[k] = order[k - 1], k--;
order[k] = (uint8_t)i;
}
}
int g_rec_buf = -1;
static void bb_start(void) { g_bb[0] = g_bb[1] = 0x7FFF, g_bb[2] = g_bb[3] = -0x7FFF, g_bb_sum = 0; }
static void bb_keep(Ent *e, int buf) {
for (int k = 0; k < 4; k++) e->bb[buf][k] = (int16_t)iclamp(g_bb[k], -0x7FFF, 0x7FFF);
e->sum[buf] = g_bb_sum;
}
void ents_render(int dmax, int dmin) {
int cb = g_cull_buf, rb = g_rec_buf;
for (int k = 0; k < norder; k++) {
Ent *e = &g_ents[order[k]];
if (e->depth > dmax || e->depth <= dmin) continue;
if (cb >= 0 && (e->bb[cb][0] >= g_clip_x1 || e->bb[cb][2] <= g_clip_x0 || e->bb[cb][1] >= g_clip_y1 ||
e->bb[cb][3] <= g_clip_y0))
continue;
if (rb < 0) {
ent_draw(e);
continue;
}
bb_start(), g_rec = true; /* (drawn and measured) */
ent_draw(e);
g_rec = false, bb_keep(e, rb);
}
}
/* what each one would draw (its box and sum), drawing nothing */
static bool ent_static(const Ent *e) { /* what never changes how it looks (until it goes) */
switch (e->type) {
case ET_spikesUp: case ET_spikesDown: case ET_spikesLeft: case ET_spikesRight: return !e->ptr;
case ET_jumpThru: case ET_dashBlock: case ET_wire: return true;
case ET_checkpoint: case ET_memorial: case ET_bonfire: return rec_val(e->rec, 1) <= 1;
}
return false;
}
void ents_measure(int buf, void (*changed)(const int16_t *was, const int *now)) {
g_dry = g_rec = true;
for (int i = 0; i < g_nents; i++) {
Ent *e = &g_ents[i];
if (e->type == 255 || ent_static(e)) continue;
bb_start();
if ((e->flags & EF_VISIBLE) && ent_near(e)) ent_draw(e);
for (int k = 0; k < 4; k++) g_bb[k] = iclamp(g_bb[k], -0x7FFF, 0x7FFF);
int16_t *bb = e->bb[buf];
if (e->sum[buf] != g_bb_sum || bb[0] != g_bb[0] || bb[1] != g_bb[1] || bb[2] != g_bb[2] || bb[3] != g_bb[3]) {
changed(bb, g_bb);
bb_keep(e, buf);
}
}
g_dry = g_rec = false;
}
void ents_forget(int buf) {
for (int i = 0; i < g_nents; i++) g_ents[i].bb[buf][0] = 1, g_ents[i].bb[buf][2] = 0;
}