@terrafirmagreg-team/game 0.0.0-stage → 0.1.0

package/src/lib/dump/contract/ref.ts

@@ -0,0 +1,262 @@
+
+
+import { formatNbt, parseSnbt } from '@terrafirmagreg-team/game/lib/snbt';
+import { asRecord, asString } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+
+const REFERENCE_KINDS = [
+  'item',
+  'block',
+  'fluid',
+  'entity',
+  'itemTag',
+  'blockTag',
+  'fluidTag',
+  'entityTag',
+  'texture',
+  'model',
+  'recipe',
+  'guide',
+  'quest',
+  'chapter',
+] as const;
+
+export type ReferenceKind = (typeof REFERENCE_KINDS)[number];
+
+const TAG_KINDS = ['itemTag', 'blockTag', 'fluidTag', 'entityTag'] as const;
+
+const ICON_KINDS: readonly ReferenceKind[] = [
+  'item',
+  'block',
+  'fluid',
+  'entity',
+  ...TAG_KINDS,
+  'texture',
+];
+
+export type DumpNbt =
+  | string
+  | number
+  | boolean
+  | null
+  | DumpNbt[]
+  | { [key: string]: DumpNbt };
+
+export type TaggedReference = {
+  kind: ReferenceKind;
+  id: string;
+  tag?: DumpNbt;
+};
+
+export type ParsedStackId = {
+  id: string;
+  nbt?: DumpNbt;
+};
+
+function asReferenceKind(value: unknown): ReferenceKind | undefined {
+  if (typeof value !== 'string') return undefined;
+  return (REFERENCE_KINDS as readonly string[]).includes(value)
+    ? (value as ReferenceKind)
+    : undefined;
+}
+
+export function asNbt(value: unknown): DumpNbt | undefined {
+  if (value === null) return null;
+  if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+    return value;
+  }
+  if (Array.isArray(value)) return value as DumpNbt[];
+  const row = asRecord(value);
+  if (!row || Object.keys(row).length === 0) return undefined;
+  return row as { [key: string]: DumpNbt };
+}
+
+export function nbtAt(
+  tag: DumpNbt | undefined,
+  ...path: (string | number)[]
+): DumpNbt | undefined {
+  let cur: DumpNbt | undefined = tag;
+  for (const key of path) {
+    if (cur === undefined || cur === null) return undefined;
+    if (typeof key === 'number') {
+      if (!Array.isArray(cur)) return undefined;
+      cur = cur[key];
+      continue;
+    }
+    if (typeof cur !== 'object' || Array.isArray(cur)) return undefined;
+    cur = cur[key];
+  }
+  return cur;
+}
+
+export function parseStackId(compact: string): ParsedStackId {
+  const brace = compact.indexOf('{');
+  if (brace <= 0) return { id: compact };
+  const id = compact.slice(0, brace);
+  if (!id) return { id: compact };
+  try {
+    const nbt = asNbt(parseSnbt(compact.slice(brace)));
+    return nbt !== undefined ? { id, nbt } : { id };
+  } catch {
+    return { id };
+  }
+}
+
+export function stackIdBase(compact: string): string {
+  const brace = compact.indexOf('{');
+  return brace > 0 ? compact.slice(0, brace) : compact;
+}
+
+export function canonicalStackId(compact: string): string {
+  const brace = compact.indexOf('{');
+  if (brace <= 0) return compact;
+  const parsed = parseStackId(compact);
+  const nbt = formatNbt(parsed.nbt);
+  return nbt !== undefined && nbt.startsWith('{')
+    ? `${parsed.id}${nbt}`
+    : compact;
+}
+
+export function asTaggedReference(value: unknown): TaggedReference | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const kind = asReferenceKind(row.kind);
+  const id = asString(row.id);
+  if (!kind || !id) return undefined;
+  const tag = asNbt(row.tag);
+  return { kind, id, ...(tag !== undefined ? { tag } : {}) };
+}
+
+export function isTagKind(
+  kind: ReferenceKind | undefined,
+): kind is (typeof TAG_KINDS)[number] {
+  return kind !== undefined && (TAG_KINDS as readonly string[]).includes(kind);
+}
+
+export function tagKindOf(
+  kind: ReferenceKind | undefined,
+): 'item' | 'block' | 'fluid' | 'entity' | undefined {
+  switch (kind) {
+    case 'itemTag':
+      return 'item';
+    case 'blockTag':
+      return 'block';
+    case 'fluidTag':
+      return 'fluid';
+    case 'entityTag':
+      return 'entity';
+    default:
+      return undefined;
+  }
+}
+
+export function isIconKind(kind: ReferenceKind | undefined): boolean {
+  return kind !== undefined && ICON_KINDS.includes(kind);
+}
+
+export function classifyRefId(
+  id: string,
+  kind?: ReferenceKind,
+): TaggedReference | undefined {
+  const trimmed = id.trim();
+  if (!trimmed) return undefined;
+  const parsed = parseStackId(
+    trimmed.startsWith('#') ? trimmed.slice(1) : trimmed,
+  );
+  const resolved = trimmed.startsWith('#')
+    ? (isTagKind(kind) ? kind : 'itemTag')
+    : (kind ?? 'item');
+  return {
+    kind: resolved,
+    id: parsed.id,
+    ...(parsed.nbt !== undefined ? { tag: parsed.nbt } : {}),
+  };
+}
+
+export function refId(ref: TaggedReference): string {
+  return stackIdFromRef(ref);
+}
+
+export function compactRefId(value: unknown): string | undefined {
+  if (typeof value === 'string' && value) return value;
+  const tagged = asTaggedReference(value);
+  return tagged ? stackIdFromRef(tagged) : undefined;
+}
+
+function nbtEquals(left: DumpNbt | undefined, right: DumpNbt | undefined): boolean {
+  if (left === right) return true;
+  if (left === undefined || right === undefined) return false;
+  if (left === null || right === null) return left === right;
+  if (typeof left !== typeof right) return false;
+  if (typeof left !== 'object') return left === right;
+  if (Array.isArray(left)) {
+    return (
+      Array.isArray(right) &&
+      left.length === right.length &&
+      left.every((value, index) => nbtEquals(value, right[index]))
+    );
+  }
+  if (Array.isArray(right)) return false;
+  const leftRow = left as { [key: string]: DumpNbt };
+  const rightRow = right as { [key: string]: DumpNbt };
+  const leftKeys = Object.keys(leftRow).sort();
+  const rightKeys = Object.keys(rightRow).sort();
+  if (leftKeys.length !== rightKeys.length) return false;
+  return leftKeys.every(
+    (key, index) => key === rightKeys[index] && nbtEquals(leftRow[key], rightRow[key]),
+  );
+}
+
+function nbtMatches(pattern: DumpNbt | undefined, actual: DumpNbt | undefined): boolean {
+  if (pattern === undefined) return actual === undefined;
+  if (actual === undefined || actual === null) return pattern === actual;
+  if (pattern === null) return actual === null;
+  if (typeof pattern !== 'object') return pattern === actual;
+  if (Array.isArray(pattern)) {
+    if (!Array.isArray(actual) || pattern.length !== actual.length) return false;
+    return pattern.every((item, index) => nbtMatches(item, actual[index]));
+  }
+  if (typeof actual !== 'object' || Array.isArray(actual) || actual === null) return false;
+  const actualRow = actual as { [key: string]: DumpNbt };
+  return Object.entries(pattern).every(([key, value]) => nbtMatches(value, actualRow[key]));
+}
+
+function nbtKeyCount(tag: DumpNbt | undefined): number {
+  return tag !== null && typeof tag === 'object' && !Array.isArray(tag)
+    ? Object.keys(tag ?? {}).length
+    : 0;
+}
+
+function nbtSharedKeys(left: DumpNbt | undefined, right: DumpNbt | undefined): number {
+  if (!left || !right) return 0;
+  if (typeof left !== 'object' || Array.isArray(left)) return 0;
+  if (typeof right !== 'object' || Array.isArray(right)) return 0;
+  const rightRow = right as { [key: string]: DumpNbt };
+  let shared = 0;
+  for (const [key, value] of Object.entries(left)) {
+    if (key in rightRow && nbtEquals(value, rightRow[key])) shared++;
+  }
+  return shared;
+}
+
+export function nbtSpecificity(candidate: DumpNbt, query: DumpNbt): number {
+  if (nbtEquals(candidate, query)) return 500;
+  if (nbtMatches(candidate, query)) return 400 + nbtKeyCount(candidate);
+  if (nbtMatches(query, candidate)) return 300 - nbtKeyCount(candidate);
+  const shared = nbtSharedKeys(candidate, query);
+  return shared > 0 ? 200 + shared : -1;
+}
+
+export function stackIdFromRef(ref: TaggedReference): string {
+  switch (ref.kind) {
+    case 'itemTag':
+    case 'blockTag':
+    case 'fluidTag':
+    case 'entityTag':
+      return `#${ref.id.replace(/^#+/, '')}`;
+    default: {
+      const tag = formatNbt(ref.tag);
+      return tag !== undefined && tag.startsWith('{') ? `${ref.id}${tag}` : ref.id;
+    }
+  }
+}
+

