@auraindustry/aurajs 0.0.6 → 0.1.0

package/templates/create/deckbuilder-2d/scenes/gameplay.scene.js

@@ -0,0 +1,641 @@
+import {
+  createStarterDeck,
+  resolveCardTone,
+  STARTER_CARD_LIBRARY,
+  resolveCardTotals,
+} from '../content/cards/starter.deck.js';
+import { createTrainingBattle } from '../content/encounters/training-battle.js';
+import { DECKBUILDER_CONFIG, DECKBUILDER_TEXT } from '../config/gameplay/deckbuilder.config.js';
+
+const INPUT_KEYS = ['1', '2', '3', '4', '5'];
+const RUN_STATE_SCHEMA = 'aurajs.deckbuilder-run-state.v1';
+
+function cloneState(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function summarizeCard(card) {
+  return card?.text || card?.summary || 'Custom card effect.';
+}
+
+function materializeCard(cardId, instanceId = null) {
+  const source = STARTER_CARD_LIBRARY[cardId] || STARTER_CARD_LIBRARY.strike;
+  const totals = resolveCardTotals(source);
+  return {
+    ...source,
+    ...totals,
+    name: source.title || source.name || source.id,
+    summary: summarizeCard(source),
+    instanceId: instanceId || `${source.id}-restore`,
+  };
+}
+
+function exportCardRefs(cards) {
+  return Array.isArray(cards)
+    ? cards.map((card, index) => ({
+      cardId: typeof card?.id === 'string' && card.id.trim().length > 0 ? card.id : 'strike',
+      instanceId: typeof card?.instanceId === 'string' && card.instanceId.trim().length > 0
+        ? card.instanceId
+        : `card-${index + 1}`,
+    }))
+    : [];
+}
+
+function createCardPool() {
+  const byInstanceId = new Map();
+  const byCardId = new Map();
+  for (const card of createStarterDeck()) {
+    byInstanceId.set(card.instanceId, card);
+    if (!byCardId.has(card.id)) {
+      byCardId.set(card.id, []);
+    }
+    byCardId.get(card.id).push(card);
+  }
+  return {
+    byInstanceId,
+    byCardId,
+    usedInstanceIds: new Set(),
+  };
+}
+
+function takeCardFromPool(pool, ref, fallbackTag) {
+  const instanceId = typeof ref?.instanceId === 'string' && ref.instanceId.trim().length > 0
+    ? ref.instanceId.trim()
+    : null;
+  const cardId = typeof ref?.cardId === 'string' && ref.cardId.trim().length > 0
+    ? ref.cardId.trim()
+    : (instanceId && instanceId.includes('-') ? instanceId.split('-')[0] : 'strike');
+
+  if (instanceId && !pool.usedInstanceIds.has(instanceId) && pool.byInstanceId.has(instanceId)) {
+    pool.usedInstanceIds.add(instanceId);
+    return cloneState(pool.byInstanceId.get(instanceId));
+  }
+
+  const candidates = pool.byCardId.get(cardId) || [];
+  while (candidates.length > 0) {
+    const candidate = candidates.shift();
+    if (!pool.usedInstanceIds.has(candidate.instanceId)) {
+      pool.usedInstanceIds.add(candidate.instanceId);
+      return cloneState(candidate);
+    }
+  }
+
+  return materializeCard(cardId, instanceId || `${cardId}-${fallbackTag}`);
+}
+
+function restorePile(pool, cards, slot) {
+  if (!Array.isArray(cards)) return [];
+  return cards.map((ref, index) => takeCardFromPool(pool, ref, `${slot}-${index + 1}`));
+}
+
+function exportRunState(state) {
+  return {
+    schema: RUN_STATE_SCHEMA,
+    turn: state.turn,
+    energy: state.energy,
+    playerHp: state.playerHp,
+    playerBlock: state.playerBlock,
+    drawPile: exportCardRefs(state.drawPile),
+    hand: exportCardRefs(state.hand),
+    discardPile: exportCardRefs(state.discardPile),
+    outcome: state.outcome,
+    logLines: Array.isArray(state.logLines) ? [...state.logLines] : [],
+    encounter: {
+      id: state.encounter?.id || 'training-battle',
+      enemyId: state.encounter?.enemyId || 'training-automaton',
+      enemyHp: Number(state.encounter?.enemyHp || 0),
+      enemyBlock: Number(state.encounter?.enemyBlock || 0),
+    },
+  };
+}
+
+function restoreRunState(snapshot) {
+  if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) {
+    return {
+      ok: false,
+      reasonCode: 'scene_state_invalid',
+    };
+  }
+  if (snapshot.schema && snapshot.schema !== RUN_STATE_SCHEMA) {
+    return {
+      ok: false,
+      reasonCode: 'scene_state_invalid',
+    };
+  }
+
+  const state = createRunState();
+  if (snapshot.encounter?.id && snapshot.encounter.id !== state.encounter.id) {
+    return {
+      ok: false,
+      reasonCode: 'scene_state_invalid',
+    };
+  }
+  if (snapshot.encounter?.enemyId && snapshot.encounter.enemyId !== state.encounter.enemyId) {
+    return {
+      ok: false,
+      reasonCode: 'scene_state_invalid',
+    };
+  }
+
+  const pool = createCardPool();
+  state.turn = Number.isFinite(Number(snapshot.turn)) && Number(snapshot.turn) > 0
+    ? Number(snapshot.turn)
+    : state.turn;
+  state.energy = Number.isFinite(Number(snapshot.energy))
+    ? Math.max(0, Number(snapshot.energy))
+    : state.energy;
+  state.playerHp = Number.isFinite(Number(snapshot.playerHp))
+    ? Math.max(0, Number(snapshot.playerHp))
+    : state.playerHp;
+  state.playerBlock = Number.isFinite(Number(snapshot.playerBlock))
+    ? Math.max(0, Number(snapshot.playerBlock))
+    : state.playerBlock;
+  state.drawPile = restorePile(pool, snapshot.drawPile, 'draw');
+  state.hand = restorePile(pool, snapshot.hand, 'hand');
+  state.discardPile = restorePile(pool, snapshot.discardPile, 'discard');
+  state.outcome = typeof snapshot.outcome === 'string' && snapshot.outcome.trim().length > 0
+    ? snapshot.outcome
+    : null;
+  state.logLines = Array.isArray(snapshot.logLines) && snapshot.logLines.length > 0
+    ? snapshot.logLines.filter((entry) => typeof entry === 'string' && entry.trim().length > 0).slice(0, 4)
+    : state.logLines;
+  state.encounter.enemyHp = Number.isFinite(Number(snapshot.encounter?.enemyHp))
+    ? Math.max(0, Math.min(state.encounter.enemyMaxHp, Number(snapshot.encounter.enemyHp)))
+    : state.encounter.enemyHp;
+  state.encounter.enemyBlock = Number.isFinite(Number(snapshot.encounter?.enemyBlock))
+    ? Math.max(0, Number(snapshot.encounter.enemyBlock))
+    : state.encounter.enemyBlock;
+
+  return {
+    ok: true,
+    state,
+  };
+}
+
+function shuffleCards(cards) {
+  const output = [...cards];
+  for (let index = output.length - 1; index > 0; index -= 1) {
+    const swapIndex = Math.floor(Math.random() * (index + 1));
+    [output[index], output[swapIndex]] = [output[swapIndex], output[index]];
+  }
+  return output;
+}
+
+function createRunState() {
+  const encounter = createTrainingBattle();
+  const state = {
+    turn: 1,
+    energy: DECKBUILDER_CONFIG.energyPerTurn,
+    playerHp: DECKBUILDER_CONFIG.playerMaxHp,
+    playerBlock: 0,
+    drawPile: shuffleCards(createStarterDeck()),
+    hand: [],
+    discardPile: [],
+    outcome: null,
+    encounter,
+    logLines: [
+      encounter.intro,
+      encounter.rewardNote,
+    ],
+  };
+  drawCards(state, DECKBUILDER_CONFIG.handSize);
+  return state;
+}
+
+function recycleDiscard(state) {
+  if (state.drawPile.length > 0 || state.discardPile.length <= 0) return;
+  state.drawPile = shuffleCards(state.discardPile);
+  state.discardPile = [];
+}
+
+function drawCards(state, count) {
+  for (let index = 0; index < count; index += 1) {
+    recycleDiscard(state);
+    if (state.drawPile.length <= 0) return;
+    state.hand.push(state.drawPile.shift());
+  }
+}
+
+function pushLog(state, line) {
+  if (!line) return;
+  state.logLines = [line, ...state.logLines].slice(0, 4);
+}
+
+function currentEnemyIntent(state) {
+  const cycle = state.encounter.moves;
+  return cycle[(state.turn - 1) % cycle.length];
+}
+
+function createDeckbuilderUiStateSeed() {
+  return {
+    showBattleHint: true,
+  };
+}
+
+function ensureDeckbuilderUiState(context, appState) {
+  if (typeof context.ensureUiState === 'function') {
+    return context.ensureUiState('deckbuilderHud', createDeckbuilderUiStateSeed());
+  }
+  if (!appState.ui || typeof appState.ui !== 'object' || Array.isArray(appState.ui)) {
+    appState.ui = {};
+  }
+  if (!appState.ui.deckbuilderHud || typeof appState.ui.deckbuilderHud !== 'object' || Array.isArray(appState.ui.deckbuilderHud)) {
+    appState.ui.deckbuilderHud = createDeckbuilderUiStateSeed();
+  }
+  return appState.ui.deckbuilderHud;
+}
+
+function syncHud(context, state) {
+  const intent = currentEnemyIntent(state);
+  const appState = context.appState || {};
+  const deckbuilderUiState = ensureDeckbuilderUiState(context, appState);
+  context.screenShell.setHud('hud', {
+    sceneLabel: 'BATTLE',
+    title: '{{PROJECT_TITLE}} Deckbuilder',
+    subtitle: `${state.encounter.enemyName} · intent: ${intent.name}`,
+    turn: state.turn,
+    energy: state.energy,
+    playerHp: state.playerHp,
+    playerBlock: state.playerBlock,
+    enemyHp: state.encounter.enemyHp,
+    enemyBlock: state.encounter.enemyBlock,
+    drawPile: state.drawPile.length,
+    discardPile: state.discardPile.length,
+    handSize: state.hand.length,
+    hint: state.outcome
+      ? 'Press R to restart or ESC for boot.'
+      : (deckbuilderUiState.showBattleHint !== false ? DECKBUILDER_TEXT.battleHint : ''),
+    logLines: state.logLines,
+    outcome: state.outcome,
+  });
+}
+
+function startNextTurn(state) {
+  state.turn += 1;
+  state.energy = DECKBUILDER_CONFIG.energyPerTurn;
+  state.playerBlock = 0;
+  state.encounter.enemyBlock = 0;
+  while (state.hand.length > 0) {
+    state.discardPile.push(state.hand.shift());
+  }
+  drawCards(state, DECKBUILDER_CONFIG.handSize);
+}
+
+function applyDamageToEnemy(state, damage) {
+  const absorbed = Math.min(state.encounter.enemyBlock, damage);
+  const spill = Math.max(0, damage - absorbed);
+  state.encounter.enemyBlock -= absorbed;
+  state.encounter.enemyHp = Math.max(0, state.encounter.enemyHp - spill);
+}
+
+function resolvePlayerCard(state, card) {
+  if (card.damage > 0) {
+    applyDamageToEnemy(state, card.damage);
+  }
+  if (card.block > 0) {
+    state.playerBlock += card.block;
+  }
+  if (card.draw > 0) {
+    drawCards(state, card.draw);
+  }
+}
+
+function playCard(state, cardIndex) {
+  const card = state.hand[cardIndex];
+  if (!card) return;
+  if (card.cost > state.energy) {
+    pushLog(state, `${card.name} needs ${card.cost} energy.`);
+    return;
+  }
+
+  state.energy -= card.cost;
+  state.hand.splice(cardIndex, 1);
+  resolvePlayerCard(state, card);
+  state.discardPile.push(card);
+  pushLog(state, `Played ${card.name}. ${card.summary}`);
+
+  if (state.encounter.enemyHp <= 0) {
+    state.outcome = 'VICTORY';
+    pushLog(state, `${state.encounter.enemyName} was defeated.`);
+  }
+}
+
+function resolveEnemyTurn(state) {
+  const intent = currentEnemyIntent(state);
+  if (intent.block > 0) {
+    state.encounter.enemyBlock += intent.block;
+  }
+
+  let damage = intent.damage;
+  const absorbed = Math.min(state.playerBlock, damage);
+  state.playerBlock -= absorbed;
+  damage -= absorbed;
+  if (damage > 0) {
+    state.playerHp = Math.max(0, state.playerHp - damage);
+  }
+
+  pushLog(state, `${state.encounter.enemyName} used ${intent.name}. ${intent.summary}`);
+  if (state.playerHp <= 0) {
+    state.outcome = 'DEFEAT';
+    pushLog(state, 'The starter run ended. Press R to restart.');
+    return;
+  }
+
+  startNextTurn(state);
+}
+
+function drawPanel(x, y, width, height, outer, inner) {
+  aura.draw2d.rectFill(x, y, width, height, outer);
+  aura.draw2d.rectFill(x + 3, y + 3, width - 6, height - 6, inner);
+}
+
+function drawBar(x, y, width, value, maxValue, fillColor) {
+  const ratio = maxValue <= 0 ? 0 : Math.max(0, Math.min(1, value / maxValue));
+  aura.draw2d.rectFill(x, y, width, 14, aura.rgb(0.12, 0.14, 0.18));
+  aura.draw2d.rectFill(x + 2, y + 2, Math.max(0, Math.floor((width - 4) * ratio)), 10, fillColor);
+}
+
+function drawCard(card, index, x, y, selected) {
+  const tone = resolveCardTone(card);
+  const edge = selected ? aura.rgb(0.96, 0.86, 0.42) : aura.rgb(0.22, 0.24, 0.32);
+  drawPanel(x, y, DECKBUILDER_CONFIG.cardWidth, DECKBUILDER_CONFIG.cardHeight, edge, aura.rgb(0.08, 0.09, 0.14));
+  aura.draw2d.rectFill(x + 6, y + 6, DECKBUILDER_CONFIG.cardWidth - 12, 20, aura.rgb(tone.r, tone.g, tone.b));
+  aura.draw2d.text(`${index + 1}`, x + 12, y + 8, {
+    size: 12,
+    color: aura.Color.WHITE,
+  });
+  aura.draw2d.text(card.name, x + 34, y + 8, {
+    size: 13,
+    color: aura.Color.WHITE,
+  });
+  aura.draw2d.text(`${card.cost}E`, x + DECKBUILDER_CONFIG.cardWidth - 44, y + 8, {
+    size: 12,
+    color: aura.Color.WHITE,
+  });
+  aura.draw2d.text(card.summary, x + 12, y + 38, {
+    size: 12,
+    color: aura.rgb(0.88, 0.9, 0.95),
+  });
+  aura.draw2d.text(`DMG ${card.damage}`, x + 12, y + 72, {
+    size: 11,
+    color: aura.rgb(0.92, 0.44, 0.4),
+  });
+  aura.draw2d.text(`BLK ${card.block}`, x + 72, y + 72, {
+    size: 11,
+    color: aura.rgb(0.48, 0.72, 0.94),
+  });
+  aura.draw2d.text(`DRAW ${card.draw}`, x + 124, y + 72, {
+    size: 11,
+    color: aura.rgb(0.76, 0.78, 0.94),
+  });
+}
+
+function createDeckbuilderSessionSeed() {
+  return {
+    runsStarted: 0,
+    bestTurn: 0,
+    lastOutcome: 'idle',
+    lastSceneId: 'gameplay',
+  };
+}
+
+function ensureDeckbuilderSession(context, appState) {
+  if (typeof context.ensureSessionState === 'function') {
+    return context.ensureSessionState('deckbuilder', createDeckbuilderSessionSeed());
+  }
+  if (!appState.session || typeof appState.session !== 'object' || Array.isArray(appState.session)) {
+    appState.session = {};
+  }
+  if (!appState.session.deckbuilder || typeof appState.session.deckbuilder !== 'object' || Array.isArray(appState.session.deckbuilder)) {
+    appState.session.deckbuilder = createDeckbuilderSessionSeed();
+  }
+  return appState.session.deckbuilder;
+}
+
+export function createGameplayScene(context = {}) {
+  const appState = context.appState || {};
+  const deckbuilderSession = ensureDeckbuilderSession(context, appState);
+  const deckbuilderUiState = ensureDeckbuilderUiState(context, appState);
+  let sceneState = createRunState();
+
+  function syncSessionState() {
+    deckbuilderSession.lastSceneId = 'gameplay';
+    deckbuilderSession.bestTurn = Math.max(Number(deckbuilderSession.bestTurn || 0), sceneState.turn);
+    deckbuilderSession.lastOutcome = sceneState.outcome || 'running';
+    deckbuilderSession.lastTurn = sceneState.turn;
+    deckbuilderSession.lastPlayerHp = sceneState.playerHp;
+    deckbuilderSession.lastEnemyHp = sceneState.encounter.enemyHp;
+  }
+
+  function resetRun() {
+    sceneState = createRunState();
+    deckbuilderSession.runsStarted += 1;
+    syncSessionState();
+    syncHud(context, sceneState);
+  }
+
+  function isPauseOpen() {
+    const shellState = context.getScreenShellState?.();
+    return Array.isArray(shellState?.modals) && shellState.modals.some((entry) => entry.screenId === 'pause');
+  }
+
+  function syncPauseModal() {
+    if (!aura.input.isKeyPressed('escape')) return false;
+
+    const shellState = context.getScreenShellState?.();
+    const topModal = shellState?.modals?.[shellState.modals.length - 1] || null;
+    if (topModal) {
+      context.popModalScreen?.({ action: 'resume' });
+      return true;
+    }
+
+    context.pushModalScreen?.('pause', {
+      turn: sceneState.turn,
+      playerHp: sceneState.playerHp,
+      enemyHp: sceneState.encounter.enemyHp,
+      enemyName: sceneState.encounter.enemyName,
+      outcome: sceneState.outcome,
+    });
+    return true;
+  }
+
+  return {
+    id: 'gameplay',
+    template: 'deckbuilder-2d',
+    getState() {
+      return exportRunState(sceneState);
+    },
+    applyState(nextState) {
+      const restored = restoreRunState(nextState);
+      if (!restored.ok) {
+        return restored;
+      }
+      sceneState = restored.state;
+      syncSessionState();
+      syncHud(context, sceneState);
+      return {
+        ok: true,
+        reasonCode: 'scene_state_apply_ok',
+      };
+    },
+    setup() {
+      syncSessionState();
+      syncHud(context, sceneState);
+    },
+    enter() {
+      resetRun();
+    },
+    exit() {
+      context.screenShell.clearHud();
+    },
+    update() {
+      if (syncPauseModal()) {
+        syncSessionState();
+        syncHud(context, sceneState);
+        return;
+      }
+      if (isPauseOpen()) {
+        syncSessionState();
+        syncHud(context, sceneState);
+        return;
+      }
+
+      if (aura.input.isKeyPressed('r')) {
+        resetRun();
+        return;
+      }
+
+      if (!sceneState.outcome) {
+        for (let index = 0; index < INPUT_KEYS.length; index += 1) {
+          if (aura.input.isKeyPressed(INPUT_KEYS[index])) {
+            deckbuilderUiState.showBattleHint = false;
+            playCard(sceneState, index);
+            syncSessionState();
+            syncHud(context, sceneState);
+            return;
+          }
+        }
+
+        if (aura.input.isKeyPressed('enter') || aura.input.isKeyPressed('space')) {
+          deckbuilderUiState.showBattleHint = false;
+          resolveEnemyTurn(sceneState);
+          syncSessionState();
+          syncHud(context, sceneState);
+          return;
+        }
+      }
+
+      syncSessionState();
+      syncHud(context, sceneState);
+    },
+    draw() {
+      const size = aura.window.getSize();
+      const boardTop = DECKBUILDER_CONFIG.hudHeight + 16;
+      const handY = size.height - DECKBUILDER_CONFIG.cardHeight - 28;
+      const handGap = 14;
+      const handTotalWidth = (DECKBUILDER_CONFIG.cardWidth * DECKBUILDER_CONFIG.handSize)
+        + (handGap * (DECKBUILDER_CONFIG.handSize - 1));
+      const handStartX = Math.max(DECKBUILDER_CONFIG.boardPadding, Math.floor((size.width - handTotalWidth) * 0.5));
+
+      aura.draw2d.rectFill(0, 0, size.width, size.height, aura.rgb(0.05, 0.06, 0.09));
+      aura.draw2d.rectFill(0, boardTop, size.width, size.height - boardTop, aura.rgb(0.09, 0.1, 0.15));
+
+      drawPanel(36, boardTop + 24, size.width - 72, 198, aura.rgb(0.16, 0.17, 0.23), aura.rgb(0.11, 0.12, 0.18));
+      aura.draw2d.text(sceneState.encounter.enemyName, 58, boardTop + 42, {
+        size: 24,
+        color: aura.rgb(0.96, 0.9, 0.82),
+      });
+      aura.draw2d.text(`Intent: ${currentEnemyIntent(sceneState).name}`, 58, boardTop + 74, {
+        size: 15,
+        color: aura.rgb(0.8, 0.86, 0.95),
+      });
+      drawBar(
+        58,
+        boardTop + 106,
+        340,
+        sceneState.encounter.enemyHp,
+        sceneState.encounter.enemyMaxHp,
+        aura.rgb(0.86, 0.28, 0.28),
+      );
+      aura.draw2d.text(`Enemy HP ${sceneState.encounter.enemyHp}/${sceneState.encounter.enemyMaxHp}`, 58, boardTop + 126, {
+        size: 13,
+        color: aura.Color.WHITE,
+      });
+      aura.draw2d.text(`Enemy Block ${sceneState.encounter.enemyBlock}`, 58, boardTop + 148, {
+        size: 13,
+        color: aura.rgb(0.58, 0.8, 0.96),
+      });
+
+      drawPanel(size.width - 360, boardTop + 24, 324, 198, aura.rgb(0.16, 0.17, 0.23), aura.rgb(0.11, 0.12, 0.18));
+      aura.draw2d.text('Pilot', size.width - 338, boardTop + 42, {
+        size: 22,
+        color: aura.rgb(0.92, 0.94, 0.97),
+      });
+      aura.draw2d.text(`Energy ${sceneState.energy}`, size.width - 338, boardTop + 74, {
+        size: 16,
+        color: aura.rgb(0.94, 0.84, 0.36),
+      });
+      drawBar(
+        size.width - 338,
+        boardTop + 106,
+        260,
+        sceneState.playerHp,
+        DECKBUILDER_CONFIG.playerMaxHp,
+        aura.rgb(0.32, 0.72, 0.42),
+      );
+      aura.draw2d.text(`Player HP ${sceneState.playerHp}/${DECKBUILDER_CONFIG.playerMaxHp}`, size.width - 338, boardTop + 126, {
+        size: 13,
+        color: aura.Color.WHITE,
+      });
+      aura.draw2d.text(`Player Block ${sceneState.playerBlock}`, size.width - 338, boardTop + 148, {
+        size: 13,
+        color: aura.rgb(0.58, 0.8, 0.96),
+      });
+      aura.draw2d.text(
+        `Draw ${sceneState.drawPile.length}  Discard ${sceneState.discardPile.length}`,
+        size.width - 338,
+        boardTop + 170,
+        {
+          size: 13,
+          color: aura.rgb(0.84, 0.87, 0.95),
+        },
+      );
+
+      for (let index = 0; index < DECKBUILDER_CONFIG.handSize; index += 1) {
+        const card = sceneState.hand[index];
+        const x = handStartX + (index * (DECKBUILDER_CONFIG.cardWidth + handGap));
+        if (!card) {
+          drawPanel(x, handY, DECKBUILDER_CONFIG.cardWidth, DECKBUILDER_CONFIG.cardHeight, aura.rgb(0.18, 0.2, 0.28), aura.rgb(0.11, 0.12, 0.18));
+          aura.draw2d.text(`${index + 1}`, x + 12, handY + 8, {
+            size: 12,
+            color: aura.rgb(0.55, 0.6, 0.72),
+          });
+          continue;
+        }
+        drawCard(card, index, x, handY, card.cost <= sceneState.energy && !sceneState.outcome);
+      }
+
+      if (sceneState.outcome) {
+        const bannerWidth = 280;
+        const bannerX = Math.floor((size.width - bannerWidth) * 0.5);
+        const bannerY = boardTop + 248;
+        drawPanel(
+          bannerX,
+          bannerY,
+          bannerWidth,
+          78,
+          sceneState.outcome === 'VICTORY' ? aura.rgb(0.44, 0.34, 0.12) : aura.rgb(0.36, 0.12, 0.12),
+          aura.rgb(0.1, 0.11, 0.16),
+        );
+        aura.draw2d.text(sceneState.outcome, bannerX + 86, bannerY + 16, {
+          size: 26,
+          color: sceneState.outcome === 'VICTORY' ? aura.rgb(0.98, 0.9, 0.36) : aura.rgb(0.96, 0.46, 0.42),
+        });
+        aura.draw2d.text('Press R to restart or ESC for boot.', bannerX + 34, bannerY + 48, {
+          size: 13,
+          color: aura.Color.WHITE,
+        });
+      }
+    },
+  };
+}

