Website: Inscription Tooltips

// inscription.ts
import fs from "fs";
import sql from "mssql";
import { XMLParser } from "fast-xml-parser";

const DATA_DIR = "C:/MuServer/Data/Plugins/Inscription";   // your server's path
const SYS_INSCRIPTION = 1;
const TIER_TEXT = ["", " II", " III", " IV", " V", " VI", " VII", " VIII"];

// ---------- Step 1: serial ----------
export function itemSerial(item: Buffer): number | null {
  if (item.length < 16) return null;
  const empty = item[0] === 0xff && (item[7] & 0x80) !== 0 && (item[9] & 0xf0) === 0xf0;
  if (empty) return null;
  const serial = item.readUInt32BE(3);
  return serial === 0 ? null : serial;
}

// ---------- Step 2: ItemExt rows ----------
export async function loadItemExt(pool: sql.ConnectionPool, serials: number[]): Promise<Map<number, Buffer>> {
  const out = new Map<number, Buffer>();
  const unique = [...new Set(serials)];
  for (let i = 0; i < unique.length; i += 500) {
    const chunk = unique.slice(i, i + 500);
    const req = pool.request();
    chunk.forEach((s, n) => req.input(`s${n}`, sql.BigInt, s));
    const names = chunk.map((_, n) => `@s${n}`).join(",");
    const r = await req.query(`SELECT ItemSerial, Data FROM ItemExt WHERE ItemSerial IN (${names})`);
    for (const row of r.recordset) out.set(Number(row.ItemSerial), row.Data as Buffer);
  }
  return out;
}

// ---------- Step 3 + 4: record ----------
export interface InscSlot { id: number; tier: number; state: number }
export interface InscRecord { potential: number; spent: number; slots: InscSlot[]; bound: string }

export function readInscription(data: Buffer): InscRecord | null {
  let p = 0;
  while (p + 3 <= data.length && data[p] !== 0) {
    const len = data[p + 2];
    if (p + 3 + len > data.length) return null;              // broken tail
    if (data[p] === SYS_INSCRIPTION) {
      if (data[p + 1] !== 1 || len < 21) return null;          // unknown version
      const b = data.subarray(p + 3, p + 3 + len);
      const slots = [0, 1, 2].map((s) => ({ id: b[2 + s * 3], tier: b[3 + s * 3], state: b[4 + s * 3] }));
      const name = b.subarray(11, 21);
      const end = name.indexOf(0);
      return {
        potential: b[0],
        spent: b[1],
        slots,
        bound: name.subarray(0, end < 0 ? 10 : end).toString("latin1"),
      };
    }
    p += 3 + len;
  }
  return null;
}

// ---------- Step 5: Pools.xml ----------
interface InscEntry { name: string; desc: string; magnitude: number[] }
let cache: { mtime: number; enabled: boolean; entries: Map<number, InscEntry> } | null = null;

const asArray = <T>(v: T | T[] | undefined): T[] => (v === undefined ? [] : Array.isArray(v) ? v : [v]);

function loadConfig() {
  const poolsFile = `${DATA_DIR}/Pools.xml`;
  const mainFile = `${DATA_DIR}/Inscription.xml`;
  const mtime = Math.max(fs.statSync(poolsFile).mtimeMs, fs.statSync(mainFile).mtimeMs);
  if (cache && cache.mtime === mtime) return cache;

  const parser = new XMLParser({ ignoreAttributes: false, attributeNamePrefix: "", parseAttributeValue: false });
  const main = parser.parse(fs.readFileSync(mainFile, "utf8"));
  const pools = parser.parse(fs.readFileSync(poolsFile, "utf8"));

  const entries = new Map<number, InscEntry>();
  for (const pool of asArray<any>(pools.Pools?.Pool)) {
    for (const e of asArray<any>(pool.Entry)) {
      const id = parseInt(e.Id, 10);
      if (!(id >= 1 && id <= 255) || entries.has(id)) continue;   // the server skips these too
      const mag = String(e.Magnitude ?? "").split(",").map((x) => parseInt(x.trim(), 10)).filter((x) => !isNaN(x)).slice(0, 8);
      if (mag.length === 0) mag.push(0);
      while (mag.length < 8) mag.push(mag[mag.length - 1]);      // short list repeats its last value
      entries.set(id, {
        name: String(e.Name ?? "").slice(0, 31),
        desc: String(e.Desc ?? "").slice(0, 95),
        magnitude: mag,
      });
    }
  }

  cache = { mtime, enabled: String(main.Inscription?.Enabled ?? "0") === "1", entries };
  return cache;
}

