@auraindustry/aurajs 0.0.7 → 0.1.0

package/templates/create/shared/src/runtime/ui-theme.js

@@ -0,0 +1,352 @@
+export const UI_THEME_SCHEMA = 'aurajs.ui-theme.v1';
+export const UI_PREFERENCES_SCHEMA = 'aurajs.ui-preferences.v1';
+
+const UI_THEME_PRESETS = Object.freeze({
+  'signal-dawn': Object.freeze({
+    id: 'signal-dawn',
+    label: 'Signal Dawn',
+    description: 'Warm amber callouts over slate control panels.',
+    theme: Object.freeze({
+      gap: 10,
+      padding: 12,
+      fontSize: 16,
+      lineHeight: 20,
+      buttonHeight: 38,
+      borderWidth: 1,
+      textColor: '#eef5ff',
+      mutedTextColor: '#9db2cb',
+      panelColor: '#0d1622',
+      panelBorderColor: '#314e68',
+      buttonColor: '#132132',
+      buttonHoverColor: '#203853',
+      buttonFocusColor: '#1e5b97',
+      buttonActiveColor: '#2183d6',
+      buttonTextColor: '#ffffff',
+    }),
+  }),
+  'midnight-arcade': Object.freeze({
+    id: 'midnight-arcade',
+    label: 'Midnight Arcade',
+    description: 'Neon cyan and magenta over a darker cabinet shell.',
+    theme: Object.freeze({
+      gap: 10,
+      padding: 12,
+      fontSize: 16,
+      lineHeight: 20,
+      buttonHeight: 38,
+      borderWidth: 1,
+      textColor: '#f5f8ff',
+      mutedTextColor: '#a9b4de',
+      panelColor: '#090d18',
+      panelBorderColor: '#4d3f82',
+      buttonColor: '#101728',
+      buttonHoverColor: '#21304f',
+      buttonFocusColor: '#7a49ff',
+      buttonActiveColor: '#f062d0',
+      buttonTextColor: '#ffffff',
+    }),
+  }),
+  'pine-night': Object.freeze({
+    id: 'pine-night',
+    label: 'Pine Night',
+    description: 'Forest greens and bright mint accents for readable HUDs.',
+    theme: Object.freeze({
+      gap: 10,
+      padding: 12,
+      fontSize: 16,
+      lineHeight: 20,
+      buttonHeight: 38,
+      borderWidth: 1,
+      textColor: '#eef7f2',
+      mutedTextColor: '#adc8bb',
+      panelColor: '#0b1713',
+      panelBorderColor: '#35584b',
+      buttonColor: '#13241e',
+      buttonHoverColor: '#1e3a31',
+      buttonFocusColor: '#2d7b63',
+      buttonActiveColor: '#4fb98c',
+      buttonTextColor: '#ffffff',
+    }),
+  }),
+});
+
+const UI_DENSITY_CHOICES = Object.freeze([
+  Object.freeze({ id: 'compact', label: 'Compact', description: 'Tighter gaps and shorter controls.' }),
+  Object.freeze({ id: 'cozy', label: 'Cozy', description: 'A roomier default for game settings screens.' }),
+]);
+
+const UI_CONTRAST_CHOICES = Object.freeze([
+  Object.freeze({ id: 'standard', label: 'Standard', description: 'Default contrast and chrome.' }),
+  Object.freeze({ id: 'high', label: 'High', description: 'Brighter text and stronger borders.' }),
+]);
+
+const UI_TEXT_SCALE_CHOICES = Object.freeze([
+  Object.freeze({ id: 'normal', label: 'Normal', description: 'Default retained UI text scale.' }),
+  Object.freeze({ id: 'large', label: 'Large', description: 'Increase retained UI text and control readability.' }),
+]);
+
+const UI_FOCUS_VISIBILITY_CHOICES = Object.freeze([
+  Object.freeze({ id: 'standard', label: 'Standard', description: 'Default focus emphasis.' }),
+  Object.freeze({ id: 'high', label: 'High', description: 'Stronger focus contrast and borders.' }),
+]);
+
+const DEFAULT_UI_PREFERENCES = Object.freeze({
+  schema: UI_PREFERENCES_SCHEMA,
+  themeId: 'signal-dawn',
+  density: 'cozy',
+  contrast: 'standard',
+  textScale: 'normal',
+  focusVisibility: 'standard',
+  musicEnabled: true,
+  subtitlesEnabled: false,
+  masterVolume: 8,
+  reduceMotion: false,
+});
+
+function cloneUiValue(value) {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneUiValue(entry));
+  }
+  if (value && typeof value === 'object') {
+    const output = {};
+    for (const [key, entry] of Object.entries(value)) {
+      output[key] = cloneUiValue(entry);
+    }
+    return output;
+  }
+  return value;
+}
+
+function clampNumber(value, min, max, fallback) {
+  const numeric = Number(value);
+  if (!Number.isFinite(numeric)) return fallback;
+  return Math.max(min, Math.min(max, numeric));
+}
+
+function normalizeChoice(value, choices, fallback) {
+  const normalized = typeof value === 'string' ? value.trim() : '';
+  if (!normalized) return fallback;
+  return choices.some((entry) => entry.id === normalized) ? normalized : fallback;
+}
+
+function normalizeBoolean(value, fallback) {
+  if (value === true) return true;
+  if (value === false) return false;
+  return fallback;
+}
+
+function ensureUiBucket(appState) {
+  if (!appState || typeof appState !== 'object' || Array.isArray(appState)) {
+    throw new Error('Expected appState to be a mutable object.');
+  }
+  if (!appState.ui || typeof appState.ui !== 'object' || Array.isArray(appState.ui)) {
+    appState.ui = {};
+  }
+  return appState.ui;
+}
+
+function densityThemePatch(density) {
+  if (density === 'compact') {
+    return {
+      gap: 8,
+      padding: 10,
+      fontSize: 15,
+      lineHeight: 18,
+      buttonHeight: 34,
+    };
+  }
+  return {
+    gap: 12,
+    padding: 14,
+    fontSize: 16,
+    lineHeight: 20,
+    buttonHeight: 40,
+  };
+}
+
+function contrastThemePatch(contrast) {
+  if (contrast === 'high') {
+    return {
+      textColor: '#ffffff',
+      mutedTextColor: '#d4e1ff',
+      panelBorderColor: '#ffffff',
+      buttonFocusColor: '#ffffff',
+      buttonTextColor: '#08111b',
+    };
+  }
+  return {};
+}
+
+function textScaleThemePatch(textScale) {
+  if (textScale === 'large') {
+    return {
+      fontSize: 18,
+      lineHeight: 22,
+      buttonHeight: 44,
+      padding: 16,
+    };
+  }
+  return {};
+}
+
+function focusVisibilityThemePatch(focusVisibility) {
+  if (focusVisibility === 'high') {
+    return {
+      borderWidth: 2,
+      panelBorderColor: '#f4f8ff',
+      buttonFocusColor: '#f4f8ff',
+      buttonActiveColor: '#ffd166',
+      buttonTextColor: '#08111b',
+    };
+  }
+  return {};
+}
+
+export function listUiThemeChoices() {
+  return Object.values(UI_THEME_PRESETS).map((entry) => ({
+    id: entry.id,
+    label: entry.label,
+    description: entry.description,
+  }));
+}
+
+export function listUiDensityChoices() {
+  return UI_DENSITY_CHOICES.map((entry) => ({ ...entry }));
+}
+
+export function listUiContrastChoices() {
+  return UI_CONTRAST_CHOICES.map((entry) => ({ ...entry }));
+}
+
+export function listUiTextScaleChoices() {
+  return UI_TEXT_SCALE_CHOICES.map((entry) => ({ ...entry }));
+}
+
+export function listUiFocusVisibilityChoices() {
+  return UI_FOCUS_VISIBILITY_CHOICES.map((entry) => ({ ...entry }));
+}
+
+export function createUiPreferencesSeed(overrides = {}) {
+  const source = overrides && typeof overrides === 'object' && !Array.isArray(overrides)
+    ? overrides
+    : {};
+  return {
+    schema: UI_PREFERENCES_SCHEMA,
+    themeId: normalizeChoice(source.themeId, listUiThemeChoices(), DEFAULT_UI_PREFERENCES.themeId),
+    density: normalizeChoice(source.density, UI_DENSITY_CHOICES, DEFAULT_UI_PREFERENCES.density),
+    contrast: normalizeChoice(source.contrast, UI_CONTRAST_CHOICES, DEFAULT_UI_PREFERENCES.contrast),
+    textScale: normalizeChoice(source.textScale, UI_TEXT_SCALE_CHOICES, DEFAULT_UI_PREFERENCES.textScale),
+    focusVisibility: normalizeChoice(
+      source.focusVisibility,
+      UI_FOCUS_VISIBILITY_CHOICES,
+      DEFAULT_UI_PREFERENCES.focusVisibility,
+    ),
+    musicEnabled: normalizeBoolean(source.musicEnabled, DEFAULT_UI_PREFERENCES.musicEnabled),
+    subtitlesEnabled: normalizeBoolean(source.subtitlesEnabled, DEFAULT_UI_PREFERENCES.subtitlesEnabled),
+    masterVolume: Math.round(clampNumber(source.masterVolume, 0, 10, DEFAULT_UI_PREFERENCES.masterVolume)),
+    reduceMotion: normalizeBoolean(source.reduceMotion, DEFAULT_UI_PREFERENCES.reduceMotion),
+  };
+}
+
+export function normalizeUiPreferences(source = null) {
+  const merged = source && typeof source === 'object' && !Array.isArray(source)
+    ? { ...DEFAULT_UI_PREFERENCES, ...source }
+    : { ...DEFAULT_UI_PREFERENCES };
+  return createUiPreferencesSeed(merged);
+}
+
+export function ensureUiPreferences(appState, seed = null) {
+  const ui = ensureUiBucket(appState);
+  const fallback = createUiPreferencesSeed(seed || {});
+  if (!ui.preferences || typeof ui.preferences !== 'object' || Array.isArray(ui.preferences)) {
+    ui.preferences = fallback;
+    return ui.preferences;
+  }
+  ui.preferences = normalizeUiPreferences({
+    ...fallback,
+    ...ui.preferences,
+  });
+  return ui.preferences;
+}
+
+export function updateUiPreferences(appState, patch = {}) {
+  const current = ensureUiPreferences(appState);
+  const next = normalizeUiPreferences({
+    ...current,
+    ...(patch && typeof patch === 'object' && !Array.isArray(patch) ? patch : {}),
+  });
+  const changedKeys = Object.keys(next).filter((key) => JSON.stringify(current[key]) !== JSON.stringify(next[key]));
+  ensureUiBucket(appState).preferences = next;
+  return {
+    ok: true,
+    reasonCode: changedKeys.length > 0 ? 'ui_preferences_updated' : 'ui_preferences_unchanged',
+    changedKeys,
+    preferences: cloneUiValue(next),
+  };
+}
+
+export function resetUiPreferences(appState, seed = null) {
+  const next = createUiPreferencesSeed(seed || {});
+  ensureUiBucket(appState).preferences = next;
+  return {
+    ok: true,
+    reasonCode: 'ui_preferences_reset',
+    preferences: cloneUiValue(next),
+  };
+}
+
+export function resolveUiTheme(preferences = null) {
+  const normalized = normalizeUiPreferences(preferences);
+  const preset = UI_THEME_PRESETS[normalized.themeId] || UI_THEME_PRESETS[DEFAULT_UI_PREFERENCES.themeId];
+  const theme = {
+    ...cloneUiValue(preset.theme),
+    ...densityThemePatch(normalized.density),
+    ...contrastThemePatch(normalized.contrast),
+    ...textScaleThemePatch(normalized.textScale),
+    ...focusVisibilityThemePatch(normalized.focusVisibility),
+  };
+  return {
+    schema: UI_THEME_SCHEMA,
+    reasonCode: 'ui_theme_ready',
+    presetId: preset.id,
+    presetLabel: preset.label,
+    density: normalized.density,
+    contrast: normalized.contrast,
+    textScale: normalized.textScale,
+    focusVisibility: normalized.focusVisibility,
+    preferences: cloneUiValue(normalized),
+    theme,
+    availableThemeIds: Object.keys(UI_THEME_PRESETS),
+  };
+}
+
+export function inspectUiTheme(appState) {
+  return resolveUiTheme(ensureUiPreferences(appState));
+}
+
+export function applyUiTheme(appState, { preferences = null } = {}) {
+  const themeState = preferences
+    ? resolveUiTheme(preferences)
+    : inspectUiTheme(appState);
+  const runtime = globalThis.aura;
+  if (!runtime?.ui || typeof runtime.ui.setTheme !== 'function') {
+    return {
+      ok: false,
+      reasonCode: 'ui_theme_runtime_unavailable',
+      themeState,
+    };
+  }
+  const result = runtime.ui.setTheme(themeState.theme);
+  if (result?.ok === false) {
+    return {
+      ok: false,
+      reasonCode: result.reasonCode || 'ui_theme_apply_failed',
+      themeState,
+    };
+  }
+  return {
+    ok: true,
+    reasonCode: result?.reasonCode || 'ui_theme_updated',
+    themeState,
+  };
+}

