@jjlmoya/utils-tabletop 1.34.0 → 1.37.0

package/src/tool/card-draw-odds-calculator/i18n/tr.ts

@@ -0,0 +1,15 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { CardDrawOddsUI } from '../ui';
+
+export const content: ToolLocaleContent<CardDrawOddsUI> = {
+  slug: 'kart-cekme-olasilik-hesaplayici', title: 'Kart Çekme Olasılığı Hesaplayıcı',
+  description: 'Hipergeometrik dağılımla belirli bir tura kadar bir kartın en az bir kopyasını çekme olasılığını hesaplayın.',
+  ui: {
+    configureLabel: 'Deste kurallarını ayarla', configureHint: 'Deste, el, çekim ve mulligan varsayımlarını değiştirin. Sonuçlar anında güncellenir.', presetLabel: 'Başlangıç noktası', presetCustom: 'Özel kurallar', presetStandard: '60 kartlık deste · 4 kopya', presetLimited: '40 kartlık deste · 4 kopya', presetSingleton: '100 kartlık deste · 1 kopya', deckSizeLabel: 'Deste boyutu', targetCopiesLabel: 'Kartın kopyaları', openingHandLabel: 'Başlangıç eli', drawsPerTurnLabel: 'Tur başına çekim', throughTurnLabel: 'Şu tura kadar göster', mulliganLabel: 'Mulligan modeli', mulliganNone: 'Mulligan yok', mulliganFullRedraw: 'Kaçırınca yeniden çek', visualLabel: 'Çekim yolun', visualHint: 'Örneğe daha fazla kart girdikçe kart yelpazesi açılır.', openingHandStage: 'Başlangıç eli', turnLabel: 'Tur', cardsSeenLabel: 'Görülen kartlar', finalChanceLabel: 'Son turdaki olasılık', expectedCopiesLabel: 'O zamana kadar beklenen kopya', probabilityByTurnLabel: 'Tura göre olasılık', explanationLabel: 'En az bir kopya', noMulliganNote: 'Mulligan yok: model karıştırılmış desteden tek bir örnek sayar.', fullRedrawNote: 'Kaçırınca yeniden çek: başlangıç elinde hedef yoksa el bir kez tamamen değiştirilir.', invalidInput: 'Devam etmek için deste kurallarını kontrol edin.', invalidDeck: 'Geçerli bir deste boyutu seçin.', invalidCopies: 'Kopya sayısı sıfır ile deste boyutu arasında olmalıdır.', invalidHand: 'Başlangıç eli desteden büyük olamaz.', invalidDraws: 'Tur başına çekim sıfır veya daha fazla olmalıdır.', invalidTurns: 'Sıfır ile 60 arasında bir tur seçin.', cardsLabel: 'kart', copyLabel: 'kopya',
+  },
+  seo: [{ type: 'title', level: 2, text: 'Deste kart çekme olasılığını hesaplayın' }, { type: 'paragraph', html: 'Bu hesaplayıcı deste kurarken şu pratik soruyu yanıtlar: belirli bir tura kadar bir kartın en az bir kopyasını görme olasılığım nedir? Deste boyutu, kopyalar, başlangıç eli, çekimler ve mulligan kuralını girerek tur tur sonucu görün.' }, { type: 'paragraph', html: 'Kartlar geri konmadan çekildiği için hipergeometrik dağılım kullanılır. Bu model koleksiyon kart oyunları, masa oyunları, limited desteler ve diğer sonlu kart havuzları için uygundur.' }, { type: 'title', level: 2, text: 'Çekim zaman çizelgesi nasıl okunur' }, { type: 'list', items: ['Başlangıç eli, karıştırılmış desteden alınan ilk örnektir.', 'Her tur ayarlanan sayıda kart ekler.', 'Yüzde en az bir kopyayı gösterir; tam olarak bir kopyayı değil.', 'Beklenen kopya ayrı bir ortalamadır ve isabet olasılığıyla aynı şeyi ölçmez.'] }, { type: 'title', level: 2, text: 'Mulligan varsayımları ayarlanabilir' }, { type: 'paragraph', html: 'Yeniden çekme seçeneği basit bir stratejiyi modeller: hedefi içeren eli tut; hedef yoksa eli bir kez tamamen değiştir ve yeni yoldan devam et. Kısmi mulligan, scry, tutor ve diğer kartlara göre kararlar dahil değildir.' }, { type: 'tip', title: 'Oyunun gerçek kurallarını kullanın', html: 'Oyununuzda farklı bir başlangıç eli, ek çekim veya mulligan prosedürü varsa alanları değiştirin. Doğru sonuç kurallara ve kopya sayısına bağlıdır.' }, { type: 'title', level: 2, text: 'Hipergeometrik fikir tek satırda' }, { type: 'paragraph', html: 'N kartlık destede K hedef kopyası varsa, n kartta hedef bulamama olasılığı C(N − K, n) / C(N, n) olur. Hesaplayıcı bunun tümleyenini, 1 − hedefsiz olasılığı, kullanarak en az bir hedef kartı bulma ihtimalini verir.' }, { type: 'diagnostic', variant: 'info', title: 'Bu hesaplayıcı neyi simüle etmez', badge: 'SINIRLAR', html: 'İsimli kartları, seçimleri, değiştirme etkilerini, scry işlemlerini, tutorları, birden çok hedefi veya tam oyun durumunu izlemez. Sonucu temel alın ve ek kuralları ayrıca modelleyin.' }],
+  faq: [{ question: 'Kart çekme olasılığı formülü nedir?', answer: 'n kartta en az bir kopya için 1 − C(N − K, n) / C(N, n) kullanılır; N deste boyutu, K kopya sayısıdır.' }, { question: 'Beş kartlık çekim için çalışır mı?', answer: 'Evet. Başlangıç eli değerini 5 yapın ve oyununuzdaki çekim ve turları seçin.' }, { question: 'Mulligan seçeneği nasıl çalışır?', answer: 'Kaçırınca yeniden çek, hedef kopyası olmayan başlangıç elinin bir kez tamamen değiştirilmesini modeller. Oyunlara özel kısmi kurallardan daha basittir.' }, { question: 'Beklenen kopya neden isabet olasılığından farklıdır?', answer: 'İsabet olasılığı örnekte bir veya daha fazla kopya olup olmadığını sorar. Beklenen kopya örnekteki ortalama kopya sayısıdır.' }],
+  bibliography, howTo: [{ name: 'Deste boyutunu ve kopyaları girin', text: 'Toplam kart sayısını ve aradığınız kopya sayısını belirleyin.' }, { name: 'El ve çekim kurallarını eşleştirin', text: 'Başlangıç eli, tur başına kart ve gösterilecek son turu girin.' }, { name: 'Mulligan modeli seçin', text: 'Tek örnek için Mulligan yok seçeneğini veya tek tam değişim için kaçırınca yeniden çek seçeneğini kullanın.' }, { name: 'Zaman çizelgesini okuyun', text: 'Başlangıç elinde ve her turda en az bir kopya yüzdesini karşılaştırın.' }],
+  schemas: [{ '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: 'Kart Çekme Olasılığı Hesaplayıcı', applicationCategory: 'GameApplication', operatingSystem: 'Web', description: 'Sonlu tabletop desteleri için kart çekme olasılıkları.' }, { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: [{ '@type': 'Question', name: 'Kart çekme olasılığı formülü nedir?', acceptedAnswer: { '@type': 'Answer', text: 'Hesaplayıcı, hedef bulamamanın hipergeometrik olasılığının tümleyenini kullanır.' } }] }, { '@context': 'https://schema.org', '@type': 'HowTo', name: 'Kart çekme olasılığını hesaplama', step: [{ '@type': 'HowToStep', name: 'Deste kurallarını ayarla', text: 'Deste boyutu, kopyalar, el, çekimler ve turları girin.' }, { '@type': 'HowToStep', name: 'Sonucu okuyun', text: 'Zaman çizelgesinde en az bir kopya görme olasılığını karşılaştırın.' }] }],
+};

package/src/tool/card-draw-odds-calculator/i18n/zh.ts

@@ -0,0 +1,15 @@
+import type { ToolLocaleContent } from '../../../types';
+import { bibliography } from '../bibliography';
+import type { CardDrawOddsUI } from '../ui';
+
+export const content: ToolLocaleContent<CardDrawOddsUI> = {
+  slug: 'card-draw-odds-calculator', title: '卡牌抽取概率计算器',
+  description: '使用超几何分布，计算在指定回合前抽到至少一张目标卡的概率。',
+  ui: {
+    configureLabel: '设置牌组规则', configureHint: '修改牌组、起手、抽牌和调度规则，结果会立即更新。', presetLabel: '起始方案', presetCustom: '自定义规则', presetStandard: '60张牌组 · 4张', presetLimited: '40张牌组 · 4张', presetSingleton: '100张牌组 · 1张', deckSizeLabel: '牌组大小', targetCopiesLabel: '目标卡数量', openingHandLabel: '起手牌', drawsPerTurnLabel: '每回合抽牌', throughTurnLabel: '显示至回合', mulliganLabel: '调度模型', mulliganNone: '不调度', mulliganFullRedraw: '未命中后重抽', visualLabel: '你的抽牌路径', visualHint: '样本中的牌越来越多时，扇形牌面会展开。', openingHandStage: '起手牌', turnLabel: '回合', cardsSeenLabel: '已看牌数', finalChanceLabel: '最终回合概率', expectedCopiesLabel: '预计看到的目标牌', probabilityByTurnLabel: '按回合查看概率', explanationLabel: '至少一张', noMulliganNote: '不调度：模型只计算洗牌后牌组的一次样本。', fullRedrawNote: '未命中后重抽：起手没有目标牌时，将整手牌替换一次。', invalidInput: '请检查牌组规则后继续。', invalidDeck: '请输入有效的牌组大小。', invalidCopies: '目标牌数量必须在0和牌组大小之间。', invalidHand: '起手牌不能多于牌组。', invalidDraws: '每回合抽牌数不能小于0。', invalidTurns: '请选择0到60之间的回合。', cardsLabel: '张牌', copyLabel: '张',
+  },
+  seo: [{ type: 'title', level: 2, text: '计算牌组抽到目标卡的概率' }, { type: 'paragraph', html: '这个计算器回答组牌时的实际问题：在指定回合前看到至少一张目标卡的概率是多少？输入牌组大小、目标牌数量、起手牌、每回合抽牌和调度规则，即可查看每回合的变化。' }, { type: 'paragraph', html: '由于抽牌后不会放回，计算使用超几何分布。它适用于集换式卡牌、桌游、限制赛牌组以及其他有限的牌池。' }, { type: 'title', level: 2, text: '如何阅读抽牌时间线' }, { type: 'list', items: ['起手牌是洗牌后牌组的第一份样本。', '每个回合会加入设置数量的牌。', '百分比表示至少一张，而不是刚好一张。', '预计牌数是独立的平均值，与命中概率不同。'] }, { type: 'title', level: 2, text: '调度假设可以调整' }, { type: 'paragraph', html: '重抽选项模拟简单策略：起手有目标卡就保留，没有目标卡时将整手牌替换一次，然后继续计算。它不包含部分调度、占卜、检索或基于其他牌的决策。' }, { type: 'tip', title: '使用游戏的真实规则', html: '如果游戏有不同的起手牌、额外抽牌或调度流程，请修改这些字段。准确结果取决于规则和牌组中的目标牌数量。' }, { type: 'title', level: 2, text: '一行理解超几何分布' }, { type: 'paragraph', html: '从含有N张牌、其中K张目标牌的牌组中看n张时，没有目标牌的概率是 C(N − K, n) / C(N, n)。计算器使用其补集，得到至少一张目标牌的概率。' }, { type: 'diagnostic', variant: 'info', title: '本计算器不会模拟什么', badge: '限制', html: '它不会追踪具体牌名、选牌、替换效果、占卜、检索、多个目标或完整的游戏状态。请把结果当作基准，再单独处理额外规则。' }],
+  faq: [{ question: '抽牌概率使用什么公式？', answer: '在n张牌中至少有一张目标牌的概率是 1 − C(N − K, n) / C(N, n)，其中N是牌组大小，K是目标牌数量。' }, { question: '可以计算抽5张牌吗？', answer: '可以。把起手牌设置为5，并按照游戏规则填写抽牌数和回合。' }, { question: '调度选项如何计算？', answer: '未命中后重抽表示将没有目标牌的起手整手替换一次，比具体游戏的部分调度规则更简单。' }, { question: '预计牌数为什么不同于命中概率？', answer: '命中概率只询问样本中是否有一张或更多目标牌，预计牌数表示样本中的平均数量。' }],
+  bibliography, howTo: [{ name: '输入牌组大小和目标数量', text: '设置牌组总数以及想抽到的目标牌数量。' }, { name: '匹配起手和抽牌规则', text: '填写起手牌、每回合抽牌数和最后显示的回合。' }, { name: '选择调度模型', text: '连续样本选择不调度，需要整手替换时选择未命中后重抽。' }, { name: '阅读时间线', text: '比较起手和每个回合看到至少一张目标牌的概率。' }],
+  schemas: [{ '@context': 'https://schema.org', '@type': 'SoftwareApplication', name: '卡牌抽取概率计算器', applicationCategory: 'GameApplication', operatingSystem: 'Web', description: '用于有限桌游牌组的抽牌概率计算器。' }, { '@context': 'https://schema.org', '@type': 'FAQPage', mainEntity: [{ '@type': 'Question', name: '抽牌概率使用什么公式？', acceptedAnswer: { '@type': 'Answer', text: '计算器使用没有目标牌的超几何概率的补集。' } }] }, { '@context': 'https://schema.org', '@type': 'HowTo', name: '计算抽牌概率', step: [{ '@type': 'HowToStep', name: '设置牌组规则', text: '输入牌组大小、目标数量、起手、抽牌和回合。' }, { '@type': 'HowToStep', name: '查看结果', text: '在时间线中比较看到至少一张目标牌的概率。' }] }],
+};

package/src/tool/card-draw-odds-calculator/index.ts

@@ -0,0 +1,11 @@
+import type { ToolDefinition } from '../../types';
+import { cardDrawOddsCalculator } from './entry';
+
+export * from './entry';
+
+export const CARD_DRAW_ODDS_CALCULATOR_TOOL: ToolDefinition = {
+  entry: cardDrawOddsCalculator,
+  Component: () => import('./component.astro'),
+  SEOComponent: () => import('./seo.astro'),
+  BibliographyComponent: () => import('./bibliography.astro'),
+};

package/src/tool/card-draw-odds-calculator/logic.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest';
+import { evaluateInput } from './evaluator';
+import { calculateCardDrawOdds, DEFAULT_INPUT, probabilityAtLeastOne } from './logic';
+
+describe('card draw odds calculator', () => {
+  it('matches the exact no-target complement for a 60 card deck', () => {
+    const result = probabilityAtLeastOne({ ...DEFAULT_INPUT, mulliganMode: 'none' }, 7);
+    expect(result).toBeCloseTo(1 - (56 * 55 * 54 * 53 * 52 * 51 * 50) / (60 * 59 * 58 * 57 * 56 * 55 * 54), 10);
+  });
+
+  it('increases the opening chance when a full redraw is taken after a miss', () => {
+    const input = { ...DEFAULT_INPUT, mulliganMode: 'fullRedraw' as const };
+    const noMulligan = probabilityAtLeastOne({ ...input, mulliganMode: 'none' }, 7);
+    const withMulligan = probabilityAtLeastOne(input, 7);
+    expect(withMulligan).toBeGreaterThan(noMulligan);
+    expect(withMulligan).toBeCloseTo(1 - (1 - noMulligan) ** 2, 10);
+  });
+
+  it('returns a monotonic timeline and a finite expected count', () => {
+    const result = calculateCardDrawOdds(DEFAULT_INPUT);
+    expect(result.points).toHaveLength(7);
+    expect(result.points[0]?.cardsSeen).toBe(7);
+    expect(result.points.at(-1)?.cardsSeen).toBe(13);
+    expect(result.points.every((point, index, points) => index === 0 || point.probability >= (points[index - 1]?.probability ?? 0))).toBe(true);
+    expect(result.expectedCopiesAtFinal).toBeGreaterThan(4 * 13 / 60);
+  });
+
+  it('handles a deck with no copies as zero probability', () => {
+    const result = calculateCardDrawOdds({ ...DEFAULT_INPUT, targetCopies: 0 });
+    expect(result.finalProbability).toBe(0);
+  });
+
+  it('rejects each invalid input family with a localized error key', () => {
+    expect(evaluateInput({ ...DEFAULT_INPUT, deckSize: 0 }).errorKey).toBe('invalidDeck');
+    expect(evaluateInput({ ...DEFAULT_INPUT, targetCopies: 61 }).errorKey).toBe('invalidCopies');
+    expect(evaluateInput({ ...DEFAULT_INPUT, openingHand: 61 }).errorKey).toBe('invalidHand');
+    expect(evaluateInput({ ...DEFAULT_INPUT, drawsPerTurn: -1 }).errorKey).toBe('invalidDraws');
+    expect(evaluateInput({ ...DEFAULT_INPUT, throughTurn: 61 }).errorKey).toBe('invalidTurns');
+    expect(evaluateInput(DEFAULT_INPUT)).toEqual({ valid: true });
+  });
+
+  it('handles boundary samples without producing invalid probabilities', () => {
+    expect(probabilityAtLeastOne({ ...DEFAULT_INPUT, targetCopies: DEFAULT_INPUT.deckSize }, 0)).toBe(1);
+    expect(probabilityAtLeastOne({ ...DEFAULT_INPUT, targetCopies: 0 }, 13)).toBe(0);
+    const result = calculateCardDrawOdds({ ...DEFAULT_INPUT, throughTurn: 0 });
+    expect(result.points).toHaveLength(1);
+    expect(result.points[0]?.stage).toBe('opening');
+    expect(result.points.every((point) => point.probability >= 0 && point.probability <= 1)).toBe(true);
+  });
+});

package/src/tool/card-draw-odds-calculator/logic.ts

@@ -0,0 +1,100 @@
+export type MulliganMode = 'none' | 'fullRedraw';
+
+export interface CardDrawInput {
+  deckSize: number;
+  targetCopies: number;
+  openingHand: number;
+  drawsPerTurn: number;
+  throughTurn: number;
+  mulliganMode: MulliganMode;
+}
+
+export interface DrawOddsPoint {
+  stage: 'opening' | 'turn';
+  turn: number;
+  cardsSeen: number;
+  probability: number;
+  expectedCopies: number;
+}
+
+export interface CardDrawResult {
+  points: DrawOddsPoint[];
+  finalProbability: number;
+  openingProbability: number;
+  expectedCopiesAtFinal: number;
+}
+
+export const DEFAULT_INPUT: CardDrawInput = {
+  deckSize: 60,
+  targetCopies: 4,
+  openingHand: 7,
+  drawsPerTurn: 1,
+  throughTurn: 6,
+  mulliganMode: 'fullRedraw',
+};
+
+export const PRESETS: Record<string, Partial<CardDrawInput>> = {
+  standard: { deckSize: 60, targetCopies: 4, openingHand: 7, drawsPerTurn: 1, throughTurn: 6 },
+  limited: { deckSize: 40, targetCopies: 4, openingHand: 7, drawsPerTurn: 1, throughTurn: 6 },
+  singleton: { deckSize: 100, targetCopies: 1, openingHand: 7, drawsPerTurn: 1, throughTurn: 6 },
+};
+
+const clampProbability = (value: number): number => Math.min(1, Math.max(0, value));
+
+const logCombination = (n: number, k: number): number => {
+  if (k < 0 || k > n) return Number.NEGATIVE_INFINITY;
+  const count = Math.min(k, n - k);
+  let total = 0;
+  for (let index = 1; index <= count; index += 1) {
+    total += Math.log(n - count + index) - Math.log(index);
+  }
+  return total;
+};
+
+const noTargetProbability = (input: CardDrawInput, cardsSeen: number): number => {
+  if (input.targetCopies === 0) return 1;
+  if (cardsSeen > input.deckSize - input.targetCopies) return 0;
+  const logNoTarget = logCombination(input.deckSize - input.targetCopies, cardsSeen);
+  const logSample = logCombination(input.deckSize, cardsSeen);
+  return clampProbability(Math.exp(logNoTarget - logSample));
+};
+
+const expectedCopiesAt = (input: CardDrawInput, cardsSeen: number): number => {
+  const baseline = input.targetCopies * Math.min(cardsSeen, input.deckSize) / input.deckSize;
+  if (input.mulliganMode === 'none' || input.openingHand === input.deckSize) return baseline;
+  const drawCards = Math.max(0, cardsSeen - input.openingHand);
+  const expectedDrawsAfterMiss = drawCards * input.targetCopies / (input.deckSize - input.openingHand);
+  const expectedReplacement = baseline;
+  return baseline + noTargetProbability(input, input.openingHand) * (expectedReplacement - expectedDrawsAfterMiss);
+};
+
+export const probabilityAtLeastOne = (input: CardDrawInput, cardsSeen: number): number => {
+  const noTarget = noTargetProbability(input, cardsSeen);
+  if (input.mulliganMode === 'none') return clampProbability(1 - noTarget);
+  const noOpeningTarget = noTargetProbability(input, input.openingHand);
+  return clampProbability(1 - noOpeningTarget * noTarget);
+};
+
+const createPoint = (input: CardDrawInput, stage: 'opening' | 'turn', turn: number, cardsSeen: number): DrawOddsPoint => ({
+  stage,
+  turn,
+  cardsSeen,
+  probability: probabilityAtLeastOne(input, cardsSeen),
+  expectedCopies: expectedCopiesAt(input, cardsSeen),
+});
+
+export const calculateCardDrawOdds = (input: CardDrawInput): CardDrawResult => {
+  const points = [createPoint(input, 'opening', 0, input.openingHand)];
+  for (let turn = 1; turn <= input.throughTurn; turn += 1) {
+    const cardsSeen = Math.min(input.deckSize, input.openingHand + input.drawsPerTurn * turn);
+    points.push(createPoint(input, 'turn', turn, cardsSeen));
+  }
+  const openingPoint = points[0] as DrawOddsPoint;
+  const finalPoint = points[points.length - 1] as DrawOddsPoint;
+  return {
+    points,
+    finalProbability: finalPoint.probability,
+    openingProbability: openingPoint.probability,
+    expectedCopiesAtFinal: finalPoint.expectedCopies,
+  };
+};

package/src/tool/card-draw-odds-calculator/seo.astro

@@ -0,0 +1,16 @@
+---
+import { SEORenderer } from '@jjlmoya/utils-shared';
+import { cardDrawOddsCalculator } from './index';
+import type { KnownLocale } from '../../types';
+
+interface Props {
+  locale?: KnownLocale;
+}
+
+const { locale = 'en' } = Astro.props;
+const loader = cardDrawOddsCalculator.i18n[locale] || cardDrawOddsCalculator.i18n.en;
+const content = await loader?.();
+if (!content) return null;
+---
+
+{content.seo?.length > 0 && <SEORenderer content={{ locale, sections: content.seo }} />}

package/src/tool/card-draw-odds-calculator/storage.ts

@@ -0,0 +1,22 @@
+import type { CardDrawInput } from './logic';
+
+const STORAGE_KEY = 'card-draw-odds-calculator-input';
+
+export const loadCardDrawInput = (): Partial<CardDrawInput> => {
+  if (typeof localStorage === 'undefined') return {};
+  try {
+    const stored = localStorage.getItem(STORAGE_KEY);
+    return stored ? JSON.parse(stored) as Partial<CardDrawInput> : {};
+  } catch {
+    return {};
+  }
+};
+
+export const saveCardDrawInput = (input: CardDrawInput): void => {
+  if (typeof localStorage === 'undefined') return;
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(input));
+  } catch {
+    return;
+  }
+};

