Skip to content

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.

Hollow Knight: the False Knight; scenes loaded with others

Mason Chen3df0d5cbb3da
diff --git a/games/hollowknight/src/data.bin b/games/hollowknight/src/data.bin
index c8b58ee0..53fd708e 100644
Binary files a/games/hollowknight/src/data.bin and b/games/hollowknight/src/data.bin differ
diff --git a/games/hollowknight/src/data.h b/games/hollowknight/src/data.h
index 6502e825..d460df6e 100644
--- a/games/hollowknight/src/data.h
+++ b/games/hollowknight/src/data.h
@@ -16,7 +16,8 @@
#define SEC_FONT 13
#define SEC_PHASH 14
#define SEC_SCOL 15
-#define NUM_ROOMS 41
+#define SEC_RVAR 16
+#define NUM_ROOMS 38
#define ROOM_TUTORIAL_01 0
#define ROOM_TOWN 1
#define ROOM_ROOM_SHOP 2
@@ -31,33 +32,30 @@
#define ROOM_CROSSROADS_06 11
#define ROOM_CROSSROADS_SHAMANTEMPLE 12
#define ROOM_CROSSROADS_10 13
-#define ROOM_CROSSROADS_10_BOSS 14
-#define ROOM_CROSSROADS_10_BOSS_DEFEATED 15
-#define ROOM_CROSSROADS_21 16
-#define ROOM_CROSSROADS_39 17
-#define ROOM_CROSSROADS_14 18
-#define ROOM_CROSSROADS_16 19
-#define ROOM_CROSSROADS_03 20
-#define ROOM_CROSSROADS_47 21
-#define ROOM_CROSSROADS_19 22
-#define ROOM_CROSSROADS_04 23
-#define ROOM_ROOM_RUINHOUSE 24
-#define ROOM_ROOM_CHARM_SHOP 25
-#define ROOM_CROSSROADS_08 26
-#define ROOM_CROSSROADS_30 27
-#define ROOM_CROSSROADS_11_ALT 28
-#define ROOM_FUNGUS1_01 29
-#define ROOM_FUNGUS1_01B 30
-#define ROOM_FUNGUS1_02 31
-#define ROOM_FUNGUS1_17 32
-#define ROOM_FUNGUS1_03 33
-#define ROOM_FUNGUS1_31 34
-#define ROOM_FUNGUS1_32 35
-#define ROOM_FUNGUS1_21 36
-#define ROOM_FUNGUS1_22 37
-#define ROOM_FUNGUS1_16_ALT 38
-#define ROOM_FUNGUS1_04 39
-#define ROOM_FUNGUS1_04_BOSS 40
+#define ROOM_CROSSROADS_21 14
+#define ROOM_CROSSROADS_39 15
+#define ROOM_CROSSROADS_14 16
+#define ROOM_CROSSROADS_16 17
+#define ROOM_CROSSROADS_03 18
+#define ROOM_CROSSROADS_47 19
+#define ROOM_CROSSROADS_19 20
+#define ROOM_CROSSROADS_04 21
+#define ROOM_ROOM_RUINHOUSE 22
+#define ROOM_ROOM_CHARM_SHOP 23
+#define ROOM_CROSSROADS_08 24
+#define ROOM_CROSSROADS_30 25
+#define ROOM_CROSSROADS_11_ALT 26
+#define ROOM_FUNGUS1_01 27
+#define ROOM_FUNGUS1_01B 28
+#define ROOM_FUNGUS1_02 29
+#define ROOM_FUNGUS1_17 30
+#define ROOM_FUNGUS1_03 31
+#define ROOM_FUNGUS1_31 32
+#define ROOM_FUNGUS1_32 33
+#define ROOM_FUNGUS1_21 34
+#define ROOM_FUNGUS1_22 35
+#define ROOM_FUNGUS1_16_ALT 36
+#define ROOM_FUNGUS1_04 37
#define CLIP_KNIGHT_IDLE 0
#define CLIP_KNIGHT_IDLE_HURT 1
#define CLIP_KNIGHT_IDLE_WIND 2
@@ -295,14 +293,48 @@
#define CLIP_GUARD_TURN 234
#define CLIP_GUARD_WAKE 235
#define CLIP_GUARD_WALK 236
-#define CLIP_BULLET_IDLE 237
-#define CLIP_BULLET_IMPACT 238
-#define CLIP_BULLET_SHOCKWAVE_SPURT 239
-#define SPRITE_HERO_LIGHT 1034
-#define SPRITE_DIALOGUE_BACKBOARD 1035
-#define SPRITE_PROMPT_SHADOW 1036
-#define SPRITE_CORPSE_NAIL 1037
-#define SPRITE_DIGIT0 1218
+#define CLIP_FK_ATTACK 237
+#define CLIP_FK_ATTACK_ANTIC 238
+#define CLIP_FK_ATTACK_RECOVER 239
+#define CLIP_FK_BLANK 240
+#define CLIP_FK_BODY 241
+#define CLIP_FK_DEATH_FALL 242
+#define CLIP_FK_DEATH_HEAD_1 243
+#define CLIP_FK_DEATH_HEAD_2 244
+#define CLIP_FK_DEATH_LAND 245
+#define CLIP_FK_DEATH_SPAZ 246
+#define CLIP_FK_IDLE 247
+#define CLIP_FK_JUMP 248
+#define CLIP_FK_JUMP_ANTIC 249
+#define CLIP_FK_JUMP_ATTACK_HIT_1 250
+#define CLIP_FK_JUMP_ATTACK_HIT_2 251
+#define CLIP_FK_JUMP_ATTACK_HIT_3 252
+#define CLIP_FK_JUMP_ATTACK_UP 253
+#define CLIP_FK_LAND 254
+#define CLIP_FK_RAGE 255
+#define CLIP_FK_RUN 256
+#define CLIP_FK_RUN_ANTIC 257
+#define CLIP_FK_STUN_HIT 258
+#define CLIP_FK_STUN_OPEN 259
+#define CLIP_FK_STUN_OPENED 260
+#define CLIP_FK_STUN_RECOVER 261
+#define CLIP_FK_STUN_ROLL 262
+#define CLIP_FK_STUN_ROLL_END 263
+#define CLIP_FK_TURN 264
+#define CLIP_FKHEAD_DEATH_LAND 265
+#define CLIP_FKHEAD_HEAD_HIT 266
+#define CLIP_FKHEAD_HEAD_IDLE 267
+#define CLIP_FKHEAD_HEAD_SPAZ 268
+#define CLIP_BULLET_IDLE 269
+#define CLIP_BULLET_IMPACT 270
+#define CLIP_BULLET_SHOCKWAVE_SPURT 271
+#define SPRITE_HERO_LIGHT 1129
+#define SPRITE_DIALOGUE_BACKBOARD 1130
+#define SPRITE_PROMPT_SHADOW 1131
+#define SPRITE_CORPSE_NAIL 1132
+#define SPRITE_FK_BARREL 1133
+#define SPRITE_FK_STAFF 1134
+#define SPRITE_DIGIT0 1321
#define STYLE_DIALOGUE 0
#define STYLE_PROMPT 1
#define TEXT_K 1.333333f
@@ -320,8 +352,10 @@
#define EK_HORNHEAD 11
#define EK_LEAPER 12
#define EK_GUARD 13
-#define NUM_KINDS 14
-#define KIND_TABLE {{0}, {EF_CRAWLER, {-1, 150, 149, -1, -1, -1, -1, -1, -1, -1, -1, 152, 153}}, {EF_BUZZER, {155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 157, 158}}, {EF_SHADE, {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, {EF_CLIMBER, {-1, -1, 165, 164, -1, -1, -1, -1, -1, -1, -1, 162, 163}}, {EF_BOUNCER, {-1, -1, -1, 168, -1, -1, -1, -1, -1, -1, -1, 166, 167}}, {EF_SPITTER, {-1, -1, -1, 171, 172, 170, -1, -1, -1, -1, -1, 169, -1}}, {EF_ROLLER, {175, -1, -1, 177, 176, 178, -1, -1, -1, -1, -1, 173, 174}}, {EF_BLOCKER, {185, -1, -1, 181, 186, 179, 180, 187, 188, 184, 183, -1, 182}}, {EF_HUSK, {194, 195, 196, 189, 191, 190, -1, -1, -1, -1, -1, 192, 193}}, {EF_HUSK, {202, 203, 204, 197, 199, 198, -1, -1, -1, -1, -1, 200, 201}}, {EF_HUSK, {210, 211, 212, 205, 207, 206, -1, -1, -1, -1, -1, 208, 209}}, {EF_LEAPER, {216, 218, 219, 213, 217, -1, -1, -1, -1, -1, -1, 214, 215}}, {EF_GUARD, {225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 222, 223}}}
+#define EK_FK 14
+#define EK_FKHEAD 15
+#define NUM_KINDS 16
+#define KIND_TABLE {{0}, {EF_CRAWLER, {-1, 150, 149, -1, -1, -1, -1, -1, -1, -1, -1, 152, 153}}, {EF_BUZZER, {155, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 157, 158}}, {EF_SHADE, {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}, {EF_CLIMBER, {-1, -1, 165, 164, -1, -1, -1, -1, -1, -1, -1, 162, 163}}, {EF_BOUNCER, {-1, -1, -1, 168, -1, -1, -1, -1, -1, -1, -1, 166, 167}}, {EF_SPITTER, {-1, -1, -1, 171, 172, 170, -1, -1, -1, -1, -1, 169, -1}}, {EF_ROLLER, {175, -1, -1, 177, 176, 178, -1, -1, -1, -1, -1, 173, 174}}, {EF_BLOCKER, {185, -1, -1, 181, 186, 179, 180, 187, 188, 184, 183, -1, 182}}, {EF_HUSK, {194, 195, 196, 189, 191, 190, -1, -1, -1, -1, -1, 192, 193}}, {EF_HUSK, {202, 203, 204, 197, 199, 198, -1, -1, -1, -1, -1, 200, 201}}, {EF_HUSK, {210, 211, 212, 205, 207, 206, -1, -1, -1, -1, -1, 208, 209}}, {EF_LEAPER, {216, 218, 219, 213, 217, -1, -1, -1, -1, -1, -1, 214, 215}}, {EF_GUARD, {225, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 222, 223}}, {EF_FK, {247, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 245}}, {EF_FKHEAD, {267, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 265}}}
#define TXT_PROMPT_LISTEN 0
#define TXT_PROMPT_REST 1
#define TXT_PROMPT_INSPECT 2
diff --git a/games/hollowknight/src/enemy.c b/games/hollowknight/src/enemy.c
index fcec0368..30d8df75 100644
--- a/games/hollowknight/src/enemy.c
+++ b/games/hollowknight/src/enemy.c
@@ -14,7 +14,10 @@
/* ---------------------------------------------------------------- what each kind is */
/* (data.h: EK_* each kind, KIND_TABLE: the FSM each runs and the clips its roles play) */
-enum { EF_CRAWLER = 1, EF_BUZZER, EF_SHADE, EF_HUSK, EF_CLIMBER, EF_BOUNCER, EF_SPITTER, EF_ROLLER, EF_BLOCKER, EF_LEAPER, EF_GUARD };
+enum {
+ EF_CRAWLER = 1, EF_BUZZER, EF_SHADE, EF_HUSK, EF_CLIMBER, EF_BOUNCER, EF_SPITTER, EF_ROLLER, EF_BLOCKER, EF_LEAPER, EF_GUARD,
+ EF_FK, EF_FKHEAD
+};
enum { R_IDLE, R_TURN, R_WALK, R_A1, R_A2, R_A3, R_A4, R_A5, R_A6, R_A7, R_A8, R_DEATH_AIR, R_DEATH_LAND, NUM_ROLES };
typedef struct {
uint8_t fsm;
@@ -35,7 +38,7 @@ enum { EM_OFF, EM_ALIVE, EM_CORPSE };
enum { RC_READY, RC_RECOILING, RC_FROZEN };
enum { CS_AIR, CS_DEATH_ANIM, CS_LANDED };
/* (flags: 1 collider off, 2 RECOIL HORIZONTAL, 4 invincible, 8 TOOK DAMAGE: for its FSM this frame, 16 collider off
- * by its frame) */
+ * by its frame, 32 not drawn) */
typedef struct {
uint8_t mode, kind, st, flags;
uint16_t ent; /* its record (NO_ENT: spawned) */
@@ -315,6 +318,9 @@ static void enemy_die(Enemy *e, float direction, bool has_direction) {
/* HealthManager.Hit (a nail's): evasion, damage, recoil, flash, soul */
static void blocker_hit(Enemy *e);
+static void fk_head_hit(void);
+static void fk_stun(Enemy *e);
+static void fk_head_stun_end(Enemy *h);
static void enemy_hit(Enemy *e, float direction, int damage) {
if (e->mode != EM_ALIVE || e->evasion > 0 || damage <= 0) return;
int dir = cardinal(direction);
@@ -328,15 +334,21 @@ static void enemy_hit(Enemy *e, float direction, int damage) {
return;
}
recoil_by_direction(e, dir, 1);
- if (FSM(e) != EF_SHADE) hero_soul_gain(); /* (enemyType 3, a shade: no soul) */
+ if (FSM(e) != EF_SHADE && FSM(e) != EF_FK) hero_soul_gain(); /* (enemyType 3, a shade, or 6: no soul) */
e->flashing = true, e->flash_t = 0;
e->flags |= 8;
e->hp = (int16_t)(e->hp - damage < -50 ? -50 : e->hp - damage);
if ((FSM(e) == EF_BUZZER || FSM(e) == EF_SHADE || FSM(e) == EF_HUSK) && e->st == 0) e->b1 = true; /* (TOOK DAMAGE, in Idle / Ready) */
if (FSM(e) == EF_BLOCKER && e->hp > 0) blocker_hit(e);
+ if (FSM(e) == EF_FKHEAD) fk_head_hit(); /* (its sendHitTo) */
if (e->hp > 0)
e->evasion = 0.2f;
- else
+ else if (FSM(e) == EF_FK || FSM(e) == EF_FKHEAD) {
+ /* (hasSpecialDeath: ZERO HP to its FSMs, then NonFatalHit) */
+ if (FSM(e) == EF_FK) fk_stun(e);
+ else fk_head_stun_end(e);
+ e->evasion = 0.2f;
+ } else
enemy_die(e, direction, true);
}
@@ -1909,6 +1921,934 @@ static void guard_fixed(Enemy *e) {
}
}
+/* ---------------------------------------------------------------- the False Knight: FalseyControl, Check Health */
+enum {
+ FK_DORMANT, FK_START_FALL, FK_STATE1, FK_FIRST_IDLE, FK_IDLE, FK_TURN, FK_JUMP_ANTIC, FK_RISE, FK_FALL,
+ FK_JA_ANTIC, FK_JA_RISE, FK_JA_FALL, FK_JA_HIT, FK_JA_SLAM, FK_JA_RECOIL, FK_JA_RECOIL2, FK_JA_END,
+ FK_S_ANTIC, FK_S_RISE, FK_S_FALL, FK_S_LAND, FK_S_ATTACK_ANTIC, FK_S_ATTACK, FK_SLAM, FK_S_RECOVER,
+ FK_RUN_ANTIC, FK_RUN, FK_STUN_START, FK_STUN_AIR, FK_STUN_LAND, FK_ROLL_END, FK_OPEN, FK_OPENED, FK_HIT,
+ FK_STUN_FAIL, FK_RECOVER, FK_IDLE_PAUSE, FK_RAGE_ANTIC, FK_RISE2, FK_FALL2, FK_STATE2, FK_R_ATTACK_ANTIC,
+ FK_RAGE_BEGIN, FK_RAGE, FK_PARTICLE_PAUSE, FK_ANIM_END, FK_RAGE_END, FK_JA_ANTIC2, FK_JA_RISE2, FK_JA_FALL2,
+ FK_JA_HIT2, FK_FLOOR_BREAK, FK_DEATH_LAND, FK_DEATH_OPEN, FK_OPENED2, FK_HIT2, FK_DEATH_ANIM, FK_STEAM, FK_READY,
+ FK_BLOW, FK_HEAD_LAND, FK_DEAD
+};
+#define FK_SCALE 1.3f
+#define FK_RECOVER_HP 65 /* (Check Health: Recover HP, its HP at the start) */
+#define FK_HEAD_HP 40
+#define FK_HEAD_X 2.29f /* (the Head's place in the False Knight: shown, or out of the way) */
+#define FK_HEAD_Y -3.2709f
+#define MAX_BARRELS 12
+
+typedef struct {
+ bool on, broken, deflected;
+ float x, y, vx, vy, ang, spin, scale, gravity, t;
+} Barrel;
+
+static struct {
+ int8_t fk, head; /* (their slots) */
+ bool head_shown, first_jump, inert, going_right, kinematic;
+ uint8_t turns, jump_count, ja_row, slam_row, stunned, rages;
+ float jump_x, recoil, stun_x, idle_min, idle_max, shock_x;
+ /* the Barrel Summoner (summon) */
+ uint8_t summon_st, spawns;
+ float summon_t, summon_x0, summon_x1, summon_y;
+ Barrel barrels[MAX_BARRELS];
+ /* its arena (Battle Control) and floor (Floor Control) */
+ int16_t battle, floor; /* (their records, -1: none) */
+ uint8_t battle_st, floor_st;
+ float battle_t;
+ /* what is left: the Death Head, the staff */
+ bool dhead_on, staff_on;
+ Body dhead, staff;
+ Anim dhead_anim;
+ float staff_ang, staff_w;
+ Body bits[3];
+ bool bits_on;
+} fk;
+
+enum { BT_DETECT, BT_FIGHT, BT_END_WAIT, BT_DONE };
+enum { FL_IDLE, FL_CRACKED, FL_BROKEN };
+
+static Enemy *fk_body(void) { return fk.fk >= 0 && en[fk.fk].mode != EM_OFF ? &en[fk.fk] : NULL; }
+static Enemy *fk_head(void) { return fk.head >= 0 && en[fk.head].mode != EM_OFF ? &en[fk.head] : NULL; }
+
+static void fk_face(Enemy *e, bool right) {
+ fk.stun_x = right ? -10 : 10;
+ e->b0 = right;
+ set_scale_x(e, right ? FK_SCALE : -FK_SCALE);
+}
+
+static bool fk_ground(const Enemy *e) { return e->body.ncontacts && side_hit(e, 3); }
+
+/* (Rise / Fall: the speed up slowed, the speed down quickened, a fixed step at a time) */
+static void fk_air_fixed(Enemy *e) {
+ switch (e->st) {
+ case FK_RISE: case FK_JA_RISE: case FK_S_RISE: case FK_RISE2: case FK_JA_RISE2: e->body.vy *= 0.85f; break;
+ case FK_FALL: case FK_JA_FALL: case FK_S_FALL: case FK_FALL2: case FK_JA_FALL2: e->body.vy *= 1.15f; break;
+ case FK_RUN: e->body.vx = fk.jump_x; break; /* (Run Speed) */
+ }
+}
+
+static void fk_hitter(Enemy *e, int clip) {
+ if (clip < 0) {
+ e->hb_on = 0, e->sub_hb = 0;
+ return;
+ }
+ e->hb_on |= 1;
+ anim_play_from_frame(&e->sub, clip, 0);
+ e->sub_hb = 1;
+}
+
+static void fk_jump(Enemy *e, float gravity, int clip, float vy, int st) {
+ e->body.gravity_scale = gravity;
+ anim_play_from_frame(&e->anim, clip, 0);
+ e->body.vx = fk.jump_x, e->body.vy = vy;
+ cam_shake(SHAKE_ENEMY_KILL);
+ e->st = st;
+}
+
+static void fk_idle(Enemy *e) {
+ e->body.gravity_scale = 0.39f;
+ anim_play(&e->anim, CLIP_FK_IDLE);
+ fk_hitter(e, -1);
+ e->wait = rand_range(fk.idle_min, fk.idle_max);
+ e->t0 = 0;
+ e->st = FK_IDLE;
+}
+
+/* the hero's x, its own */
+static bool fk_hero_right(const Enemy *e) { return hero_x() > e->body.x; }
+
+/* JA Check Hero Pos .. JA Antic */
+static void fk_jump_attack(Enemy *e) {
+ fk.jump_count = 0;
+ cam_rumble(RUMBLE_OFF);
+ bool right = fk_hero_right(e);
+ fk.jump_x = hero_x() + (right ? -3 : 3) - e->body.x;
+ fk.recoil = right ? -3 : 3;
+ e->body.vx = 0;
+ fk.jump_x *= 0.58f;
+ fk.jump_x = fk.jump_x > 12 ? 12 : fk.jump_x < -12 ? -12 : fk.jump_x;
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ e->st = FK_JA_ANTIC;
+}
+
+static void fk_slam_antic(Enemy *e) {
+ anim_play_from_frame(&e->anim, CLIP_FK_ATTACK_ANTIC, 0);
+ e->st = FK_S_ATTACK_ANTIC, e->t0 = 0;
+}
+
+static void fk_walls_jump(Enemy *e);
+
+/* Move Choice: a run at a far hero, else a slam, a jump attack or a jump */
+static void fk_move_choice(Enemy *e) {
+ fk.turns = 0;
+ for (int guard = 0; guard < 16; guard++) {
+ float dx = hero_x() - e->body.x, dy = hero_y() - e->body.y;
+ if (dx * dx + dy * dy > 21 * 21) {
+ /* Run Antic: at its scale times 14 */
+ anim_play_from_frame(&e->anim, CLIP_FK_RUN_ANTIC, 0);
+ fk.jump_x = e->sx * 14;
+ e->st = FK_RUN_ANTIC;
+ return;
+ }
+ int r = (int)rand_range(0, 3);
+ if (r == 0) {
+ /* S Check Hero Pos */
+ if (fk.slam_row > 2) continue;
+ fk.ja_row = 0, fk.slam_row++, fk.jump_count = 0;
+ bool right = fk_hero_right(e);
+ fk.jump_x = hero_x() + (right ? -1 : 1) * rand_range(12, 18) - e->body.x;
+ fk.recoil = right ? -5 : 5, fk.shock_x = right ? 5.5f : -5.5f, fk.going_right = right;
+ /* S Antic: a smash from where it is if the hero is far, else a jump back first */
+ if (dx * dx + dy * dy >= 12 * 12) {
+ fk_slam_antic(e);
+ return;
+ }
+ fk.jump_x *= 0.9f;
+ fk.jump_x = fk.jump_x > 12 ? 12 : fk.jump_x < -12 ? -12 : fk.jump_x;
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ e->st = FK_S_ANTIC;
+ return;
+ }
+ if (r == 1) {
+ /* Row Check */
+ if (fk.ja_row > 3) continue;
+ fk.slam_row = 0, fk.ja_row++;
+ fk_jump_attack(e);
+ return;
+ }
+ /* Determine Jump */
+ if (fk.jump_count > 0 || fk.stunned == 2) continue;
+ fk.jump_count++;
+ if (rand_range(0, 1) < 0.5f) fk_walls_jump(e);
+ else {
+ /* Towards */
+ float hx = hero_x() < 15 ? 15 : hero_x() > 42 ? 42 : hero_x();
+ fk.jump_x = (hx - e->body.x) * 0.9f;
+ fk.jump_x = fk.jump_x > 12 ? 12 : fk.jump_x < -12 ? -12 : fk.jump_x;
+ }
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ e->st = FK_JUMP_ANTIC;
+ return;
+ }
+ fk_idle(e);
+}
+
+/* Walls Check, Random: away from a near wall, else either way */
+static void fk_walls_jump(Enemy *e) {
+ if (phys_ray(e->body.x, e->body.y, -1, 0, 8, CF_TERRAIN, NULL)) fk.jump_x = 5; /* (Random R, Random Right) */
+ else if (phys_ray(e->body.x, e->body.y, 1, 0, 8, CF_TERRAIN, NULL)) fk.jump_x = -5; /* (Random L, Random Left) */
+ else {
+ fk.jump_x = rand_range(-10, 10);
+ fk.jump_x = fk.jump_x <= 0 ? (fk.jump_x > -5 ? -5 : fk.jump_x) : (fk.jump_x < 5 ? 5 : fk.jump_x);
+ }
+}
+
+static void fk_head_show(bool on) {
+ Enemy *h = fk_head();
+ fk.head_shown = on;
+ if (h) {
+ if (on) h->flags &= (uint8_t)~1;
+ else h->flags |= 1;
+ }
+}
+
+/* Recover / Stun Fail: up again */
+static void fk_recover(Enemy *e, bool stunned) {
+ if (stunned) fk.stunned++, cam_shake(SHAKE_ENEMY_KILL);
+ fk_head_show(false);
+ fk.kinematic = false;
+ anim_play_from_frame(&e->anim, CLIP_FK_STUN_RECOVER, 0);
+ e->damage = 1;
+ if (!stunned) e->flags &= (uint8_t)~4;
+ e->st = stunned ? FK_RECOVER : FK_STUN_FAIL;
+}
+
+static void barrel_summon(void);
+static void fk_floor_event(int ev);
+static void fk_battle_end(void);
+
+/* (Check Health: its health gone, STUN, its health back) */
+static void fk_stun(Enemy *e) {
+ if (fk.inert) return;
+ e->hp = FK_RECOVER_HP;
+ /* Check Direction: facing the hero; Stun Start */
+ fk_hitter(e, -1);
+ bool right = fk_hero_right(e);
+ if (e->b0 != right) fk_face(e, right), fk.jump_x = right ? 14 : -14;
+ e->flags |= 4;
+ e->damage = 0;
+ e->body.gravity_scale = 1;
+ anim_play_from_frame(&e->anim, CLIP_FK_STUN_ROLL, 0);
+ e->body.vx = fk.stun_x, e->body.vy = 20;
+ cam_shake(SHAKE_BIG);
+ cam_rumble(RUMBLE_OFF);
+ e->st = FK_STUN_START;
+}
+
+static void fk_start(Enemy *e) {
+ fk.idle_min = fk.idle_max = 1;
+#ifdef HOST
+ if (getenv("FKSTUNNED")) fk.stunned = (uint8_t)atoi(getenv("FKSTUNNED")); /* (tests: the fight further on) */
+#endif
+ fk.fk = (int8_t)(e - en);
+ e->body.gravity_scale = 0;
+ e->flags |= 32; /* (its renderer off till it falls) */
+ fk_face(e, e->sx > 0);
+ e->st = FK_DORMANT;
+ fk_head_show(false);
+}
+
+static void fk_head_start(Enemy *e) {
+ fk.head = (int8_t)(e - en);
+ e->body.gravity_scale = 0;
+ e->flags |= 1;
+ e->damage = 0;
+}
+
+/* the Head, where its FSM puts it in the False Knight */
+static void fk_head_place(void) {
+ Enemy *h = fk_head(), *e = fk_body();
+ if (!h || !e) return;
+ h->sx = e->sx;
+ h->body.x = e->body.x + FK_HEAD_X * e->sx, h->body.y = e->body.y + FK_HEAD_Y * FK_SCALE;
+ h->body.vx = h->body.vy = 0;
+}
+
+/* (BATTLE START) */
+static void fk_battle_start(void) {
+ Enemy *e = fk_body();
+ if (!e || e->st != FK_DORMANT) return;
+ /* Start Fall */
+ e->flags &= (uint8_t)~32;
+ cam_shake(SHAKE_BIG);
+ e->body.gravity_scale = 1;
+ e->st = FK_START_FALL;
+}
+
+static void fk_update(Enemy *e) {
+ bool done = (e->anim.events & ANIM_DONE) != 0, sub_done = e->sub_hb && ((e->sub.events & ANIM_DONE) || !e->sub.playing);
+ bool hit = (e->flags & 8) != 0;
+ (void)hit;
+ e->t0 += DT;
+ switch (e->st) {
+ case FK_DORMANT:
+ break;
+ case FK_START_FALL:
+ if (fk_ground(e)) {
+ /* Rubble End: KILL ALL ENEMIES; State 1 */
+ for (int i = 0; i < MAX_ENEMIES; i++)
+ if (en[i].mode == EM_ALIVE && en[i].ent != NO_ENT && (ent_at(en[i].ent)->s1 & EF_PREBATTLE)) {
+ en[i].flags &= (uint8_t)~4, en[i].evasion = 0;
+ enemy_hit(&en[i], 90, 9999);
+ }
+ e->body.vx = 0;
+ anim_play_from_frame(&e->anim, CLIP_FK_LAND, 0);
+ cam_shake(SHAKE_AVERAGE);
+ e->st = FK_STATE1;
+ }
+ break;
+ case FK_STATE1:
+ if (done) {
+ if (fk.first_jump) fk_idle(e);
+ else {
+ /* Music: (its title shown), First Idle */
+ e->body.gravity_scale = 0.39f;
+ anim_play(&e->anim, CLIP_FK_IDLE);
+ fk_hitter(e, -1);
+ fk.first_jump = true;
+ e->st = FK_FIRST_IDLE, e->t0 = 0;
+ }
+ }
+ break;
+ case FK_FIRST_IDLE:
+ if (e->t0 >= 1.5f) {
+ fk_walls_jump(e); /* (Random) */
+ fk.jump_x = rand_range(-10, 10);
+ fk.jump_x = fk.jump_x <= 0 ? (fk.jump_x > -5 ? -5 : fk.jump_x) : (fk.jump_x < 5 ? 5 : fk.jump_x);
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ e->st = FK_JUMP_ANTIC;
+ }
+ break;
+ case FK_IDLE: {
+ bool right = fk_hero_right(e);
+ if (e->b0 != right) {
+ /* Turn L / R: three turns in a row, then a move */
+ if (fk.turns == 3) {
+ fk_move_choice(e);
+ break;
+ }
+ fk.turns++;
+ fk_face(e, right);
+ anim_play_from_frame(&e->anim, CLIP_FK_TURN, 0);
+ e->st = FK_TURN;
+ } else if (e->t0 >= e->wait)
+ fk_move_choice(e);
+ break;
+ }
+ case FK_TURN:
+ if (done) fk_idle(e);
+ break;
+ case FK_JUMP_ANTIC:
+ if (done) fk_jump(e, 0.125f, CLIP_FK_JUMP, 90, FK_RISE);
+ break;
+ case FK_RISE: case FK_S_RISE: case FK_RISE2:
+ if (e->body.vy < 0) e->st++; /* (FALL) */
+ break;
+ case FK_FALL: case FK_FALL2:
+ if (fk_ground(e)) {
+ /* State 1 / State 2: landed */
+ e->body.vx = 0;
+ anim_play_from_frame(&e->anim, CLIP_FK_LAND, 0);
+ cam_shake(SHAKE_AVERAGE);
+ e->st = e->st == FK_FALL ? FK_STATE1 : FK_STATE2;
+ }
+ break;
+ case FK_JA_ANTIC:
+ if (done) fk_jump(e, 0.12f, CLIP_FK_JUMP_ATTACK_UP, 90, FK_JA_RISE);
+ break;
+ case FK_JA_RISE: case FK_JA_RISE2:
+ if (e->body.vy < 0) e->st++;
+ break;
+ case FK_JA_FALL: case FK_JA_FALL2:
+ if (e->st == FK_JA_FALL2) fk.inert = true; /* (FALLEN: Check Health inert) */
+ if (phys_ray(e->body.x, e->body.y, 0, -1, 9.5f, CF_TERRAIN, NULL)) {
+ /* JA Hit: the mace down */
+ fk_hitter(e, CLIP_FK_JUMP_ATTACK_HIT_1);
+ anim_play(&e->anim, CLIP_FK_BLANK);
+ e->st = e->st == FK_JA_FALL ? FK_JA_HIT : FK_JA_HIT2;
+ }
+ break;
+ case FK_JA_HIT:
+ if (fk_ground(e)) {
+ /* JA Slam */
+ e->body.vx = 0;
+ cam_shake(SHAKE_BIG);
+ e->st = FK_JA_SLAM, e->t0 = 0;
+ }
+ break;
+ case FK_JA_SLAM:
+ if (e->t0 >= 0.083f || sub_done) {
+ /* (Barrels?) JA Recoil: back off, barrels summoned */
+ fk_hitter(e, -1);
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ATTACK_HIT_2, 0);
+ e->body.vx = fk.recoil;
+ barrel_summon();
+ e->st = FK_JA_RECOIL;
+ }
+ break;
+ case FK_JA_RECOIL:
+ if (done) {
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ATTACK_HIT_3, 0);
+ fk.recoil /= 2;
+ e->body.vx = fk.recoil;
+ e->st = FK_JA_RECOIL2, e->t0 = 0;
+ }
+ break;
+ case FK_JA_RECOIL2:
+ if (e->t0 >= 0.084f) e->body.gravity_scale = 0.39f, e->body.vx = 0, e->st = FK_JA_END;
+ break;
+ case FK_JA_END:
+ if (done || !e->anim.playing) fk_idle(e);
+ break;
+ case FK_S_ANTIC:
+ if (done) {
+ /* Check Jump Dir, Walls Check 2: no jump back into a wall */
+ float dir = fk.jump_x <= 0 ? -1 : 1;
+ if (phys_ray(e->body.x, e->body.y, dir, 0, 8, CF_TERRAIN, NULL)) fk_slam_antic(e);
+ else {
+ cam_shake(SHAKE_ENEMY_KILL);
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP, 0);
+ e->body.vx = fk.jump_x, e->body.vy = 105;
+ e->st = FK_S_RISE;
+ }
+ }
+ break;
+ case FK_S_FALL:
+ if (fk_ground(e)) {
+ cam_shake(SHAKE_AVERAGE);
+ e->body.vx = 0;
+ anim_play_from_frame(&e->anim, CLIP_FK_LAND, 0);
+ e->st = FK_S_LAND;
+ }
+ break;
+ case FK_S_LAND:
+ if (done) fk_slam_antic(e);
+ break;
+ case FK_S_ATTACK_ANTIC:
+ if (e->t0 >= 1.2f) {
+ /* S Attack: the mace swung */
+ fk_hitter(e, CLIP_FK_ATTACK);
+ anim_play(&e->anim, CLIP_FK_BLANK);
+ e->st = FK_S_ATTACK, e->t0 = 0;
+ }
+ break;
+ case FK_S_ATTACK:
+ if (e->t0 >= 0.12f) cam_shake(SHAKE_BIG), e->st = FK_SLAM;
+ break;
+ case FK_SLAM:
+ if (sub_done) {
+ /* S Attack Recover: barrels, a shockwave the way it faced */
+ barrel_summon();
+ wave_spawn(e->body.x + fk.shock_x, e->body.y - 5.8f, fk.going_right, 22, 1);
+ anim_play_from_frame(&e->anim, CLIP_FK_ATTACK_RECOVER, 0);
+ fk_hitter(e, -1);
+ e->st = FK_S_RECOVER;
+ }
+ break;
+ case FK_S_RECOVER:
+ if (done) fk_idle(e);
+ break;
+ case FK_RUN_ANTIC:
+ if (done) {
+ cam_rumble(RUMBLE_MED);
+ anim_play(&e->anim, CLIP_FK_RUN);
+ e->st = FK_RUN;
+ }
+ break;
+ case FK_RUN: {
+ float dx = hero_x() - e->body.x, dy = hero_y() - e->body.y;
+ if (dx * dx + dy * dy < 14 * 14) fk_jump_attack(e);
+ break;
+ }
+ case FK_STUN_START:
+ e->st = FK_STUN_AIR;
+ break;
+ case FK_STUN_AIR:
+ if (fk_ground(e)) e->st = FK_STUN_LAND, e->t0 = 0;
+ break;
+ case FK_STUN_LAND:
+ /* (END: rolling left fast, or half a second) */
+ if (e->body.vx < -3 || e->t0 >= 0.5f) {
+ /* Roll End: lying there a while */
+ fk.kinematic = true;
+ e->body.vx = e->body.vy = 0;
+ anim_play_from_frame(&e->anim, CLIP_FK_STUN_ROLL_END, 0);
+ e->wait = pd_flag(PDF_FK_FIRST_PLOP) ? 1.2f : 2.5f;
+ pd_set_flag(PDF_FK_FIRST_PLOP, true);
+ e->st = FK_ROLL_END, e->t0 = 0;
+ }
+ break;
+ case FK_ROLL_END:
+ if (e->t0 >= e->wait) anim_play_from_frame(&e->anim, CLIP_FK_STUN_OPEN, 0), e->st = FK_OPEN;
+ break;
+ case FK_OPEN:
+ if (done) {
+ /* Head Reset, Opened: the head out, for five seconds */
+ Enemy *h = fk_head();
+ if (h) anim_play_from_frame(&h->anim, h->anim.clip, 0);
+ anim_play(&e->anim, CLIP_FK_STUN_OPENED);
+ fk_head_show(true);
+ e->st = FK_OPENED, e->t0 = 0;
+ }
+ break;
+ case FK_OPENED:
+ if (e->t0 >= 5) fk_recover(e, false);
+ break;
+ case FK_HIT: case FK_HIT2:
+ if (done) anim_play(&e->anim, CLIP_FK_STUN_OPENED), e->st = e->st == FK_HIT ? FK_OPENED : FK_OPENED2, e->t0 = 0;
+ break;
+ case FK_STUN_FAIL:
+ if (done) fk_idle(e);
+ break;
+ case FK_RECOVER:
+ if (done) {
+ anim_play(&e->anim, CLIP_FK_IDLE);
+ e->flags &= (uint8_t)~4;
+ e->st = FK_IDLE_PAUSE, e->t0 = 0;
+ }
+ break;
+ case FK_IDLE_PAUSE:
+ if (e->t0 >= 0.5f) {
+ /* Rage Jump Antic: to the arena's middle */
+ fk.jump_x = (28.9f - e->body.x) * 1.05f;
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ e->st = FK_RAGE_ANTIC;
+ }
+ break;
+ case FK_RAGE_ANTIC:
+ if (done) fk_jump(e, 0.3f, CLIP_FK_JUMP, 105, FK_RISE2);
+ break;
+ case FK_STATE2:
+ if (done) {
+ fk.rages = 8;
+ anim_play_from_frame(&e->anim, CLIP_FK_ATTACK_ANTIC, 0);
+ e->st = FK_R_ATTACK_ANTIC, e->t0 = 0;
+ }
+ break;
+ case FK_R_ATTACK_ANTIC:
+ if (e->t0 >= 0.7f) {
+ fk_hitter(e, CLIP_FK_RAGE);
+ anim_play(&e->anim, CLIP_FK_BLANK);
+ e->st = FK_RAGE_BEGIN;
+ }
+ break;
+ case FK_RAGE_BEGIN:
+ e->st = FK_RAGE, e->t0 = 0;
+ fk_hitter(e, CLIP_FK_RAGE);
+ break;
+ case FK_RAGE:
+ if (e->t0 >= 0.249f) {
+ /* Rage Slam; Floor Crack? (the last of the second rage's) */
+ cam_shake(SHAKE_AVERAGE);
+ if (fk.stunned == 2 && fk.rages == 1) fk_floor_event(FL_CRACKED);
+ e->st = FK_PARTICLE_PAUSE, e->t0 = 0;
+ }
+ break;
+ case FK_PARTICLE_PAUSE:
+ if (e->t0 >= 0.1f) e->st = FK_ANIM_END;
+ break;
+ case FK_ANIM_END:
+ if (sub_done) {
+ /* Turn: barrels, the other way */
+ barrel_summon();
+ fk.rages--;
+ set_scale_x(e, -e->sx);
+ if (fk.rages <= 0) {
+ /* Rage Check */
+ if (fk.stunned >= 3) {
+ /* JA Antic 2: the last jump, onto the floor's middle */
+ e->flags |= 4;
+ fk_hitter(e, -1);
+ fk.jump_x = (34 - e->body.x) * 0.76f;
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ANTIC, 0);
+ fk_face(e, true);
+ e->st = FK_JA_ANTIC2;
+ break;
+ }
+ /* To Phase 2 / 3, Rage End */
+ fk.idle_min = 0.8f, fk.idle_max = 1;
+ fk_hitter(e, -1);
+ anim_play(&e->anim, CLIP_FK_IDLE);
+ e->st = FK_RAGE_END, e->t0 = 0;
+ } else
+ e->st = FK_RAGE, e->t0 = 0, fk_hitter(e, CLIP_FK_RAGE);
+ }
+ break;
+ case FK_RAGE_END:
+ if (e->t0 >= 0.75f) fk_idle(e);
+ break;
+ case FK_JA_ANTIC2:
+ if (done) {
+ e->body.gravity_scale = 0.2f;
+ anim_play_from_frame(&e->anim, CLIP_FK_JUMP_ATTACK_UP, 0);
+ e->body.vx = fk.jump_x, e->body.vy = 90;
+ e->st = FK_JA_RISE2;
+ }
+ break;
+ case FK_JA_HIT2:
+ if (fk_ground(e)) {
+ /* Floor Break: through the floor */
+ fk_hitter(e, -1);
+ fk_floor_event(FL_BROKEN);
+ e->body.gravity_scale = 1;
+ anim_play_from_frame(&e->anim, CLIP_FK_DEATH_FALL, 0);
+ e->body.vx = 0, e->body.vy = 15;
+ cam_shake(SHAKE_BIG);
+ e->damage = 0;
+ e->st = FK_FLOOR_BREAK;
+ }
+ break;
+ case FK_FLOOR_BREAK:
+ if (e->body.vy <= 0 && fk_ground(e)) {
+ anim_play_from_frame(&e->anim, CLIP_FK_DEATH_LAND, 0);
+ fk.kinematic = true;
+ e->body.vx = e->body.vy = 0;
+ e->st = FK_DEATH_LAND, e->t0 = 0;
+ }
+ break;
+ case FK_DEATH_LAND:
+ if (e->t0 >= 2) anim_play_from_frame(&e->anim, CLIP_FK_STUN_OPEN, 0), e->st = FK_DEATH_OPEN;
+ break;
+ case FK_DEATH_OPEN:
+ if (done) {
+ Enemy *h = fk_head();
+ if (h) anim_play_from_frame(&h->anim, h->anim.clip, 0);
+ anim_play(&e->anim, CLIP_FK_STUN_OPENED);
+ fk_head_show(true);
+ e->st = FK_OPENED2;
+ }
+ break;
+ case FK_DEATH_ANIM:
+ if (e->t0 >= 1) {
+ /* Open Map Shop and Journal; Steam */
+ pd_set_flag(PDF_MAPPER_SHOP, true);
+ pd_set_flag(PDF_CORN_CROSSROADS_LEFT, true);
+ e->flags |= 1;
+ cam_shake(SHAKE_BIG);
+ e->st = FK_STEAM, e->t0 = 0;
+ }
+ break;
+ case FK_STEAM:
+ if (e->t0 >= 3) e->st = FK_READY, e->t0 = 0;
+ break;
+ case FK_READY:
+ if (e->t0 >= 1) {
+ /* Blow: the maggot out, the staff flung */
+ Enemy *h = fk_head();
+ if (h) h->mode = EM_OFF;
+ fk.head_shown = false;
+ cam_shake(SHAKE_BIG);
+ anim_play(&e->anim, CLIP_FK_BODY);
+ fk.dhead_on = true;
+ memset(&fk.dhead, 0, sizeof fk.dhead);
+ fk.dhead.x = e->body.x + 3.11f * e->sx, fk.dhead.y = e->body.y - 2.86f * FK_SCALE;
+ fk.dhead.vx = e->b0 ? 4 : -4;
+ fk.dhead.ox = -0.1094f * 0.975f * (e->sx < 0 ? -1 : 1), fk.dhead.oy = -0.7812f * 0.975f;
+ fk.dhead.hx = 2.8125f / 2 * 0.975f, fk.dhead.hy = 2.1562f / 2 * 0.975f;
+ fk.dhead.gravity_scale = 1, fk.dhead.friction = 0.2828f, fk.dhead.mask = CF_SOLID;
+ anim_play_from_frame(&fk.dhead_anim, CLIP_FK_DEATH_HEAD_1, 0);
+ fk.staff_on = true;
+ memset(&fk.staff, 0, sizeof fk.staff);
+ fk.staff.x = e->body.x - 1.45f * e->sx, fk.staff.y = e->body.y + 0.04f * FK_SCALE;
+ fk.staff.vx = cosf(150 * (float)M_PI / 180) * 20, fk.staff.vy = sinf(150 * (float)M_PI / 180) * 20;
+ fk.staff.hx = fk.staff.hy = 0.2f;
+ fk.staff.gravity_scale = 1, fk.staff.friction = 0.2828f, fk.staff.mask = CF_SOLID;
+ fk.staff_ang = 0, fk.staff_w = 700;
+ e->st = FK_BLOW;
+ }
+ break;
+ case FK_BLOW:
+ if ((fk.dhead_anim.events & ANIM_DONE) || !fk.dhead_anim.playing) {
+ fk.dhead.vx = 0;
+ anim_play_from_frame(&fk.dhead_anim, CLIP_FK_DEATH_HEAD_2, 0);
+ e->st = FK_HEAD_LAND, e->t0 = 0;
+ }
+ break;
+ case FK_HEAD_LAND:
+ if (e->t0 >= 1.5f) {
+ /* Decrement Battle Enemies, Cough */
+ fk_battle_end();
+ e->st = FK_DEAD;
+ }
+ break;
+ }
+}
+
+static void fk_fixed(Enemy *e) {
+ if (e->st == FK_DORMANT) e->body.vx = e->body.vy = 0;
+ fk_air_fixed(e);
+}
+
+/* the head's HP gone (its Health Check: STUN END, its HP back) */
+static void fk_head_stun_end(Enemy *h) {
+ h->hp = FK_HEAD_HP;
+ anim_play(&h->anim, CLIP_FKHEAD_HEAD_IDLE);
+ Enemy *e = fk_body();
+ if (!e) return;
+ if (e->st == FK_OPENED || e->st == FK_HIT) fk_recover(e, true);
+ else if (e->st == FK_OPENED2 || e->st == FK_HIT2) {
+ /* Death Anim Start */
+ pd_set_flag(PDF_FALSE_KNIGHT_DEFEATED, true);
+ cam_shake(SHAKE_ENEMY_KILL);
+ anim_play(&h->anim, CLIP_FKHEAD_HEAD_SPAZ);
+ h->flags |= 1;
+ fk.kinematic = false;
+ anim_play(&e->anim, CLIP_FK_DEATH_SPAZ);
+ e->st = FK_DEATH_ANIM, e->t0 = 0;
+ }
+}
+
+/* (the head's HealthManager: HIT to the False Knight) */
+static void fk_head_hit(void) {
+ Enemy *e = fk_body(), *h = fk_head();
+ if (!e) return;
+ if (e->st == FK_OPENED || e->st == FK_OPENED2 || e->st == FK_HIT || e->st == FK_HIT2) {
+ anim_play_from_frame(&e->anim, CLIP_FK_STUN_HIT, 0);
+ if (h) anim_play_from_frame(&h->anim, CLIP_FKHEAD_HEAD_HIT, 0);
+ e->st = e->st == FK_OPENED || e->st == FK_HIT ? FK_HIT : FK_HIT2;
+ }
+}
+
+/* ---------------------------------------------------------------- the barrels the False Knight brings down */
+/* (summon: Determine Spawns, Spawn, Check Spawns: six to eight, a fifth of a second or so apart) */
+static void barrel_summon(void) {
+ if (fk.summon_st) return;
+ fk.spawns = (uint8_t)(6 + (int)rand_range(0, 3));
+ fk.summon_t = rand_range(0.15f, 0.25f);
+ fk.summon_st = 1;
+}
+
+static void barrels_tick(void) {
+ if (fk.summon_st && (fk.summon_t -= DT) <= 0) {
+ if (fk.spawns == 0) fk.summon_st = 0;
+ else {
+ for (int i = 0; i < MAX_BARRELS; i++) {
+ Barrel *b = &fk.barrels[i];
+ if (b->on) continue;
+ memset(b, 0, sizeof *b);
+ b->on = true;
+ b->x = rand_range(fk.summon_x0, fk.summon_x1), b->y = fk.summon_y;
+ b->scale = rand_range(0.8f, 1);
+ b->gravity = 0.325f;
+ b->spin = rand_range(0, 1) < 0.5f ? -720 : 720;
+ break;
+ }
+ fk.spawns--;
+ fk.summon_t = rand_range(0.15f, 0.25f);
+ }
+ }
+ for (int i = 0; i < MAX_BARRELS; i++) {
+ Barrel *b = &fk.barrels[i];
+ if (!b->on) continue;
+ if (b->broken) {
+ if ((b->t += DT) >= 3) b->on = false;
+ continue;
+ }
+ b->vy -= 60 * b->gravity * DT;
+ b->ang += b->spin * DT;
+ float hx = 0.59f * b->scale, hy = 0.555f * b->scale;
+ b->x += b->vx * DT, b->y += b->vy * DT;
+ /* (its trigger: the terrain, the hero or an enemy breaks it) */
+ bool brk = false;
+ for (int k = -1; k <= 1 && !brk; k += 2)
+ brk = phys_ray(b->x, b->y, 0, (float)k, hy, CF_TERRAIN, NULL) || phys_ray(b->x, b->y, (float)k, 0, hx, CF_TERRAIN, NULL);
+ for (int j = 0; j < MAX_ENEMIES && !brk; j++) {
+ Enemy *e = &en[j];
+ if (e->mode != EM_ALIVE || (e->flags & 17)) continue;
+ float x0, y0, x1, y1;
+ enemy_box(e, &x0, &y0, &x1, &y1);
+ if (b->x + hx > x0 && b->x - hx < x1 && b->y + hy > y0 && b->y - hy < y1) {
+ brk = true;
+ if (b->deflected) enemy_hit(e, b->vx >= 0 ? 0 : 180, 10); /* (damages_enemy: 10, once deflected) */
+ }
+ }
+ if (brk || b->y < -20) b->broken = true, b->t = 0;
+ }
+}
+
+static int barrels_touch(float x0, float y0, float x1, float y1, int *side) {
+ for (int i = 0; i < MAX_BARRELS; i++) {
+ Barrel *b = &fk.barrels[i];
+ if (!b->on || b->broken) continue;
+ float hx = 0.59f * b->scale, hy = 0.555f * b->scale;
+ if (x1 > b->x - hx && x0 < b->x + hx && y1 > b->y - hy && y0 < b->y + hy) {
+ b->broken = true, b->t = 0;
+ *side = b->x > g_hero.body.x ? SIDE_RIGHT : SIDE_LEFT;
+ return 1;
+ }
+ }
+ return 0;
+}
+
+/* a nail's swing at the barrels: struck the way it swung (Check Direct) */
+static void barrels_nail(const float *pts, int npts, float direction) {
+ for (int i = 0; i < MAX_BARRELS; i++) {
+ Barrel *b = &fk.barrels[i];
+ if (!b->on || b->broken || b->deflected) continue;
+ float hx = 0.59f * b->scale, hy = 0.555f * b->scale;
+ if (!box_meets_shape(b->x - hx, b->y - hy, b->x + hx, b->y + hy, pts, npts)) continue;
+ float a = direction * (float)M_PI / 180;
+ b->vx = cosf(a) * 45, b->vy = sinf(a) * 45;
+ b->gravity = 0.3f;
+ b->deflected = true;
+ }
+}
+
+static void barrels_draw(void) {
+ for (int i = 0; i < MAX_BARRELS; i++) {
+ const Barrel *b = &fk.barrels[i];
+ if (!b->on || b->broken) continue;
+ Inst in;
+ sprite_inst_rot(SPRITE_FK_BARREL, b->x, b->y, 0.006f, b->scale, b->scale, b->ang, 0, &in);
+ gfx_actor(&in, SORT_KEY(0, 0));
+ }
+}
+
+/* ---------------------------------------------------------------- its arena and floor */
+static void fk_floor_event(int ev) {
+ if (fk.floor < 0 || fk.floor_st >= ev) return;
+ const Ent *f = ent_at(fk.floor);
+ fk.floor_st = (uint8_t)ev;
+ group_fade(f->group2, 0, 0); /* (Normal 1, 2 off) */
+ if (ev == FL_BROKEN) {
+ for (int c = f->a; c < f->a + f->group; c++) phys_collider_enable(c, false); /* (Break Floor off) */
+ fk.bits_on = true;
+ for (int k = 0; k < 3; k++) {
+ const Ent *r = f + 1;
+ for (int j = 1; j <= f->s0; j++)
+ if (f[j].flags == 3 + k) r = &f[j];
+ Body *b = &fk.bits[k];
+ memset(b, 0, sizeof *b);
+ b->x = r->x0, b->y = r->y0, b->vx = r->p0, b->vy = r->p1;
+ b->gravity_scale = 1;
+ }
+ }
+}
+
+static void fk_battle_end(void) {
+ if (fk.battle < 0 || fk.battle_st != BT_FIGHT) return;
+ const Ent *b = ent_at(fk.battle);
+ persist_set(b->persist);
+ if (b->p0 >= 0) ent_set_enabled((int)b->p0, false);
+ if (b->p1 >= 0) ent_set_enabled((int)b->p1, false);
+ cam_rumble(RUMBLE_OFF);
+ fk.battle_st = BT_END_WAIT, fk.battle_t = 0;
+}
+
+/* the arena's records: Battle Control (Init; Activate if its fight is over), Floor Control */
+static void fk_arena_enter(void) {
+ memset(&fk, 0, sizeof fk);
+ fk.battle = fk.floor = -1;
+ fk.fk = fk.head = -1;
+ int n;
+ const Ent *es = room_ents(&n);
+ for (int i = 0; i < n; i++) {
+ if (es[i].type != ENT_OBJ) continue;
+ if (es[i].flags == OK_BATTLE) fk.battle = (int16_t)i;
+ if (es[i].flags == OK_FK_FLOOR) fk.floor = (int16_t)i;
+ }
+ if (fk.battle < 0) return;
+ const Ent *b = &es[fk.battle];
+ fk.summon_x0 = 13.18f, fk.summon_x1 = 44.27f, fk.summon_y = 40.98f; /* (summon: Summon Min, Max; its y) */
+ if (persist_get(b->persist)) {
+ /* Activate: the fight over, the floor broken, the armour there */
+ if (b->p0 >= 0) ent_set_enabled((int)b->p0, false);
+ if (b->p1 >= 0) ent_set_enabled((int)b->p1, false);
+ fk.battle_st = BT_DONE;
+ if (fk.floor >= 0) {
+ const Ent *f = &es[fk.floor];
+ fk.floor_st = FL_BROKEN;
+ group_fade(f->group2, 0, 0);
+ for (int c = f->a; c < f->a + f->group; c++) phys_collider_enable(c, false);
+ }
+ } else {
+ if (b->p0 >= 0) ent_set_enabled((int)b->p0, false); /* (Init: CameraLock 1 off) */
+ if (b->group) group_fade(b->group, 0, 0); /* (the armour not there yet) */
+ fk.battle_st = BT_DETECT;
+ fk.floor_st = FL_IDLE;
+ }
+}
+
+static void fk_arena_tick(void) {
+ if (fk.battle < 0) return;
+ const Ent *b = ent_at(fk.battle);
+ switch (fk.battle_st) {
+ case BT_DETECT: {
+ const Body *k = &g_hero.body;
+ float x0 = k->x + k->ox - k->hx, x1 = k->x + k->ox + k->hx, y0 = k->y + k->oy - k->hy, y1 = k->y + k->oy + k->hy;
+ if (x1 > b->x0 && x0 < b->x1 && y1 > b->y0 && y0 < b->y1) {
+ /* Start: the camera locked to the arena, BATTLE START */
+ if (b->p0 >= 0) ent_set_enabled((int)b->p0, true);
+ if (b->p1 >= 0) ent_set_enabled((int)b->p1, false);
+ fk.battle_st = BT_FIGHT;
+ fk_battle_start();
+ }
+ break;
+ }
+ case BT_END_WAIT:
+ if ((fk.battle_t += DT) >= 2) fk.battle_st = BT_DONE;
+ break;
+ }
+ barrels_tick();
+ /* what is left of it */
+ if (fk.dhead_on) {
+ fk.dhead_anim.events = 0;
+ anim_update(&fk.dhead_anim, DT);
+ body_step(&fk.dhead, DT);
+ }
+ if (fk.staff_on) {
+ body_step(&fk.staff, DT);
+ fk.staff_ang += fk.staff_w * DT;
+ if (fk.staff.ncontacts) fk.staff_w *= 0.9f;
+ }
+ if (fk.bits_on)
+ for (int k = 0; k < 3; k++) {
+ Body *bb = &fk.bits[k];
+ bb->vy -= 60 * bb->gravity_scale * DT;
+ bb->x += bb->vx * DT, bb->y += bb->vy * DT;
+ }
+}
+
+static void fk_arena_draw(void) {
+ if (fk.battle < 0) return;
+ barrels_draw();
+ Inst in;
+ if (fk.dhead_on && fk.dhead_anim.sprite >= 0) {
+ Enemy *e = fk_body();
+ float s = 0.975f * (e && e->sx < 0 ? -1 : 1);
+ sprite_inst(fk.dhead_anim.sprite, fk.dhead.x, fk.dhead.y, 0.0054f, s, 0.975f, 0, &in);
+ gfx_actor(&in, SORT_KEY(0, 0));
+ }
+ if (fk.staff_on) {
+ sprite_inst_rot(SPRITE_FK_STAFF, fk.staff.x, fk.staff.y, 0.005f, 1, 1, fk.staff_ang, 0, &in);
+ gfx_actor(&in, SORT_KEY(0, 0));
+ }
+ if (fk.floor >= 0 && fk.floor_st != FL_IDLE) {
+ const Ent *f = ent_at(fk.floor);
+ for (int j = 1; j <= f->s0; j++) {
+ const Ent *r = &f[j];
+ bool show = fk.floor_st == FL_CRACKED ? r->flags <= 1 : r->flags == 2 || (r->flags >= 3 && fk.bits_on);
+ if (!show) continue;
+ float x = r->x0, y = r->y0;
+ if (r->flags >= 3 && fk.bits_on) x = fk.bits[r->flags - 3].x, y = fk.bits[r->flags - 3].y;
+ sprite_inst(r->s0, x, y, r->x1, 1, 1, 0, &in);
+ gfx_actor(&in, SORT_KEY(r->group, (int)r->a - 32768));
+ }
+ }
+}
+
/* ---------------------------------------------------------------- the Hollow Shade: its Shade Control FSM */
enum {
SH_IDLE, SH_STARTLE, SH_FLY, SH_POSITION, SH_SLASH_ANTIC, SH_SLASH, SH_SLASH_BOX, SH_SLASH_CD, SH_FIREBALL_POS,
@@ -2251,6 +3191,7 @@ static void balls_tick(void) {
void enemies_enter(void) {
memset(en, 0, sizeof en);
memset(geo, 0, sizeof geo);
+ fk_arena_enter();
int n, k = 0;
const Ent *es = room_ents(&n);
for (int i = 0; i < n && k < MAX_ENEMIES; i++) {
@@ -2289,6 +3230,8 @@ void enemies_enter(void) {
else if (FSM(e) == EF_BLOCKER) blocker_start(e);
else if (FSM(e) == EF_LEAPER) leaper_start(e);
else if (FSM(e) == EF_GUARD) guard_start(e);
+ else if (FSM(e) == EF_FK) fk_start(e);
+ else if (FSM(e) == EF_FKHEAD) fk_head_start(e);
for (int h = 0; h < 8; h++) {
const Ent *r = hitbox_rec(e, h);
if (!r) break;
@@ -2321,6 +3264,13 @@ void enemies_fixed(void) {
if (e->st != SH_RETREAT) body_step(&e->body, DT);
continue;
}
+ if (e->mode == EM_ALIVE && FSM(e) == EF_FK) {
+ fk_fixed(e);
+ if (fk.kinematic) e->body.vx = e->body.vy = 0;
+ else body_step(&e->body, DT);
+ continue;
+ }
+ if (e->mode == EM_ALIVE && FSM(e) == EF_FKHEAD) continue;
if (e->mode == EM_ALIVE && FSM(e) == EF_CLIMBER) {
/* (a kinematic body: its velocity, nothing in its way) */
recoil_fixed(e);
@@ -2369,6 +3319,8 @@ void enemies_fixed(void) {
balls_tick();
bullets_tick();
waves_tick();
+ fk_arena_tick();
+ fk_head_place();
}
/* Update: the FSMs' every-frame actions, the animations, the timers */
@@ -2393,7 +3345,13 @@ void enemies_update(void) {
else if (FSM(e) == EF_BLOCKER) blocker_update(e);
else if (FSM(e) == EF_LEAPER) leaper_update(e);
else if (FSM(e) == EF_GUARD) guard_update(e);
- hitbox_tick(e);
+ else if (FSM(e) == EF_FK) fk_update(e);
+ if (FSM(e) == EF_FK) {
+ /* (its Hitter: on till its FSM turns it off) */
+ e->sub.events = 0;
+ if (e->sub_hb) anim_update(&e->sub, DT);
+ } else
+ hitbox_tick(e);
e->flags &= (uint8_t)~8;
} else if (FSM(e) == EF_SHADE)
shade_update(e);
@@ -2411,13 +3369,15 @@ void enemies_draw(void) {
Inst in;
float z = e->mode == EM_CORPSE && FSM(e) != EF_SHADE ? 0.0085f : e->z;
if (FSM(e) == EF_SHADE && e->st == SH_DISSIPATE) continue; /* (its renderer off) */
+ if ((e->flags & 32) || (FSM(e) == EF_FKHEAD && !fk.head_shown && e->mode == EM_ALIVE)) continue;
+ float sy = fabsf(e->sx) > 0 ? fabsf(e->sx) : 1;
if (e->ang != 0 && e->mode == EM_ALIVE)
sprite_inst_rot(e->anim.sprite, e->body.x, e->body.y, z, e->sx, 1, e->ang, flash_tint(e, 2 + i % 5), &in);
else
- sprite_inst(e->anim.sprite, e->body.x + e->jx, e->body.y + e->jy, z, e->sx, 1, flash_tint(e, 2 + i % 5), &in);
+ sprite_inst(e->anim.sprite, e->body.x + e->jx, e->body.y + e->jy, z, e->sx, sy, flash_tint(e, 2 + i % 5), &in);
gfx_actor(&in, SORT_KEY(0, 0));
if (e->sub_hb && e->sub.sprite >= 0 && e->mode == EM_ALIVE) {
- sprite_inst(e->sub.sprite, e->body.x, e->body.y, z - 0.001f, e->sx, 1, 0, &in);
+ sprite_inst(e->sub.sprite, e->body.x, e->body.y, z - 0.001f, e->sx, sy, flash_tint(e, 2 + i % 5), &in);
gfx_actor(&in, SORT_KEY(0, 0));
}
if (FSM(e) == EF_SHADE && sh.slash_on) {
@@ -2427,6 +3387,7 @@ void enemies_draw(void) {
}
bullets_draw();
spurts_draw();
+ fk_arena_draw();
for (int i = 0; i < MAX_BALLS; i++) {
const Ball *b = &balls[i];
if (!b->on) continue;
@@ -2449,6 +3410,7 @@ void enemies_swing_start(void) { swing_bits = 0; }
/* the slash's shape: enemies it touches are hit, once a swing -> HB_* */
int enemies_nail(const float *pts, int npts, float direction, int damage) {
int out = 0;
+ barrels_nail(pts, npts, direction);
for (int i = 0; i < MAX_ENEMIES; i++) {
Enemy *e = &en[i];
if (e->mode != EM_ALIVE || (e->flags & 17)) continue;
@@ -2494,6 +3456,8 @@ int enemies_touch_hero(float x0, float y0, float x1, float y1, int *side) {
if (dmg) return dmg;
dmg = spurts_touch(x0, y0, x1, y1, side);
if (dmg) return dmg;
+ dmg = barrels_touch(x0, y0, x1, y1, side);
+ if (dmg) return dmg;
for (int i = 0; i < MAX_BALLS; i++) {
const Ball *b = &balls[i];
if (!b->on || b->ending) continue;
@@ -2524,8 +3488,9 @@ void enemies_debug_hit(int damage) {
for (int i = 0; i < MAX_ENEMIES; i++) {
Enemy *e = &en[i];
float dx = e->body.x - g_hero.body.x, dy = e->body.y - g_hero.body.y;
- if (e->mode != EM_ALIVE || dx * dx + dy * dy > 15 * 15) continue;
- e->flags &= (uint8_t)~4, e->evasion = 0;
+ float r = getenv("HKHITR") ? (float)atof(getenv("HKHITR")) : 15;
+ if (e->mode != EM_ALIVE || (e->flags & 5) || dx * dx + dy * dy > r * r) continue;
+ if (FSM(e) == EF_FK && e->st == FK_DORMANT) continue;
enemy_hit(e, dx > 0 ? 0 : 180, damage);
}
}
diff --git a/games/hollowknight/src/game.c b/games/hollowknight/src/game.c
index 2534e7c8..a9ef37ea 100644
--- a/games/hollowknight/src/game.c
+++ b/games/hollowknight/src/game.c
@@ -4,6 +4,15 @@
PlayerData g_pd;
Game g_game;
static uint8_t inside[MAX_ENTS / 8]; /* the triggers the Knight is in */
+static uint8_t ent_off[MAX_ENTS / 8]; /* (triggers whose objects are off) */
+
+bool room_flag(int flag) { return flag >= 0 && flag < PDF_COUNT && pd_flag(flag); }
+
+void ent_set_enabled(int i, bool on) {
+ if (i < 0 || i >= MAX_ENTS) return;
+ if (on) ent_off[i >> 3] &= (uint8_t)~(1 << (i & 7));
+ else ent_off[i >> 3] |= (uint8_t)(1 << (i & 7));
+}
void game_new(void) {
memset(&g_pd, 0, sizeof g_pd);
@@ -24,6 +33,7 @@ void game_new(void) {
bool game_enter(int room, float x, float y, bool facing_right) {
if (!room_load(room)) return false;
memset(inside, 0, sizeof inside);
+ memset(ent_off, 0, sizeof ent_off);
prompts_reset();
world_enter();
hero_init(x, y, facing_right);
@@ -41,6 +51,7 @@ bool game_respawn(void) {
if (!strcmp(room_name(i), g_pd.respawn_scene)) room = i;
if (room < 0 || !room_load(room)) return false;
memset(inside, 0, sizeof inside);
+ memset(ent_off, 0, sizeof ent_off);
prompts_reset();
world_enter();
float x = g_room.h->w / 2, y = g_room.h->h / 2;
@@ -130,6 +141,7 @@ static void scene_load(void) {
g->scene_phase = SP_NONE;
if (!room_load(g->next_room)) return;
memset(inside, 0, sizeof inside);
+ memset(ent_off, 0, sizeof ent_off);
prompts_reset(); /* (PromptMarker.RecycleOnLevelLoad) */
world_enter();
int n;
@@ -189,10 +201,11 @@ static void triggers_tick(void) {
for (int i = 0; i < n; i++) {
const Ent *e = &es[i];
if (e->type != ENT_CAMLOCK && e->type != ENT_GATE && e->type != ENT_HAZARD_TRIGGER && e->type != ENT_MASK) continue;
- bool in = false;
+ bool in = false, off = ent_off[i >> 3] >> (i & 7) & 1;
for (int j = i; j < n && (j == i || es[j].type == ENT_BOX); j++)
if (j == i || !(es[j].flags & 1)) in |= x1 > es[j].x0 && x0 < es[j].x1 && y1 > es[j].y0 && y0 < es[j].y1;
bool was = inside[i >> 3] >> (i & 7) & 1;
+ if (off) in = false;
if (in) inside[i >> 3] |= (uint8_t)(1 << (i & 7));
else inside[i >> 3] &= (uint8_t)~(1 << (i & 7));
if (in || was) trigger_event(i, e, in && was ? EV_STAY : in ? EV_ENTER : EV_EXIT);
diff --git a/games/hollowknight/src/game.h b/games/hollowknight/src/game.h
index d1a95e06..517b7cef 100644
--- a/games/hollowknight/src/game.h
+++ b/games/hollowknight/src/game.h
@@ -8,6 +8,7 @@
/* the game's many bools (PlayerData's), by number: new ones only ever added at the end (saves keep them) */
enum {
PDF_AT_BENCH, PDF_HAS_MAP, PDF_HAS_QUILL, PDF_HAS_CHARM, PDF_CHARM_BENCH_MSG, PDF_MET_ELDERBUG, PDF_VISITED_CROSSROADS,
+ PDF_FALSE_KNIGHT_DEFEATED, PDF_FK_FIRST_PLOP, PDF_MAPPER_SHOP, PDF_CORN_CROSSROADS_LEFT, PDF_HORNET1_DEFEATED,
PDF_COUNT
};
typedef struct {
@@ -51,7 +52,8 @@ void save_set_respawn(const char *marker, bool facing_right); /* (Bench Contro
/* ---------------------------------------------------------------- the room's game objects (tools/ents.py) */
enum { ENT_CAMLOCK = 1, ENT_GATE, ENT_HAZARD_MARKER, ENT_RESPAWN, ENT_HAZARD_TRIGGER, ENT_MASK, ENT_DAMAGE, ENT_SHAPE,
ENT_BOX, ENT_OBJ, ENT_PIECE, ENT_SHADE_MARKER }; /* (shape, box, piece: more of the record before) */
-enum { OK_BREAKABLE = 1, OK_ENEMY, OK_GREAT_DOOR, OK_GEO_ROCK, OK_CHEST, OK_BENCH }; /* objects (ENT_OBJ's flags) */
+enum { OK_BREAKABLE = 1, OK_ENEMY, OK_GREAT_DOOR, OK_GEO_ROCK, OK_CHEST, OK_BENCH, OK_BATTLE, OK_FK_FLOOR }; /* objects (ENT_OBJ's flags) */
+#define EF_PREBATTLE 4 /* (an enemy record's s1: one of an arena's Pre Battle Enemies) */
enum { HB_BOUNCE = 1, HB_RECOIL = 2 }; /* a hit box (ENT_BOX's flags): a down slash bounces off it, a slash recoils */
enum { HAZ_NONE, HAZ_NORMAL, HAZ_SPIKES, HAZ_ACID, HAZ_LAVA, HAZ_PIT }; /* DamageHero.hazardType */
enum { MK_SECRET = 1, MK_REMASK = 2, MK_SIMPLE = 4 }; /* masks: the unmasker, remasker and inverse FSMs */
@@ -289,6 +291,7 @@ enum { SHAKE_ENEMY_KILL = 1, SHAKE_AVERAGE, SHAKE_BIG, SHAKE_SMALL }; /* the C
void cam_shake(int kind);
enum { RUMBLE_OFF, RUMBLE_SMALL, RUMBLE_MED, RUMBLE_BIG };
void cam_rumble(int kind); /* (RumblingSmall, ...: on until turned off) */
+void ent_set_enabled(int i, bool on); /* (a trigger record on or off: its object (de)activated) */
void cam_freeze(void); /* FreezeInPlace (both) */
void cam_lock(int ent); /* CameraController.LockToArea, the hero entering the area's trigger */
void cam_release(int ent); /* ReleaseLock */
diff --git a/games/hollowknight/src/hk.h b/games/hollowknight/src/hk.h
index f901f38c..9027bc54 100644
--- a/games/hollowknight/src/hk.h
+++ b/games/hollowknight/src/hk.h
@@ -114,7 +114,9 @@ typedef struct {
const SectorRec *secs;
int nnear;
uint8_t near[MAX_LOADED]; /* the sectors near the camera */
+ uint16_t hide_lo, hide_hi; /* (a scene loaded with it, not this time: its sprites' groups, hidden) */
} Room;
+bool room_flag(int flag); /* (game.c: a PlayerData bool, the room's variant chosen by) */
extern Room g_room;
bool room_load(int id);
void room_near(float cx, float cy); /* picks the sectors near the camera */
diff --git a/games/hollowknight/src/room.c b/games/hollowknight/src/room.c
index df5020ff..f021c3ed 100644
--- a/games/hollowknight/src/room.c
+++ b/games/hollowknight/src/room.c
@@ -9,15 +9,34 @@ Room g_room = {.id = -1};
static const uint8_t *room_entry(int id) { return section(SEC_ROOMS) + 4 + ENTRY * id; }
const char *room_name(int id) { return (const char *)room_entry(id); }
+/* (tools/pack.py: RVAR) a room loads with other scenes: by a PlayerData bool, its first one (the room's own entry) or
+ * the alternative (an entry of its own); each one's groups hidden in the other */
+static int room_variant(int id, uint16_t *lo, uint16_t *hi) {
+ const uint8_t *v = section(SEC_RVAR);
+ uint32_t n = rd32(v);
+ *lo = *hi = 0;
+ for (uint32_t i = 0; i < n; i++) {
+ const uint8_t *r = v + 4 + 16 * i;
+ if ((r[0] | r[1] << 8) != id) continue;
+ bool first = room_flag(r[4] | r[5] << 8) == (r[6] != 0);
+ const uint8_t *h = r + (first ? 12 : 8); /* (the other's groups) */
+ *lo = (uint16_t)(h[0] | h[1] << 8), *hi = (uint16_t)(h[2] | h[3] << 8);
+ return first ? id : (r[2] | r[3] << 8);
+ }
+ return id;
+}
+
bool room_load(int id) {
if (id < 0 || id >= NUM_ROOMS) return false;
- const uint8_t *e = room_entry(id);
+ uint16_t lo, hi;
+ const uint8_t *e = room_entry(room_variant(id, &lo, &hi));
uint32_t off = rd32(e + 32), comp = rd32(e + 36), raw = rd32(e + 40);
if (raw > sizeof hdr_ram) return false;
lz_decode(section(SEC_RBLOB) + off, comp, (uint8_t *)hdr_ram, raw);
RoomHdr *h = (RoomHdr *)hdr_ram;
g_room.id = id;
g_room.h = h;
+ g_room.hide_lo = lo, g_room.hide_hi = hi;
g_room.tints = (const uint8_t *)hdr_ram + sizeof(RoomHdr);
g_room.secs = (const SectorRec *)((const uint8_t *)hdr_ram + ((sizeof(RoomHdr) + 4u * h->ntint + 3) & ~3u));
g_room.nnear = 0;
diff --git a/games/hollowknight/src/world.c b/games/hollowknight/src/world.c
index 03cc6dbd..00af0665 100644
--- a/games/hollowknight/src/world.c
+++ b/games/hollowknight/src/world.c
@@ -117,6 +117,7 @@ void world_enter(void) {
memset(es, 0, sizeof es);
memset(fades, 0, sizeof fades);
memset(g_group_alpha, 255, sizeof g_group_alpha);
+ for (int g = g_room.hide_lo; g && g <= g_room.hide_hi && g < MAX_GROUPS; g++) g_group_alpha[g] = 0;
hero_in_position = false;
int n;
const Ent *e = room_ents(&n);
diff --git a/games/hollowknight/tests/play.c b/games/hollowknight/tests/play.c
index 1c7488c3..2197a4ed 100644
--- a/games/hollowknight/tests/play.c
+++ b/games/hollowknight/tests/play.c
@@ -58,6 +58,11 @@ int main(int argc, char **argv) {
if (getenv("HKHEALTH")) g_pd.health = (int8_t)atoi(getenv("HKHEALTH"));
if (getenv("HKGEO")) g_pd.geo = atoi(getenv("HKGEO"));
if (getenv("HKFIRE")) g_pd.fireball_level = atoi(getenv("HKFIRE"));
+ for (const char *f = getenv("HKFLAGS"); f && *f;) { /* (PlayerData bools on, by number: "7,8") */
+ pd_set_flag(atoi(f), true);
+ while (*f && *f != ',') f++;
+ if (*f) f++;
+ }
/* (HKLOAD=slot: that save loaded, the Knight at its respawn point) */
if (getenv("HKLOAD")) {
if (!save_load(atoi(getenv("HKLOAD"))) || (getenv("HKGEO") && (g_pd.geo = atoi(getenv("HKGEO")), 0)) || !game_respawn()) {
@@ -82,9 +87,11 @@ int main(int argc, char **argv) {
dialogue_start(atoi(strchr(getenv("HKTALK"), ':') + 1));
}
if (getenv("HKKILL") && atoi(getenv("HKKILL")) == tick) hero_take_damage(SIDE_LEFT, 99, HAZ_NORMAL);
- if (getenv("HKHIT") && atoi(getenv("HKHIT")) <= tick && tick % 10 == 0) {
+ if (getenv("HKGOD")) g_pd.health = g_pd.max_health;
+ if (getenv("HKHIT") && atoi(getenv("HKHIT")) <= tick &&
+ tick % (getenv("HKHITN") ? atoi(getenv("HKHITN")) : 10) == 0) {
extern void enemies_debug_hit(int damage);
- enemies_debug_hit(21);
+ enemies_debug_hit(getenv("HKHITD") ? atoi(getenv("HKHITD")) : 21);
}
if (getenv("HKPROMPT") && atoi(getenv("HKPROMPT")) == tick)
prompt_show(-1, TXT_PROMPT_LISTEN, g_hero.body.x, g_hero.body.y + 1.5f);
diff --git a/games/hollowknight/tools/actors.py b/games/hollowknight/tools/actors.py
index e856aea6..90fb0821 100644
--- a/games/hollowknight/tools/actors.py
+++ b/games/hollowknight/tools/actors.py
@@ -46,6 +46,12 @@ ENEMY_KINDS = [
("guard", "Zombie Guard", ("sharedassets58.assets", 57), "GUARD", {"IDLE": "Idle"},
["Dormant", "Wake", "Walk", "Run", "Stop Run", "Stop Walk", "Turn", "Anticipate", "Startle", "Stomp Antic",
"Stomp Land", "Attack2", "Swipe", "Stomp Jump"]),
+ ("fk", "FalseyControl", ("sharedassets47.assets", 9), "FK", {"IDLE": "Idle"},
+ ["Jump Antic", "Land", "Jump", "Attack Antic", "Turn", "Jump Attack Up", "Jump Attack Hit 1", "Jump Attack Hit 2",
+ "Jump Attack Hit 3", "Attack", "Attack Recover", "Blank", "Run Antic", "Run", "Stun Roll", "Stun Roll End",
+ "Stun Open", "Stun Hit", "Stun Recover", "Rage", "Death Fall", "Death Land", "Death Head 1", "Death Head 2",
+ "Death Spaz", "Body", "Stun Opened"]),
+ ("fkhead", "Health Check", ("sharedassets47.assets", 9), "FKHEAD", {"IDLE": "Head Idle"}, ["Head Hit", "Head Spaz"]),
]
ENEMY_CORPSE_LIBS = {} # (name -> its corpse's library, if not its own)
@@ -109,6 +115,9 @@ NAMED = {
"DIALOGUE_BACKBOARD": ("resources.assets", 4446, "DialogueManager/DialogueBox/backboard", "hud", 2.325 * text.TEXT_K),
"PROMPT_SHADOW": ("resources.assets", 8342, "Arrow Prompt New/Shadow", 1.0, 0.8),
"CORPSE_NAIL": ("resources.assets", 6648, "Corpse Nail Hero", 1.0),
+ # (the False Knight's barrels, and its staff flung as it dies: a scene's object)
+ "FK_BARREL": ("sharedassets48.assets", 61, "Falling Barrel", 1.0),
+ "FK_STAFF": ("scene:Crossroads_10_boss", 0, "Battle Scene/False Knight New/Staff", 1.0),
}
@@ -116,7 +125,7 @@ def named_sprites(sprites):
"""Registers NAMED in sprites (ents.Sprites) -> {name: sprite id}."""
out = {}
for name, (path, gid, opath, res, *scale) in NAMED.items():
- d = unity.prefab(path, gid)
+ d = unity.scene(path[6:]) if path.startswith("scene:") else unity.prefab(path, gid)
o = next(o for o in d["objects"] if o["path"] == opath)
v = next(c["v"] for c in o["c"] if c["type"] == "SpriteRenderer")
m = np.array(o["m3"]).reshape(3, 3)
diff --git a/games/hollowknight/tools/ents.py b/games/hollowknight/tools/ents.py
index 495c15b9..69c2a0e7 100644
--- a/games/hollowknight/tools/ents.py
+++ b/games/hollowknight/tools/ents.py
@@ -8,7 +8,7 @@ import numpy as np
ENT_CAMLOCK, ENT_GATE, ENT_HAZARD_MARKER, ENT_RESPAWN, ENT_HAZARD_TRIGGER, ENT_MASK, ENT_DAMAGE, ENT_SHAPE, ENT_BOX, \
ENT_OBJ, ENT_PIECE, ENT_SHADE_MARKER = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
# objects (ENT_OBJ's flags: src/obj.c)
-OK_BREAKABLE, OK_ENEMY, OK_GREAT_DOOR, OK_GEO_ROCK, OK_CHEST, OK_BENCH = 1, 2, 3, 4, 5, 6
+OK_BREAKABLE, OK_ENEMY, OK_GREAT_DOOR, OK_GEO_ROCK, OK_CHEST, OK_BENCH, OK_BATTLE, OK_FK_FLOOR = 1, 2, 3, 4, 5, 6, 7, 8
# enemies (an OK_ENEMY's a: src/enemy.c), by their FSM and animation library
import actors as _actors
# enemies: by the FSM (or component) that runs them and their animation library -> their kind (actors.ENEMY_KINDS)
@@ -22,7 +22,8 @@ ENEMY_VARS = {"Zombie Swipe": (["Lunge Speed", "Idle Time"], ["Coward"]),
"Zombie Guard": (["Chase Distance", "Roam Distance"], ["Start Facing Left"])}
# what follows an enemy's record: ENT_BOX records, tagged
ET_COLLIDER, ET_ALERT, ET_RANGE, ET_WALKER, ET_RECOIL, ET_CORPSE, ET_VARS, ET_TERRAIN, ET_HITBOX = 0, 1, 2, 3, 4, 5, 6, 7, 8
-EF_START, EF_STARTLES = 1, 2 # (FSM bools: First Crawler or Start Alert; Startles)
+EF_START, EF_STARTLES, EF_PREBATTLE = 1, 2, 4 # (FSM bools: First Crawler or Start Alert; Startles; one of an arena's
+# Pre Battle Enemies)
# the layers the nail's slashes touch (Physics2D's collision matrix, layer 17 Attack)
ATTACK_HITS = {3, 6, 7, 8, 11, 12, 17, 19, 20, 21, 25, 31}
MAX_GROUPS = 256
@@ -439,7 +440,7 @@ def _enemy(o, by_id, persist, name, d=None, strings=None, owners=None):
print("ents: %s: corpse %s" % (o["path"], e))
if owners:
import coll
- c0, cn = coll.subtree_colliders(d, owners, o["id"])
+ c0, cn = _subcols(d, owners, o["id"])
if cn:
out.append(rec(ENT_BOX, ET_TERRAIN, a=c0, group=cn))
persistent = any(c.get("class") == "PersistentBoolItem" for c in o["c"])
@@ -450,6 +451,15 @@ def _enemy(o, by_id, persist, name, d=None, strings=None, owners=None):
return [head] + out
+COL_BASE = [0] # (a scene loaded with another: its colliders numbered after that one's)
+
+
+def _subcols(d, owners, oid):
+ import coll
+ c0, cn = coll.subtree_colliders(d, owners, oid)
+ return (c0 + COL_BASE[0], cn) if cn else (0, 0)
+
+
def _tk2d_sprite(d, o):
"""An object's tk2dSprite -> (its collection's file, path id, the sprite's name) or None."""
import tk2d, unity
@@ -472,7 +482,7 @@ def _props(d, o, by_id, rooms, strings, persist, sprites, owners, name):
import coll
var = lambda f, k, dflt: (f.get("vars", {}).get(k) or [0, dflt])[1]
hits = _hit_boxes(o, by_id)
- c0, cn = coll.subtree_colliders(d, owners, o["id"]) if owners else (0, 0)
+ c0, cn = _subcols(d, owners, o["id"]) if owners else (0, 0)
persistent = any(c.get("class") == "PersistentBoolItem" for c in o["c"])
f = _fsm(o, ("Great Door",))
if f:
@@ -513,13 +523,15 @@ def _props(d, o, by_id, rooms, strings, persist, sprites, owners, name):
return None
-def room(d, rooms, strings, persist, name, sprites=None, owners=None):
+def room(d, rooms, strings, persist, name, sprites=None, owners=None, rec_base=0, col_base=0, group_base=0):
"""-> (packed records, {object id: render group}). owners: each collider's object (coll.room); sprites: where the
objects' own sprites go (Sprites)."""
import coll
sprites = sprites or Sprites()
recs = []
rec_of, receivers = {}, [] # (an object's record; the records that send HIT to another object's)
+ cam_rec, battles = {}, [] # (camera locks' records; arenas, to point at theirs)
+ prebattle = set()
groups = {}
marker_index = {}
objs = [o for o in d["objects"] if o["active"]]
@@ -529,7 +541,8 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
groups[oid] = g
for c in by_id[oid].get("children", []):
subtree(c, g)
- ngroups = [0]
+ ngroups = [group_base]
+ COL_BASE[0] = col_base
def new_group(oid):
ngroups[0] += 1
@@ -586,8 +599,58 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
group=g_lit, group2=g_light, s0=strings.id(o["name"])))
recs.append(rec(ENT_BOX, 0, box))
recs.append(rec(ENT_BOX, 0, dr or box))
+ f = _fsm(o, ("Battle Control",))
+ if f and "False Knight" in f["vars"]:
+ # the False Knight's arena: its trigger, its camera locks (fixed up below), the armour left after the fight;
+ # its pre-battle enemies marked
+ fv = f["vars"]
+ ref = lambda k: (fv.get(k) or [0, None])[1]
+ arm = ref("Armour")
+ g_arm = new_group(arm[2]) if arm and arm[2] in by_id else 0
+ pre = ref("Pre Battle Enemies")
+ if pre and pre[2] in by_id:
+ todo = list(by_id[pre[2]].get("children", []))
+ while todo:
+ q = todo.pop()
+ prebattle.add(q)
+ todo += by_id[q].get("children", [])
+ persistent = any(c.get("class") == "PersistentBoolItem" for c in o["c"])
+ battles.append((len(recs), (ref("CameraLock 1") or [0, 0, 0])[2], (ref("CameraLock 2") or [0, 0, 0])[2]))
+ recs.append(rec(ENT_OBJ, OK_BATTLE, _trigger(o) or (0, 0, 0, 0), (-1, -1, 1, 0), group=g_arm,
+ persist=persist.id(name, o["path"]) if persistent else NO_PERSIST))
+ f = _fsm(o, ("Floor Control",))
+ if f:
+ # the False Knight's floor: the colliders it loses (Break Floor's), its whole sprites' group, then a record
+ # for each sprite it shows cracked and broken, and its bits (sprite, place, the speed they are flung at)
+ import coll
+ kids = {by_id[c]["name"]: by_id[c] for c in o.get("children", [])}
+ c0, cn = _subcols(d, owners, kids["Break Floor"]["id"]) if owners and "Break Floor" in kids else (0, 0)
+ g_norm = new_group(kids["Normal 1"]["id"]) if "Normal 1" in kids else 0
+ if "Normal 2" in kids:
+ subtree(kids["Normal 2"]["id"], g_norm)
+ extra = []
+ flings = {"Floor Bit 1": (-3, 8), "Floor Bit 2": (2, 6), "Floor Bit 3": (-2, 9)}
+ for k, nm in enumerate(["Cracked 1", "Cracked 2", "Broken", "Floor Bit 1", "Floor Bit 2", "Floor Bit 3"]):
+ q = kids.get(nm)
+ sr = q and next((c["v"] for c in q["c"] if c["type"] == "SpriteRenderer" and (c.get("v") or {}).get("m_Sprite")), None)
+ if not sr:
+ continue
+ import scene
+ m = np.array(q["m3"]).reshape(3, 3)
+ sid = sprites.id(d, sr["m_Sprite"], float(np.hypot(m[0, 0], m[1, 0])))
+ vx, vy = flings.get(nm, (0, 0))
+ extra.append(rec(ENT_BOX, k, (q["pos"][0], q["pos"][1], q["pos"][2], 0), (vx, vy, 0, 0),
+ a=sr.get("m_SortingOrder", 0) + 32768, group=scene.layer_index(sr.get("m_SortingLayerID", 0)),
+ s0=sid))
+ recs.append(rec(ENT_OBJ, OK_FK_FLOOR, (o["pos"][0], o["pos"][1], 0, 0), a=c0, group=cn, group2=g_norm,
+ s0=len(extra)))
+ recs += extra
en = _enemy(o, by_id, persist, name, d, strings, owners) or _props(d, o, by_id, rooms, strings, persist, sprites, owners, name)
if en:
+ if o["id"] in prebattle and en[0][1] == OK_ENEMY:
+ b = bytearray(en[0])
+ struct.pack_into("<H", b, 42, struct.unpack_from("<H", b, 42)[0] | EF_PREBATTLE)
+ en[0] = bytes(b)
recs += en
br = next((c for c in o["c"] if c.get("class") == "Breakable" and c.get("v") is not None), None)
if br is not None:
@@ -603,8 +666,8 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
g2 = ngroups[0]
for r in rem:
subtree(r, g2)
- c0, cn = coll.subtree_colliders(d, owners, o["id"]) if owners else (0, 0)
- if rem and owners and any(coll.subtree_colliders(d, owners, r)[1] for r in rem):
+ c0, cn = _subcols(d, owners, o["id"]) if owners else (0, 0)
+ if rem and owners and any(_subcols(d, owners, r)[1] for r in rem):
print("ents: %s: remnant colliders not handled" % o["path"])
debris = [r[1] for r in v.get("debrisParts") or [] if r]
pieces = _pieces(d, o, debris, by_id, sprites)
@@ -647,6 +710,7 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
continue
fl = (CL_PREVENT_UP if v.get("preventLookUp") else 0) | (CL_PREVENT_DOWN if v.get("preventLookDown") else 0) | \
(CL_MAX_PRIORITY if v.get("maxPriority") else 0)
+ cam_rec[o["id"]] = len(recs)
recs.append(rec(ENT_CAMLOCK, fl, box, (v["cameraXMin"], v["cameraYMin"], v["cameraXMax"], v["cameraYMax"])))
recs += _more_boxes(o)
elif cls == "TransitionPoint":
@@ -661,7 +725,7 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
# (its respawn marker: a component; the record of its object)
ref = v.get("respawnMarker")
mid = ref[1] if isinstance(ref, (list, tuple)) else None
- marker = next((marker_index[oo["id"]] for oo in objs for cc in oo["c"] if cc.get("pid") == mid and
+ marker = next((marker_index[oo["id"]] + rec_base for oo in objs for cc in oo["c"] if cc.get("pid") == mid and
oo["id"] in marker_index), -1)
off = v.get("entryOffset") or {"x": 0, "y": 0}
recs.append(rec(ENT_GATE, fl, box, (float(v.get("entryDelay", 0)), off["x"], off["y"], marker + 1), a=ti,
@@ -681,13 +745,18 @@ def room(d, rooms, strings, persist, name, sprites=None, owners=None):
target = oo["id"]
if box is None or target not in marker_index:
continue
- recs.append(rec(ENT_HAZARD_TRIGGER, box=box, a=marker_index[target]))
+ recs.append(rec(ENT_HAZARD_TRIGGER, box=box, a=marker_index[target] + rec_base))
recs += _more_boxes(o)
+ # (arenas: their camera locks' records)
+ for i, c1, c2 in battles:
+ b = bytearray(recs[i])
+ struct.pack_into("<2f", b, 24, cam_rec[c1] + rec_base if c1 in cam_rec else -1, cam_rec[c2] + rec_base if c2 in cam_rec else -1)
+ recs[i] = bytes(b)
# (an object that sends HIT to another: that one's record + 1 in its box's y1)
for i, target in receivers:
if target in rec_of:
b = bytearray(recs[i])
- struct.pack_into("<f", b, 20, rec_of[target] + 1)
+ struct.pack_into("<f", b, 20, rec_of[target] + rec_base + 1)
recs[i] = bytes(b)
else:
print("ents: %s: HIT receiver %d has no record" % (name, target))
diff --git a/games/hollowknight/tools/pack.py b/games/hollowknight/tools/pack.py
index 02471910..35a04147 100644
--- a/games/hollowknight/tools/pack.py
+++ b/games/hollowknight/tools/pack.py
@@ -7,7 +7,10 @@ sys.path.insert(0, HERE)
import unity, scene, visible, art, actors, coll, ents, font, text
SRC = os.path.join(HERE, "..", "src")
-ROOMS = [l.strip() for l in open(os.path.join(HERE, "rooms.txt")) if l.strip() and not l.startswith("#")]
+ALL_ROOMS = [l.strip() for l in open(os.path.join(HERE, "rooms.txt")) if l.strip() and not l.startswith("#")]
+# (scenes loaded with others are part of those: two variants of the room, by a PlayerData bool)
+ROOMS = [r for r in ALL_ROOMS if r not in scene.additive_scenes(ALL_ROOMS)]
+VARIANT_ROOMS = [r for r in ROOMS if scene.additive(r)]
STRINGS = ents.Strings()
PERSIST = ents.Persist()
SPRITES = ents.Sprites()
@@ -18,18 +21,55 @@ PROMPTS = ["Listen", "Rest", "Inspect", "Enter", "Sit", "Shop", "Travel", "Ascen
ROOM_DATA = {} # name -> (coll.room's, ents.room's)
-def room_data(name):
- """A room's ground and objects (once: the objects' sprites go into SPRITES)."""
- if name not in ROOM_DATA:
+def room_data(name, variant=0):
+ """A room's ground and objects (once: the objects' sprites go into SPRITES) -> (coll.room's, (records, {(scene,
+ object id): group}), {which: its groups (first, last)}). With the scenes it loads with it: variant 0 has the first's
+ (which 1), variant 1 the alternative's (which 2); the groups of both numbered the same in either, after the room's;
+ (scene, None): the group of a scene's sprites with none of their own."""
+ if (name, variant) not in ROOM_DATA:
d = unity.scene(name)
st = scene.settings(d)
w, h = st["size"] if st["size"] else (40, 24)
- cr = coll.room(d, w, h)
- ROOM_DATA[name] = (cr, ents.room(d, ROOMS, STRINGS, PERSIST, name, SPRITES, cr[3]))
- return ROOM_DATA[name]
+ solid, segs, cols, owners = coll.room(d, w, h)
+ recs, gr = ents.room(d, ROOMS, STRINGS, PERSIST, name, SPRITES, owners)
+ groups = {(name, k): g for k, g in gr.items()}
+ segs, cols, recs = list(segs), list(cols), list(recs)
+ gb = max(gr.values(), default=0)
+ spans = {}
+ for an, flag, val, which in scene.additive(name):
+ da = unity.scene(an)
+ _, asegs, acols, aown = coll.room(da, w, h)
+ ar, ag = ents.room(da, ROOMS, STRINGS, PERSIST, an, SPRITES, aown, rec_base=len(recs), col_base=len(cols),
+ group_base=gb)
+ cond = max(ag.values(), default=gb) + 1
+ groups.update({(an, k): g for k, g in ag.items()})
+ groups[(an, None)] = cond
+ spans[which] = (gb + 1, cond)
+ gb = cond
+ if (which == 1) == (variant == 0):
+ segs += [(x0, y0, x1, y1, ci + len(cols)) for x0, y0, x1, y1, ci in asegs]
+ cols += acols
+ recs += ar
+ assert gb < ents.MAX_GROUPS, (name, gb)
+ ROOM_DATA[(name, variant)] = ((solid, segs, cols, owners), (recs, groups), spans)
+ return ROOM_DATA[(name, variant)]
SECTIONS = ["TEX", "TMAP", "PAL", "BIDX", "BLK", "ROOMS", "RBLOB", "PRIOR", "SOFT", "SPR", "CLIP", "STR", "TEXT", "FONT", "PHASH",
- "SCOL"]
+ "SCOL", "RVAR"]
+
+
+def _pdf_flags():
+ """PlayerData's bools as the game numbers them (src/game.h: PDF_*), by their names in the game ("falseKnightDefeated")"""
+ import re
+ src = open(os.path.join(SRC, "game.h")).read()
+ names = re.search(r"enum \{\s*(PDF_AT_BENCH[^}]*)\}", src).group(1)
+ ids = [n.strip() for n in names.replace("\n", " ").split(",") if n.strip() and n.strip() != "PDF_COUNT"]
+ camel = lambda n: "".join(w.capitalize() for w in n[4:].lower().split("_"))
+ out = {}
+ for i, n in enumerate(ids):
+ c = camel(n)
+ out[c[0].lower() + c[1:]] = i
+ return out
BLENDS = {"alpha": 0, "add": 1, "screen": 2, "linearlight": 3, "overlay": 4, "multiply": 5}
F_LIT, F_ROT, F_SOLID, F_DYN, F_GRASS = 8, 16, 32, 64, 128
@@ -180,16 +220,16 @@ def sector_stream(recs):
return bytes(out)
-def room_blobs(name, keep, st, tex_id):
+def room_blobs(name, keep, st, tex_id, variant=0):
"""A room: its header (kept in RAM) and its instances in sectors (decoded when the camera is near)."""
w, h = st["size"] if st["size"] else (40, 24)
cx0, cx1, cy0, cy1 = scene.camera_range(st) if st["size"] else (20, 20, 12, 12)
axis = 0 if (cx1 - cx0) >= (cy1 - cy0) else 1
lo, hi = (cx0, cx1) if axis == 0 else (cy0, cy1)
HWU, HHU = scene.VIEW_W / 2 / scene.FOCAL, scene.VIEW_H / 2 / scene.FOCAL
- (solid, segs, cols, _), (erecs, groups) = room_data(name)
+ (solid, segs, cols, _), (erecs, groups), _ = room_data(name, variant)
for it in keep:
- it.group = groups.get(it.obj["id"], 0)
+ it.group = groups.get((it.scene, it.obj["id"]), groups.get((it.scene, None), 0) if it.which else 0)
tints = [(255, 255, 255, 255)]
secs = {}
for rank, it in enumerate(keep):
@@ -300,6 +340,8 @@ def main():
TEXTS.id("Elderbug", "ELDERBUG_INTRO_MAIN") # (until the NPCs: a conversation to try)
for r in ROOMS:
room_data(r)
+ if r in VARIANT_ROOMS:
+ room_data(r, 1)
sprites += actors.unity_sprites(SPRITES.list)
# the HUD's geo count: TrajanPro-Bold digits (TextMesh: size 45, character size 1, scale 0.1527)
digit_base = len(sprites)
@@ -409,23 +451,35 @@ def main():
name = v.name if isinstance(v, art.ImageJob) else v.sprite.name
f.write("%d %s %.3f %d %d %dx%d %d\n" % (i, name.replace(" ", "_"), getattr(v, "scale", 1.0), v.blur, v.alpha_only,
t.w, t.h, t.ntiles))
- rooms = bytearray(struct.pack("<I", len(ROOMS)))
- for r in ROOMS:
- keep, st = per_room[r]
- body, o_sec, blobs, ground, recs = room_blobs(r, keep, st, tex_id)
+ rooms = bytearray(struct.pack("<I", len(ROOMS) + len(VARIANT_ROOMS)))
+ sector_offs, rvar = {}, bytearray(struct.pack("<I", len(VARIANT_ROOMS)))
+ pdf = _pdf_flags()
+ for r in ROOMS + [r + "@1" for r in VARIANT_ROOMS]:
+ base, variant = (r[:-2], 1) if r.endswith("@1") else (r, 0)
+ keep, st = per_room[base]
+ body, o_sec, blobs, ground, recs = room_blobs(base, keep, st, tex_id, variant)
struct.pack_into("<I", body, 76, secs["RBLOB"].add(ground))
struct.pack_into("<I", body, 80, secs["RBLOB"].add(recs))
packed = 0
for i, (c, n) in enumerate(blobs):
- off = secs["RBLOB"].add(c)
+ # (a room's variant: the same sectors)
+ off = sector_offs[(base, i)] if variant else secs["RBLOB"].add(c)
+ sector_offs[(base, i)] = off
struct.pack_into("<II", body, o_sec + 20 * i, off, len(c))
packed += len(c)
+ if variant:
+ # its variants: which entry, by which PlayerData bool, and each one's groups to hide in the other
+ (flag, val), spans = next(((a[1], a[2]) for a in scene.additive(base)), ("", False)), room_data(base)[2]
+ s1, s2 = spans.get(1, (0, 0)), spans.get(2, (0, 0))
+ rvar += struct.pack("<HHHBB4H", ROOMS.index(base), len(ROOMS) + VARIANT_ROOMS.index(base), pdf[flag], val, 0,
+ *s1, *s2)
hc = lz(bytes(body))
off = secs["RBLOB"].add(hc)
assert len(r) < 32, r
- rooms += struct.pack("<32sIII", r.encode(), off, len(hc), len(body))
+ rooms += struct.pack("<32sIII", base.encode(), off, len(hc), len(body))
print("room %-26s %5d instances in %2d sectors, %6d packed, ground %d, recs %d" % (r, len(keep), len(blobs), packed + len(hc), len(ground), len(recs)), flush=True)
secs["ROOMS"].b += rooms
+ secs["RVAR"].b += rvar
secs["STR"].b += STRINGS.blob()
secs["TEXT"].b += TEXTS.blob()
secs["FONT"].b += TEXTS.fonts()
diff --git a/games/hollowknight/tools/scene.py b/games/hollowknight/tools/scene.py
index 9952db04..4eda46f5 100644
--- a/games/hollowknight/tools/scene.py
+++ b/games/hollowknight/tools/scene.py
@@ -129,8 +129,44 @@ class Inst:
pass
[email protected]_cache(maxsize=None)
+def additive(name):
+ """The scenes a scene loads with it (SceneAdditiveLoadConditional): [(scene, PlayerData bool, value, which)]: the
+ first (which 1) loaded when the bool has that value, the alternative (which 2) otherwise."""
+ out = []
+ for o in unity.scene(name)["objects"]:
+ for c in o["c"]:
+ v = c.get("v") or {}
+ if c.get("class") == "SceneAdditiveLoadConditional" and o["active"]:
+ flag, val = v.get("needsPlayerDataBool", ""), bool(v.get("playerDataBoolValue"))
+ if v.get("sceneNameToLoad"):
+ out.append((v["sceneNameToLoad"], flag, val, 1))
+ if v.get("altSceneNameToLoad"):
+ out.append((v["altSceneNameToLoad"], flag, val, 2))
+ return out
+
+
+def additive_scenes(rooms):
+ return {a[0] for r in rooms for a in additive(r)}
+
+
[email protected]_cache(maxsize=None)
def instances(name):
- """The scene's SpriteRenderers, active and enabled, in a fixed draw order (sorting layer, order, depth)."""
+ """The scene's SpriteRenderers, active and enabled, in a fixed draw order (sorting layer, order, depth); with those
+ of the scenes it loads with it (tagged: it.scene, it.which)."""
+ out = _instances(name)
+ for k, (an, _, _, which) in enumerate(additive(name)):
+ for it in _instances(an):
+ it.scene, it.which = an, which
+ out.append(it)
+ if additive(name):
+ out.sort(key=lambda i: (i.layer, i.order, -i.z))
+ for k, it in enumerate(out):
+ it.id = k
+ return out
+
+
+def _instances(name):
d = unity.scene(name)
level, exts = d["level"], tuple(d["externals"])
dyn = dynamic_ids(d)
@@ -151,6 +187,7 @@ def instances(name):
mat = unity.material(unity.ref_path(d, mats[0][0]), mats[0][1]) if mats and mats[0] else ("?", "?")
col = v["m_Color"]
it = Inst()
+ it.scene, it.which = name, 0
it.obj, it.sprite, it.mat = o, s, mat
it.pos, it.m3 = o["pos"], o["m3"]
it.color = (col["r"], col["g"], col["b"], col["a"])