Files
Triforce-Source/host/prompts.c
ruckus7382sfgsgdf 93eeb714c2 Triforce v0.4.0
What was merged from NX2navi (DLSS frame generation, AMD FSR 4 in Setup builds, texture detail by video memory, sprint, volume, frame caps, safer saves, the above-60 fixes), the ultrawide HUD at the screen edges, camera speed, movies without the AV1 Video Extension, the 5120x2880 + RenoDX HDR start fix, the renderer work of 11-14 and the first float changes of the lift.
2026-11-15 06:39:00 -06:00

610 lines
30 KiB
C

/* (hookshot) The button prompts of the controller in use: the game's button-icon font (Font2/Scalable/External.*.bfotf,
every icon in a text: dialogue, the control hints, menus) served from prompts/<face>/External.bfotf in the game folder,
which nx2/prompt_assets.py draws per controller face at build time, with each Switch button's icon pointed at the icon of
the pad input bound to it (host/nn_hid.c's controls, the menu's Layout preset and Controls page). So the icons say which
button to press on this pad, custom controls too.
The face: triforce_options.ini's button_prompts (the menu's Button prompts row): 0 Auto, from the first controller's name
(SDL), else 1 Switch, 2 Xbox, 3 PlayStation 4, 4 PlayStation 5, 5 Steam Deck. The game reads the font once, at its start:
a new face or new controls show at the next start.
The font as built: an OpenType font behind an 8-byte header, XORed per little-endian word with the key the header's magic
(0x18029a7f) gives. Its cmap has one icon per pad input at U+F700 + HOS_PAD_*, and each Switch button's code point in a
format 4 segment of its own, by idDelta: pointing a button at another icon is that segment's idDelta. The result goes out
as a zstd frame of raw blocks (the file name says .zs; the game's decoder takes a frame made without its dictionary). */
#include "hos.h"
#include "hos_paths.h"
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "../gpu/vk/vk_api.h" /* (HOS_SW_*, HOS_PAD_*, HOS_BIND_PAD) */
int hos_binding(int set, int button, int slot); /* nn_hid.c */
int hos_sdl_pads(uint64_t *buttons, int32_t stick[4]); /* pad_sdl.c */
void hos_sdl_pad_first_name(char *out, size_t cap);
int hos_mods_has(const char *prefix, const char *suffix); /* mods.c */
#define FONT_PATH "font2/scalable/external.nin_ounce_nvn2.bfotf.zs" /* (as hos_mods_romfs's keys: lower case) */
#define TEXTURES_PATH "ui/layout2archive/common.product.100.nin_ounce_nvn2.bntx.zs"
#define LAYOUTS_PATH "ui/layout2archive/common.product.100.nin_ounce_nvn2.blarc.zs"
#define SIZES_PATH "system/resource/resourcesizetable." /* (then the version, ".rsizetable.zs") */
#define CAMERA_PATH "pack/actor/playercamera.pack.zs" /* (Triforce: the Camera speed row, build_camera) */
#define MAGIC 0x18029a7fu
#define PAD_BASE 0xF700
static const char *const faces[HOS_PROMPT_N] = {"switch", "xbox", "ps4", "ps5", "steamdeck"};
/* the Switch buttons' code points in the font, in HOS_SW_* order (nx2/prompt_assets.py SWITCH) */
static const uint16_t switch_code[HOS_SW_N] = {0xE040, 0xE041, 0xE042, 0xE043, 0xE056, 0xE057, 0xE044, 0xE045,
0xE046, 0xE047, 0xE04B, 0xE04C, 0xE062, 0xE060, 0xE063, 0xE061};
static int game_dir(char *out, size_t cap) { /* the game folder, with its separator */
char path[MAX_PATH];
const DWORD len = hos_game_path_a(path, MAX_PATH);
char *slash = len ? (strrchr(path, 92) ? strrchr(path, 92) : strrchr(path, 47)) : NULL; /* (linux: '/') */
if (!slash) return 0;
slash[1] = 0;
snprintf(out, cap, "%s", path);
return 1;
}
static int contains(const char *text, const char *word) { /* (any case) */
for (; *text; text++) {
size_t i = 0;
while (word[i] && tolower((unsigned char)text[i]) == word[i]) i++;
if (!word[i]) return 1;
}
return 0;
}
/* HOS_PROMPT_* (faces[]) */
static int choose_face(const char *dir) {
char path[MAX_PATH], line[80];
int choice = 0;
snprintf(path, sizeof path, "%striforce_options.ini", dir);
FILE *f = fopen(path, "r");
if (f) {
while (fgets(line, sizeof line, f))
if (!strncmp(line, "button_prompts=", 15)) choice = atoi(line + 15);
fclose(f);
}
if (choice >= 1 && choice <= HOS_PROMPT_N) return choice - 1;
/* Auto: the first controller SDL opens (it scans every second: up to 1.5 s for one, at the game's start) */
char name[128] = "";
uint64_t b = 0;
int32_t s[4] = {0};
for (int i = 0; i < 30 && !name[0]; i++) {
hos_sdl_pads(&b, s);
hos_sdl_pad_first_name(name, sizeof name);
if (!name[0]) Sleep(50);
}
int face;
if (!name[0]) face = HOS_PROMPT_SWITCH; /* (no controller: the keyboard, the game's own icons; or XInput without SDL) */
else if (contains(name, "dualsense") || contains(name, "ps5")) face = HOS_PROMPT_PS5;
else if (contains(name, "dualshock") || contains(name, "ps4") || contains(name, "playstation")) face = HOS_PROMPT_PS4;
else if (contains(name, "steam deck")) face = HOS_PROMPT_STEAMDECK;
else if (contains(name, "nintendo") || contains(name, "switch") || contains(name, "joy-con")) face = HOS_PROMPT_SWITCH;
else face = HOS_PROMPT_XBOX; /* (Xbox pads, and the many that copy their layout) */
hos_log("prompts: auto: controller \"%s\": %s", name[0] ? name : "(none)", faces[face]);
return face;
}
static uint32_t rd32le(const uint8_t *p) { return p[0] | p[1] << 8 | p[2] << 16 | (uint32_t)p[3] << 24; }
static void wr32le(uint8_t *p, uint32_t v) { p[0] = (uint8_t)v, p[1] = (uint8_t)(v >> 8), p[2] = (uint8_t)(v >> 16), p[3] = (uint8_t)(v >> 24); }
static unsigned rd16(const uint8_t *p) { return p[0] << 8 | p[1]; }
static uint32_t rd32(const uint8_t *p) { return (uint32_t)p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]; }
static void wr16(uint8_t *p, unsigned v) { p[0] = (uint8_t)(v >> 8), p[1] = (uint8_t)v; }
/* the glyph of a code point in a format 4 subtable (st: its start, n its bytes), 0 none */
static unsigned cmap4_glyph(const uint8_t *st, size_t n, unsigned code) {
const unsigned segs = rd16(st + 6) / 2;
if (14 + 8 * (size_t)segs + 2 > n) return 0;
const uint8_t *ends = st + 14, *starts = ends + 2 * segs + 2, *deltas = starts + 2 * segs, *ranges = deltas + 2 * segs;
for (unsigned i = 0; i < segs; i++) {
if (rd16(ends + 2 * i) < code) continue;
if (rd16(starts + 2 * i) > code) return 0;
const unsigned ro = rd16(ranges + 2 * i);
if (!ro) return (code + rd16(deltas + 2 * i)) & 0xFFFF;
const uint8_t *g = ranges + 2 * i + ro + 2 * (code - rd16(starts + 2 * i));
if (g + 2 > st + n) return 0;
const unsigned gid = rd16(g);
return gid ? (gid + rd16(deltas + 2 * i)) & 0xFFFF : 0;
}
return 0;
}
/* each Switch button's segment pointed at its pad input's icon; how many */
static int cmap4_bind(uint8_t *st, size_t n) {
const unsigned segs = rd16(st + 6) / 2;
if (14 + 8 * (size_t)segs + 2 > n) return 0; /* (as cmap4_glyph: the ranges' last entry too) */
uint8_t *ends = st + 14, *starts = ends + 2 * segs + 2, *deltas = starts + 2 * segs, *ranges = deltas + 2 * segs;
int done = 0;
for (int b = 0; b < HOS_SW_N; b++) {
const int pad = hos_binding(HOS_BIND_PAD, b, 0);
if (pad < 0 || pad >= HOS_PAD_N) continue; /* (unbound: the default icon stays) */
const unsigned gid = cmap4_glyph(st, n, PAD_BASE + (unsigned)pad);
if (!gid) continue;
for (unsigned i = 0; i < segs; i++)
if (rd16(starts + 2 * i) == switch_code[b] && rd16(ends + 2 * i) == switch_code[b] && !rd16(ranges + 2 * i)) {
wr16(deltas + 2 * i, (gid - switch_code[b]) & 0xFFFF);
done++;
break;
}
}
return done;
}
/* the controls into the decrypted font's format 4 subtables; how many buttons */
static int bind_font(uint8_t *otf, size_t n) {
if (n < 12) return 0;
const unsigned tables = rd16(otf + 4);
for (unsigned t = 0; t < tables && 12 + 16 * (size_t)(t + 1) <= n; t++) {
const uint8_t *rec = otf + 12 + 16 * t;
if (memcmp(rec, "cmap", 4)) continue;
const uint32_t off = rd32(rec + 8), len = rd32(rec + 12);
if (off > n || len > n - off || len < 4) return 0;
uint8_t *cmap = otf + off;
const unsigned subs = rd16(cmap + 2);
uint32_t seen[8];
int nseen = 0, done = 0;
for (unsigned s = 0; s < subs && 4 + 8 * (size_t)(s + 1) <= len; s++) {
const uint32_t so = rd32(cmap + 4 + 8 * s + 4);
if (so > len || len - so < 14 || rd16(cmap + so) != 4) continue; /* (so + 14 wrapped past 4 GB) */
int dup = 0; /* (platforms 0 and 3 share one subtable) */
for (int k = 0; k < nseen; k++) dup |= seen[k] == so;
if (dup) continue;
if (nseen < 8) seen[nseen++] = so;
const unsigned sl = rd16(cmap + so + 2);
done = cmap4_bind(cmap + so, sl <= len - so ? sl : len - so);
}
return done;
}
return 0;
}
/* a zstd frame's header for raw blocks of 128 KB: the 4-byte content size, and a window of 128 KB (raw blocks never look back:
a single-segment frame's window, the whole content, is more than decoders take: zstd's own refuses 244 MB) */
static void zstd_head(uint8_t head[10], size_t n) {
wr32le(head, 0xFD2FB528u);
head[4] = 0x80; /* (FCS 4 bytes, not single segment, no checksum, no dictionary) */
head[5] = 7 << 3; /* (window 2^(10+7)) */
wr32le(head + 6, (uint32_t)n);
}
/* one raw block of a frame (zstd_head): k bytes (at most 128 KB), last for the frame's last */
static int zstd_block(FILE *o, const uint8_t *data, size_t k, int last) {
const uint32_t bh = (uint32_t)(k << 3) | (last ? 1u : 0u);
const uint8_t b3[3] = {(uint8_t)bh, (uint8_t)(bh >> 8), (uint8_t)(bh >> 16)};
return fwrite(b3, 1, 3, o) == 3 && fwrite(data, 1, k, o) == k;
}
/* data as a zstd frame of raw blocks (zstd_head) */
static int write_zstd_raw(const char *path, const uint8_t *data, size_t n) {
FILE *f = fopen(path, "wb");
if (!f) return 0;
uint8_t head[10];
zstd_head(head, n);
int ok = fwrite(head, 1, 10, f) == 10;
size_t at = 0;
do {
const size_t k = n - at < 131072 ? n - at : 131072;
ok &= zstd_block(f, data + at, k, at + k == n);
at += k;
} while (at < n);
ok &= fclose(f) == 0;
return ok;
}
static uint8_t *read_all(const char *path, const char *magic, long *n) { /* (the whole file, if it starts with magic: NULL any) */
FILE *f = fopen(path, "rb");
if (!f) return NULL;
fseek(f, 0, SEEK_END);
*n = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t *t = *n > 8 ? (uint8_t *)malloc((size_t)*n) : NULL;
const int got = t && fread(t, 1, (size_t)*n, f) == (size_t)*n;
fclose(f);
if (!got || (magic && memcmp(t, magic, 4))) {
free(t);
return NULL;
}
return t;
}
static volatile LONG setup_state; /* setup's: 0 not looked, 1 looking, 2 prompts, 3 none */
/* the game folder and the face, found once; 0 when the folder has no prompts/ (built before them: the game's own icons) */
static int setup(char *dir, size_t cap, int *face) {
static char d[MAX_PATH];
static int f;
if (InterlockedCompareExchange(&setup_state, 1, 0) == 0) {
char path[MAX_PATH];
int ok = game_dir(d, sizeof d);
if (ok) {
snprintf(path, sizeof path, "%sprompts", d);
ok = GetFileAttributesA(path) != INVALID_FILE_ATTRIBUTES;
}
if (ok) f = choose_face(d);
/* (v0.3.5 shipped tools whose Python lacked nx2/prompt_requirements.txt: no folder was made, the Button prompts
setting did nothing, and the log said nothing of it) */
else hos_log("prompts: no prompts folder beside the game: the game's own icons, whatever Button prompts is set to "
"(Setup's Update makes them)");
InterlockedExchange(&setup_state, ok ? 2 : 3);
}
while (setup_state == 1) Sleep(1);
snprintf(dir, cap, "%s", d);
*face = f;
return setup_state == 2;
}
static uint64_t fnv(uint64_t h, const void *p, size_t n) {
for (size_t i = 0; i < n; i++) h = (h ^ ((const uint8_t *)p)[i]) * 0x100000001b3ull;
return h;
}
typedef struct { uint32_t off, len, idx; const uint8_t *data; } Run; /* (idx: its place in textures.bin) */
static int run_cmp(const void *a, const void *b) {
const Run *x = (const Run *)a, *y = (const Run *)b;
return x->off != y->off ? (x->off < y->off ? -1 : 1) : (x->idx > y->idx) - (x->idx < y->idx);
}
static int run_order(const void *a, const void *b) {
const uint32_t x = (*(const Run *const *)a)->idx, y = (*(const Run *const *)b)->idx;
return (x > y) - (x < y);
}
static void add_run(Run **runs, size_t *nruns, size_t *cap, uint32_t off, uint32_t len, const uint8_t *data) {
if (*nruns == *cap) *runs = (Run *)realloc(*runs, (*cap *= 2) * sizeof **runs);
(*runs)[*nruns] = (Run){off, len, (uint32_t)*nruns, data};
(*nruns)++;
}
/* prompts/Common.bntx.zs: the game's textures (prompts/Common.bntx) with the blocks of prompts/<face>/textures.bin that this
pad's controls choose (nx2/prompt_assets.py: "HPTX", u32 count; each: u8 Switch button (0xff: always), u8 pad input, u16,
u32 runs; each run: u32 offset, u32 length, the bytes; a later entry over an earlier). Written again only when the face, the
controls or the blocks changed (prompts/Common.key) */
/* out: the game's file (game) with the runs written over it (a later one over an earlier where they meet), as raw zstd blocks;
written again only when its key (keypath: the hash h of what chose the runs) changed */
static int write_patched(const char *game, const char *out, const char *keypath, uint64_t h, Run *runs, size_t nruns) {
qsort(runs, nruns, sizeof *runs, run_cmp);
char keyline[32] = "", want[32];
FILE *f;
if ((f = fopen(keypath, "r"))) {
if (!fgets(keyline, sizeof keyline, f)) keyline[0] = 0;
fclose(f);
}
snprintf(want, sizeof want, "%016llx", (unsigned long long)h);
int ok = !strcmp(keyline, want) && GetFileAttributesA(out) != INVALID_FILE_ATTRIBUTES;
if (!ok) { /* the game's file through, the chosen runs written over it, out as raw zstd blocks */
FILE *in = fopen(game, "rb"), *o = fopen(out, "wb");
uint8_t *chunk = (uint8_t *)malloc(131072);
ok = in && o && chunk;
if (ok) {
fseek(in, 0, SEEK_END);
const uint64_t n = (uint64_t)ftell(in);
fseek(in, 0, SEEK_SET);
uint8_t head[10];
zstd_head(head, n);
ok = n < 0xFFFFFFFFull && fwrite(head, 1, 10, o) == 10;
size_t first = 0; /* (the first run that may reach this chunk) */
const Run **here = (const Run **)malloc((nruns ? nruns : 1) * sizeof *here);
ok = ok && here;
for (uint64_t pos = 0; ok && pos < n;) {
const size_t k = n - pos < 131072 ? (size_t)(n - pos) : 131072;
ok = fread(chunk, 1, k, in) == k;
while (first < nruns && runs[first].off + runs[first].len <= pos) first++;
size_t nh = 0; /* (the runs in this chunk, written in their order: a later one over an earlier) */
for (size_t r = first; r < nruns && runs[r].off < pos + k; r++)
if (runs[r].off + runs[r].len > pos) here[nh++] = &runs[r];
qsort(here, nh, sizeof *here, run_order);
for (size_t i = 0; i < nh; i++) {
const Run *r = here[i];
const uint64_t a = r->off > pos ? r->off : pos;
const uint64_t z = r->off + r->len < pos + k ? r->off + r->len : pos + k;
memcpy(chunk + (a - pos), r->data + (a - r->off), (size_t)(z - a));
}
ok = ok && zstd_block(o, chunk, k, pos + k == n);
pos += k;
}
free(here);
}
if (in) fclose(in);
if (o) ok &= fclose(o) == 0;
free(chunk);
if (ok && (f = fopen(keypath, "w"))) {
fputs(want, f);
fclose(f);
}
}
return ok;
}
static int build_textures(char *out, size_t cap) {
char dir[MAX_PATH], path[MAX_PATH];
int face;
if (!setup(dir, sizeof dir, &face)) return 0;
snprintf(path, sizeof path, "%sprompts/%s/textures.bin", dir, faces[face]);
long tn;
uint8_t *t = read_all(path, "HPTX", &tn);
if (!t) return 0; /* (built without the textures: the game's) */
int bind[HOS_SW_N];
for (int b = 0; b < HOS_SW_N; b++) bind[b] = hos_binding(HOS_BIND_PAD, b, 0);
uint64_t h = fnv(fnv(fnv(0xcbf29ce484222325ull, &face, sizeof face), bind, sizeof bind), t, (size_t)tn);
/* the runs these controls choose */
const uint32_t count = rd32le(t + 4);
size_t at = 8, nruns = 0, cap_runs = 256;
Run *runs = (Run *)malloc(cap_runs * sizeof *runs);
for (uint32_t e = 0; e < count && at + 8 <= (size_t)tn; e++) {
const int sw = t[at], pad = t[at + 1];
const uint32_t nr = rd32le(t + at + 4);
const int on = sw == 0xff || (sw < HOS_SW_N && bind[sw] == pad);
at += 8;
for (uint32_t r = 0; r < nr && at + 8 <= (size_t)tn; r++) {
const uint32_t off = rd32le(t + at), len = rd32le(t + at + 4);
if (len > (size_t)tn - at - 8) break;
if (on) add_run(&runs, &nruns, &cap_runs, off, len, t + at + 8);
at += 8 + len;
}
}
snprintf(out, cap, "%sprompts/Common.bntx.zs", dir);
snprintf(path, sizeof path, "%sprompts/Common.bntx", dir);
char keypath[MAX_PATH];
snprintf(keypath, sizeof keypath, "%sprompts/Common.key", dir);
const int ok = write_patched(path, out, keypath, h, runs, nruns);
hos_log("prompts: %s textures, %zu runs for this pad's controls%s", faces[face], nruns,
ok ? "" : ": could not be written");
free(runs);
free(t);
return ok;
}
/* the face the game was given (faces[]), -1 none: the Insert menu names the pad inputs as that controller does. -1 too
until the game has asked for a prompt file: the menu asks from the present thread, and choose_face can wait for SDL */
int hos_prompts_face(void) {
char dir[MAX_PATH];
int face;
return setup_state >= 2 && setup(dir, sizeof dir, &face) ? face : -1;
}
/* the Talk ring's place for each of A B X Y (0 east, 1 south, 2 north, 3 west: nx2/prompt_assets.py RING_PLACES): where its pad
input is among the face buttons, else its own place on the Switch when free, else the first one free */
static void ring_places(const int *bind, int place[4]) {
static const int of_pad[4] = {1, 0, 3, 2}; /* (HOS_PAD_SOUTH, EAST, WEST, NORTH) */
int taken[4] = {0};
for (int s = 0; s < 4; s++) {
const int p = bind[s] >= 0 && bind[s] < 4 ? of_pad[bind[s]] : -1;
place[s] = p >= 0 && !taken[p] ? p : -1;
if (place[s] >= 0) taken[place[s]] = 1;
}
for (int s = 0; s < 4; s++) {
if (place[s] >= 0) continue;
int p = s; /* (A B X Y's own places are 0 1 2 3) */
if (taken[p])
for (p = 0; taken[p]; p++) {}
place[s] = p;
taken[p] = 1;
}
}
/* prompts/Common.blarc.zs: the game's layouts (prompts/Common.blarc) with
- the Talk ring's A B X Y where their pad inputs are (prompts/ring.bin, nx2/prompt_assets.py: "HPRG", u32 count; each: u8
group, u8 Switch button placed, u8 place, u8, u32 runs, the runs);
- the ocarina hint's icons moved apart for the wide ones bound (prompts/<face>/hint.bin, nx2/prompt_assets.py HINTS: "HPHN",
u32 count of pad inputs, each one's icon's extra width (f32), u32 panes; each: u32 offset, u8 slot, 3 bytes, f32 x): each
icon the one before's extra further on, the last one where it is;
- the hearts, the item slot and the small map out at a wide picture's sides (prompts/wide.bin, nx2/prompt_assets.py HUD_SIDE_PANES: "HPWD", u32
count; each: u32 offset, i8 side, 3 bytes, f32 x), with the Insert menu's Ultrawide HUD row on Screen edges
(host/oot_wide_hud.h);
none when all are as the game has them (the game's own file) */
static int build_layouts(char *out, size_t cap) {
char dir[MAX_PATH], path[MAX_PATH];
int face;
if (!setup(dir, sizeof dir, &face)) return 0;
int bind[HOS_SW_N], place[4];
for (int b = 0; b < HOS_SW_N; b++) bind[b] = hos_binding(HOS_BIND_PAD, b, 0);
ring_places(bind, place);
const int ring_moved = !(place[0] == 0 && place[1] == 1 && place[2] == 2 && place[3] == 3);
size_t nruns = 0, cap_runs = 64;
Run *runs = (Run *)malloc(cap_runs * sizeof *runs);
uint64_t h = fnv(0xcbf29ce484222325ull, place, sizeof place);
long tn = 0, hn = 0;
snprintf(path, sizeof path, "%sprompts/ring.bin", dir);
uint8_t *t = ring_moved ? read_all(path, "HPRG", &tn) : NULL;
if (t) {
const uint32_t count = rd32le(t + 4);
size_t at = 8;
for (uint32_t e = 0; e < count && at + 8 <= (size_t)tn; e++) {
const int placed = t[at + 1], where = t[at + 2];
const uint32_t nr = rd32le(t + at + 4);
const int on = placed < 4 && place[placed] == where;
at += 8;
for (uint32_t r = 0; r < nr && at + 8 <= (size_t)tn; r++) {
const uint32_t off = rd32le(t + at), len = rd32le(t + at + 4);
if (len > (size_t)tn - at - 8) break;
if (on) add_run(&runs, &nruns, &cap_runs, off, len, t + at + 8);
at += 8 + len;
}
}
h = fnv(h, t, (size_t)tn);
}
/* the hint's notes, in its order (Switch L R Y X A: up, down, left, right, A) */
static const int notes[5] = {HOS_SW_L, HOS_SW_R, HOS_SW_Y, HOS_SW_X, HOS_SW_A};
snprintf(path, sizeof path, "%sprompts/%s/hint.bin", dir, faces[face]);
uint8_t *hint = read_all(path, "HPHN", &hn);
float *xs = NULL;
int spread = 0;
if (hint) {
const uint32_t npads = rd32le(hint + 4);
const size_t panes_at = 8 + 4 * (size_t)npads;
float extra[5], shift[6] = {0};
for (int i = 0; i < 5; i++) {
const int p = bind[notes[i]];
extra[i] = 0;
if (p >= 0 && (uint32_t)p < npads && panes_at <= (size_t)hn) memcpy(&extra[i], hint + 8 + 4 * p, 4);
}
for (int i = 3; i >= 0; i--) shift[i] = shift[i + 1] - extra[i]; /* (an icon is drawn from its pane's left) */
shift[5] = shift[0]; /* (the text with the first icon) */
spread = shift[0] != 0;
const uint32_t count = panes_at + 4 <= (size_t)hn ? rd32le(hint + panes_at) : 0;
if (spread && count <= ((size_t)hn - panes_at - 4) / 12) {
xs = (float *)malloc(count * sizeof *xs);
for (uint32_t k = 0; k < count; k++) {
const uint8_t *e = hint + panes_at + 4 + 12 * k;
memcpy(&xs[k], e + 8, 4);
xs[k] += shift[e[4] < 6 ? e[4] : 5];
add_run(&runs, &nruns, &cap_runs, rd32le(e), 4, (const uint8_t *)&xs[k]);
}
h = fnv(fnv(h, shift, sizeof shift), hint, (size_t)hn);
}
}
float hos_wide_hud_out(void);
const float wide_out = hos_wide_hud_out();
long wn = 0;
snprintf(path, sizeof path, "%sprompts/wide.bin", dir);
uint8_t *wide = wide_out > 0.0f ? read_all(path, "HPWD", &wn) : NULL;
float *wxs = NULL;
if (wide) {
const uint32_t count = rd32le(wide + 4);
if (count && count <= ((size_t)wn - 8) / 12) {
wxs = (float *)malloc(count * sizeof *wxs);
for (uint32_t k = 0; k < count; k++) {
const uint8_t *e = wide + 8 + 12 * k;
memcpy(&wxs[k], e + 8, 4);
wxs[k] += (float)(int8_t)e[4] * wide_out;
add_run(&runs, &nruns, &cap_runs, rd32le(e), 4, (const uint8_t *)&wxs[k]);
}
h = fnv(fnv(h, &wide_out, sizeof wide_out), wide, (size_t)wn);
}
} else if (wide_out > 0.0f) {
hos_log("prompts: no prompts/wide.bin: the Ultrawide HUD stays in the middle (Setup's Update makes it)");
}
int ok = 0;
if (nruns) {
char keypath[MAX_PATH];
snprintf(out, cap, "%sprompts/Common.blarc.zs", dir);
snprintf(path, sizeof path, "%sprompts/Common.blarc", dir);
snprintf(keypath, sizeof keypath, "%sprompts/Common.blarc.key", dir);
ok = write_patched(path, out, keypath, h, runs, nruns);
hos_log("prompts: the Talk ring's A B X Y at places %d %d %d %d, the ocarina hint %s, the hearts, item slot and map %s%s",
place[0], place[1], place[2], place[3], xs ? "spread" : "as is", wxs ? "at the picture's sides" : "as is",
ok ? "" : ": could not be written");
}
free(wxs);
free(wide);
free(xs);
free(hint);
free(runs);
free(t);
return ok;
}
/* builds prompts/External.bfotf.zs for this run; 1 when there is one */
static int build(char *out, size_t cap) {
char dir[MAX_PATH], path[MAX_PATH];
int face;
if (!setup(dir, sizeof dir, &face)) return 0;
/* (a mod's size table is served, not ours: the faces' fonts, larger than the game's, do not fit it) */
if (hos_mods_has(SIZES_PATH, ".rsizetable.zs")) {
hos_log("prompts: a mod has the resource size table: the game's own icons in texts");
return 0;
}
snprintf(path, sizeof path, "%sprompts/%s/External.bfotf", dir, faces[face]);
long n;
uint8_t *b = read_all(path, NULL, &n);
if (!b || n < 16 || n % 4) {
hos_log("prompts: no %s: the game's own icons", path);
free(b);
return 0;
}
const uint32_t key = rd32le(b) ^ MAGIC;
for (long i = 8; i < n; i += 4) wr32le(b + i, rd32le(b + i) ^ key);
const int bound = bind_font(b + 8, (size_t)n - 8);
for (long i = 8; i < n; i += 4) wr32le(b + i, rd32le(b + i) ^ key);
snprintf(out, cap, "%sprompts/External.bfotf.zs", dir);
const int ok = write_zstd_raw(out, b, (size_t)n);
free(b);
hos_log("prompts: %s icons, %d buttons on this pad's controls%s", faces[face], bound, ok ? "" : ": could not be written");
return ok;
}
/* (Triforce) The Insert menu's Camera speed row (camera_speed= in the options file, percent; HOS_CAMERA_SPEED=<percent>
over it): how fast the right stick turns the camera, times the game's own speed at any of the five Camera sensitivity
settings of its Options. The rates are five floats in the game's camera pack (nx2/prompt_assets.py CAMERA has where and
why): prompts/PlayerCamera.pack.zs is that pack (prompts/PlayerCamera.pack) with each rate of prompts/camera.bin ("HPCM",
u32 count; each: u32 offset, f32 the game's rate) times the factor. Read once: the game loads the pack at its start, so
the row applies after a restart. At 100 the game's own file is served. NX2navi's camera speed setting, without its
search of the game's memory for a change during play. */
int hos_ini_option(const char *key, int otherwise);
static volatile double camera_applied = 1.0; /* the factor in the pack the game was given */
static double camera_wanted(void) {
static int v = -1;
if (v < 0) {
const char *e = getenv("HOS_CAMERA_SPEED");
v = e && atoi(e) > 0 ? atoi(e) : hos_ini_option("camera_speed", 100);
v = v < 25 ? 25 : v > 300 ? 300 : v;
}
return v / 100.0;
}
/* host/nn_hid.c: the mouse's panning reaches the game as the right stick; divided by this it keeps its own sensitivity */
double hos_camera_speed(void) {
return camera_applied;
}
static int build_camera(char *out, size_t cap) {
char dir[MAX_PATH], path[MAX_PATH], keypath[MAX_PATH];
int face;
const double k = camera_wanted();
if (k == 1.0 || !setup(dir, sizeof dir, &face)) return 0;
long tn = 0;
snprintf(path, sizeof path, "%sprompts/camera.bin", dir);
uint8_t *t = read_all(path, "HPCM", &tn);
const uint32_t count = t ? rd32le(t + 4) : 0;
if (!count || count > 8 || (size_t)tn < 8 + 8 * (size_t)count) {
hos_log("prompts: no prompts/camera.bin: the camera keeps the game's speed (Setup's Update makes it)");
free(t);
return 0;
}
float rates[8];
size_t nruns = 0, cap_runs = 8;
Run *runs = (Run *)malloc(cap_runs * sizeof *runs);
for (uint32_t i = 0; i < count; i++) {
memcpy(&rates[i], t + 8 + 8 * i + 4, 4);
rates[i] = (float)(rates[i] * k);
add_run(&runs, &nruns, &cap_runs, rd32le(t + 8 + 8 * i), 4, (const uint8_t *)&rates[i]);
}
const uint64_t h = fnv(fnv(0xcbf29ce484222325ull, &k, sizeof k), t, (size_t)tn);
snprintf(out, cap, "%sprompts/PlayerCamera.pack.zs", dir);
snprintf(path, sizeof path, "%sprompts/PlayerCamera.pack", dir);
snprintf(keypath, sizeof keypath, "%sprompts/PlayerCamera.key", dir);
const int ok = write_patched(path, out, keypath, h, runs, nruns);
if (ok) camera_applied = k;
hos_log("prompts: camera speed x%.2f, the first rate %.2f%s", k, (double)rates[0], ok ? "" : ": could not be written");
free(runs);
free(t);
return ok;
}
/* mods.c: the file for a RomFS path the prompts replace (key: lower case, '/'), 1 with one. Asked only when no mod has
the file: a mod's own wins */
int hos_prompts_romfs(const char *key, char *out, size_t cap) {
static volatile LONG state[4]; /* the font, the textures, the layouts, the camera: 0 not built, 1 being built, 2 built, 3 none */
static char path[4][MAX_PATH];
const size_t kn = strlen(key);
if (!strncmp(key, SIZES_PATH, sizeof SIZES_PATH - 1) && kn > 14 && !strcmp(key + kn - 14, ".rsizetable.zs")) {
char dir[MAX_PATH]; /* (the game's size table with room for the faces' fonts, larger than its: nx2/prompt_assets.py) */
int face;
if (!setup(dir, sizeof dir, &face)) return 0;
snprintf(out, cap, "%sprompts/rsizetable.zs", dir);
return GetFileAttributesA(out) != INVALID_FILE_ATTRIBUTES;
}
const int which = !strcmp(key, FONT_PATH) ? 0 : !strcmp(key, TEXTURES_PATH) ? 1 : !strcmp(key, LAYOUTS_PATH) ? 2 :
!strcmp(key, CAMERA_PATH) ? 3 : -1;
if (which < 0) return 0;
static int (*const builders[4])(char *, size_t) = {build, build_textures, build_layouts, build_camera};
if (InterlockedCompareExchange(&state[which], 1, 0) == 0)
InterlockedExchange(&state[which], builders[which](path[which], MAX_PATH) ? 2 : 3);
while (state[which] == 1) Sleep(1);
if (state[which] != 2) return 0;
snprintf(out, cap, "%s", path[which]);
return 1;
}