package/src/tool/card-draw-odds-calculator/ui.ts

@@ -0,0 +1,37 @@
+export interface CardDrawOddsUI {
+  [key: string]: string;
+  configureLabel: string;
+  configureHint: string;
+  presetLabel: string;
+  presetCustom: string;
+  presetStandard: string;
+  presetLimited: string;
+  presetSingleton: string;
+  deckSizeLabel: string;
+  targetCopiesLabel: string;
+  openingHandLabel: string;
+  drawsPerTurnLabel: string;
+  throughTurnLabel: string;
+  mulliganLabel: string;
+  mulliganNone: string;
+  mulliganFullRedraw: string;
+  visualLabel: string;
+  visualHint: string;
+  openingHandStage: string;
+  turnLabel: string;
+  cardsSeenLabel: string;
+  finalChanceLabel: string;
+  expectedCopiesLabel: string;
+  probabilityByTurnLabel: string;
+  explanationLabel: string;
+  noMulliganNote: string;
+  fullRedrawNote: string;
+  invalidInput: string;
+  invalidDeck: string;
+  invalidCopies: string;
+  invalidHand: string;
+  invalidDraws: string;
+  invalidTurns: string;
+  cardsLabel: string;
+  copyLabel: string;
+}

package/src/tool/dice-roller-simulator/i18n/es.ts