// ---------- Step 6: lines ----------
export type LineColor = "yellow" | "violet" | "blue" | "gray" | "darkred" | "red";
export interface TooltipLine { text: string; color: LineColor; bold: boolean }

function formatDesc(desc: string, value: number): string {
  let out = "";
  let replaced = false;
  for (let i = 0; i < desc.length; i++) {
    if (desc[i] === "%" && desc[i + 1] === "d" && !replaced) { out += String(value); replaced = true; i++; continue; }
    if (desc[i] === "%" && desc[i + 1] === "%") i++;
    out += desc[i];
  }
  return out;
}

export function inscriptionLines(data: Buffer | undefined): TooltipLine[] {
  if (!data) return [];
  const cfg = loadConfig();
  if (!cfg.enabled) return [];
  const rec = readInscription(data);
  if (!rec) return [];

  const lines: TooltipLine[] = [];
  const left = Math.max(0, rec.potential - rec.spent);
  lines.push({ text: `Potential ${left} / ${rec.potential}`, color: "yellow", bold: true });

  for (const slot of rec.slots) {
    if (slot.state === 1) lines.push({ text: "Inscription Slot (empty)", color: "gray", bold: false });
    else if (slot.state === 3) lines.push({ text: "Inscription Slot (corrupted)", color: "darkred", bold: false });
    else if (slot.state === 2) {
      const e = cfg.entries.get(slot.id);
      if (!e) { lines.push({ text: "Unknown Inscription", color: "gray", bold: false }); continue; }
      const tier = Math.min(slot.tier, 7);
      lines.push({ text: e.name + TIER_TEXT[tier], color: "violet", bold: true });
      if (e.desc) lines.push({ text: formatDesc(e.desc, e.magnitude[tier]), color: "blue", bold: false });
    }
  }

  if (rec.bound) lines.push({ text: `Bound to ${rec.bound}`, color: "red", bold: false });
  return lines;
}

const inv: Buffer = character.Inventory;                  // varbinary(3792)
const items = [];
for (let slot = 0; slot * 16 + 16 <= inv.length; slot++) items.push(inv.subarray(slot * 16, slot * 16 + 16));

const ext = await loadItemExt(pool, items.map(itemSerial).filter((s): s is number => s !== null));

for (const item of items) {
  const serial = itemSerial(item);
  const extra = serial === null ? [] : inscriptionLines(ext.get(serial));
  // render your normal tooltip, then `extra` at the end (after a blank line)
}

<?php
// inscription.php
const INSC_DATA_DIR = 'C:/MuServer/Data/Plugins/Inscription';   // your server's path
const INSC_TIER_TEXT = ['', ' II', ' III', ' IV', ' V', ' VI', ' VII', ' VIII'];

// ---------- Step 1: serial ----------
function itemSerial(string $item): ?int {
    if (strlen($item) < 16) return null;
    $b = array_values(unpack('C16', $item));
    if ($b[0] === 0xFF && ($b[7] & 0x80) && ($b[9] & 0xF0) === 0xF0) return null;   // empty slot
    $serial = unpack('N', substr($item, 3, 4))[1];                                     // big-endian
    return $serial === 0 ? null : $serial;
}

// ---------- Step 2: ItemExt rows ----------
function loadItemExt(PDO $db, array $serials): array {
    $out = [];
    foreach (array_chunk(array_values(array_unique($serials)), 500) as $chunk) {
        $marks = implode(',', array_fill(0, count($chunk), '?'));
        $st = $db->prepare("SELECT ItemSerial, Data FROM ItemExt WHERE ItemSerial IN ($marks)");
        $st->execute($chunk);
        $st->bindColumn(1, $serial);
        $st->bindColumn(2, $data, PDO::PARAM_LOB, 0, PDO::SQLSRV_ENCODING_BINARY);
        while ($st->fetch(PDO::FETCH_BOUND)) $out[(int)$serial] = is_resource($data) ? stream_get_contents($data) : $data;
    }
    return $out;
}

// ---------- Step 3 + 4: record ----------
function readInscription(string $data): ?array {
    $n = strlen($data);
    $p = 0;
    while ($p + 3 <= $n && ord($data[$p]) !== 0) {
        $len = ord($data[$p + 2]);
        if ($p + 3 + $len > $n) return null;                                   // broken tail
        if (ord($data[$p]) === 1) {
            if (ord($data[$p + 1]) !== 1 || $len < 21) return null;           // unknown version
            $b = substr($data, $p + 3, $len);
            $slots = [];
            for ($s = 0; $s < 3; $s++) {
                $slots[] = ['id' => ord($b[2 + $s * 3]), 'tier' => ord($b[3 + $s * 3]), 'state' => ord($b[4 + $s * 3])];
            }
            $name = substr($b, 11, 10);
            $zero = strpos($name, "\0");
            return [
                'potential' => ord($b[0]),
                'spent' => ord($b[1]),
                'slots' => $slots,
                'bound' => $zero === false ? $name : substr($name, 0, $zero),
            ];
        }
        $p += 3 + $len;
    }
    return null;
}

