Acgti Anime Persona Quiz

// MBTI dimension keysexport type Dimension = 'EI' | 'SN' | 'TF' | 'JP';
// One question entryexport interface Question {  id: number;  text: string;  dimension: Dimension;  archetypeWeights: Record<string, number>; // archetype id → weight (-3..+3)  tags?: string[];}
// One of 8 archetypesexport interface Archetype {  id: string;           // e.g. "glowing-protagonist"  name: string;  mbtiTypes: string[];  // e.g. ["ENFJ","ENFP"]  description: string;  strengths: string[];  weaknesses: string[];  color: string;        // hex}
// Anime character entryexport interface Character {  id: string;           // unique slug, becomes the "character code"  name: string;  series: string;  mbtiType: string;     // e.g. "ENFJ"  archetypeId: string;  tags: string[];  stats: {              // 0–100 six-axis radar    energy: number;    intuition: number;    empathy: number;    logic: number;    order: number;    chaos: number;  };}
// Visual theming per characterexport interface CharacterVisual {  characterId: string;  portraitUrl: string;  backgroundUrl: string;  primaryColor: string;  accentColor: string;}
// Final computed result passed to ResultPageexport interface QuizResult {  mbtiType: string;               // e.g. "INFP"  dimensionScores: Record<Dimension, number>; // 50–100, direction-normalised  archetypeId: string;  characterId: string;}

import questions from '@/data/questions.json';import archetypes from '@/data/archetypes.json';import characters from '@/data/characters.json';import type { Dimension, QuizResult } from '@/types/quiz';
type Answers = Record<number, number>; // questionId → -3..+3
/** Step 1: Sum raw signed scores per MBTI dimension */function calcDimensionRaw(answers: Answers): Record<Dimension, number> {  const raw: Record<Dimension, number> = { EI: 0, SN: 0, TF: 0, JP: 0 };  for (const q of questions) {    const val = answers[q.id] ?? 0;    raw[q.dimension as Dimension] += val;  }  return raw;}
/** Step 2: Normalise to 50–100 (50 = perfectly balanced) */function normaliseDimension(raw: number, questionCount: number): number {  const max = questionCount * 3;           // maximum possible absolute value  const clamped = Math.max(-max, Math.min(max, raw));  return Math.round(50 + (Math.abs(clamped) / max) * 50);}
/** Step 3: Derive MBTI letter for one dimension */function mbtiLetter(dimension: Dimension, raw: number): string {  const positive: Record<Dimension, string> = { EI: 'E', SN: 'N', TF: 'T', JP: 'J' };  const negative: Record<Dimension, string> = { EI: 'I', SN: 'S', TF: 'F', JP: 'P' };  return raw >= 0 ? positive[dimension] : negative[dimension];}
/** Full pipeline */export function computeResult(answers: Answers): QuizResult {  const dims: Dimension[] = ['EI', 'SN', 'TF', 'JP'];  const raw = calcDimensionRaw(answers);
  // Count questions per dimension for normalisation  const countPerDim = dims.reduce((acc, d) => {    acc[d] = questions.filter(q => q.dimension === d).length;    return acc;  }, {} as Record<Dimension, number>);
  const dimensionScores = dims.reduce((acc, d) => {    acc[d] = normaliseDimension(raw[d], countPerDim[d]);    return acc;  }, {} as Record<Dimension, number>);
  const mbtiType = dims.map(d => mbtiLetter(d, raw[d])).join('');
  // Match archetype (archetypes list mbtiTypes they cover)  const archetype = archetypes.find(a => a.mbtiTypes.includes(mbtiType))    ?? archetypes[0];
  // Pick best-fit character within archetype  const candidates = characters.filter(c => c.archetypeId === archetype.id);  // Default: first match; extendable with probability weighting  const character = candidates[0];
  return {    mbtiType,    dimensionScores,    archetypeId: archetype.id,    characterId: character.id,  };}

// src/composables/useQuiz.ts — typical usage from a page componentimport { useQuiz } from '@/composables/useQuiz';
const {  currentQuestion,   // Ref<Question>  currentIndex,      // Ref<number>  totalQuestions,    // number (39)  progress,          // ComputedRef<number> 0–100  answer,            // (value: number) => void  — records -3..+3 and advances  goBack,            // () => void  result,            // Ref<QuizResult | null>  isComplete,        // ComputedRef<boolean>  resetQuiz,         // () => void} = useQuiz();

import { useShare } from '@/composables/useShare';
const { exportPNG, shareNative } = useShare();
// exportPNG wraps html2canvas on the #share-poster elementawait exportPNG('#share-poster', 'my-acgti-result.png');
// shareNative uses Web Share API with fallback to clipboard copyawait shareNative({  title: 'My ACGTI Result',  text: `I got ${result.value?.characterId}!`,  url: 'https://acgti.tianxingleo.top',});

// Five named routesconst routes = [  { path: '/',          name: 'home',       component: HomePage },  { path: '/intro',     name: 'intro',      component: IntroPage },  { path: '/quiz',      name: 'quiz',       component: QuizPage },  { path: '/result',    name: 'result',     component: ResultPage },  { path: '/characters',name: 'characters', component: CharactersPage },  { path: '/about',     name: 'about',      component: AboutPage },];

import { useRouter } from 'vue-router';const router = useRouter();router.push({ name: 'result' });

import { saveResult, loadResult, clearResult } from '@/utils/storage';import type { QuizResult } from '@/types/quiz';
// Persist result across page refreshessaveResult(result);
// Restore on ResultPage mountconst saved: QuizResult | null = loadResult();
// Reset for retakeclearResult();

import characters from '@/data/characters.json';import type { Character } from '@/types/quiz';
const archetypeId = 'glowing-protagonist';const subset: Character[] = characters.filter(  (c) => c.archetypeId === archetypeId);

import visuals from '@/data/characterVisuals.json';import { enrichCharacterVisuals } from '@/utils/characterVisuals';
const enriched = enrichCharacterVisuals(characters, visuals);// enriched[i] = { ...Character, ...CharacterVisual }

function dimensionLabel(dim: Dimension, score: number): string {  const labels: Record<Dimension, [string, string]> = {    EI: ['E 外向', 'I 内向'],    SN: ['N 直觉', 'S 实感'],    TF: ['T 思考', 'F 情感'],    JP: ['J 判断', 'P 知觉'],  };  // score > 50 means positive pole; score === 50 means balanced (show both)  return score >= 50 ? labels[dim][0] : labels[dim][1];}