@quybt93/pcgf 0.0.1

package/plugins/phaser-casual-game-factory/templates/boot/brand/SplashFullscreenBg.js

@@ -0,0 +1,18 @@
+const SPLASH_BODY_CLASS = "splash-fullscreen";
+const ROOT_ID = "studio25-splash";
+
+/**
+ * Nền night (#0B1220) khi boot/splash 25 Studio.
+ * Copy cùng templates/boot/brand/BootLoadingScreen.js — default boot art khi user không đổi brand.
+ */
+export function showSplashFullscreenBg() {
+	if (typeof document === "undefined") return;
+	document.body.classList.add(SPLASH_BODY_CLASS);
+}
+
+export function hideSplashFullscreenBg() {
+	if (typeof document === "undefined") return;
+	document.body.classList.remove(SPLASH_BODY_CLASS);
+	const el = document.getElementById(ROOT_ID);
+	if (el?.parentNode) el.parentNode.removeChild(el);
+}

package/plugins/phaser-casual-game-factory/templates/boot/brand/brand-defaults.js

@@ -0,0 +1,36 @@
+/**
+ * Company Studio25 Boot brand tokens.
+ * Rebrand by editing this file + replacing public/logo-frog.png.
+ * Owned by skill `phaser-studio25-boot-brand` — not game splash art.
+ */
+
+/** DOM frog image for Boot splash (Home↔Game overlay may reuse the same URL as mask). */
+export const STUDIO25_FROG_SRC = '/logo-frog.png';
+
+/** Phaser texture key when loading the frog as a Home↔Game overlay mask. */
+export const STUDIO25_FROG_MASK_KEY = 'studio25_frog_mask';
+
+export const STUDIO25_WORDMARK = {
+  n: '25',
+  s: 'STUDIO',
+};
+
+export const STUDIO25_TAGLINE = 'Building Instant Games for the World';
+export const STUDIO25_FOOTER = 'A Skylink Group Company';
+
+/** Same tips + tip thresholds as demo-splash (`Math.floor(pct / 28)`). */
+export const DEFAULT_TIPS = [
+  'Loading assets…',
+  'Tip: play instantly — no app install!',
+  'Starting the game…',
+  'Almost ready…',
+];
+
+export const STUDIO25_BOOT_BRAND = {
+  frogSrc: STUDIO25_FROG_SRC,
+  frogMaskKey: STUDIO25_FROG_MASK_KEY,
+  wordmark: STUDIO25_WORDMARK,
+  tagline: STUDIO25_TAGLINE,
+  footer: STUDIO25_FOOTER,
+  tips: DEFAULT_TIPS,
+};

package/plugins/phaser-casual-game-factory/templates/boot/brand-shims.d.ts

@@ -0,0 +1,40 @@
+declare module '*BootLoadingScreen.js' {
+  export type Studio25BootLoadingViewOptions = {
+    lowEnd?: boolean;
+    tips?: string[];
+    tagline?: string;
+    footer?: string;
+    frogSrc?: string;
+    /** Pin splash to this element (prefer Phaser canvas). */
+    splashAnchor?: Element | null;
+  };
+
+  export type Studio25BootLoadingView = {
+    setDisplayedProgress: (progress01: number) => void;
+    beginClose: () => Promise<void>;
+    getFrogLogoRect: () => DOMRect | null;
+    dispose: () => void;
+  };
+
+  export const DEFAULT_TIPS: string[];
+  export const STUDIO25_FROG_MASK_KEY: string;
+  export const STUDIO25_FROG_SRC: string;
+  export const STUDIO25_FOOTER: string;
+  export const STUDIO25_TAGLINE: string;
+  export const STUDIO25_WORDMARK: { n: string; s: string };
+  export const STUDIO25_BOOT_BRAND: Record<string, unknown>;
+  export const FROG_SVG: string;
+  export function studio25FrogMaskDataUrl(): string;
+  export function tipForPercent(tips: string[], pct: number): string;
+  export function dismissStudioSplash(): void;
+  export function createStudio25BootLoadingView(
+    opts?: Studio25BootLoadingViewOptions,
+  ): Studio25BootLoadingView | null;
+  /** @deprecated Use createStudio25BootLoadingView + playBootLoadingView. */
+  export function createBootLoadingScreen(scene: unknown, opts?: unknown): void;
+}
+
+declare module '*SplashFullscreenBg.js' {
+  export function showSplashFullscreenBg(): void;
+  export function hideSplashFullscreenBg(): void;
+}