package/src/lib/dump/contract/text.ts

@@ -0,0 +1,86 @@
+import { asRecord, asString } from '@terrafirmagreg-team/game/lib/dump/contract/read';
+
+export const MC_FORMAT_COLORS: Record<string, string> = {
+  '0': '#000000',
+  '1': '#0000aa',
+  '2': '#00aa00',
+  '3': '#00aaaa',
+  '4': '#aa0000',
+  '5': '#aa00aa',
+  '6': '#ffaa00',
+  '7': '#aaaaaa',
+  '8': '#555555',
+  '9': '#5555ff',
+  a: '#55ff55',
+  b: '#55ffff',
+  c: '#ff5555',
+  d: '#ff55ff',
+  e: '#ffff55',
+  f: '#ffffff',
+};
+
+export type DumpText = {
+  translate?: string;
+  text?: string;
+  keybind?: string;
+  with?: DumpText[];
+  extra?: DumpText[];
+};
+
+export type DumpDisplay = {
+  name?: string;
+  tooltip?: DumpText[];
+
+  tooltipMods?: Record<string, DumpText[]>;
+};
+
+export function asDumpText(value: unknown): DumpText | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const translate = asString(row.translate);
+  const text = typeof row.text === 'string' ? row.text : undefined;
+  const keybind = asString(row.keybind);
+  const withParts = asDumpTextList(row.with);
+  const extra = asDumpTextList(row.extra);
+  if (!translate && text === undefined && !keybind && !withParts && !extra) {
+    return undefined;
+  }
+  return {
+    ...(translate ? { translate } : {}),
+    ...(text !== undefined ? { text } : {}),
+    ...(keybind ? { keybind } : {}),
+    ...(withParts ? { with: withParts } : {}),
+    ...(extra ? { extra } : {}),
+  };
+}
+
+export function asDumpTextList(value: unknown): DumpText[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value.flatMap((item) => {
+    const text = asDumpText(item);
+    return text ? [text] : [];
+  });
+  return out.length ? out : undefined;
+}
+
+export function asDisplay(value: unknown): DumpDisplay | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const name = asString(row.name);
+  const tooltip = asDumpTextList(row.tooltip);
+  const modsRow = asRecord(row.tooltipMods);
+  const tooltipMods = modsRow
+    ? Object.fromEntries(
+        Object.entries(modsRow).flatMap(([mod, lines]) => {
+          const list = asDumpTextList(lines);
+          return list ? [[mod, list] as const] : [];
+        }),
+      )
+    : undefined;
+  if (!name && !tooltip && !tooltipMods) return undefined;
+  return {
+    ...(name ? { name } : {}),
+    ...(tooltip ? { tooltip } : {}),
+    ...(tooltipMods && Object.keys(tooltipMods).length ? { tooltipMods } : {}),
+  };
+}