package/templates/create/shared/src/starter-utils/adventure-objectives.js

@@ -0,0 +1,102 @@
+import { distanceSquared2D, distanceSquared3D } from './core.js';
+
+function finite(value, fallback = 0) {
+  const numeric = Number(value);
+  return Number.isFinite(numeric) ? numeric : fallback;
+}
+
+function normalizeId(value, fallback) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function normalizeLabel(value, fallback) {
+  if (typeof value === 'string' && value.trim().length > 0) {
+    return value.trim();
+  }
+  return fallback;
+}
+
+function normalizeObjectiveEntry(entry, index, options = {}) {
+  const dimension = options.dimension === '3d' ? '3d' : '2d';
+  const fallbackId = `objective-${index + 1}`;
+  const fallbackLabel = `Objective ${index + 1}`;
+  return {
+    id: normalizeId(entry?.id, fallbackId),
+    label: normalizeLabel(entry?.label ?? entry?.name, fallbackLabel),
+    x: finite(entry?.x),
+    y: finite(entry?.y),
+    z: dimension === '3d' ? finite(entry?.z) : 0,
+    radius: Math.max(0.1, finite(entry?.radius, finite(options.defaultRadius, 1))),
+    value: Math.max(1, Math.round(finite(entry?.value, 1))),
+    collected: entry?.collected === true,
+  };
+}
+
+export function createAdventureObjectives(entries = [], options = {}) {
+  return (Array.isArray(entries) ? entries : []).map((entry, index) => normalizeObjectiveEntry(entry, index, options));
+}
+
+export function resetAdventureObjectives(objectives) {
+  for (const objective of Array.isArray(objectives) ? objectives : []) {
+    objective.collected = false;
+  }
+  return objectives;
+}
+
+export function countCompletedObjectives(objectives) {
+  return (Array.isArray(objectives) ? objectives : []).reduce(
+    (total, objective) => total + (objective?.collected === true ? 1 : 0),
+    0,
+  );
+}
+
+export function objectivesComplete(objectives, requiredCount = null) {
+  const totalObjectives = Array.isArray(objectives) ? objectives.length : 0;
+  const threshold = Number.isFinite(Number(requiredCount))
+    ? Math.max(0, Math.min(totalObjectives, Number(requiredCount)))
+    : totalObjectives;
+  return countCompletedObjectives(objectives) >= threshold;
+}
+
+export function firstPendingObjective(objectives) {
+  return (Array.isArray(objectives) ? objectives : []).find((objective) => objective?.collected !== true) || null;
+}
+
+function collectAdventureObjectives(subject, objectives, pickupRadius, measureDistanceSquared) {
+  const collected = [];
+  const extraRadius = Math.max(0, finite(pickupRadius, 0));
+  let scoreDelta = 0;
+
+  for (const objective of Array.isArray(objectives) ? objectives : []) {
+    if (!objective || objective.collected === true) continue;
+    const threshold = objective.radius + extraRadius;
+    if (measureDistanceSquared(subject, objective) > (threshold * threshold)) continue;
+    objective.collected = true;
+    scoreDelta += objective.value;
+    collected.push({
+      id: objective.id,
+      label: objective.label,
+      value: objective.value,
+    });
+  }
+
+  return {
+    changed: collected.length > 0,
+    collected,
+    collectedCount: collected.length,
+    scoreDelta,
+    completedObjectives: countCompletedObjectives(objectives),
+    totalObjectives: Array.isArray(objectives) ? objectives.length : 0,
+  };
+}
+
+export function collectAdventureObjectives2D(subject, objectives, pickupRadius = 0) {
+  return collectAdventureObjectives(subject, objectives, pickupRadius, distanceSquared2D);
+}
+
+export function collectAdventureObjectives3D(subject, objectives, pickupRadius = 0) {
+  return collectAdventureObjectives(subject, objectives, pickupRadius, distanceSquared3D);
+}