package/plugins/phaser-casual-game-factory/templates/boot/close-styles.ts

@@ -0,0 +1,26 @@
+/**
+ * Boot → Home close presentation styles (skill `phaser-studio25-boot-brand`).
+ *
+ * - `iris` (default): frog bitmap mask scale 0 → full at logo origin.
+ * - `slide-up`: whole `#studio25-splash` DOM slides up (`translateY(-102%)`),
+ *   matching associatio-match.
+ *
+ * Home↔Game / Next Level overlay holes stay separate — never reuse those
+ * full→0 / 0→full contracts for Boot brand close.
+ */
+export const BOOT_CLOSE_STYLE = {
+  iris: 'iris',
+  slideUp: 'slide-up',
+} as const;
+
+export type BootCloseStyle = (typeof BOOT_CLOSE_STYLE)[keyof typeof BOOT_CLOSE_STYLE];
+
+/** Factory default when the product does not request another Boot close. */
+export const DEFAULT_BOOT_CLOSE_STYLE: BootCloseStyle = BOOT_CLOSE_STYLE.iris;
+
+export function resolveBootCloseStyle(
+  style: BootCloseStyle | undefined | null,
+): BootCloseStyle {
+  if (style === BOOT_CLOSE_STYLE.slideUp) return BOOT_CLOSE_STYLE.slideUp;
+  return DEFAULT_BOOT_CLOSE_STYLE;
+}

package/plugins/phaser-casual-game-factory/templates/boot/index.ts

@@ -0,0 +1,32 @@
+export {
+  playBootLoadingView,
+  type PlayBootLoadingViewOptions,
+  type BootCloseRevealContext,
+} from './play-boot-loading-view';
+export {
+  BOOT_CLOSE_STYLE,
+  DEFAULT_BOOT_CLOSE_STYLE,
+  resolveBootCloseStyle,
+  type BootCloseStyle,
+} from './close-styles';
+export { createBootIrisClose, type BootIrisCloseOptions } from './iris-close';
+export {
+  mapDomRectToPhaserGame,
+  resolveBootSplashAnchor,
+  type DomRectGameLayout,
+} from './map-dom-rect-to-game';
+export {
+  createStudio25BootLoadingView,
+  dismissStudioSplash,
+  tipForPercent,
+  DEFAULT_TIPS,
+  STUDIO25_FROG_MASK_KEY,
+  STUDIO25_FROG_SRC,
+  STUDIO25_FOOTER,
+  STUDIO25_TAGLINE,
+  STUDIO25_WORDMARK,
+  STUDIO25_BOOT_BRAND,
+  FROG_SVG,
+  studio25FrogMaskDataUrl,
+} from './brand/BootLoadingScreen.js';
+export { showSplashFullscreenBg, hideSplashFullscreenBg } from './brand/SplashFullscreenBg.js';

package/plugins/phaser-casual-game-factory/templates/boot/iris-close.ts

