@terrafirmagreg-team/game 0.0.0-stage → 0.1.0

package/src/lib/dump/assets/atlas/sprites.ts

@@ -0,0 +1,130 @@
+import { asSpriteEntry } from '@terrafirmagreg-team/game/lib/dump/data/registry/parse';
+import { asDisplay } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import { asNbt } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import { asRecord, asString } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import type {
+  AtlasKind,
+  AtlasTint,
+  IconAtlas,
+} from '@terrafirmagreg-team/game/lib/dump/assets/atlas/dto';
+import type { DumpRegistryKind } from '@terrafirmagreg-team/game/lib/dump/data/registry/dto';
+import type { TaggedReference } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { SpriteEntry } from '@terrafirmagreg-team/game/lib/dump/gen';
+
+const TINTS = new Set(['none', 'grass', 'foliage', 'water', 'custom']);
+
+function asTint(raw: unknown): AtlasTint | undefined {
+  return typeof raw === 'string' && TINTS.has(raw) ? (raw as AtlasTint) : undefined;
+}
+
+function asTintColor(raw: unknown): string | undefined {
+  if (typeof raw === 'number' && Number.isFinite(raw)) {
+    return `#${(raw & 0xffffff).toString(16).padStart(6, '0')}`;
+  }
+  if (typeof raw !== 'string' || !raw) return undefined;
+  if (/^#[0-9a-f]{6}$/i.test(raw)) return raw;
+  if (/^#[0-9a-f]{8}$/i.test(raw)) return `#${raw.slice(-6)}`;
+  if (/^0x[0-9a-f]{6,8}$/i.test(raw)) return `#${raw.slice(-6)}`;
+  return undefined;
+}
+
+const STACK_KIND: Record<DumpRegistryKind, TaggedReference['kind']> = {
+  items: 'item',
+  blocks: 'block',
+  fluids: 'fluid',
+  entities: 'entity',
+};
+
+function pushSprite(
+  atlas: IconAtlas,
+  bySrc: Map<string, number>,
+  ref: TaggedReference,
+  sprite: SpriteEntry,
+  langKey?: string,
+): void {
+  let page = bySrc.get(sprite.image);
+  if (page === undefined) {
+    atlas.pages.push({ image: sprite.image, w: sprite.pw, h: sprite.ph });
+    page = atlas.pages.length - 1;
+    bySrc.set(sprite.image, page);
+  }
+  const tint = asTint(sprite.tint);
+  const tintColor = asTintColor(sprite.tintColor);
+  atlas.sprites.push({
+    ref,
+    page,
+    x: sprite.x,
+    y: sprite.y,
+    w: sprite.w,
+    h: sprite.h,
+    ...(tint ? { tint } : {}),
+    ...(tintColor ? { tintColor } : {}),
+    ...(langKey ? { langKey } : {}),
+  });
+}
+
+export function iconAtlasFromEntries(
+  value: unknown,
+  dataset: string,
+  modId: string,
+  kind: DumpRegistryKind,
+  atlasKind: AtlasKind,
+): IconAtlas | null {
+  const entries = asRecord(value);
+  if (!entries) return null;
+  const stackKind = STACK_KIND[kind];
+  const atlas: IconAtlas = { sprites: [], pages: [], modId, dataset, kind: atlasKind };
+  const bySrc = new Map<string, number>();
+  for (const [key, raw] of Object.entries(entries)) {
+    const row = asRecord(raw);
+    if (!row) continue;
+    const id = asString(row.id) ?? key;
+    const langKey = asDisplay(row.display)?.name;
+    const sprite = asSpriteEntry(row.sprite);
+    if (sprite) pushSprite(atlas, bySrc, { id, kind: stackKind }, sprite, langKey);
+    const variants = row.variants;
+    if (!Array.isArray(variants)) continue;
+    for (const raw2 of variants) {
+      const variant = asRecord(raw2);
+      const variantSprite = asSpriteEntry(variant?.sprite);
+      if (!variantSprite) continue;
+      const tag = asNbt(variant?.tag);
+      pushSprite(
+        atlas,
+        bySrc,
+        { id, kind: stackKind, ...(tag !== undefined ? { tag } : {}) },
+        variantSprite,
+        asDisplay(variant?.display)?.name ?? langKey,
+      );
+    }
+  }
+  return atlas.sprites.length || atlas.pages.length ? atlas : null;
+}
+
+export function mergeAtlases(
+  parts: Array<IconAtlas | null>,
+  dataset: string,
+  modId: string,
+  kind: AtlasKind,
+): IconAtlas | null {
+  const sources = parts.flatMap((part) => (part ? [part] : []));
+  if (!sources.length) return null;
+  const atlas: IconAtlas = { sprites: [], pages: [], modId, dataset, kind };
+  const bySrc = new Map<string, number>();
+  for (const source of sources) {
+    const pageMap = new Map<number, number>();
+    for (const [index, page] of source.pages.entries()) {
+      let mapped = bySrc.get(page.image);
+      if (mapped === undefined) {
+        atlas.pages.push({ image: page.image, w: page.w, h: page.h });
+        mapped = atlas.pages.length - 1;
+        bySrc.set(page.image, mapped);
+      }
+      pageMap.set(index, mapped);
+    }
+    for (const sprite of source.sprites) {
+      atlas.sprites.push({ ...sprite, page: pageMap.get(sprite.page) ?? 0 });
+    }
+  }
+  return atlas.sprites.length || atlas.pages.length ? atlas : null;
+}

package/src/lib/dump/assets/lang/load.ts

@@ -0,0 +1,17 @@
+import 'server-only';
+import { clientDumpLang } from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import type { Lang } from '@terrafirmagreg-team/translate/types/locale';
+
+export {
+  creativeTabName,
+  isTechnicalId,
+  langString,
+  resolveName,
+} from '@terrafirmagreg-team/game/lib/dump/assets/lang/names';
+
+export function loadMergedLangMap(
+  dataset: string,
+  lang: Lang,
+): Promise<Record<string, string>> {
+  return clientDumpLang(dataset, lang);
+}

package/src/lib/dump/assets/lang/names.ts

@@ -0,0 +1,244 @@
+import {
+  nbtAt,
+  parseStackId,
+  stackIdBase,
+  type DumpNbt,
+} from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+
+function unwrapLangKey(raw: string): string {
+  const value = raw.trim();
+  return value.startsWith('{') && value.endsWith('}') && value.length > 2
+    ? value.slice(1, -1).trim()
+    : value;
+}
+
+export function langString(
+  map: Record<string, string>,
+  key: string | undefined,
+): string | undefined {
+  if (!key) return undefined;
+  const bare = unwrapLangKey(key);
+  return map[key] ?? map[bare];
+}
+
+function applyFormat(template: string, args: string[]): string {
+  let sequential = 0;
+  return template.replace(
+    /%(?:(\d+)\$)?([A-Za-z%])/g,
+    (_, n: string | undefined, conv: string) => {
+      if (conv === '%') return '%';
+      if (conv === 'n') return '\n';
+      const index = n ? Number(n) - 1 : sequential++;
+      return args[index] ?? '';
+    },
+  );
+}
+
+export function customStackName(
+  map: Record<string, string>,
+  compactId: string,
+): string | undefined {
+  const raw = nbtAt(parseStackId(compactId).nbt, 'display', 'Name');
+  if (typeof raw !== 'string' || !raw) return undefined;
+  try {
+    const node: unknown = JSON.parse(raw);
+    if (node && typeof node === 'object') {
+      return dumpTextString(map, node as Parameters<typeof dumpTextString>[1]);
+    }
+    if (typeof node === 'string') return node;
+  } catch {
+
+  }
+  return raw;
+}
+
+export function dumpTextString(
+  map: Record<string, string>,
+  text: {
+    translate?: string;
+    text?: string;
+    keybind?: string;
+    with?: unknown[];
+    extra?: unknown[];
+  },
+  keybinds?: Record<string, string>,
+): string {
+  const parts: string[] = [];
+  if (text.translate) {
+    const template = langString(map, text.translate) ?? text.translate;
+    const args = Array.isArray(text.with)
+      ? text.with.map((item) =>
+          item && typeof item === 'object'
+            ? dumpTextString(map, item as typeof text, keybinds)
+            : String(item ?? ''),
+        )
+      : [];
+    parts.push(args.length ? applyFormat(template, args) : template);
+  } else if (text.text !== undefined) {
+    parts.push(text.text);
+  } else if (text.keybind) {
+    parts.push(
+      keybinds?.[text.keybind] ?? langString(map, text.keybind) ?? text.keybind,
+    );
+  }
+  if (Array.isArray(text.extra)) {
+    for (const item of text.extra) {
+      if (item && typeof item === 'object') {
+        parts.push(dumpTextString(map, item as typeof text, keybinds));
+      }
+    }
+  }
+  return parts.join('');
+}
+
+export function dumpTextLines(
+  map: Record<string, string>,
+  lines: Array<{
+    translate?: string;
+    text?: string;
+    keybind?: string;
+    with?: unknown[];
+    extra?: unknown[];
+  }>,
+  keybinds?: Record<string, string>,
+): string[] {
+
+  return lines.map((line) => dumpTextString(map, line, keybinds));
+}
+
+export function resolveName(
+  map: Record<string, string>,
+  id: string,
+  langKey?: string,
+): string {
+  if (langKey) {
+    return langString(map, langKey) ?? langKey;
+  }
+  return langString(map, id) ?? id;
+}
+
+export function stripMcFormat(value: string): string {
+  return value.replace(/§x(?:§[0-9a-f]){6}|§[0-9a-fk-or]/gi, '');
+}
+
+const KIND_LANG_PREFIXES: Record<string, readonly string[]> = {
+  item: ['item', 'block'],
+  block: ['block', 'item'],
+  fluid: ['fluid', 'fluid_type', 'block'],
+  entity: ['entity'],
+  itemTag: ['tag.item'],
+  blockTag: ['tag.block', 'tag.item'],
+  fluidTag: ['tag.fluid'],
+  entityTag: ['tag.entity'],
+};
+
+const DEFAULT_LANG_PREFIXES = ['item', 'block', 'fluid', 'fluid_type', 'entity'];
+const TAG_LANG_PREFIXES = ['tag.item', 'tag.block', 'tag.fluid', 'tag.entity'];
+
+function stackLangKeys(
+  kind: string | undefined,
+  id: string,
+  typeKeys = true,
+): string[] {
+  const raw = parseStackId(id).id;
+  const hashed = raw.startsWith('#');
+  const resource = hashed ? raw.slice(1) : raw;
+  if (!resource.includes(':')) return [];
+  const [ns, path] = resource.split(':', 2);
+  const flat = path.replaceAll('/', '.');
+  const prefixes = hashed
+    ? ((kind ? KIND_LANG_PREFIXES[kind] : undefined) ?? TAG_LANG_PREFIXES)
+    : (KIND_LANG_PREFIXES[kind ?? ''] ?? DEFAULT_LANG_PREFIXES);
+  return [
+    ...prefixes.map((prefix) => `${prefix}.${ns}.${flat}`),
+    ...(typeKeys ? [`${ns}.type.${flat}.name`, `${ns}.type.${flat}`] : []),
+  ];
+}
+
+function nbtLangKeys(nbt: DumpNbt | undefined): string[] {
+  if (!nbt || typeof nbt !== 'object' || Array.isArray(nbt)) return [];
+  const keys: string[] = [];
+  for (const [field, value] of Object.entries(nbt)) {
+    if (!field.endsWith('Id') || field.length <= 2) continue;
+    if (typeof value !== 'string' || !value.includes(':')) continue;
+    const [ns, path] = value.split(':', 2);
+    const flat = path.replaceAll('/', '.');
+    const stem = field
+      .slice(0, -2)
+      .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
+      .toLowerCase();
+    if (!stem) continue;
+    keys.push(`${ns}.${stem}.${flat}`, `${ns}.${stem}.${flat}.name`);
+  }
+  return keys;
+}
+
+export function stackDisplay(
+  langMap: Record<string, string> | undefined,
+  compactId: string,
+  kind?: string,
+  langKey?: string,
+): { name: string; localized: boolean } {
+  const parsed = parseStackId(compactId);
+  if (!langMap) return { name: langKey ?? parsed.id, localized: false };
+  const custom = customStackName(langMap, compactId);
+  if (custom) return { name: stripMcFormat(custom), localized: true };
+  const canonical = stackLangKeys(kind, parsed.id, false);
+  const candidates: { key: string | undefined; localized: boolean }[] = [
+    { key: compactId, localized: true },
+    { key: langKey, localized: true },
+    ...nbtLangKeys(parsed.nbt).map((key) => ({ key, localized: true })),
+    ...canonical.map((key) => ({ key, localized: true })),
+    ...stackLangKeys(kind, parsed.id, true)
+      .slice(canonical.length)
+      .map((key) => ({ key, localized: false })),
+    { key: parsed.id, localized: false },
+  ];
+  for (const { key, localized } of candidates) {
+    if (!key) continue;
+    const value = langString(langMap, key);
+    if (value !== undefined) {
+      return { name: stripMcFormat(value), localized };
+    }
+  }
+  return {
+    name: humanizeKey(langKey ?? stackIdBase(compactId)),
+    localized: false,
+  };
+}
+
+export function stackDisplayName(
+  langMap: Record<string, string> | undefined,
+  compactId: string,
+  kind?: string,
+  langKey?: string,
+): string {
+  return stackDisplay(langMap, compactId, kind, langKey).name;
+}
+
+export function humanizeKey(key: string): string {
+  const value = unwrapLangKey(key);
+  const segment = value.includes(':')
+    ? (value.split(':', 2)[1] ?? value)
+    : (value.split('.').pop() ?? value);
+  const words = segment
+    .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+    .split(/[_.\-/]+/)
+    .filter(Boolean);
+  if (!words.length) return key;
+  return words
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+export function creativeTabName(
+  map: Record<string, string>,
+  nameKey?: string,
+): string {
+  return langString(map, nameKey) ?? humanizeKey(nameKey ?? '');
+}
+
+export function isTechnicalId(map: Record<string, string>, id: string): boolean {
+  return resolveName(map, id) === id;
+}
+

package/src/lib/dump/assets/urls.ts

@@ -0,0 +1,143 @@
+import type {
+  AtlasPage,
+  IconAtlas,
+} from '@terrafirmagreg-team/game/lib/dump/assets/atlas/dto';
+import {
+  cleanDumpRel,
+  dumpLocation,
+  dumpRelPublicUrl,
+  dumpStorageUrl,
+  splitDumpId,
+  type DumpLocation,
+} from '@terrafirmagreg-team/game/lib/dump/paths';
+
+export { dumpRelPublicUrl } from '@terrafirmagreg-team/game/lib/dump/paths';
+
+export function texturePublicUrl(
+  dataset: string,
+  textureId: string,
+): string | undefined {
+  const parts = splitDumpId(textureId.trim());
+  if (!parts) return undefined;
+  const path = parts.path.startsWith('textures/')
+    ? parts.path
+    : `textures/${parts.path}`;
+  const rel = `${path.replace(/\.(png|webp)$/i, '')}.webp`;
+  return dumpRelPublicUrl(dataset, `assets/${parts.ns}/${rel}`);
+}
+
+export function modelPublicUrl(
+  dataset: string,
+  namespace: string,
+  rel: string | null | undefined,
+): string | undefined {
+  const cleaned = typeof rel === 'string' ? cleanDumpRel(rel) : null;
+  return cleaned
+    ? dumpRelPublicUrl(dataset, `assets/${namespace}/${cleaned}`)
+    : undefined;
+}
+
+export function recipeImageUrl(
+  dataset: string,
+  recipe: { modId: string; image?: string },
+): string | undefined {
+  const rel = recipe.image ? cleanDumpRel(recipe.image) : undefined;
+  if (!rel) return undefined;
+  if (rel.startsWith('assets/')) return dumpRelPublicUrl(dataset, rel);
+  if (!recipe.modId) return undefined;
+  return dumpRelPublicUrl(dataset, `assets/${recipe.modId}/${rel}`);
+}
+
+export function atlasPagePublicUrl(
+  dataset: string,
+  atlas: IconAtlas,
+  page: AtlasPage,
+): string | undefined {
+  const src = cleanDumpRel(page.image);
+  if (!src || !atlas.modId) return undefined;
+  return dumpRelPublicUrl(dataset, `assets/${atlas.modId}/${src}`);
+}
+
+function pathDir(path: string): string {
+  const slash = path.lastIndexOf('/');
+  return slash >= 0 ? path.slice(0, slash + 1) : '';
+}
+
+function relativePath(fromDir: string, toPath: string): string {
+  const a = fromDir.split('/').filter(Boolean);
+  const b = toPath.split('/').filter(Boolean);
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) i += 1;
+  return '../'.repeat(a.length - i) + b.slice(i).join('/');
+}
+
+function resolveAssetRel(baseDir: string, relUri: string): string | null {
+  const out: string[] = [];
+  for (const seg of `${baseDir}${relUri}`.split('/')) {
+    if (seg === '..') {
+      if (!out.pop()) return null;
+    } else if (seg !== '.' && seg !== '') {
+      out.push(seg);
+    }
+  }
+  return out.length ? out.join('/') : null;
+}
+
+const reverseFileIndexes = new WeakMap<
+  Record<string, string>,
+  Map<string, string>
+>();
+function reverseFileIndex(files: Record<string, string>): Map<string, string> {
+  let map = reverseFileIndexes.get(files);
+  if (!map) {
+    map = new Map(Object.entries(files).map(([rel, key]) => [key, rel]));
+    reverseFileIndexes.set(files, map);
+  }
+  return map;
+}
+
+function dumpRelForStorageRel(
+  loc: DumpLocation,
+  storageRel: string,
+): string | undefined {
+  if (loc.files) return reverseFileIndex(loc.files).get(storageRel);
+  return storageRel.startsWith(`${loc.root}/`)
+    ? storageRel.slice(loc.root.length + 1)
+    : undefined;
+}
+
+export function createDumpAssetResolver(
+  dataset: string,
+): (resourceUrl: string, modelUrl: string) => string | undefined {
+
+  let prefix: string | null = null;
+  return (resourceUrl, modelUrl) => {
+    const loc = dumpLocation(dataset);
+    if (!loc) return undefined;
+    const base =
+      typeof window === 'undefined' ? 'http://x.invalid' : location.origin;
+    prefix ??= new URL(dumpStorageUrl(''), base).href;
+    let resourcePath: string;
+    let modelAbs: URL;
+    try {
+      modelAbs = new URL(modelUrl, base);
+      const resource = new URL(resourceUrl, modelAbs);
+      if (resource.origin !== modelAbs.origin) return undefined;
+      resourcePath = resource.pathname;
+    } catch {
+      return undefined;
+    }
+    const modelHref = modelAbs.href;
+    if (!modelHref.startsWith(prefix)) return undefined;
+    const modelRel = dumpRelForStorageRel(
+      loc,
+      modelHref.slice(prefix.length),
+    );
+    if (!modelRel) return undefined;
+    const rel = relativePath(pathDir(modelAbs.pathname), resourcePath);
+    if (!rel || !rel.includes('/')) return undefined;
+    const dumpRel = resolveAssetRel(pathDir(modelRel), rel);
+    if (!dumpRel) return undefined;
+    return dumpRelPublicUrl(dataset, dumpRel);
+  };
+}

package/src/lib/dump/client/atlases.ts

@@ -0,0 +1,83 @@
+import type { AtlasBundle, IconAtlas } from '@terrafirmagreg-team/game/lib/dump/assets/atlas/dto';
+import {
+  iconAtlasFromEntries,
+  mergeAtlases,
+} from '@terrafirmagreg-team/game/lib/dump/assets/atlas/sprites';
+import {
+  clientDumpJson,
+  loadClientManifest,
+} from '@terrafirmagreg-team/game/lib/dump/client/dump';
+import { asRecord } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import { createAsyncCache } from '@terrafirmagreg-team/ui/lib/utils/async-cache';
+
+async function modEntries(
+  dataset: string,
+  modId: string,
+  kind: string,
+): Promise<Record<string, unknown> | undefined> {
+  const entries = asRecord(
+    await clientDumpJson(dataset, `registry/${kind}.json`, 'high'),
+  );
+  if (!entries) return undefined;
+  const prefix = `${modId}:`;
+  const out: Record<string, unknown> = {};
+  for (const [key, value] of Object.entries(entries)) {
+    if (key.startsWith(prefix)) out[key] = value;
+  }
+  return out;
+}
+
+const loadClientModAtlas = createAsyncCache(
+  async (
+    dataset: string,
+    modId: string,
+    kind: 'items' | 'blocks',
+  ): Promise<IconAtlas | null> => {
+    const manifest = await loadClientManifest(dataset);
+    const listed = manifest?.namespaces[modId];
+    if (!listed) return null;
+    const has = (file: string) => listed.registry.includes(file);
+    if (kind === 'blocks') {
+      if (!has('blocks')) return null;
+      return iconAtlasFromEntries(
+        await modEntries(dataset, modId, 'blocks'),
+        dataset,
+        modId,
+        'blocks',
+        'block',
+      );
+    }
+    return mergeAtlases(
+      [
+        has('items')
+          ? iconAtlasFromEntries(
+              await modEntries(dataset, modId, 'items'),
+              dataset,
+              modId,
+              'items',
+              'item',
+            )
+          : null,
+        has('fluids')
+          ? iconAtlasFromEntries(
+              await modEntries(dataset, modId, 'fluids'),
+              dataset,
+              modId,
+              'fluids',
+              'item',
+            )
+          : null,
+      ],
+      dataset,
+      modId,
+      'item',
+    );
+  },
+);
+
+export const loadClientModAtlases = createAsyncCache(
+  async (dataset: string, modId: string): Promise<AtlasBundle> => ({
+    items: await loadClientModAtlas(dataset, modId, 'items'),
+    blocks: await loadClientModAtlas(dataset, modId, 'blocks'),
+  }),
+);