package/src/lib/dump/data/registry/dto.ts

@@ -0,0 +1,56 @@
+import type { DumpNbt, TaggedReference } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { DumpDisplay } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import type {
+  BlockEntry,
+  EntityEntry,
+  FluidEntry,
+  ItemEntry,
+  SpriteEntry,
+  VariantEntry,
+} from '@terrafirmagreg-team/game/lib/dump/gen';
+
+export type { SpriteEntry };
+
+export type DumpEntryVariant = Omit<VariantEntry, 'display' | 'tag'> & {
+  tag: DumpNbt;
+  display?: DumpDisplay;
+};
+
+export type DumpItemEntry = Omit<
+  ItemEntry,
+  'block' | 'display' | 'maxCount' | 'rarity' | 'variants'
+> & {
+  maxCount?: number;
+  rarity?: string;
+  block?: string;
+  display?: DumpDisplay;
+  variants?: DumpEntryVariant[];
+};
+
+export type DumpBlockEntry = Omit<BlockEntry, 'display' | 'item'> & {
+  item?: TaggedReference;
+  display?: DumpDisplay;
+};
+
+export type DumpFluidEntry = Omit<FluidEntry, 'display' | 'variants'> & {
+  display?: DumpDisplay;
+  variants?: DumpEntryVariant[];
+};
+
+export type DumpEntityEntry = Omit<
+  EntityEntry,
+  'display' | 'model' | 'texture' | 'variants'
+> & {
+  display?: DumpDisplay;
+  texture?: string;
+  model?: string;
+  variants?: DumpEntryVariant[];
+};
+
+export type DumpRegistryKind = 'items' | 'blocks' | 'fluids' | 'entities';
+
+export type DumpRegistryEntry =
+  | DumpItemEntry
+  | DumpBlockEntry
+  | DumpFluidEntry
+  | DumpEntityEntry;