@@ -0,0 +1,85 @@
+import type { Game } from 'phaser';
+import type { FactoryLoadingOverlayScene } from '../phaser/loading-overlay-scene';
+import { mapDomRectToPhaserGame } from './map-dom-rect-to-game';
+import type { BootCloseRevealContext } from './play-boot-loading-view';
+
+export type BootIrisCloseOptions = {
+  game: Game;
+  maskKey: string;
+  coverColor?: number;
+  /**
+   * Ensure overlay scene is running and returned.
+   * Callers usually warm it during the home `afterOpen` task.
+   */
+  ensureOverlay: () => Promise<FactoryLoadingOverlayScene>;
+  /**
+   * Camera prep only — do not change DOM stage size here or the frog→iris
+   * map drifts. Flip hybrid Home chrome in `afterCoverReady`.
+   */
+  prepareCameras?: () => void;
+  /**
+   * Runs after night cover + scale-0 mask are up and DOM splash is dismissed.
+   * Hybrid demos prepare phone Home under the veil here.
+   */
+  afterCoverReady?: () => void;
+};
+
+/**
+ * Standard `iris` Boot close runner — pass as `runIrisClose` when
+ * `closeStyle` is `'iris'` (default).
+ *
+ * Frog mask starts at **scale 0** on the splash logo point, then grows to full.
+ */
+export function createBootIrisClose(
+  options: BootIrisCloseOptions,
+): (ctx: BootCloseRevealContext) => Promise<void> {
+  const coverColor = options.coverColor ?? 0x0b1220;
+
+  return async ({ durationMs, frogRect, dismissDomSplash }) => {
+    const { game } = options;
+    const overlay = await options.ensureOverlay();
+
+    // Measure while splash is still in its Boot layout (same box as canvas).
+    window.dispatchEvent(new Event('resize'));
+    await new Promise<void>((resolve) => {
+      requestAnimationFrame(() => requestAnimationFrame(() => resolve()));
+    });
+
+    const liveFrog =
+      typeof document !== 'undefined'
+        ? (() => {
+            const frog = document.querySelector<HTMLElement>('#studio25-splash .frog');
+            if (!frog) return null;
+            const idle = document.querySelector<HTMLElement>('#studio25-splash .frogidle');
+            const wrap = document.querySelector<HTMLElement>('#studio25-splash .frogwrap');
+            const prevIdle = idle?.style.animation ?? '';
+            const prevWrap = wrap?.style.animation ?? '';
+            if (idle) idle.style.animation = 'none';
+            if (wrap) wrap.style.animation = 'none';
+            void frog.offsetWidth;
+            const rect = frog.getBoundingClientRect();
+            if (idle) idle.style.animation = prevIdle;
+            if (wrap) wrap.style.animation = prevWrap;
+            return rect;
+          })()
+        : null;
+
+    const layout = mapDomRectToPhaserGame(game, liveFrog ?? frogRect);
+    options.prepareCameras?.();
+    game.scene.bringToTop(overlay.sys.settings.key);
+
+    await overlay.playIconMaskReveal({
+      maskKey: options.maskKey,
+      durationMs,
+      coverColor,
+      originX: layout.x,
+      originY: layout.y,
+      startDisplayWidth: layout.displayWidth,
+      onCoverReady: () => {
+        dismissDomSplash();
+        options.afterCoverReady?.();
+        game.scale.refresh();
+      },
+    });
+  };
+}

package/plugins/phaser-casual-game-factory/templates/boot/map-dom-rect-to-game.ts

@@ -0,0 +1,53 @@
+import type Phaser from 'phaser';
+
+export type DomRectGameLayout = {
+  x: number;
+  y: number;
+  displayWidth: number;
+  displayHeight: number;
+};
+
+/**
+ * Map a DOM rect into Phaser game coordinates (optional helpers / custom overlays).
+ * Always use the Phaser canvas client box as the reference — the Boot splash
+ * must be synced to that same box (`syncSplashToGameView`) or the iris misses.
+ */
+export function mapDomRectToPhaserGame(
+  game: Phaser.Game,
+  rect: DOMRect | null | undefined,
+): DomRectGameLayout {
+  const canvas = game.canvas;
+  const cr = canvas.getBoundingClientRect();
+  const gw = Math.max(1, game.scale.width);
+  const gh = Math.max(1, game.scale.height);
+
+  if (!rect || cr.width <= 0 || cr.height <= 0) {
+    return {
+      x: gw / 2,
+      y: gh * 0.32,
+      displayWidth: Math.min(180, gw * 0.42),
+      displayHeight: Math.min(163, gh * 0.28),
+    };
+  }
+
+  const scaleX = gw / cr.width;
+  const scaleY = gh / cr.height;
+  return {
+    x: (rect.left + rect.width / 2 - cr.left) * scaleX,
+    y: (rect.top + rect.height / 2 - cr.top) * scaleY,
+    displayWidth: Math.max(24, rect.width * scaleX),
+    displayHeight: Math.max(24, rect.height * scaleY),
+  };
+}
+
+/** Prefer the Phaser canvas so Boot brand overlay and iris share one coordinate space. */
+export function resolveBootSplashAnchor(explicit?: Element | null): Element | null {
+  if (explicit) return explicit;
+  if (typeof document === 'undefined') return null;
+  return (
+    document.querySelector('#game canvas') ||
+    document.querySelector('canvas') ||
+    document.querySelector('.stage-screen') ||
+    document.getElementById('game')
+  );
+}