// ---------- Step 5: Pools.xml ----------
function inscriptionConfig(): array {
    static $cache = null;
    $pools = INSC_DATA_DIR . '/Pools.xml';
    $main = INSC_DATA_DIR . '/Inscription.xml';
    clearstatcache();
    $mtime = max(filemtime($pools), filemtime($main));
    if ($cache !== null && $cache['mtime'] === $mtime) return $cache;

    $enabled = (string)simplexml_load_file($main)['Enabled'] === '1';
    $entries = [];
    foreach (simplexml_load_file($pools)->Pool as $pool) {
        foreach ($pool->Entry as $e) {
            $id = (int)$e['Id'];
            if ($id < 1 || $id > 255 || isset($entries[$id])) continue;          // the server skips these too
            $mag = [];
            foreach (explode(',', (string)$e['Magnitude']) as $x) {
                if (trim($x) !== '' && count($mag) < 8) $mag[] = (int)trim($x);
            }
            if (!$mag) $mag[] = 0;
            while (count($mag) < 8) $mag[] = end($mag);                         // short list repeats its last value
            $entries[$id] = [
                'name' => substr((string)$e['Name'], 0, 31),
                'desc' => substr((string)$e['Desc'], 0, 95),
                'magnitude' => $mag,
            ];
        }
    }
    return $cache = ['mtime' => $mtime, 'enabled' => $enabled, 'entries' => $entries];
}

// ---------- Step 6: lines ----------
function formatInscDesc(string $desc, int $value): string {
    $out = '';
    $replaced = false;
    $n = strlen($desc);
    for ($i = 0; $i < $n; $i++) {
        $next = $i + 1 < $n ? $desc[$i + 1] : '';
        if ($desc[$i] === '%' && $next === 'd' && !$replaced) { $out .= $value; $replaced = true; $i++; continue; }
        if ($desc[$i] === '%' && $next === '%') $i++;
        $out .= $desc[$i];
    }
    return $out;
}

/** @return array<array{text: string, color: string, bold: bool}> */
function inscriptionLines(?string $data): array {
    if ($data === null) return [];
    $cfg = inscriptionConfig();
    if (!$cfg['enabled']) return [];
    $rec = readInscription($data);
    if ($rec === null) return [];

    $left = max(0, $rec['potential'] - $rec['spent']);
    $lines = [['text' => "Potential $left / {$rec['potential']}", 'color' => 'yellow', 'bold' => true]];

    foreach ($rec['slots'] as $slot) {
        if ($slot['state'] === 1) $lines[] = ['text' => 'Inscription Slot (empty)', 'color' => 'gray', 'bold' => false];
        elseif ($slot['state'] === 3) $lines[] = ['text' => 'Inscription Slot (corrupted)', 'color' => 'darkred', 'bold' => false];
        elseif ($slot['state'] === 2) {
            $e = $cfg['entries'][$slot['id']] ?? null;
            if ($e === null) { $lines[] = ['text' => 'Unknown Inscription', 'color' => 'gray', 'bold' => false]; continue; }
            $tier = min($slot['tier'], 7);
            $lines[] = ['text' => $e['name'] . INSC_TIER_TEXT[$tier], 'color' => 'violet', 'bold' => true];
            if ($e['desc'] !== '') $lines[] = ['text' => formatInscDesc($e['desc'], $e['magnitude'][$tier]), 'color' => 'blue', 'bold' => false];
        }
    }

    if ($rec['bound'] !== '') $lines[] = ['text' => 'Bound to ' . $rec['bound'], 'color' => 'red', 'bold' => false];
    return $lines;
}

$items = str_split($character['Inventory'], 16);          // varbinary(3792)
$ext = loadItemExt($db, array_filter(array_map('itemSerial', $items), fn($s) => $s !== null));

foreach ($items as $item) {
    $serial = itemSerial($item);
    $extra = $serial === null ? [] : inscriptionLines($ext[$serial] ?? null);
    // render your normal tooltip, then $extra at the end (after a blank line):
    foreach ($extra as $l) {
        printf('<div class="insc-%s%s">%s</div>', $l['color'], $l['bold'] ? ' bold' : '', htmlspecialchars($l['text']));
    }
}