package/src/lib/dump/data/registry/parse.ts

@@ -0,0 +1,291 @@
+import {
+  asEdgeList,
+  asNumber,
+  asRecord,
+  asString,
+  asStringList,
+} from '@terrafirmagreg-team/game/lib/dump/contract/read';
+import {
+  asNbt,
+  asTaggedReference,
+  nbtSpecificity,
+  type DumpNbt,
+} from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import { formatNbt } from '@terrafirmagreg-team/game/lib/snbt';
+import { asDisplay, type DumpDisplay } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import type {
+  DumpBlockEntry,
+  DumpEntityEntry,
+  DumpEntryVariant,
+  DumpFluidEntry,
+  DumpItemEntry,
+  DumpRegistryEntry,
+  DumpRegistryKind,
+  SpriteEntry,
+} from '@terrafirmagreg-team/game/lib/dump/data/registry/dto';
+
+export function asSpriteEntry(value: unknown): SpriteEntry | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const image = asString(row.image);
+  const x = asNumber(row.x);
+  const y = asNumber(row.y);
+  const w = asNumber(row.w);
+  const h = asNumber(row.h);
+  const pw = asNumber(row.pw);
+  const ph = asNumber(row.ph);
+  if (
+    !image ||
+    x === undefined ||
+    y === undefined ||
+    w === undefined ||
+    h === undefined ||
+    pw === undefined ||
+    ph === undefined
+  ) {
+    return undefined;
+  }
+  const tint = asString(row.tint);
+  const tintColor = asString(row.tintColor);
+  return {
+    image,
+    x,
+    y,
+    w,
+    h,
+    pw,
+    ph,
+    ...(tint ? { tint } : {}),
+    ...(tintColor ? { tintColor } : {}),
+  };
+}
+
+function asVariant(value: unknown): DumpEntryVariant | undefined {
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const tag = asNbt(row.tag);
+  if (tag === undefined) return undefined;
+  const display = asDisplay(row.display);
+  const sprite = asSpriteEntry(row.sprite);
+  const texture = asString(row.texture);
+  const model = asString(row.model);
+  return {
+    tag,
+    ...(display ? { display } : {}),
+    ...(sprite ? { sprite } : {}),
+    ...(texture ? { texture } : {}),
+    ...(model ? { model } : {}),
+  };
+}
+
+function asVariants(value: unknown): DumpEntryVariant[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const out = value.flatMap((item) => {
+    const variant = asVariant(item);
+    return variant ? [variant] : [];
+  });
+  return out.length ? out : undefined;
+}
+
+const EXACT_SAFE_MAX_KEYS = 99;
+
+const variantExactIndex = new WeakMap<
+  DumpEntryVariant[],
+  { byTag: Map<string, DumpEntryVariant>; maxTagKeys: number }
+>();
+
+function exactVariantIndex(variants: DumpEntryVariant[]) {
+  let index = variantExactIndex.get(variants);
+  if (!index) {
+    const byTag = new Map<string, DumpEntryVariant>();
+    let maxTagKeys = 0;
+    for (const variant of variants) {
+      if (variant.tag === undefined) continue;
+      const keyCount =
+        variant.tag !== null &&
+        typeof variant.tag === 'object' &&
+        !Array.isArray(variant.tag)
+          ? Object.keys(variant.tag).length
+          : 0;
+      if (keyCount > maxTagKeys) maxTagKeys = keyCount;
+      const key = formatNbt(variant.tag);
+      if (key !== undefined && !byTag.has(key)) byTag.set(key, variant);
+    }
+    index = { byTag, maxTagKeys };
+    variantExactIndex.set(variants, index);
+  }
+  return index;
+}
+
+export function matchVariant(
+  variants: DumpEntryVariant[] | undefined,
+  nbt: DumpNbt | undefined,
+): DumpEntryVariant | undefined {
+  if (!variants?.length) return undefined;
+  if (nbt === undefined) {
+    return variants.find((variant) => variant.tag === undefined);
+  }
+  const key = formatNbt(nbt);
+  const index =
+    variants.length > 16 && key !== undefined
+      ? exactVariantIndex(variants)
+      : undefined;
+  if (index && index.maxTagKeys <= EXACT_SAFE_MAX_KEYS && key !== undefined) {
+    const exact = index.byTag.get(key);
+    if (exact) return exact;
+  }
+  let best: DumpEntryVariant | undefined;
+  let bestScore = -1;
+  for (const variant of variants) {
+    if (variant.tag === undefined) continue;
+    const score = nbtSpecificity(variant.tag, nbt);
+    if (score > bestScore) {
+      best = variant;
+      bestScore = score;
+    }
+  }
+  return best;
+}
+
+export function displayOf(
+  entry: { display?: DumpDisplay; variants?: DumpEntryVariant[] },
+  nbt?: DumpNbt,
+): DumpDisplay | undefined {
+  return matchVariant(entry.variants, nbt)?.display ?? entry.display;
+}
+
+function asId(value: unknown, fallbackId?: string): string | undefined {
+  const row = asRecord(value);
+  return asString(row?.id) ?? fallbackId;
+}
+
+function asEntryMeta(row: Record<string, unknown>, ids?: string[]) {
+  const tags = asStringList(row.tags);
+  const usedBy = asEdgeList(row.usedBy, ids);
+  const producedBy = asEdgeList(row.producedBy, ids);
+  const order = asNumber(row.order);
+  return {
+    ...(tags.length ? { tags } : {}),
+    ...(usedBy.length ? { usedBy } : {}),
+    ...(producedBy.length ? { producedBy } : {}),
+    ...(order !== undefined ? { order } : {}),
+  };
+}
+
+function asItemEntry(
+  value: unknown,
+  fallbackId?: string,
+  ids?: string[],
+): DumpItemEntry | undefined {
+  const id = asId(value, fallbackId);
+  if (!id) return undefined;
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const rarity = asString(row.rarity);
+  const block = asString(row.block);
+  const maxCount =
+    typeof row.maxCount === 'number' && Number.isFinite(row.maxCount)
+      ? row.maxCount
+      : undefined;
+  const display = asDisplay(row.display);
+  const variants = asVariants(row.variants);
+  const sprite = asSpriteEntry(row.sprite);
+  return {
+    id,
+    ...(maxCount !== undefined ? { maxCount } : {}),
+    ...(rarity ? { rarity } : {}),
+    ...(block ? { block } : {}),
+    ...(display ? { display } : {}),
+    ...(variants ? { variants } : {}),
+    ...(sprite ? { sprite } : {}),
+    ...asEntryMeta(row, ids),
+  };
+}
+
+function asBlockEntry(
+  value: unknown,
+  fallbackId?: string,
+  ids?: string[],
+): DumpBlockEntry | undefined {
+  const id = asId(value, fallbackId);
+  if (!id) return undefined;
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const item = asTaggedReference(row.item);
+  const display = asDisplay(row.display);
+  const sprite = asSpriteEntry(row.sprite);
+  return {
+    id,
+    ...(item ? { item } : {}),
+    ...(display ? { display } : {}),
+    ...(sprite ? { sprite } : {}),
+    ...asEntryMeta(row, ids),
+  };
+}
+
+function asFluidEntry(
+  value: unknown,
+  fallbackId?: string,
+  ids?: string[],
+): DumpFluidEntry | undefined {
+  const id = asId(value, fallbackId);
+  if (!id) return undefined;
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const display = asDisplay(row.display);
+  const variants = asVariants(row.variants);
+  const sprite = asSpriteEntry(row.sprite);
+  return {
+    id,
+    ...(display ? { display } : {}),
+    ...(variants ? { variants } : {}),
+    ...(sprite ? { sprite } : {}),
+    ...asEntryMeta(row, ids),
+  };
+}
+
+function asEntityEntry(
+  value: unknown,
+  fallbackId?: string,
+  ids?: string[],
+): DumpEntityEntry | undefined {
+  const id = asId(value, fallbackId);
+  if (!id) return undefined;
+  const row = asRecord(value);
+  if (!row) return undefined;
+  const display = asDisplay(row.display);
+  const texture = asString(row.texture);
+  const model = asString(row.model);
+  const variants = asVariants(row.variants);
+  return {
+    id,
+    ...(display ? { display } : {}),
+    ...(texture ? { texture } : {}),
+    ...(model ? { model } : {}),
+    ...(variants ? { variants } : {}),
+    ...asEntryMeta(row, ids),
+  };
+}
+
+export function asEntry(
+  value: unknown,
+  kind: DumpRegistryKind,
+  fallbackId?: string,
+  ids?: string[],
+): DumpRegistryEntry | undefined {
+  switch (kind) {
+    case 'items':
+      return asItemEntry(value, fallbackId, ids);
+    case 'blocks':
+      return asBlockEntry(value, fallbackId, ids);
+    case 'fluids':
+      return asFluidEntry(value, fallbackId, ids);
+    case 'entities':
+      return asEntityEntry(value, fallbackId, ids);
+    default: {
+      const _never: never = kind;
+      return _never;
+    }
+  }
+}
+

package/src/lib/dump/data/tab/dto.ts

@@ -0,0 +1,13 @@
+import type { DumpDisplay } from '@terrafirmagreg-team/game/lib/dump/contract/text';
+import type { TaggedReference } from '@terrafirmagreg-team/game/lib/dump/contract/ref';
+import type { TabEntry } from '@terrafirmagreg-team/game/lib/dump/gen';
+
+export type DumpCreativeTab = Omit<TabEntry, 'display' | 'icon' | 'items'> & {
+  display: DumpDisplay;
+  icon?: TaggedReference;
+};
+
+export type DumpCreativeTabs = {
+  tabs: DumpCreativeTab[];
+  members: Record<string, string[]>;
+};