package/plugins/phaser-casual-game-factory/templates/boot/play-boot-loading-view.ts

@@ -0,0 +1,124 @@
+import type { LoadingViewModel } from '../loading-view';
+import { createStudio25BootLoadingView } from './brand/BootLoadingScreen.js';
+import { hideSplashFullscreenBg, showSplashFullscreenBg } from './brand/SplashFullscreenBg.js';
+import {
+  BOOT_CLOSE_STYLE,
+  resolveBootCloseStyle,
+  type BootCloseStyle,
+} from './close-styles';
+import { resolveBootSplashAnchor } from './map-dom-rect-to-game';
+
+export type BootCloseRevealContext = {
+  durationMs: number;
+  frogRect: DOMRect | null;
+  /**
+   * For `iris`: call after Phaser night cover is up so Home shows under the mask.
+   * For `slide-up`: usually unused (splash dismisses after the slide).
+   */
+  dismissDomSplash: () => void;
+};
+
+export type PlayBootLoadingViewOptions = {
+  lowEnd?: boolean;
+  tips?: string[];
+  tagline?: string;
+  footer?: string;
+  /** Frog art (default from `phaser-studio25-boot-brand` / brand-defaults). */
+  frogSrc?: string;
+  /**
+   * Element the splash is positioned over. Defaults to Phaser `#game canvas`.
+   */
+  splashAnchor?: Element | null;
+  /**
+   * Boot → Home close style. Default **`iris`** (factory classic).
+   * Set `slide-up` for associatio-match DOM slide.
+   */
+  closeStyle?: BootCloseStyle;
+  /**
+   * Runner for `closeStyle: 'iris'` (default). Use `createBootIrisClose(...)`.
+   * Ignored when `closeStyle` is `slide-up`.
+   */
+  runIrisClose?: (ctx: BootCloseRevealContext) => Promise<void>;
+  /**
+   * @deprecated Prefer `runIrisClose` + `closeStyle: 'iris'`.
+   * Still accepted as an alias for the iris runner.
+   */
+  closeReveal?: (ctx: BootCloseRevealContext) => Promise<void>;
+};
+
+type BootView = {
+  setDisplayedProgress: (progress01: number) => void;
+  beginClose: () => Promise<void>;
+  getFrogLogoRect?: () => DOMRect | null;
+  dispose: () => void;
+};
+
+/**
+ * Sole Boot LoadingView: company brand DOM (skill `phaser-studio25-boot-brand`).
+ * Close style defaults to **`iris`**; pass `closeStyle: 'slide-up'` to switch.
+ * One ViewModel drives open / showing / close. Do not run a parallel HTML gate.
+ */
+export async function playBootLoadingView(
+  viewModel: LoadingViewModel,
+  options: PlayBootLoadingViewOptions = {},
+): Promise<void> {
+  showSplashFullscreenBg();
+  // Demo HTML gate must never compete with Studio25 during Boot.
+  const gate = document.getElementById('loading-overlay');
+  gate?.classList.add('is-hidden');
+  gate?.setAttribute('hidden', '');
+
+  const closeStyle = resolveBootCloseStyle(options.closeStyle);
+  const irisRunner = options.runIrisClose ?? options.closeReveal;
+
+  if (closeStyle === BOOT_CLOSE_STYLE.iris && !irisRunner) {
+    throw new Error(
+      'Boot closeStyle "iris" (default) requires runIrisClose — use createBootIrisClose(...), or set closeStyle: "slide-up".',
+    );
+  }
+
+  const splashAnchor = resolveBootSplashAnchor(options.splashAnchor);
+  const view = createStudio25BootLoadingView({
+    ...options,
+    splashAnchor,
+  }) as BootView | null;
+  let closeStarted = false;
+  let closePromise: Promise<void> = Promise.resolve();
+  let splashDismissed = false;
+
+  const dismissDomSplash = () => {
+    if (splashDismissed) return;
+    splashDismissed = true;
+    gate?.classList.add('is-hidden');
+    gate?.setAttribute('hidden', '');
+    view?.dispose();
+    hideSplashFullscreenBg();
+  };
+
+  const subscription = viewModel.state$.subscribe((state) => {
+    if (state.phase === 'showing' || state.phase === 'closing') {
+      view?.setDisplayedProgress(state.displayedProgress);
+    }
+    if (state.phase === 'closing' && !closeStarted) {
+      closeStarted = true;
+      if (closeStyle === BOOT_CLOSE_STYLE.slideUp) {
+        closePromise = view?.beginClose() ?? Promise.resolve();
+      } else {
+        closePromise = irisRunner!({
+          durationMs: viewModel.closeDurationMs,
+          frogRect: view?.getFrogLogoRect?.() ?? null,
+          dismissDomSplash,
+        });
+      }
+    }
+  });
+
+  try {
+    await viewModel.start();
+    await closePromise;
+  } finally {
+    subscription.unsubscribe();
+    dismissDomSplash();
+    viewModel.dispose();
+  }
+}