@@ -71,7 +71,7 @@ export const content: ToolLocaleContent = {
           con: 'Los resultados de D20 son muy inestables, haciendo que la habilidad del personaje dependa demasiado del azar.',
         },
         {
-          pro: 'Las curvas de campana de 3d6 priorizan los resultados medios, garantizando que los personajes hábiles rara vez fallen tareas fáciles.',
+          pro: 'Las curvas de campana de 3d6 priorizan los resultados medios, por lo que los personajes hábiles suelen fallar menos tareas fáciles.',
           con: 'Los sistemas de 3d6 exigen sumar tres dados y hacen que los impactos críticos (un 18 perfecto) sean extremadamente raros (0.46%).',
         },
       ],
@@ -182,7 +182,7 @@ export const content: ToolLocaleContent = {
     },
     {
       question: '¿Qué son los éxitos críticos y las pifias?',
-      answer: 'Un éxito crítico ocurre cuando sacas el máximo del dado (un 20 natural en D20), garantizando el éxito. Una pifia es sacar un 1 en el dado, lo que garantiza el fallo.',
+      answer: 'Un éxito crítico ocurre cuando sacas el máximo del dado (un 20 natural en D20), y suele considerarse un éxito. Una pifia es sacar un 1 en el dado, que suele considerarse un fallo.',
     },
     {
       question: '¿Cómo calcula el simulador las probabilidades de las tiradas?',
@@ -258,7 +258,7 @@ export const content: ToolLocaleContent = {
           'name': '¿Qué son los éxitos críticos y las pifias?',
           'acceptedAnswer': {
             '@type': 'Answer',
-            'text': 'Un éxito crítico ocurre cuando sacas el máximo del dado (un 20 natural en D20), garantizando el éxito. Una pifia es sacar un 1 en el dado, lo que garantiza el fallo.'
+            'text': 'Un éxito crítico ocurre cuando sacas el máximo del dado (un 20 natural en D20), y suele considerarse un éxito. Una pifia es sacar un 1 en el dado, que suele considerarse un fallo.'
           }
         },
         {

package/src/tool/dungeon-map-generator/component.astro

@@ -1,5 +1,5 @@
----
-import { buildMapSvg } from './dom-views';
+---
+import { buildMapSvg } from './dom-views';
 import { evaluateMap } from './evaluator';
 import { DEFAULT_CONFIG, generateDungeon } from './logic';
 import type { DungeonMapGeneratorUI } from './ui';
@@ -15,13 +15,15 @@ const initialEvaluation = evaluateMap(initialMap, ui);
 
 <div class="dmg" data-dungeon-generator data-style="dungeon">
   <script is:inline type="application/json" data-ui set:html={JSON.stringify(ui)} />
-  <section class="dmg-controls" aria-label={ui.styleLabel}>
-    <div class="dmg-field dmg-field-seed">
+  <section class="dmg-controls" aria-label={ui.styleLabel}>
+    <div class="dmg-intro">{ui.intro}</div>
+    <div class="dmg-field dmg-field-seed">
       <label for="dmg-seed-input">{ui.seedLabel}</label>
       <div class="dmg-seed-input-group">
-        <input id="dmg-seed-input" name="seed" type="text" value={DEFAULT_CONFIG.seed} maxlength="48" spellcheck="false" />
-        <button class="dmg-shuffle" type="button" data-random-seed>{ui.randomSeed}</button>
-      </div>
+        <input id="dmg-seed-input" name="seed" type="text" value={DEFAULT_CONFIG.seed} maxlength="48" spellcheck="false" />
+        <button class="dmg-shuffle" type="button" data-random-seed>{ui.randomSeed}</button>
+      </div>
+      <small>{ui.seedHint}</small>
     </div>
 
     <fieldset class="dmg-styles">
@@ -103,11 +105,13 @@ const initialEvaluation = evaluateMap(initialMap, ui);
         <div><dt>{ui.doorsLabel}</dt><dd data-door-count>{initialMap.doorCount}</dd></div>
         <div><dt>{ui.floorLabel}</dt><dd data-floor-percent>{initialEvaluation.coverage}%</dd></div>
       </dl>
-      <div class="dmg-legend" aria-label={ui.mapReady}>
-        <span><i data-tile="floor"></i>{ui.legendFloor}</span>
-        <span><i data-tile="wall"></i>{ui.legendWall}</span>
-        <span><i data-tile="door"></i>{ui.legendDoor}</span>
-      </div>
+      <div class="dmg-legend" aria-label={ui.mapReady}>
+        <span class="dmg-connected-badge">{ui.connectedBadge}</span>
+        <span class="dmg-dimensions" data-dimensions>{initialMap.config.columns} × {initialMap.config.rows} {ui.dimensionsUnit}</span>
+        <span><i data-tile="floor"></i>{ui.legendFloor}</span>
+        <span><i data-tile="wall"></i>{ui.legendWall}</span>
+        <span><i data-tile="door"></i>{ui.legendDoor}</span>
+      </div>
     </div>
 
     <div class="dmg-actions">

package/src/tool/dungeon-map-generator/dom-views.ts

@@ -67,10 +67,11 @@ export function renderMap(context: RenderContext): void {
   const mapHost = root.querySelector<HTMLElement>('[data-map-host]');
   if (mapHost) mapHost.innerHTML = buildMapSvg(map);
   setText(root, '[data-map-seed]', map.config.seed);
-  setText(root, '[data-room-count]', String(map.rooms.length));
-  setText(root, '[data-door-count]', String(map.doorCount));
-  renderEvaluation(context);
-}
+  setText(root, '[data-room-count]', String(map.rooms.length));
+  setText(root, '[data-door-count]', String(map.doorCount));
+  setText(root, '[data-dimensions]', `${map.config.columns} × ${map.config.rows} ${context.ui.dimensionsUnit}`);
+  renderEvaluation(context);
+}
 
 function renderEvaluation(context: RenderContext): void {
   const evaluation = evaluateMap(context.map, context.ui);

package/src/tool/dungeon-map-generator/i18n/es.ts

@@ -63,7 +63,7 @@ const faq = [
   },
   {
     question: '¿Todas las salas generadas son accesibles entre sí?',
-    answer: 'Sí. Las salas se conectan mediante una ruta principal tras su colocación, garantizando que cada región transitable pertenezca a un único mapa conectado.',
+    answer: 'Sí. Las salas se conectan mediante una ruta principal tras su colocación, de modo que cada región transitable queda dentro de un único mapa conectado.',
   },
   {
     question: '¿Qué cambia entre los estilos mazmorra, cueva y ciencia ficción?',
@@ -139,7 +139,7 @@ export const content: DungeonMapGeneratorLocaleContent = {
   ui,
   seo: [
     { type: 'title', text: 'Genera un Mapa de Mazmorra Jugable mediante una Semilla Reutilizable', level: 2 },
-    { type: 'paragraph', html: 'Un generador de mapas de mazmorras aleatorios necesita ir más allá del ruido visual aleatorio. Cada cámara debe ser alcanzable mediante pasillos conectados, la cuadrícula debe adaptarse a la superficie de juego y el resultado debe poder recuperarse en cualquier momento. Este generador trata la semilla y los controles como una especificación de mapa compacta y determinista. Mantener la misma semilla, filas, columnas y estilo garantiza reconstruir exactamente la misma estructura más adelante.' },
+    { type: 'paragraph', html: 'Un generador de mapas de mazmorras aleatorios necesita ir más allá del ruido visual aleatorio. Cada cámara debe ser alcanzable mediante pasillos conectados, la cuadrícula debe adaptarse a la superficie de juego y el resultado debe poder recuperarse en cualquier momento. Este generador trata la semilla y los controles como una especificación de mapa compacta y determinista. Mantener la misma semilla, filas, columnas y estilo permite reconstruir la misma estructura más adelante.' },
     { type: 'title', text: 'Dimensiones de Cuadrícula para Impresión y Tableros Virtuales', level: 2 },
     { type: 'paragraph', html: 'Configurar el tamaño de la cuadrícula es el primer paso práctico. Una cuadrícula pequeña es fácil de imprimir en papel y resulta ideal para aventuras cortas, mientras que un mapa amplio deja espacio para exploración compleja y múltiples facciones. La imagen exportada mantiene celdas perfectamente cuadradas para alinearse sin esfuerzo con la rejilla de cualquier software de tablero virtual (VTT).' },
     {

package/src/tool/encounter-difficulty-calculator/dom-views.ts

@@ -16,7 +16,14 @@ function renderMarkers(count: number, className: string, element: string): strin
 }
 
 function renderHint(result: EncounterResult, labels: Labels): string {
-  return labels[result.difficulty + 'Hint'] ?? '';
+  const hints: Record<EncounterDifficulty, string> = {
+    belowEasy: labels.belowEasyHint ?? '',
+    easy: labels.easyHint ?? '',
+    medium: labels.mediumHint ?? '',
+    hard: labels.hardHint ?? '',
+    deadly: labels.deadlyHint ?? '',
+  };
+  return hints[result.difficulty];
 }
 
 function renderWarnings(result: EncounterResult, labels: Labels): string {

package/src/tool/fantasy-runes-translator/component.astro

@@ -1,5 +1,4 @@
 ---
-import './fantasy-runes-translator.css';
 
 interface Props {
   ui: Record<string, string>;

package/src/tool/fantasy-runes-translator/logic.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { ALPHABETS, getAlphabet, getShuffledMapping, translateText } from './logic';
+
+describe('fantasy runes translator logic', () => {
+  it('translates a documented Elder Futhark sample', () => {
+    expect(translateText('abc', 'elder-futhark').raw).toBe('ᚨᛒᚲ');
+  });
+
+  it('falls back to the first alphabet for an unknown key', () => {
+    expect(getAlphabet('not-a-real-alphabet' as never)).toBe(ALPHABETS[0]);
+  });
+
+  it('preserves spaces and leaves unsupported characters unchanged', () => {
+    const result = translateText('a 1', 'elder-futhark');
+    expect(result.raw).toBe('ᚨ 1');
+    expect(result.characters).toHaveLength(3);
+    expect(result.characters[1]?.char.name).toBe('Space');
+    expect(result.characters[2]?.char).toBeNull();
+  });
+
+  it('keeps seeded mappings deterministic and changes the assignment', () => {
+    const first = getShuffledMapping('elder-futhark', 42);
+    const second = getShuffledMapping('elder-futhark', 42);
+    expect(second).toEqual(first);
+    expect(first).not.toEqual(getShuffledMapping('elder-futhark', null));
+  });
+
+  it('handles an empty input without creating characters', () => {
+    expect(translateText('', 'fantasy').characters).toEqual([]);
+    expect(translateText('', 'fantasy').raw).toBe('');
+  });
+});

package/src/tool/first-player-selector/component.astro

@@ -1,5 +1,4 @@
 ---
-import './first-player-selector.css';
 
 interface Props {
   ui: Record<string, string>;

package/src/tool/first-player-selector/i18n/en.ts

@@ -84,7 +84,7 @@ export const content: ToolLocaleContent<FirstPlayerSelectorUI> = {
   ui,
   seo: [
     { type: 'title', text: 'Fairness and Strategy: Resolving the First-Player Advantage in Board Games', level: 2 },
-    { type: 'paragraph', html: 'Determining the starting player in tabletop sessions can heavily influence game dynamics. In game theory, the First-Player Advantage (FPA) refers to the statistical edge that the player taking the first turn has over their opponents. In strategic chess matches, wargames, and modern Eurogames like Agricola or Puerto Rico, taking the first action allows a player to secure critical resources or position pieces before opponents can react. To mitigate FPA and guarantee a balanced playing field, a reliable, unbiased selection method is essential. Our digital starting player selector guarantees absolute randomness, allowing gaming groups to establish turn order instantly and get straight to playing.' },
+    { type: 'paragraph', html: 'Determining the starting player in tabletop sessions can heavily influence game dynamics. In game theory, the First-Player Advantage (FPA) refers to the statistical edge that the player taking the first turn has over their opponents. In strategic chess matches, wargames, and modern Eurogames like Agricola or Puerto Rico, taking the first action allows a player to secure critical resources or position pieces before opponents can react. To mitigate FPA and support a balanced playing field, a reliable, unbiased selection method is useful. Our digital starting player selector uses a random selection step, allowing gaming groups to establish turn order instantly and get straight to playing.' },
     {
       type: 'stats',
       items: [

package/src/tool/first-player-selector/i18n/es.ts

@@ -34,7 +34,7 @@ const faq = [
   },
   {
     question: '¿La selección es realmente aleatoria?',
-    answer: 'Sí. El algoritmo de selección utiliza Math.random() de JavaScript, de grado criptográfico, para garantizar resultados imparciales. En el modo táctil, el ganador se elige uniformemente al azar entre todos los puntos de contacto detectados. En el modo ruleta, la rueda se desacelera de forma realista usando física de fricción, y el ángulo final determina matemáticamente al ganador.',
+    answer: 'Sí. El algoritmo de selección utiliza Math.random() de JavaScript para buscar resultados imparciales. En el modo táctil, el ganador se elige al azar entre todos los puntos de contacto detectados. En el modo ruleta, la rueda se desacelera de forma realista usando física de fricción, y el ángulo final determina matemáticamente al ganador.',
   },
   {
     question: '¿Cómo elimino un pin de jugador en el modo ruleta?',
@@ -84,7 +84,7 @@ export const content: ToolLocaleContent<FirstPlayerSelectorUI> = {
   ui,
   seo: [
     { type: 'title', text: 'Justicia y Estrategia: Cómo Evitar la Ventaja del Primer Jugador', level: 2 },
-    { type: 'paragraph', html: 'Determinar el jugador que comienza en las partidas de mesa puede influir enormemente en la dinámica del juego. En teoría de juegos, la Ventaja del Primer Jugador (FPA, por sus siglas en inglés) se refiere a la ventaja estadística que tiene el jugador que realiza el primer turno sobre sus oponentes. En partidas de ajedrez estratégico, wargames y Eurogames modernos como Agricola o Puerto Rico, realizar la primera acción permite asegurar recursos críticos o posicionar piezas antes de que los oponentes puedan reaccionar. Para mitigar la FPA y garantizar un campo de juego equilibrado, es esencial un método de selección fiable e imparcial. Nuestro selector digital de jugador inicial garantiza un azar absoluto, permitiendo a los grupos de juego establecer el orden de turnos al instante y pasar directamente a jugar.' },
+    { type: 'paragraph', html: 'Determinar el jugador que comienza en las partidas de mesa puede influir enormemente en la dinámica del juego. En teoría de juegos, la Ventaja del Primer Jugador (FPA, por sus siglas en inglés) se refiere a la ventaja estadística que tiene el jugador que realiza el primer turno sobre sus oponentes. En partidas de ajedrez estratégico, wargames y Eurogames modernos como Agricola o Puerto Rico, realizar la primera acción permite asegurar recursos críticos o posicionar piezas antes de que los oponentes puedan reaccionar. Para mitigar la FPA y favorecer un campo de juego equilibrado, es útil un método de selección fiable e imparcial. Nuestro selector digital de jugador inicial usa una selección aleatoria, permitiendo a los grupos de juego establecer el orden de turnos al instante y pasar directamente a jugar.' },
     {
       type: 'stats',
       items: [
@@ -109,7 +109,7 @@ export const content: ToolLocaleContent<FirstPlayerSelectorUI> = {
     {
       type: 'tip',
       title: 'Optimizando tu configuración de selección multitáctil',
-      html: 'Para obtener la mejor experiencia en el modo táctil, coloca tu tableta o teléfono inteligente plano en el centro de la mesa. Todos los jugadores deben colocar un dedo claramente sobre el lienzo. La cuenta atrás se reinicia si un jugador levanta o mueve el dedo, evitando selecciones accidentales y garantizando el consenso absoluto antes de que el selector se active.',
+      html: 'Para obtener la mejor experiencia en el modo táctil, coloca tu tableta o teléfono inteligente plano en el centro de la mesa. Todos los jugadores deben colocar un dedo claramente sobre el lienzo. La cuenta atrás se reinicia si un jugador levanta o mueve el dedo, evitando selecciones accidentales y dando al grupo la oportunidad de confirmar antes de que el selector se active.',
     },
     {
       type: 'title',

package/src/tool/hidden-role-dealer/component.astro

@@ -1,5 +1,4 @@
 ---
-import './hidden-role-dealer.css';
 
 interface Props {
   ui: Record<string, string>;

package/src/tool/lunar-tide-tracker/component.astro

@@ -1,5 +1,4 @@
 ---
-import './lunar-tide-tracker.css';
 
 interface Props {
   ui: Record<string, string>;

package/src/tool/mus-scoreboard/component.astro

@@ -1,5 +1,4 @@
 ---
-import './online-mus-scoreboard.css';
 import { musScoreboard } from './index';
 import type { KnownLocale } from '../../types';
 import type { MusScoreboardUI } from './ui';
@@ -113,13 +112,13 @@ if (!ui) return null;
       <div class="mus-felt-center">
         <span class="mus-center-label">{ui.scoreLabel}</span>
         <strong><span data-score="0">0</span><i>:</i><span data-score="1">0</span></strong>
-        <span class="mus-center-status" data-status-message>{ui.matchSaved}</span>
+        <span class="mus-center-status" data-status-message>{ui.matchReady}</span>
       </div>
     </div>
 
     <div class="mus-pair-score-row">
       <article class="mus-pair-card mus-pair-card-left">
-        <header><span class="mus-pair-index">A</span><h3 data-pair-label="0"></h3><span class="mus-game-count"><span data-games="0">0</span> {ui.gameLabel}</span></header>
+        <header><span class="mus-pair-index">A</span><h3 data-pair-label="0"></h3><span class="mus-game-count"><span data-games="0">0</span> <span data-game-unit="0">{ui.gameLabel}</span></span></header>
         <p class="mus-score-breakdown" data-breakdown="0">0 {ui.amarracoPlural} + 0 {ui.stonePlural}</p>
         <p class="mus-remaining" data-remaining="0">40 {ui.pointsToGo}</p>
         <div class="mus-tally" data-tally="0" aria-label={ui.stonesLabel}></div>
@@ -130,7 +129,7 @@ if (!ui) return null;
         </div>
       </article>
       <article class="mus-pair-card mus-pair-card-right">
-        <header><span class="mus-pair-index">B</span><h3 data-pair-label="1"></h3><span class="mus-game-count"><span data-games="1">0</span> {ui.gameLabel}</span></header>
+        <header><span class="mus-pair-index">B</span><h3 data-pair-label="1"></h3><span class="mus-game-count"><span data-games="1">0</span> <span data-game-unit="1">{ui.gameLabel}</span></span></header>
         <p class="mus-score-breakdown" data-breakdown="1">0 {ui.amarracoPlural} + 0 {ui.stonePlural}</p>
         <p class="mus-remaining" data-remaining="1">40 {ui.pointsToGo}</p>
         <div class="mus-tally" data-tally="1" aria-label={ui.stonesLabel}></div>

package/src/tool/mus-scoreboard/controller.ts

@@ -84,7 +84,8 @@ const confirmClose = (context: ControllerContext, team: Team): void => {
   showConfirmation(context, `${context.state.config.pairNames[team]}: ${context.ui.closeGamePrompt}`, () => {
     context.state = closeGame(context.state, team);
     const winner = context.state.games[team] >= context.state.config.gamesToWin;
-    refresh(context, winner ? context.ui.vacaWon : `${context.state.config.pairNames[team]} ${context.ui.gameClosed}`);
+    const gameMessage = `${context.state.config.pairNames[team]} ${context.ui.gameWon}`;
+    refresh(context, winner ? `${gameMessage}. ${context.ui.vacaWon}` : `${context.state.config.pairNames[team]} ${context.ui.gameClosed}`);
   });
 };
 

package/src/tool/mus-scoreboard/dom-views.ts

@@ -55,6 +55,11 @@ const renderHistory = (root: ParentNode, state: MusState, ui: MusScoreboardUI):
   });
 };
 
+const renderGameCount = (root: ParentNode, team: Team, games: number, ui: MusScoreboardUI): void => {
+  setText(root, `[data-games="${team}"]`, String(games));
+  setText(root, `[data-game-unit="${team}"]`, games === 1 ? ui.gameLabel : ui.gamePlural);
+};
+
 export const renderMusState = (root: ParentNode, state: MusState, ui: MusScoreboardUI, message: string): void => {
   const felt = query<HTMLElement>(root, '[data-mus-felt]');
   felt.dataset.handTeam = String(state.hand);
@@ -73,7 +78,7 @@ export const renderMusState = (root: ParentNode, state: MusState, ui: MusScorebo
     setTeamProgress(root, index, score, state.config.targetPoints);
     renderTally(root, index, score, ui);
   });
-  state.games.forEach((games, team) => setText(root, `[data-games="${team}"]`, String(games)));
+  state.games.forEach((games, team) => renderGameCount(root, team, games, ui));
   const matchWinner = getMatchWinner(state);
   state.points.forEach((_, team) => {
     const closeButton = query<HTMLButtonElement>(root, `[data-action="close-game"][data-team="${team}"]`);

package/src/tool/rpg-initiative-tracker/component.astro

@@ -1,5 +1,4 @@
 ---
-import './rpg-initiative-tracker.css';
 import AddForm from './components/AddForm.astro';
 import CombatantList from './components/CombatantList.astro';
 import TurnControls from './components/TurnControls.astro';