package/templates/create/deckbuilder-2d/src/components/.gitkeep

@@ -0,0 +1 @@
+

package/templates/create/deckbuilder-2d/src/main.js

@@ -0,0 +1,17 @@
+// {{PROJECT_TITLE}} - AuraJS deckbuilder-2d starter
+
+import { createApp } from './runtime/app.js';
+
+const app = createApp();
+
+aura.setup = function () {
+  app.setup();
+};
+
+aura.update = function (dt) {
+  app.update(dt);
+};
+
+aura.draw = function () {
+  app.draw();
+};

package/templates/create/deckbuilder-2d/src/runtime/capabilities.js

@@ -0,0 +1,22 @@
+function hasMethod(obj, method) {
+  return Boolean(obj) && typeof obj[method] === 'function';
+}
+
+function failWithReason(reasonCode, message) {
+  throw new Error(`[deckbuilder-2d-template] ${message} [reason:${reasonCode}]`);
+}
+
+export function assertRuntimeCapabilities() {
+  const missing = [];
+  if (!hasMethod(aura.window, 'getSize')) missing.push('aura.window.getSize');
+  if (!hasMethod(aura.input, 'isKeyPressed')) missing.push('aura.input.isKeyPressed');
+  if (!hasMethod(aura.draw2d, 'rectFill')) missing.push('aura.draw2d.rectFill');
+  if (!hasMethod(aura.draw2d, 'text')) missing.push('aura.draw2d.text');
+  if (typeof aura.rgb !== 'function') missing.push('aura.rgb');
+  if (typeof aura.rgba !== 'function') missing.push('aura.rgba');
+  if (!aura.Color || !aura.Color.WHITE) missing.push('aura.Color.WHITE');
+
+  if (missing.length > 0) {
+    failWithReason('missing_runtime_api', `runtime missing required APIs: ${missing.join(', ')}`);
+  }
+}

package/templates/create/deckbuilder-2d/src/shared/.gitkeep

@@ -0,0 +1 @@
+

package/templates/create/deckbuilder-2d/src/systems/.gitkeep

@@ -0,0 +1 @@
+

package/templates/create/deckbuilder-2d/tests/smoke/.gitkeep

@@ -0,0 +1 @@
+