package/plugins/phaser-casual-game-factory/templates/commerce/commerce-service.ts

@@ -0,0 +1,22 @@
+import type { ManagedTimeService } from '../core/time';
+import type { Result } from '../core/types';
+import type { EconomyConfig, TransactionReceipt } from '../economy/types';
+import type { EconomyRepository } from '../economy/repository';
+import { applyInput, applyRewards, resourceRewardsFromChanges } from '../economy/state-utils';
+import type { CommerceConfig, OfferPurchase, VerifiedPayment } from './types';
+export class DefaultCommerceService {
+  constructor(private readonly repository: EconomyRepository, private readonly economy: EconomyConfig, private readonly time: ManagedTimeService, private readonly config: CommerceConfig) {}
+  async purchase(offerId: string, transactionId: string, payment?: VerifiedPayment): Promise<Result<OfferPurchase>> { try {
+    const offer = this.config.offers[offerId]; if (!offer) throw new Error(`Unknown offer: ${offerId}`);
+    const result = await this.repository.runAtomic(transactionId, async (state) => {
+      const now = this.time.now(); if (offer.startsAt && now < offer.startsAt || offer.endsAt && now > offer.endsAt) throw new Error('Offer is unavailable');
+      if (offer.requiredPackageId && !state.activePackages[offer.requiredPackageId]) throw new Error('Required package is not active');
+      const periodKey = offer.reset === 'daily' ? this.time.todayKey() : offer.reset === 'monthly' ? this.time.snapshot().monthKey : offer.reset === 'weekly' ? this.time.snapshot().weekKey : undefined;
+      const history = state.offerPurchases[offerId]; const count = history?.periodKey === periodKey ? history.count : periodKey ? 0 : history?.count ?? 0;
+      if (offer.maxPurchases !== undefined && count >= offer.maxPurchases) throw new Error('Offer purchase limit reached');
+      if ((offer.payment.type === 'ad' || offer.payment.type === 'iap') && (!payment?.verified || payment.type !== offer.payment.type || !payment.providerTransactionId)) throw new Error(`Verified ${offer.payment.type} authorization is required`);
+      const changes: TransactionReceipt['changes'] = []; if (offer.payment.type === 'resource') applyInput(state, this.economy, offer.payment.cost, 'spendable', changes); applyRewards(state, this.economy, offer.rewards, changes);
+      state.offerPurchases[offerId] = { count: count + 1, periodKey }; const rewards = resourceRewardsFromChanges(changes); const receipt: TransactionReceipt = { transactionId, operationType: 'commerce-purchase', applied: true, changes, rewards, metadata: { offerId, payment: offer.payment.type } }; return { state, receipt, value: { rewards } };
+    }); return { ok: true, value: { offerId, rewards: result.receipt.rewards ?? [], receipt: result.receipt } };
+  } catch (error) { return { ok: false, error: error instanceof Error ? error : new Error(String(error)) }; } }
+}

package/plugins/phaser-casual-game-factory/templates/commerce/index.ts

@@ -0,0 +1 @@
+export * from './types'; export * from './commerce-service';

package/plugins/phaser-casual-game-factory/templates/commerce/types.ts

@@ -0,0 +1,6 @@
+import type { ResourceStack, RewardSummary, TransactionReceipt } from '../economy/types';
+export type OfferPayment = { type: 'free' } | { type: 'resource'; cost: ResourceStack[] } | { type: 'ad' } | { type: 'iap'; productId: string };
+export interface OfferConfig { id: string; payment: OfferPayment; rewards: ResourceStack[]; maxPurchases?: number; reset?: 'daily' | 'weekly' | 'monthly'; startsAt?: number; endsAt?: number; requiredPackageId?: string; }
+export interface CommerceConfig { offers: Record<string, OfferConfig>; }
+export interface VerifiedPayment { type: 'ad' | 'iap'; providerTransactionId: string; verified: true; }
+export interface OfferPurchase { offerId: string; rewards: RewardSummary[]; receipt: TransactionReceipt; }

package/plugins/phaser-casual-game-factory/templates/condition/condition-service.ts

@@ -0,0 +1,166 @@
+import type { Result } from '../core/types';
+import type { EconomyRepository } from '../economy/repository';
+import type { EconomyState } from '../economy/types';
+import type {
+  ComparisonOperator,
+  ConditionConfig,
+  ConditionDefinition,
+  ConditionEvaluation,
+  ConditionMetricProvider,
+  ConditionNode,
+  ConditionProgress,
+  ConditionService,
+  ConditionViewModel,
+  MetricCondition,
+} from './types';
+
+export class DefaultConditionService implements ConditionService {
+  private config: ConditionConfig;
+  private readonly providers = new Map<string, ConditionMetricProvider>();
+
+  constructor(
+    private readonly repository: EconomyRepository,
+    config: ConditionConfig = { definitions: {} },
+    providers: ConditionMetricProvider[] = [],
+  ) {
+    this.config = cloneAndValidateConfig(config);
+    for (const provider of [...defaultProviders(), ...providers]) this.providers.set(provider.metric, provider);
+  }
+
+  replaceConfig(config: ConditionConfig): void {
+    this.config = cloneAndValidateConfig(config);
+  }
+
+  getDefinition(id: string): ConditionDefinition | undefined {
+    const definition = this.config.definitions[id];
+    return definition ? structuredClone(definition) : undefined;
+  }
+
+  async evaluate(id: string): Promise<Result<ConditionEvaluation>> {
+    const definition = this.config.definitions[id];
+    if (!definition) return { ok: false, error: new Error(`Unknown condition: ${id}`) };
+    return this.evaluateNode(definition.root);
+  }
+
+  async evaluateNode(node: ConditionNode): Promise<Result<ConditionEvaluation>> {
+    try {
+      return { ok: true, value: this.evaluateState(node, await this.repository.getSnapshot()) };
+    } catch (error) {
+      return { ok: false, error: asError(error) };
+    }
+  }
+
+  async getViewModel(id: string): Promise<Result<ConditionViewModel>> {
+    const definition = this.config.definitions[id];
+    if (!definition) return { ok: false, error: new Error(`Unknown condition: ${id}`) };
+    const result = await this.evaluateNode(definition.root);
+    return result.ok
+      ? { ok: true, value: { id, title: definition.title, ...result.value } }
+      : result;
+  }
+
+  evaluateState(node: ConditionNode, state: EconomyState): ConditionEvaluation {
+    if (node.type === 'metric') return this.evaluateMetric(node, state);
+    if (node.type === 'not') {
+      const child = this.evaluateState(node.condition, state);
+      return { met: !child.met, description: node.description ?? `Not: ${child.description}`, progress: { format: 'none' }, children: [child] };
+    }
+    const children = node.conditions.map((child) => this.evaluateState(child, state));
+    const met = node.type === 'all' ? children.every((child) => child.met) : children.some((child) => child.met);
+    const focus = (node.type === 'all' ? children.find((child) => !child.met) : children.find((child) => child.met)) ?? children[0];
+    return {
+      met,
+      description: node.description ?? (node.type === 'all' ? 'Complete all requirements' : 'Complete any requirement'),
+      progress: focus?.progress ?? { format: 'none' },
+      children,
+    };
+  }
+
+  private evaluateMetric(condition: MetricCondition, state: EconomyState): ConditionEvaluation {
+    const provider = this.providers.get(condition.metric);
+    if (!provider) throw new Error(`No ConditionMetricProvider registered for metric: ${condition.metric}`);
+    const current = provider.getValue(condition, state);
+    if (!Number.isFinite(current)) throw new Error(`Condition metric returned invalid value: ${condition.metric}`);
+    const met = compare(current, condition.operator, condition.target);
+    const format = condition.progressFormat ?? 'both';
+    return {
+      met,
+      description: interpolate(condition.description ?? defaultDescription(condition), current, condition.target),
+      progress: buildProgress(current, condition.target, condition.operator, format),
+    };
+  }
+}
+
+function defaultProviders(): ConditionMetricProvider[] {
+  return [
+    createLevelMetricProvider(),
+    { metric: 'login-days', getValue: (_condition, state) => Object.keys(state.dailyLogin.days).length },
+    { metric: 'login-streak', getValue: (_condition, state) => state.dailyLogin.currentStreak },
+    { metric: 'resource', getValue: (condition, state) => state.balances[String(condition.params?.resourceId ?? '')] ?? 0 },
+  ];
+}
+
+/** Override the default level metric when a Leveling track has a non-zero start level before it is persisted. */
+export function createLevelMetricProvider(defaultLevels: Record<string, number> = {}): ConditionMetricProvider {
+  return {
+    metric: 'level',
+    getValue: (condition, state) => {
+      const trackId = String(condition.params?.trackId ?? 'character');
+      return state.levels[trackId]?.level ?? defaultLevels[trackId] ?? 0;
+    },
+  };
+}
+
+function compare(current: number, operator: ComparisonOperator, target: number): boolean {
+  switch (operator) {
+    case '>=': return current >= target;
+    case '>': return current > target;
+    case '=': return current === target;
+    case '!=': return current !== target;
+    case '<': return current < target;
+    case '<=': return current <= target;
+  }
+}
+
+function buildProgress(current: number, target: number, operator: ComparisonOperator, format: ConditionProgress['format']): ConditionProgress {
+  if (format === 'none') return { format };
+  const percent = operator === '>=' || operator === '>' || operator === '='
+    ? target <= 0 ? 100 : clamp((current / target) * 100)
+    : current <= target ? 100 : clamp((target / Math.max(current, 1)) * 100);
+  const label = format === 'percent' ? `${Math.round(percent)}%` : format === 'fraction' ? `${current}/${target}` : `${current}/${target} (${Math.round(percent)}%)`;
+  return { current, target, percent, label, format };
+}
+
+function defaultDescription(condition: MetricCondition): string {
+  const label = condition.label ?? condition.metric;
+  return `${label} ${condition.operator} {target}`;
+}
+
+function interpolate(template: string, current: number, target: number): string {
+  return template.replaceAll('{current}', String(current)).replaceAll('{target}', String(target));
+}
+
+function cloneAndValidateConfig(config: ConditionConfig): ConditionConfig {
+  if (!config || typeof config !== 'object' || !config.definitions || typeof config.definitions !== 'object') {
+    throw new Error('Condition config must contain definitions.');
+  }
+  for (const [id, definition] of Object.entries(config.definitions)) {
+    if (!definition || definition.id !== id) throw new Error(`Condition definition id must match key: ${id}`);
+    validateNode(definition.root);
+  }
+  return structuredClone(config);
+}
+
+function validateNode(node: ConditionNode): void {
+  if (node.type === 'metric') {
+    if (!Number.isFinite(node.target)) throw new Error(`Condition target must be finite: ${node.metric}`);
+    if (!['>=', '>', '=', '!=', '<', '<='].includes(node.operator)) throw new Error(`Unknown comparison operator: ${node.operator}`);
+    return;
+  }
+  if (node.type === 'not') return validateNode(node.condition);
+  if (!node.conditions.length) throw new Error(`Condition group ${node.type} must contain at least one condition.`);
+  node.conditions.forEach(validateNode);
+}
+
+function clamp(value: number): number { return Math.max(0, Math.min(100, value)); }
+function asError(error: unknown): Error { return error instanceof Error ? error : new Error(String(error)); }

package/plugins/phaser-casual-game-factory/templates/condition/index.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './condition-service';