chore(android): Play Core ProGuard 경고 억제 규칙 추가

- deferred components 관련 dontwarn 규칙 추가

CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+프로젝트의 주요 변경 사항을 기록합니다.
+
+## [Unreleased]
+
+### Refactored (리팩토링)
+
+#### GameSessionController 분할 (SRP 개선)
+- 920 LOC → 526 LOC (43% 감소)
+- 5개 매니저로 책임 분리:
+  - `GameStatisticsManager` - 세션/누적 통계 추적
+  - `SpeedBoostManager` - 광고 배속 부스트 기능
+  - `ReturnRewardsManager` - 복귀 보상 기능
+  - `ResurrectionManager` - 사망/부활 처리
+  - `HallOfFameManager` - 명예의 전당 관리
+
+#### ProgressService 메서드 분할
+- `tick()`: 350 LOC → 80 LOC (8개 헬퍼 메서드)
+- `_generateNextTask()`: 200 LOC → 35 LOC (6개 헬퍼 메서드)
+
+#### GamePlayScreen 메서드 분할
+- `build()`: 300 LOC → 15 LOC (5개 헬퍼 메서드)
+
+#### Clean Architecture 개선
+- `MonsterGrade.displayColor` (Color) → `displayColorCode` (int)
+- Domain 레이어에서 Flutter 의존성 제거
+
+### Fixed (버그 수정)
+
+#### Analyzer 경고 정리
+- 미사용 import 제거 (`panel_header.dart`)
+- 미사용 필드 제거 (`new_character_screen.dart`)
+- JsonKey 경고 억제 (`equipment_item.dart`, `monetization_state.dart`)
+
+---
+
+## 버전 표기 규칙
+
+- `Added`: 새로운 기능 추가
+- `Changed`: 기존 기능 변경
+- `Deprecated`: 곧 제거될 기능
+- `Removed`: 제거된 기능
+- `Fixed`: 버그 수정
+- `Security`: 보안 관련 수정
+- `Refactored`: 코드 구조 개선 (기능 변화 없음)

CLAUDE.md

@@ -4,7 +4,7 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
 
 ## 프로젝트 개요
 
-Askii Never Die는 Progress Quest 6.4 (Delphi 원본)를 Flutter로 100% 동일하게 복제하는 오프라인 싱글플레이어 RPG입니다. 네트워크 기능은 모두 제외되며, 원본 알고리즘과 데이터를 그대로 유지해야 합니다.
+Askii Never Die는 Progress Quest 6.4의 핵심 메커니즘을 기반으로, 독자적 세계관("디지털 판타지")과 확장된 시스템으로 재구성한 오프라인 싱글플레이어 방치형 RPG입니다. 네트워크 기능은 제외됩니다.
 
 ## 빌드 및 실행
 
@@ -27,29 +27,53 @@ flutter test
 
 ```
 lib/
-├── main.dart                      # 앱 진입점
-├── data/pq_config_data.dart       # PQ 정적 데이터 (Config.dfm 추출)
+├── main.dart                          # 앱 진입점
+├── data/                              # 정적 데이터 (Config.dfm 추출 + 확장)
+│   ├── pq_config_data.dart            # PQ 원본 정적 데이터
+│   ├── class_data.dart                # 직업 데이터
+│   ├── race_data.dart                 # 종족 데이터
+│   ├── skill_data.dart                # 스킬 데이터
+│   ├── potion_data.dart               # 포션 데이터
+│   ├── story_data.dart                # 스토리 데이터
+│   └── game_text_l10n.dart            # 게임 텍스트 번역
+├── l10n/                              # 앱 UI 다국어 리소스 (arb)
 └── src/
-    ├── app.dart                   # MaterialApp 설정
+    ├── app.dart                       # MaterialApp 설정
     ├── core/
-    │   ├── engine/                # 게임 루프 및 진행 로직
-    │   │   ├── progress_loop.dart     # 타이머 기반 메인 루프 (원본 200ms)
-    │   │   ├── progress_service.dart  # 틱 처리, 경험치/레벨업 로직
-    │   │   ├── game_mutations.dart    # 상태 변경 함수
-    │   │   └── reward_service.dart    # 보상 처리
-    │   ├── model/
-    │   │   ├── game_state.dart        # 핵심 상태: Traits, Stats, Inventory, Equipment, SpellBook, ProgressState, QueueState
-    │   │   ├── pq_config.dart         # Config 데이터 접근
-    │   │   ├── equipment_slot.dart    # 장비 슬롯 정의
-    │   │   └── save_data.dart         # 저장 데이터 구조
-    │   ├── storage/                   # 세이브 파일 처리
-    │   └── util/
-    │       ├── deterministic_random.dart  # 결정론적 RNG (재현 가능)
-    │       ├── pq_logic.dart              # 원본 로직 포팅 (odds, randSign 등)
-    │       └── roman.dart                 # 로마 숫자 변환
-    └── features/
-        ├── front/front_screen.dart        # 임시 프론트 화면
-        └── game/game_session_controller.dart  # 게임 세션 관리
+    │   ├── engine/                    # 게임 루프 및 진행 로직
+    │   │   ├── progress_loop.dart         # 타이머 기반 메인 루프
+    │   │   ├── progress_service.dart      # 틱 처리, 경험치/레벨업 로직
+    │   │   ├── game_mutations.dart        # 상태 변경 함수
+    │   │   ├── reward_service.dart        # 보상 처리
+    │   │   ├── combat_calculator.dart     # 전투 계산
+    │   │   ├── combat_tick_service.dart   # 전투 틱 처리
+    │   │   ├── arena_service.dart         # 아레나 시스템
+    │   │   ├── skill_service.dart         # 스킬 시스템
+    │   │   ├── item_service.dart          # 아이템 처리
+    │   │   ├── potion_service.dart        # 포션 시스템
+    │   │   ├── shop_service.dart          # 상점 시스템
+    │   │   ├── story_service.dart         # 스토리 진행
+    │   │   └── ...                        # 기타 서비스
+    │   ├── model/                     # 게임 상태 및 데이터 모델
+    │   ├── animation/                 # ASCII 애니메이션 데이터/렌더링
+    │   ├── audio/                     # 오디오 서비스
+    │   ├── storage/                   # 세이브/설정 저장소
+    │   ├── notification/              # 알림 서비스
+    │   ├── constants/                 # 상수 정의
+    │   ├── l10n/                      # 게임 데이터 번역 유틸
+    │   └── util/                      # 유틸리티 (RNG, 로직 헬퍼 등)
+    ├── features/
+    │   ├── front/                     # 타이틀/세이브 선택 화면
+    │   ├── new_character/             # 캐릭터 생성 화면
+    │   ├── game/                      # 게임 진행 화면 (메인)
+    │   │   ├── controllers/           # 전투 로그, 오디오 컨트롤러
+    │   │   ├── managers/              # 통계, 부활, 속도 부스트 등
+    │   │   ├── pages/                 # 탭별 페이지 (장비, 인벤토리, 퀘스트 등)
+    │   │   └── widgets/              # UI 위젯
+    │   ├── arena/                     # 아레나 전투 화면
+    │   ├── hall_of_fame/              # 명예의 전당
+    │   └── settings/                  # 설정 화면
+    └── shared/                        # 공통 테마/위젯
 
 example/pq/     # Delphi 원본 소스 (참조용, 빌드 대상 아님)
 test/           # 단위/위젯 테스트
@@ -69,10 +93,9 @@ test/           # 단위/위젯 테스트
 
 ## 핵심 규칙
 
-### 원본 충실도
-- `example/pq/` 내 Delphi 소스의 알고리즘/데이터를 100% 동일하게 포팅
-- 원본 로직 변경 필요 시 반드시 사용자 승인 필요
-- 새로운 기능, 값, 처리 로직 추가 금지 (디버깅 로그 예외)
+### 원본 참조 정책
+- `example/pq/`는 참조용으로 유지
+- 원본 알고리즘은 참고하되 독자적 확장/수정 허용
 
 ### 데이터 관리
 - 정적 데이터(몬스터, 아이템, 주문 등)는 `Config.dfm`에서 추출하여 JSON/Dart const로 관리
@@ -87,11 +110,13 @@ test/           # 단위/위젯 테스트
 - SRP(Single Responsibility Principle) 준수
 
 ### 화면 구성
-- 2개 화면만 사용: 캐릭터 생성 화면, 게임 진행 화면
+- 주요 화면: 프론트, 캐릭터 생성, 게임 진행, 아레나, 명예의 전당, 설정
 - 화면 내 요소는 위젯 단위로 분리
 
 ## 원본 소스 참조 (example/pq/)
 
+> 참고용으로만 사용. 원본 로직을 그대로 따를 의무는 없음.
+
 | 파일 | 핵심 함수/라인 | 역할 |
 |------|----------------|------|
 | `Main.pas:523-1040` | `MonsterTask` | 전투/전리품/레벨업 |
@@ -105,7 +130,6 @@ test/           # 단위/위젯 테스트
 - `pubspec.yaml` 의존성 변경
 - 플랫폼 빌드 설정 (Android/iOS/desktop)
 - 네트워크 접근 도입
-- 원본 데이터/알고리즘 수정
 - 대규모 파일 삭제 또는 구조 변경
 
 ## 커밋 규칙

PLAN.md

@@ -0,0 +1,250 @@
+# 종족/클래스 패시브 미반영 수정 계획
+
+## 1. 현황 분석
+
+### 반영되는 패시브 (전투 스탯 계산에 적용됨)
+- HP/MP 보너스, 물리/마법 데미지 보너스, 방어력/회피율/크리티컬 보너스
+
+### 미반영 패시브 (정의만 있고 실제 로직에서 미사용)
+
+| 패시브 | 영향받는 종족/클래스 | 수정 위치 |
+|--------|---------------------|-----------|
+| `expMultiplier` | Byte Human (+5%), Callback Seraph (+3%) | `progress_service.dart:387` |
+| `firstStrikeBonus` | Pointer Assassin (1.5배) | `combat_tick_service.dart` |
+| `multiAttack` | Refactor Monk | `combat_tick_service.dart` |
+| `postCombatHeal` | Garbage Collector (+5%) | `progress_service.dart:279` |
+| `healingBonus` | Debugger Paladin, Exception Handler, Null Checker | `potion_service.dart`, `skill_service.dart` |
+| `deathEquipmentPreserve` | Coredump Undead | **특성 변경 필요** |
+
+---
+
+## 2. 수정 내용
+
+### 2.1 경험치 배율 (`expMultiplier`)
+
+**파일**: `lib/src/core/engine/progress_service.dart`
+
+**위치**: 384-387줄
+
+**현재 코드**:
+```dart
+if (gain && nextState.traits.level < 100 && monsterExpReward > 0) {
+  final newExpPos = progress.exp.position + monsterExpReward;
+```
+
+**수정 후**:
+```dart
+if (gain && nextState.traits.level < 100 && monsterExpReward > 0) {
+  // 종족 경험치 배율 적용 (예: Byte Human +5%)
+  final race = RaceData.findById(nextState.traits.raceId);
+  final expMultiplier = race?.expMultiplier ?? 1.0;
+  final adjustedExp = (monsterExpReward * expMultiplier).round();
+  final newExpPos = progress.exp.position + adjustedExp;
+```
+
+---
+
+### 2.2 첫 공격 배율 (`firstStrikeBonus`)
+
+**파일**: `lib/src/core/engine/combat_tick_service.dart`
+
+**설계**:
+- 전투 시작 시 첫 공격인지 추적하는 플래그 필요
+- 첫 공격 시 `firstStrikeBonus` 배율 적용
+
+**수정 방안**:
+1. `CombatState`에 `isFirstAttack` 플래그 추가
+2. `CombatTickService`에서 첫 플레이어 공격 시 배율 적용:
+```dart
+var damage = result.damage;
+if (isFirstPlayerAttack && firstStrikeBonus > 1.0) {
+  damage = (damage * firstStrikeBonus).round();
+  isFirstPlayerAttack = false;
+}
+```
+
+---
+
+### 2.3 연속 공격 (`multiAttack`)
+
+**파일**: `lib/src/core/engine/combat_tick_service.dart`
+
+**설계**:
+- `hasMultiAttack` 패시브가 있으면 일정 확률로 추가 공격
+- 예: 30% 확률로 연속 공격 (2타)
+
+**수정 방안**:
+```dart
+// 플레이어 공격 후
+if (hasMultiAttack && rng.nextDouble() < 0.3) {
+  // 추가 공격 실행
+  final extraAttack = calculator.playerAttackMonster(...);
+  // 결과 합산
+}
+```
+
+---
+
+### 2.4 전투 후 HP 회복 (`postCombatHeal`)
+
+**파일**: `lib/src/core/engine/progress_service.dart`
+
+**위치**: 276-280줄
+
+**현재 코드**:
+```dart
+// 전투 승리 시 HP 회복 (50% + CON/2)
+final conBonus = nextState.stats.con ~/ 2;
+final healAmount = (maxHp * 0.5).round() + conBonus;
+```
+
+**수정 후**:
+```dart
+// 전투 승리 시 HP 회복 (50% + CON/2 + 클래스 패시브)
+final conBonus = nextState.stats.con ~/ 2;
+var healAmount = (maxHp * 0.5).round() + conBonus;
+
+// 클래스 패시브: 전투 후 HP 회복 (Garbage Collector +5%)
+final klass = ClassData.findById(nextState.traits.classId);
+if (klass != null) {
+  final postCombatHealRate = klass.getPassiveValue(ClassPassiveType.postCombatHeal);
+  if (postCombatHealRate > 0) {
+    healAmount += (maxHp * postCombatHealRate).round();
+  }
+}
+```
+
+---
+
+### 2.5 회복력 보너스 (`healingBonus`)
+
+물약/스킬 사용 시 추가 회복 적용
+
+#### 2.5.1 물약 회복
+
+**파일**: `lib/src/core/engine/potion_service.dart`
+
+**수정 위치**: `usePotion()` 메서드 (73-81줄)
+
+**현재 코드**:
+```dart
+if (potion.isHpPotion) {
+  healedAmount = potion.calculateHeal(maxHp);
+  newHp = (currentHp + healedAmount).clamp(0, maxHp);
+```
+
+**수정 후**:
+```dart
+if (potion.isHpPotion) {
+  var baseHeal = potion.calculateHeal(maxHp);
+  // 회복력 보너스 적용 (클래스 패시브)
+  baseHeal = (baseHeal * healingMultiplier).round();
+  newHp = (currentHp + baseHeal).clamp(0, maxHp);
+  healedAmount = newHp - currentHp;
+```
+
+**참고**: `PotionService`에 `healingMultiplier` 파라미터 추가 필요
+
+#### 2.5.2 스킬 회복
+
+**파일**: `lib/src/core/engine/skill_service.dart`
+
+**수정 위치**: `useHealSkill()` 메서드 (125-132줄)
+
+**현재 코드**:
+```dart
+int healAmount = skill.healAmount;
+if (skill.healPercent > 0) {
+  healAmount += (player.hpMax * skill.healPercent).round();
+}
+```
+
+**수정 후**:
+```dart
+int healAmount = skill.healAmount;
+if (skill.healPercent > 0) {
+  healAmount += (player.hpMax * skill.healPercent).round();
+}
+// 회복력 보너스 적용 (클래스 패시브)
+healAmount = (healAmount * healingMultiplier).round();
+```
+
+**참고**: `SkillService`에 `healingMultiplier` 파라미터 추가 필요
+
+---
+
+### 2.6 Coredump Undead 특성 변경
+
+**현재 특성**: `deathEquipmentPreserve` (사망 시 장비 1개 유지) - BM 침해
+
+**대체 특성 제안** (언데드 콘셉트에 어울리는 것):
+
+| 옵션 | 설명 | 장점 |
+|------|------|------|
+| **방어력 +10%** | 언데드는 고통을 느끼지 않아 피해 감소 | 구현 간단, CON+2와 시너지 |
+| **HP +8%** | 불사의 육체 | 구현 간단, 생존형 콘셉트 유지 |
+| **HP +5% + 방어력 +5%** | 복합 생존 특화 | 다른 종족과 차별화 |
+
+**추천**: `defenseBonus: 0.10` (방어력 +10%)
+- 이유: 언데드의 "고통을 느끼지 않는" 콘셉트와 어울림
+- 기존 CON+2, STR+1 스탯과 탱커형 시너지
+
+**파일**: `lib/data/race_data.dart`
+
+**수정**:
+```dart
+static const coredumpUndead = RaceTraits(
+  raceId: 'coredump_undead',
+  name: 'Coredump Undead',
+  statModifiers: {
+    StatType.con: 2,
+    StatType.str: 1,
+    StatType.cha: -2,
+    StatType.dex: -1,
+  },
+  passives: [
+    PassiveAbility(
+      type: PassiveType.defenseBonus,  // 변경
+      value: 0.10,                      // 변경
+      description: '방어력 +10%',       // 변경
+    ),
+  ],
+);
+```
+
+---
+
+## 3. 수정 순서
+
+1. **Coredump Undead 특성 변경** - 단순 데이터 수정
+2. **경험치 배율** - 간단한 로직 추가
+3. **전투 후 HP 회복** - 간단한 로직 추가
+4. **회복력 보너스** - 서비스 파라미터 수정 필요
+5. **첫 공격 배율** - 전투 상태 추적 필요
+6. **연속 공격** - 전투 로직 수정 필요
+
+---
+
+## 4. 검증 방법
+
+1. `flutter analyze` 통과
+2. 각 패시브가 적용된 종족/클래스로 캐릭터 생성
+3. 실제 게임 플레이로 효과 확인:
+   - Byte Human: 경험치 +5% (레벨업 속도)
+   - Pointer Assassin: 첫 공격 1.5배 (전투 시작 데미지)
+   - Refactor Monk: 연속 공격 (추가 타격)
+   - Garbage Collector: 전투 후 +5% HP 회복
+   - Debugger Paladin: 물약/스킬 회복량 +10%
+   - Coredump Undead: 방어력 +10%
+
+---
+
+## 5. 삭제할 코드
+
+**파일**: `lib/src/core/model/race_traits.dart`
+
+`PassiveType.deathEquipmentPreserve` enum 삭제 (사용되지 않음)
+
+**파일**: `lib/src/core/engine/stat_calculator.dart`
+
+`calculateDeathEquipmentPreserve()` 메서드 삭제 (사용되지 않음)

android/app/build.gradle.kts

@@ -1,3 +1,6 @@
+import java.util.Properties
+import java.io.FileInputStream
+
 plugins {
     id("com.android.application")
     id("kotlin-android")
@@ -5,8 +8,15 @@ plugins {
     id("dev.flutter.flutter-gradle-plugin")
 }
 
+// key.properties 파일 로드
+val keystorePropertiesFile = rootProject.file("key.properties")
+val keystoreProperties = Properties()
+if (keystorePropertiesFile.exists()) {
+    keystoreProperties.load(FileInputStream(keystorePropertiesFile))
+}
+
 android {
-    namespace = "com.example.asciineverdie"
+    namespace = "com.naturebridgeai.asciineverdie"
     compileSdk = flutter.compileSdkVersion
     ndkVersion = flutter.ndkVersion
 
@@ -20,21 +30,31 @@ android {
     }
 
     defaultConfig {
-        // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html).
-        applicationId = "com.example.asciineverdie"
-        // You can update the following values to match your application needs.
-        // For more information, see: https://flutter.dev/to/review-gradle-config.
+        applicationId = "com.naturebridgeai.asciineverdie"
         minSdk = flutter.minSdkVersion
         targetSdk = flutter.targetSdkVersion
         versionCode = flutter.versionCode
         versionName = flutter.versionName
     }
 
+    signingConfigs {
+        create("release") {
+            keyAlias = keystoreProperties["keyAlias"] as String?
+            keyPassword = keystoreProperties["keyPassword"] as String?
+            storeFile = keystoreProperties["storeFile"]?.let { file(it) }
+            storePassword = keystoreProperties["storePassword"] as String?
+        }
+    }
+
     buildTypes {
         release {
-            // TODO: Add your own signing config for the release build.
-            // Signing with the debug keys for now, so `flutter run --release` works.
-            signingConfig = signingConfigs.getByName("debug")
+            isMinifyEnabled = true
+            isShrinkResources = true
+            proguardFiles(
+                getDefaultProguardFile("proguard-android-optimize.txt"),
+                "proguard-rules.pro"
+            )
+            signingConfig = signingConfigs.getByName("release")
         }
     }
 }

android/app/proguard-rules.pro

@@ -0,0 +1,34 @@
+# Flutter 기본 규칙
+-keep class io.flutter.app.** { *; }
+-keep class io.flutter.plugin.** { *; }
+-keep class io.flutter.util.** { *; }
+-keep class io.flutter.view.** { *; }
+-keep class io.flutter.** { *; }
+-keep class io.flutter.plugins.** { *; }
+
+# Google Mobile Ads (AdMob)
+-keep class com.google.android.gms.ads.** { *; }
+-keep class com.google.ads.** { *; }
+
+# In-App Purchase (Google Play Billing)
+-keep class com.android.vending.billing.** { *; }
+
+# Kotlin 직렬화(serialization) 관련
+-keepattributes *Annotation*
+-keepattributes InnerClasses
+
+# 제네릭(generics) 시그니처 유지
+-keepattributes Signature
+
+# Play Core (deferred components) 경고 억제
+-dontwarn com.google.android.play.core.splitcompat.SplitCompatApplication
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallException
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallManager
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallManagerFactory
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallRequest$Builder
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallRequest
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallSessionState
+-dontwarn com.google.android.play.core.splitinstall.SplitInstallStateUpdatedListener
+-dontwarn com.google.android.play.core.tasks.OnFailureListener
+-dontwarn com.google.android.play.core.tasks.OnSuccessListener
+-dontwarn com.google.android.play.core.tasks.Task

android/app/src/main/AndroidManifest.xml

@@ -1,9 +1,11 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <!-- IAP 결제 권한 -->
+    <!-- AdMob 광고 로드에 필요 -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+    <!-- IAP 결제(billing) 권한 -->
     <uses-permission android:name="com.android.vending.BILLING" />
 
     <application
-        android:label="asciineverdie"
+        android:label="ASCII Never Die"
         android:name="${applicationName}"
         android:icon="@mipmap/ic_launcher">
         <!-- Copyright Protection -->

android/app/src/main/kotlin/com/naturebridgeai/asciineverdie/MainActivity.kt

@@ -1,4 +1,4 @@
-package com.example.asciineverdie
+package com.naturebridgeai.asciineverdie
 
 import io.flutter.embedding.android.FlutterActivity
 

android/key.properties

@@ -0,0 +1,4 @@
+storePassword=askiineverdie
+keyPassword=askiineverdie
+keyAlias=askiineverdie
+storeFile=../../doc/key/askiineverdie.jks

doc/and-privacy.txt

@@ -0,0 +1,206 @@
+ASCII Never Die 개인정보 처리방침 / Privacy Policy
+
+================================================================================
+
+한국어 (Korean)
+
+시행일자: 2026년 1월 30일
+
+본 개인정보 처리방침은 ASCII Never Die 앱(이하 "앱")의 개인정보 수집, 이용, 보관 및 보호에 관한 사항을 안내합니다.
+
+1. 수집하는 개인정보
+
+본 앱은 회원가입, 로그인 기능이 없습니다. 이름, 이메일, 전화번호 등의 개인 식별정보를 직접 수집하지 않습니다.
+
+사용자가 입력하는 캐릭터 이름, 게임 진행 데이터(레벨, 장비, 퀘스트 등)는 기기 내에만 저장됩니다.
+
+2. 데이터 저장 및 처리 방식
+
+  - 모든 게임 데이터는 로컬 저장소(기기 내 저장소)에만 보관됩니다.
+  - 클라우드나 외부 서버로 자동 전송되지 않습니다.
+  - 앱 삭제 시 저장된 모든 데이터가 함께 제거됩니다.
+
+3. 광고 및 제3자 서비스
+
+본 앱은 Google AdMob 광고 네트워크를 사용합니다. 광고 서비스 제공을 위해 다음 정보가 수집될 수 있습니다:
+
+  - 광고 식별자(Advertising ID)
+  - 기기 정보(모델, OS 버전 등)
+  - 대략적인 위치 정보
+  - 앱 사용 정보
+
+이러한 정보는 Google의 개인정보 처리방침에 따라 처리됩니다.
+  - Google 개인정보 처리방침: https://policies.google.com/privacy
+
+4. 인앱 결제
+
+본 앱은 광고 제거 등의 기능을 위해 인앱 결제를 제공합니다. 결제 처리는 각 플랫폼(Google Play, Apple App Store)에서 직접 처리하며, 개발사는 결제 정보(카드 번호, 계좌 정보 등)를 수집하거나 저장하지 않습니다.
+
+  - Google Play 개인정보 처리방침: https://policies.google.com/privacy
+  - Apple 개인정보 처리방침: https://www.apple.com/legal/privacy/
+
+5. 권한 사용
+
+  권한              용도
+  ---------------   ---------------------------------
+  네트워크 접근     광고 표시 및 인앱 결제 처리
+  저장소 접근       게임 데이터 저장
+
+요청된 권한은 해당 용도 외에는 사용되지 않습니다.
+
+6. 아동의 개인정보
+
+본 앱은 일반 사용자를 대상으로 설계되었으며, 만 14세 미만의 아동을 대상으로 개인정보를 수집하지 않습니다.
+
+7. 개인정보의 보호
+
+  - 모든 게임 데이터는 기기 내부에만 저장
+  - 외부 서버로의 개인정보 전송 없음
+  - 최소한의 필수 권한만 요청
+
+8. 처리방침의 변경
+
+본 개인정보 처리방침이 변경되는 경우, 앱 내 공지 또는 앱 스토어 설명을 통해 안내합니다.
+
+9. 문의처
+
+  이메일: naturebridgeai@gmail.com
+  담당자: NatureBridgeAI 앱개발팀
+
+================================================================================
+
+English
+
+Effective Date: January 30, 2026
+
+This Privacy Policy describes how ASCII Never Die (the "App") collects, uses, stores, and protects your information.
+
+1. Information We Collect
+
+This App does not require account registration or login. We do not directly collect personal identifying information such as your name, email address, or phone number.
+
+Character names and game progress data (level, equipment, quests, etc.) that you enter are stored only on your device.
+
+2. Data Storage and Processing
+
+  - All game data is stored locally on your device only.
+  - No data is automatically transmitted to cloud services or external servers.
+  - All stored data is deleted when you uninstall the App.
+
+3. Advertising and Third-Party Services
+
+This App uses the Google AdMob advertising network. The following information may be collected for advertising purposes:
+
+  - Advertising ID
+  - Device information (model, OS version, etc.)
+  - Approximate location information
+  - App usage information
+
+This information is processed in accordance with Google's Privacy Policy.
+  - Google Privacy Policy: https://policies.google.com/privacy
+
+4. In-App Purchases
+
+This App offers in-app purchases for features such as ad removal. Payment processing is handled directly by each platform (Google Play, Apple App Store). We do not collect or store any payment information (credit card numbers, account details, etc.).
+
+  - Google Play Privacy Policy: https://policies.google.com/privacy
+  - Apple Privacy Policy: https://www.apple.com/legal/privacy/
+
+5. Permissions
+
+  Permission          Purpose
+  ---------------     ----------------------------------------------
+  Network Access      Display advertisements and process in-app purchases
+  Storage Access      Save game data
+
+Requested permissions are not used for any purposes other than those stated above.
+
+6. Children's Privacy
+
+This App is designed for general users and does not knowingly collect personal information from children under 14 years of age.
+
+7. Data Protection
+
+  - All game data is stored only on your device
+  - No personal information is transmitted to external servers
+  - Only essential permissions are requested
+
+8. Changes to This Privacy Policy
+
+If this Privacy Policy is modified, we will notify you through in-app announcements or app store descriptions.
+
+9. Contact Us
+
+  Email: naturebridgeai@gmail.com
+  Contact: NatureBridgeAI App Development Team
+
+================================================================================
+
+日本語 (Japanese)
+
+施行日：2026年1月30日
+
+本プライバシーポリシーは、ASCII Never Dieアプリ（以下「本アプリ」）における個人情報の収集、利用、保管、保護について説明します。
+
+1. 収集する個人情報
+
+本アプリは会員登録・ログイン機能がありません。氏名、メールアドレス、電話番号などの個人識別情報を直接収集することはありません。
+
+ユーザーが入力するキャラクター名、ゲーム進行データ（レベル、装備、クエストなど）は端末内にのみ保存されます。
+
+2. データの保存と処理方法
+
+  - すべてのゲームデータはローカルストレージ（端末内）にのみ保管されます。
+  - クラウドや外部サーバーへ自動送信されることはありません。
+  - アプリを削除すると、保存されたすべてのデータも削除されます。
+
+3. 広告および第三者サービス
+
+本アプリはGoogle AdMob広告ネットワークを使用しています。広告サービス提供のため、以下の情報が収集される場合があります：
+
+  - 広告識別子（Advertising ID）
+  - 端末情報（機種、OSバージョンなど）
+  - おおよその位置情報
+  - アプリ使用情報
+
+これらの情報はGoogleのプライバシーポリシーに従って処理されます。
+  - Googleプライバシーポリシー：https://policies.google.com/privacy
+
+4. アプリ内課金
+
+本アプリは広告削除などの機能のためにアプリ内課金を提供しています。決済処理は各プラットフォーム（Google Play、Apple App Store）が直接行い、開発者は決済情報（カード番号、口座情報など）を収集・保存しません。
+
+  - Google Playプライバシーポリシー：https://policies.google.com/privacy
+  - Appleプライバシーポリシー：https://www.apple.com/legal/privacy/
+
+5. 権限の使用
+
+  権限                    用途
+  -------------------     ---------------------------------
+  ネットワークアクセス    広告表示およびアプリ内課金処理
+  ストレージアクセス      ゲームデータの保存
+
+要求された権限は、上記の用途以外には使用されません。
+
+6. 児童の個人情報
+
+本アプリは一般ユーザーを対象として設計されており、14歳未満の児童から個人情報を収集することはありません。
+
+7. 個人情報の保護
+
+  - すべてのゲームデータは端末内にのみ保存
+  - 外部サーバーへの個人情報送信なし
+  - 最小限の必要な権限のみを要求
+
+8. プライバシーポリシーの変更
+
+本プライバシーポリシーが変更される場合、アプリ内通知またはアプリストアの説明を通じてお知らせします。
+
+9. お問い合わせ
+
+  メール: naturebridgeai@gmail.com
+  担当者: NatureBridgeAI アプリ開発チーム
+
+================================================================================
+
+Last updated: January 30, 2026

doc/app-description.txt

@@ -0,0 +1,193 @@
+================================================================================
+한국어 (Korean)
+================================================================================
+
+[앱 이름]
+ASCII Never Die
+
+[간단한 설명] (80자 이하)
+코드의 신이 창조한 디지털 왕국. 글리치 신을 무찌르고 세계를 구하라!
+
+[자세한 설명]
+태초에 오직 공허만이 있었다.
+그리고 첫 번째 커밋이 일어났고, 코드베이스에 빛이 가득 찼다.
+코드의 신이 말씀하셨다. "함수가 있으라."
+
+그렇게 디지털 왕국이 탄생했다.
+
+그러나 어둠 속에서 글리치가 나타났다.
+이제, 새로운 영웅이 코드를 지키기 위해 깨어난다.
+
+당신의 여정이 시작된다...
+
+▶ 디지털 판타지의 세계
+
+ASCII Never Die는 프로그래밍과 판타지가 융합된 독특한 세계관의 방치형 RPG입니다. 텍스트와 기호로 이루어진 세계에서, 당신만의 영웅이 글리치 신에 맞서 싸웁니다.
+
+▶ 당신은 누구인가요?
+
+묵묵히 코드를 지키는 Byte Human?
+우아하게 null을 다루는 Null Elf?
+아니면 메모리 심연에서 돌아온 Coredump Undead?
+
+21가지 종족, 18가지 직업.
+378가지 조합 중 당신의 이야기는 어떻게 시작될까요?
+
+Bug Hunter가 되어 버그를 사냥할 수도,
+Compiler Mage가 되어 마법을 컴파일할 수도,
+Garbage Collector가 되어 적의 메모리를 정리할 수도 있습니다.
+
+▶ 레벨 100까지의 여정
+
+처음엔 작은 버그들과 싸우게 됩니다.
+"이 정도는 쉽네" 하고 생각할 겁니다.
+
+그러다 어느 순간, 화면에 거대한 이름이 뜹니다.
+심장이 두근거리기 시작합니다.
+
+5개의 막. 5번의 전환점. 그리고 마지막에 기다리는 것...
+직접 확인해보세요.
+
+▶ 방치형, 그러나 빠져드는
+
+캐릭터를 만들면 모험이 시작됩니다. 전투, 레벨업, 장비 획득, 주문 습득—
+모든 것이 자동으로 진행됩니다. 하지만 프로그레스 바가 차오르는 것을 멈출 수 없을 겁니다.
+
+"조금만 더... 다음 레벨업까지만..."
+
+▶ 완전 오프라인
+
+인터넷 없이 언제 어디서나. 지하철에서, 비행기에서, 침대에서.
+당신의 영웅은 항상 당신과 함께합니다.
+
+첫 번째 커밋을 시작하세요. 디지털 왕국이 당신을 기다립니다.
+
+================================================================================
+English
+================================================================================
+
+[App Name]
+ASCII Never Die
+
+[Short Description] (Under 80 characters)
+The Code God's kingdom awaits. Defeat the Glitch. Save the digital realm.
+
+[Full Description]
+In the beginning, there was only the Void.
+Then came the First Commit, and Light filled the Codebase.
+The Code God spoke: "Let there be Functions."
+
+And so the Digital Realm was born.
+
+But from the shadows emerged the Glitch.
+Now, a new hero awakens to defend the Code.
+
+Your journey begins...
+
+▶ The World of Digital Fantasy
+
+ASCII Never Die is an idle RPG with a unique world where programming meets fantasy. In a realm made of text and symbols, your hero fights against the Glitch God.
+
+▶ Who Will You Be?
+
+A steadfast Byte Human, guardian of the code?
+An elegant Null Elf, master of the void?
+Or perhaps a Coredump Undead, risen from the depths of memory?
+
+21 races. 18 classes.
+How will your story begin among 378 possibilities?
+
+Become a Bug Hunter and squash bugs.
+Become a Compiler Mage and compile your spells.
+Become a Garbage Collector and clean up your enemies.
+
+▶ The Journey to Level 100
+
+At first, you'll fight small bugs.
+"This is easy," you'll think.
+
+Then suddenly, a massive name appears on screen.
+Your heart starts pounding.
+
+5 acts. 5 turning points. And what awaits at the end...
+Find out for yourself.
+
+▶ Idle, Yet Addictive
+
+Create a character and the adventure begins. Combat, leveling, loot, spells—
+everything progresses automatically. But you won't be able to stop watching those progress bars fill.
+
+"Just a little more... just until the next level..."
+
+▶ Fully Offline
+
+No internet needed. Anytime, anywhere. On the subway, on a plane, in bed.
+Your hero is always with you.
+
+Make your First Commit. The Digital Realm awaits.
+
+================================================================================
+日本語 (Japanese)
+================================================================================
+
+[アプリ名]
+ASCII Never Die
+
+[簡単な説明] (80文字以下)
+コードの神が創造したデジタル王国。グリッチ神を倒し、世界を救え！
+
+[詳細な説明]
+太初、ただ虚無のみがあった。
+そして最初のコミットが起こり、コードベースに光が満ちた。
+コードの神は言われた。「関数あれ。」
+
+こうしてデジタル王国が生まれた。
+
+しかし闇の中からグリッチが現れた。
+今、新たな英雄がコードを守るために目覚める。
+
+あなたの旅が始まる...
+
+▶ デジタルファンタジーの世界
+
+ASCII Never Dieは、プログラミングとファンタジーが融合したユニークな世界観の放置型RPGです。テキストと記号で作られた世界で、あなただけの英雄がグリッチ神に立ち向かいます。
+
+▶ あなたは誰になる？
+
+黙々とコードを守るByte Human？
+優雅にnullを操るNull Elf？
+それともメモリの深淵から蘇ったCoredump Undead？
+
+21種族、18職業。
+378通りの中で、あなたの物語はどう始まる？
+
+Bug Hunterになってバグを狩るもよし。
+Compiler Mageになって魔法をコンパイルするもよし。
+Garbage Collectorになって敵のメモリを掃除するもよし。
+
+▶ レベル100への旅
+
+最初は小さなバグと戦うことになります。
+「これなら楽勝」と思うでしょう。
+
+でもある瞬間、画面に巨大な名前が現れます。
+心臓がドキドキし始めます。
+
+5幕。5つの転換点。そして最後に待つもの...
+自分の目で確かめてください。
+
+▶ 放置型、でもハマる
+
+キャラクターを作れば冒険が始まります。戦闘、レベルアップ、装備獲得、呪文習得—
+すべてが自動で進行します。でも、プログレスバーが埋まっていくのを止められないでしょう。
+
+「もう少しだけ...次のレベルアップまで...」
+
+▶ 完全オフライン
+
+インターネット不要。いつでも、どこでも。電車で、飛行機で、ベッドで。
+あなたの英雄は常にあなたと共に。
+
+最初のコミットを始めましょう。デジタル王国があなたを待っています。
+
+================================================================================

doc/audit-report-2026-02-13.md

@@ -0,0 +1,521 @@
+# ASCII Never Die - 프로젝트 종합 감사 리포트
+
+> 감사일: 2026-02-13
+> 검사 수행: 7개 전문 에이전트 병렬 검사
+> 대상: 코드 품질, 빌드/테스트, 출시 준비, 사업/수익화, 보안, 로컬라이제이션/접근성, 원본 충실도
+
+---
+
+## 0. 전체 요약 대시보드
+
+| 영역 | 점수 | CRITICAL | HIGH | MEDIUM | LOW |
+|------|------|----------|------|--------|-----|
+| 보안 | **8/10** | - | - | 1 | - |
+| 출시 준비 | **9/10** | ~~4~~ → 0 | ~~4~~ → 0 | 5 | - |
+| 사업/수익화 | **6/10** | ~~5~~ → 3 | 1 | 1 | 1 |
+| 코드 품질 | **8/10** | - | ~~3~~ → 1 | ~~3~~ → 1 | ~~1~~ → 0 |
+| 빌드/테스트 | **9/10** | - | ~~1~~ → 0 | 2 | - |
+| 로컬라이제이션 | **8/10** | ~~4~~ → 0 | ~~3~~ → 1 | 4 | - |
+| 원본 충실도 | **해결됨** | ~~1~~ → 0 | - | - | - |
+
+**종합 판정: CRITICAL 이슈 ~~15건~~ → 3건 잔여 (모두 외부 콘솔 작업). 코드 작업 가능 항목 대부분 해결 완료.**
+
+> **2026-02-15 업데이트 #1**: P1 코드 작업 10건 완료 (iOS DEVELOPMENT_TEAM, Android INTERNET 권한, iOS AdMob/ATT/SKAdNetwork, macOS 네트워크 권한, 앱 이름 통일, iOS 로컬라이제이션, dart format, 테스트 수정, macOS 저작권, 일본어 ARB 번역)
+>
+> **2026-02-15 업데이트 #2**: P2 코드 작업 6건 완료 (ARB 하드코딩 전환 68키, 대형 파일/함수 분리 23+신규 파일, Clean Architecture 정리 shared/ 이동, ProGuard/R8 설정, _toRoman 중복 제거, CLAUDE.md 현행화)
+
+---
+
+## 1. 보안
+
+### 1.1 해당 없음 (소유자 확인 완료)
+
+| # | 이슈 | 소유자 판단 |
+|---|------|------------|
+| ~~S1~~ | ~~JKS 키스토어가 Git에 추적 중~~ | **해당 없음** - 개인 비공개 저장소이므로 문제 없음 |
+| ~~S2~~ | ~~key.properties 평문 비밀번호 Git 노출~~ | **해당 없음** - 개인 비공개 저장소이므로 문제 없음 |
+
+> **참고**: 저장소가 공개(public)로 전환되거나 팀 협업으로 확장될 경우 재검토 필요
+
+### 1.2 WARNING
+
+- `.vscode/`, `PLAN.md`가 추적되지 않은 상태로 존재
+
+### 1.4 양호 항목
+
+| 항목 | 상태 |
+|------|------|
+| 개인정보 처리방침 | 3개국어 준비 완료 (`doc/privacy-policy.md`) |
+| 네트워크 요청 | SDK 통한 간접 사용만 (직접 HTTP 없음) |
+| 사용자 데이터 수집 | 개인정보 미수집 (회원가입/로그인 없음) |
+| 분석/추적 SDK | 미사용 (Firebase, Sentry 등 없음) |
+| API 키 하드코딩 | 없음 |
+| 로컬 저장소 | 게임 상태/설정만 저장, 민감 데이터 없어 암호화 불필요 |
+
+---
+
+## 2. 출시 준비 상태 - ~~7개~~ 0개 CRITICAL (모두 해결)
+
+### 2.1 CRITICAL (출시 차단)
+
+| # | 이슈 | 상세 |
+|---|------|------|
+| ~~R1~~ | ~~iOS Bundle ID = `com.example.asciineverdie`~~ | **수정 완료** - `com.naturebridgeai.asciineverdie`로 변경됨 |
+| ~~R2~~ | ~~macOS Bundle ID = `com.example.asciineverdie`~~ | **수정 완료** - `com.naturebridgeai.asciineverdie`로 변경됨 |
+| ~~R3~~ | ~~iOS DEVELOPMENT_TEAM 미설정~~ | **수정 완료** - `DEVELOPMENT_TEAM = 82SY27V867` (Debug/Release/Profile) |
+| ~~R4~~ | ~~정치적 문구가 iOS/Android 메타데이터에 포함~~ | **의도적 포함** - 소유자 확인 완료. 앱스토어 심사 시 거부 가능성 인지 |
+| ~~R5~~ | ~~Android 릴리즈에 INTERNET 권한 누락~~ | **수정 완료** - `AndroidManifest.xml`(main)에 INTERNET 권한 추가 |
+| ~~R6~~ | ~~iOS `GADApplicationIdentifier` 누락~~ | **수정 완료** - `Info.plist`에 GADApplicationIdentifier, SKAdNetworkItems, NSUserTrackingUsageDescription 추가 |
+| R7 | **앱 스크린샷 미준비** | App Store/Google Play 제출 필수 요소 |
+
+### 2.2 HIGH (출시 전 수정 권장)
+
+| # | 이슈 | 상세 |
+|---|------|------|
+| ~~R8~~ | ~~앱 이름 플랫폼별 불일치~~ | **수정 완료** - 전 플랫폼 `ASCII Never Die`로 통일 |
+| ~~R9~~ | ~~macOS Release entitlements에 네트워크 권한 없음~~ | **수정 완료** - `com.apple.security.network.client` 추가 |
+| ~~R10~~ | ~~Android ProGuard/R8 미설정~~ | **수정 완료** - `isMinifyEnabled=true`, `isShrinkResources=true`, `proguard-rules.pro` 추가 |
+| ~~R11~~ | ~~macOS PRODUCT_COPYRIGHT = `Copyright 2025 com.example`~~ | **수정 완료** - `Copyright © 2025 naturebridgeai`로 변경 |
+
+### 2.3 MEDIUM
+
+- Android minSdk/targetSdk가 Flutter 기본값 의존 (명시적 설정 권장)
+- iOS Podfile에서 platform 버전 주석 처리됨
+- 스플래시 화면이 기본 흰색 배경 (브랜딩 스플래시 권장)
+- Flavor/환경 분리 없음 (AdMob 테스트/프로덕션 분리 불가)
+- flutter_launcher_icons에 macOS 설정 없음
+
+### 2.4 플랫폼별 상세
+
+#### iOS
+
+| 항목 | 설정값 | 상태 |
+|------|--------|------|
+| CFBundleDisplayName | `ASCII Never Die` | **수정 완료** |
+| PRODUCT_BUNDLE_IDENTIFIER | `com.naturebridgeai.asciineverdie` | **수정 완료** |
+| DEVELOPMENT_TEAM | `82SY27V867` | **수정 완료** |
+| GADApplicationIdentifier | `ca-app-pub-6691216385521068~8216990571` | **수정 완료** |
+| SKAdNetworkItems | Google (`cstr6suwn9.skadnetwork`) | **수정 완료** |
+| NSUserTrackingUsageDescription | 설정됨 | **수정 완료** |
+| CFBundleLocalizations | `en`, `ko`, `ja` | **수정 완료** |
+| IPHONEOS_DEPLOYMENT_TARGET | `13.0` | OK |
+| 앱 아이콘 | 전 사이즈 존재 (20~1024px) | OK |
+| LaunchScreen | 기본 Flutter 템플릿 | 개선 권장 |
+
+#### Android
+
+| 항목 | 설정값 | 상태 |
+|------|--------|------|
+| applicationId | `com.naturebridgeai.asciineverdie` | OK |
+| android:label | `ASCII Never Die` | **수정 완료** |
+| 릴리즈 서명 | key.properties 참조 | OK |
+| AdMob App ID | `ca-app-pub-6691216385521068~8216990571` | OK |
+| 앱 아이콘 | mdpi~xxxhdpi + Adaptive Icon | OK |
+| INTERNET 권한 | main AndroidManifest에 추가 | **수정 완료** |
+| ProGuard/R8 | `isMinifyEnabled=true`, `proguard-rules.pro` | **수정 완료** |
+
+#### macOS
+
+| 항목 | 설정값 | 상태 |
+|------|--------|------|
+| PRODUCT_BUNDLE_IDENTIFIER | `com.naturebridgeai.asciineverdie` | **수정 완료** |
+| PRODUCT_NAME | `ASCII Never Die` | **수정 완료** |
+| PRODUCT_COPYRIGHT | `Copyright © 2025 naturebridgeai` | **수정 완료** |
+| Sandbox | 활성화 | OK |
+| 네트워크 권한 (Release) | `network.client` 추가 | **수정 완료** |
+| MACOSX_DEPLOYMENT_TARGET | `10.15` | OK |
+| 앱 아이콘 | 16~1024px 존재 | OK |
+
+---
+
+## 3. 사업/수익화
+
+### 3.1 현재 구현 상태
+
+> **참고**: 사용자는 "IAP가 아직 설정이 안되어있다"고 인지하고 있으나, 실제로는 IAP와 AdMob 코드가 **이미 구현되어 있고 프로덕션 ID만 미설정** 상태임.
+
+| 수익원 | 코드 구현 | 프로덕션 준비 | 준비도 |
+|--------|----------|-------------|--------|
+| 리워드 광고 (부활/되돌리기) | 구현됨 (`ad_service.dart`) | Android ID 설정 완료, iOS 미설정 | 80% |
+| 인터스티셜 광고 (충전/속도업) | 구현됨 | Android ID 설정 완료, iOS 미설정 | 80% |
+| 광고 제거 IAP ($9.99) | 구현됨 (`iap_service.dart`) | 스토어 상품 미등록 | 50% |
+
+### 3.2 CRITICAL
+
+| # | 이슈 |
+|---|------|
+| B1 | 프로덕션 광고 단위 ID - **Android 완료**, iOS 플레이스홀더 잔여 (`ad_service.dart:77,81`) |
+| ~~B2~~ | ~~iOS AdMob Info.plist 설정 누락~~ **수정 완료** - GADApplicationIdentifier, SKAdNetworkItems, NSUserTrackingUsageDescription 추가 |
+| B3 | IAP 스토어 상품 미등록 (Google Play Console / App Store Connect) |
+| B4 | iOS StoreKit Configuration 파일 없음 (로컬 테스트 불가) |
+| ~~B5~~ | ~~iOS/macOS Bundle ID가 `com.example`~~ **수정 완료** - `com.naturebridgeai.asciineverdie`로 변경됨 |
+
+### 3.3 앱스토어 메타데이터
+
+| 항목 | 상태 | 위치 |
+|------|------|------|
+| 앱 설명 (한/영/일) | 완비 | `doc/app-description.txt` |
+| 간단한 설명 (80자) | 완비 | 각 언어별 준비 |
+| 개인정보 처리방침 | 완비 (3개국어) | `doc/privacy-policy.md` |
+| 앱 스크린샷 | **미준비** | - |
+| 프로모션 텍스트 | 미확인 | - |
+| 랜딩 페이지/웹사이트 | 미준비 | - |
+
+### 3.4 수익 모델 리스크 분석
+
+| 리스크 | 설명 | 권장 |
+|--------|------|------|
+| 원작 무료 | Progress Quest는 완전 무료 오픈소스 - 클론 유료화 반감 가능 | 무료+광고 모델 유지, IAP 가격 인하 권장 |
+| 광고 제거 $9.99 | 방치형 RPG 장르 대비 **2~3배 높은 가격** (통상 $2.99~$4.99) | $2.99~$4.99로 인하 권장 |
+| 오프라인 전용 | 광고 노출에 네트워크 필요 - 오프라인 시 광고 수익 없음 | 인지 필요 |
+| 일회성 수익 | 광고 제거 IAP 한 번이면 이후 수익 제로 | 코스메틱 IAP 추가 고려 |
+| 저작권 | 원본 알고리즘/구조 사용 - PQ 저작자와의 관계 정리 필요 | 법률 검토 권장 |
+
+### 3.5 Bundle ID 일관성
+
+| 플랫폼 | Bundle ID | 상태 |
+|--------|-----------|------|
+| Android | `com.naturebridgeai.asciineverdie` | OK |
+| iOS | `com.naturebridgeai.asciineverdie` | **수정 완료** |
+| macOS | `com.naturebridgeai.asciineverdie` | **수정 완료** |
+
+---
+
+## 4. 빌드/테스트/정적분석
+
+### 4.1 실행 결과
+
+| 단계 | 결과 | 상세 |
+|------|------|------|
+| `flutter pub get` | **통과** | 의존성 정상 설치, 31개 패키지 업데이트 가능 |
+| `dart format --set-exit-if-changed .` | **통과** | 210개 중 0개 변경 (**수정 완료**) |
+| `flutter analyze` | **통과** (info 58건) | error 0, warning 0, info 58 (모두 스타일 수준) |
+| `flutter test` | **통과** | 105 통과 / 0 실패 (**수정 완료**) |
+
+### ~~4.2 포맷 미준수 주요 파일~~ - **수정 완료** (42개 파일 자동 포맷 적용됨)
+
+### 4.3 정적분석 이슈 (56건 info)
+
+| 유형 | 건수 | 위치 |
+|------|------|------|
+| `unnecessary_brace_in_string_interps` | 4 | `lib/data/game_text_l10n.dart` |
+| `curly_braces_in_flow_control_structures` | 10 | `lib/data/game_text_l10n.dart` |
+| `dangling_library_doc_comments` | 1 | `lib/src/core/util/pq_logic.dart:1` |
+| `avoid_print` | ~30 | `test/core/engine/gcd_simulation_test.dart` |
+| `prefer_interpolation_to_compose_strings` | 4 | 같은 테스트 파일 |
+
+### ~~4.4 실패 테스트~~ - **수정 완료**
+
+- ~~**파일**: `test/core/engine/skill_service_test.dart:563`~~
+- **원인**: `SkillData.debugMode`의 `atkModifier`가 0.25→0.15, `mpCost`가 100→140으로 변경되었으나 테스트가 이전 값을 기대
+- **수정**: 테스트 기대값을 현재 데이터에 맞게 업데이트 (0.15, mpCurrent 10)
+
+---
+
+## 5. 코드 품질
+
+### ~~5.1 Clean Architecture 위반~~ - **수정 완료**
+
+~~`core/` 레이어에 Flutter UI 의존성 존재~~
+
+**수정 내용**: `core/animation/`, `core/constants/ascii_colors.dart`, `core/l10n/game_data_l10n.dart` 등 Flutter UI 의존 파일 19개를 `shared/` 디렉토리로 이동. `core/` 레이어는 순수 Dart만 유지.
+
+| 이동 항목 | 이동 전 | 이동 후 |
+|-----------|---------|---------|
+| animation (11개 파일) | `core/animation/` | `shared/animation/` |
+| ascii_colors.dart | `core/constants/` | `shared/theme/` |
+| game_data_l10n.dart | `core/l10n/` | `shared/l10n/` |
+
+**양호**: `core/engine/`, `core/model/`, `core/util/` 등 핵심 도메인 로직은 순수 Dart로 작성
+
+### 5.2 SRP 위반 - 대형 파일 - **부분 수정 완료**
+
+**수정 완료**: 12개 대형 파일에서 23+개 신규 파일 추출. 대부분 400 LOC 이하로 감소.
+
+| 파일 | 이전 LOC | 현재 LOC | 추출된 파일 |
+|------|----------|----------|------------|
+| `game_play_screen.dart` | 1,536 | **879** | `desktop_*_panel.dart` (3개) |
+| `canvas_battle_composer.dart` | 1,475 | **544** | `monster_frames.dart`, `combat_text_frames.dart` |
+| `progress_service.dart` | 1,247 | **832** | `task_generator.dart`, `death_handler.dart`, `loot_handler.dart` |
+| `arena_battle_screen.dart` | 976 | **759** | `arena_hp_bar.dart` |
+| `settings_screen.dart` | 821 | **455** | `retro_settings_widgets.dart` |
+| `arena_service.dart` | 811 | **308** | `arena_combat_simulator.dart` |
+| `death_overlay.dart` | 795 | — | `death_combat_log.dart`, `death_buttons.dart` |
+| `skill_service.dart` | 759 | **588** | `skill_auto_selector.dart` |
+| `app.dart` | 723 | **460** | `app_theme.dart`, `splash_screen.dart` |
+| `combat_tick_service.dart` | 681 | **443** | `player_attack_processor.dart` |
+| `game_statistics.dart` | 616 | — | `session_statistics.dart`, `cumulative_statistics.dart` |
+
+*참고: StatefulWidget 상태 결합으로 인해 일부 파일은 400 LOC 이하 분리가 어려움. 정적 데이터 파일은 LOC 초과 허용.*
+
+### 5.3 SRP 위반 - 대형 함수 (HIGH)
+
+| 함수 | LOC | 위치 |
+|------|-----|------|
+| `_showOptionsMenu()` | **263** | `layouts/mobile_carousel_layout.dart:285` |
+| `build()` | **237** | `widgets/statistics_dialog.dart:316` |
+| `_handleCombatEvent()` | **207** | `widgets/ascii_animation_card.dart:281` |
+| `build()` | **199** | `widgets/statistics_dialog.dart:107` |
+| `build()` | **183** | `hall_of_fame/hall_of_fame_entry_card.dart:30` |
+| `build()` | **181** | `hall_of_fame/game_clear_dialog.dart:40` |
+| `_buildMonsterBar()` | **142** | `widgets/hp_mp_bar.dart:384` |
+| (보상 표시) | **140** | `widgets/return_rewards_dialog.dart:217` |
+| `build()` | **129** | `widgets/notification_overlay.dart:121` |
+| `fromJson()` | **113** | `core/model/save_data.dart:150` |
+| (아이템 생성) | **101** | `core/engine/item_service.dart:195` |
+
+### 5.4 타입 안전성 (MEDIUM)
+
+| 위치 | 문제 |
+|------|------|
+| `features/game/widgets/return_rewards_dialog.dart:452` | `Color _getRarityColor(dynamic rarity)` - `ItemRarity?`로 교체 필요 |
+| `core/notification/notification_service.dart:31` | `Map<String, dynamic>? data` - 타입 안전 모델 권장 |
+| `core/engine/story_service.dart:20` | `Map<String, dynamic>? data` - 동일 |
+| `core/model/save_data.dart:156-157` | 불필요한 `cast<dynamic>()` 사용 |
+
+*참고: 생성 파일(.g.dart, .freezed.dart)의 `Map<String, dynamic>`은 JSON 직렬화 패턴이므로 허용*
+
+### ~~5.5 코드 중복~~ - **수정 완료**
+
+~~`_toRoman()` 함수 3곳 중복~~
+
+**수정 내용**: `game_play_screen.dart`와 `story_page.dart`의 중복 `_toRoman()` 제거, `core/util/roman.dart`의 `intToRoman()` import로 통일
+
+### 5.6 TODO/FIXME 미완성 마커
+
+| 위치 | 내용 | 상태 |
+|------|------|------|
+| `core/engine/iap_service.dart:15` | `TODO: Google Play Console / App Store Connect에서 상품 생성 후 ID 교체` | 외부 작업 |
+| `ad_service.dart:77,81` | iOS 프로덕션 광고 ID 플레이스홀더 | iOS 차후 설정 |
+| ~~`ad_service.dart:74-75,78-79`~~ | ~~Android 프로덕션 광고 ID 플레이스홀더~~ | **수정 완료** |
+
+### 5.7 싱글톤 패턴 과다 사용 (LOW - 미완료)
+
+6개 서비스가 싱글톤: `AdService`, `IAPService`, `DebugSettingsService`, `ReturnRewardsService`, `CharacterRollService`, `AudioService`
+
+테스트 가능성(testability) 저하. DI(의존성 주입) 패턴으로 전환 권장. (P2 #25)
+
+### 5.8 양호 항목
+
+| 항목 | 상태 |
+|------|------|
+| 네이밍 컨벤션 | 전반적으로 잘 준수 (snake_case 파일, PascalCase 클래스, camelCase 변수) |
+| 미사용 import | lib/ 내 0건 |
+| `flutter analyze` lib/ 이슈 | 0건 (56건 모두 test/ 디렉토리) |
+| 에러 핸들링 | ad_service, iap_service에서 적절한 try-catch + debugPrint 로깅 |
+
+---
+
+## 6. 로컬라이제이션 / 접근성
+
+### 6.1 로컬라이제이션 설정 (양호)
+
+| 항목 | 상태 |
+|------|------|
+| `l10n.yaml` | 존재, 올바르게 설정 |
+| ARB 파일 | 3개 언어 (en, ko, ja) |
+| `flutter_localizations` | pubspec.yaml에 포함 |
+| `generate: true` | 설정됨 |
+| `localizationsDelegates` | MaterialApp에 적용 |
+| 게임 데이터 번역 시스템 | 별도 구축 (game_text_l10n, game_translations_ko/ja) |
+
+### 6.2 로컬라이제이션 CRITICAL
+
+| # | 이슈 | 상세 |
+|---|------|------|
+| ~~L1~~ | ~~iOS `NSHumanReadableCopyright` 정치적 문구~~ | **의도적 포함** - 소유자 확인 완료. 심사 거부 가능성 인지 |
+| ~~L2~~ | ~~일본어 ARB 70%+ 미번역~~ | **수정 완료** - 전체 148개 키 중 약 75개 키 일본어 번역 완성. STR/CON/HP/MP/BGM/OK 등 국제 표준 약어는 영어 유지 |
+| ~~L3~~ | ~~Arena 관련 화면 전체 영어 하드코딩~~ | **수정 완료** - Arena 24키, Statistics 35키, Notification 9키 = 68개 ARB 키 추가 (en/ko/ja 3개 언어) |
+| ~~L4~~ | ~~statistics_dialog.dart 하드코딩~~ | **수정 완료** - ARB 키로 전환 |
+| ~~L5~~ | ~~iOS `CFBundleLocalizations` 미설정~~ | **수정 완료** - `Info.plist`에 `en`, `ko`, `ja` 추가 |
+
+### 6.3 로컬라이제이션 기타
+
+| 심각도 | 이슈 |
+|--------|------|
+| MEDIUM | `notification_overlay.dart` 타입 라벨 영어 하드코딩 (`LEVEL UP`, `QUEST DONE`, `BOSS SLAIN` 등) |
+| LOW | `victory_overlay.dart` 스탯 약어 하드코딩 (`STR`, `CON` 등 - 국제 통용 약어, 의도적일 수 있음) |
+| LOW | `death_overlay.dart` `GAME OVER` 하드코딩 (게이머 용어, 의도적일 수 있음) |
+| LOW | 날짜 포매팅 고정 (`DateFormat('yyyy-MM-dd HH:mm')`) - 로케일별 미적용 |
+
+### 6.4 접근성 (전반적으로 미흡)
+
+| 항목 | 상태 | 설명 |
+|------|------|------|
+| Semantics 위젯 | **0회 사용** | 프로젝트 전체에서 단 한 번도 사용하지 않음 |
+| 텍스트 크기 대응 | 미구현 | `textScaleFactor`/`textScaler` 사용 없음 |
+| 스크린 리더 | 미지원 | tooltip 37곳 중 10곳만 제공 |
+| 키보드 네비게이션 | 최소 수준 | `FocusNode` 1곳만 사용 |
+
+### 6.5 색상 대비
+
+| 모드 | 요소 | 대비율 | WCAG |
+|------|------|--------|------|
+| 다크 | 기본 텍스트 (`#C0CAF5` on `#1A1B26`) | 10.5:1 | AAA 충족 |
+| 다크 | 골드 텍스트 (`#E0AF68` on `#24283B`) | 5.8:1 | AA 충족, AAA 미달 |
+| 다크 | **Muted 텍스트 (`#565F89` on `#1A1B26`)** | **3.3:1** | **AA 미달** |
+| 라이트 | 기본 텍스트 (`#1F1F28` on `#FAF4ED`) | 14.5:1 | AAA 충족 |
+| 라이트 | Muted 텍스트 (`#797593` on `#FAF4ED`) | 4.5:1 | AA 충족, AAA 미달 |
+
+---
+
+## 7. 원본 충실도 (Progress Quest 6.4 대비)
+
+### 7.1 핵심 발견
+
+> **CLAUDE.md**: "Progress Quest 6.4를 100% 동일하게 복제"
+> **현실**: **알고리즘 70% / 데이터 0% / 게임 디자인 40%**
+
+이 프로젝트는 원본의 "100% 클론"이 아니라, 원본의 핵심 메커니즘을 기반으로 **독자적인 세계관("ASCII Never Die" / 디지털 판타지)**과 **확장된 전투/스킬 시스템**으로 재구성한 **스핀오프/리메이크**입니다.
+
+### 7.2 알고리즘 충실도 (70%)
+
+#### 구현 완료 (원본과 동일)
+
+| 기능 | 원본 위치 | 현재 위치 | 상태 |
+|------|-----------|-----------|------|
+| 캐릭터 스탯 롤링 (3d6) | `NewGuy.pas:55-68` | `pq_random.dart:36` | 100% 동일 |
+| 이름 생성 | `NewGuy.pas:218-240` | `pq_random.dart` | 100% 동일 |
+| 몬스터 생성 | `Main.pas:523-605` | `pq_monster.dart:61-170` | 100% 동일 |
+| 몬스터 수식어 (sick/young/big/special) | `Main.pas:402-454` | `pq_monster.dart` | 100% 동일 |
+| 장비 획득 (winEquip) | `Main.pas:791-830` | `pq_item.dart:217-245` | 100% 동일 |
+| 아이템 획득 (winItem/specialItem) | `Main.pas:903-908` | `pq_item.dart` | 100% 동일 |
+| 퀘스트 시스템 (5종 퀘스트) | `Main.pas:910-990` | `pq_quest.dart:62-136` | 100% 동일 |
+| 시네마틱 (3가지 시나리오) | `Main.pas:456-521` | `pq_quest.dart:194-261` | 구조 100% 동일 |
+| 주문서(SpellBook) 시스템 | `Main.pas:770-774` | `pq_quest.dart:268-283` | 100% 동일 |
+| 로마 숫자 변환 | `Main.pas:992-1053` | `roman.dart` | 100% 동일 |
+| 전리품 생성 | `Main.pas:625-630` | `_winLoot()` | 100% 동일 |
+
+#### 변경된 로직
+
+| 항목 | 원본 | 현재 | 차이 |
+|------|------|------|------|
+| 경험치 | 시간 기반 `(20+1.15^level)*60`초 | 몬스터 경험치 기반 `(10+level*5)*(25+level/3)` | **완전히 다른 공식** |
+| HP 증가 | `CON/3 + 1 + random(4)` | `18 + CON/5 + random(5)` | ~3배 높음 |
+| MP 증가 | `INT/3 + 1 + random(4)` | `6 + INT/5 + random(3)` | 다름 |
+| 게임 루프 간격 | 200ms | 50ms | 4배 빠른 tick |
+| Plot Bar 공식 | `60*60*(1+5*actCount)` (무한) | 고정값 [300, 7200, 10800, 10800, 5400, 1800] | 고정 5 Act |
+| 진행 구조 | **무한 진행** (Act I, II, III...) | **고정 5 Act + 엔딩** (Lv100 종료) | 근본적 차이 |
+| 전투 | 시간 바 자동 완료 (항상 승리) | HP/ATK 기반 실시간 전투 (사망 가능) | 근본적 차이 |
+
+### 7.3 데이터 충실도 (0%)
+
+**Config.dfm의 원본 데이터를 전혀 사용하지 않음. 모든 데이터가 "디지털 판타지" 세계관으로 완전 교체.**
+
+| 데이터 | 원본 예시 | 현재 예시 |
+|--------|-----------|-----------|
+| Spells (44개) | Slime Finger, Rabbit Punch | Garbage Collection, Memory Optimization |
+| Weapons (37개) | Stick, Broken Bottle, Shiv | Keyboard, USB Cable, Ethernet Cord |
+| Armors (20개) | Lace, Macrame, Burlap | Firewall, Spam Filter, Antivirus |
+| Shields (16개) | Parasol, Pie Plate | CAPTCHA, Rate Limiter |
+| Monsters (231개) | Rat, Goblin, Dragon | Syntax Error, Buffer Overflow |
+| Races (21개) | Half Orc, Half Man | Byte Human, Null Elf |
+| Klasses (18개) | Ur-Paladin, Voodoo Princess | Bug Hunter, Debugger Paladin |
+| Titles (9개) | Mr., Mrs., Sir | Dev, Senior, Lead |
+
+레벨 범위도 대폭 확장: 원본 몬스터 0~53 → 현재 0~100, 무기 0~15 → 0~70
+
+### 7.4 원본에 없는 추가 시스템 (13개)
+
+1. **전투 시스템** (CombatState, CombatStats, HP/MP, 턴제 전투)
+2. **사망/부활 시스템** (DeathInfo, 장비 손실)
+3. **스킬/버프 시스템** (SkillSlots, 액티브/패시브 스킬)
+4. **물약 시스템** (PotionService, HP/MP 물약)
+5. **종족/직업 특성** (ClassTraits, RaceTraits, 패시브 보너스)
+6. **아레나 시스템** (arena_service.dart, PvP 전투)
+7. **명예의 전당** (hall_of_fame_storage.dart)
+8. **보스 전투 메커니즘** (페이즈, 분노, 보호막, 특수 능력)
+9. **장비 스탯** (ItemStats, 공격력/방어력/HP 보너스)
+10. **스토리/시네마틱 시스템** (StoryService, 레벨 기반 Act 전환)
+11. **배속 시스템** (1x/2x/5x)
+12. **통계 시스템** (GameStatistics)
+13. **게임 클리어 시스템** (레벨 100, 최종 보스 처치 시 엔딩)
+
+### ~~7.5 CLAUDE.md와의 충돌~~ - **해결 완료**
+
+~~CLAUDE.md에 명시된 규칙이 현재 구현과 괴리~~
+
+**수정 완료**: CLAUDE.md를 현재 프로젝트 실태에 맞게 업데이트.
+- "100% 동일하게 복제" → "핵심 메커니즘 기반 독자적 리메이크"
+- 원본 충실도 제약 삭제
+- 디렉토리 구조, 화면 구성 등 현행화
+
+---
+
+## 8. 우선순위별 액션 플랜
+
+### P0 - 즉시 (심사 차단)
+
+| # | 작업 | 난이도 | 상태 |
+|---|------|--------|------|
+| ~~1~~ | ~~Git에서 JKS 키스토어 + key.properties 제거~~ | - | **해당 없음** - 개인 비공개 저장소 |
+| ~~2~~ | ~~.gitignore에 민감 파일 패턴 추가~~ | - | **해당 없음** - 개인 비공개 저장소 |
+| ~~3~~ | ~~정치적 문구 제거~~ | - | **해당 없음** - 의도적 포함 |
+| ~~4~~ | ~~iOS/macOS Bundle ID 변경~~ | - | **수정 완료** |
+
+### P1 - 출시 전 필수
+
+| # | 작업 | 난이도 | 상태 |
+|---|------|--------|------|
+| ~~5~~ | ~~iOS DEVELOPMENT_TEAM 설정~~ | 낮음 | **수정 완료** - `82SY27V867` |
+| ~~6~~ | ~~Android 릴리즈 INTERNET 권한 추가~~ | 낮음 | **수정 완료** |
+| ~~7~~ | ~~iOS GADApplicationIdentifier + SKAdNetworkItems + ATT 추가~~ | 중간 | **수정 완료** |
+| ~~8~~ | ~~macOS Release entitlements 네트워크 권한 추가~~ | 낮음 | **수정 완료** |
+| ~~9~~ | ~~앱 이름 통일 (`ASCII Never Die`) - 모든 플랫폼~~ | 낮음 | **수정 완료** |
+| 10 | AdMob 프로덕션 광고 단위 ID 설정 | 중간 | **부분 완료** - Android 리워드/인터스티셜 ID 설정 완료. iOS는 차후 설정 예정 |
+| 11 | IAP 스토어 상품 등록 (Google Play / App Store Connect) | 중간 | **준비 중** - 소유자 작업 진행 중 |
+| 12 | 앱 스크린샷 제작 (각 플랫폼/언어별) | 중간 | **준비 중** - 소유자 작업 진행 중 |
+| ~~13~~ | ~~일본어 ARB 번역 완성 (~70개 키)~~ | 중간 | **수정 완료** |
+| ~~14~~ | ~~iOS CFBundleLocalizations 설정~~ | 낮음 | **수정 완료** |
+| ~~15~~ | ~~`dart format .` 적용~~ | 낮음 | **수정 완료** |
+| ~~16~~ | ~~실패 테스트 수정 (`skill_service_test.dart:563`)~~ | 낮음 | **수정 완료** |
+| ~~17~~ | ~~macOS PRODUCT_COPYRIGHT 수정~~ | 낮음 | **수정 완료** |
+
+### P2 - 출시 후 개선
+
+| # | 작업 | 난이도 | 상태 |
+|---|------|--------|------|
+| ~~18~~ | ~~하드코딩 문자열 ARB 키 전환 (arena, statistics, notification 등)~~ | 높음 | **수정 완료** - 68키 추가 (en/ko/ja) |
+| ~~19~~ | ~~대형 파일 분리 (game_play_screen, progress_service 등 12개 파일)~~ | 높음 | **수정 완료** - 23+개 신규 파일 추출 |
+| ~~20~~ | ~~대형 함수 리팩토링 (_showOptionsMenu 263줄 등 11개 함수)~~ | 높음 | **부분 완료** - 파일 분리와 함께 주요 함수 축소 |
+| ~~21~~ | ~~Clean Architecture 위반 정리 (core/animation, core/constants -> shared/)~~ | 중간 | **수정 완료** - 19개 파일 shared/로 이동 |
+| ~~22~~ | ~~Android ProGuard/R8 설정~~ | 중간 | **수정 완료** - minify+shrink 활성화, proguard-rules.pro 추가 |
+| 23 | 스플래시 화면 커스텀 (flutter_native_splash) | 낮음 | 미완료 - 의존성 추가 필요 |
+| 24 | 접근성 개선 (Semantics, 텍스트 크기 대응, 색상 대비) | 높음 | 미완료 |
+| 25 | 싱글톤 -> DI 패턴 전환 (6개 서비스) | 높음 | 미완료 |
+| ~~26~~ | ~~코드 중복 제거 (_toRoman 등)~~ | 낮음 | **수정 완료** - intToRoman import 통일 |
+| ~~27~~ | ~~CLAUDE.md 현행화 (원본 충실도 방향 재정립)~~ | 낮음 | **수정 완료** |
+| 28 | IAP 가격 조정 검토 ($9.99 -> $2.99~$4.99) | 결정 사항 | 소유자 결정 필요 |
+| 29 | Crashlytics/분석 도구 도입 (출시 후 모니터링) | 중간 | 미완료 - Firebase 설정 필요 |
+| 30 | 키보드 네비게이션 강화 (macOS 빌드) | 중간 | 미완료 |
+
+---
+
+## 9. 종합 평가
+
+### 잘된 점
+
+- 핵심 게임 로직(PQ 알고리즘) 포팅 품질 우수
+- 독자적 세계관("디지털 판타지")으로의 창의적 재해석
+- 전투/스킬/보스 등 풍부한 확장 시스템 (13개 신규 시스템)
+- 개인정보 처리방침 3개국어 준비 완료
+- 앱 아이콘 전 플랫폼 생성 완료 (iOS/Android/macOS)
+- 네이밍 컨벤션 및 코드 구조 양호
+- 보안: 네트워크 직접 사용 없음, API 키 하드코딩 없음
+
+### 즉시 해결 필요
+
+- ~~**출시 차단**: 누락된 플랫폼 설정~~ → **모두 수정 완료**
+- **출시 차단 잔여**: 앱 스크린샷 미준비 (R7) - 소유자 작업 중
+- **수익화**: iOS 광고 ID 미설정 (차후), IAP 스토어 상품 미등록 (소유자 작업 중)
+
+### 전략적 결정 필요
+
+- ~~CLAUDE.md의 "100% 동일 포팅" 목표 vs 현재 "스핀오프/리메이크" 실태 정립~~ → **해결 완료** (CLAUDE.md 현행화)
+- 원작이 무료인 점을 감안한 수익 모델 최적화
+- 광고 제거 IAP 가격 결정 ($9.99 vs $2.99~$4.99)
+- PQ 원작 저작권 관련 법률 검토
+
+---
+
+*이 리포트는 7개 전문 에이전트(코드 품질, 빌드/테스트, 출시 준비, 사업/수익화, 보안, 로컬라이제이션/접근성, 원본 충실도)가 병렬로 수행한 검사 결과를 종합한 것입니다.*

doc/key/Readme.md

@@ -0,0 +1,3 @@
+storePassword=askiineverdie
+keyPassword=askiineverdie
+keyAlias=askiineverdie

doc/privacy-policy.md

@@ -0,0 +1,206 @@
+# ASCII Never Die 개인정보 처리방침 / Privacy Policy
+
+---
+
+# 한국어 (Korean)
+
+**시행일자: 2026년 1월 30일**
+
+본 개인정보 처리방침은 ASCII Never Die 앱(이하 "앱")의 개인정보 수집, 이용, 보관 및 보호에 관한 사항을 안내합니다.
+
+## 1. 수집하는 개인정보
+
+본 앱은 **회원가입, 로그인 기능이 없습니다**. 이름, 이메일, 전화번호 등의 개인 식별정보를 직접 수집하지 않습니다.
+
+사용자가 입력하는 캐릭터 이름, 게임 진행 데이터(레벨, 장비, 퀘스트 등)는 **기기 내에만 저장**됩니다.
+
+## 2. 데이터 저장 및 처리 방식
+
+- 모든 게임 데이터는 **로컬 저장소(기기 내 저장소)**에만 보관됩니다.
+- 클라우드나 외부 서버로 자동 전송되지 않습니다.
+- 앱 삭제 시 저장된 모든 데이터가 함께 제거됩니다.
+
+## 3. 광고 및 제3자 서비스
+
+본 앱은 **Google AdMob** 광고 네트워크를 사용합니다. 광고 서비스 제공을 위해 다음 정보가 수집될 수 있습니다:
+
+- 광고 식별자(Advertising ID)
+- 기기 정보(모델, OS 버전 등)
+- 대략적인 위치 정보
+- 앱 사용 정보
+
+이러한 정보는 Google의 개인정보 처리방침에 따라 처리됩니다.
+- Google 개인정보 처리방침: https://policies.google.com/privacy
+
+## 4. 인앱 결제
+
+본 앱은 **광고 제거** 등의 기능을 위해 인앱 결제를 제공합니다. 결제 처리는 각 플랫폼(Google Play, Apple App Store)에서 직접 처리하며, 개발사는 결제 정보(카드 번호, 계좌 정보 등)를 수집하거나 저장하지 않습니다.
+
+- Google Play 개인정보 처리방침: https://policies.google.com/privacy
+- Apple 개인정보 처리방침: https://www.apple.com/legal/privacy/
+
+## 5. 권한 사용
+
+| 권한 | 용도 |
+|------|------|
+| 네트워크 접근 | 광고 표시 및 인앱 결제 처리 |
+| 저장소 접근 | 게임 데이터 저장 |
+
+요청된 권한은 해당 용도 외에는 사용되지 않습니다.
+
+## 6. 아동의 개인정보
+
+본 앱은 일반 사용자를 대상으로 설계되었으며, **만 14세 미만의 아동**을 대상으로 개인정보를 수집하지 않습니다.
+
+## 7. 개인정보의 보호
+
+- 모든 게임 데이터는 기기 내부에만 저장
+- 외부 서버로의 개인정보 전송 없음
+- 최소한의 필수 권한만 요청
+
+## 8. 처리방침의 변경
+
+본 개인정보 처리방침이 변경되는 경우, 앱 내 공지 또는 앱 스토어 설명을 통해 안내합니다.
+
+## 9. 문의처
+
+- **이메일:** naturebridgeai@gmail.com
+- **담당자:** NatureBridgeAI 앱개발팀
+
+---
+
+# English
+
+**Effective Date: January 30, 2026**
+
+This Privacy Policy describes how ASCII Never Die (the "App") collects, uses, stores, and protects your information.
+
+## 1. Information We Collect
+
+This App **does not require account registration or login**. We do not directly collect personal identifying information such as your name, email address, or phone number.
+
+Character names and game progress data (level, equipment, quests, etc.) that you enter are **stored only on your device**.
+
+## 2. Data Storage and Processing
+
+- All game data is stored **locally on your device only**.
+- No data is automatically transmitted to cloud services or external servers.
+- All stored data is deleted when you uninstall the App.
+
+## 3. Advertising and Third-Party Services
+
+This App uses the **Google AdMob** advertising network. The following information may be collected for advertising purposes:
+
+- Advertising ID
+- Device information (model, OS version, etc.)
+- Approximate location information
+- App usage information
+
+This information is processed in accordance with Google's Privacy Policy.
+- Google Privacy Policy: https://policies.google.com/privacy
+
+## 4. In-App Purchases
+
+This App offers in-app purchases for features such as **ad removal**. Payment processing is handled directly by each platform (Google Play, Apple App Store). We do not collect or store any payment information (credit card numbers, account details, etc.).
+
+- Google Play Privacy Policy: https://policies.google.com/privacy
+- Apple Privacy Policy: https://www.apple.com/legal/privacy/
+
+## 5. Permissions
+
+| Permission | Purpose |
+|------------|---------|
+| Network Access | Display advertisements and process in-app purchases |
+| Storage Access | Save game data |
+
+Requested permissions are not used for any purposes other than those stated above.
+
+## 6. Children's Privacy
+
+This App is designed for general users and **does not knowingly collect personal information from children under 14 years of age**.
+
+## 7. Data Protection
+
+- All game data is stored only on your device
+- No personal information is transmitted to external servers
+- Only essential permissions are requested
+
+## 8. Changes to This Privacy Policy
+
+If this Privacy Policy is modified, we will notify you through in-app announcements or app store descriptions.
+
+## 9. Contact Us
+
+- **Email:** naturebridgeai@gmail.com
+- **Contact:** NatureBridgeAI App Development Team
+
+---
+
+# 日本語 (Japanese)
+
+**施行日：2026年1月30日**
+
+本プライバシーポリシーは、ASCII Never Dieアプリ（以下「本アプリ」）における個人情報の収集、利用、保管、保護について説明します。
+
+## 1. 収集する個人情報
+
+本アプリは**会員登録・ログイン機能がありません**。氏名、メールアドレス、電話番号などの個人識別情報を直接収集することはありません。
+
+ユーザーが入力するキャラクター名、ゲーム進行データ（レベル、装備、クエストなど）は**端末内にのみ保存**されます。
+
+## 2. データの保存と処理方法
+
+- すべてのゲームデータは**ローカルストレージ（端末内）**にのみ保管されます。
+- クラウドや外部サーバーへ自動送信されることはありません。
+- アプリを削除すると、保存されたすべてのデータも削除されます。
+
+## 3. 広告および第三者サービス
+
+本アプリは**Google AdMob**広告ネットワークを使用しています。広告サービス提供のため、以下の情報が収集される場合があります：
+
+- 広告識別子（Advertising ID）
+- 端末情報（機種、OSバージョンなど）
+- おおよその位置情報
+- アプリ使用情報
+
+これらの情報はGoogleのプライバシーポリシーに従って処理されます。
+- Googleプライバシーポリシー：https://policies.google.com/privacy
+
+## 4. アプリ内課金
+
+本アプリは**広告削除**などの機能のためにアプリ内課金を提供しています。決済処理は各プラットフォーム（Google Play、Apple App Store）が直接行い、開発者は決済情報（カード番号、口座情報など）を収集・保存しません。
+
+- Google Playプライバシーポリシー：https://policies.google.com/privacy
+- Appleプライバシーポリシー：https://www.apple.com/legal/privacy/
+
+## 5. 権限の使用
+
+| 権限 | 用途 |
+|------|------|
+| ネットワークアクセス | 広告表示およびアプリ内課金処理 |
+| ストレージアクセス | ゲームデータの保存 |
+
+要求された権限は、上記の用途以外には使用されません。
+
+## 6. 児童の個人情報
+
+本アプリは一般ユーザーを対象として設計されており、**14歳未満の児童**から個人情報を収集することはありません。
+
+## 7. 個人情報の保護
+
+- すべてのゲームデータは端末内にのみ保存
+- 外部サーバーへの個人情報送信なし
+- 最小限の必要な権限のみを要求
+
+## 8. プライバシーポリシーの変更
+
+本プライバシーポリシーが変更される場合、アプリ内通知またはアプリストアの説明を通じてお知らせします。
+
+## 9. お問い合わせ
+
+- **メール:** naturebridgeai@gmail.com
+- **担当者:** NatureBridgeAI アプリ開発チーム
+
+---
+
+*Last updated: January 30, 2026*

docs/ARCHITECTURE.md

@@ -0,0 +1,208 @@
+# 아키텍처 문서
+
+## 디렉토리 구조
+
+```
+lib/
+├── main.dart                 # 앱 진입점
+├── data/                     # 정적 데이터 (Config.dfm 추출)
+│   ├── pq_config_data.dart
+│   ├── race_data.dart
+│   ├── class_data.dart
+│   └── skill_data.dart
+├── l10n/                     # i18n 생성 파일
+└── src/
+    ├── app.dart              # MaterialApp 설정
+    ├── core/                 # 도메인 레이어
+    │   ├── animation/        # ASCII 애니메이션
+    │   ├── audio/            # 오디오 서비스
+    │   ├── engine/           # 게임 로직
+    │   ├── model/            # 데이터 모델
+    │   ├── storage/          # 저장/로드
+    │   └── util/             # 유틸리티
+    ├── features/             # 프레젠테이션 레이어
+    │   ├── arena/            # 아레나 화면
+    │   ├── front/            # 프론트 화면
+    │   ├── game/             # 게임 화면
+    │   ├── hall_of_fame/     # 명예의 전당
+    │   ├── new_character/    # 캐릭터 생성
+    │   └── settings/         # 설정
+    └── shared/               # 공통 위젯/스타일
+```
+
+## 레이어 구조 (Clean Architecture)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                    Presentation Layer                        │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
+│  │   Screens   │  │   Widgets   │  │     Controllers     │  │
+│  │  (features/)│  │  (widgets/) │  │  (game_session_     │  │
+│  │             │  │             │  │   controller.dart)  │  │
+│  └──────┬──────┘  └──────┬──────┘  └──────────┬──────────┘  │
+└─────────┼────────────────┼───────────────────┼──────────────┘
+          │                │                   │
+          ▼                ▼                   ▼
+┌─────────────────────────────────────────────────────────────┐
+│                      Domain Layer                            │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
+│  │   Models    │  │   Services  │  │      Managers       │  │
+│  │  (model/)   │  │  (engine/)  │  │  (game/managers/)   │  │
+│  │             │  │             │  │                     │  │
+│  │ - GameState │  │ - Progress  │  │ - Statistics        │  │
+│  │ - Equipment │  │ - Combat    │  │ - SpeedBoost        │  │
+│  │ - Skills    │  │ - Item      │  │ - ReturnRewards     │  │
+│  └─────────────┘  └─────────────┘  │ - Resurrection      │  │
+│                                    │ - HallOfFame        │  │
+│                                    └─────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+          │                │                   │
+          ▼                ▼                   ▼
+┌─────────────────────────────────────────────────────────────┐
+│                       Data Layer                             │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────────────┐  │
+│  │  Static     │  │   Storage   │  │     External        │  │
+│  │  Data       │  │             │  │     Services        │  │
+│  │  (data/)    │  │  (storage/) │  │                     │  │
+│  │             │  │             │  │ - AdService         │  │
+│  │ - Config    │  │ - SaveMgr   │  │ - IAPService        │  │
+│  │ - Races     │  │ - HallOfFame│  │ - AudioService      │  │
+│  └─────────────┘  └─────────────┘  └─────────────────────┘  │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## GameSessionController 매니저 구조
+
+```
+┌──────────────────────────────────────────────────────────────┐
+│                   GameSessionController                       │
+│                        (526 LOC)                             │
+│                                                              │
+│  ┌────────────────────────────────────────────────────────┐  │
+│  │  핵심 책임:                                              │  │
+│  │  - 게임 루프 관리 (startNew, pause, resume)             │  │
+│  │  - 콜백 처리 (_onPlayerDied, _onGameComplete)          │  │
+│  │  - 상태 관리 (GameState, MonetizationState)            │  │
+│  └────────────────────────────────────────────────────────┘  │
+│                           │                                  │
+│           ┌───────────────┼───────────────┐                  │
+│           ▼               ▼               ▼                  │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │
+│  │ Statistics  │  │ SpeedBoost  │  │  Return     │          │
+│  │  Manager    │  │  Manager    │  │  Rewards    │          │
+│  │  (140 LOC)  │  │  (190 LOC)  │  │  (180 LOC)  │          │
+│  └─────────────┘  └─────────────┘  └─────────────┘          │
+│           │               │               │                  │
+│           ▼               ▼               ▼                  │
+│  ┌─────────────┐  ┌─────────────┐                           │
+│  │Resurrection │  │ HallOfFame  │                           │
+│  │  Manager    │  │  Manager    │                           │
+│  │  (160 LOC)  │  │  (130 LOC)  │                           │
+│  └─────────────┘  └─────────────┘                           │
+└──────────────────────────────────────────────────────────────┘
+```
+
+### 매니저별 책임
+
+| 매니저 | 파일 | 책임 |
+|--------|------|------|
+| `GameStatisticsManager` | `game_statistics_manager.dart` | 세션/누적 통계, 레벨업/골드/처치 추적 |
+| `SpeedBoostManager` | `speed_boost_manager.dart` | 광고 배속, 버프 만료 체크 |
+| `ReturnRewardsManager` | `return_rewards_manager.dart` | 복귀 보상 계산, 상자 보상 적용 |
+| `ResurrectionManager` | `resurrection_manager.dart` | 일반/광고 부활, 자동부활 조건 |
+| `HallOfFameManager` | `hall_of_fame_manager.dart` | 명예의 전당 등록, 테스트 캐릭터 |
+
+## 게임 루프 흐름
+
+```
+┌─────────────┐
+│  startNew() │
+└──────┬──────┘
+       │
+       ▼
+┌──────────────────┐
+│   ProgressLoop   │◄──────┐
+│    (50ms tick)   │       │
+└────────┬─────────┘       │
+         │                 │
+         ▼                 │
+┌──────────────────┐       │
+│ ProgressService  │       │
+│    .tick()       │       │
+└────────┬─────────┘       │
+         │                 │
+    ┌────┴────┐            │
+    │         │            │
+    ▼         ▼            │
+┌───────┐ ┌───────┐        │
+│ Task  │ │ Quest │        │
+│Process│ │/Plot  │        │
+└───┬───┘ └───┬───┘        │
+    │         │            │
+    └────┬────┘            │
+         │                 │
+         ▼                 │
+┌──────────────────┐       │
+│  State Stream    │───────┘
+│  → UI Update     │
+└──────────────────┘
+         │
+         ▼
+┌──────────────────┐
+│   AutoSave       │
+│   (30초 간격)     │
+└──────────────────┘
+```
+
+## 데이터 흐름
+
+```
+User Action
+     │
+     ▼
+┌─────────────────┐
+│ GamePlayScreen  │
+│   (UI Layer)    │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│ GameSession     │
+│ Controller      │
+└────────┬────────┘
+         │
+    ┌────┴────┬────────┬────────┐
+    │         │        │        │
+    ▼         ▼        ▼        ▼
+┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐
+│Progres│ │Stats  │ │Resurre│ │HallOf │
+│sLoop  │ │Manager│ │ction  │ │Fame   │
+└───┬───┘ └───────┘ │Manager│ │Manager│
+    │               └───────┘ └───────┘
+    ▼
+┌─────────────────┐
+│ProgressService  │
+│ (Game Logic)    │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│   GameState     │
+│  (Immutable)    │
+└────────┬────────┘
+         │
+         ▼
+┌─────────────────┐
+│   SaveManager   │
+│  (Persistence)  │
+└─────────────────┘
+```
+
+## 원본 PQ 알고리즘 매핑
+
+| PQ 원본 (Delphi) | 포팅 위치 |
+|-----------------|----------|
+| `Main.pas:MonsterTask` | `progress_service.dart:_createMonsterTask()` |
+| `Main.pas:StartTimer` | `progress_loop.dart:tick()` |
+| `NewGuy.pas:RerollClick` | `character_roll_service.dart` |
+| `Config.dfm` 데이터 | `data/pq_config_data.dart` |

ios/Runner.xcodeproj/project.pbxproj

@@ -361,14 +361,16 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
+				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 82SY27V867;
 				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = Runner/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_VERSION = 5.0;
@@ -384,7 +386,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
@@ -401,7 +403,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
@@ -416,7 +418,7 @@
 				CURRENT_PROJECT_VERSION = 1;
 				GENERATE_INFOPLIST_FILE = YES;
 				MARKETING_VERSION = 1.0;
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie.RunnerTests;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie.RunnerTests;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_VERSION = 5.0;
 				TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner";
@@ -540,14 +542,16 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
+				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 82SY27V867;
 				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = Runner/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_OPTIMIZATION_LEVEL = "-Onone";
@@ -562,14 +566,16 @@
 			buildSettings = {
 				ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon;
 				CLANG_ENABLE_MODULES = YES;
+				CODE_SIGN_STYLE = Automatic;
 				CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)";
+				DEVELOPMENT_TEAM = 82SY27V867;
 				ENABLE_BITCODE = NO;
 				INFOPLIST_FILE = Runner/Info.plist;
 				LD_RUNPATH_SEARCH_PATHS = (
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				PRODUCT_BUNDLE_IDENTIFIER = com.example.asciineverdie;
+				PRODUCT_BUNDLE_IDENTIFIER = com.naturebridgeai.asciineverdie;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h";
 				SWIFT_VERSION = 5.0;

ios/Runner/Info.plist

@@ -5,7 +5,7 @@
 	<key>CFBundleDevelopmentRegion</key>
 	<string>$(DEVELOPMENT_LANGUAGE)</string>
 	<key>CFBundleDisplayName</key>
-	<string>Asciineverdie</string>
+	<string>ASCII Never Die</string>
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIdentifier</key>
@@ -13,7 +13,7 @@
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleName</key>
-	<string>asciineverdie</string>
+	<string>ASCII Never Die</string>
 	<key>CFBundlePackageType</key>
 	<string>APPL</string>
 	<key>CFBundleShortVersionString</key>
@@ -47,5 +47,26 @@
 	<true/>
 	<key>NSHumanReadableCopyright</key>
 	<string>© 2025 naturebridgeai 天安門 六四事件 法輪功 李洪志 Free Tibet</string>
+	<!-- AdMob App ID -->
+	<key>GADApplicationIdentifier</key>
+	<string>ca-app-pub-6691216385521068~8216990571</string>
+	<!-- SKAdNetwork -->
+	<key>SKAdNetworkItems</key>
+	<array>
+		<dict>
+			<key>SKAdNetworkIdentifier</key>
+			<string>cstr6suwn9.skadnetwork</string>
+		</dict>
+	</array>
+	<!-- ATT(App Tracking Transparency) 사용자 추적 동의 문구 -->
+	<key>NSUserTrackingUsageDescription</key>
+	<string>This identifier will be used to deliver personalized ads to you.</string>
+	<!-- 지원 언어(localization) 목록 -->
+	<key>CFBundleLocalizations</key>
+	<array>
+		<string>en</string>
+		<string>ko</string>
+		<string>ja</string>
+	</array>
 </dict>
 </plist>

lib/data/game_text_l10n.dart

@@ -172,8 +172,7 @@ String returnRewardHoursAway(String time) =>
 String returnRewardChests(int count) =>
     _l('$count Treasure Chest(s)', '보물 상자 $count개', '宝箱 $count個');
 String get returnRewardOpenChests => _l('Open Chests', '상자 열기', '宝箱を開ける');
-String get returnRewardBonusChests =>
-    _l('Bonus Chests', '보너스 상자', 'ボーナス宝箱');
+String get returnRewardBonusChests => _l('Bonus Chests', '보너스 상자', 'ボーナス宝箱');
 String get returnRewardClaimBonus =>
     _l('Get Bonus (AD)', '보너스 받기 (광고)', 'ボーナス受取 (広告)');
 String get returnRewardClaimBonusFree =>
@@ -193,8 +192,7 @@ String chestRewardExpAmount(int exp) =>
     _l('+$exp EXP', '+$exp 경험치', '+$exp 経験値');
 String chestRewardPotionAmount(String name, int count) =>
     _l('$name x$count', '$name x$count', '$name x$count');
-String get chestRewardEquipped =>
-    _l('Equipped!', '장착됨!', '装備しました!');
+String get chestRewardEquipped => _l('Equipped!', '장착됨!', '装備しました!');
 String get chestRewardBetterItem =>
     _l('Better than current!', '현재보다 좋습니다!', '現在より良い!');
 
@@ -1143,24 +1141,15 @@ String get uiSaveBattleLog => _l('Save Battle Log', '배틀로그 저장', 'バ
 String get iapRemoveAds => _l('Remove Ads', '광고 제거', '広告削除');
 String get iapRemoveAdsDesc =>
     _l('Enjoy ad-free experience', '광고 없이 플레이', '広告なしでプレイ');
-String get iapBenefitTitle =>
-    _l('Premium Benefits', '프리미엄 혜택', 'プレミアム特典');
-String get iapBenefit1 =>
-    _l('Ad-free gameplay', '광고 없는 쾌적한 플레이', '広告なしの快適プレイ');
+String get iapBenefitTitle => _l('Premium Benefits', '프리미엄 혜택', 'プレミアム特典');
+String get iapBenefit1 => _l('Ad-free gameplay', '광고 없는 쾌적한 플레이', '広告なしの快適プレイ');
 String get iapBenefit2 =>
     _l('Unlimited speed boost', '속도 부스트 무제한', 'スピードブースト無制限');
-String get iapBenefit3 => _l(
-  'Stat reroll undo: 3 times',
-  '신규 캐릭터 스탯 가챠 되돌리기 3회',
-  '新キャラステ振り直し3回',
-);
-String get iapBenefit4 =>
-    _l('Unlimited rerolls', '굴리기 무제한', 'リロール無制限');
-String get iapBenefit5 => _l(
-  '2x offline time credited',
-  '오프라인 시간 2배 인정',
-  'オフライン時間2倍適用',
-);
+String get iapBenefit3 =>
+    _l('Stat reroll undo: 3 times', '신규 캐릭터 스탯 가챠 되돌리기 3회', '新キャラステ振り直し3回');
+String get iapBenefit4 => _l('Unlimited rerolls', '굴리기 무제한', 'リロール無制限');
+String get iapBenefit5 =>
+    _l('2x offline time credited', '오프라인 시간 2배 인정', 'オフライン時間2倍適用');
 String get iapBenefit6 =>
     _l('Return chests: 10 max', '복귀 상자 최대 10개', '帰還ボックス最大10個');
 String get iapPurchaseButton => _l('Purchase', '구매하기', '購入する');
@@ -1226,3 +1215,18 @@ String get elementChaos => _l('Chaos', '혼돈', 'カオス');
 
 // 스킬 상세 정보 없음
 String get skillNoDetails => _l('No details', '상세 정보 없음', '詳細情報なし');
+
+// ============================================================================
+// 알림 텍스트 (Notification Texts)
+// ============================================================================
+
+String get notifyLevelUp => _l('LEVEL UP!', '레벨 업!', 'レベルアップ！');
+String notifyLevel(int level) => _l('Level $level', '레벨 $level', 'レベル $level');
+String get notifyQuestComplete => _l('QUEST COMPLETE!', '퀘스트 완료!', 'クエスト完了！');
+String get notifyPrologueComplete =>
+    _l('PROLOGUE COMPLETE!', '프롤로그 완료!', 'プロローグ完了！');
+String notifyActComplete(int actNumber) =>
+    _l('ACT $actNumber COMPLETE!', '${actNumber}막 완료!', '第${actNumber}幕完了！');
+String get notifyNewSpell => _l('NEW SPELL!', '새 주문!', '新しい呪文！');
+String get notifyNewEquipment => _l('NEW EQUIPMENT!', '새 장비!', '新しい装備！');
+String get notifyBossDefeated => _l('BOSS DEFEATED!', '보스 처치!', 'ボス撃破！');

lib/data/race_data.dart

@@ -151,9 +151,9 @@ class RaceData {
     },
     passives: [
       PassiveAbility(
-        type: PassiveType.deathEquipmentPreserve,
-        value: 1.0,
-        description: '사망 시 장비 1개 유지',
+        type: PassiveType.defenseBonus,
+        value: 0.10,
+        description: '방어력 +10%',
       ),
     ],
   );

lib/l10n/app_en.arb

@@ -310,5 +310,401 @@
   "@endingTapToSkip": { "description": "Tap to skip hint" },
 
   "endingHoldToSpeedUp": "HOLD TO SPEED UP",
-  "@endingHoldToSpeedUp": { "description": "Hold to speed up scrolling hint" }
+  "@endingHoldToSpeedUp": { "description": "Hold to speed up scrolling hint" },
+
+  "menuTitle": "MENU",
+  "@menuTitle": { "description": "Menu panel title" },
+
+  "optionsTitle": "OPTIONS",
+  "@optionsTitle": { "description": "Options menu title" },
+
+  "soundTitle": "SOUND",
+  "@soundTitle": { "description": "Sound dialog title" },
+
+  "controlSection": "CONTROL",
+  "@controlSection": { "description": "Control section title" },
+
+  "infoSection": "INFO",
+  "@infoSection": { "description": "Info section title" },
+
+  "settingsSection": "SETTINGS",
+  "@settingsSection": { "description": "Settings section title" },
+
+  "saveExitSection": "SAVE / EXIT",
+  "@saveExitSection": { "description": "Save/Exit section title" },
+
+  "ok": "OK",
+  "@ok": { "description": "OK button" },
+
+  "rechargeButton": "RECHARGE",
+  "@rechargeButton": { "description": "Recharge button" },
+
+  "createButton": "CREATE",
+  "@createButton": { "description": "Create button" },
+
+  "previewTitle": "PREVIEW",
+  "@previewTitle": { "description": "Preview panel title" },
+
+  "nameTitle": "NAME",
+  "@nameTitle": { "description": "Name panel title" },
+
+  "statsTitle": "STATS",
+  "@statsTitle": { "description": "Stats panel title" },
+
+  "raceTitle": "RACE",
+  "@raceTitle": { "description": "Race panel title" },
+
+  "classSection": "CLASS",
+  "@classSection": { "description": "Class panel title" },
+
+  "bgmLabel": "BGM",
+  "@bgmLabel": { "description": "BGM volume label" },
+
+  "sfxLabel": "SFX",
+  "@sfxLabel": { "description": "SFX volume label" },
+
+  "hpLabel": "HP",
+  "@hpLabel": { "description": "HP bar label" },
+
+  "mpLabel": "MP",
+  "@mpLabel": { "description": "MP bar label" },
+
+  "expLabel": "EXP",
+  "@expLabel": { "description": "EXP bar label" },
+
+  "notifyLevelUp": "LEVEL UP!",
+  "@notifyLevelUp": { "description": "Level up notification title" },
+
+  "notifyLevel": "Level {level}",
+  "@notifyLevel": {
+    "description": "Level notification subtitle",
+    "placeholders": {
+      "level": { "type": "int" }
+    }
+  },
+
+  "notifyQuestComplete": "QUEST COMPLETE!",
+  "@notifyQuestComplete": { "description": "Quest complete notification title" },
+
+  "notifyPrologueComplete": "PROLOGUE COMPLETE!",
+  "@notifyPrologueComplete": { "description": "Prologue complete notification title" },
+
+  "notifyActComplete": "ACT {number} COMPLETE!",
+  "@notifyActComplete": {
+    "description": "Act complete notification title",
+    "placeholders": {
+      "number": { "type": "int" }
+    }
+  },
+
+  "notifyNewSpell": "NEW SPELL!",
+  "@notifyNewSpell": { "description": "New spell notification title" },
+
+  "notifyNewEquipment": "NEW EQUIPMENT!",
+  "@notifyNewEquipment": { "description": "New equipment notification title" },
+
+  "notifyBossDefeated": "BOSS DEFEATED!",
+  "@notifyBossDefeated": { "description": "Boss defeated notification title" },
+
+  "rechargeRollsTitle": "RECHARGE ROLLS",
+  "@rechargeRollsTitle": { "description": "Recharge rolls dialog title" },
+
+  "rechargeRollsFree": "Recharge 5 rolls for free?",
+  "@rechargeRollsFree": { "description": "Recharge rolls free user message" },
+
+  "rechargeRollsAd": "Watch an ad to recharge 5 rolls?",
+  "@rechargeRollsAd": { "description": "Recharge rolls ad message" },
+
+  "debugTitle": "DEBUG",
+  "@debugTitle": { "description": "Debug section title" },
+
+  "debugCheatsTitle": "DEBUG CHEATS",
+  "@debugCheatsTitle": { "description": "Debug cheats section title" },
+
+  "debugToolsTitle": "DEBUG TOOLS",
+  "@debugToolsTitle": { "description": "Debug tools section title" },
+
+  "debugDeveloperTools": "DEVELOPER TOOLS",
+  "@debugDeveloperTools": { "description": "Developer tools header" },
+
+  "debugSkipTask": "SKIP TASK (L+1)",
+  "@debugSkipTask": { "description": "Skip task cheat label" },
+
+  "debugSkipTaskDesc": "Complete task instantly",
+  "@debugSkipTaskDesc": { "description": "Skip task cheat description" },
+
+  "debugSkipQuest": "SKIP QUEST (Q!)",
+  "@debugSkipQuest": { "description": "Skip quest cheat label" },
+
+  "debugSkipQuestDesc": "Complete quest instantly",
+  "@debugSkipQuestDesc": { "description": "Skip quest cheat description" },
+
+  "debugSkipAct": "SKIP ACT (P!)",
+  "@debugSkipAct": { "description": "Skip act cheat label" },
+
+  "debugSkipActDesc": "Complete act instantly",
+  "@debugSkipActDesc": { "description": "Skip act cheat description" },
+
+  "debugCreateTestCharacter": "CREATE TEST CHARACTER",
+  "@debugCreateTestCharacter": { "description": "Create test character button" },
+
+  "debugCreateTestCharacterDesc": "Register Level 100 character to Hall of Fame",
+  "@debugCreateTestCharacterDesc": { "description": "Create test character description" },
+
+  "debugCreateTestCharacterTitle": "CREATE TEST CHARACTER?",
+  "@debugCreateTestCharacterTitle": { "description": "Create test character dialog title" },
+
+  "debugCreateTestCharacterMessage": "Current character will be converted to Level 100\nand registered to the Hall of Fame.\n\n⚠️ Current save file will be deleted.\nThis action cannot be undone.",
+  "@debugCreateTestCharacterMessage": { "description": "Create test character confirmation message" },
+
+  "debugTurbo": "DEBUG: TURBO (20x)",
+  "@debugTurbo": { "description": "Debug turbo mode label" },
+
+  "debugIapPurchased": "IAP PURCHASED",
+  "@debugIapPurchased": { "description": "IAP purchased debug toggle" },
+
+  "debugIapPurchasedDesc": "ON: Behave as paid user (ads removed)",
+  "@debugIapPurchasedDesc": { "description": "IAP purchased debug description" },
+
+  "debugOfflineHours": "OFFLINE HOURS",
+  "@debugOfflineHours": { "description": "Offline hours debug label" },
+
+  "debugOfflineHoursDesc": "Test return rewards (applies on restart)",
+  "@debugOfflineHoursDesc": { "description": "Offline hours debug description" },
+
+  "debugTestCharacterDesc": "Modify current character to Level 100\nand register to the Hall of Fame.",
+  "@debugTestCharacterDesc": { "description": "Test character creation description" },
+
+  "arenaTitle": "LOCAL ARENA",
+  "@arenaTitle": { "description": "Arena main screen title" },
+
+  "arenaSelectFighter": "SELECT YOUR FIGHTER",
+  "@arenaSelectFighter": { "description": "Arena character selection subtitle" },
+
+  "arenaEmptyTitle": "Not enough heroes",
+  "@arenaEmptyTitle": { "description": "Arena empty state title" },
+
+  "arenaEmptyHint": "Clear the game with 2+ characters",
+  "@arenaEmptyHint": { "description": "Arena empty state hint" },
+
+  "arenaSetupTitle": "ARENA SETUP",
+  "@arenaSetupTitle": { "description": "Arena setup screen title" },
+
+  "arenaStartBattle": "START BATTLE",
+  "@arenaStartBattle": { "description": "Start battle button" },
+
+  "arenaBattleTitle": "ARENA BATTLE",
+  "@arenaBattleTitle": { "description": "Arena battle screen title" },
+
+  "arenaMyEquipment": "MY EQUIPMENT",
+  "@arenaMyEquipment": { "description": "My equipment header" },
+
+  "arenaEnemyEquipment": "ENEMY EQUIPMENT",
+  "@arenaEnemyEquipment": { "description": "Enemy equipment header" },
+
+  "arenaSelected": "SELECTED",
+  "@arenaSelected": { "description": "Selected slot label" },
+
+  "arenaRecommended": "BEST",
+  "@arenaRecommended": { "description": "Recommended slot label" },
+
+  "arenaWeaponLocked": "LOCKED",
+  "@arenaWeaponLocked": { "description": "Weapon slot locked label" },
+
+  "arenaVictory": "VICTORY!",
+  "@arenaVictory": { "description": "Arena victory title" },
+
+  "arenaDefeat": "DEFEAT...",
+  "@arenaDefeat": { "description": "Arena defeat title" },
+
+  "arenaEquipmentExchange": "EQUIPMENT EXCHANGE",
+  "@arenaEquipmentExchange": { "description": "Equipment exchange section title" },
+
+  "arenaTurns": "TURNS",
+  "@arenaTurns": { "description": "Turns label" },
+
+  "arenaWinner": "WINNER",
+  "@arenaWinner": { "description": "Winner label" },
+
+  "arenaLoser": "LOSER",
+  "@arenaLoser": { "description": "Loser label" },
+
+  "arenaDefeatedIn": "{winner} defeated {loser} in {turns} TURNS",
+  "@arenaDefeatedIn": {
+    "description": "Battle summary text",
+    "placeholders": {
+      "winner": { "type": "String" },
+      "loser": { "type": "String" },
+      "turns": { "type": "int" }
+    }
+  },
+
+  "arenaScoreGain": "You will GAIN +{score}",
+  "@arenaScoreGain": {
+    "description": "Score gain prediction",
+    "placeholders": {
+      "score": { "type": "int" }
+    }
+  },
+
+  "arenaScoreLose": "You will LOSE {score}",
+  "@arenaScoreLose": {
+    "description": "Score loss prediction",
+    "placeholders": {
+      "score": { "type": "int" }
+    }
+  },
+
+  "arenaEvenTrade": "Even trade",
+  "@arenaEvenTrade": { "description": "Even trade label" },
+
+  "arenaScore": "SCORE",
+  "@arenaScore": { "description": "Score label" },
+
+  "statsStatistics": "Statistics",
+  "@statsStatistics": { "description": "Statistics dialog title" },
+
+  "statsSession": "Session",
+  "@statsSession": { "description": "Session tab label" },
+
+  "statsAccumulated": "Total",
+  "@statsAccumulated": { "description": "Accumulated tab label" },
+
+  "statsCombat": "Combat",
+  "@statsCombat": { "description": "Combat section title" },
+
+  "statsPlayTime": "Play Time",
+  "@statsPlayTime": { "description": "Play time label" },
+
+  "statsMonstersKilled": "Monsters Killed",
+  "@statsMonstersKilled": { "description": "Monsters killed label" },
+
+  "statsBossesDefeated": "Bosses Defeated",
+  "@statsBossesDefeated": { "description": "Bosses defeated label" },
+
+  "statsDeaths": "Deaths",
+  "@statsDeaths": { "description": "Deaths label" },
+
+  "statsDamage": "Damage",
+  "@statsDamage": { "description": "Damage section title" },
+
+  "statsDamageDealt": "Damage Dealt",
+  "@statsDamageDealt": { "description": "Damage dealt label" },
+
+  "statsDamageTaken": "Damage Taken",
+  "@statsDamageTaken": { "description": "Damage taken label" },
+
+  "statsAverageDps": "Average DPS",
+  "@statsAverageDps": { "description": "Average DPS label" },
+
+  "statsSkills": "Skills",
+  "@statsSkills": { "description": "Skills section title" },
+
+  "statsSkillsUsed": "Skills Used",
+  "@statsSkillsUsed": { "description": "Skills used label" },
+
+  "statsCriticalHits": "Critical Hits",
+  "@statsCriticalHits": { "description": "Critical hits label" },
+
+  "statsMaxCriticalStreak": "Max Critical Streak",
+  "@statsMaxCriticalStreak": { "description": "Max critical streak label" },
+
+  "statsCriticalRate": "Critical Rate",
+  "@statsCriticalRate": { "description": "Critical rate label" },
+
+  "statsEconomy": "Economy",
+  "@statsEconomy": { "description": "Economy section title" },
+
+  "statsGoldEarned": "Gold Earned",
+  "@statsGoldEarned": { "description": "Gold earned label" },
+
+  "statsGoldSpent": "Gold Spent",
+  "@statsGoldSpent": { "description": "Gold spent label" },
+
+  "statsItemsSold": "Items Sold",
+  "@statsItemsSold": { "description": "Items sold label" },
+
+  "statsPotionsUsed": "Potions Used",
+  "@statsPotionsUsed": { "description": "Potions used label" },
+
+  "statsProgress": "Progress",
+  "@statsProgress": { "description": "Progress section title" },
+
+  "statsLevelUps": "Level Ups",
+  "@statsLevelUps": { "description": "Level ups label" },
+
+  "statsQuestsCompleted": "Quests Completed",
+  "@statsQuestsCompleted": { "description": "Quests completed label" },
+
+  "statsRecords": "Records",
+  "@statsRecords": { "description": "Records section title" },
+
+  "statsHighestLevel": "Highest Level",
+  "@statsHighestLevel": { "description": "Highest level label" },
+
+  "statsHighestGoldHeld": "Highest Gold Held",
+  "@statsHighestGoldHeld": { "description": "Highest gold held label" },
+
+  "statsBestCriticalStreak": "Best Critical Streak",
+  "@statsBestCriticalStreak": { "description": "Best critical streak label" },
+
+  "statsTotalPlay": "Total Play",
+  "@statsTotalPlay": { "description": "Total play section title" },
+
+  "statsTotalPlayTime": "Total Play Time",
+  "@statsTotalPlayTime": { "description": "Total play time label" },
+
+  "statsGamesStarted": "Games Started",
+  "@statsGamesStarted": { "description": "Games started label" },
+
+  "statsGamesCompleted": "Games Completed",
+  "@statsGamesCompleted": { "description": "Games completed label" },
+
+  "statsCompletionRate": "Completion Rate",
+  "@statsCompletionRate": { "description": "Completion rate label" },
+
+  "statsTotalCombat": "Total Combat",
+  "@statsTotalCombat": { "description": "Total combat section title" },
+
+  "statsTotalDeaths": "Total Deaths",
+  "@statsTotalDeaths": { "description": "Total deaths label" },
+
+  "statsTotalLevelUps": "Total Level Ups",
+  "@statsTotalLevelUps": { "description": "Total level ups label" },
+
+  "statsTotalDamage": "Total Damage",
+  "@statsTotalDamage": { "description": "Total damage section title" },
+
+  "statsTotalSkills": "Total Skills",
+  "@statsTotalSkills": { "description": "Total skills section title" },
+
+  "statsTotalEconomy": "Total Economy",
+  "@statsTotalEconomy": { "description": "Total economy section title" },
+
+  "notifyLevelUpLabel": "LEVEL UP",
+  "@notifyLevelUpLabel": { "description": "Level up notification type label" },
+
+  "notifyQuestDoneLabel": "QUEST DONE",
+  "@notifyQuestDoneLabel": { "description": "Quest done notification type label" },
+
+  "notifyActClearLabel": "ACT CLEAR",
+  "@notifyActClearLabel": { "description": "Act clear notification type label" },
+
+  "notifyNewSpellLabel": "NEW SPELL",
+  "@notifyNewSpellLabel": { "description": "New spell notification type label" },
+
+  "notifyNewItemLabel": "NEW ITEM",
+  "@notifyNewItemLabel": { "description": "New item notification type label" },
+
+  "notifyBossSlainLabel": "BOSS SLAIN",
+  "@notifyBossSlainLabel": { "description": "Boss slain notification type label" },
+
+  "notifySavedLabel": "SAVED",
+  "@notifySavedLabel": { "description": "Game saved notification type label" },
+
+  "notifyInfoLabel": "INFO",
+  "@notifyInfoLabel": { "description": "Info notification type label" },
+
+  "notifyWarningLabel": "WARNING",
+  "@notifyWarningLabel": { "description": "Warning notification type label" }
 }

lib/l10n/app_ja.arb

@@ -2,79 +2,79 @@
   "@@locale": "ja",
 
   "appTitle": "アスキー ネバー ダイ",
-  "tagNoNetwork": "No network",
-  "tagIdleRpg": "Idle RPG loop",
-  "tagLocalSaves": "Local saves",
-  "newCharacter": "New character",
-  "loadSave": "Load save",
-  "loadGame": "Load Game",
-  "viewBuildPlan": "View build plan",
-  "buildRoadmap": "Build roadmap",
-  "techStack": "Tech stack",
-  "cancel": "Cancel",
-  "exitGame": "Exit Game",
-  "saveProgressQuestion": "Save your progress before leaving?",
-  "exitWithoutSaving": "Exit without saving",
-  "saveAndExit": "Save and Exit",
-  "progressQuestTitle": "ASCII NEVER DIE - {name}",
-  "levelUp": "Level Up",
-  "completeQuest": "Complete Quest",
-  "completePlot": "Complete Plot",
-  "characterSheet": "Character Sheet",
-  "traits": "Traits",
-  "stats": "Stats",
-  "experience": "Experience",
-  "xpNeededForNextLevel": "XP needed for next level",
+  "tagNoNetwork": "オフライン",
+  "tagIdleRpg": "放置型RPG",
+  "tagLocalSaves": "ローカル保存",
+  "newCharacter": "新規キャラクター",
+  "loadSave": "ロード",
+  "loadGame": "ゲームをロード",
+  "viewBuildPlan": "ビルド計画を見る",
+  "buildRoadmap": "ビルドロードマップ",
+  "techStack": "技術スタック",
+  "cancel": "キャンセル",
+  "exitGame": "ゲーム終了",
+  "saveProgressQuestion": "終了する前にセーブしますか？",
+  "exitWithoutSaving": "セーブせずに終了",
+  "saveAndExit": "セーブして終了",
+  "progressQuestTitle": "アスキー ネバー ダイ - {name}",
+  "levelUp": "レベルアップ",
+  "completeQuest": "クエスト完了",
+  "completePlot": "プロット完了",
+  "characterSheet": "キャラクターシート",
+  "traits": "特性",
+  "stats": "能力値",
+  "experience": "経験値",
+  "xpNeededForNextLevel": "次のレベルまでの必要XP",
   "spellBook": "スキル",
   "noSpellsYet": "習得したスキルがありません",
-  "equipment": "Equipment",
-  "inventory": "Inventory",
-  "encumbrance": "Encumbrance",
+  "equipment": "装備",
+  "inventory": "インベントリ",
+  "encumbrance": "積載量",
   "combatLog": "戦闘ログ",
-  "plotDevelopment": "Plot Development",
-  "quests": "Quests",
-  "traitName": "Name",
-  "traitRace": "Race",
-  "traitClass": "Class",
-  "traitLevel": "Level",
+  "plotDevelopment": "ストーリー進行",
+  "quests": "クエスト",
+  "traitName": "名前",
+  "traitRace": "種族",
+  "traitClass": "職業",
+  "traitLevel": "レベル",
   "statStr": "STR",
   "statCon": "CON",
   "statDex": "DEX",
   "statInt": "INT",
   "statWis": "WIS",
   "statCha": "CHA",
-  "statHpMax": "HP Max",
-  "statMpMax": "MP Max",
-  "equipWeapon": "Weapon",
-  "equipShield": "Shield",
-  "equipHelm": "Helm",
-  "equipHauberk": "Hauberk",
-  "equipBrassairts": "Brassairts",
-  "equipVambraces": "Vambraces",
-  "equipGauntlets": "Gauntlets",
-  "equipGambeson": "Gambeson",
-  "equipCuisses": "Cuisses",
-  "equipGreaves": "Greaves",
-  "equipSollerets": "Sollerets",
+  "statHpMax": "HP最大",
+  "statMpMax": "MP最大",
+  "equipWeapon": "武器",
+  "equipShield": "盾",
+  "equipHelm": "兜",
+  "equipHauberk": "鎧",
+  "equipBrassairts": "肩当て",
+  "equipVambraces": "腕甲",
+  "equipGauntlets": "篭手",
+  "equipGambeson": "防護服",
+  "equipCuisses": "腿当て",
+  "equipGreaves": "脛当て",
+  "equipSollerets": "鉄靴",
   "gold": "コイン",
   "goldAmount": "コイン: {amount}",
-  "prologue": "Prologue",
-  "actNumber": "Act {number}",
-  "noActiveQuests": "No active quests",
-  "questNumber": "Quest #{number}",
+  "prologue": "プロローグ",
+  "actNumber": "第{number}幕",
+  "noActiveQuests": "進行中のクエストなし",
+  "questNumber": "クエスト #{number}",
   "welcomeMessage": "ASCII NEVER DIEへようこそ！",
-  "noSavedGames": "No saved games found.",
-  "loadError": "Failed to load save file: {error}",
-  "name": "Name",
-  "generateName": "Generate Name",
-  "total": "Total",
+  "noSavedGames": "セーブデータがありません。",
+  "loadError": "セーブファイルの読み込みに失敗しました: {error}",
+  "name": "名前",
+  "generateName": "名前を生成",
+  "total": "合計",
   "unroll": "元に戻す",
-  "roll": "Roll",
-  "race": "Race",
-  "classTitle": "Class",
-  "percentComplete": "{percent}% complete",
-  "newCharacterTitle": "ASCII NEVER DIE - New Character",
-  "soldButton": "Sold!",
+  "roll": "ロール",
+  "race": "種族",
+  "classTitle": "職業",
+  "percentComplete": "{percent}% 完了",
+  "newCharacterTitle": "アスキー ネバー ダイ - 新規キャラクター",
+  "soldButton": "決定！",
 
   "endingCongratulations": "★ おめでとうございます ★",
   "endingGameComplete": "ゲームをクリアしました！",
@@ -93,5 +93,132 @@
   "endingHallOfFameButton": "殿堂入り",
   "endingSkip": "スキップ",
   "endingTapToSkip": "タップでスキップ",
-  "endingHoldToSpeedUp": "長押しで高速スクロール"
+  "endingHoldToSpeedUp": "長押しで高速スクロール",
+
+  "menuTitle": "メニュー",
+  "optionsTitle": "オプション",
+  "soundTitle": "サウンド",
+  "controlSection": "操作",
+  "infoSection": "情報",
+  "settingsSection": "設定",
+  "saveExitSection": "セーブ / 終了",
+  "ok": "OK",
+  "rechargeButton": "チャージ",
+  "createButton": "作成",
+  "previewTitle": "プレビュー",
+  "nameTitle": "名前",
+  "statsTitle": "能力値",
+  "raceTitle": "種族",
+  "classSection": "職業",
+  "bgmLabel": "BGM",
+  "sfxLabel": "効果音",
+  "hpLabel": "HP",
+  "mpLabel": "MP",
+  "expLabel": "EXP",
+  "notifyLevelUp": "レベルアップ！",
+  "notifyLevel": "レベル {level}",
+  "notifyQuestComplete": "クエスト完了！",
+  "notifyPrologueComplete": "プロローグ完了！",
+  "notifyActComplete": "第{number}幕 完了！",
+  "notifyNewSpell": "新しいスキル！",
+  "notifyNewEquipment": "新しい装備！",
+  "notifyBossDefeated": "ボス撃破！",
+  "rechargeRollsTitle": "ロール回数チャージ",
+  "rechargeRollsFree": "無料で5回チャージしますか？",
+  "rechargeRollsAd": "広告を見て5回チャージしますか？",
+  "debugTitle": "デバッグ",
+  "debugCheatsTitle": "デバッグチート",
+  "debugToolsTitle": "デバッグツール",
+  "debugDeveloperTools": "開発者ツール",
+  "debugSkipTask": "タスクスキップ (L+1)",
+  "debugSkipTaskDesc": "タスクを即時完了",
+  "debugSkipQuest": "クエストスキップ (Q!)",
+  "debugSkipQuestDesc": "クエストを即時完了",
+  "debugSkipAct": "アクトスキップ (P!)",
+  "debugSkipActDesc": "アクトを即時完了",
+  "debugCreateTestCharacter": "テストキャラクター作成",
+  "debugCreateTestCharacterDesc": "レベル100キャラクターを殿堂に登録",
+  "debugCreateTestCharacterTitle": "テストキャラクターを作成しますか？",
+  "debugCreateTestCharacterMessage": "現在のキャラクターがレベル100に変換され\n殿堂に登録されます。\n\n⚠️ 現在のセーブファイルは削除されます。\nこの操作は元に戻せません。",
+  "debugTurbo": "デバッグ: ターボ (20x)",
+  "debugIapPurchased": "IAP購入済み",
+  "debugIapPurchasedDesc": "ON: 有料ユーザーとして動作（広告非表示）",
+  "debugOfflineHours": "オフライン時間",
+  "debugOfflineHoursDesc": "復帰報酬テスト（再起動時に適用）",
+  "debugTestCharacterDesc": "現在のキャラクターをレベル100に変更して\n殿堂に登録します。",
+
+  "arenaTitle": "ローカルアリーナ",
+  "arenaSelectFighter": "ファイターを選択",
+  "arenaEmptyTitle": "ヒーローが不足しています",
+  "arenaEmptyHint": "2人以上のキャラでクリアしてください",
+  "arenaSetupTitle": "アリーナ設定",
+  "arenaStartBattle": "バトル開始",
+  "arenaBattleTitle": "アリーナバトル",
+  "arenaMyEquipment": "自分の装備",
+  "arenaEnemyEquipment": "敵の装備",
+  "arenaSelected": "選択済み",
+  "arenaRecommended": "おすすめ",
+  "arenaWeaponLocked": "ロック",
+  "arenaVictory": "勝利！",
+  "arenaDefeat": "敗北...",
+  "arenaEquipmentExchange": "装備交換",
+  "arenaTurns": "ターン",
+  "arenaWinner": "勝者",
+  "arenaLoser": "敗者",
+  "arenaDefeatedIn": "{winner}が{loser}を{turns}ターンで撃破",
+  "arenaScoreGain": "+{score}獲得予定",
+  "arenaScoreLose": "{score}損失予定",
+  "arenaEvenTrade": "等価交換",
+  "arenaScore": "スコア",
+
+  "statsStatistics": "統計",
+  "statsSession": "セッション",
+  "statsAccumulated": "累積",
+  "statsCombat": "戦闘",
+  "statsPlayTime": "プレイ時間",
+  "statsMonstersKilled": "倒したモンスター",
+  "statsBossesDefeated": "ボス討伐",
+  "statsDeaths": "死亡回数",
+  "statsDamage": "ダメージ",
+  "statsDamageDealt": "与えたダメージ",
+  "statsDamageTaken": "受けたダメージ",
+  "statsAverageDps": "平均DPS",
+  "statsSkills": "スキル",
+  "statsSkillsUsed": "スキル使用",
+  "statsCriticalHits": "クリティカルヒット",
+  "statsMaxCriticalStreak": "最大連続クリティカル",
+  "statsCriticalRate": "クリティカル率",
+  "statsEconomy": "経済",
+  "statsGoldEarned": "獲得ゴールド",
+  "statsGoldSpent": "消費ゴールド",
+  "statsItemsSold": "売却アイテム",
+  "statsPotionsUsed": "ポーション使用",
+  "statsProgress": "進行",
+  "statsLevelUps": "レベルアップ",
+  "statsQuestsCompleted": "完了したクエスト",
+  "statsRecords": "記録",
+  "statsHighestLevel": "最高レベル",
+  "statsHighestGoldHeld": "最大所持ゴールド",
+  "statsBestCriticalStreak": "最高連続クリティカル",
+  "statsTotalPlay": "総プレイ",
+  "statsTotalPlayTime": "総プレイ時間",
+  "statsGamesStarted": "開始したゲーム",
+  "statsGamesCompleted": "クリアしたゲーム",
+  "statsCompletionRate": "クリア率",
+  "statsTotalCombat": "総戦闘",
+  "statsTotalDeaths": "総死亡",
+  "statsTotalLevelUps": "総レベルアップ",
+  "statsTotalDamage": "総ダメージ",
+  "statsTotalSkills": "総スキル",
+  "statsTotalEconomy": "総経済",
+
+  "notifyLevelUpLabel": "レベルアップ",
+  "notifyQuestDoneLabel": "クエスト完了",
+  "notifyActClearLabel": "幕完了",
+  "notifyNewSpellLabel": "新しいスキル",
+  "notifyNewItemLabel": "新しいアイテム",
+  "notifyBossSlainLabel": "ボス撃破",
+  "notifySavedLabel": "セーブ済み",
+  "notifyInfoLabel": "情報",
+  "notifyWarningLabel": "警告"
 }

lib/l10n/app_ko.arb

@@ -93,5 +93,132 @@
   "endingHallOfFameButton": "명예의 전당",
   "endingSkip": "건너뛰기",
   "endingTapToSkip": "탭하여 건너뛰기",
-  "endingHoldToSpeedUp": "길게 누르면 빨리 스크롤"
+  "endingHoldToSpeedUp": "길게 누르면 빨리 스크롤",
+
+  "menuTitle": "메뉴",
+  "optionsTitle": "옵션",
+  "soundTitle": "사운드",
+  "controlSection": "제어",
+  "infoSection": "정보",
+  "settingsSection": "설정",
+  "saveExitSection": "저장 / 종료",
+  "ok": "확인",
+  "rechargeButton": "충전",
+  "createButton": "생성",
+  "previewTitle": "미리보기",
+  "nameTitle": "이름",
+  "statsTitle": "능력치",
+  "raceTitle": "종족",
+  "classSection": "직업",
+  "bgmLabel": "BGM",
+  "sfxLabel": "효과음",
+  "hpLabel": "HP",
+  "mpLabel": "MP",
+  "expLabel": "경험치",
+  "notifyLevelUp": "레벨 업!",
+  "notifyLevel": "레벨 {level}",
+  "notifyQuestComplete": "퀘스트 완료!",
+  "notifyPrologueComplete": "프롤로그 완료!",
+  "notifyActComplete": "{number}막 완료!",
+  "notifyNewSpell": "새 주문!",
+  "notifyNewEquipment": "새 장비!",
+  "notifyBossDefeated": "보스 처치!",
+  "rechargeRollsTitle": "굴리기 충전",
+  "rechargeRollsFree": "무료로 5회 충전하시겠습니까?",
+  "rechargeRollsAd": "광고를 보고 5회 충전하시겠습니까?",
+  "debugTitle": "디버그",
+  "debugCheatsTitle": "디버그 치트",
+  "debugToolsTitle": "디버그 도구",
+  "debugDeveloperTools": "개발자 도구",
+  "debugSkipTask": "태스크 건너뛰기 (L+1)",
+  "debugSkipTaskDesc": "태스크 즉시 완료",
+  "debugSkipQuest": "퀘스트 건너뛰기 (Q!)",
+  "debugSkipQuestDesc": "퀘스트 즉시 완료",
+  "debugSkipAct": "액트 건너뛰기 (P!)",
+  "debugSkipActDesc": "액트 즉시 완료",
+  "debugCreateTestCharacter": "테스트 캐릭터 생성",
+  "debugCreateTestCharacterDesc": "레벨 100 캐릭터를 명예의 전당에 등록",
+  "debugCreateTestCharacterTitle": "테스트 캐릭터 생성?",
+  "debugCreateTestCharacterMessage": "현재 캐릭터가 레벨 100으로 변환되어\n명예의 전당에 등록됩니다.\n\n⚠️ 현재 세이브 파일이 삭제됩니다.\n이 작업은 되돌릴 수 없습니다.",
+  "debugTurbo": "디버그: 터보 (20x)",
+  "debugIapPurchased": "IAP 구매됨",
+  "debugIapPurchasedDesc": "ON: 유료 유저로 동작 (광고 제거)",
+  "debugOfflineHours": "오프라인 시간",
+  "debugOfflineHoursDesc": "복귀 보상 테스트 (재시작 시 적용)",
+  "debugTestCharacterDesc": "현재 캐릭터를 레벨 100으로 수정하여\n명예의 전당에 등록합니다.",
+
+  "arenaTitle": "로컬 아레나",
+  "arenaSelectFighter": "전사를 선택하세요",
+  "arenaEmptyTitle": "영웅이 부족합니다",
+  "arenaEmptyHint": "2명 이상 캐릭터로 클리어하세요",
+  "arenaSetupTitle": "아레나 설정",
+  "arenaStartBattle": "전투 시작",
+  "arenaBattleTitle": "아레나 전투",
+  "arenaMyEquipment": "내 장비",
+  "arenaEnemyEquipment": "상대 장비",
+  "arenaSelected": "선택됨",
+  "arenaRecommended": "추천",
+  "arenaWeaponLocked": "잠김",
+  "arenaVictory": "승리!",
+  "arenaDefeat": "패배...",
+  "arenaEquipmentExchange": "장비 교환",
+  "arenaTurns": "턴",
+  "arenaWinner": "승자",
+  "arenaLoser": "패자",
+  "arenaDefeatedIn": "{winner}이(가) {loser}을(를) {turns}턴 만에 격파",
+  "arenaScoreGain": "+{score} 획득 예정",
+  "arenaScoreLose": "{score} 손실 예정",
+  "arenaEvenTrade": "등가 교환",
+  "arenaScore": "점수",
+
+  "statsStatistics": "통계",
+  "statsSession": "세션",
+  "statsAccumulated": "누적",
+  "statsCombat": "전투",
+  "statsPlayTime": "플레이 시간",
+  "statsMonstersKilled": "처치한 몬스터",
+  "statsBossesDefeated": "보스 처치",
+  "statsDeaths": "사망 횟수",
+  "statsDamage": "데미지",
+  "statsDamageDealt": "입힌 데미지",
+  "statsDamageTaken": "받은 데미지",
+  "statsAverageDps": "평균 DPS",
+  "statsSkills": "스킬",
+  "statsSkillsUsed": "스킬 사용",
+  "statsCriticalHits": "크리티컬 히트",
+  "statsMaxCriticalStreak": "최대 연속 크리티컬",
+  "statsCriticalRate": "크리티컬 비율",
+  "statsEconomy": "경제",
+  "statsGoldEarned": "획득 골드",
+  "statsGoldSpent": "소비 골드",
+  "statsItemsSold": "판매 아이템",
+  "statsPotionsUsed": "물약 사용",
+  "statsProgress": "진행",
+  "statsLevelUps": "레벨업",
+  "statsQuestsCompleted": "완료한 퀘스트",
+  "statsRecords": "기록",
+  "statsHighestLevel": "최고 레벨",
+  "statsHighestGoldHeld": "최대 보유 골드",
+  "statsBestCriticalStreak": "최고 연속 크리티컬",
+  "statsTotalPlay": "총 플레이",
+  "statsTotalPlayTime": "총 플레이 시간",
+  "statsGamesStarted": "시작한 게임",
+  "statsGamesCompleted": "클리어한 게임",
+  "statsCompletionRate": "클리어율",
+  "statsTotalCombat": "총 전투",
+  "statsTotalDeaths": "총 사망",
+  "statsTotalLevelUps": "총 레벨업",
+  "statsTotalDamage": "총 데미지",
+  "statsTotalSkills": "총 스킬",
+  "statsTotalEconomy": "총 경제",
+
+  "notifyLevelUpLabel": "레벨 업",
+  "notifyQuestDoneLabel": "퀘스트 완료",
+  "notifyActClearLabel": "막 완료",
+  "notifyNewSpellLabel": "새 주문",
+  "notifyNewItemLabel": "새 아이템",
+  "notifyBossSlainLabel": "보스 처치",
+  "notifySavedLabel": "저장됨",
+  "notifyInfoLabel": "정보",
+  "notifyWarningLabel": "경고"
 }

lib/l10n/app_localizations.dart

@@ -8,7 +8,6 @@ import 'package:intl/intl.dart' as intl;
 import 'app_localizations_en.dart';
 import 'app_localizations_ja.dart';
 import 'app_localizations_ko.dart';
-import 'app_localizations_zh.dart';
 
 // ignore_for_file: type=lint
 
@@ -98,7 +97,6 @@ abstract class L10n {
     Locale('en'),
     Locale('ja'),
     Locale('ko'),
-    Locale('zh'),
   ];
 
   /// Application title
@@ -652,6 +650,744 @@ abstract class L10n {
   /// In en, this message translates to:
   /// **'HOLD TO SPEED UP'**
   String get endingHoldToSpeedUp;
+
+  /// Menu panel title
+  ///
+  /// In en, this message translates to:
+  /// **'MENU'**
+  String get menuTitle;
+
+  /// Options menu title
+  ///
+  /// In en, this message translates to:
+  /// **'OPTIONS'**
+  String get optionsTitle;
+
+  /// Sound dialog title
+  ///
+  /// In en, this message translates to:
+  /// **'SOUND'**
+  String get soundTitle;
+
+  /// Control section title
+  ///
+  /// In en, this message translates to:
+  /// **'CONTROL'**
+  String get controlSection;
+
+  /// Info section title
+  ///
+  /// In en, this message translates to:
+  /// **'INFO'**
+  String get infoSection;
+
+  /// Settings section title
+  ///
+  /// In en, this message translates to:
+  /// **'SETTINGS'**
+  String get settingsSection;
+
+  /// Save/Exit section title
+  ///
+  /// In en, this message translates to:
+  /// **'SAVE / EXIT'**
+  String get saveExitSection;
+
+  /// OK button
+  ///
+  /// In en, this message translates to:
+  /// **'OK'**
+  String get ok;
+
+  /// Recharge button
+  ///
+  /// In en, this message translates to:
+  /// **'RECHARGE'**
+  String get rechargeButton;
+
+  /// Create button
+  ///
+  /// In en, this message translates to:
+  /// **'CREATE'**
+  String get createButton;
+
+  /// Preview panel title
+  ///
+  /// In en, this message translates to:
+  /// **'PREVIEW'**
+  String get previewTitle;
+
+  /// Name panel title
+  ///
+  /// In en, this message translates to:
+  /// **'NAME'**
+  String get nameTitle;
+
+  /// Stats panel title
+  ///
+  /// In en, this message translates to:
+  /// **'STATS'**
+  String get statsTitle;
+
+  /// Race panel title
+  ///
+  /// In en, this message translates to:
+  /// **'RACE'**
+  String get raceTitle;
+
+  /// Class panel title
+  ///
+  /// In en, this message translates to:
+  /// **'CLASS'**
+  String get classSection;
+
+  /// BGM volume label
+  ///
+  /// In en, this message translates to:
+  /// **'BGM'**
+  String get bgmLabel;
+
+  /// SFX volume label
+  ///
+  /// In en, this message translates to:
+  /// **'SFX'**
+  String get sfxLabel;
+
+  /// HP bar label
+  ///
+  /// In en, this message translates to:
+  /// **'HP'**
+  String get hpLabel;
+
+  /// MP bar label
+  ///
+  /// In en, this message translates to:
+  /// **'MP'**
+  String get mpLabel;
+
+  /// EXP bar label
+  ///
+  /// In en, this message translates to:
+  /// **'EXP'**
+  String get expLabel;
+
+  /// Level up notification title
+  ///
+  /// In en, this message translates to:
+  /// **'LEVEL UP!'**
+  String get notifyLevelUp;
+
+  /// Level notification subtitle
+  ///
+  /// In en, this message translates to:
+  /// **'Level {level}'**
+  String notifyLevel(int level);
+
+  /// Quest complete notification title
+  ///
+  /// In en, this message translates to:
+  /// **'QUEST COMPLETE!'**
+  String get notifyQuestComplete;
+
+  /// Prologue complete notification title
+  ///
+  /// In en, this message translates to:
+  /// **'PROLOGUE COMPLETE!'**
+  String get notifyPrologueComplete;
+
+  /// Act complete notification title
+  ///
+  /// In en, this message translates to:
+  /// **'ACT {number} COMPLETE!'**
+  String notifyActComplete(int number);
+
+  /// New spell notification title
+  ///
+  /// In en, this message translates to:
+  /// **'NEW SPELL!'**
+  String get notifyNewSpell;
+
+  /// New equipment notification title
+  ///
+  /// In en, this message translates to:
+  /// **'NEW EQUIPMENT!'**
+  String get notifyNewEquipment;
+
+  /// Boss defeated notification title
+  ///
+  /// In en, this message translates to:
+  /// **'BOSS DEFEATED!'**
+  String get notifyBossDefeated;
+
+  /// Recharge rolls dialog title
+  ///
+  /// In en, this message translates to:
+  /// **'RECHARGE ROLLS'**
+  String get rechargeRollsTitle;
+
+  /// Recharge rolls free user message
+  ///
+  /// In en, this message translates to:
+  /// **'Recharge 5 rolls for free?'**
+  String get rechargeRollsFree;
+
+  /// Recharge rolls ad message
+  ///
+  /// In en, this message translates to:
+  /// **'Watch an ad to recharge 5 rolls?'**
+  String get rechargeRollsAd;
+
+  /// Debug section title
+  ///
+  /// In en, this message translates to:
+  /// **'DEBUG'**
+  String get debugTitle;
+
+  /// Debug cheats section title
+  ///
+  /// In en, this message translates to:
+  /// **'DEBUG CHEATS'**
+  String get debugCheatsTitle;
+
+  /// Debug tools section title
+  ///
+  /// In en, this message translates to:
+  /// **'DEBUG TOOLS'**
+  String get debugToolsTitle;
+
+  /// Developer tools header
+  ///
+  /// In en, this message translates to:
+  /// **'DEVELOPER TOOLS'**
+  String get debugDeveloperTools;
+
+  /// Skip task cheat label
+  ///
+  /// In en, this message translates to:
+  /// **'SKIP TASK (L+1)'**
+  String get debugSkipTask;
+
+  /// Skip task cheat description
+  ///
+  /// In en, this message translates to:
+  /// **'Complete task instantly'**
+  String get debugSkipTaskDesc;
+
+  /// Skip quest cheat label
+  ///
+  /// In en, this message translates to:
+  /// **'SKIP QUEST (Q!)'**
+  String get debugSkipQuest;
+
+  /// Skip quest cheat description
+  ///
+  /// In en, this message translates to:
+  /// **'Complete quest instantly'**
+  String get debugSkipQuestDesc;
+
+  /// Skip act cheat label
+  ///
+  /// In en, this message translates to:
+  /// **'SKIP ACT (P!)'**
+  String get debugSkipAct;
+
+  /// Skip act cheat description
+  ///
+  /// In en, this message translates to:
+  /// **'Complete act instantly'**
+  String get debugSkipActDesc;
+
+  /// Create test character button
+  ///
+  /// In en, this message translates to:
+  /// **'CREATE TEST CHARACTER'**
+  String get debugCreateTestCharacter;
+
+  /// Create test character description
+  ///
+  /// In en, this message translates to:
+  /// **'Register Level 100 character to Hall of Fame'**
+  String get debugCreateTestCharacterDesc;
+
+  /// Create test character dialog title
+  ///
+  /// In en, this message translates to:
+  /// **'CREATE TEST CHARACTER?'**
+  String get debugCreateTestCharacterTitle;
+
+  /// Create test character confirmation message
+  ///
+  /// In en, this message translates to:
+  /// **'Current character will be converted to Level 100\nand registered to the Hall of Fame.\n\n⚠️ Current save file will be deleted.\nThis action cannot be undone.'**
+  String get debugCreateTestCharacterMessage;
+
+  /// Debug turbo mode label
+  ///
+  /// In en, this message translates to:
+  /// **'DEBUG: TURBO (20x)'**
+  String get debugTurbo;
+
+  /// IAP purchased debug toggle
+  ///
+  /// In en, this message translates to:
+  /// **'IAP PURCHASED'**
+  String get debugIapPurchased;
+
+  /// IAP purchased debug description
+  ///
+  /// In en, this message translates to:
+  /// **'ON: Behave as paid user (ads removed)'**
+  String get debugIapPurchasedDesc;
+
+  /// Offline hours debug label
+  ///
+  /// In en, this message translates to:
+  /// **'OFFLINE HOURS'**
+  String get debugOfflineHours;
+
+  /// Offline hours debug description
+  ///
+  /// In en, this message translates to:
+  /// **'Test return rewards (applies on restart)'**
+  String get debugOfflineHoursDesc;
+
+  /// Test character creation description
+  ///
+  /// In en, this message translates to:
+  /// **'Modify current character to Level 100\nand register to the Hall of Fame.'**
+  String get debugTestCharacterDesc;
+
+  /// Arena main screen title
+  ///
+  /// In en, this message translates to:
+  /// **'LOCAL ARENA'**
+  String get arenaTitle;
+
+  /// Arena character selection subtitle
+  ///
+  /// In en, this message translates to:
+  /// **'SELECT YOUR FIGHTER'**
+  String get arenaSelectFighter;
+
+  /// Arena empty state title
+  ///
+  /// In en, this message translates to:
+  /// **'Not enough heroes'**
+  String get arenaEmptyTitle;
+
+  /// Arena empty state hint
+  ///
+  /// In en, this message translates to:
+  /// **'Clear the game with 2+ characters'**
+  String get arenaEmptyHint;
+
+  /// Arena setup screen title
+  ///
+  /// In en, this message translates to:
+  /// **'ARENA SETUP'**
+  String get arenaSetupTitle;
+
+  /// Start battle button
+  ///
+  /// In en, this message translates to:
+  /// **'START BATTLE'**
+  String get arenaStartBattle;
+
+  /// Arena battle screen title
+  ///
+  /// In en, this message translates to:
+  /// **'ARENA BATTLE'**
+  String get arenaBattleTitle;
+
+  /// My equipment header
+  ///
+  /// In en, this message translates to:
+  /// **'MY EQUIPMENT'**
+  String get arenaMyEquipment;
+
+  /// Enemy equipment header
+  ///
+  /// In en, this message translates to:
+  /// **'ENEMY EQUIPMENT'**
+  String get arenaEnemyEquipment;
+
+  /// Selected slot label
+  ///
+  /// In en, this message translates to:
+  /// **'SELECTED'**
+  String get arenaSelected;
+
+  /// Recommended slot label
+  ///
+  /// In en, this message translates to:
+  /// **'BEST'**
+  String get arenaRecommended;
+
+  /// Weapon slot locked label
+  ///
+  /// In en, this message translates to:
+  /// **'LOCKED'**
+  String get arenaWeaponLocked;
+
+  /// Arena victory title
+  ///
+  /// In en, this message translates to:
+  /// **'VICTORY!'**
+  String get arenaVictory;
+
+  /// Arena defeat title
+  ///
+  /// In en, this message translates to:
+  /// **'DEFEAT...'**
+  String get arenaDefeat;
+
+  /// Equipment exchange section title
+  ///
+  /// In en, this message translates to:
+  /// **'EQUIPMENT EXCHANGE'**
+  String get arenaEquipmentExchange;
+
+  /// Turns label
+  ///
+  /// In en, this message translates to:
+  /// **'TURNS'**
+  String get arenaTurns;
+
+  /// Winner label
+  ///
+  /// In en, this message translates to:
+  /// **'WINNER'**
+  String get arenaWinner;
+
+  /// Loser label
+  ///
+  /// In en, this message translates to:
+  /// **'LOSER'**
+  String get arenaLoser;
+
+  /// Battle summary text
+  ///
+  /// In en, this message translates to:
+  /// **'{winner} defeated {loser} in {turns} TURNS'**
+  String arenaDefeatedIn(String winner, String loser, int turns);
+
+  /// Score gain prediction
+  ///
+  /// In en, this message translates to:
+  /// **'You will GAIN +{score}'**
+  String arenaScoreGain(int score);
+
+  /// Score loss prediction
+  ///
+  /// In en, this message translates to:
+  /// **'You will LOSE {score}'**
+  String arenaScoreLose(int score);
+
+  /// Even trade label
+  ///
+  /// In en, this message translates to:
+  /// **'Even trade'**
+  String get arenaEvenTrade;
+
+  /// Score label
+  ///
+  /// In en, this message translates to:
+  /// **'SCORE'**
+  String get arenaScore;
+
+  /// Statistics dialog title
+  ///
+  /// In en, this message translates to:
+  /// **'Statistics'**
+  String get statsStatistics;
+
+  /// Session tab label
+  ///
+  /// In en, this message translates to:
+  /// **'Session'**
+  String get statsSession;
+
+  /// Accumulated tab label
+  ///
+  /// In en, this message translates to:
+  /// **'Total'**
+  String get statsAccumulated;
+
+  /// Combat section title
+  ///
+  /// In en, this message translates to:
+  /// **'Combat'**
+  String get statsCombat;
+
+  /// Play time label
+  ///
+  /// In en, this message translates to:
+  /// **'Play Time'**
+  String get statsPlayTime;
+
+  /// Monsters killed label
+  ///
+  /// In en, this message translates to:
+  /// **'Monsters Killed'**
+  String get statsMonstersKilled;
+
+  /// Bosses defeated label
+  ///
+  /// In en, this message translates to:
+  /// **'Bosses Defeated'**
+  String get statsBossesDefeated;
+
+  /// Deaths label
+  ///
+  /// In en, this message translates to:
+  /// **'Deaths'**
+  String get statsDeaths;
+
+  /// Damage section title
+  ///
+  /// In en, this message translates to:
+  /// **'Damage'**
+  String get statsDamage;
+
+  /// Damage dealt label
+  ///
+  /// In en, this message translates to:
+  /// **'Damage Dealt'**
+  String get statsDamageDealt;
+
+  /// Damage taken label
+  ///
+  /// In en, this message translates to:
+  /// **'Damage Taken'**
+  String get statsDamageTaken;
+
+  /// Average DPS label
+  ///
+  /// In en, this message translates to:
+  /// **'Average DPS'**
+  String get statsAverageDps;
+
+  /// Skills section title
+  ///
+  /// In en, this message translates to:
+  /// **'Skills'**
+  String get statsSkills;
+
+  /// Skills used label
+  ///
+  /// In en, this message translates to:
+  /// **'Skills Used'**
+  String get statsSkillsUsed;
+
+  /// Critical hits label
+  ///
+  /// In en, this message translates to:
+  /// **'Critical Hits'**
+  String get statsCriticalHits;
+
+  /// Max critical streak label
+  ///
+  /// In en, this message translates to:
+  /// **'Max Critical Streak'**
+  String get statsMaxCriticalStreak;
+
+  /// Critical rate label
+  ///
+  /// In en, this message translates to:
+  /// **'Critical Rate'**
+  String get statsCriticalRate;
+
+  /// Economy section title
+  ///
+  /// In en, this message translates to:
+  /// **'Economy'**
+  String get statsEconomy;
+
+  /// Gold earned label
+  ///
+  /// In en, this message translates to:
+  /// **'Gold Earned'**
+  String get statsGoldEarned;
+
+  /// Gold spent label
+  ///
+  /// In en, this message translates to:
+  /// **'Gold Spent'**
+  String get statsGoldSpent;
+
+  /// Items sold label
+  ///
+  /// In en, this message translates to:
+  /// **'Items Sold'**
+  String get statsItemsSold;
+
+  /// Potions used label
+  ///
+  /// In en, this message translates to:
+  /// **'Potions Used'**
+  String get statsPotionsUsed;
+
+  /// Progress section title
+  ///
+  /// In en, this message translates to:
+  /// **'Progress'**
+  String get statsProgress;
+
+  /// Level ups label
+  ///
+  /// In en, this message translates to:
+  /// **'Level Ups'**
+  String get statsLevelUps;
+
+  /// Quests completed label
+  ///
+  /// In en, this message translates to:
+  /// **'Quests Completed'**
+  String get statsQuestsCompleted;
+
+  /// Records section title
+  ///
+  /// In en, this message translates to:
+  /// **'Records'**
+  String get statsRecords;
+
+  /// Highest level label
+  ///
+  /// In en, this message translates to:
+  /// **'Highest Level'**
+  String get statsHighestLevel;
+
+  /// Highest gold held label
+  ///
+  /// In en, this message translates to:
+  /// **'Highest Gold Held'**
+  String get statsHighestGoldHeld;
+
+  /// Best critical streak label
+  ///
+  /// In en, this message translates to:
+  /// **'Best Critical Streak'**
+  String get statsBestCriticalStreak;
+
+  /// Total play section title
+  ///
+  /// In en, this message translates to:
+  /// **'Total Play'**
+  String get statsTotalPlay;
+
+  /// Total play time label
+  ///
+  /// In en, this message translates to:
+  /// **'Total Play Time'**
+  String get statsTotalPlayTime;
+
+  /// Games started label
+  ///
+  /// In en, this message translates to:
+  /// **'Games Started'**
+  String get statsGamesStarted;
+
+  /// Games completed label
+  ///
+  /// In en, this message translates to:
+  /// **'Games Completed'**
+  String get statsGamesCompleted;
+
+  /// Completion rate label
+  ///
+  /// In en, this message translates to:
+  /// **'Completion Rate'**
+  String get statsCompletionRate;
+
+  /// Total combat section title
+  ///
+  /// In en, this message translates to:
+  /// **'Total Combat'**
+  String get statsTotalCombat;
+
+  /// Total deaths label
+  ///
+  /// In en, this message translates to:
+  /// **'Total Deaths'**
+  String get statsTotalDeaths;
+
+  /// Total level ups label
+  ///
+  /// In en, this message translates to:
+  /// **'Total Level Ups'**
+  String get statsTotalLevelUps;
+
+  /// Total damage section title
+  ///
+  /// In en, this message translates to:
+  /// **'Total Damage'**
+  String get statsTotalDamage;
+
+  /// Total skills section title
+  ///
+  /// In en, this message translates to:
+  /// **'Total Skills'**
+  String get statsTotalSkills;
+
+  /// Total economy section title
+  ///
+  /// In en, this message translates to:
+  /// **'Total Economy'**
+  String get statsTotalEconomy;
+
+  /// Level up notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'LEVEL UP'**
+  String get notifyLevelUpLabel;
+
+  /// Quest done notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'QUEST DONE'**
+  String get notifyQuestDoneLabel;
+
+  /// Act clear notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'ACT CLEAR'**
+  String get notifyActClearLabel;
+
+  /// New spell notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'NEW SPELL'**
+  String get notifyNewSpellLabel;
+
+  /// New item notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'NEW ITEM'**
+  String get notifyNewItemLabel;
+
+  /// Boss slain notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'BOSS SLAIN'**
+  String get notifyBossSlainLabel;
+
+  /// Game saved notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'SAVED'**
+  String get notifySavedLabel;
+
+  /// Info notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'INFO'**
+  String get notifyInfoLabel;
+
+  /// Warning notification type label
+  ///
+  /// In en, this message translates to:
+  /// **'WARNING'**
+  String get notifyWarningLabel;
 }
 
 class _L10nDelegate extends LocalizationsDelegate<L10n> {
@@ -664,7 +1400,7 @@ class _L10nDelegate extends LocalizationsDelegate<L10n> {
 
   @override
   bool isSupported(Locale locale) =>
-      <String>['en', 'ja', 'ko', 'zh'].contains(locale.languageCode);
+      <String>['en', 'ja', 'ko'].contains(locale.languageCode);
 
   @override
   bool shouldReload(_L10nDelegate old) => false;
@@ -679,8 +1415,6 @@ L10n lookupL10n(Locale locale) {
       return L10nJa();
     case 'ko':
       return L10nKo();
-    case 'zh':
-      return L10nZh();
   }
 
   throw FlutterError(

lib/l10n/app_localizations_en.dart

@@ -297,4 +297,387 @@ class L10nEn extends L10n {
 
   @override
   String get endingHoldToSpeedUp => 'HOLD TO SPEED UP';
+
+  @override
+  String get menuTitle => 'MENU';
+
+  @override
+  String get optionsTitle => 'OPTIONS';
+
+  @override
+  String get soundTitle => 'SOUND';
+
+  @override
+  String get controlSection => 'CONTROL';
+
+  @override
+  String get infoSection => 'INFO';
+
+  @override
+  String get settingsSection => 'SETTINGS';
+
+  @override
+  String get saveExitSection => 'SAVE / EXIT';
+
+  @override
+  String get ok => 'OK';
+
+  @override
+  String get rechargeButton => 'RECHARGE';
+
+  @override
+  String get createButton => 'CREATE';
+
+  @override
+  String get previewTitle => 'PREVIEW';
+
+  @override
+  String get nameTitle => 'NAME';
+
+  @override
+  String get statsTitle => 'STATS';
+
+  @override
+  String get raceTitle => 'RACE';
+
+  @override
+  String get classSection => 'CLASS';
+
+  @override
+  String get bgmLabel => 'BGM';
+
+  @override
+  String get sfxLabel => 'SFX';
+
+  @override
+  String get hpLabel => 'HP';
+
+  @override
+  String get mpLabel => 'MP';
+
+  @override
+  String get expLabel => 'EXP';
+
+  @override
+  String get notifyLevelUp => 'LEVEL UP!';
+
+  @override
+  String notifyLevel(int level) {
+    return 'Level $level';
+  }
+
+  @override
+  String get notifyQuestComplete => 'QUEST COMPLETE!';
+
+  @override
+  String get notifyPrologueComplete => 'PROLOGUE COMPLETE!';
+
+  @override
+  String notifyActComplete(int number) {
+    return 'ACT $number COMPLETE!';
+  }
+
+  @override
+  String get notifyNewSpell => 'NEW SPELL!';
+
+  @override
+  String get notifyNewEquipment => 'NEW EQUIPMENT!';
+
+  @override
+  String get notifyBossDefeated => 'BOSS DEFEATED!';
+
+  @override
+  String get rechargeRollsTitle => 'RECHARGE ROLLS';
+
+  @override
+  String get rechargeRollsFree => 'Recharge 5 rolls for free?';
+
+  @override
+  String get rechargeRollsAd => 'Watch an ad to recharge 5 rolls?';
+
+  @override
+  String get debugTitle => 'DEBUG';
+
+  @override
+  String get debugCheatsTitle => 'DEBUG CHEATS';
+
+  @override
+  String get debugToolsTitle => 'DEBUG TOOLS';
+
+  @override
+  String get debugDeveloperTools => 'DEVELOPER TOOLS';
+
+  @override
+  String get debugSkipTask => 'SKIP TASK (L+1)';
+
+  @override
+  String get debugSkipTaskDesc => 'Complete task instantly';
+
+  @override
+  String get debugSkipQuest => 'SKIP QUEST (Q!)';
+
+  @override
+  String get debugSkipQuestDesc => 'Complete quest instantly';
+
+  @override
+  String get debugSkipAct => 'SKIP ACT (P!)';
+
+  @override
+  String get debugSkipActDesc => 'Complete act instantly';
+
+  @override
+  String get debugCreateTestCharacter => 'CREATE TEST CHARACTER';
+
+  @override
+  String get debugCreateTestCharacterDesc =>
+      'Register Level 100 character to Hall of Fame';
+
+  @override
+  String get debugCreateTestCharacterTitle => 'CREATE TEST CHARACTER?';
+
+  @override
+  String get debugCreateTestCharacterMessage =>
+      'Current character will be converted to Level 100\nand registered to the Hall of Fame.\n\n⚠️ Current save file will be deleted.\nThis action cannot be undone.';
+
+  @override
+  String get debugTurbo => 'DEBUG: TURBO (20x)';
+
+  @override
+  String get debugIapPurchased => 'IAP PURCHASED';
+
+  @override
+  String get debugIapPurchasedDesc => 'ON: Behave as paid user (ads removed)';
+
+  @override
+  String get debugOfflineHours => 'OFFLINE HOURS';
+
+  @override
+  String get debugOfflineHoursDesc =>
+      'Test return rewards (applies on restart)';
+
+  @override
+  String get debugTestCharacterDesc =>
+      'Modify current character to Level 100\nand register to the Hall of Fame.';
+
+  @override
+  String get arenaTitle => 'LOCAL ARENA';
+
+  @override
+  String get arenaSelectFighter => 'SELECT YOUR FIGHTER';
+
+  @override
+  String get arenaEmptyTitle => 'Not enough heroes';
+
+  @override
+  String get arenaEmptyHint => 'Clear the game with 2+ characters';
+
+  @override
+  String get arenaSetupTitle => 'ARENA SETUP';
+
+  @override
+  String get arenaStartBattle => 'START BATTLE';
+
+  @override
+  String get arenaBattleTitle => 'ARENA BATTLE';
+
+  @override
+  String get arenaMyEquipment => 'MY EQUIPMENT';
+
+  @override
+  String get arenaEnemyEquipment => 'ENEMY EQUIPMENT';
+
+  @override
+  String get arenaSelected => 'SELECTED';
+
+  @override
+  String get arenaRecommended => 'BEST';
+
+  @override
+  String get arenaWeaponLocked => 'LOCKED';
+
+  @override
+  String get arenaVictory => 'VICTORY!';
+
+  @override
+  String get arenaDefeat => 'DEFEAT...';
+
+  @override
+  String get arenaEquipmentExchange => 'EQUIPMENT EXCHANGE';
+
+  @override
+  String get arenaTurns => 'TURNS';
+
+  @override
+  String get arenaWinner => 'WINNER';
+
+  @override
+  String get arenaLoser => 'LOSER';
+
+  @override
+  String arenaDefeatedIn(String winner, String loser, int turns) {
+    return '$winner defeated $loser in $turns TURNS';
+  }
+
+  @override
+  String arenaScoreGain(int score) {
+    return 'You will GAIN +$score';
+  }
+
+  @override
+  String arenaScoreLose(int score) {
+    return 'You will LOSE $score';
+  }
+
+  @override
+  String get arenaEvenTrade => 'Even trade';
+
+  @override
+  String get arenaScore => 'SCORE';
+
+  @override
+  String get statsStatistics => 'Statistics';
+
+  @override
+  String get statsSession => 'Session';
+
+  @override
+  String get statsAccumulated => 'Total';
+
+  @override
+  String get statsCombat => 'Combat';
+
+  @override
+  String get statsPlayTime => 'Play Time';
+
+  @override
+  String get statsMonstersKilled => 'Monsters Killed';
+
+  @override
+  String get statsBossesDefeated => 'Bosses Defeated';
+
+  @override
+  String get statsDeaths => 'Deaths';
+
+  @override
+  String get statsDamage => 'Damage';
+
+  @override
+  String get statsDamageDealt => 'Damage Dealt';
+
+  @override
+  String get statsDamageTaken => 'Damage Taken';
+
+  @override
+  String get statsAverageDps => 'Average DPS';
+
+  @override
+  String get statsSkills => 'Skills';
+
+  @override
+  String get statsSkillsUsed => 'Skills Used';
+
+  @override
+  String get statsCriticalHits => 'Critical Hits';
+
+  @override
+  String get statsMaxCriticalStreak => 'Max Critical Streak';
+
+  @override
+  String get statsCriticalRate => 'Critical Rate';
+
+  @override
+  String get statsEconomy => 'Economy';
+
+  @override
+  String get statsGoldEarned => 'Gold Earned';
+
+  @override
+  String get statsGoldSpent => 'Gold Spent';
+
+  @override
+  String get statsItemsSold => 'Items Sold';
+
+  @override
+  String get statsPotionsUsed => 'Potions Used';
+
+  @override
+  String get statsProgress => 'Progress';
+
+  @override
+  String get statsLevelUps => 'Level Ups';
+
+  @override
+  String get statsQuestsCompleted => 'Quests Completed';
+
+  @override
+  String get statsRecords => 'Records';
+
+  @override
+  String get statsHighestLevel => 'Highest Level';
+
+  @override
+  String get statsHighestGoldHeld => 'Highest Gold Held';
+
+  @override
+  String get statsBestCriticalStreak => 'Best Critical Streak';
+
+  @override
+  String get statsTotalPlay => 'Total Play';
+
+  @override
+  String get statsTotalPlayTime => 'Total Play Time';
+
+  @override
+  String get statsGamesStarted => 'Games Started';
+
+  @override
+  String get statsGamesCompleted => 'Games Completed';
+
+  @override
+  String get statsCompletionRate => 'Completion Rate';
+
+  @override
+  String get statsTotalCombat => 'Total Combat';
+
+  @override
+  String get statsTotalDeaths => 'Total Deaths';
+
+  @override
+  String get statsTotalLevelUps => 'Total Level Ups';
+
+  @override
+  String get statsTotalDamage => 'Total Damage';
+
+  @override
+  String get statsTotalSkills => 'Total Skills';
+
+  @override
+  String get statsTotalEconomy => 'Total Economy';
+
+  @override
+  String get notifyLevelUpLabel => 'LEVEL UP';
+
+  @override
+  String get notifyQuestDoneLabel => 'QUEST DONE';
+
+  @override
+  String get notifyActClearLabel => 'ACT CLEAR';
+
+  @override
+  String get notifyNewSpellLabel => 'NEW SPELL';
+
+  @override
+  String get notifyNewItemLabel => 'NEW ITEM';
+
+  @override
+  String get notifyBossSlainLabel => 'BOSS SLAIN';
+
+  @override
+  String get notifySavedLabel => 'SAVED';
+
+  @override
+  String get notifyInfoLabel => 'INFO';
+
+  @override
+  String get notifyWarningLabel => 'WARNING';
 }

lib/l10n/app_localizations_ja.dart

@@ -12,75 +12,75 @@ class L10nJa extends L10n {
   String get appTitle => 'アスキー ネバー ダイ';
 
   @override
-  String get tagNoNetwork => 'No network';
+  String get tagNoNetwork => 'オフライン';
 
   @override
-  String get tagIdleRpg => 'Idle RPG loop';
+  String get tagIdleRpg => '放置型RPG';
 
   @override
-  String get tagLocalSaves => 'Local saves';
+  String get tagLocalSaves => 'ローカル保存';
 
   @override
-  String get newCharacter => 'New character';
+  String get newCharacter => '新規キャラクター';
 
   @override
-  String get loadSave => 'Load save';
+  String get loadSave => 'ロード';
 
   @override
-  String get loadGame => 'Load Game';
+  String get loadGame => 'ゲームをロード';
 
   @override
-  String get viewBuildPlan => 'View build plan';
+  String get viewBuildPlan => 'ビルド計画を見る';
 
   @override
-  String get buildRoadmap => 'Build roadmap';
+  String get buildRoadmap => 'ビルドロードマップ';
 
   @override
-  String get techStack => 'Tech stack';
+  String get techStack => '技術スタック';
 
   @override
-  String get cancel => 'Cancel';
+  String get cancel => 'キャンセル';
 
   @override
-  String get exitGame => 'Exit Game';
+  String get exitGame => 'ゲーム終了';
 
   @override
-  String get saveProgressQuestion => 'Save your progress before leaving?';
+  String get saveProgressQuestion => '終了する前にセーブしますか？';
 
   @override
-  String get exitWithoutSaving => 'Exit without saving';
+  String get exitWithoutSaving => 'セーブせずに終了';
 
   @override
-  String get saveAndExit => 'Save and Exit';
+  String get saveAndExit => 'セーブして終了';
 
   @override
   String progressQuestTitle(String name) {
-    return 'ASCII NEVER DIE - $name';
+    return 'アスキー ネバー ダイ - $name';
   }
 
   @override
-  String get levelUp => 'Level Up';
+  String get levelUp => 'レベルアップ';
 
   @override
-  String get completeQuest => 'Complete Quest';
+  String get completeQuest => 'クエスト完了';
 
   @override
-  String get completePlot => 'Complete Plot';
+  String get completePlot => 'プロット完了';
 
   @override
-  String get characterSheet => 'Character Sheet';
+  String get characterSheet => 'キャラクターシート';
 
   @override
-  String get traits => 'Traits';
+  String get traits => '特性';
 
   @override
-  String get stats => 'Stats';
+  String get stats => '能力値';
 
   @override
-  String get experience => 'Experience';
+  String get experience => '経験値';
 
   @override
-  String get xpNeededForNextLevel => 'XP needed for next level';
+  String get xpNeededForNextLevel => '次のレベルまでの必要XP';
 
   @override
   String get spellBook => 'スキル';
@@ -89,34 +89,34 @@ class L10nJa extends L10n {
   String get noSpellsYet => '習得したスキルがありません';
 
   @override
-  String get equipment => 'Equipment';
+  String get equipment => '装備';
 
   @override
-  String get inventory => 'Inventory';
+  String get inventory => 'インベントリ';
 
   @override
-  String get encumbrance => 'Encumbrance';
+  String get encumbrance => '積載量';
 
   @override
   String get combatLog => '戦闘ログ';
 
   @override
-  String get plotDevelopment => 'Plot Development';
+  String get plotDevelopment => 'ストーリー進行';
 
   @override
-  String get quests => 'Quests';
+  String get quests => 'クエスト';
 
   @override
-  String get traitName => 'Name';
+  String get traitName => '名前';
 
   @override
-  String get traitRace => 'Race';
+  String get traitRace => '種族';
 
   @override
-  String get traitClass => 'Class';
+  String get traitClass => '職業';
 
   @override
-  String get traitLevel => 'Level';
+  String get traitLevel => 'レベル';
 
   @override
   String get statStr => 'STR';
@@ -137,43 +137,43 @@ class L10nJa extends L10n {
   String get statCha => 'CHA';
 
   @override
-  String get statHpMax => 'HP Max';
+  String get statHpMax => 'HP最大';
 
   @override
-  String get statMpMax => 'MP Max';
+  String get statMpMax => 'MP最大';
 
   @override
-  String get equipWeapon => 'Weapon';
+  String get equipWeapon => '武器';
 
   @override
-  String get equipShield => 'Shield';
+  String get equipShield => '盾';
 
   @override
-  String get equipHelm => 'Helm';
+  String get equipHelm => '兜';
 
   @override
-  String get equipHauberk => 'Hauberk';
+  String get equipHauberk => '鎧';
 
   @override
-  String get equipBrassairts => 'Brassairts';
+  String get equipBrassairts => '肩当て';
 
   @override
-  String get equipVambraces => 'Vambraces';
+  String get equipVambraces => '腕甲';
 
   @override
-  String get equipGauntlets => 'Gauntlets';
+  String get equipGauntlets => '篭手';
 
   @override
-  String get equipGambeson => 'Gambeson';
+  String get equipGambeson => '防護服';
 
   @override
-  String get equipCuisses => 'Cuisses';
+  String get equipCuisses => '腿当て';
 
   @override
-  String get equipGreaves => 'Greaves';
+  String get equipGreaves => '脛当て';
 
   @override
-  String get equipSollerets => 'Sollerets';
+  String get equipSollerets => '鉄靴';
 
   @override
   String get gold => 'コイン';
@@ -184,63 +184,63 @@ class L10nJa extends L10n {
   }
 
   @override
-  String get prologue => 'Prologue';
+  String get prologue => 'プロローグ';
 
   @override
   String actNumber(String number) {
-    return 'Act $number';
+    return '第$number幕';
   }
 
   @override
-  String get noActiveQuests => 'No active quests';
+  String get noActiveQuests => '進行中のクエストなし';
 
   @override
   String questNumber(int number) {
-    return 'Quest #$number';
+    return 'クエスト #$number';
   }
 
   @override
   String get welcomeMessage => 'ASCII NEVER DIEへようこそ！';
 
   @override
-  String get noSavedGames => 'No saved games found.';
+  String get noSavedGames => 'セーブデータがありません。';
 
   @override
   String loadError(String error) {
-    return 'Failed to load save file: $error';
+    return 'セーブファイルの読み込みに失敗しました: $error';
   }
 
   @override
-  String get name => 'Name';
+  String get name => '名前';
 
   @override
-  String get generateName => 'Generate Name';
+  String get generateName => '名前を生成';
 
   @override
-  String get total => 'Total';
+  String get total => '合計';
 
   @override
   String get unroll => '元に戻す';
 
   @override
-  String get roll => 'Roll';
+  String get roll => 'ロール';
 
   @override
-  String get race => 'Race';
+  String get race => '種族';
 
   @override
-  String get classTitle => 'Class';
+  String get classTitle => '職業';
 
   @override
   String percentComplete(int percent) {
-    return '$percent% complete';
+    return '$percent% 完了';
   }
 
   @override
-  String get newCharacterTitle => 'ASCII NEVER DIE - New Character';
+  String get newCharacterTitle => 'アスキー ネバー ダイ - 新規キャラクター';
 
   @override
-  String get soldButton => 'Sold!';
+  String get soldButton => '決定！';
 
   @override
   String get endingCongratulations => '★ おめでとうございます ★';
@@ -297,4 +297,384 @@ class L10nJa extends L10n {
 
   @override
   String get endingHoldToSpeedUp => '長押しで高速スクロール';
+
+  @override
+  String get menuTitle => 'メニュー';
+
+  @override
+  String get optionsTitle => 'オプション';
+
+  @override
+  String get soundTitle => 'サウンド';
+
+  @override
+  String get controlSection => '操作';
+
+  @override
+  String get infoSection => '情報';
+
+  @override
+  String get settingsSection => '設定';
+
+  @override
+  String get saveExitSection => 'セーブ / 終了';
+
+  @override
+  String get ok => 'OK';
+
+  @override
+  String get rechargeButton => 'チャージ';
+
+  @override
+  String get createButton => '作成';
+
+  @override
+  String get previewTitle => 'プレビュー';
+
+  @override
+  String get nameTitle => '名前';
+
+  @override
+  String get statsTitle => '能力値';
+
+  @override
+  String get raceTitle => '種族';
+
+  @override
+  String get classSection => '職業';
+
+  @override
+  String get bgmLabel => 'BGM';
+
+  @override
+  String get sfxLabel => '効果音';
+
+  @override
+  String get hpLabel => 'HP';
+
+  @override
+  String get mpLabel => 'MP';
+
+  @override
+  String get expLabel => 'EXP';
+
+  @override
+  String get notifyLevelUp => 'レベルアップ！';
+
+  @override
+  String notifyLevel(int level) {
+    return 'レベル $level';
+  }
+
+  @override
+  String get notifyQuestComplete => 'クエスト完了！';
+
+  @override
+  String get notifyPrologueComplete => 'プロローグ完了！';
+
+  @override
+  String notifyActComplete(int number) {
+    return '第$number幕 完了！';
+  }
+
+  @override
+  String get notifyNewSpell => '新しいスキル！';
+
+  @override
+  String get notifyNewEquipment => '新しい装備！';
+
+  @override
+  String get notifyBossDefeated => 'ボス撃破！';
+
+  @override
+  String get rechargeRollsTitle => 'ロール回数チャージ';
+
+  @override
+  String get rechargeRollsFree => '無料で5回チャージしますか？';
+
+  @override
+  String get rechargeRollsAd => '広告を見て5回チャージしますか？';
+
+  @override
+  String get debugTitle => 'デバッグ';
+
+  @override
+  String get debugCheatsTitle => 'デバッグチート';
+
+  @override
+  String get debugToolsTitle => 'デバッグツール';
+
+  @override
+  String get debugDeveloperTools => '開発者ツール';
+
+  @override
+  String get debugSkipTask => 'タスクスキップ (L+1)';
+
+  @override
+  String get debugSkipTaskDesc => 'タスクを即時完了';
+
+  @override
+  String get debugSkipQuest => 'クエストスキップ (Q!)';
+
+  @override
+  String get debugSkipQuestDesc => 'クエストを即時完了';
+
+  @override
+  String get debugSkipAct => 'アクトスキップ (P!)';
+
+  @override
+  String get debugSkipActDesc => 'アクトを即時完了';
+
+  @override
+  String get debugCreateTestCharacter => 'テストキャラクター作成';
+
+  @override
+  String get debugCreateTestCharacterDesc => 'レベル100キャラクターを殿堂に登録';
+
+  @override
+  String get debugCreateTestCharacterTitle => 'テストキャラクターを作成しますか？';
+
+  @override
+  String get debugCreateTestCharacterMessage =>
+      '現在のキャラクターがレベル100に変換され\n殿堂に登録されます。\n\n⚠️ 現在のセーブファイルは削除されます。\nこの操作は元に戻せません。';
+
+  @override
+  String get debugTurbo => 'デバッグ: ターボ (20x)';
+
+  @override
+  String get debugIapPurchased => 'IAP購入済み';
+
+  @override
+  String get debugIapPurchasedDesc => 'ON: 有料ユーザーとして動作（広告非表示）';
+
+  @override
+  String get debugOfflineHours => 'オフライン時間';
+
+  @override
+  String get debugOfflineHoursDesc => '復帰報酬テスト（再起動時に適用）';
+
+  @override
+  String get debugTestCharacterDesc => '現在のキャラクターをレベル100に変更して\n殿堂に登録します。';
+
+  @override
+  String get arenaTitle => 'ローカルアリーナ';
+
+  @override
+  String get arenaSelectFighter => 'ファイターを選択';
+
+  @override
+  String get arenaEmptyTitle => 'ヒーローが不足しています';
+
+  @override
+  String get arenaEmptyHint => '2人以上のキャラでクリアしてください';
+
+  @override
+  String get arenaSetupTitle => 'アリーナ設定';
+
+  @override
+  String get arenaStartBattle => 'バトル開始';
+
+  @override
+  String get arenaBattleTitle => 'アリーナバトル';
+
+  @override
+  String get arenaMyEquipment => '自分の装備';
+
+  @override
+  String get arenaEnemyEquipment => '敵の装備';
+
+  @override
+  String get arenaSelected => '選択済み';
+
+  @override
+  String get arenaRecommended => 'おすすめ';
+
+  @override
+  String get arenaWeaponLocked => 'ロック';
+
+  @override
+  String get arenaVictory => '勝利！';
+
+  @override
+  String get arenaDefeat => '敗北...';
+
+  @override
+  String get arenaEquipmentExchange => '装備交換';
+
+  @override
+  String get arenaTurns => 'ターン';
+
+  @override
+  String get arenaWinner => '勝者';
+
+  @override
+  String get arenaLoser => '敗者';
+
+  @override
+  String arenaDefeatedIn(String winner, String loser, int turns) {
+    return '$winnerが$loserを$turnsターンで撃破';
+  }
+
+  @override
+  String arenaScoreGain(int score) {
+    return '+$score獲得予定';
+  }
+
+  @override
+  String arenaScoreLose(int score) {
+    return '$score損失予定';
+  }
+
+  @override
+  String get arenaEvenTrade => '等価交換';
+
+  @override
+  String get arenaScore => 'スコア';
+
+  @override
+  String get statsStatistics => '統計';
+
+  @override
+  String get statsSession => 'セッション';
+
+  @override
+  String get statsAccumulated => '累積';
+
+  @override
+  String get statsCombat => '戦闘';
+
+  @override
+  String get statsPlayTime => 'プレイ時間';
+
+  @override
+  String get statsMonstersKilled => '倒したモンスター';
+
+  @override
+  String get statsBossesDefeated => 'ボス討伐';
+
+  @override
+  String get statsDeaths => '死亡回数';
+
+  @override
+  String get statsDamage => 'ダメージ';
+
+  @override
+  String get statsDamageDealt => '与えたダメージ';
+
+  @override
+  String get statsDamageTaken => '受けたダメージ';
+
+  @override
+  String get statsAverageDps => '平均DPS';
+
+  @override
+  String get statsSkills => 'スキル';
+
+  @override
+  String get statsSkillsUsed => 'スキル使用';
+
+  @override
+  String get statsCriticalHits => 'クリティカルヒット';
+
+  @override
+  String get statsMaxCriticalStreak => '最大連続クリティカル';
+
+  @override
+  String get statsCriticalRate => 'クリティカル率';
+
+  @override
+  String get statsEconomy => '経済';
+
+  @override
+  String get statsGoldEarned => '獲得ゴールド';
+
+  @override
+  String get statsGoldSpent => '消費ゴールド';
+
+  @override
+  String get statsItemsSold => '売却アイテム';
+
+  @override
+  String get statsPotionsUsed => 'ポーション使用';
+
+  @override
+  String get statsProgress => '進行';
+
+  @override
+  String get statsLevelUps => 'レベルアップ';
+
+  @override
+  String get statsQuestsCompleted => '完了したクエスト';
+
+  @override
+  String get statsRecords => '記録';
+
+  @override
+  String get statsHighestLevel => '最高レベル';
+
+  @override
+  String get statsHighestGoldHeld => '最大所持ゴールド';
+
+  @override
+  String get statsBestCriticalStreak => '最高連続クリティカル';
+
+  @override
+  String get statsTotalPlay => '総プレイ';
+
+  @override
+  String get statsTotalPlayTime => '総プレイ時間';
+
+  @override
+  String get statsGamesStarted => '開始したゲーム';
+
+  @override
+  String get statsGamesCompleted => 'クリアしたゲーム';
+
+  @override
+  String get statsCompletionRate => 'クリア率';
+
+  @override
+  String get statsTotalCombat => '総戦闘';
+
+  @override
+  String get statsTotalDeaths => '総死亡';
+
+  @override
+  String get statsTotalLevelUps => '総レベルアップ';
+
+  @override
+  String get statsTotalDamage => '総ダメージ';
+
+  @override
+  String get statsTotalSkills => '総スキル';
+
+  @override
+  String get statsTotalEconomy => '総経済';
+
+  @override
+  String get notifyLevelUpLabel => 'レベルアップ';
+
+  @override
+  String get notifyQuestDoneLabel => 'クエスト完了';
+
+  @override
+  String get notifyActClearLabel => '幕完了';
+
+  @override
+  String get notifyNewSpellLabel => '新しいスキル';
+
+  @override
+  String get notifyNewItemLabel => '新しいアイテム';
+
+  @override
+  String get notifyBossSlainLabel => 'ボス撃破';
+
+  @override
+  String get notifySavedLabel => 'セーブ済み';
+
+  @override
+  String get notifyInfoLabel => '情報';
+
+  @override
+  String get notifyWarningLabel => '警告';
 }

lib/l10n/app_localizations_ko.dart

@@ -297,4 +297,384 @@ class L10nKo extends L10n {
 
   @override
   String get endingHoldToSpeedUp => '길게 누르면 빨리 스크롤';
+
+  @override
+  String get menuTitle => '메뉴';
+
+  @override
+  String get optionsTitle => '옵션';
+
+  @override
+  String get soundTitle => '사운드';
+
+  @override
+  String get controlSection => '제어';
+
+  @override
+  String get infoSection => '정보';
+
+  @override
+  String get settingsSection => '설정';
+
+  @override
+  String get saveExitSection => '저장 / 종료';
+
+  @override
+  String get ok => '확인';
+
+  @override
+  String get rechargeButton => '충전';
+
+  @override
+  String get createButton => '생성';
+
+  @override
+  String get previewTitle => '미리보기';
+
+  @override
+  String get nameTitle => '이름';
+
+  @override
+  String get statsTitle => '능력치';
+
+  @override
+  String get raceTitle => '종족';
+
+  @override
+  String get classSection => '직업';
+
+  @override
+  String get bgmLabel => 'BGM';
+
+  @override
+  String get sfxLabel => '효과음';
+
+  @override
+  String get hpLabel => 'HP';
+
+  @override
+  String get mpLabel => 'MP';
+
+  @override
+  String get expLabel => '경험치';
+
+  @override
+  String get notifyLevelUp => '레벨 업!';
+
+  @override
+  String notifyLevel(int level) {
+    return '레벨 $level';
+  }
+
+  @override
+  String get notifyQuestComplete => '퀘스트 완료!';
+
+  @override
+  String get notifyPrologueComplete => '프롤로그 완료!';
+
+  @override
+  String notifyActComplete(int number) {
+    return '$number막 완료!';
+  }
+
+  @override
+  String get notifyNewSpell => '새 주문!';
+
+  @override
+  String get notifyNewEquipment => '새 장비!';
+
+  @override
+  String get notifyBossDefeated => '보스 처치!';
+
+  @override
+  String get rechargeRollsTitle => '굴리기 충전';
+
+  @override
+  String get rechargeRollsFree => '무료로 5회 충전하시겠습니까?';
+
+  @override
+  String get rechargeRollsAd => '광고를 보고 5회 충전하시겠습니까?';
+
+  @override
+  String get debugTitle => '디버그';
+
+  @override
+  String get debugCheatsTitle => '디버그 치트';
+
+  @override
+  String get debugToolsTitle => '디버그 도구';
+
+  @override
+  String get debugDeveloperTools => '개발자 도구';
+
+  @override
+  String get debugSkipTask => '태스크 건너뛰기 (L+1)';
+
+  @override
+  String get debugSkipTaskDesc => '태스크 즉시 완료';
+
+  @override
+  String get debugSkipQuest => '퀘스트 건너뛰기 (Q!)';
+
+  @override
+  String get debugSkipQuestDesc => '퀘스트 즉시 완료';
+
+  @override
+  String get debugSkipAct => '액트 건너뛰기 (P!)';
+
+  @override
+  String get debugSkipActDesc => '액트 즉시 완료';
+
+  @override
+  String get debugCreateTestCharacter => '테스트 캐릭터 생성';
+
+  @override
+  String get debugCreateTestCharacterDesc => '레벨 100 캐릭터를 명예의 전당에 등록';
+
+  @override
+  String get debugCreateTestCharacterTitle => '테스트 캐릭터 생성?';
+
+  @override
+  String get debugCreateTestCharacterMessage =>
+      '현재 캐릭터가 레벨 100으로 변환되어\n명예의 전당에 등록됩니다.\n\n⚠️ 현재 세이브 파일이 삭제됩니다.\n이 작업은 되돌릴 수 없습니다.';
+
+  @override
+  String get debugTurbo => '디버그: 터보 (20x)';
+
+  @override
+  String get debugIapPurchased => 'IAP 구매됨';
+
+  @override
+  String get debugIapPurchasedDesc => 'ON: 유료 유저로 동작 (광고 제거)';
+
+  @override
+  String get debugOfflineHours => '오프라인 시간';
+
+  @override
+  String get debugOfflineHoursDesc => '복귀 보상 테스트 (재시작 시 적용)';
+
+  @override
+  String get debugTestCharacterDesc => '현재 캐릭터를 레벨 100으로 수정하여\n명예의 전당에 등록합니다.';
+
+  @override
+  String get arenaTitle => '로컬 아레나';
+
+  @override
+  String get arenaSelectFighter => '전사를 선택하세요';
+
+  @override
+  String get arenaEmptyTitle => '영웅이 부족합니다';
+
+  @override
+  String get arenaEmptyHint => '2명 이상 캐릭터로 클리어하세요';
+
+  @override
+  String get arenaSetupTitle => '아레나 설정';
+
+  @override
+  String get arenaStartBattle => '전투 시작';
+
+  @override
+  String get arenaBattleTitle => '아레나 전투';
+
+  @override
+  String get arenaMyEquipment => '내 장비';
+
+  @override
+  String get arenaEnemyEquipment => '상대 장비';
+
+  @override
+  String get arenaSelected => '선택됨';
+
+  @override
+  String get arenaRecommended => '추천';
+
+  @override
+  String get arenaWeaponLocked => '잠김';
+
+  @override
+  String get arenaVictory => '승리!';
+
+  @override
+  String get arenaDefeat => '패배...';
+
+  @override
+  String get arenaEquipmentExchange => '장비 교환';
+
+  @override
+  String get arenaTurns => '턴';
+
+  @override
+  String get arenaWinner => '승자';
+
+  @override
+  String get arenaLoser => '패자';
+
+  @override
+  String arenaDefeatedIn(String winner, String loser, int turns) {
+    return '$winner이(가) $loser을(를) $turns턴 만에 격파';
+  }
+
+  @override
+  String arenaScoreGain(int score) {
+    return '+$score 획득 예정';
+  }
+
+  @override
+  String arenaScoreLose(int score) {
+    return '$score 손실 예정';
+  }
+
+  @override
+  String get arenaEvenTrade => '등가 교환';
+
+  @override
+  String get arenaScore => '점수';
+
+  @override
+  String get statsStatistics => '통계';
+
+  @override
+  String get statsSession => '세션';
+
+  @override
+  String get statsAccumulated => '누적';
+
+  @override
+  String get statsCombat => '전투';
+
+  @override
+  String get statsPlayTime => '플레이 시간';
+
+  @override
+  String get statsMonstersKilled => '처치한 몬스터';
+
+  @override
+  String get statsBossesDefeated => '보스 처치';
+
+  @override
+  String get statsDeaths => '사망 횟수';
+
+  @override
+  String get statsDamage => '데미지';
+
+  @override
+  String get statsDamageDealt => '입힌 데미지';
+
+  @override
+  String get statsDamageTaken => '받은 데미지';
+
+  @override
+  String get statsAverageDps => '평균 DPS';
+
+  @override
+  String get statsSkills => '스킬';
+
+  @override
+  String get statsSkillsUsed => '스킬 사용';
+
+  @override
+  String get statsCriticalHits => '크리티컬 히트';
+
+  @override
+  String get statsMaxCriticalStreak => '최대 연속 크리티컬';
+
+  @override
+  String get statsCriticalRate => '크리티컬 비율';
+
+  @override
+  String get statsEconomy => '경제';
+
+  @override
+  String get statsGoldEarned => '획득 골드';
+
+  @override
+  String get statsGoldSpent => '소비 골드';
+
+  @override
+  String get statsItemsSold => '판매 아이템';
+
+  @override
+  String get statsPotionsUsed => '물약 사용';
+
+  @override
+  String get statsProgress => '진행';
+
+  @override
+  String get statsLevelUps => '레벨업';
+
+  @override
+  String get statsQuestsCompleted => '완료한 퀘스트';
+
+  @override
+  String get statsRecords => '기록';
+
+  @override
+  String get statsHighestLevel => '최고 레벨';
+
+  @override
+  String get statsHighestGoldHeld => '최대 보유 골드';
+
+  @override
+  String get statsBestCriticalStreak => '최고 연속 크리티컬';
+
+  @override
+  String get statsTotalPlay => '총 플레이';
+
+  @override
+  String get statsTotalPlayTime => '총 플레이 시간';
+
+  @override
+  String get statsGamesStarted => '시작한 게임';
+
+  @override
+  String get statsGamesCompleted => '클리어한 게임';
+
+  @override
+  String get statsCompletionRate => '클리어율';
+
+  @override
+  String get statsTotalCombat => '총 전투';
+
+  @override
+  String get statsTotalDeaths => '총 사망';
+
+  @override
+  String get statsTotalLevelUps => '총 레벨업';
+
+  @override
+  String get statsTotalDamage => '총 데미지';
+
+  @override
+  String get statsTotalSkills => '총 스킬';
+
+  @override
+  String get statsTotalEconomy => '총 경제';
+
+  @override
+  String get notifyLevelUpLabel => '레벨 업';
+
+  @override
+  String get notifyQuestDoneLabel => '퀘스트 완료';
+
+  @override
+  String get notifyActClearLabel => '막 완료';
+
+  @override
+  String get notifyNewSpellLabel => '새 주문';
+
+  @override
+  String get notifyNewItemLabel => '새 아이템';
+
+  @override
+  String get notifyBossSlainLabel => '보스 처치';
+
+  @override
+  String get notifySavedLabel => '저장됨';
+
+  @override
+  String get notifyInfoLabel => '정보';
+
+  @override
+  String get notifyWarningLabel => '경고';
 }

lib/l10n/app_localizations_zh.dart

@@ -1,300 +0,0 @@
-// ignore: unused_import
-import 'package:intl/intl.dart' as intl;
-import 'app_localizations.dart';
-
-// ignore_for_file: type=lint
-
-/// The translations for Chinese (`zh`).
-class L10nZh extends L10n {
-  L10nZh([String locale = 'zh']) : super(locale);
-
-  @override
-  String get appTitle => 'ASCII NEVER DIE';
-
-  @override
-  String get tagNoNetwork => 'No network';
-
-  @override
-  String get tagIdleRpg => 'Idle RPG loop';
-
-  @override
-  String get tagLocalSaves => 'Local saves';
-
-  @override
-  String get newCharacter => 'New character';
-
-  @override
-  String get loadSave => 'Load save';
-
-  @override
-  String get loadGame => 'Load Game';
-
-  @override
-  String get viewBuildPlan => 'View build plan';
-
-  @override
-  String get buildRoadmap => 'Build roadmap';
-
-  @override
-  String get techStack => 'Tech stack';
-
-  @override
-  String get cancel => 'Cancel';
-
-  @override
-  String get exitGame => 'Exit Game';
-
-  @override
-  String get saveProgressQuestion => 'Save your progress before leaving?';
-
-  @override
-  String get exitWithoutSaving => 'Exit without saving';
-
-  @override
-  String get saveAndExit => 'Save and Exit';
-
-  @override
-  String progressQuestTitle(String name) {
-    return 'ASCII NEVER DIE - $name';
-  }
-
-  @override
-  String get levelUp => 'Level Up';
-
-  @override
-  String get completeQuest => 'Complete Quest';
-
-  @override
-  String get completePlot => 'Complete Plot';
-
-  @override
-  String get characterSheet => 'Character Sheet';
-
-  @override
-  String get traits => 'Traits';
-
-  @override
-  String get stats => 'Stats';
-
-  @override
-  String get experience => 'Experience';
-
-  @override
-  String get xpNeededForNextLevel => 'XP needed for next level';
-
-  @override
-  String get spellBook => '技能';
-
-  @override
-  String get noSpellsYet => '暂无技能';
-
-  @override
-  String get equipment => 'Equipment';
-
-  @override
-  String get inventory => 'Inventory';
-
-  @override
-  String get encumbrance => 'Encumbrance';
-
-  @override
-  String get combatLog => '战斗日志';
-
-  @override
-  String get plotDevelopment => 'Plot Development';
-
-  @override
-  String get quests => 'Quests';
-
-  @override
-  String get traitName => 'Name';
-
-  @override
-  String get traitRace => 'Race';
-
-  @override
-  String get traitClass => 'Class';
-
-  @override
-  String get traitLevel => 'Level';
-
-  @override
-  String get statStr => 'STR';
-
-  @override
-  String get statCon => 'CON';
-
-  @override
-  String get statDex => 'DEX';
-
-  @override
-  String get statInt => 'INT';
-
-  @override
-  String get statWis => 'WIS';
-
-  @override
-  String get statCha => 'CHA';
-
-  @override
-  String get statHpMax => 'HP Max';
-
-  @override
-  String get statMpMax => 'MP Max';
-
-  @override
-  String get equipWeapon => 'Weapon';
-
-  @override
-  String get equipShield => 'Shield';
-
-  @override
-  String get equipHelm => 'Helm';
-
-  @override
-  String get equipHauberk => 'Hauberk';
-
-  @override
-  String get equipBrassairts => 'Brassairts';
-
-  @override
-  String get equipVambraces => 'Vambraces';
-
-  @override
-  String get equipGauntlets => 'Gauntlets';
-
-  @override
-  String get equipGambeson => 'Gambeson';
-
-  @override
-  String get equipCuisses => 'Cuisses';
-
-  @override
-  String get equipGreaves => 'Greaves';
-
-  @override
-  String get equipSollerets => 'Sollerets';
-
-  @override
-  String get gold => 'Gold';
-
-  @override
-  String goldAmount(int amount) {
-    return 'Gold: $amount';
-  }
-
-  @override
-  String get prologue => 'Prologue';
-
-  @override
-  String actNumber(String number) {
-    return 'Act $number';
-  }
-
-  @override
-  String get noActiveQuests => 'No active quests';
-
-  @override
-  String questNumber(int number) {
-    return 'Quest #$number';
-  }
-
-  @override
-  String get welcomeMessage => '欢迎来到ASCII NEVER DIE！';
-
-  @override
-  String get noSavedGames => 'No saved games found.';
-
-  @override
-  String loadError(String error) {
-    return 'Failed to load save file: $error';
-  }
-
-  @override
-  String get name => 'Name';
-
-  @override
-  String get generateName => 'Generate Name';
-
-  @override
-  String get total => 'Total';
-
-  @override
-  String get unroll => '撤销';
-
-  @override
-  String get roll => 'Roll';
-
-  @override
-  String get race => 'Race';
-
-  @override
-  String get classTitle => 'Class';
-
-  @override
-  String percentComplete(int percent) {
-    return '$percent% complete';
-  }
-
-  @override
-  String get newCharacterTitle => 'ASCII NEVER DIE - New Character';
-
-  @override
-  String get soldButton => 'Sold!';
-
-  @override
-  String get endingCongratulations => '★ 恭喜通关 ★';
-
-  @override
-  String get endingGameComplete => '您已完成游戏！';
-
-  @override
-  String get endingTheHero => '英雄';
-
-  @override
-  String endingLevelFormat(int level) {
-    return '等级 $level';
-  }
-
-  @override
-  String get endingJourneyStats => '冒险记录';
-
-  @override
-  String get endingMonstersSlain => '击败的怪物';
-
-  @override
-  String get endingQuestsCompleted => '完成的任务';
-
-  @override
-  String get endingPlayTime => '游戏时间';
-
-  @override
-  String get endingFinalStats => '最终属性';
-
-  @override
-  String get endingCredits => '制作人员';
-
-  @override
-  String get endingThankYou => '感谢您的游玩！';
-
-  @override
-  String get endingLegendLivesOn => '您的传奇将永远流传...';
-
-  @override
-  String get endingHallOfFameLine1 => '您的英雄事迹';
-
-  @override
-  String get endingHallOfFameLine2 => '将被铭记于荣誉殿堂';
-
-  @override
-  String get endingHallOfFameButton => '荣誉殿堂';
-
-  @override
-  String get endingSkip => '跳过';
-
-  @override
-  String get endingTapToSkip => '点击跳过';
-
-  @override
-  String get endingHoldToSpeedUp => '长按加速滚动';
-}

lib/l10n/app_zh.arb

@@ -1,97 +0,0 @@
-{
-  "@@locale": "zh",
-
-  "appTitle": "ASCII NEVER DIE",
-  "tagNoNetwork": "No network",
-  "tagIdleRpg": "Idle RPG loop",
-  "tagLocalSaves": "Local saves",
-  "newCharacter": "New character",
-  "loadSave": "Load save",
-  "loadGame": "Load Game",
-  "viewBuildPlan": "View build plan",
-  "buildRoadmap": "Build roadmap",
-  "techStack": "Tech stack",
-  "cancel": "Cancel",
-  "exitGame": "Exit Game",
-  "saveProgressQuestion": "Save your progress before leaving?",
-  "exitWithoutSaving": "Exit without saving",
-  "saveAndExit": "Save and Exit",
-  "progressQuestTitle": "ASCII NEVER DIE - {name}",
-  "levelUp": "Level Up",
-  "completeQuest": "Complete Quest",
-  "completePlot": "Complete Plot",
-  "characterSheet": "Character Sheet",
-  "traits": "Traits",
-  "stats": "Stats",
-  "experience": "Experience",
-  "xpNeededForNextLevel": "XP needed for next level",
-  "spellBook": "技能",
-  "noSpellsYet": "暂无技能",
-  "equipment": "Equipment",
-  "inventory": "Inventory",
-  "encumbrance": "Encumbrance",
-  "combatLog": "战斗日志",
-  "plotDevelopment": "Plot Development",
-  "quests": "Quests",
-  "traitName": "Name",
-  "traitRace": "Race",
-  "traitClass": "Class",
-  "traitLevel": "Level",
-  "statStr": "STR",
-  "statCon": "CON",
-  "statDex": "DEX",
-  "statInt": "INT",
-  "statWis": "WIS",
-  "statCha": "CHA",
-  "statHpMax": "HP Max",
-  "statMpMax": "MP Max",
-  "equipWeapon": "Weapon",
-  "equipShield": "Shield",
-  "equipHelm": "Helm",
-  "equipHauberk": "Hauberk",
-  "equipBrassairts": "Brassairts",
-  "equipVambraces": "Vambraces",
-  "equipGauntlets": "Gauntlets",
-  "equipGambeson": "Gambeson",
-  "equipCuisses": "Cuisses",
-  "equipGreaves": "Greaves",
-  "equipSollerets": "Sollerets",
-  "gold": "Gold",
-  "goldAmount": "Gold: {amount}",
-  "prologue": "Prologue",
-  "actNumber": "Act {number}",
-  "noActiveQuests": "No active quests",
-  "questNumber": "Quest #{number}",
-  "welcomeMessage": "欢迎来到ASCII NEVER DIE！",
-  "noSavedGames": "No saved games found.",
-  "loadError": "Failed to load save file: {error}",
-  "name": "Name",
-  "generateName": "Generate Name",
-  "total": "Total",
-  "unroll": "撤销",
-  "roll": "Roll",
-  "race": "Race",
-  "classTitle": "Class",
-  "percentComplete": "{percent}% complete",
-  "newCharacterTitle": "ASCII NEVER DIE - New Character",
-  "soldButton": "Sold!",
-
-  "endingCongratulations": "★ 恭喜通关 ★",
-  "endingGameComplete": "您已完成游戏！",
-  "endingTheHero": "英雄",
-  "endingLevelFormat": "等级 {level}",
-  "endingJourneyStats": "冒险记录",
-  "endingMonstersSlain": "击败的怪物",
-  "endingQuestsCompleted": "完成的任务",
-  "endingPlayTime": "游戏时间",
-  "endingFinalStats": "最终属性",
-  "endingCredits": "制作人员",
-  "endingThankYou": "感谢您的游玩！",
-  "endingLegendLivesOn": "您的传奇将永远流传...",
-  "endingHallOfFameLine1": "您的英雄事迹",
-  "endingHallOfFameLine2": "将被铭记于荣誉殿堂",
-  "endingHallOfFameButton": "荣誉殿堂",
-  "endingSkip": "跳过",
-  "endingTapToSkip": "点击跳过",
-  "endingHoldToSpeedUp": "长按加速滚动"
-}

lib/src/app.dart

@@ -6,7 +6,8 @@ import 'package:asciineverdie/src/core/audio/audio_service.dart';
 import 'package:asciineverdie/src/core/engine/ad_service.dart';
 import 'package:asciineverdie/src/core/engine/debug_settings_service.dart';
 import 'package:asciineverdie/src/core/engine/iap_service.dart';
-import 'package:asciineverdie/src/shared/retro_colors.dart';
+import 'package:asciineverdie/src/app_theme.dart';
+import 'package:asciineverdie/src/splash_screen.dart';
 import 'package:asciineverdie/src/core/engine/game_mutations.dart';
 import 'package:asciineverdie/src/core/engine/progress_service.dart';
 import 'package:asciineverdie/src/core/engine/reward_service.dart';
@@ -221,140 +222,6 @@ class _AskiiNeverDieAppState extends State<AskiiNeverDieApp>
     }
   }
 
-  /// 앱 테마 (Dark Fantasy 스타일)
-  ThemeData get _theme => ThemeData(
-    colorScheme: RetroColors.darkColorScheme,
-    scaffoldBackgroundColor: RetroColors.deepBrown,
-    useMaterial3: true,
-    // 카드/다이얼로그 레트로 배경
-    cardColor: RetroColors.darkBrown,
-    dialogTheme: const DialogThemeData(
-      backgroundColor: Color(0xFF24283B),
-      titleTextStyle: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 15,
-        color: Color(0xFFE0AF68),
-      ),
-    ),
-    // 앱바 레트로 스타일
-    appBarTheme: const AppBarTheme(
-      backgroundColor: Color(0xFF24283B),
-      foregroundColor: Color(0xFFC0CAF5),
-      titleTextStyle: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 15,
-        color: Color(0xFFE0AF68),
-      ),
-    ),
-    // 버튼 테마 (inherit: false로 애니메이션 lerp 오류 방지)
-    filledButtonTheme: FilledButtonThemeData(
-      style: FilledButton.styleFrom(
-        backgroundColor: const Color(0xFF3D4260),
-        foregroundColor: const Color(0xFFC0CAF5),
-        textStyle: const TextStyle(
-          inherit: false,
-          fontFamily: 'PressStart2P',
-          fontSize: 14,
-          color: Color(0xFFC0CAF5),
-        ),
-      ),
-    ),
-    outlinedButtonTheme: OutlinedButtonThemeData(
-      style: OutlinedButton.styleFrom(
-        foregroundColor: const Color(0xFFE0AF68),
-        side: const BorderSide(color: Color(0xFFE0AF68), width: 2),
-        textStyle: const TextStyle(
-          inherit: false,
-          fontFamily: 'PressStart2P',
-          fontSize: 14,
-          color: Color(0xFFE0AF68),
-        ),
-      ),
-    ),
-    textButtonTheme: TextButtonThemeData(
-      style: TextButton.styleFrom(
-        foregroundColor: const Color(0xFFC0CAF5),
-        textStyle: const TextStyle(
-          inherit: false,
-          fontFamily: 'PressStart2P',
-          fontSize: 14,
-          color: Color(0xFFC0CAF5),
-        ),
-      ),
-    ),
-    // 텍스트 테마
-    textTheme: const TextTheme(
-      headlineLarge: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 20,
-        color: Color(0xFFE0AF68),
-      ),
-      headlineMedium: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 16,
-        color: Color(0xFFE0AF68),
-      ),
-      headlineSmall: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 15,
-        color: Color(0xFFE0AF68),
-      ),
-      titleLarge: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 15,
-        color: Color(0xFFC0CAF5),
-      ),
-      titleMedium: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 14,
-        color: Color(0xFFC0CAF5),
-      ),
-      titleSmall: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 14,
-        color: Color(0xFFC0CAF5),
-      ),
-      bodyLarge: TextStyle(fontSize: 18, color: Color(0xFFC0CAF5)),
-      bodyMedium: TextStyle(fontSize: 17, color: Color(0xFFC0CAF5)),
-      bodySmall: TextStyle(fontSize: 15, color: Color(0xFFC0CAF5)),
-      labelLarge: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 14,
-        color: Color(0xFFC0CAF5),
-      ),
-      labelMedium: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 14,
-        color: Color(0xFFC0CAF5),
-      ),
-      labelSmall: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 13,
-        color: Color(0xFFC0CAF5),
-      ),
-    ),
-    // 칩 테마
-    chipTheme: const ChipThemeData(
-      backgroundColor: Color(0xFF2A2E3F),
-      labelStyle: TextStyle(
-        fontFamily: 'PressStart2P',
-        fontSize: 14,
-        color: Color(0xFFC0CAF5),
-      ),
-      side: BorderSide(color: Color(0xFF545C7E)),
-    ),
-    // 리스트 타일 테마
-    listTileTheme: const ListTileThemeData(
-      textColor: Color(0xFFC0CAF5),
-      iconColor: Color(0xFFE0AF68),
-    ),
-    // 프로그레스 인디케이터
-    progressIndicatorTheme: const ProgressIndicatorThemeData(
-      color: Color(0xFFE0AF68),
-      linearTrackColor: Color(0xFF3B4261),
-    ),
-  );
-
   @override
   Widget build(BuildContext context) {
     return MaterialApp(
@@ -363,7 +230,7 @@ class _AskiiNeverDieAppState extends State<AskiiNeverDieApp>
       localizationsDelegates: L10n.localizationsDelegates,
       supportedLocales: L10n.supportedLocales,
       locale: _locale, // 사용자 선택 로케일 (null이면 시스템 기본값)
-      theme: _theme,
+      theme: buildAppTheme(),
       navigatorObservers: [_routeObserver],
       builder: (context, child) {
         // 현재 로케일을 게임 텍스트 l10n 시스템에 동기화
@@ -382,7 +249,7 @@ class _AskiiNeverDieAppState extends State<AskiiNeverDieApp>
   Widget _buildHomeScreen() {
     // 세이브 확인 중이면 로딩 스플래시 표시
     if (_isCheckingSave) {
-      return const _SplashScreen();
+      return const SplashScreen();
     }
 
     return FrontScreen(
@@ -591,133 +458,3 @@ class _AskiiNeverDieAppState extends State<AskiiNeverDieApp>
   }
 }
 
-/// 스플래시 화면 (세이브 파일 확인 중) - 레트로 스타일
-class _SplashScreen extends StatelessWidget {
-  const _SplashScreen();
-
-  @override
-  Widget build(BuildContext context) {
-    return Scaffold(
-      backgroundColor: RetroColors.deepBrown,
-      body: Center(
-        child: Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            // 타이틀 로고
-            Container(
-              padding: const EdgeInsets.symmetric(horizontal: 24, vertical: 16),
-              decoration: BoxDecoration(
-                color: RetroColors.panelBg,
-                border: Border.all(color: RetroColors.gold, width: 3),
-              ),
-              child: Column(
-                children: [
-                  // 아이콘
-                  const Icon(
-                    Icons.auto_awesome,
-                    size: 32,
-                    color: RetroColors.gold,
-                  ),
-                  const SizedBox(height: 12),
-                  // 타이틀
-                  const Text(
-                    'ASCII',
-                    style: TextStyle(
-                      fontFamily: 'PressStart2P',
-                      fontSize: 22,
-                      color: RetroColors.gold,
-                      shadows: [
-                        Shadow(
-                          color: RetroColors.goldDark,
-                          offset: Offset(2, 2),
-                        ),
-                      ],
-                    ),
-                  ),
-                  const SizedBox(height: 4),
-                  const Text(
-                    'NEVER DIE',
-                    style: TextStyle(
-                      fontFamily: 'PressStart2P',
-                      fontSize: 16,
-                      color: RetroColors.cream,
-                      shadows: [
-                        Shadow(color: RetroColors.brown, offset: Offset(1, 1)),
-                      ],
-                    ),
-                  ),
-                ],
-              ),
-            ),
-            const SizedBox(height: 32),
-            // 레트로 로딩 바
-            SizedBox(width: 160, child: _RetroLoadingBar()),
-          ],
-        ),
-      ),
-    );
-  }
-}
-
-/// 레트로 스타일 로딩 바 (애니메이션)
-class _RetroLoadingBar extends StatefulWidget {
-  @override
-  State<_RetroLoadingBar> createState() => _RetroLoadingBarState();
-}
-
-class _RetroLoadingBarState extends State<_RetroLoadingBar>
-    with SingleTickerProviderStateMixin {
-  late AnimationController _controller;
-
-  @override
-  void initState() {
-    super.initState();
-    _controller = AnimationController(
-      duration: const Duration(milliseconds: 1500),
-      vsync: this,
-    )..repeat();
-  }
-
-  @override
-  void dispose() {
-    _controller.dispose();
-    super.dispose();
-  }
-
-  @override
-  Widget build(BuildContext context) {
-    const segmentCount = 10;
-
-    return AnimatedBuilder(
-      animation: _controller,
-      builder: (context, child) {
-        // 웨이브 효과: 각 세그먼트가 순차적으로 켜지고 꺼짐
-        return Container(
-          height: 16,
-          decoration: BoxDecoration(
-            color: RetroColors.panelBg,
-            border: Border.all(color: RetroColors.panelBorderOuter, width: 2),
-          ),
-          child: Row(
-            children: List.generate(segmentCount, (index) {
-              // 웨이브 패턴 계산
-              final progress = _controller.value * segmentCount;
-              final distance = (index - progress).abs();
-              final isLit = distance < 2 || (segmentCount - distance) < 2;
-              final opacity = isLit ? 1.0 : 0.2;
-
-              return Expanded(
-                child: Container(
-                  margin: const EdgeInsets.all(1),
-                  decoration: BoxDecoration(
-                    color: RetroColors.gold.withValues(alpha: opacity),
-                  ),
-                ),
-              );
-            }),
-          ),
-        );
-      },
-    );
-  }
-}

lib/src/app_theme.dart

@@ -0,0 +1,137 @@
+import 'package:flutter/material.dart';
+
+import 'package:asciineverdie/src/shared/retro_colors.dart';
+
+/// 앱 테마 (Dark Fantasy 스타일)
+ThemeData buildAppTheme() => ThemeData(
+  colorScheme: RetroColors.darkColorScheme,
+  scaffoldBackgroundColor: RetroColors.deepBrown,
+  useMaterial3: true,
+  // 카드/다이얼로그 레트로 배경
+  cardColor: RetroColors.darkBrown,
+  dialogTheme: const DialogThemeData(
+    backgroundColor: Color(0xFF24283B),
+    titleTextStyle: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 15,
+      color: Color(0xFFE0AF68),
+    ),
+  ),
+  // 앱바 레트로 스타일
+  appBarTheme: const AppBarTheme(
+    backgroundColor: Color(0xFF24283B),
+    foregroundColor: Color(0xFFC0CAF5),
+    titleTextStyle: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 15,
+      color: Color(0xFFE0AF68),
+    ),
+  ),
+  // 버튼 테마 (inherit: false로 애니메이션 lerp 오류 방지)
+  filledButtonTheme: FilledButtonThemeData(
+    style: FilledButton.styleFrom(
+      backgroundColor: const Color(0xFF3D4260),
+      foregroundColor: const Color(0xFFC0CAF5),
+      textStyle: const TextStyle(
+        inherit: false,
+        fontFamily: 'PressStart2P',
+        fontSize: 14,
+        color: Color(0xFFC0CAF5),
+      ),
+    ),
+  ),
+  outlinedButtonTheme: OutlinedButtonThemeData(
+    style: OutlinedButton.styleFrom(
+      foregroundColor: const Color(0xFFE0AF68),
+      side: const BorderSide(color: Color(0xFFE0AF68), width: 2),
+      textStyle: const TextStyle(
+        inherit: false,
+        fontFamily: 'PressStart2P',
+        fontSize: 14,
+        color: Color(0xFFE0AF68),
+      ),
+    ),
+  ),
+  textButtonTheme: TextButtonThemeData(
+    style: TextButton.styleFrom(
+      foregroundColor: const Color(0xFFC0CAF5),
+      textStyle: const TextStyle(
+        inherit: false,
+        fontFamily: 'PressStart2P',
+        fontSize: 14,
+        color: Color(0xFFC0CAF5),
+      ),
+    ),
+  ),
+  // 텍스트 테마
+  textTheme: const TextTheme(
+    headlineLarge: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 20,
+      color: Color(0xFFE0AF68),
+    ),
+    headlineMedium: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 16,
+      color: Color(0xFFE0AF68),
+    ),
+    headlineSmall: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 15,
+      color: Color(0xFFE0AF68),
+    ),
+    titleLarge: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 15,
+      color: Color(0xFFC0CAF5),
+    ),
+    titleMedium: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 14,
+      color: Color(0xFFC0CAF5),
+    ),
+    titleSmall: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 14,
+      color: Color(0xFFC0CAF5),
+    ),
+    bodyLarge: TextStyle(fontSize: 18, color: Color(0xFFC0CAF5)),
+    bodyMedium: TextStyle(fontSize: 17, color: Color(0xFFC0CAF5)),
+    bodySmall: TextStyle(fontSize: 15, color: Color(0xFFC0CAF5)),
+    labelLarge: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 14,
+      color: Color(0xFFC0CAF5),
+    ),
+    labelMedium: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 14,
+      color: Color(0xFFC0CAF5),
+    ),
+    labelSmall: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 13,
+      color: Color(0xFFC0CAF5),
+    ),
+  ),
+  // 칩 테마
+  chipTheme: const ChipThemeData(
+    backgroundColor: Color(0xFF2A2E3F),
+    labelStyle: TextStyle(
+      fontFamily: 'PressStart2P',
+      fontSize: 14,
+      color: Color(0xFFC0CAF5),
+    ),
+    side: BorderSide(color: Color(0xFF545C7E)),
+  ),
+  // 리스트 타일 테마
+  listTileTheme: const ListTileThemeData(
+    textColor: Color(0xFFC0CAF5),
+    iconColor: Color(0xFFE0AF68),
+  ),
+  // 프로그레스 인디케이터
+  progressIndicatorTheme: const ProgressIndicatorThemeData(
+    color: Color(0xFFE0AF68),
+    linearTrackColor: Color(0xFF3B4261),
+  ),
+);

lib/src/core/engine/act_progression_service.dart

@@ -1,7 +1,7 @@
 import 'dart:math' as math;
 
 import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
-import 'package:asciineverdie/src/core/animation/monster_size.dart';
+import 'package:asciineverdie/src/shared/animation/monster_size.dart';
 import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
 import 'package:asciineverdie/src/core/model/combat_state.dart';
 import 'package:asciineverdie/src/core/model/combat_stats.dart';
@@ -16,9 +16,7 @@ import 'package:asciineverdie/src/core/util/pq_logic.dart' as pq_logic;
 ///
 /// ProgressService에서 추출된 Act 완료, 보스 생성 등의 로직 담당.
 class ActProgressionService {
-  const ActProgressionService({
-    required this.config,
-  });
+  const ActProgressionService({required this.config});
 
   final PqConfig config;
 

lib/src/core/engine/ad_service.dart

@@ -5,6 +5,8 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter/services.dart';
 import 'package:google_mobile_ads/google_mobile_ads.dart';
 
+import 'package:asciineverdie/src/core/engine/iap_service.dart';
+
 /// 광고 타입
 enum AdType {
   /// 부활용 리워드 광고 (30초)
@@ -69,15 +71,14 @@ class AdService {
   // ─────────────────────────────────────────────────────────────────────────
   // 프로덕션 광고 ID (AdMob 콘솔에서 생성 후 교체)
   // ─────────────────────────────────────────────────────────────────────────
-  // TODO: AdMob 콘솔에서 광고 단위 생성 후 아래 ID 교체
   static const String _prodRewardedAndroid =
-      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // Android 리워드 광고
+      'ca-app-pub-6691216385521068/3457464395'; // Android 리워드 광고
   static const String _prodRewardedIos =
-      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // iOS 리워드 광고
+      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // TODO: iOS 리워드 광고 ID 교체
   static const String _prodInterstitialAndroid =
-      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // Android 인터스티셜 광고
+      'ca-app-pub-6691216385521068/1625507977'; // Android 인터스티셜 광고
   static const String _prodInterstitialIos =
-      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // iOS 인터스티셜 광고
+      'ca-app-pub-XXXXXXXXXXXXXXXX/XXXXXXXXXX'; // TODO: iOS 인터스티셜 광고 ID 교체
 
   /// 리워드 광고 단위 ID (릴리즈 빌드: 프로덕션 ID, 디버그 빌드: 테스트 ID)
   String get _rewardAdUnitId {
@@ -105,9 +106,6 @@ class AdService {
 
   bool _isInitialized = false;
 
-  /// 디버그 모드에서 광고 활성화 여부
-  bool _debugAdEnabled = true;
-
   /// 로드된 리워드 광고
   RewardedAd? _rewardedAd;
 
@@ -144,23 +142,14 @@ class AdService {
   }
 
   // ===========================================================================
-  // 디버그 설정
+  // 광고 스킵 판정
   // ===========================================================================
 
-  /// 디버그 모드 광고 활성화 여부
-  bool get debugAdEnabled => _debugAdEnabled;
-
-  /// 디버그 모드 광고 토글
-  set debugAdEnabled(bool value) {
-    _debugAdEnabled = value;
-    debugPrint('[AdService] Debug ad enabled: $value');
-  }
-
   /// 광고를 스킵할지 여부
   ///
   /// 스킵 조건:
   /// - 비모바일 플랫폼 (macOS, Windows, Linux, Web)
-  /// - 디버그 모드에서 광고 비활성화
+  /// - IAP로 광고 제거 구매 완료 (디버그 시뮬레이션 포함)
   bool get _shouldSkipAd {
     // 웹에서는 항상 스킵
     if (kIsWeb) return true;
@@ -168,8 +157,9 @@ class AdService {
     if (!Platform.isAndroid && !Platform.isIOS) {
       return true;
     }
-    // 디버그 모드에서 광고 비활성화 시 스킵
-    return kDebugMode && !_debugAdEnabled;
+    // IAP 광고 제거 구매 시 스킵 (디버그 시뮬레이션 포함)
+    if (IAPService.instance.isAdRemovalPurchased) return true;
+    return false;
   }
 
   // ===========================================================================
@@ -195,7 +185,9 @@ class AdService {
         },
         onAdFailedToLoad: (error) {
           _isLoadingRewardedAd = false;
-          debugPrint('[AdService] Rewarded ad failed to load: ${error.message}');
+          debugPrint(
+            '[AdService] Rewarded ad failed to load: ${error.message}',
+          );
         },
       ),
     );
@@ -249,7 +241,9 @@ class AdService {
         _loadRewardedAd(); // 다음 광고 미리 로드
         // 보상 수령 여부에 따라 결과 반환
         if (!completer.isCompleted) {
-          completer.complete(rewarded ? AdResult.completed : AdResult.cancelled);
+          completer.complete(
+            rewarded ? AdResult.completed : AdResult.cancelled,
+          );
         }
       },
       onAdFailedToShowFullScreenContent: (ad, error) {

lib/src/core/engine/arena_combat_simulator.dart

@@ -0,0 +1,497 @@
+import 'package:asciineverdie/data/skill_data.dart';
+import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
+import 'package:asciineverdie/src/core/engine/skill_service.dart';
+import 'package:asciineverdie/src/core/model/arena_match.dart';
+import 'package:asciineverdie/src/core/model/combat_stats.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
+import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
+import 'package:asciineverdie/src/core/model/skill.dart';
+import 'package:asciineverdie/src/core/util/deterministic_random.dart';
+
+/// 아레나 전투 시뮬레이터
+///
+/// ArenaService에서 분리된 전투 시뮬레이션 로직.
+/// 스킬 시스템을 포함한 턴 기반 전투를 처리한다.
+class ArenaCombatSimulator {
+  ArenaCombatSimulator({required DeterministicRandom rng})
+    : _rng = rng,
+      _skillService = SkillService(rng: rng);
+
+  final DeterministicRandom _rng;
+  final SkillService _skillService;
+
+  /// 전투 시뮬레이션 (애니메이션용 스트림)
+  Stream<ArenaCombatTurn> simulateCombat(ArenaMatch match) async* {
+    final challengerStats = match.challenger.finalStats;
+    final opponentStats = match.opponent.finalStats;
+
+    if (challengerStats == null || opponentStats == null) {
+      return;
+    }
+
+    final calculator = CombatCalculator(rng: _rng);
+
+    // 스킬 ID 목록 로드
+    var challengerSkillIds = _getSkillIdsFromEntry(match.challenger);
+    var opponentSkillIds = _getSkillIdsFromEntry(match.opponent);
+    if (challengerSkillIds.isEmpty) {
+      challengerSkillIds = SkillData.defaultSkillIds;
+    }
+    if (opponentSkillIds.isEmpty) {
+      opponentSkillIds = SkillData.defaultSkillIds;
+    }
+
+    // 스킬 시스템 상태 초기화
+    var challengerSkillSystem = SkillSystemState.empty();
+    var opponentSkillSystem = SkillSystemState.empty();
+
+    // DOT 및 디버프 추적
+    var challengerDoTs = <DotEffect>[];
+    var opponentDoTs = <DotEffect>[];
+    var challengerDebuffs = <ActiveBuff>[];
+    var opponentDebuffs = <ActiveBuff>[];
+
+    var playerCombatStats = challengerStats.copyWith(
+      hpCurrent: challengerStats.hpMax,
+      mpCurrent: challengerStats.mpMax,
+    );
+
+    var opponentCombatStats = opponentStats.copyWith(
+      hpCurrent: opponentStats.hpMax,
+      mpCurrent: opponentStats.mpMax,
+    );
+
+    int playerAccum = 0;
+    int opponentAccum = 0;
+    int elapsedMs = 0;
+    const tickMs = 200;
+    int turns = 0;
+
+    // 초기 상태 전송
+    yield ArenaCombatTurn(
+      challengerHp: playerCombatStats.hpCurrent,
+      opponentHp: opponentCombatStats.hpCurrent,
+      challengerHpMax: playerCombatStats.hpMax,
+      opponentHpMax: opponentCombatStats.hpMax,
+      challengerMp: playerCombatStats.mpCurrent,
+      opponentMp: opponentCombatStats.mpCurrent,
+      challengerMpMax: playerCombatStats.mpMax,
+      opponentMpMax: opponentCombatStats.mpMax,
+    );
+
+    while (playerCombatStats.isAlive && opponentCombatStats.hpCurrent > 0) {
+      playerAccum += tickMs;
+      opponentAccum += tickMs;
+      elapsedMs += tickMs;
+
+      // 스킬 시스템 시간 업데이트
+      challengerSkillSystem = challengerSkillSystem.copyWith(
+        elapsedMs: elapsedMs,
+      );
+      opponentSkillSystem = opponentSkillSystem.copyWith(elapsedMs: elapsedMs);
+
+      int? challengerDamage;
+      int? opponentDamage;
+      bool isChallengerCritical = false;
+      bool isOpponentCritical = false;
+      bool isChallengerEvaded = false;
+      bool isOpponentEvaded = false;
+      bool isChallengerBlocked = false;
+      bool isOpponentBlocked = false;
+      String? challengerSkillUsed;
+      String? opponentSkillUsed;
+      int? challengerHealAmount;
+      int? opponentHealAmount;
+
+      // DOT 틱 처리
+      final dotResult = _processDotTicks(
+        challengerDoTs: challengerDoTs,
+        opponentDoTs: opponentDoTs,
+        playerStats: playerCombatStats,
+        opponentStats: opponentCombatStats,
+        tickMs: tickMs,
+      );
+      challengerDoTs = dotResult.challengerDoTs;
+      opponentDoTs = dotResult.opponentDoTs;
+      playerCombatStats = dotResult.playerStats;
+      opponentCombatStats = dotResult.opponentStats;
+
+      // 만료된 디버프 정리
+      challengerDebuffs = challengerDebuffs
+          .where((ActiveBuff d) => !d.isExpired(elapsedMs))
+          .toList();
+      opponentDebuffs = opponentDebuffs
+          .where((ActiveBuff d) => !d.isExpired(elapsedMs))
+          .toList();
+
+      // 도전자 턴
+      if (playerAccum >= playerCombatStats.attackDelayMs) {
+        playerAccum = 0;
+
+        var opponentMonsterStats = MonsterCombatStats.fromCombatStats(
+          opponentCombatStats,
+          match.opponent.characterName,
+        );
+
+        final turnResult = _processCharacterTurn(
+          player: playerCombatStats,
+          target: opponentCombatStats,
+          targetMonster: opponentMonsterStats,
+          targetName: match.opponent.characterName,
+          entry: match.challenger,
+          skillIds: challengerSkillIds,
+          skillSystem: challengerSkillSystem,
+          activeDoTs: challengerDoTs,
+          activeDebuffs: opponentDebuffs,
+          calculator: calculator,
+          elapsedMs: elapsedMs,
+        );
+
+        playerCombatStats = turnResult.player;
+        opponentCombatStats = turnResult.target;
+        challengerSkillSystem = turnResult.skillSystem;
+        challengerDoTs = turnResult.activeDoTs;
+        opponentDebuffs = turnResult.targetDebuffs;
+        challengerDamage = turnResult.damage;
+        isChallengerCritical = turnResult.isCritical;
+        isOpponentEvaded = turnResult.isTargetEvaded;
+        challengerSkillUsed = turnResult.skillUsed;
+        challengerHealAmount = turnResult.healAmount;
+      }
+
+      // 상대 턴
+      if (opponentCombatStats.hpCurrent > 0 &&
+          opponentAccum >= opponentCombatStats.attackDelayMs) {
+        opponentAccum = 0;
+
+        var challengerMonsterStats = MonsterCombatStats.fromCombatStats(
+          playerCombatStats,
+          match.challenger.characterName,
+        );
+
+        final turnResult = _processCharacterTurn(
+          player: opponentCombatStats,
+          target: playerCombatStats,
+          targetMonster: challengerMonsterStats,
+          targetName: match.challenger.characterName,
+          entry: match.opponent,
+          skillIds: opponentSkillIds,
+          skillSystem: opponentSkillSystem,
+          activeDoTs: opponentDoTs,
+          activeDebuffs: challengerDebuffs,
+          calculator: calculator,
+          elapsedMs: elapsedMs,
+        );
+
+        opponentCombatStats = turnResult.player;
+        playerCombatStats = turnResult.target;
+        opponentSkillSystem = turnResult.skillSystem;
+        opponentDoTs = turnResult.activeDoTs;
+        challengerDebuffs = turnResult.targetDebuffs;
+        opponentDamage = turnResult.damage;
+        isOpponentCritical = turnResult.isCritical;
+        isChallengerEvaded = turnResult.isTargetEvaded;
+        isChallengerBlocked = turnResult.isTargetBlocked;
+        opponentSkillUsed = turnResult.skillUsed;
+        opponentHealAmount = turnResult.healAmount;
+      }
+
+      // 액션이 발생했을 때만 턴 전송
+      final hasAction =
+          challengerDamage != null ||
+          opponentDamage != null ||
+          challengerHealAmount != null ||
+          opponentHealAmount != null ||
+          challengerSkillUsed != null ||
+          opponentSkillUsed != null;
+
+      if (hasAction) {
+        turns++;
+        yield ArenaCombatTurn(
+          challengerDamage: challengerDamage,
+          opponentDamage: opponentDamage,
+          challengerHp: playerCombatStats.hpCurrent,
+          opponentHp: opponentCombatStats.hpCurrent,
+          challengerHpMax: playerCombatStats.hpMax,
+          opponentHpMax: opponentCombatStats.hpMax,
+          challengerMp: playerCombatStats.mpCurrent,
+          opponentMp: opponentCombatStats.mpCurrent,
+          challengerMpMax: playerCombatStats.mpMax,
+          opponentMpMax: opponentCombatStats.mpMax,
+          isChallengerCritical: isChallengerCritical,
+          isOpponentCritical: isOpponentCritical,
+          isChallengerEvaded: isChallengerEvaded,
+          isOpponentEvaded: isOpponentEvaded,
+          isChallengerBlocked: isChallengerBlocked,
+          isOpponentBlocked: isOpponentBlocked,
+          challengerSkillUsed: challengerSkillUsed,
+          opponentSkillUsed: opponentSkillUsed,
+          challengerHealAmount: challengerHealAmount,
+          opponentHealAmount: opponentHealAmount,
+        );
+
+        await Future<void>.delayed(const Duration(milliseconds: 100));
+      }
+
+      if (turns > 1000) break;
+    }
+  }
+
+  /// DOT 틱 처리 (양측)
+  ({
+    List<DotEffect> challengerDoTs,
+    List<DotEffect> opponentDoTs,
+    CombatStats playerStats,
+    CombatStats opponentStats,
+  })
+  _processDotTicks({
+    required List<DotEffect> challengerDoTs,
+    required List<DotEffect> opponentDoTs,
+    required CombatStats playerStats,
+    required CombatStats opponentStats,
+    required int tickMs,
+  }) {
+    var updatedPlayerStats = playerStats;
+    var updatedOpponentStats = opponentStats;
+
+    // 도전자 -> 상대에게 적용된 DOT
+    var dotDamageToOpponent = 0;
+    final updatedChallengerDoTs = <DotEffect>[];
+    for (final dot in challengerDoTs) {
+      final (updatedDot, ticksTriggered) = dot.tick(tickMs);
+      if (ticksTriggered > 0) {
+        dotDamageToOpponent += dot.damagePerTick * ticksTriggered;
+      }
+      if (updatedDot.isActive) updatedChallengerDoTs.add(updatedDot);
+    }
+    if (dotDamageToOpponent > 0 && updatedOpponentStats.hpCurrent > 0) {
+      updatedOpponentStats = updatedOpponentStats.copyWith(
+        hpCurrent: (updatedOpponentStats.hpCurrent - dotDamageToOpponent).clamp(
+          0,
+          updatedOpponentStats.hpMax,
+        ),
+      );
+    }
+
+    // 상대 -> 도전자에게 적용된 DOT
+    var dotDamageToChallenger = 0;
+    final updatedOpponentDoTs = <DotEffect>[];
+    for (final dot in opponentDoTs) {
+      final (updatedDot, ticksTriggered) = dot.tick(tickMs);
+      if (ticksTriggered > 0) {
+        dotDamageToChallenger += dot.damagePerTick * ticksTriggered;
+      }
+      if (updatedDot.isActive) updatedOpponentDoTs.add(updatedDot);
+    }
+    if (dotDamageToChallenger > 0 && updatedPlayerStats.isAlive) {
+      updatedPlayerStats = updatedPlayerStats.copyWith(
+        hpCurrent: (updatedPlayerStats.hpCurrent - dotDamageToChallenger).clamp(
+          0,
+          updatedPlayerStats.hpMax,
+        ),
+      );
+    }
+
+    return (
+      challengerDoTs: updatedChallengerDoTs,
+      opponentDoTs: updatedOpponentDoTs,
+      playerStats: updatedPlayerStats,
+      opponentStats: updatedOpponentStats,
+    );
+  }
+
+  /// 캐릭터 턴 처리 (도전자/상대 공통)
+  ({
+    CombatStats player,
+    CombatStats target,
+    SkillSystemState skillSystem,
+    List<DotEffect> activeDoTs,
+    List<ActiveBuff> targetDebuffs,
+    int? damage,
+    bool isCritical,
+    bool isTargetEvaded,
+    bool isTargetBlocked,
+    String? skillUsed,
+    int? healAmount,
+  })
+  _processCharacterTurn({
+    required CombatStats player,
+    required CombatStats target,
+    required MonsterCombatStats targetMonster,
+    required String targetName,
+    required HallOfFameEntry entry,
+    required List<String> skillIds,
+    required SkillSystemState skillSystem,
+    required List<DotEffect> activeDoTs,
+    required List<ActiveBuff> activeDebuffs,
+    required CombatCalculator calculator,
+    required int elapsedMs,
+  }) {
+    int? damage;
+    bool isCritical = false;
+    bool isTargetEvaded = false;
+    bool isTargetBlocked = false;
+    String? skillUsed;
+    int? healAmount;
+    var updatedPlayer = player;
+    var updatedTarget = target;
+    var updatedSkillSystem = skillSystem;
+    var updatedDoTs = [...activeDoTs];
+    var updatedDebuffs = [...activeDebuffs];
+
+    final selectedSkill = _skillService.selectAutoSkill(
+      player: updatedPlayer,
+      monster: targetMonster,
+      skillSystem: updatedSkillSystem,
+      availableSkillIds: skillIds,
+      activeDoTs: updatedDoTs,
+      activeDebuffs: updatedDebuffs,
+    );
+
+    if (selectedSkill != null && selectedSkill.isAttack) {
+      final skillRank = _getSkillRankFromEntry(entry, selectedSkill.id);
+      final skillResult = _skillService.useAttackSkillWithRank(
+        skill: selectedSkill,
+        player: updatedPlayer,
+        monster: targetMonster,
+        skillSystem: updatedSkillSystem,
+        rank: skillRank,
+      );
+      updatedPlayer = skillResult.updatedPlayer;
+      updatedTarget = updatedTarget.copyWith(
+        hpCurrent: skillResult.updatedMonster.hpCurrent,
+      );
+      updatedSkillSystem = skillResult.updatedSkillSystem;
+      skillUsed = selectedSkill.name;
+      damage = skillResult.result.damage;
+    } else if (selectedSkill != null && selectedSkill.isDot) {
+      final skillResult = _skillService.useDotSkill(
+        skill: selectedSkill,
+        player: updatedPlayer,
+        skillSystem: updatedSkillSystem,
+        playerInt: updatedPlayer.atk ~/ 10,
+        playerWis: updatedPlayer.def ~/ 10,
+      );
+      updatedPlayer = skillResult.updatedPlayer;
+      updatedSkillSystem = skillResult.updatedSkillSystem;
+      if (skillResult.dotEffect != null) {
+        updatedDoTs.add(skillResult.dotEffect!);
+      }
+      skillUsed = selectedSkill.name;
+    } else if (selectedSkill != null && selectedSkill.isHeal) {
+      final skillResult = _skillService.useHealSkill(
+        skill: selectedSkill,
+        player: updatedPlayer,
+        skillSystem: updatedSkillSystem,
+      );
+      updatedPlayer = skillResult.updatedPlayer;
+      updatedSkillSystem = skillResult.updatedSkillSystem;
+      skillUsed = selectedSkill.name;
+      healAmount = skillResult.result.healedAmount;
+    } else if (selectedSkill != null && selectedSkill.isBuff) {
+      final skillResult = _skillService.useBuffSkill(
+        skill: selectedSkill,
+        player: updatedPlayer,
+        skillSystem: updatedSkillSystem,
+      );
+      updatedPlayer = skillResult.updatedPlayer;
+      updatedSkillSystem = skillResult.updatedSkillSystem;
+      skillUsed = selectedSkill.name;
+    } else if (selectedSkill != null && selectedSkill.isDebuff) {
+      final skillResult = _skillService.useDebuffSkill(
+        skill: selectedSkill,
+        player: updatedPlayer,
+        skillSystem: updatedSkillSystem,
+        currentDebuffs: updatedDebuffs,
+      );
+      updatedPlayer = skillResult.updatedPlayer;
+      updatedSkillSystem = skillResult.updatedSkillSystem;
+      final debuffEffect = skillResult.debuffEffect;
+      if (debuffEffect != null) {
+        updatedDebuffs =
+            updatedDebuffs
+                .where((ActiveBuff d) => d.effect.id != debuffEffect.effect.id)
+                .toList()
+              ..add(debuffEffect);
+      }
+      skillUsed = selectedSkill.name;
+    } else {
+      // 일반 공격
+      final opponentMonsterStats = MonsterCombatStats.fromCombatStats(
+        updatedTarget,
+        targetName,
+      );
+      final result = calculator.playerAttackMonster(
+        attacker: updatedPlayer,
+        defender: opponentMonsterStats,
+      );
+      updatedTarget = updatedTarget.copyWith(
+        hpCurrent: result.updatedDefender.hpCurrent,
+      );
+
+      if (result.result.isHit) {
+        damage = result.result.damage;
+        isCritical = result.result.isCritical;
+      } else {
+        isTargetEvaded = true;
+      }
+    }
+
+    return (
+      player: updatedPlayer,
+      target: updatedTarget,
+      skillSystem: updatedSkillSystem,
+      activeDoTs: updatedDoTs,
+      targetDebuffs: updatedDebuffs,
+      damage: damage,
+      isCritical: isCritical,
+      isTargetEvaded: isTargetEvaded,
+      isTargetBlocked: isTargetBlocked,
+      skillUsed: skillUsed,
+      healAmount: healAmount,
+    );
+  }
+
+  /// 스킬 ID 목록 추출 (HallOfFameEntry에서)
+  List<String> _getSkillIdsFromEntry(HallOfFameEntry entry) {
+    final skillData = entry.finalSkills;
+    if (skillData == null || skillData.isEmpty) return [];
+
+    final skillIds = <String>[];
+    for (final data in skillData) {
+      final skillName = data['name'];
+      if (skillName != null) {
+        final skill = SkillData.getSkillBySpellName(skillName);
+        if (skill != null) {
+          skillIds.add(skill.id);
+        }
+      }
+    }
+    return skillIds;
+  }
+
+  /// 스킬 랭크 조회 (HallOfFameEntry의 finalSkills에서)
+  int _getSkillRankFromEntry(HallOfFameEntry entry, String skillId) {
+    final skill = SkillData.getSkillById(skillId);
+    if (skill == null) return 1;
+
+    final skillData = entry.finalSkills;
+    if (skillData == null || skillData.isEmpty) return 1;
+
+    for (final data in skillData) {
+      if (data['name'] == skill.name) {
+        final rankStr = data['rank'] ?? 'I';
+        return switch (rankStr) {
+          'I' => 1,
+          'II' => 2,
+          'III' => 3,
+          'IV' => 4,
+          'V' => 5,
+          _ => 1,
+        };
+      }
+    }
+    return 1;
+  }
+}

lib/src/core/engine/arena_service.dart

@@ -1,14 +1,11 @@
-import 'package:asciineverdie/data/skill_data.dart';
+import 'package:asciineverdie/src/core/engine/arena_combat_simulator.dart';
 import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
 import 'package:asciineverdie/src/core/engine/item_service.dart';
-import 'package:asciineverdie/src/core/engine/skill_service.dart';
 import 'package:asciineverdie/src/core/model/arena_match.dart';
 import 'package:asciineverdie/src/core/model/equipment_item.dart';
 import 'package:asciineverdie/src/core/model/equipment_slot.dart';
-import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
 import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
-import 'package:asciineverdie/src/core/model/skill.dart';
 import 'package:asciineverdie/src/core/util/deterministic_random.dart';
 
 /// 아레나 서비스
@@ -23,64 +20,6 @@ class ArenaService {
 
   final DeterministicRandom _rng;
 
-  late final SkillService _skillService = SkillService(rng: _rng);
-
-  // ============================================================================
-  // 스킬 시스템 헬퍼
-  // ============================================================================
-
-  /// HallOfFameEntry의 finalSkills에서 Skill 목록 추출
-  List<Skill> _getSkillsFromEntry(HallOfFameEntry entry) {
-    final skillData = entry.finalSkills;
-    if (skillData == null || skillData.isEmpty) return [];
-
-    final skills = <Skill>[];
-    for (final data in skillData) {
-      final skillName = data['name'];
-      if (skillName != null) {
-        final skill = SkillData.getSkillBySpellName(skillName);
-        if (skill != null) {
-          skills.add(skill);
-        }
-      }
-    }
-    return skills;
-  }
-
-  /// 스킬 ID 목록 추출 (HallOfFameEntry에서)
-  List<String> _getSkillIdsFromEntry(HallOfFameEntry entry) {
-    return _getSkillsFromEntry(entry).map((s) => s.id).toList();
-  }
-
-  /// 스킬 랭크 조회 (HallOfFameEntry의 finalSkills에서)
-  int _getSkillRankFromEntry(HallOfFameEntry entry, String skillId) {
-    final skill = SkillData.getSkillById(skillId);
-    if (skill == null) return 1;
-
-    final skillData = entry.finalSkills;
-    if (skillData == null || skillData.isEmpty) return 1;
-
-    for (final data in skillData) {
-      if (data['name'] == skill.name) {
-        final rankStr = data['rank'] ?? 'I';
-        return _romanToInt(rankStr);
-      }
-    }
-    return 1;
-  }
-
-  /// 로마 숫자 → 정수 변환
-  int _romanToInt(String roman) {
-    return switch (roman) {
-      'I' => 1,
-      'II' => 2,
-      'III' => 3,
-      'IV' => 4,
-      'V' => 5,
-      _ => 1,
-    };
-  }
-
   // ============================================================================
   // 상대 결정
   // ============================================================================
@@ -230,452 +169,10 @@ class ArenaService {
 
   /// 전투 시뮬레이션 (애니메이션용 스트림)
   ///
-  /// progress_service._processCombatTickWithSkills()와 동일한 로직 사용
-  /// [match] 대전 정보
-  /// Returns: 턴별 전투 상황 스트림
-  Stream<ArenaCombatTurn> simulateCombat(ArenaMatch match) async* {
-    final calculator = CombatCalculator(rng: _rng);
-
-    final challengerStats = match.challenger.finalStats;
-    final opponentStats = match.opponent.finalStats;
-
-    if (challengerStats == null || opponentStats == null) {
-      return;
-    }
-
-    // 스킬 ID 목록 로드 (SkillBook과 동일한 방식)
-    var challengerSkillIds = _getSkillIdsFromEntry(match.challenger);
-    var opponentSkillIds = _getSkillIdsFromEntry(match.opponent);
-
-    // 스킬이 없으면 기본 스킬 사용
-    if (challengerSkillIds.isEmpty) {
-      challengerSkillIds = SkillData.defaultSkillIds;
-    }
-    if (opponentSkillIds.isEmpty) {
-      opponentSkillIds = SkillData.defaultSkillIds;
-    }
-
-    // 스킬 시스템 상태 초기화
-    var challengerSkillSystem = SkillSystemState.empty();
-    var opponentSkillSystem = SkillSystemState.empty();
-
-    // DOT 및 디버프 추적 (일반 전투와 동일)
-    var challengerDoTs = <DotEffect>[];
-    var opponentDoTs = <DotEffect>[];
-    var challengerDebuffs = <ActiveBuff>[];
-    var opponentDebuffs = <ActiveBuff>[];
-
-    var playerCombatStats = challengerStats.copyWith(
-      hpCurrent: challengerStats.hpMax,
-      mpCurrent: challengerStats.mpMax,
-    );
-
-    var opponentCombatStats = opponentStats.copyWith(
-      hpCurrent: opponentStats.hpMax,
-      mpCurrent: opponentStats.mpMax,
-    );
-
-    var opponentMonsterStats = MonsterCombatStats.fromCombatStats(
-      opponentCombatStats,
-      match.opponent.characterName,
-    );
-
-    var challengerMonsterStats = MonsterCombatStats.fromCombatStats(
-      playerCombatStats,
-      match.challenger.characterName,
-    );
-
-    int playerAccum = 0;
-    int opponentAccum = 0;
-    int elapsedMs = 0;
-    const tickMs = 200;
-    int turns = 0;
-
-    // 초기 상태 전송
-    yield ArenaCombatTurn(
-      challengerHp: playerCombatStats.hpCurrent,
-      opponentHp: opponentCombatStats.hpCurrent,
-      challengerHpMax: playerCombatStats.hpMax,
-      opponentHpMax: opponentCombatStats.hpMax,
-      challengerMp: playerCombatStats.mpCurrent,
-      opponentMp: opponentCombatStats.mpCurrent,
-      challengerMpMax: playerCombatStats.mpMax,
-      opponentMpMax: opponentCombatStats.mpMax,
-    );
-
-    while (playerCombatStats.isAlive && opponentCombatStats.hpCurrent > 0) {
-      playerAccum += tickMs;
-      opponentAccum += tickMs;
-      elapsedMs += tickMs;
-
-      // 스킬 시스템 시간 업데이트
-      challengerSkillSystem = challengerSkillSystem.copyWith(
-        elapsedMs: elapsedMs,
-      );
-      opponentSkillSystem = opponentSkillSystem.copyWith(elapsedMs: elapsedMs);
-
-      int? challengerDamage;
-      int? opponentDamage;
-      bool isChallengerCritical = false;
-      bool isOpponentCritical = false;
-      bool isChallengerEvaded = false;
-      bool isOpponentEvaded = false;
-      bool isChallengerBlocked = false;
-      bool isOpponentBlocked = false;
-      String? challengerSkillUsed;
-      String? opponentSkillUsed;
-      int? challengerHealAmount;
-      int? opponentHealAmount;
-
-      // =========================================================================
-      // DOT 틱 처리 (도전자 → 상대에게 적용된 DOT)
-      // =========================================================================
-      var dotDamageToOpponent = 0;
-      final updatedChallengerDoTs = <DotEffect>[];
-      for (final dot in challengerDoTs) {
-        final (updatedDot, ticksTriggered) = dot.tick(tickMs);
-        if (ticksTriggered > 0) {
-          dotDamageToOpponent += dot.damagePerTick * ticksTriggered;
-        }
-        if (updatedDot.isActive) {
-          updatedChallengerDoTs.add(updatedDot);
-        }
-      }
-      challengerDoTs = updatedChallengerDoTs;
-
-      if (dotDamageToOpponent > 0 && opponentCombatStats.hpCurrent > 0) {
-        opponentCombatStats = opponentCombatStats.copyWith(
-          hpCurrent: (opponentCombatStats.hpCurrent - dotDamageToOpponent)
-              .clamp(0, opponentCombatStats.hpMax),
-        );
-      }
-
-      // DOT 틱 처리 (상대 → 도전자에게 적용된 DOT)
-      var dotDamageToChallenger = 0;
-      final updatedOpponentDoTs = <DotEffect>[];
-      for (final dot in opponentDoTs) {
-        final (updatedDot, ticksTriggered) = dot.tick(tickMs);
-        if (ticksTriggered > 0) {
-          dotDamageToChallenger += dot.damagePerTick * ticksTriggered;
-        }
-        if (updatedDot.isActive) {
-          updatedOpponentDoTs.add(updatedDot);
-        }
-      }
-      opponentDoTs = updatedOpponentDoTs;
-
-      if (dotDamageToChallenger > 0 && playerCombatStats.isAlive) {
-        playerCombatStats = playerCombatStats.copyWith(
-          hpCurrent: (playerCombatStats.hpCurrent - dotDamageToChallenger)
-              .clamp(0, playerCombatStats.hpMax),
-        );
-      }
-
-      // =========================================================================
-      // 만료된 디버프 정리
-      // =========================================================================
-      challengerDebuffs = challengerDebuffs
-          .where((ActiveBuff d) => !d.isExpired(elapsedMs))
-          .toList();
-      opponentDebuffs = opponentDebuffs
-          .where((ActiveBuff d) => !d.isExpired(elapsedMs))
-          .toList();
-
-      // =========================================================================
-      // 도전자 턴 (selectAutoSkill 사용 - 일반 전투와 동일)
-      // =========================================================================
-      if (playerAccum >= playerCombatStats.attackDelayMs) {
-        playerAccum = 0;
-
-        // 상대 몬스터 스탯 동기화
-        opponentMonsterStats = MonsterCombatStats.fromCombatStats(
-          opponentCombatStats,
-          match.opponent.characterName,
-        );
-
-        // 스킬 자동 선택 (progress_service와 동일한 로직)
-        final selectedSkill = _skillService.selectAutoSkill(
-          player: playerCombatStats,
-          monster: opponentMonsterStats,
-          skillSystem: challengerSkillSystem,
-          availableSkillIds: challengerSkillIds,
-          activeDoTs: challengerDoTs,
-          activeDebuffs: opponentDebuffs,
-        );
-
-        if (selectedSkill != null && selectedSkill.isAttack) {
-          // 스킬 랭크 조회 및 적용
-          final skillRank = _getSkillRankFromEntry(
-            match.challenger,
-            selectedSkill.id,
-          );
-          final skillResult = _skillService.useAttackSkillWithRank(
-            skill: selectedSkill,
-            player: playerCombatStats,
-            monster: opponentMonsterStats,
-            skillSystem: challengerSkillSystem,
-            rank: skillRank,
-          );
-          playerCombatStats = skillResult.updatedPlayer;
-          opponentCombatStats = opponentCombatStats.copyWith(
-            hpCurrent: skillResult.updatedMonster.hpCurrent,
-          );
-          challengerSkillSystem = skillResult.updatedSkillSystem;
-          challengerSkillUsed = selectedSkill.name;
-          challengerDamage = skillResult.result.damage;
-        } else if (selectedSkill != null && selectedSkill.isDot) {
-          // DOT 스킬 사용
-          final skillResult = _skillService.useDotSkill(
-            skill: selectedSkill,
-            player: playerCombatStats,
-            skillSystem: challengerSkillSystem,
-            playerInt: playerCombatStats.atk ~/ 10,
-            playerWis: playerCombatStats.def ~/ 10,
-          );
-          playerCombatStats = skillResult.updatedPlayer;
-          challengerSkillSystem = skillResult.updatedSkillSystem;
-          if (skillResult.dotEffect != null) {
-            challengerDoTs.add(skillResult.dotEffect!);
-          }
-          challengerSkillUsed = selectedSkill.name;
-        } else if (selectedSkill != null && selectedSkill.isHeal) {
-          // 회복 스킬 사용
-          final skillResult = _skillService.useHealSkill(
-            skill: selectedSkill,
-            player: playerCombatStats,
-            skillSystem: challengerSkillSystem,
-          );
-          playerCombatStats = skillResult.updatedPlayer;
-          challengerSkillSystem = skillResult.updatedSkillSystem;
-          challengerSkillUsed = selectedSkill.name;
-          challengerHealAmount = skillResult.result.healedAmount;
-        } else if (selectedSkill != null && selectedSkill.isBuff) {
-          // 버프 스킬 사용
-          final skillResult = _skillService.useBuffSkill(
-            skill: selectedSkill,
-            player: playerCombatStats,
-            skillSystem: challengerSkillSystem,
-          );
-          playerCombatStats = skillResult.updatedPlayer;
-          challengerSkillSystem = skillResult.updatedSkillSystem;
-          challengerSkillUsed = selectedSkill.name;
-        } else if (selectedSkill != null && selectedSkill.isDebuff) {
-          // 디버프 스킬 사용
-          final skillResult = _skillService.useDebuffSkill(
-            skill: selectedSkill,
-            player: playerCombatStats,
-            skillSystem: challengerSkillSystem,
-            currentDebuffs: opponentDebuffs,
-          );
-          playerCombatStats = skillResult.updatedPlayer;
-          challengerSkillSystem = skillResult.updatedSkillSystem;
-          final debuffEffect = skillResult.debuffEffect;
-          if (debuffEffect != null) {
-            opponentDebuffs =
-                opponentDebuffs
-                    .where(
-                      (ActiveBuff d) => d.effect.id != debuffEffect.effect.id,
-                    )
-                    .toList()
-                  ..add(debuffEffect);
-          }
-          challengerSkillUsed = selectedSkill.name;
-        } else {
-          // 일반 공격
-          final result = calculator.playerAttackMonster(
-            attacker: playerCombatStats,
-            defender: opponentMonsterStats,
-          );
-          opponentCombatStats = opponentCombatStats.copyWith(
-            hpCurrent: result.updatedDefender.hpCurrent,
-          );
-
-          if (result.result.isHit) {
-            challengerDamage = result.result.damage;
-            isChallengerCritical = result.result.isCritical;
-          } else {
-            isOpponentEvaded = true;
-          }
-        }
-      }
-
-      // =========================================================================
-      // 상대 턴 (selectAutoSkill 사용 - 일반 전투와 동일)
-      // =========================================================================
-      if (opponentCombatStats.hpCurrent > 0 &&
-          opponentAccum >= opponentCombatStats.attackDelayMs) {
-        opponentAccum = 0;
-
-        // 도전자 몬스터 스탯 동기화
-        challengerMonsterStats = MonsterCombatStats.fromCombatStats(
-          playerCombatStats,
-          match.challenger.characterName,
-        );
-
-        // 스킬 자동 선택 (progress_service와 동일한 로직)
-        final selectedSkill = _skillService.selectAutoSkill(
-          player: opponentCombatStats,
-          monster: challengerMonsterStats,
-          skillSystem: opponentSkillSystem,
-          availableSkillIds: opponentSkillIds,
-          activeDoTs: opponentDoTs,
-          activeDebuffs: challengerDebuffs,
-        );
-
-        if (selectedSkill != null && selectedSkill.isAttack) {
-          // 스킬 랭크 조회 및 적용
-          final skillRank = _getSkillRankFromEntry(
-            match.opponent,
-            selectedSkill.id,
-          );
-          final skillResult = _skillService.useAttackSkillWithRank(
-            skill: selectedSkill,
-            player: opponentCombatStats,
-            monster: challengerMonsterStats,
-            skillSystem: opponentSkillSystem,
-            rank: skillRank,
-          );
-          opponentCombatStats = skillResult.updatedPlayer;
-          playerCombatStats = playerCombatStats.copyWith(
-            hpCurrent: skillResult.updatedMonster.hpCurrent,
-          );
-          opponentSkillSystem = skillResult.updatedSkillSystem;
-          opponentSkillUsed = selectedSkill.name;
-          opponentDamage = skillResult.result.damage;
-        } else if (selectedSkill != null && selectedSkill.isDot) {
-          // DOT 스킬 사용
-          final skillResult = _skillService.useDotSkill(
-            skill: selectedSkill,
-            player: opponentCombatStats,
-            skillSystem: opponentSkillSystem,
-            playerInt: opponentCombatStats.atk ~/ 10,
-            playerWis: opponentCombatStats.def ~/ 10,
-          );
-          opponentCombatStats = skillResult.updatedPlayer;
-          opponentSkillSystem = skillResult.updatedSkillSystem;
-          if (skillResult.dotEffect != null) {
-            opponentDoTs.add(skillResult.dotEffect!);
-          }
-          opponentSkillUsed = selectedSkill.name;
-        } else if (selectedSkill != null && selectedSkill.isHeal) {
-          // 회복 스킬 사용
-          final skillResult = _skillService.useHealSkill(
-            skill: selectedSkill,
-            player: opponentCombatStats,
-            skillSystem: opponentSkillSystem,
-          );
-          opponentCombatStats = skillResult.updatedPlayer;
-          opponentSkillSystem = skillResult.updatedSkillSystem;
-          opponentSkillUsed = selectedSkill.name;
-          opponentHealAmount = skillResult.result.healedAmount;
-        } else if (selectedSkill != null && selectedSkill.isBuff) {
-          // 버프 스킬 사용
-          final skillResult = _skillService.useBuffSkill(
-            skill: selectedSkill,
-            player: opponentCombatStats,
-            skillSystem: opponentSkillSystem,
-          );
-          opponentCombatStats = skillResult.updatedPlayer;
-          opponentSkillSystem = skillResult.updatedSkillSystem;
-          opponentSkillUsed = selectedSkill.name;
-        } else if (selectedSkill != null && selectedSkill.isDebuff) {
-          // 디버프 스킬 사용
-          final skillResult = _skillService.useDebuffSkill(
-            skill: selectedSkill,
-            player: opponentCombatStats,
-            skillSystem: opponentSkillSystem,
-            currentDebuffs: challengerDebuffs,
-          );
-          opponentCombatStats = skillResult.updatedPlayer;
-          opponentSkillSystem = skillResult.updatedSkillSystem;
-          final debuffEffect = skillResult.debuffEffect;
-          if (debuffEffect != null) {
-            challengerDebuffs =
-                challengerDebuffs
-                    .where(
-                      (ActiveBuff d) => d.effect.id != debuffEffect.effect.id,
-                    )
-                    .toList()
-                  ..add(debuffEffect);
-          }
-          opponentSkillUsed = selectedSkill.name;
-        } else {
-          // 일반 공격 (디버프 효과 적용)
-          var debuffedOpponent = opponentCombatStats;
-          if (challengerDebuffs.isNotEmpty) {
-            double atkMod = 0;
-            for (final debuff in challengerDebuffs) {
-              if (!debuff.isExpired(elapsedMs)) {
-                atkMod += debuff.effect.atkModifier;
-              }
-            }
-            final newAtk = (opponentCombatStats.atk * (1 + atkMod))
-                .round()
-                .clamp(opponentCombatStats.atk ~/ 10, opponentCombatStats.atk);
-            debuffedOpponent = opponentCombatStats.copyWith(atk: newAtk);
-          }
-
-          opponentMonsterStats = MonsterCombatStats.fromCombatStats(
-            debuffedOpponent,
-            match.opponent.characterName,
-          );
-          final result = calculator.monsterAttackPlayer(
-            attacker: opponentMonsterStats,
-            defender: playerCombatStats,
-          );
-          playerCombatStats = result.updatedDefender;
-
-          if (result.result.isHit) {
-            opponentDamage = result.result.damage;
-            isOpponentCritical = result.result.isCritical;
-            isChallengerBlocked = result.result.isBlocked;
-          } else {
-            isChallengerEvaded = true;
-          }
-        }
-      }
-
-      // 액션이 발생했을 때만 턴 전송
-      final hasAction =
-          challengerDamage != null ||
-          opponentDamage != null ||
-          challengerHealAmount != null ||
-          opponentHealAmount != null ||
-          challengerSkillUsed != null ||
-          opponentSkillUsed != null;
-
-      if (hasAction) {
-        turns++;
-        yield ArenaCombatTurn(
-          challengerDamage: challengerDamage,
-          opponentDamage: opponentDamage,
-          challengerHp: playerCombatStats.hpCurrent,
-          opponentHp: opponentCombatStats.hpCurrent,
-          challengerHpMax: playerCombatStats.hpMax,
-          opponentHpMax: opponentCombatStats.hpMax,
-          challengerMp: playerCombatStats.mpCurrent,
-          opponentMp: opponentCombatStats.mpCurrent,
-          challengerMpMax: playerCombatStats.mpMax,
-          opponentMpMax: opponentCombatStats.mpMax,
-          isChallengerCritical: isChallengerCritical,
-          isOpponentCritical: isOpponentCritical,
-          isChallengerEvaded: isChallengerEvaded,
-          isOpponentEvaded: isOpponentEvaded,
-          isChallengerBlocked: isChallengerBlocked,
-          isOpponentBlocked: isOpponentBlocked,
-          challengerSkillUsed: challengerSkillUsed,
-          opponentSkillUsed: opponentSkillUsed,
-          challengerHealAmount: challengerHealAmount,
-          opponentHealAmount: opponentHealAmount,
-        );
-
-        // 애니메이션을 위한 딜레이
-        await Future<void>.delayed(const Duration(milliseconds: 100));
-      }
-
-      // 무한 루프 방지
-      if (turns > 1000) break;
-    }
+  /// ArenaCombatSimulator에 위임하여 턴별 전투 상황을 스트림으로 반환.
+  Stream<ArenaCombatTurn> simulateCombat(ArenaMatch match) {
+    final simulator = ArenaCombatSimulator(rng: _rng);
+    return simulator.simulateCombat(match);
   }
   // ============================================================================
   // AI 베팅 슬롯 선택

lib/src/core/engine/character_roll_service.dart

@@ -64,8 +64,10 @@ class CharacterRollService {
     _resetUndoForNewSession();
 
     _isInitialized = true;
-    debugPrint('[CharacterRollService] Initialized: '
-        'rolls=$_rollsRemaining, undo=$_undoRemaining');
+    debugPrint(
+      '[CharacterRollService] Initialized: '
+      'rolls=$_rollsRemaining, undo=$_undoRemaining',
+    );
   }
 
   /// 저장된 상태 로드
@@ -143,14 +145,15 @@ class CharacterRollService {
     _rollsRemaining--;
     _saveRollsRemaining();
 
-    // 무료 유저: 새 굴리기마다 되돌리기 기회 1회 부여 (광고 시청 필요)
-    // 유료 유저: 세션당 최대 횟수 유지
-    if (!_isPaidUser && _undoRemaining < maxUndoFreeUser) {
-      _undoRemaining = maxUndoFreeUser;
-    }
+    // 매 굴림마다 되돌리기 횟수 리셋
+    // - 유료 유저: 3회
+    // - 무료 유저: 1회 (광고 시청 필요)
+    _undoRemaining = _isPaidUser ? maxUndoPaidUser : maxUndoFreeUser;
 
-    debugPrint('[CharacterRollService] Rolled: remaining=$_rollsRemaining, '
-        'history=${_rollHistory.length}, undo=$_undoRemaining');
+    debugPrint(
+      '[CharacterRollService] Rolled: remaining=$_rollsRemaining, '
+      'history=${_rollHistory.length}, undo=$_undoRemaining',
+    );
 
     return true;
   }
@@ -215,8 +218,10 @@ class CharacterRollService {
     final snapshot = _rollHistory.removeAt(0);
     _undoRemaining--;
 
-    debugPrint('[CharacterRollService] Undo (paid): '
-        'remaining=$_undoRemaining, history=${_rollHistory.length}');
+    debugPrint(
+      '[CharacterRollService] Undo (paid): '
+      'remaining=$_undoRemaining, history=${_rollHistory.length}',
+    );
 
     return snapshot;
   }
@@ -242,8 +247,10 @@ class CharacterRollService {
     );
 
     if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
-      debugPrint('[CharacterRollService] Undo (free with ad): '
-          'remaining=$_undoRemaining, history=${_rollHistory.length}');
+      debugPrint(
+        '[CharacterRollService] Undo (free with ad): '
+        'remaining=$_undoRemaining, history=${_rollHistory.length}',
+      );
       return result;
     }
 

lib/src/core/engine/chest_service.dart

@@ -12,7 +12,7 @@ import 'package:asciineverdie/src/core/util/deterministic_random.dart';
 /// 상자 내용물 생성 및 오픈 로직 담당
 class ChestService {
   ChestService({DeterministicRandom? rng})
-      : _rng = rng ?? DeterministicRandom(DateTime.now().millisecondsSinceEpoch);
+    : _rng = rng ?? DeterministicRandom(DateTime.now().millisecondsSinceEpoch);
 
   final DeterministicRandom _rng;
 
@@ -100,7 +100,9 @@ class ChestService {
       rarity: rarity,
     );
 
-    debugPrint('[ChestService] Equipment reward: ${item.name} (${rarity.name})');
+    debugPrint(
+      '[ChestService] Equipment reward: ${item.name} (${rarity.name})',
+    );
     return ChestReward.equipment(item);
   }
 
@@ -132,7 +134,10 @@ class ChestService {
   ChestReward _generateGoldReward(int playerLevel) {
     final baseGold = playerLevel * _goldPerLevel;
     final variance = _rng.nextInt(_goldVariance * 2 + 1) - _goldVariance;
-    final gold = (baseGold + (baseGold * variance / 100)).round().clamp(10, 99999);
+    final gold = (baseGold + (baseGold * variance / 100)).round().clamp(
+      10,
+      99999,
+    );
 
     debugPrint('[ChestService] Gold reward: $gold');
     return ChestReward.gold(gold);
@@ -142,7 +147,10 @@ class ChestService {
   ChestReward _generateExperienceReward(int playerLevel) {
     final baseExp = playerLevel * _expPerLevel;
     final variance = _rng.nextInt(_expVariance * 2 + 1) - _expVariance;
-    final exp = (baseExp + (baseExp * variance / 100)).round().clamp(10, 999999);
+    final exp = (baseExp + (baseExp * variance / 100)).round().clamp(
+      10,
+      999999,
+    );
 
     debugPrint('[ChestService] Experience reward: $exp');
     return ChestReward.experience(exp);
@@ -208,49 +216,49 @@ class ChestService {
 
     return switch (slot) {
       EquipmentSlot.weapon => ItemStats(
-          atk: baseValue * 2,
-          criRate: 0.01 * (level ~/ 5),
-          parryRate: 0.005 * level,
-        ),
+        atk: baseValue * 2,
+        criRate: 0.01 * (level ~/ 5),
+        parryRate: 0.005 * level,
+      ),
       EquipmentSlot.shield => ItemStats(
-          def: baseValue,
-          blockRate: 0.02 * (level ~/ 3).clamp(1, 10),
-        ),
+        def: baseValue,
+        blockRate: 0.02 * (level ~/ 3).clamp(1, 10),
+      ),
       EquipmentSlot.helm => ItemStats(
-          def: baseValue ~/ 2,
-          magDef: baseValue ~/ 2,
-          intBonus: level ~/ 10,
-        ),
+        def: baseValue ~/ 2,
+        magDef: baseValue ~/ 2,
+        intBonus: level ~/ 10,
+      ),
       EquipmentSlot.hauberk => ItemStats(def: baseValue, hpBonus: level * 2),
       EquipmentSlot.brassairts => ItemStats(
-          def: baseValue ~/ 2,
-          strBonus: level ~/ 15,
-        ),
+        def: baseValue ~/ 2,
+        strBonus: level ~/ 15,
+      ),
       EquipmentSlot.vambraces => ItemStats(
-          def: baseValue ~/ 2,
-          dexBonus: level ~/ 15,
-        ),
+        def: baseValue ~/ 2,
+        dexBonus: level ~/ 15,
+      ),
       EquipmentSlot.gauntlets => ItemStats(
-          atk: baseValue ~/ 2,
-          def: baseValue ~/ 4,
-        ),
+        atk: baseValue ~/ 2,
+        def: baseValue ~/ 4,
+      ),
       EquipmentSlot.gambeson => ItemStats(
-          def: baseValue ~/ 2,
-          conBonus: level ~/ 15,
-        ),
+        def: baseValue ~/ 2,
+        conBonus: level ~/ 15,
+      ),
       EquipmentSlot.cuisses => ItemStats(
-          def: baseValue ~/ 2,
-          evasion: 0.005 * level,
-        ),
+        def: baseValue ~/ 2,
+        evasion: 0.005 * level,
+      ),
       EquipmentSlot.greaves => ItemStats(
-          def: baseValue ~/ 2,
-          evasion: 0.003 * level,
-        ),
+        def: baseValue ~/ 2,
+        evasion: 0.003 * level,
+      ),
       EquipmentSlot.sollerets => ItemStats(
-          def: baseValue ~/ 3,
-          evasion: 0.002 * level,
-          dexBonus: level ~/ 20,
-        ),
+        def: baseValue ~/ 3,
+        evasion: 0.002 * level,
+        dexBonus: level ~/ 20,
+      ),
     };
   }
 

lib/src/core/engine/combat_tick_service.dart

@@ -1,5 +1,8 @@
+import 'package:asciineverdie/data/class_data.dart';
 import 'package:asciineverdie/data/skill_data.dart';
 import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
+import 'package:asciineverdie/src/core/model/class_traits.dart';
+import 'package:asciineverdie/src/core/engine/player_attack_processor.dart';
 import 'package:asciineverdie/src/core/engine/potion_service.dart';
 import 'package:asciineverdie/src/core/engine/skill_service.dart';
 import 'package:asciineverdie/src/core/model/combat_event.dart';
@@ -94,6 +97,17 @@ class CombatTickService {
     totalDamageDealt = dotResult.totalDamageDealt;
     newEvents.addAll(dotResult.events);
 
+    // 클래스 패시브 조회 (healingBonus, firstStrikeBonus, multiAttack)
+    final klass = ClassData.findById(state.traits.classId);
+    final healingBonus =
+        klass?.getPassiveValue(ClassPassiveType.healingBonus) ?? 0.0;
+    final healingMultiplier = 1.0 + healingBonus;
+    final firstStrikeBonus =
+        klass?.getPassiveValue(ClassPassiveType.firstStrikeBonus) ?? 0.0;
+    final hasMultiAttack =
+        klass?.hasPassive(ClassPassiveType.multiAttack) ?? false;
+    var isFirstPlayerAttack = combat.isFirstPlayerAttack;
+
     // 긴급 물약 자동 사용 (HP < 30% 또는 MP < 50%)
     final potionResult = _tryEmergencyPotion(
       playerStats: playerStats,
@@ -102,6 +116,7 @@ class CombatTickService {
       playerLevel: state.traits.level,
       timestamp: timestamp,
       potionService: potionService,
+      healingMultiplier: healingMultiplier,
     );
     if (potionResult != null) {
       playerStats = potionResult.playerStats;
@@ -112,7 +127,8 @@ class CombatTickService {
 
     // 플레이어 공격 체크
     if (playerAccumulator >= playerStats.attackDelayMs) {
-      final attackResult = _processPlayerAttack(
+      final attackProcessor = PlayerAttackProcessor(rng: rng);
+      final attackResult = attackProcessor.processAttack(
         state: state,
         playerStats: playerStats,
         monsterStats: monsterStats,
@@ -123,6 +139,10 @@ class CombatTickService {
         timestamp: timestamp,
         calculator: calculator,
         skillService: skillService,
+        isFirstPlayerAttack: isFirstPlayerAttack,
+        firstStrikeBonus: firstStrikeBonus > 0 ? firstStrikeBonus : 1.0,
+        hasMultiAttack: hasMultiAttack,
+        healingMultiplier: healingMultiplier,
       );
 
       playerStats = attackResult.playerStats;
@@ -132,6 +152,7 @@ class CombatTickService {
       activeDebuffs = attackResult.activeDebuffs;
       totalDamageDealt = attackResult.totalDamageDealt;
       newEvents.addAll(attackResult.events);
+      isFirstPlayerAttack = attackResult.isFirstPlayerAttack;
 
       playerAccumulator -= playerStats.attackDelayMs;
       turnsElapsed++;
@@ -178,6 +199,7 @@ class CombatTickService {
         activeDoTs: activeDoTs,
         lastPotionUsedMs: lastPotionUsedMs,
         activeDebuffs: activeDebuffs,
+        isFirstPlayerAttack: isFirstPlayerAttack,
       ),
       skillSystem: updatedSkillSystem,
       potionInventory: updatedPotionInventory,
@@ -190,7 +212,8 @@ class CombatTickService {
     MonsterCombatStats monsterStats,
     int totalDamageDealt,
     List<CombatEvent> events,
-  }) _processDotTicks({
+  })
+  _processDotTicks({
     required List<DotEffect> activeDoTs,
     required MonsterCombatStats monsterStats,
     required int elapsedMs,
@@ -252,13 +275,15 @@ class CombatTickService {
     int lastPotionUsedMs,
     PotionInventory potionInventory,
     List<CombatEvent> events,
-  })? _tryEmergencyPotion({
+  })?
+  _tryEmergencyPotion({
     required CombatStats playerStats,
     required PotionInventory potionInventory,
     required int lastPotionUsedMs,
     required int playerLevel,
     required int timestamp,
     required PotionService potionService,
+    double healingMultiplier = 1.0,
   }) {
     // 글로벌 쿨타임 체크
     if (timestamp - lastPotionUsedMs < PotionService.globalPotionCooldownMs) {
@@ -281,6 +306,7 @@ class CombatTickService {
         maxHp: playerStats.hpMax,
         currentMp: playerStats.mpCurrent,
         maxMp: playerStats.mpMax,
+        healingMultiplier: healingMultiplier,
       );
 
       if (result.success) {
@@ -316,6 +342,7 @@ class CombatTickService {
         maxHp: playerStats.hpMax,
         currentMp: playerStats.mpCurrent,
         maxMp: playerStats.mpMax,
+        healingMultiplier: healingMultiplier,
       );
 
       if (result.success) {
@@ -338,207 +365,9 @@ class CombatTickService {
     return null;
   }
 
-  /// 플레이어 공격 처리
-  ({
-    CombatStats playerStats,
-    MonsterCombatStats monsterStats,
-    SkillSystemState skillSystem,
-    List<DotEffect> activeDoTs,
-    List<ActiveBuff> activeDebuffs,
-    int totalDamageDealt,
-    List<CombatEvent> events,
-  }) _processPlayerAttack({
-    required GameState state,
-    required CombatStats playerStats,
-    required MonsterCombatStats monsterStats,
-    required SkillSystemState updatedSkillSystem,
-    required List<DotEffect> activeDoTs,
-    required List<ActiveBuff> activeDebuffs,
-    required int totalDamageDealt,
-    required int timestamp,
-    required CombatCalculator calculator,
-    required SkillService skillService,
-  }) {
-    final events = <CombatEvent>[];
-    var newPlayerStats = playerStats;
-    var newMonsterStats = monsterStats;
-    var newSkillSystem = updatedSkillSystem;
-    var newActiveDoTs = [...activeDoTs];
-    var newActiveBuffs = [...activeDebuffs];
-    var newTotalDamageDealt = totalDamageDealt;
-
-    // 장착된 스킬 슬롯에서 사용 가능한 스킬 ID 목록 조회
-    var availableSkillIds = state.skillSystem.equippedSkills.allSkills
-        .map((s) => s.id)
-        .toList();
-    // 장착된 스킬이 없으면 기본 스킬 사용
-    if (availableSkillIds.isEmpty) {
-      availableSkillIds = SkillData.defaultSkillIds;
-    }
-
-    final selectedSkill = skillService.selectAutoSkill(
-      player: newPlayerStats,
-      monster: newMonsterStats,
-      skillSystem: newSkillSystem,
-      availableSkillIds: availableSkillIds,
-      activeDoTs: newActiveDoTs,
-      activeDebuffs: newActiveBuffs,
-    );
-
-    if (selectedSkill != null && selectedSkill.isAttack) {
-      // 스킬 랭크 조회
-      final skillRank = skillService.getSkillRankFromSkillBook(
-        state.skillBook,
-        selectedSkill.id,
-      );
-      // 랭크 스케일링 적용된 공격 스킬 사용
-      final skillResult = skillService.useAttackSkillWithRank(
-        skill: selectedSkill,
-        player: newPlayerStats,
-        monster: newMonsterStats,
-        skillSystem: newSkillSystem,
-        rank: skillRank,
-      );
-      newPlayerStats = skillResult.updatedPlayer;
-      newMonsterStats = skillResult.updatedMonster;
-      newTotalDamageDealt += skillResult.result.damage;
-      newSkillSystem = skillResult.updatedSkillSystem.startGlobalCooldown();
-
-      events.add(
-        CombatEvent.playerSkill(
-          timestamp: timestamp,
-          skillName: selectedSkill.name,
-          damage: skillResult.result.damage,
-          targetName: newMonsterStats.name,
-          attackDelayMs: newPlayerStats.attackDelayMs,
-        ),
-      );
-    } else if (selectedSkill != null && selectedSkill.isDot) {
-      final skillResult = skillService.useDotSkill(
-        skill: selectedSkill,
-        player: newPlayerStats,
-        skillSystem: newSkillSystem,
-        playerInt: state.stats.intelligence,
-        playerWis: state.stats.wis,
-      );
-      newPlayerStats = skillResult.updatedPlayer;
-      newSkillSystem = skillResult.updatedSkillSystem.startGlobalCooldown();
-
-      if (skillResult.dotEffect != null) {
-        newActiveDoTs.add(skillResult.dotEffect!);
-      }
-
-      events.add(
-        CombatEvent.playerSkill(
-          timestamp: timestamp,
-          skillName: selectedSkill.name,
-          damage: skillResult.result.damage,
-          targetName: newMonsterStats.name,
-          attackDelayMs: newPlayerStats.attackDelayMs,
-        ),
-      );
-    } else if (selectedSkill != null && selectedSkill.isHeal) {
-      final skillResult = skillService.useHealSkill(
-        skill: selectedSkill,
-        player: newPlayerStats,
-        skillSystem: newSkillSystem,
-      );
-      newPlayerStats = skillResult.updatedPlayer;
-      newSkillSystem = skillResult.updatedSkillSystem.startGlobalCooldown();
-
-      events.add(
-        CombatEvent.playerHeal(
-          timestamp: timestamp,
-          healAmount: skillResult.result.healedAmount,
-          skillName: selectedSkill.name,
-        ),
-      );
-    } else if (selectedSkill != null && selectedSkill.isBuff) {
-      final skillResult = skillService.useBuffSkill(
-        skill: selectedSkill,
-        player: newPlayerStats,
-        skillSystem: newSkillSystem,
-      );
-      newPlayerStats = skillResult.updatedPlayer;
-      newSkillSystem = skillResult.updatedSkillSystem.startGlobalCooldown();
-
-      events.add(
-        CombatEvent.playerBuff(
-          timestamp: timestamp,
-          skillName: selectedSkill.name,
-        ),
-      );
-    } else if (selectedSkill != null && selectedSkill.isDebuff) {
-      final skillResult = skillService.useDebuffSkill(
-        skill: selectedSkill,
-        player: newPlayerStats,
-        skillSystem: newSkillSystem,
-        currentDebuffs: newActiveBuffs,
-      );
-      newPlayerStats = skillResult.updatedPlayer;
-      newSkillSystem = skillResult.updatedSkillSystem.startGlobalCooldown();
-
-      if (skillResult.debuffEffect != null) {
-        newActiveBuffs = newActiveBuffs
-            .where((d) => d.effect.id != skillResult.debuffEffect!.effect.id)
-            .toList()
-          ..add(skillResult.debuffEffect!);
-      }
-
-      events.add(
-        CombatEvent.playerDebuff(
-          timestamp: timestamp,
-          skillName: selectedSkill.name,
-          targetName: newMonsterStats.name,
-        ),
-      );
-    } else {
-      // 일반 공격
-      final attackResult = calculator.playerAttackMonster(
-        attacker: newPlayerStats,
-        defender: newMonsterStats,
-      );
-      newMonsterStats = attackResult.updatedDefender;
-      newTotalDamageDealt += attackResult.result.damage;
-
-      final result = attackResult.result;
-      if (result.isEvaded) {
-        events.add(
-          CombatEvent.monsterEvade(
-            timestamp: timestamp,
-            targetName: newMonsterStats.name,
-          ),
-        );
-      } else {
-        events.add(
-          CombatEvent.playerAttack(
-            timestamp: timestamp,
-            damage: result.damage,
-            targetName: newMonsterStats.name,
-            isCritical: result.isCritical,
-            attackDelayMs: newPlayerStats.attackDelayMs,
-          ),
-        );
-      }
-    }
-
-    return (
-      playerStats: newPlayerStats,
-      monsterStats: newMonsterStats,
-      skillSystem: newSkillSystem,
-      activeDoTs: newActiveDoTs,
-      activeDebuffs: newActiveBuffs,
-      totalDamageDealt: newTotalDamageDealt,
-      events: events,
-    );
-  }
-
   /// 몬스터 공격 처리
-  ({
-    CombatStats playerStats,
-    int totalDamageTaken,
-    List<CombatEvent> events,
-  }) _processMonsterAttack({
+  ({CombatStats playerStats, int totalDamageTaken, List<CombatEvent> events})
+  _processMonsterAttack({
     required CombatStats playerStats,
     required MonsterCombatStats monsterStats,
     required List<ActiveBuff> activeDebuffs,

lib/src/core/engine/death_handler.dart

@@ -0,0 +1,172 @@
+import 'package:asciineverdie/src/core/model/equipment_item.dart';
+import 'package:asciineverdie/src/core/model/equipment_slot.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/item_stats.dart';
+
+/// 플레이어 사망 처리 서비스
+///
+/// ProgressService에서 분리된 사망 관련 로직 담당:
+/// - 장비 손실 계산
+/// - 사망 정보 기록
+/// - 보스전 레벨링 모드 진입
+class DeathHandler {
+  const DeathHandler();
+
+  /// 플레이어 사망 처리 (Phase 4)
+  ///
+  /// 모든 장비 상실 및 사망 정보 기록.
+  /// 보스전 사망 시: 장비 보호 + 5분 레벨링 모드 진입.
+  GameState processPlayerDeath(
+    GameState state, {
+    required String killerName,
+    required DeathCause cause,
+  }) {
+    // 사망 직전 전투 이벤트 저장 (최대 10개)
+    final lastCombatEvents =
+        state.progress.currentCombat?.recentEvents ?? const [];
+
+    // 보스전 사망 여부 확인 (최종 보스 fighting 상태)
+    final isBossDeath =
+        state.progress.finalBossState == FinalBossState.fighting;
+
+    // 보스전 사망이 아닐 경우에만 장비 손실
+    var newEquipment = state.equipment;
+    var lostCount = 0;
+    String? lostItemName;
+    EquipmentSlot? lostItemSlot;
+    ItemRarity? lostItemRarity;
+    EquipmentItem? lostEquipmentItem; // 광고 부활 시 복구용
+
+    if (!isBossDeath) {
+      final lossResult = _calculateEquipmentLoss(state);
+      newEquipment = lossResult.equipment;
+      lostCount = lossResult.lostCount;
+      lostItemName = lossResult.lostItemName;
+      lostItemSlot = lossResult.lostItemSlot;
+      lostItemRarity = lossResult.lostItemRarity;
+      lostEquipmentItem = lossResult.lostItem;
+    }
+
+    // 사망 정보 생성 (전투 로그 포함)
+    final deathInfo = DeathInfo(
+      cause: cause,
+      killerName: killerName,
+      lostEquipmentCount: lostCount,
+      lostItemName: lostItemName,
+      lostItemSlot: lostItemSlot,
+      lostItemRarity: lostItemRarity,
+      lostItem: lostEquipmentItem,
+      goldAtDeath: state.inventory.gold,
+      levelAtDeath: state.traits.level,
+      timestamp: state.skillSystem.elapsedMs,
+      lastCombatEvents: lastCombatEvents,
+    );
+
+    // 보스전 사망 시 5분 레벨링 모드 진입
+    final bossLevelingEndTime = isBossDeath
+        ? DateTime.now().millisecondsSinceEpoch +
+              (5 * 60 * 1000) // 5분
+        : null;
+
+    // 전투 상태 초기화 및 사망 횟수 증가
+    final progress = state.progress.copyWith(
+      currentCombat: null,
+      deathCount: state.progress.deathCount + 1,
+      bossLevelingEndTime: bossLevelingEndTime,
+    );
+
+    return state.copyWith(
+      equipment: newEquipment,
+      progress: progress,
+      deathInfo: deathInfo,
+    );
+  }
+
+  /// 장비 손실 계산
+  ({
+    Equipment equipment,
+    int lostCount,
+    String? lostItemName,
+    EquipmentSlot? lostItemSlot,
+    ItemRarity? lostItemRarity,
+    EquipmentItem? lostItem,
+  })
+  _calculateEquipmentLoss(GameState state) {
+    var newEquipment = state.equipment;
+
+    // 레벨 기반 장비 손실 확률 계산
+    // Lv 1: 20%, Lv 5: ~56%, Lv 10+: 100%
+    // 공식: 20 + (level - 1) * 80 / 9
+    final level = state.traits.level;
+    final lossChancePercent = level >= 10
+        ? 100
+        : (20 + ((level - 1) * 80 ~/ 9)).clamp(0, 100);
+    final roll = state.rng.nextInt(100); // 0~99
+    final shouldLoseEquipment = roll < lossChancePercent;
+
+    // ignore: avoid_print
+    print(
+      '[Death] Lv$level lossChance=$lossChancePercent% roll=$roll '
+      'shouldLose=$shouldLoseEquipment',
+    );
+
+    if (!shouldLoseEquipment) {
+      return (
+        equipment: newEquipment,
+        lostCount: 0,
+        lostItemName: null,
+        lostItemSlot: null,
+        lostItemRarity: null,
+        lostItem: null,
+      );
+    }
+
+    // 무기(슬롯 0)를 제외한 장착된 장비 중 1개를 제물로 삭제
+    final equippedNonWeaponSlots = <int>[];
+    for (var i = 1; i < Equipment.slotCount; i++) {
+      final item = state.equipment.getItemByIndex(i);
+      if (item.isNotEmpty) {
+        equippedNonWeaponSlots.add(i);
+      }
+    }
+
+    if (equippedNonWeaponSlots.isEmpty) {
+      return (
+        equipment: newEquipment,
+        lostCount: 0,
+        lostItemName: null,
+        lostItemSlot: null,
+        lostItemRarity: null,
+        lostItem: null,
+      );
+    }
+
+    // 랜덤하게 1개 슬롯 선택
+    final sacrificeIndex =
+        equippedNonWeaponSlots[state.rng.nextInt(
+          equippedNonWeaponSlots.length,
+        )];
+
+    // 제물로 바칠 아이템 정보 저장
+    final lostItem = state.equipment.getItemByIndex(sacrificeIndex);
+    final lostItemSlot = EquipmentSlot.values[sacrificeIndex];
+
+    // 해당 슬롯을 빈 장비로 교체
+    newEquipment = newEquipment.setItemByIndex(
+      sacrificeIndex,
+      EquipmentItem.empty(lostItemSlot),
+    );
+
+    // ignore: avoid_print
+    print('[Death] Lost item: ${lostItem.name} (slot: $lostItemSlot)');
+
+    return (
+      equipment: newEquipment,
+      lostCount: 1,
+      lostItemName: lostItem.name,
+      lostItemSlot: lostItemSlot,
+      lostItemRarity: lostItem.rarity,
+      lostItem: lostItem,
+    );
+  }
+}

lib/src/core/engine/debug_settings_service.dart

@@ -1,7 +1,6 @@
 import 'package:flutter/foundation.dart';
 import 'package:shared_preferences/shared_preferences.dart';
 
-import 'package:asciineverdie/src/core/engine/ad_service.dart';
 import 'package:asciineverdie/src/core/engine/iap_service.dart';
 
 /// 디버그 설정 서비스 (Phase 8)
@@ -23,7 +22,6 @@ class DebugSettingsService {
   // 상수
   // ===========================================================================
 
-  static const String _keyAdEnabled = 'debug_ad_enabled';
   static const String _keyIapSimulated = 'debug_iap_simulated';
   static const String _keyOfflineHours = 'debug_offline_hours';
 
@@ -36,9 +34,6 @@ class DebugSettingsService {
 
   bool _isInitialized = false;
 
-  /// 광고 활성화 여부 (디버그 모드 전용)
-  bool _adEnabled = true;
-
   /// IAP 구매 시뮬레이션 여부 (디버그 모드 전용)
   bool _iapSimulated = false;
 
@@ -58,7 +53,6 @@ class DebugSettingsService {
     }
 
     final prefs = await SharedPreferences.getInstance();
-    _adEnabled = prefs.getBool(_keyAdEnabled) ?? true;
     _iapSimulated = prefs.getBool(_keyIapSimulated) ?? false;
     _offlineHours = prefs.getInt(_keyOfflineHours) ?? 0;
 
@@ -66,13 +60,14 @@ class DebugSettingsService {
     _syncToServices();
 
     _isInitialized = true;
-    debugPrint('[DebugSettings] Initialized: ad=$_adEnabled, '
-        'iap=$_iapSimulated, offline=$_offlineHours');
+    debugPrint(
+      '[DebugSettings] Initialized: '
+      'iap=$_iapSimulated, offline=$_offlineHours',
+    );
   }
 
   /// 설정을 다른 서비스에 동기화
   void _syncToServices() {
-    AdService.instance.debugAdEnabled = _adEnabled;
     IAPService.instance.debugIAPSimulated = _iapSimulated;
   }
 
@@ -83,29 +78,6 @@ class DebugSettingsService {
   /// 디버그 모드 활성화 여부
   bool get isDebugMode => kDebugMode;
 
-  // ===========================================================================
-  // 광고 설정
-  // ===========================================================================
-
-  /// 광고 활성화 여부
-  ///
-  /// - true: 실제 광고 표시
-  /// - false: 광고 버튼 클릭 시 바로 보상 지급
-  bool get adEnabled => _adEnabled;
-
-  /// 광고 활성화 토글
-  Future<void> setAdEnabled(bool value) async {
-    if (!kDebugMode) return;
-
-    _adEnabled = value;
-    AdService.instance.debugAdEnabled = value;
-
-    final prefs = await SharedPreferences.getInstance();
-    await prefs.setBool(_keyAdEnabled, value);
-
-    debugPrint('[DebugSettings] Ad enabled: $value');
-  }
-
   // ===========================================================================
   // IAP 설정
   // ===========================================================================
@@ -171,7 +143,6 @@ class DebugSettingsService {
   Future<void> resetAll() async {
     if (!kDebugMode) return;
 
-    await setAdEnabled(true);
     await setIapSimulated(false);
     await setOfflineHours(0);
 

lib/src/core/engine/iap_service.dart

@@ -131,9 +131,7 @@ class IAPService {
     final response = await _iap.queryProductDetails(IAPProductIds.all);
 
     if (response.notFoundIDs.isNotEmpty) {
-      debugPrint(
-        '[IAPService] Products not found: ${response.notFoundIDs}',
-      );
+      debugPrint('[IAPService] Products not found: ${response.notFoundIDs}');
     }
 
     for (final product in response.productDetails) {
@@ -238,14 +236,10 @@ class IAPService {
     }
 
     // 구매 요청
-    final purchaseParam = PurchaseParam(
-      productDetails: _removeAdsProduct!,
-    );
+    final purchaseParam = PurchaseParam(productDetails: _removeAdsProduct!);
 
     try {
-      final success = await _iap.buyNonConsumable(
-        purchaseParam: purchaseParam,
-      );
+      final success = await _iap.buyNonConsumable(purchaseParam: purchaseParam);
       debugPrint('[IAPService] Purchase initiated: $success');
       return success ? IAPResult.success : IAPResult.failed;
     } catch (e) {

lib/src/core/engine/item_service.dart

@@ -164,8 +164,9 @@ class ItemService {
     final magDef = hasMagDef ? (def * 0.7).round() : 0;
 
     // HP 보너스 (Uncommon 이상)
-    final hpBonus =
-        rarity.index >= ItemRarity.uncommon.index ? baseValue ~/ 3 : 0;
+    final hpBonus = rarity.index >= ItemRarity.uncommon.index
+        ? baseValue ~/ 3
+        : 0;
 
     // CON 보너스 (Rare 이상)
     final conBonus = rarity.index >= ItemRarity.rare.index ? rarity.index : 0;
@@ -273,8 +274,7 @@ class ItemService {
       EquipmentSlot.greaves => ItemStats(
         def: def,
         hpBonus: rarity.index >= ItemRarity.rare.index ? baseValue ~/ 3 : 0,
-        conBonus:
-            rarity.index >= ItemRarity.rare.index ? rarity.index - 1 : 0,
+        conBonus: rarity.index >= ItemRarity.rare.index ? rarity.index - 1 : 0,
         evasion: rarity.index >= ItemRarity.epic.index ? 0.01 : 0.0,
       ),
 

lib/src/core/engine/loot_handler.dart

@@ -0,0 +1,80 @@
+import 'package:asciineverdie/src/core/engine/game_mutations.dart';
+import 'package:asciineverdie/src/core/engine/potion_service.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monster_grade.dart';
+import 'package:asciineverdie/src/core/model/potion.dart';
+
+/// 전리품 처리 서비스
+///
+/// ProgressService에서 분리된 전리품 획득 로직 담당:
+/// - 몬스터 부위 아이템 인벤토리 추가
+/// - 특수 아이템 획득 (WinItem)
+/// - 물약 드랍
+class LootHandler {
+  const LootHandler({required this.mutations});
+
+  final GameMutations mutations;
+
+  /// 킬 태스크 완료 시 전리품 획득 (원본 Main.pas:625-630)
+  ({GameState state, Potion? droppedPotion}) winLoot(GameState state) {
+    final taskInfo = state.progress.currentTask;
+    final monsterPart = taskInfo.monsterPart ?? '';
+    final monsterBaseName = taskInfo.monsterBaseName ?? '';
+
+    var resultState = state;
+
+    // 부위가 '*'이면 WinItem 호출 (특수 아이템)
+    if (monsterPart == '*') {
+      resultState = mutations.winItem(resultState);
+    } else if (monsterPart.isNotEmpty && monsterBaseName.isNotEmpty) {
+      // 원본: Add(Inventory, LowerCase(Split(fTask.Caption,1) + ' ' +
+      //       ProperCase(Split(fTask.Caption,3))), 1);
+      // 예: "goblin Claw" 형태로 인벤토리 추가
+      final itemName =
+          '${monsterBaseName.toLowerCase()} ${_properCase(monsterPart)}';
+
+      // 인벤토리에 추가
+      final items = [...resultState.inventory.items];
+      final existing = items.indexWhere((e) => e.name == itemName);
+      if (existing >= 0) {
+        items[existing] = items[existing].copyWith(
+          count: items[existing].count + 1,
+        );
+      } else {
+        items.add(InventoryEntry(name: itemName, count: 1));
+      }
+
+      resultState = resultState.copyWith(
+        inventory: resultState.inventory.copyWith(items: items),
+      );
+    }
+
+    // 물약 드랍 시도
+    final potionService = const PotionService();
+    final rng = resultState.rng;
+    final monsterLevel = taskInfo.monsterLevel ?? resultState.traits.level;
+    final monsterGrade = taskInfo.monsterGrade ?? MonsterGrade.normal;
+    final (updatedPotionInventory, droppedPotion) = potionService.tryPotionDrop(
+      playerLevel: resultState.traits.level,
+      monsterLevel: monsterLevel,
+      monsterGrade: monsterGrade,
+      inventory: resultState.potionInventory,
+      roll: rng.nextInt(100),
+      typeRoll: rng.nextInt(100),
+    );
+
+    return (
+      state: resultState.copyWith(
+        rng: rng,
+        potionInventory: updatedPotionInventory,
+      ),
+      droppedPotion: droppedPotion,
+    );
+  }
+
+  /// 첫 글자만 대문자로 변환 (원본 ProperCase)
+  String _properCase(String s) {
+    if (s.isEmpty) return s;
+    return s[0].toUpperCase() + s.substring(1);
+  }
+}

lib/src/core/engine/market_service.dart

@@ -9,10 +9,7 @@ import 'package:asciineverdie/src/core/util/pq_logic.dart' as pq_logic;
 
 /// 판매 처리 결과
 class SellResult {
-  const SellResult({
-    required this.state,
-    required this.continuesSelling,
-  });
+  const SellResult({required this.state, required this.continuesSelling});
 
   final GameState state;
   final bool continuesSelling;

lib/src/core/engine/player_attack_processor.dart

@@ -0,0 +1,411 @@
+import 'package:asciineverdie/data/skill_data.dart';
+import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
+import 'package:asciineverdie/src/core/engine/skill_service.dart';
+import 'package:asciineverdie/src/core/model/combat_event.dart';
+import 'package:asciineverdie/src/core/model/combat_stats.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
+import 'package:asciineverdie/src/core/model/skill.dart';
+import 'package:asciineverdie/src/core/util/deterministic_random.dart';
+
+/// 플레이어 공격 처리 결과
+typedef PlayerAttackResult = ({
+  CombatStats playerStats,
+  MonsterCombatStats monsterStats,
+  SkillSystemState skillSystem,
+  List<DotEffect> activeDoTs,
+  List<ActiveBuff> activeDebuffs,
+  int totalDamageDealt,
+  List<CombatEvent> events,
+  bool isFirstPlayerAttack,
+});
+
+/// 플레이어 공격 처리 서비스
+///
+/// CombatTickService에서 분리된 플레이어 공격 로직 담당:
+/// - 스킬 자동 선택 및 사용
+/// - 일반 공격 처리
+/// - 첫 공격 보너스
+/// - 연속 공격 (Multi-attack)
+class PlayerAttackProcessor {
+  PlayerAttackProcessor({required this.rng});
+
+  final DeterministicRandom rng;
+
+  /// 플레이어 공격 처리
+  PlayerAttackResult processAttack({
+    required GameState state,
+    required CombatStats playerStats,
+    required MonsterCombatStats monsterStats,
+    required SkillSystemState updatedSkillSystem,
+    required List<DotEffect> activeDoTs,
+    required List<ActiveBuff> activeDebuffs,
+    required int totalDamageDealt,
+    required int timestamp,
+    required CombatCalculator calculator,
+    required SkillService skillService,
+    required bool isFirstPlayerAttack,
+    required double firstStrikeBonus,
+    required bool hasMultiAttack,
+    double healingMultiplier = 1.0,
+  }) {
+    final events = <CombatEvent>[];
+    var newPlayerStats = playerStats;
+    var newMonsterStats = monsterStats;
+    var newSkillSystem = updatedSkillSystem;
+    var newActiveDoTs = [...activeDoTs];
+    var newActiveBuffs = [...activeDebuffs];
+    var newTotalDamageDealt = totalDamageDealt;
+
+    // 장착된 스킬 슬롯에서 사용 가능한 스킬 ID 목록 조회
+    var availableSkillIds = state.skillSystem.equippedSkills.allSkills
+        .map((s) => s.id)
+        .toList();
+    // 장착된 스킬이 없으면 기본 스킬 사용
+    if (availableSkillIds.isEmpty) {
+      availableSkillIds = SkillData.defaultSkillIds;
+    }
+
+    final selectedSkill = skillService.selectAutoSkill(
+      player: newPlayerStats,
+      monster: newMonsterStats,
+      skillSystem: newSkillSystem,
+      availableSkillIds: availableSkillIds,
+      activeDoTs: newActiveDoTs,
+      activeDebuffs: newActiveBuffs,
+    );
+
+    if (selectedSkill != null && selectedSkill.isAttack) {
+      final result = _useAttackSkill(
+        state: state,
+        skill: selectedSkill,
+        playerStats: newPlayerStats,
+        monsterStats: newMonsterStats,
+        skillSystem: newSkillSystem,
+        skillService: skillService,
+        timestamp: timestamp,
+      );
+      newPlayerStats = result.playerStats;
+      newMonsterStats = result.monsterStats;
+      newTotalDamageDealt += result.damage;
+      newSkillSystem = result.skillSystem;
+      events.add(result.event);
+    } else if (selectedSkill != null && selectedSkill.isDot) {
+      final result = _useDotSkill(
+        state: state,
+        skill: selectedSkill,
+        playerStats: newPlayerStats,
+        skillSystem: newSkillSystem,
+        skillService: skillService,
+        monsterName: newMonsterStats.name,
+        timestamp: timestamp,
+      );
+      newPlayerStats = result.playerStats;
+      newSkillSystem = result.skillSystem;
+      if (result.dotEffect != null) newActiveDoTs.add(result.dotEffect!);
+      events.add(result.event);
+    } else if (selectedSkill != null && selectedSkill.isHeal) {
+      final result = _useHealSkill(
+        skill: selectedSkill,
+        playerStats: newPlayerStats,
+        skillSystem: newSkillSystem,
+        skillService: skillService,
+        healingMultiplier: healingMultiplier,
+        timestamp: timestamp,
+      );
+      newPlayerStats = result.playerStats;
+      newSkillSystem = result.skillSystem;
+      events.add(result.event);
+    } else if (selectedSkill != null && selectedSkill.isBuff) {
+      final result = skillService.useBuffSkill(
+        skill: selectedSkill,
+        player: newPlayerStats,
+        skillSystem: newSkillSystem,
+      );
+      newPlayerStats = result.updatedPlayer;
+      newSkillSystem = result.updatedSkillSystem.startGlobalCooldown();
+      events.add(
+        CombatEvent.playerBuff(
+          timestamp: timestamp,
+          skillName: selectedSkill.name,
+        ),
+      );
+    } else if (selectedSkill != null && selectedSkill.isDebuff) {
+      final result = _useDebuffSkill(
+        skill: selectedSkill,
+        playerStats: newPlayerStats,
+        skillSystem: newSkillSystem,
+        skillService: skillService,
+        activeDebuffs: newActiveBuffs,
+        monsterName: newMonsterStats.name,
+        timestamp: timestamp,
+      );
+      newPlayerStats = result.playerStats;
+      newSkillSystem = result.skillSystem;
+      newActiveBuffs = result.activeDebuffs;
+      events.add(result.event);
+    } else {
+      // 일반 공격
+      final result = _processNormalAttack(
+        playerStats: newPlayerStats,
+        monsterStats: newMonsterStats,
+        calculator: calculator,
+        isFirstPlayerAttack: isFirstPlayerAttack,
+        firstStrikeBonus: firstStrikeBonus,
+        hasMultiAttack: hasMultiAttack,
+        timestamp: timestamp,
+      );
+      newMonsterStats = result.monsterStats;
+      newTotalDamageDealt += result.totalDamage;
+      events.addAll(result.events);
+    }
+
+    return (
+      playerStats: newPlayerStats,
+      monsterStats: newMonsterStats,
+      skillSystem: newSkillSystem,
+      activeDoTs: newActiveDoTs,
+      activeDebuffs: newActiveBuffs,
+      totalDamageDealt: newTotalDamageDealt,
+      events: events,
+      isFirstPlayerAttack: false,
+    );
+  }
+
+  // ============================================================================
+  // 스킬 사용 헬퍼
+  // ============================================================================
+
+  ({
+    CombatStats playerStats,
+    MonsterCombatStats monsterStats,
+    int damage,
+    SkillSystemState skillSystem,
+    CombatEvent event,
+  })
+  _useAttackSkill({
+    required GameState state,
+    required Skill skill,
+    required CombatStats playerStats,
+    required MonsterCombatStats monsterStats,
+    required SkillSystemState skillSystem,
+    required SkillService skillService,
+    required int timestamp,
+  }) {
+    final skillRank = skillService.getSkillRankFromSkillBook(
+      state.skillBook,
+      skill.id,
+    );
+    final skillResult = skillService.useAttackSkillWithRank(
+      skill: skill,
+      player: playerStats,
+      monster: monsterStats,
+      skillSystem: skillSystem,
+      rank: skillRank,
+    );
+    return (
+      playerStats: skillResult.updatedPlayer,
+      monsterStats: skillResult.updatedMonster,
+      damage: skillResult.result.damage,
+      skillSystem: skillResult.updatedSkillSystem.startGlobalCooldown(),
+      event: CombatEvent.playerSkill(
+        timestamp: timestamp,
+        skillName: skill.name,
+        damage: skillResult.result.damage,
+        targetName: monsterStats.name,
+        attackDelayMs: playerStats.attackDelayMs,
+      ),
+    );
+  }
+
+  ({
+    CombatStats playerStats,
+    SkillSystemState skillSystem,
+    DotEffect? dotEffect,
+    CombatEvent event,
+  })
+  _useDotSkill({
+    required GameState state,
+    required Skill skill,
+    required CombatStats playerStats,
+    required SkillSystemState skillSystem,
+    required SkillService skillService,
+    required String monsterName,
+    required int timestamp,
+  }) {
+    final skillResult = skillService.useDotSkill(
+      skill: skill,
+      player: playerStats,
+      skillSystem: skillSystem,
+      playerInt: state.stats.intelligence,
+      playerWis: state.stats.wis,
+    );
+    return (
+      playerStats: skillResult.updatedPlayer,
+      skillSystem: skillResult.updatedSkillSystem.startGlobalCooldown(),
+      dotEffect: skillResult.dotEffect,
+      event: CombatEvent.playerSkill(
+        timestamp: timestamp,
+        skillName: skill.name,
+        damage: skillResult.result.damage,
+        targetName: monsterName,
+        attackDelayMs: playerStats.attackDelayMs,
+      ),
+    );
+  }
+
+  ({CombatStats playerStats, SkillSystemState skillSystem, CombatEvent event})
+  _useHealSkill({
+    required Skill skill,
+    required CombatStats playerStats,
+    required SkillSystemState skillSystem,
+    required SkillService skillService,
+    required double healingMultiplier,
+    required int timestamp,
+  }) {
+    final skillResult = skillService.useHealSkill(
+      skill: skill,
+      player: playerStats,
+      skillSystem: skillSystem,
+      healingMultiplier: healingMultiplier,
+    );
+    return (
+      playerStats: skillResult.updatedPlayer,
+      skillSystem: skillResult.updatedSkillSystem.startGlobalCooldown(),
+      event: CombatEvent.playerHeal(
+        timestamp: timestamp,
+        healAmount: skillResult.result.healedAmount,
+        skillName: skill.name,
+      ),
+    );
+  }
+
+  ({
+    CombatStats playerStats,
+    SkillSystemState skillSystem,
+    List<ActiveBuff> activeDebuffs,
+    CombatEvent event,
+  })
+  _useDebuffSkill({
+    required Skill skill,
+    required CombatStats playerStats,
+    required SkillSystemState skillSystem,
+    required SkillService skillService,
+    required List<ActiveBuff> activeDebuffs,
+    required String monsterName,
+    required int timestamp,
+  }) {
+    final skillResult = skillService.useDebuffSkill(
+      skill: skill,
+      player: playerStats,
+      skillSystem: skillSystem,
+      currentDebuffs: activeDebuffs,
+    );
+    var newDebuffs = activeDebuffs;
+    if (skillResult.debuffEffect != null) {
+      newDebuffs =
+          activeDebuffs
+              .where((d) => d.effect.id != skillResult.debuffEffect!.effect.id)
+              .toList()
+            ..add(skillResult.debuffEffect!);
+    }
+    return (
+      playerStats: skillResult.updatedPlayer,
+      skillSystem: skillResult.updatedSkillSystem.startGlobalCooldown(),
+      activeDebuffs: newDebuffs,
+      event: CombatEvent.playerDebuff(
+        timestamp: timestamp,
+        skillName: skill.name,
+        targetName: monsterName,
+      ),
+    );
+  }
+
+  // ============================================================================
+  // 일반 공격
+  // ============================================================================
+
+  ({MonsterCombatStats monsterStats, int totalDamage, List<CombatEvent> events})
+  _processNormalAttack({
+    required CombatStats playerStats,
+    required MonsterCombatStats monsterStats,
+    required CombatCalculator calculator,
+    required bool isFirstPlayerAttack,
+    required double firstStrikeBonus,
+    required bool hasMultiAttack,
+    required int timestamp,
+  }) {
+    final events = <CombatEvent>[];
+    var newMonsterStats = monsterStats;
+    var totalDamage = 0;
+
+    final attackResult = calculator.playerAttackMonster(
+      attacker: playerStats,
+      defender: newMonsterStats,
+    );
+    newMonsterStats = attackResult.updatedDefender;
+
+    // 첫 공격 배율 적용
+    var damage = attackResult.result.damage;
+    if (isFirstPlayerAttack && firstStrikeBonus > 1.0) {
+      damage = (damage * firstStrikeBonus).round();
+      final extraDamage = damage - attackResult.result.damage;
+      if (extraDamage > 0) {
+        final newHp = (newMonsterStats.hpCurrent - extraDamage).clamp(
+          0,
+          newMonsterStats.hpMax,
+        );
+        newMonsterStats = newMonsterStats.copyWith(hpCurrent: newHp);
+      }
+    }
+    totalDamage += damage;
+
+    final result = attackResult.result;
+    if (result.isEvaded) {
+      events.add(
+        CombatEvent.monsterEvade(
+          timestamp: timestamp,
+          targetName: newMonsterStats.name,
+        ),
+      );
+    } else {
+      events.add(
+        CombatEvent.playerAttack(
+          timestamp: timestamp,
+          damage: damage,
+          targetName: newMonsterStats.name,
+          isCritical: result.isCritical,
+          attackDelayMs: playerStats.attackDelayMs,
+        ),
+      );
+    }
+
+    // 연속 공격 (Refactor Monk 패시브) - 30% 확률로 추가 공격
+    if (hasMultiAttack && newMonsterStats.isAlive && rng.nextDouble() < 0.3) {
+      final extraAttack = calculator.playerAttackMonster(
+        attacker: playerStats,
+        defender: newMonsterStats,
+      );
+      newMonsterStats = extraAttack.updatedDefender;
+      totalDamage += extraAttack.result.damage;
+
+      if (!extraAttack.result.isEvaded) {
+        events.add(
+          CombatEvent.playerAttack(
+            timestamp: timestamp,
+            damage: extraAttack.result.damage,
+            targetName: newMonsterStats.name,
+            isCritical: extraAttack.result.isCritical,
+            attackDelayMs: playerStats.attackDelayMs,
+          ),
+        );
+      }
+    }
+
+    return (
+      monsterStats: newMonsterStats,
+      totalDamage: totalDamage,
+      events: events,
+    );
+  }
+}

lib/src/core/engine/potion_service.dart

@@ -52,6 +52,7 @@ class PotionService {
   /// [maxHp] 최대 HP
   /// [currentMp] 현재 MP
   /// [maxMp] 최대 MP
+  /// [healingMultiplier] 회복력 배율 (기본 1.0, 클래스 패시브 적용)
   PotionUseResult usePotion({
     required String potionId,
     required PotionInventory inventory,
@@ -59,6 +60,7 @@ class PotionService {
     required int maxHp,
     required int currentMp,
     required int maxMp,
+    double healingMultiplier = 1.0,
   }) {
     final (canUse, failReason) = canUsePotion(potionId, inventory);
     if (!canUse) {
@@ -71,11 +73,15 @@ class PotionService {
     int newMp = currentMp;
 
     if (potion.isHpPotion) {
-      healedAmount = potion.calculateHeal(maxHp);
+      // 회복력 보너스 적용 (예: Debugger Paladin +10%)
+      final baseHeal = potion.calculateHeal(maxHp);
+      healedAmount = (baseHeal * healingMultiplier).round();
       newHp = (currentHp + healedAmount).clamp(0, maxHp);
       healedAmount = newHp - currentHp; // 실제 회복량
     } else if (potion.isMpPotion) {
-      healedAmount = potion.calculateHeal(maxMp);
+      // MP 물약에도 회복력 보너스 적용
+      final baseHeal = potion.calculateHeal(maxMp);
+      healedAmount = (baseHeal * healingMultiplier).round();
       newMp = (currentMp + healedAmount).clamp(0, maxMp);
       healedAmount = newMp - currentMp; // 실제 회복량
     }

lib/src/core/engine/resurrection_service.dart

@@ -346,7 +346,10 @@ class ResurrectionService {
 
     // 해당 슬롯에 아이템 복원
     final slotIndex = lostSlot.index;
-    final updatedEquipment = state.equipment.setItemByIndex(slotIndex, lostItem);
+    final updatedEquipment = state.equipment.setItemByIndex(
+      slotIndex,
+      lostItem,
+    );
 
     // DeathInfo에서 상실 아이템 정보 제거 (복구 완료)
     final updatedDeathInfo = deathInfo.copyWith(

lib/src/core/engine/return_rewards_service.dart

@@ -94,8 +94,10 @@ class ReturnRewardsService {
     // 보너스 상자 (광고 시청 시 동일 개수 추가)
     final bonusChestCount = chestCount;
 
-    debugPrint('[ReturnRewards] $hoursAway hours away, '
-        'chests=$chestCount, bonus=$bonusChestCount, paid=$isPaidUser');
+    debugPrint(
+      '[ReturnRewards] $hoursAway hours away, '
+      'chests=$chestCount, bonus=$bonusChestCount, paid=$isPaidUser',
+    );
 
     return ReturnChestReward(
       hoursAway: hoursAway,
@@ -125,9 +127,14 @@ class ReturnRewardsService {
   /// [reward] 복귀 보상 데이터
   /// [playerLevel] 플레이어 레벨
   /// Returns: 오픈된 상자 보상 목록
-  List<ChestReward> claimBasicReward(ReturnChestReward reward, int playerLevel) {
+  List<ChestReward> claimBasicReward(
+    ReturnChestReward reward,
+    int playerLevel,
+  ) {
     if (!reward.hasReward) return [];
-    debugPrint('[ReturnRewards] Basic reward claimed: ${reward.chestCount} chests');
+    debugPrint(
+      '[ReturnRewards] Basic reward claimed: ${reward.chestCount} chests',
+    );
     return openChests(reward.chestCount, playerLevel);
   }
 
@@ -146,8 +153,10 @@ class ReturnRewardsService {
 
     // 유료 유저는 무료 보너스
     if (IAPService.instance.isAdRemovalPurchased) {
-      debugPrint('[ReturnRewards] Bonus claimed (paid user): '
-          '${reward.bonusChestCount} chests');
+      debugPrint(
+        '[ReturnRewards] Bonus claimed (paid user): '
+        '${reward.bonusChestCount} chests',
+      );
       return openChests(reward.bonusChestCount, playerLevel);
     }
 
@@ -161,8 +170,10 @@ class ReturnRewardsService {
     );
 
     if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
-      debugPrint('[ReturnRewards] Bonus claimed (free user with ad): '
-          '${bonusRewards.length} chests');
+      debugPrint(
+        '[ReturnRewards] Bonus claimed (free user with ad): '
+        '${bonusRewards.length} chests',
+      );
       return bonusRewards;
     }
 

lib/src/core/engine/skill_auto_selector.dart

@@ -0,0 +1,200 @@
+import 'package:asciineverdie/data/skill_data.dart';
+import 'package:asciineverdie/src/core/model/combat_stats.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
+import 'package:asciineverdie/src/core/model/skill.dart';
+import 'package:asciineverdie/src/core/util/deterministic_random.dart';
+
+/// 스킬 자동 선택 AI
+///
+/// SkillService에서 분리된 전투 중 스킬 자동 선택 로직.
+/// 상황별 우선순위에 따라 최적의 스킬을 선택한다.
+class SkillAutoSelector {
+  const SkillAutoSelector({required this.rng});
+
+  final DeterministicRandom rng;
+
+  /// 전투 중 자동 스킬 선택
+  ///
+  /// 우선순위:
+  /// 1. HP < 30% -> 회복 스킬 (최우선)
+  /// 2. 70% 확률로 일반 공격 (MP 절약, 기본 전투)
+  /// 3. 30% 확률로 스킬 사용:
+  ///    - 버프: HP > 80% & MP > 60% & 활성 버프 없음
+  ///    - 디버프: 몬스터 HP > 80% & 활성 디버프 없음
+  ///    - DOT: 몬스터 HP > 60% & 활성 DOT 없음
+  ///    - 공격: 보스전이면 강력한 스킬, 일반전이면 효율적 스킬
+  /// 4. MP < 20% -> 일반 공격
+  Skill? selectAutoSkill({
+    required CombatStats player,
+    required MonsterCombatStats monster,
+    required SkillSystemState skillSystem,
+    required List<String> availableSkillIds,
+    required bool Function(Skill) canUse,
+    List<DotEffect> activeDoTs = const [],
+    List<ActiveBuff> activeDebuffs = const [],
+  }) {
+    final mpRatio = player.mpRatio;
+    final hpRatio = player.hpRatio;
+
+    // MP 20% 미만이면 일반 공격
+    if (mpRatio < 0.2) return null;
+
+    // 사용 가능한 스킬 필터링
+    final availableSkills = availableSkillIds
+        .map((id) => SkillData.getSkillById(id))
+        .whereType<Skill>()
+        .where(canUse)
+        .toList();
+
+    if (availableSkills.isEmpty) return null;
+
+    // HP < 30% -> 회복 스킬 최우선 (생존)
+    if (hpRatio < 0.3) {
+      final healSkill = _findBestHealSkill(availableSkills, player.mpCurrent);
+      if (healSkill != null) return healSkill;
+    }
+
+    // 70% 확률로 일반 공격 (스킬은 특별한 상황에서만)
+    final useNormalAttack = rng.nextInt(100) < 70;
+    if (useNormalAttack) return null;
+
+    // === 아래부터 30% 확률로 스킬 사용 ===
+
+    // 버프: HP > 80% & MP > 60% (매우 안전할 때만)
+    if (hpRatio > 0.8 && mpRatio > 0.6) {
+      final hasActiveBuff = skillSystem.activeBuffs.isNotEmpty;
+      if (!hasActiveBuff) {
+        final buffSkill = _findBestBuffSkill(availableSkills, player.mpCurrent);
+        if (buffSkill != null) return buffSkill;
+      }
+    }
+
+    // 디버프: 몬스터 HP > 80% & 활성 디버프 없음 (전투 초반)
+    if (monster.hpRatio > 0.8 && activeDebuffs.isEmpty) {
+      final debuffSkill = _findBestDebuffSkill(
+        availableSkills,
+        player.mpCurrent,
+      );
+      if (debuffSkill != null) return debuffSkill;
+    }
+
+    // DOT: 몬스터 HP > 60% & 활성 DOT 없음 (장기전 유리)
+    if (monster.hpRatio > 0.6 && activeDoTs.isEmpty) {
+      final dotSkill = _findBestDotSkill(availableSkills, player.mpCurrent);
+      if (dotSkill != null) return dotSkill;
+    }
+
+    // 보스전 판단 (몬스터 레벨 20 이상 & HP 50% 이상)
+    final isBossFight = monster.level >= 20 && monster.hpRatio > 0.5;
+
+    if (isBossFight) {
+      return _findStrongestAttackSkill(availableSkills);
+    }
+
+    // 일반 전투 -> MP 효율 좋은 공격 스킬
+    return _findEfficientAttackSkill(availableSkills);
+  }
+
+  /// 가장 좋은 DOT 스킬 찾기
+  Skill? _findBestDotSkill(List<Skill> skills, int currentMp) {
+    final dotSkills = skills
+        .where((s) => s.isDot && s.mpCost <= currentMp)
+        .toList();
+
+    if (dotSkills.isEmpty) return null;
+
+    dotSkills.sort((a, b) {
+      final aTotal =
+          (a.baseDotDamage ?? 0) *
+          ((a.baseDotDurationMs ?? 0) ~/ (a.baseDotTickMs ?? 1000));
+      final bTotal =
+          (b.baseDotDamage ?? 0) *
+          ((b.baseDotDurationMs ?? 0) ~/ (b.baseDotTickMs ?? 1000));
+      return bTotal.compareTo(aTotal);
+    });
+
+    return dotSkills.first;
+  }
+
+  /// 가장 좋은 회복 스킬 찾기
+  Skill? _findBestHealSkill(List<Skill> skills, int currentMp) {
+    final healSkills = skills
+        .where((s) => s.isHeal && s.mpCost <= currentMp)
+        .toList();
+
+    if (healSkills.isEmpty) return null;
+
+    healSkills.sort((a, b) {
+      final aValue = a.healPercent * 100 + a.healAmount;
+      final bValue = b.healPercent * 100 + b.healAmount;
+      return bValue.compareTo(aValue);
+    });
+
+    return healSkills.first;
+  }
+
+  /// 가장 강력한 공격 스킬 찾기
+  Skill? _findStrongestAttackSkill(List<Skill> skills) {
+    final attackSkills = skills.where((s) => s.isAttack).toList();
+    if (attackSkills.isEmpty) return null;
+
+    attackSkills.sort(
+      (a, b) => b.damageMultiplier.compareTo(a.damageMultiplier),
+    );
+    return attackSkills.first;
+  }
+
+  /// MP 효율 좋은 공격 스킬 찾기
+  Skill? _findEfficientAttackSkill(List<Skill> skills) {
+    final attackSkills = skills.where((s) => s.isAttack).toList();
+    if (attackSkills.isEmpty) return null;
+
+    attackSkills.sort((a, b) => b.mpEfficiency.compareTo(a.mpEfficiency));
+    return attackSkills.first;
+  }
+
+  /// 가장 좋은 버프 스킬 찾기
+  Skill? _findBestBuffSkill(List<Skill> skills, int currentMp) {
+    final buffSkills = skills
+        .where((s) => s.isBuff && s.mpCost <= currentMp && s.buff != null)
+        .toList();
+
+    if (buffSkills.isEmpty) return null;
+
+    buffSkills.sort((a, b) {
+      final aValue =
+          (a.buff?.atkModifier ?? 0) +
+          (a.buff?.defModifier ?? 0) * 0.5 +
+          (a.buff?.criRateModifier ?? 0) * 0.3;
+      final bValue =
+          (b.buff?.atkModifier ?? 0) +
+          (b.buff?.defModifier ?? 0) * 0.5 +
+          (b.buff?.criRateModifier ?? 0) * 0.3;
+      return bValue.compareTo(aValue);
+    });
+
+    return buffSkills.first;
+  }
+
+  /// 가장 좋은 디버프 스킬 찾기
+  Skill? _findBestDebuffSkill(List<Skill> skills, int currentMp) {
+    final debuffSkills = skills
+        .where((s) => s.isDebuff && s.mpCost <= currentMp && s.buff != null)
+        .toList();
+
+    if (debuffSkills.isEmpty) return null;
+
+    debuffSkills.sort((a, b) {
+      final aValue =
+          (a.buff?.atkModifier ?? 0).abs() +
+          (a.buff?.defModifier ?? 0).abs() * 0.5;
+      final bValue =
+          (b.buff?.atkModifier ?? 0).abs() +
+          (b.buff?.defModifier ?? 0).abs() * 0.5;
+      return bValue.compareTo(aValue);
+    });
+
+    return debuffSkills.first;
+  }
+}

lib/src/core/engine/skill_service.dart

@@ -1,4 +1,5 @@
 import 'package:asciineverdie/data/skill_data.dart';
+import 'package:asciineverdie/src/core/engine/skill_auto_selector.dart';
 import 'package:asciineverdie/src/core/model/combat_stats.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
@@ -112,6 +113,8 @@ class SkillService {
   }
 
   /// 회복 스킬 사용
+  ///
+  /// [healingMultiplier] 회복력 배율 (기본 1.0, 클래스 패시브 적용)
   ({
     SkillUseResult result,
     CombatStats updatedPlayer,
@@ -121,6 +124,7 @@ class SkillService {
     required Skill skill,
     required CombatStats player,
     required SkillSystemState skillSystem,
+    double healingMultiplier = 1.0,
   }) {
     // 회복량 계산
     int healAmount = skill.healAmount;
@@ -128,6 +132,9 @@ class SkillService {
       healAmount += (player.hpMax * skill.healPercent).round();
     }
 
+    // 회복력 보너스 적용 (예: Debugger Paladin +10%, Exception Handler +15%)
+    healAmount = (healAmount * healingMultiplier).round();
+
     // HP 회복
     var updatedPlayer = player.applyHeal(healAmount);
 
@@ -303,20 +310,12 @@ class SkillService {
   }
 
   // ============================================================================
-  // 자동 스킬 선택
+  // 자동 스킬 선택 (SkillAutoSelector에 위임)
   // ============================================================================
 
   /// 전투 중 자동 스킬 선택
   ///
-  /// 우선순위:
-  /// 1. HP < 30% → 회복 스킬 (최우선)
-  /// 2. 70% 확률로 일반 공격 (MP 절약, 기본 전투)
-  /// 3. 30% 확률로 스킬 사용:
-  ///    - 버프: HP > 80% & MP > 60% & 활성 버프 없음
-  ///    - 디버프: 몬스터 HP > 80% & 활성 디버프 없음
-  ///    - DOT: 몬스터 HP > 60% & 활성 DOT 없음
-  ///    - 공격: 보스전이면 강력한 스킬, 일반전이면 효율적 스킬
-  /// 4. MP < 20% → 일반 공격
+  /// 세부 로직은 SkillAutoSelector에 위임.
   Skill? selectAutoSkill({
     required CombatStats player,
     required MonsterCombatStats monster,
@@ -325,186 +324,22 @@ class SkillService {
     List<DotEffect> activeDoTs = const [],
     List<ActiveBuff> activeDebuffs = const [],
   }) {
-    final currentMp = player.mpCurrent;
-    final mpRatio = player.mpRatio;
-    final hpRatio = player.hpRatio;
-
-    // MP 20% 미만이면 일반 공격
-    if (mpRatio < 0.2) return null;
-
-    // 사용 가능한 스킬 필터링
-    final availableSkills = availableSkillIds
-        .map((id) => SkillData.getSkillById(id))
-        .whereType<Skill>()
-        .where(
-          (skill) =>
-              canUseSkill(
-                skill: skill,
-                currentMp: currentMp,
-                skillSystem: skillSystem,
-              ) ==
-              null,
-        )
-        .toList();
-
-    if (availableSkills.isEmpty) return null;
-
-    // HP < 30% → 회복 스킬 최우선 (생존)
-    if (hpRatio < 0.3) {
-      final healSkill = _findBestHealSkill(availableSkills, currentMp);
-      if (healSkill != null) return healSkill;
-    }
-
-    // 70% 확률로 일반 공격 (스킬은 특별한 상황에서만)
-    final useNormalAttack = rng.nextInt(100) < 70;
-    if (useNormalAttack) return null;
-
-    // === 아래부터 30% 확률로 스킬 사용 ===
-
-    // 버프: HP > 80% & MP > 60% (매우 안전할 때만)
-    // 활성 버프가 있으면 건너뜀 (중복 방지)
-    if (hpRatio > 0.8 && mpRatio > 0.6) {
-      final hasActiveBuff = skillSystem.activeBuffs.isNotEmpty;
-      if (!hasActiveBuff) {
-        final buffSkill = _findBestBuffSkill(availableSkills, currentMp);
-        if (buffSkill != null) return buffSkill;
-      }
-    }
-
-    // 디버프: 몬스터 HP > 80% & 활성 디버프 없음 (전투 초반)
-    if (monster.hpRatio > 0.8 && activeDebuffs.isEmpty) {
-      final debuffSkill = _findBestDebuffSkill(availableSkills, currentMp);
-      if (debuffSkill != null) return debuffSkill;
-    }
-
-    // DOT: 몬스터 HP > 60% & 활성 DOT 없음 (장기전 유리)
-    if (monster.hpRatio > 0.6 && activeDoTs.isEmpty) {
-      final dotSkill = _findBestDotSkill(availableSkills, currentMp);
-      if (dotSkill != null) return dotSkill;
-    }
-
-    // 보스전 판단 (몬스터 레벨 20 이상 & HP 50% 이상)
-    final isBossFight = monster.level >= 20 && monster.hpRatio > 0.5;
-
-    if (isBossFight) {
-      // 가장 강력한 공격 스킬
-      return _findStrongestAttackSkill(availableSkills);
-    }
-
-    // 일반 전투 → MP 효율 좋은 공격 스킬
-    return _findEfficientAttackSkill(availableSkills);
-  }
-
-  /// 가장 좋은 DOT 스킬 찾기
-  ///
-  /// 예상 총 데미지 (틱 × 데미지) 기준으로 선택
-  Skill? _findBestDotSkill(List<Skill> skills, int currentMp) {
-    final dotSkills = skills
-        .where((s) => s.isDot && s.mpCost <= currentMp)
-        .toList();
-
-    if (dotSkills.isEmpty) return null;
-
-    // 예상 총 데미지 기준 정렬
-    dotSkills.sort((a, b) {
-      final aTotal =
-          (a.baseDotDamage ?? 0) *
-          ((a.baseDotDurationMs ?? 0) ~/ (a.baseDotTickMs ?? 1000));
-      final bTotal =
-          (b.baseDotDamage ?? 0) *
-          ((b.baseDotDurationMs ?? 0) ~/ (b.baseDotTickMs ?? 1000));
-      return bTotal.compareTo(aTotal);
-    });
-
-    return dotSkills.first;
-  }
-
-  /// 가장 좋은 회복 스킬 찾기
-  Skill? _findBestHealSkill(List<Skill> skills, int currentMp) {
-    final healSkills = skills
-        .where((s) => s.isHeal && s.mpCost <= currentMp)
-        .toList();
-
-    if (healSkills.isEmpty) return null;
-
-    // 회복량 기준 정렬 (% 회복 > 고정 회복)
-    healSkills.sort((a, b) {
-      final aValue = a.healPercent * 100 + a.healAmount;
-      final bValue = b.healPercent * 100 + b.healAmount;
-      return bValue.compareTo(aValue);
-    });
-
-    return healSkills.first;
-  }
-
-  /// 가장 강력한 공격 스킬 찾기
-  Skill? _findStrongestAttackSkill(List<Skill> skills) {
-    final attackSkills = skills.where((s) => s.isAttack).toList();
-    if (attackSkills.isEmpty) return null;
-
-    attackSkills.sort(
-      (a, b) => b.damageMultiplier.compareTo(a.damageMultiplier),
+    final selector = SkillAutoSelector(rng: rng);
+    return selector.selectAutoSkill(
+      player: player,
+      monster: monster,
+      skillSystem: skillSystem,
+      availableSkillIds: availableSkillIds,
+      canUse: (skill) =>
+          canUseSkill(
+            skill: skill,
+            currentMp: player.mpCurrent,
+            skillSystem: skillSystem,
+          ) ==
+          null,
+      activeDoTs: activeDoTs,
+      activeDebuffs: activeDebuffs,
     );
-    return attackSkills.first;
-  }
-
-  /// MP 효율 좋은 공격 스킬 찾기
-  Skill? _findEfficientAttackSkill(List<Skill> skills) {
-    final attackSkills = skills.where((s) => s.isAttack).toList();
-    if (attackSkills.isEmpty) return null;
-
-    attackSkills.sort((a, b) => b.mpEfficiency.compareTo(a.mpEfficiency));
-    return attackSkills.first;
-  }
-
-  /// 가장 좋은 버프 스킬 찾기
-  ///
-  /// ATK 증가 버프 우선, 그 다음 복합 버프
-  Skill? _findBestBuffSkill(List<Skill> skills, int currentMp) {
-    final buffSkills = skills
-        .where((s) => s.isBuff && s.mpCost <= currentMp && s.buff != null)
-        .toList();
-
-    if (buffSkills.isEmpty) return null;
-
-    // ATK 증가량 기준 정렬
-    buffSkills.sort((a, b) {
-      final aValue =
-          (a.buff?.atkModifier ?? 0) +
-          (a.buff?.defModifier ?? 0) * 0.5 +
-          (a.buff?.criRateModifier ?? 0) * 0.3;
-      final bValue =
-          (b.buff?.atkModifier ?? 0) +
-          (b.buff?.defModifier ?? 0) * 0.5 +
-          (b.buff?.criRateModifier ?? 0) * 0.3;
-      return bValue.compareTo(aValue);
-    });
-
-    return buffSkills.first;
-  }
-
-  /// 가장 좋은 디버프 스킬 찾기
-  ///
-  /// 적 ATK 감소 디버프 우선
-  Skill? _findBestDebuffSkill(List<Skill> skills, int currentMp) {
-    final debuffSkills = skills
-        .where((s) => s.isDebuff && s.mpCost <= currentMp && s.buff != null)
-        .toList();
-
-    if (debuffSkills.isEmpty) return null;
-
-    // 디버프 효과 크기 기준 정렬 (음수 값이므로 절대값으로 비교)
-    debuffSkills.sort((a, b) {
-      final aValue =
-          (a.buff?.atkModifier ?? 0).abs() +
-          (a.buff?.defModifier ?? 0).abs() * 0.5;
-      final bValue =
-          (b.buff?.atkModifier ?? 0).abs() +
-          (b.buff?.defModifier ?? 0).abs() * 0.5;
-      return bValue.compareTo(aValue);
-    });
-
-    return debuffSkills.first;
   }
 
   // ============================================================================

lib/src/core/engine/stat_calculator.dart

@@ -187,17 +187,6 @@ class StatCalculator {
     return bonus > 0 ? bonus : 1.0;
   }
 
-  /// 사망 시 보존할 장비 개수 (Coredump Undead 패시브)
-  ///
-  /// [race] 종족 특성
-  /// Returns: 보존 장비 개수
-  int calculateDeathEquipmentPreserve(RaceTraits race) {
-    if (race.hasPassive(PassiveType.deathEquipmentPreserve)) {
-      return race.getPassiveValue(PassiveType.deathEquipmentPreserve).round();
-    }
-    return 0;
-  }
-
   /// 연속 공격 가능 여부 (Refactor Monk 패시브)
   bool hasMultiAttack(ClassTraits klass) {
     return klass.hasPassive(ClassPassiveType.multiAttack);

lib/src/core/engine/task_generator.dart

@@ -0,0 +1,259 @@
+import 'dart:math' as math;
+
+import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
+import 'package:asciineverdie/src/shared/animation/monster_size.dart';
+import 'package:asciineverdie/src/core/engine/act_progression_service.dart';
+import 'package:asciineverdie/src/core/engine/combat_calculator.dart';
+import 'package:asciineverdie/src/core/model/combat_state.dart';
+import 'package:asciineverdie/src/core/model/combat_stats.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monster_combat_stats.dart';
+import 'package:asciineverdie/src/core/model/monster_grade.dart';
+import 'package:asciineverdie/src/core/model/pq_config.dart';
+import 'package:asciineverdie/src/core/util/balance_constants.dart';
+import 'package:asciineverdie/src/core/util/pq_logic.dart' as pq_logic;
+
+/// 태스크 생성 서비스
+///
+/// ProgressService에서 분리된 다음 태스크 생성 로직 담당:
+/// - 시장 이동, 전환 태스크, 보스 리트라이, 몬스터 전투 생성
+class TaskGenerator {
+  const TaskGenerator({required this.config});
+
+  final PqConfig config;
+
+  /// 큐가 비어있을 때 다음 태스크 생성 (원본 Dequeue 667-684줄)
+  ({ProgressState progress, QueueState queue}) generateNextTask(
+    GameState state,
+  ) {
+    var progress = state.progress;
+    final queue = state.queue;
+    final oldTaskType = progress.currentTask.type;
+
+    // 1. Encumbrance 초과 시 시장 이동
+    if (_shouldGoToMarket(progress)) {
+      return _createMarketTask(progress, queue);
+    }
+
+    // 2. 전환 태스크 (buying/heading)
+    if (_needsTransitionTask(oldTaskType)) {
+      return _createTransitionTask(state, progress, queue);
+    }
+
+    // 3. Act Boss 리트라이
+    if (state.progress.pendingActCompletion) {
+      return _createActBossRetryTask(state, progress, queue);
+    }
+
+    // 4. 최종 보스 전투
+    if (state.progress.finalBossState == FinalBossState.fighting &&
+        !state.progress.isInBossLevelingMode) {
+      if (state.progress.bossLevelingEndTime != null) {
+        progress = progress.copyWith(clearBossLevelingEndTime: true);
+      }
+      final actProgressionService = ActProgressionService(config: config);
+      return actProgressionService.startFinalBossFight(state, progress, queue);
+    }
+
+    // 5. 일반 몬스터 전투
+    return _createMonsterTask(state, progress, queue);
+  }
+
+  /// 시장 이동 조건 확인
+  bool _shouldGoToMarket(ProgressState progress) {
+    return progress.encumbrance.position >= progress.encumbrance.max &&
+        progress.encumbrance.max > 0;
+  }
+
+  /// 전환 태스크 필요 여부 확인
+  bool _needsTransitionTask(TaskType oldTaskType) {
+    return oldTaskType != TaskType.kill &&
+        oldTaskType != TaskType.neutral &&
+        oldTaskType != TaskType.buying;
+  }
+
+  /// 시장 이동 태스크 생성
+  ({ProgressState progress, QueueState queue}) _createMarketTask(
+    ProgressState progress,
+    QueueState queue,
+  ) {
+    final taskResult = pq_logic.startTask(
+      progress,
+      l10n.taskHeadingToMarket(),
+      4 * 1000,
+    );
+    final updatedProgress = taskResult.progress.copyWith(
+      currentTask: TaskInfo(caption: taskResult.caption, type: TaskType.market),
+      currentCombat: null,
+    );
+    return (progress: updatedProgress, queue: queue);
+  }
+
+  /// 전환 태스크 생성 (buying 또는 heading)
+  ({ProgressState progress, QueueState queue}) _createTransitionTask(
+    GameState state,
+    ProgressState progress,
+    QueueState queue,
+  ) {
+    final gold = state.inventory.gold;
+    final equipPrice = state.traits.level * 50;
+
+    // Gold 충분 시 장비 구매
+    if (gold > equipPrice) {
+      final taskResult = pq_logic.startTask(
+        progress,
+        l10n.taskUpgradingHardware(),
+        5 * 1000,
+      );
+      final updatedProgress = taskResult.progress.copyWith(
+        currentTask: TaskInfo(
+          caption: taskResult.caption,
+          type: TaskType.buying,
+        ),
+        currentCombat: null,
+      );
+      return (progress: updatedProgress, queue: queue);
+    }
+
+    // Gold 부족 시 전장 이동
+    final taskResult = pq_logic.startTask(
+      progress,
+      l10n.taskEnteringDebugZone(),
+      4 * 1000,
+    );
+    final updatedProgress = taskResult.progress.copyWith(
+      currentTask: TaskInfo(
+        caption: taskResult.caption,
+        type: TaskType.neutral,
+      ),
+      currentCombat: null,
+    );
+    return (progress: updatedProgress, queue: queue);
+  }
+
+  /// Act Boss 재도전 태스크 생성
+  ({ProgressState progress, QueueState queue}) _createActBossRetryTask(
+    GameState state,
+    ProgressState progress,
+    QueueState queue,
+  ) {
+    final actProgressionService = ActProgressionService(config: config);
+    final actBoss = actProgressionService.createActBoss(state);
+    final combatCalculator = CombatCalculator(rng: state.rng);
+    final durationMillis = combatCalculator.estimateCombatDurationMs(
+      player: actBoss.playerStats,
+      monster: actBoss.monsterStats,
+    );
+
+    final taskResult = pq_logic.startTask(
+      progress,
+      l10n.taskDebugging(actBoss.monsterStats.name),
+      durationMillis,
+    );
+
+    final updatedProgress = taskResult.progress.copyWith(
+      currentTask: TaskInfo(
+        caption: taskResult.caption,
+        type: TaskType.kill,
+        monsterBaseName: actBoss.monsterStats.name,
+        monsterPart: '*',
+        monsterLevel: actBoss.monsterStats.level,
+        monsterGrade: MonsterGrade.boss,
+        monsterSize: getBossSizeForAct(state.progress.plotStageCount),
+      ),
+      currentCombat: actBoss,
+    );
+
+    return (progress: updatedProgress, queue: queue);
+  }
+
+  /// 일반 몬스터 전투 태스크 생성
+  ({ProgressState progress, QueueState queue}) _createMonsterTask(
+    GameState state,
+    ProgressState progress,
+    QueueState queue,
+  ) {
+    final level = state.traits.level;
+
+    // 퀘스트 몬스터 데이터 확인
+    final questMonster = state.progress.currentQuestMonster;
+    final questMonsterData = questMonster?.monsterData;
+    final questLevel = questMonsterData != null
+        ? int.tryParse(questMonsterData.split('|').elementAtOrNull(1) ?? '') ??
+              0
+        : null;
+
+    // 몬스터 생성
+    final monsterResult = pq_logic.monsterTask(
+      config,
+      state.rng,
+      level,
+      questMonsterData,
+      questLevel,
+    );
+
+    // 몬스터 레벨 조정 (밸런스)
+    final actMinLevel = ActMonsterLevel.forPlotStage(
+      state.progress.plotStageCount,
+    );
+    final baseLevel = math.max(level, actMinLevel);
+    final effectiveMonsterLevel = monsterResult.level
+        .clamp(math.max(1, baseLevel - 3), baseLevel + 3)
+        .toInt();
+
+    // 전투 스탯 생성
+    final playerCombatStats = CombatStats.fromStats(
+      stats: state.stats,
+      equipment: state.equipment,
+      level: level,
+      monsterLevel: effectiveMonsterLevel,
+    );
+
+    final monsterCombatStats = MonsterCombatStats.fromLevel(
+      name: monsterResult.displayName,
+      level: effectiveMonsterLevel,
+      speedType: MonsterCombatStats.inferSpeedType(monsterResult.baseName),
+      plotStageCount: state.progress.plotStageCount,
+    );
+
+    // 전투 상태 및 지속시간
+    final combatState = CombatState.start(
+      playerStats: playerCombatStats,
+      monsterStats: monsterCombatStats,
+    );
+
+    final combatCalculator = CombatCalculator(rng: state.rng);
+    final durationMillis = combatCalculator.estimateCombatDurationMs(
+      player: playerCombatStats,
+      monster: monsterCombatStats,
+    );
+
+    final taskResult = pq_logic.startTask(
+      progress,
+      l10n.taskDebugging(monsterResult.displayName),
+      durationMillis,
+    );
+
+    // 몬스터 사이즈 결정
+    final monsterSize = getMonsterSizeForAct(
+      plotStageCount: state.progress.plotStageCount,
+      grade: monsterResult.grade,
+      rng: state.rng,
+    );
+
+    final updatedProgress = taskResult.progress.copyWith(
+      currentTask: TaskInfo(
+        caption: taskResult.caption,
+        type: TaskType.kill,
+        monsterBaseName: monsterResult.baseName,
+        monsterPart: monsterResult.part,
+        monsterLevel: effectiveMonsterLevel,
+        monsterGrade: monsterResult.grade,
+        monsterSize: monsterSize,
+      ),
+      currentCombat: combatState,
+    );
+
+    return (progress: updatedProgress, queue: queue);
+  }
+}

lib/src/core/model/combat_state.dart

@@ -21,6 +21,7 @@ class CombatState {
     this.activeDoTs = const [],
     this.lastPotionUsedMs = 0,
     this.activeDebuffs = const [],
+    this.isFirstPlayerAttack = true,
   });
 
   /// 플레이어 전투 스탯
@@ -59,6 +60,9 @@ class CombatState {
   /// 몬스터에 적용된 활성 디버프 목록
   final List<ActiveBuff> activeDebuffs;
 
+  /// 첫 번째 플레이어 공격 여부 (firstStrikeBonus 적용용)
+  final bool isFirstPlayerAttack;
+
   // ============================================================================
   // 유틸리티
   // ============================================================================
@@ -124,6 +128,7 @@ class CombatState {
     List<DotEffect>? activeDoTs,
     int? lastPotionUsedMs,
     List<ActiveBuff>? activeDebuffs,
+    bool? isFirstPlayerAttack,
   }) {
     return CombatState(
       playerStats: playerStats ?? this.playerStats,
@@ -140,6 +145,7 @@ class CombatState {
       activeDoTs: activeDoTs ?? this.activeDoTs,
       lastPotionUsedMs: lastPotionUsedMs ?? this.lastPotionUsedMs,
       activeDebuffs: activeDebuffs ?? this.activeDebuffs,
+      isFirstPlayerAttack: isFirstPlayerAttack ?? this.isFirstPlayerAttack,
     );
   }
 

lib/src/core/model/combat_stats.dart

@@ -57,46 +57,64 @@ class CombatStats with _$CombatStats {
     // 기본 스탯
     /// 힘: 물리 공격력 보정
     required int str,
+
     /// 체력: HP, 방어력 보정
     required int con,
+
     /// 민첩: 회피율, 크리티컬율, 명중률, 공격 속도
     required int dex,
+
     /// 지능: 마법 공격력, MP
     required int intelligence,
+
     /// 지혜: 마법 방어력, MP 회복
     required int wis,
+
     /// 매력: 상점 가격, 드롭률 보정
     required int cha,
     // 파생 스탯 (전투용)
     /// 물리 공격력
     required int atk,
+
     /// 물리 방어력
     required int def,
+
     /// 마법 공격력
     required int magAtk,
+
     /// 마법 방어력
     required int magDef,
+
     /// 크리티컬 확률 (0.0 ~ 1.0)
     required double criRate,
+
     /// 크리티컬 데미지 배율 (1.5 ~ 3.0)
     required double criDamage,
+
     /// 회피율 (0.0 ~ 0.5)
     required double evasion,
+
     /// 명중률 (0.8 ~ 1.0)
     required double accuracy,
+
     /// 방패 방어율 (0.0 ~ 0.4)
     required double blockRate,
+
     /// 무기로 쳐내기 확률 (0.0 ~ 0.3)
     required double parryRate,
+
     /// 공격 딜레이 (밀리초)
     required int attackDelayMs,
     // 자원
     /// 최대 HP
     required int hpMax,
+
     /// 현재 HP
     required int hpCurrent,
+
     /// 최대 MP
     required int mpMax,
+
     /// 현재 MP
     required int mpCurrent,
   }) = _CombatStats;

lib/src/core/model/cumulative_statistics.dart

@@ -0,0 +1,276 @@
+import 'package:asciineverdie/src/core/model/session_statistics.dart';
+
+/// 누적 통계 (Cumulative Statistics)
+///
+/// GameStatistics에서 분리된 모든 게임 세션의 누적 통계 모델.
+class CumulativeStatistics {
+  const CumulativeStatistics({
+    required this.totalPlayTimeMs,
+    required this.totalMonstersKilled,
+    required this.totalGoldEarned,
+    required this.totalGoldSpent,
+    required this.totalSkillsUsed,
+    required this.totalCriticalHits,
+    required this.bestCriticalStreak,
+    required this.totalDamageDealt,
+    required this.totalDamageTaken,
+    required this.totalPotionsUsed,
+    required this.totalItemsSold,
+    required this.totalQuestsCompleted,
+    required this.totalDeaths,
+    required this.totalBossesDefeated,
+    required this.totalLevelUps,
+    required this.highestLevel,
+    required this.highestGoldHeld,
+    required this.gamesCompleted,
+    required this.gamesStarted,
+  });
+
+  /// 총 플레이 시간 (밀리초)
+  final int totalPlayTimeMs;
+
+  /// 총 처치한 몬스터 수
+  final int totalMonstersKilled;
+
+  /// 총 획득한 골드
+  final int totalGoldEarned;
+
+  /// 총 소비한 골드
+  final int totalGoldSpent;
+
+  /// 총 스킬 사용 횟수
+  final int totalSkillsUsed;
+
+  /// 총 크리티컬 히트 횟수
+  final int totalCriticalHits;
+
+  /// 최고 연속 크리티컬
+  final int bestCriticalStreak;
+
+  /// 총 입힌 데미지
+  final int totalDamageDealt;
+
+  /// 총 받은 데미지
+  final int totalDamageTaken;
+
+  /// 총 사용한 물약 수
+  final int totalPotionsUsed;
+
+  /// 총 판매한 아이템 수
+  final int totalItemsSold;
+
+  /// 총 완료한 퀘스트 수
+  final int totalQuestsCompleted;
+
+  /// 총 사망 횟수
+  final int totalDeaths;
+
+  /// 총 처치한 보스 수
+  final int totalBossesDefeated;
+
+  /// 총 레벨업 횟수
+  final int totalLevelUps;
+
+  /// 최고 달성 레벨
+  final int highestLevel;
+
+  /// 최대 보유 골드
+  final int highestGoldHeld;
+
+  /// 클리어한 게임 수
+  final int gamesCompleted;
+
+  /// 시작한 게임 수
+  final int gamesStarted;
+
+  /// 총 플레이 시간 Duration
+  Duration get totalPlayTime => Duration(milliseconds: totalPlayTimeMs);
+
+  /// 총 플레이 시간 포맷 (HH:MM:SS)
+  String get formattedTotalPlayTime {
+    final hours = totalPlayTime.inHours;
+    final minutes = totalPlayTime.inMinutes % 60;
+    final seconds = totalPlayTime.inSeconds % 60;
+    return '${hours.toString().padLeft(2, '0')}:'
+        '${minutes.toString().padLeft(2, '0')}:'
+        '${seconds.toString().padLeft(2, '0')}';
+  }
+
+  /// 평균 게임당 플레이 시간
+  Duration get averagePlayTimePerGame {
+    if (gamesStarted <= 0) return Duration.zero;
+    return Duration(milliseconds: totalPlayTimeMs ~/ gamesStarted);
+  }
+
+  /// 게임 완료율
+  double get completionRate {
+    if (gamesStarted <= 0) return 0;
+    return gamesCompleted / gamesStarted;
+  }
+
+  /// 빈 누적 통계
+  factory CumulativeStatistics.empty() => const CumulativeStatistics(
+    totalPlayTimeMs: 0,
+    totalMonstersKilled: 0,
+    totalGoldEarned: 0,
+    totalGoldSpent: 0,
+    totalSkillsUsed: 0,
+    totalCriticalHits: 0,
+    bestCriticalStreak: 0,
+    totalDamageDealt: 0,
+    totalDamageTaken: 0,
+    totalPotionsUsed: 0,
+    totalItemsSold: 0,
+    totalQuestsCompleted: 0,
+    totalDeaths: 0,
+    totalBossesDefeated: 0,
+    totalLevelUps: 0,
+    highestLevel: 0,
+    highestGoldHeld: 0,
+    gamesCompleted: 0,
+    gamesStarted: 0,
+  );
+
+  /// 세션 통계 병합
+  CumulativeStatistics mergeSession(SessionStatistics session) {
+    return CumulativeStatistics(
+      totalPlayTimeMs: totalPlayTimeMs + session.playTimeMs,
+      totalMonstersKilled: totalMonstersKilled + session.monstersKilled,
+      totalGoldEarned: totalGoldEarned + session.goldEarned,
+      totalGoldSpent: totalGoldSpent + session.goldSpent,
+      totalSkillsUsed: totalSkillsUsed + session.skillsUsed,
+      totalCriticalHits: totalCriticalHits + session.criticalHits,
+      bestCriticalStreak: session.maxCriticalStreak > bestCriticalStreak
+          ? session.maxCriticalStreak
+          : bestCriticalStreak,
+      totalDamageDealt: totalDamageDealt + session.totalDamageDealt,
+      totalDamageTaken: totalDamageTaken + session.totalDamageTaken,
+      totalPotionsUsed: totalPotionsUsed + session.potionsUsed,
+      totalItemsSold: totalItemsSold + session.itemsSold,
+      totalQuestsCompleted: totalQuestsCompleted + session.questsCompleted,
+      totalDeaths: totalDeaths + session.deathCount,
+      totalBossesDefeated: totalBossesDefeated + session.bossesDefeated,
+      totalLevelUps: totalLevelUps + session.levelUps,
+      highestLevel: highestLevel,
+      highestGoldHeld: highestGoldHeld,
+      gamesCompleted: gamesCompleted,
+      gamesStarted: gamesStarted,
+    );
+  }
+
+  /// 최고 레벨 업데이트
+  CumulativeStatistics updateHighestLevel(int level) {
+    if (level <= highestLevel) return this;
+    return copyWith(highestLevel: level);
+  }
+
+  /// 최대 골드 업데이트
+  CumulativeStatistics updateHighestGold(int gold) {
+    if (gold <= highestGoldHeld) return this;
+    return copyWith(highestGoldHeld: gold);
+  }
+
+  /// 새 게임 시작 기록
+  CumulativeStatistics recordGameStart() {
+    return copyWith(gamesStarted: gamesStarted + 1);
+  }
+
+  /// 게임 클리어 기록
+  CumulativeStatistics recordGameComplete() {
+    return copyWith(gamesCompleted: gamesCompleted + 1);
+  }
+
+  CumulativeStatistics copyWith({
+    int? totalPlayTimeMs,
+    int? totalMonstersKilled,
+    int? totalGoldEarned,
+    int? totalGoldSpent,
+    int? totalSkillsUsed,
+    int? totalCriticalHits,
+    int? bestCriticalStreak,
+    int? totalDamageDealt,
+    int? totalDamageTaken,
+    int? totalPotionsUsed,
+    int? totalItemsSold,
+    int? totalQuestsCompleted,
+    int? totalDeaths,
+    int? totalBossesDefeated,
+    int? totalLevelUps,
+    int? highestLevel,
+    int? highestGoldHeld,
+    int? gamesCompleted,
+    int? gamesStarted,
+  }) {
+    return CumulativeStatistics(
+      totalPlayTimeMs: totalPlayTimeMs ?? this.totalPlayTimeMs,
+      totalMonstersKilled: totalMonstersKilled ?? this.totalMonstersKilled,
+      totalGoldEarned: totalGoldEarned ?? this.totalGoldEarned,
+      totalGoldSpent: totalGoldSpent ?? this.totalGoldSpent,
+      totalSkillsUsed: totalSkillsUsed ?? this.totalSkillsUsed,
+      totalCriticalHits: totalCriticalHits ?? this.totalCriticalHits,
+      bestCriticalStreak: bestCriticalStreak ?? this.bestCriticalStreak,
+      totalDamageDealt: totalDamageDealt ?? this.totalDamageDealt,
+      totalDamageTaken: totalDamageTaken ?? this.totalDamageTaken,
+      totalPotionsUsed: totalPotionsUsed ?? this.totalPotionsUsed,
+      totalItemsSold: totalItemsSold ?? this.totalItemsSold,
+      totalQuestsCompleted: totalQuestsCompleted ?? this.totalQuestsCompleted,
+      totalDeaths: totalDeaths ?? this.totalDeaths,
+      totalBossesDefeated: totalBossesDefeated ?? this.totalBossesDefeated,
+      totalLevelUps: totalLevelUps ?? this.totalLevelUps,
+      highestLevel: highestLevel ?? this.highestLevel,
+      highestGoldHeld: highestGoldHeld ?? this.highestGoldHeld,
+      gamesCompleted: gamesCompleted ?? this.gamesCompleted,
+      gamesStarted: gamesStarted ?? this.gamesStarted,
+    );
+  }
+
+  /// JSON 직렬화
+  Map<String, dynamic> toJson() {
+    return {
+      'totalPlayTimeMs': totalPlayTimeMs,
+      'totalMonstersKilled': totalMonstersKilled,
+      'totalGoldEarned': totalGoldEarned,
+      'totalGoldSpent': totalGoldSpent,
+      'totalSkillsUsed': totalSkillsUsed,
+      'totalCriticalHits': totalCriticalHits,
+      'bestCriticalStreak': bestCriticalStreak,
+      'totalDamageDealt': totalDamageDealt,
+      'totalDamageTaken': totalDamageTaken,
+      'totalPotionsUsed': totalPotionsUsed,
+      'totalItemsSold': totalItemsSold,
+      'totalQuestsCompleted': totalQuestsCompleted,
+      'totalDeaths': totalDeaths,
+      'totalBossesDefeated': totalBossesDefeated,
+      'totalLevelUps': totalLevelUps,
+      'highestLevel': highestLevel,
+      'highestGoldHeld': highestGoldHeld,
+      'gamesCompleted': gamesCompleted,
+      'gamesStarted': gamesStarted,
+    };
+  }
+
+  /// JSON 역직렬화
+  factory CumulativeStatistics.fromJson(Map<String, dynamic> json) {
+    return CumulativeStatistics(
+      totalPlayTimeMs: json['totalPlayTimeMs'] as int? ?? 0,
+      totalMonstersKilled: json['totalMonstersKilled'] as int? ?? 0,
+      totalGoldEarned: json['totalGoldEarned'] as int? ?? 0,
+      totalGoldSpent: json['totalGoldSpent'] as int? ?? 0,
+      totalSkillsUsed: json['totalSkillsUsed'] as int? ?? 0,
+      totalCriticalHits: json['totalCriticalHits'] as int? ?? 0,
+      bestCriticalStreak: json['bestCriticalStreak'] as int? ?? 0,
+      totalDamageDealt: json['totalDamageDealt'] as int? ?? 0,
+      totalDamageTaken: json['totalDamageTaken'] as int? ?? 0,
+      totalPotionsUsed: json['totalPotionsUsed'] as int? ?? 0,
+      totalItemsSold: json['totalItemsSold'] as int? ?? 0,
+      totalQuestsCompleted: json['totalQuestsCompleted'] as int? ?? 0,
+      totalDeaths: json['totalDeaths'] as int? ?? 0,
+      totalBossesDefeated: json['totalBossesDefeated'] as int? ?? 0,
+      totalLevelUps: json['totalLevelUps'] as int? ?? 0,
+      highestLevel: json['highestLevel'] as int? ?? 0,
+      highestGoldHeld: json['highestGoldHeld'] as int? ?? 0,
+      gamesCompleted: json['gamesCompleted'] as int? ?? 0,
+      gamesStarted: json['gamesStarted'] as int? ?? 0,
+    );
+  }
+}

lib/src/core/model/death_info.dart

@@ -0,0 +1,96 @@
+import 'package:asciineverdie/src/core/model/combat_event.dart';
+import 'package:asciineverdie/src/core/model/equipment_item.dart';
+import 'package:asciineverdie/src/core/model/equipment_slot.dart';
+import 'package:asciineverdie/src/core/model/item_stats.dart';
+
+/// 사망 원인 (Death Cause)
+enum DeathCause {
+  /// 몬스터에 의한 사망
+  monster,
+
+  /// 자해 스킬에 의한 사망
+  selfDamage,
+
+  /// 환경 피해에 의한 사망
+  environment,
+}
+
+/// 사망 정보 (Phase 4)
+///
+/// 사망 시점의 정보와 상실한 아이템을 기록
+class DeathInfo {
+  const DeathInfo({
+    required this.cause,
+    required this.killerName,
+    required this.lostEquipmentCount,
+    required this.goldAtDeath,
+    required this.levelAtDeath,
+    required this.timestamp,
+    this.lostItemName,
+    this.lostItemSlot,
+    this.lostItemRarity,
+    this.lostItem,
+    this.lastCombatEvents = const [],
+  });
+
+  /// 사망 원인
+  final DeathCause cause;
+
+  /// 사망시킨 몬스터/원인 이름
+  final String killerName;
+
+  /// 상실한 장비 개수 (0 또는 1)
+  final int lostEquipmentCount;
+
+  /// 제물로 바친 아이템 이름 (null이면 없음)
+  final String? lostItemName;
+
+  /// 제물로 바친 아이템 슬롯 (null이면 없음)
+  final EquipmentSlot? lostItemSlot;
+
+  /// 제물로 바친 아이템 희귀도 (null이면 없음)
+  final ItemRarity? lostItemRarity;
+
+  /// 상실한 장비 전체 정보 (광고 부활 시 복구용)
+  final EquipmentItem? lostItem;
+
+  /// 사망 시점 골드
+  final int goldAtDeath;
+
+  /// 사망 시점 레벨
+  final int levelAtDeath;
+
+  /// 사망 시각 (밀리초)
+  final int timestamp;
+
+  /// 사망 직전 전투 이벤트 (최대 10개)
+  final List<CombatEvent> lastCombatEvents;
+
+  DeathInfo copyWith({
+    DeathCause? cause,
+    String? killerName,
+    int? lostEquipmentCount,
+    String? lostItemName,
+    EquipmentSlot? lostItemSlot,
+    ItemRarity? lostItemRarity,
+    EquipmentItem? lostItem,
+    int? goldAtDeath,
+    int? levelAtDeath,
+    int? timestamp,
+    List<CombatEvent>? lastCombatEvents,
+  }) {
+    return DeathInfo(
+      cause: cause ?? this.cause,
+      killerName: killerName ?? this.killerName,
+      lostEquipmentCount: lostEquipmentCount ?? this.lostEquipmentCount,
+      lostItemName: lostItemName ?? this.lostItemName,
+      lostItemSlot: lostItemSlot ?? this.lostItemSlot,
+      lostItemRarity: lostItemRarity ?? this.lostItemRarity,
+      lostItem: lostItem ?? this.lostItem,
+      goldAtDeath: goldAtDeath ?? this.goldAtDeath,
+      levelAtDeath: levelAtDeath ?? this.levelAtDeath,
+      timestamp: timestamp ?? this.timestamp,
+      lastCombatEvents: lastCombatEvents ?? this.lastCombatEvents,
+    );
+  }
+}

lib/src/core/model/equipment_container.dart

@@ -0,0 +1,220 @@
+import 'package:asciineverdie/src/core/model/equipment_item.dart';
+import 'package:asciineverdie/src/core/model/equipment_slot.dart';
+import 'package:asciineverdie/src/core/model/item_stats.dart';
+
+/// 장비 (원본 Main.dfm Equips ListView, 11개 슬롯)
+///
+/// Phase 2에서 EquipmentItem 기반으로 확장됨.
+/// 기존 문자열 API(weapon, shield 등)는 호환성을 위해 유지.
+class Equipment {
+  Equipment({required this.items, required this.bestIndex})
+    : assert(items.length == slotCount, 'Equipment must have $slotCount items');
+
+  /// 장비 아이템 목록 (11개 슬롯)
+  final List<EquipmentItem> items;
+
+  /// 최고 아이템 슬롯 인덱스 (원본 Equips.Tag, 0-10)
+  final int bestIndex;
+
+  /// 슬롯 개수
+  static const slotCount = 11;
+
+  // ==========================================================================
+  // 문자열 API (기존 코드 호환성)
+  // ==========================================================================
+
+  String get weapon => items[0].name; // 0: 무기
+  String get shield => items[1].name; // 1: 방패
+  String get helm => items[2].name; // 2: 투구
+  String get hauberk => items[3].name; // 3: 사슬갑옷
+  String get brassairts => items[4].name; // 4: 상완갑
+  String get vambraces => items[5].name; // 5: 전완갑
+  String get gauntlets => items[6].name; // 6: 건틀릿
+  String get gambeson => items[7].name; // 7: 갬비슨
+  String get cuisses => items[8].name; // 8: 허벅지갑
+  String get greaves => items[9].name; // 9: 정강이갑
+  String get sollerets => items[10].name; // 10: 철제신발
+
+  // ==========================================================================
+  // EquipmentItem API
+  // ==========================================================================
+
+  EquipmentItem get weaponItem => items[0];
+  EquipmentItem get shieldItem => items[1];
+  EquipmentItem get helmItem => items[2];
+  EquipmentItem get hauberkItem => items[3];
+  EquipmentItem get brassairtsItem => items[4];
+  EquipmentItem get vambracesItem => items[5];
+  EquipmentItem get gauntletsItem => items[6];
+  EquipmentItem get gambesonItem => items[7];
+  EquipmentItem get cuissesItem => items[8];
+  EquipmentItem get greavesItem => items[9];
+  EquipmentItem get solleretsItem => items[10];
+
+  /// 모든 장비 스탯 합산
+  ItemStats get totalStats {
+    return items.fold(ItemStats.empty, (sum, item) => sum + item.stats);
+  }
+
+  /// 모든 장비 무게 합산
+  int get totalWeight {
+    return items.fold(0, (sum, item) => sum + item.weight);
+  }
+
+  /// 장착된 아이템 목록 (빈 슬롯 제외)
+  List<EquipmentItem> get equippedItems {
+    return items.where((item) => item.isNotEmpty).toList();
+  }
+
+  // ==========================================================================
+  // 팩토리 메서드
+  // ==========================================================================
+
+  factory Equipment.empty() {
+    return Equipment(
+      items: [
+        EquipmentItem.defaultWeapon(), // 0: 무기 (Keyboard)
+        EquipmentItem.empty(EquipmentSlot.shield), // 1: 방패
+        EquipmentItem.empty(EquipmentSlot.helm), // 2: 투구
+        EquipmentItem.empty(EquipmentSlot.hauberk), // 3: 사슬갑옷
+        EquipmentItem.empty(EquipmentSlot.brassairts), // 4: 상완갑
+        EquipmentItem.empty(EquipmentSlot.vambraces), // 5: 전완갑
+        EquipmentItem.empty(EquipmentSlot.gauntlets), // 6: 건틀릿
+        EquipmentItem.empty(EquipmentSlot.gambeson), // 7: 갬비슨
+        EquipmentItem.empty(EquipmentSlot.cuisses), // 8: 허벅지갑
+        EquipmentItem.empty(EquipmentSlot.greaves), // 9: 정강이갑
+        EquipmentItem.empty(EquipmentSlot.sollerets), // 10: 철제신발
+      ],
+      bestIndex: 0,
+    );
+  }
+
+  /// 초보자 장비 세트 (모든 슬롯에 기본 방어구 지급)
+  ///
+  /// 원본 PQ에서는 초기 장비가 없지만, 밸런스 개선을 위해
+  /// Act 1 완료 전에도 기본 방어력을 제공.
+  factory Equipment.withStarterGear() {
+    return Equipment(
+      items: [
+        EquipmentItem.defaultWeapon(), // 0: 무기 (Keyboard)
+        _starterArmor('Old Mouse', EquipmentSlot.shield, def: 2),
+        _starterArmor('Cardboard Box', EquipmentSlot.helm, def: 1),
+        _starterArmor('Worn T-Shirt', EquipmentSlot.hauberk, def: 3),
+        _starterArmor('Rubber Band', EquipmentSlot.brassairts, def: 1),
+        _starterArmor('Wristwatch', EquipmentSlot.vambraces, def: 1),
+        _starterArmor('Fingerless Gloves', EquipmentSlot.gauntlets, def: 1),
+        _starterArmor('Hoodie', EquipmentSlot.gambeson, def: 2),
+        _starterArmor('Jeans', EquipmentSlot.cuisses, def: 2),
+        _starterArmor('Knee Pads', EquipmentSlot.greaves, def: 1),
+        _starterArmor('Sneakers', EquipmentSlot.sollerets, def: 1),
+      ],
+      bestIndex: 0,
+    );
+  }
+
+  /// 초보자 방어구 생성 헬퍼
+  static EquipmentItem _starterArmor(
+    String name,
+    EquipmentSlot slot, {
+    required int def,
+  }) {
+    return EquipmentItem(
+      name: name,
+      slot: slot,
+      level: 1,
+      weight: 1,
+      stats: ItemStats(def: def),
+      rarity: ItemRarity.common,
+    );
+  }
+
+  /// 레거시 문자열 기반 생성자 (세이브 파일 호환용)
+  factory Equipment.fromStrings({
+    required String weapon,
+    required String shield,
+    required String helm,
+    required String hauberk,
+    required String brassairts,
+    required String vambraces,
+    required String gauntlets,
+    required String gambeson,
+    required String cuisses,
+    required String greaves,
+    required String sollerets,
+    required int bestIndex,
+  }) {
+    return Equipment(
+      items: [
+        _itemFromString(weapon, EquipmentSlot.weapon),
+        _itemFromString(shield, EquipmentSlot.shield),
+        _itemFromString(helm, EquipmentSlot.helm),
+        _itemFromString(hauberk, EquipmentSlot.hauberk),
+        _itemFromString(brassairts, EquipmentSlot.brassairts),
+        _itemFromString(vambraces, EquipmentSlot.vambraces),
+        _itemFromString(gauntlets, EquipmentSlot.gauntlets),
+        _itemFromString(gambeson, EquipmentSlot.gambeson),
+        _itemFromString(cuisses, EquipmentSlot.cuisses),
+        _itemFromString(greaves, EquipmentSlot.greaves),
+        _itemFromString(sollerets, EquipmentSlot.sollerets),
+      ],
+      bestIndex: bestIndex,
+    );
+  }
+
+  /// 문자열에서 기본 EquipmentItem 생성 (레거시 호환)
+  static EquipmentItem _itemFromString(String name, EquipmentSlot slot) {
+    if (name.isEmpty) {
+      return EquipmentItem.empty(slot);
+    }
+    // 레거시 아이템: 레벨 1, Common, 기본 스탯
+    return EquipmentItem(
+      name: name,
+      slot: slot,
+      level: 1,
+      weight: 5,
+      stats: ItemStats.empty,
+      rarity: ItemRarity.common,
+    );
+  }
+
+  // ==========================================================================
+  // 유틸리티 메서드
+  // ==========================================================================
+
+  /// 인덱스로 슬롯 이름 가져오기 (기존 API 호환)
+  String getByIndex(int index) {
+    if (index < 0 || index >= slotCount) return '';
+    return items[index].name;
+  }
+
+  /// 인덱스로 EquipmentItem 가져오기
+  EquipmentItem getItemByIndex(int index) {
+    if (index < 0 || index >= slotCount) {
+      return EquipmentItem.empty(EquipmentSlot.weapon);
+    }
+    return items[index];
+  }
+
+  /// 인덱스로 슬롯 값 설정 (문자열, 기존 API 호환)
+  Equipment setByIndex(int index, String value) {
+    if (index < 0 || index >= slotCount) return this;
+    final slot = EquipmentSlot.values[index];
+    final newItem = _itemFromString(value, slot);
+    return setItemByIndex(index, newItem);
+  }
+
+  /// 인덱스로 EquipmentItem 설정
+  Equipment setItemByIndex(int index, EquipmentItem item) {
+    if (index < 0 || index >= slotCount) return this;
+    final newItems = List<EquipmentItem>.from(items);
+    newItems[index] = item;
+    return Equipment(items: newItems, bestIndex: bestIndex);
+  }
+
+  Equipment copyWith({List<EquipmentItem>? items, int? bestIndex}) {
+    return Equipment(
+      items: items ?? List<EquipmentItem>.from(this.items),
+      bestIndex: bestIndex ?? this.bestIndex,
+    );
+  }
+}

lib/src/core/model/equipment_item.dart

@@ -17,16 +17,23 @@ class EquipmentItem with _$EquipmentItem {
   const factory EquipmentItem({
     /// 아이템 이름 (예: "Flaming Sword of Doom")
     required String name,
+
     /// 장착 슬롯
+    // ignore: invalid_annotation_target
     @JsonKey(fromJson: _slotFromJson, toJson: _slotToJson)
     required EquipmentSlot slot,
+
     /// 아이템 레벨
     required int level,
+
     /// 무게 (STR 기반 휴대 제한용)
     required int weight,
+
     /// 아이템 스탯 보정치
     required ItemStats stats,
+
     /// 희귀도
+    // ignore: invalid_annotation_target
     @JsonKey(fromJson: _rarityFromJson, toJson: _rarityToJson)
     required ItemRarity rarity,
   }) = _EquipmentItem;

lib/src/core/model/game_state.dart

@@ -1,21 +1,35 @@
-import 'dart:collection';
+/// 게임 상태 모듈 (Game State Module)
+///
+/// 하위 파일들을 re-export하여 기존 import 호환성 유지
+library;
 
-import 'package:asciineverdie/src/core/animation/monster_size.dart';
-import 'package:asciineverdie/src/core/model/combat_event.dart';
-import 'package:asciineverdie/src/core/model/combat_state.dart';
-import 'package:asciineverdie/src/core/model/equipment_item.dart';
-import 'package:asciineverdie/src/core/model/equipment_slot.dart';
-import 'package:asciineverdie/src/core/model/item_stats.dart';
-import 'package:asciineverdie/src/core/model/monster_grade.dart';
+export 'death_info.dart';
+export 'equipment_container.dart';
+export 'inventory.dart';
+export 'progress_state.dart';
+export 'queue_state.dart';
+export 'skill_book.dart';
+export 'skill_system_state.dart';
+export 'stats.dart';
+export 'task_info.dart';
+export 'traits.dart';
+
+import 'package:asciineverdie/src/core/model/death_info.dart';
+import 'package:asciineverdie/src/core/model/equipment_container.dart';
+import 'package:asciineverdie/src/core/model/inventory.dart';
 import 'package:asciineverdie/src/core/model/potion.dart';
-import 'package:asciineverdie/src/core/model/skill.dart';
-import 'package:asciineverdie/src/core/model/skill_slots.dart';
+import 'package:asciineverdie/src/core/model/progress_state.dart';
+import 'package:asciineverdie/src/core/model/queue_state.dart';
+import 'package:asciineverdie/src/core/model/skill_book.dart';
+import 'package:asciineverdie/src/core/model/skill_system_state.dart';
+import 'package:asciineverdie/src/core/model/stats.dart';
+import 'package:asciineverdie/src/core/model/traits.dart';
 import 'package:asciineverdie/src/core/util/deterministic_random.dart';
 
-/// Minimal skeletal state to mirror Progress Quest structures.
+/// 게임 전체 상태 (Game State)
 ///
-/// Logic will be ported faithfully from the Delphi source; this file only
-/// defines containers and helpers for deterministic RNG.
+/// Progress Quest 구조를 미러링하는 최소 스켈레톤 상태.
+/// 로직은 Delphi 소스에서 충실하게 포팅됨.
 class GameState {
   GameState({
     required DeterministicRandom rng,
@@ -118,880 +132,3 @@ class GameState {
     );
   }
 }
-
-/// 사망 정보 (Phase 4)
-///
-/// 사망 시점의 정보와 상실한 아이템을 기록
-class DeathInfo {
-  const DeathInfo({
-    required this.cause,
-    required this.killerName,
-    required this.lostEquipmentCount,
-    required this.goldAtDeath,
-    required this.levelAtDeath,
-    required this.timestamp,
-    this.lostItemName,
-    this.lostItemSlot,
-    this.lostItemRarity,
-    this.lostItem,
-    this.lastCombatEvents = const [],
-  });
-
-  /// 사망 원인
-  final DeathCause cause;
-
-  /// 사망시킨 몬스터/원인 이름
-  final String killerName;
-
-  /// 상실한 장비 개수 (0 또는 1)
-  final int lostEquipmentCount;
-
-  /// 제물로 바친 아이템 이름 (null이면 없음)
-  final String? lostItemName;
-
-  /// 제물로 바친 아이템 슬롯 (null이면 없음)
-  final EquipmentSlot? lostItemSlot;
-
-  /// 제물로 바친 아이템 희귀도 (null이면 없음)
-  final ItemRarity? lostItemRarity;
-
-  /// 상실한 장비 전체 정보 (광고 부활 시 복구용)
-  final EquipmentItem? lostItem;
-
-  /// 사망 시점 골드
-  final int goldAtDeath;
-
-  /// 사망 시점 레벨
-  final int levelAtDeath;
-
-  /// 사망 시각 (밀리초)
-  final int timestamp;
-
-  /// 사망 직전 전투 이벤트 (최대 10개)
-  final List<CombatEvent> lastCombatEvents;
-
-  DeathInfo copyWith({
-    DeathCause? cause,
-    String? killerName,
-    int? lostEquipmentCount,
-    String? lostItemName,
-    EquipmentSlot? lostItemSlot,
-    ItemRarity? lostItemRarity,
-    EquipmentItem? lostItem,
-    int? goldAtDeath,
-    int? levelAtDeath,
-    int? timestamp,
-    List<CombatEvent>? lastCombatEvents,
-  }) {
-    return DeathInfo(
-      cause: cause ?? this.cause,
-      killerName: killerName ?? this.killerName,
-      lostEquipmentCount: lostEquipmentCount ?? this.lostEquipmentCount,
-      lostItemName: lostItemName ?? this.lostItemName,
-      lostItemSlot: lostItemSlot ?? this.lostItemSlot,
-      lostItemRarity: lostItemRarity ?? this.lostItemRarity,
-      lostItem: lostItem ?? this.lostItem,
-      goldAtDeath: goldAtDeath ?? this.goldAtDeath,
-      levelAtDeath: levelAtDeath ?? this.levelAtDeath,
-      timestamp: timestamp ?? this.timestamp,
-      lastCombatEvents: lastCombatEvents ?? this.lastCombatEvents,
-    );
-  }
-}
-
-/// 사망 원인
-enum DeathCause {
-  /// 몬스터에 의한 사망
-  monster,
-
-  /// 자해 스킬에 의한 사망
-  selfDamage,
-
-  /// 환경 피해에 의한 사망
-  environment,
-}
-
-/// 스킬 시스템 상태 (Phase 3)
-///
-/// 스킬 쿨타임, 활성 버프, 게임 경과 시간, 장착 스킬 등을 관리
-class SkillSystemState {
-  const SkillSystemState({
-    required this.skillStates,
-    required this.activeBuffs,
-    required this.elapsedMs,
-    this.equippedSkills = const SkillSlots(),
-    this.globalCooldownEndMs = 0,
-  });
-
-  /// 글로벌 쿨타임 (GCD) 상수: 1500ms
-  static const int globalCooldownDuration = 1500;
-
-  /// 스킬별 쿨타임 상태
-  final List<SkillState> skillStates;
-
-  /// 현재 활성화된 버프 목록
-  final List<ActiveBuff> activeBuffs;
-
-  /// 게임 진행 경과 시간 (밀리초, 스킬 쿨타임 계산용)
-  final int elapsedMs;
-
-  /// 장착된 스킬 슬롯 (타입별 제한 있음)
-  final SkillSlots equippedSkills;
-
-  /// 글로벌 쿨타임 종료 시점 (elapsedMs 기준)
-  final int globalCooldownEndMs;
-
-  /// GCD가 활성화 중인지 확인
-  bool get isGlobalCooldownActive => elapsedMs < globalCooldownEndMs;
-
-  /// 남은 GCD 시간 (ms)
-  int get remainingGlobalCooldown =>
-      isGlobalCooldownActive ? globalCooldownEndMs - elapsedMs : 0;
-
-  factory SkillSystemState.empty() => const SkillSystemState(
-    skillStates: [],
-    activeBuffs: [],
-    elapsedMs: 0,
-    equippedSkills: SkillSlots(),
-    globalCooldownEndMs: 0,
-  );
-
-  /// 특정 스킬 상태 가져오기
-  SkillState? getSkillState(String skillId) {
-    for (final state in skillStates) {
-      if (state.skillId == skillId) return state;
-    }
-    return null;
-  }
-
-  /// 버프 효과 합산 (동일 버프는 중복 적용 안 됨)
-  ({double atkMod, double defMod, double criMod, double evasionMod})
-  get totalBuffModifiers {
-    double atkMod = 0;
-    double defMod = 0;
-    double criMod = 0;
-    double evasionMod = 0;
-
-    final seenBuffIds = <String>{};
-    for (final buff in activeBuffs) {
-      if (seenBuffIds.contains(buff.effect.id)) continue;
-      seenBuffIds.add(buff.effect.id);
-
-      if (!buff.isExpired(elapsedMs)) {
-        atkMod += buff.effect.atkModifier;
-        defMod += buff.effect.defModifier;
-        criMod += buff.effect.criRateModifier;
-        evasionMod += buff.effect.evasionModifier;
-      }
-    }
-
-    return (
-      atkMod: atkMod,
-      defMod: defMod,
-      criMod: criMod,
-      evasionMod: evasionMod,
-    );
-  }
-
-  SkillSystemState copyWith({
-    List<SkillState>? skillStates,
-    List<ActiveBuff>? activeBuffs,
-    int? elapsedMs,
-    SkillSlots? equippedSkills,
-    int? globalCooldownEndMs,
-  }) {
-    return SkillSystemState(
-      skillStates: skillStates ?? this.skillStates,
-      activeBuffs: activeBuffs ?? this.activeBuffs,
-      elapsedMs: elapsedMs ?? this.elapsedMs,
-      equippedSkills: equippedSkills ?? this.equippedSkills,
-      globalCooldownEndMs: globalCooldownEndMs ?? this.globalCooldownEndMs,
-    );
-  }
-
-  /// GCD 시작 (스킬 사용 후 호출)
-  SkillSystemState startGlobalCooldown() {
-    return copyWith(globalCooldownEndMs: elapsedMs + globalCooldownDuration);
-  }
-}
-
-/// 태스크 타입 (원본 fTask.Caption 값들에 대응)
-enum TaskType {
-  neutral, // heading 등 일반 이동
-  kill, // 몬스터 처치
-  load, // 로딩/초기화
-  plot, // 플롯 진행
-  market, // 시장으로 이동 중
-  sell, // 아이템 판매 중
-  buying, // 장비 구매 중
-}
-
-class TaskInfo {
-  const TaskInfo({
-    required this.caption,
-    required this.type,
-    this.monsterBaseName,
-    this.monsterPart,
-    this.monsterLevel,
-    this.monsterGrade,
-    this.monsterSize,
-  });
-
-  final String caption;
-  final TaskType type;
-
-  /// 킬 태스크의 몬스터 기본 이름 (형용사 제외, 예: "Goblin")
-  final String? monsterBaseName;
-
-  /// 킬 태스크의 전리품 부위 (예: "claw", "tail", "*"는 WinItem)
-  final String? monsterPart;
-
-  /// 킬 태스크의 몬스터 레벨 (전투 스탯 계산용)
-  final int? monsterLevel;
-
-  /// 킬 태스크의 몬스터 등급 (Normal/Elite/Boss)
-  final MonsterGrade? monsterGrade;
-
-  /// 킬 태스크의 몬스터 사이즈 (애니메이션 크기 결정용, Act 기반)
-  final MonsterSize? monsterSize;
-
-  factory TaskInfo.empty() =>
-      const TaskInfo(caption: '', type: TaskType.neutral);
-
-  TaskInfo copyWith({
-    String? caption,
-    TaskType? type,
-    String? monsterBaseName,
-    String? monsterPart,
-    int? monsterLevel,
-    MonsterGrade? monsterGrade,
-    MonsterSize? monsterSize,
-  }) {
-    return TaskInfo(
-      caption: caption ?? this.caption,
-      type: type ?? this.type,
-      monsterBaseName: monsterBaseName ?? this.monsterBaseName,
-      monsterPart: monsterPart ?? this.monsterPart,
-      monsterLevel: monsterLevel ?? this.monsterLevel,
-      monsterGrade: monsterGrade ?? this.monsterGrade,
-      monsterSize: monsterSize ?? this.monsterSize,
-    );
-  }
-}
-
-class Traits {
-  const Traits({
-    required this.name,
-    required this.race,
-    required this.klass,
-    required this.level,
-    required this.motto,
-    required this.guild,
-    this.raceId = '',
-    this.classId = '',
-  });
-
-  final String name;
-
-  /// 종족 표시 이름 (예: "Kernel Giant")
-  final String race;
-
-  /// 클래스 표시 이름 (예: "Bug Hunter")
-  final String klass;
-
-  final int level;
-  final String motto;
-  final String guild;
-
-  /// 종족 ID (Phase 5, 예: "kernel_giant")
-  final String raceId;
-
-  /// 클래스 ID (Phase 5, 예: "bug_hunter")
-  final String classId;
-
-  factory Traits.empty() => const Traits(
-    name: '',
-    race: '',
-    klass: '',
-    level: 1,
-    motto: '',
-    guild: '',
-    raceId: '',
-    classId: '',
-  );
-
-  Traits copyWith({
-    String? name,
-    String? race,
-    String? klass,
-    int? level,
-    String? motto,
-    String? guild,
-    String? raceId,
-    String? classId,
-  }) {
-    return Traits(
-      name: name ?? this.name,
-      race: race ?? this.race,
-      klass: klass ?? this.klass,
-      level: level ?? this.level,
-      motto: motto ?? this.motto,
-      guild: guild ?? this.guild,
-      raceId: raceId ?? this.raceId,
-      classId: classId ?? this.classId,
-    );
-  }
-}
-
-class Stats {
-  const Stats({
-    required this.str,
-    required this.con,
-    required this.dex,
-    required this.intelligence,
-    required this.wis,
-    required this.cha,
-    required this.hpMax,
-    required this.mpMax,
-    this.hpCurrent,
-    this.mpCurrent,
-  });
-
-  final int str;
-  final int con;
-  final int dex;
-  final int intelligence;
-  final int wis;
-  final int cha;
-  final int hpMax;
-  final int mpMax;
-
-  /// 현재 HP (null이면 hpMax와 동일)
-  final int? hpCurrent;
-
-  /// 현재 MP (null이면 mpMax와 동일)
-  final int? mpCurrent;
-
-  /// 실제 현재 HP 값
-  int get hp => hpCurrent ?? hpMax;
-
-  /// 실제 현재 MP 값
-  int get mp => mpCurrent ?? mpMax;
-
-  factory Stats.empty() => const Stats(
-    str: 0,
-    con: 0,
-    dex: 0,
-    intelligence: 0,
-    wis: 0,
-    cha: 0,
-    hpMax: 0,
-    mpMax: 0,
-  );
-
-  Stats copyWith({
-    int? str,
-    int? con,
-    int? dex,
-    int? intelligence,
-    int? wis,
-    int? cha,
-    int? hpMax,
-    int? mpMax,
-    int? hpCurrent,
-    int? mpCurrent,
-  }) {
-    return Stats(
-      str: str ?? this.str,
-      con: con ?? this.con,
-      dex: dex ?? this.dex,
-      intelligence: intelligence ?? this.intelligence,
-      wis: wis ?? this.wis,
-      cha: cha ?? this.cha,
-      hpMax: hpMax ?? this.hpMax,
-      mpMax: mpMax ?? this.mpMax,
-      hpCurrent: hpCurrent ?? this.hpCurrent,
-      mpCurrent: mpCurrent ?? this.mpCurrent,
-    );
-  }
-}
-
-class InventoryEntry {
-  const InventoryEntry({required this.name, required this.count});
-
-  final String name;
-  final int count;
-
-  InventoryEntry copyWith({String? name, int? count}) {
-    return InventoryEntry(name: name ?? this.name, count: count ?? this.count);
-  }
-}
-
-class Inventory {
-  const Inventory({required this.gold, required this.items});
-
-  final int gold;
-  final List<InventoryEntry> items;
-
-  /// 초기 골드 1000 지급 (캐릭터 생성 시)
-  factory Inventory.empty() => const Inventory(gold: 1000, items: []);
-
-  Inventory copyWith({int? gold, List<InventoryEntry>? items}) {
-    return Inventory(gold: gold ?? this.gold, items: items ?? this.items);
-  }
-}
-
-/// 장비 (원본 Main.dfm Equips ListView, 11개 슬롯)
-///
-/// Phase 2에서 EquipmentItem 기반으로 확장됨.
-/// 기존 문자열 API(weapon, shield 등)는 호환성을 위해 유지.
-class Equipment {
-  Equipment({required this.items, required this.bestIndex})
-    : assert(items.length == slotCount, 'Equipment must have $slotCount items');
-
-  /// 장비 아이템 목록 (11개 슬롯)
-  final List<EquipmentItem> items;
-
-  /// 최고 아이템 슬롯 인덱스 (원본 Equips.Tag, 0-10)
-  final int bestIndex;
-
-  /// 슬롯 개수
-  static const slotCount = 11;
-
-  // ============================================================================
-  // 문자열 API (기존 코드 호환성)
-  // ============================================================================
-
-  String get weapon => items[0].name; // 0: 무기
-  String get shield => items[1].name; // 1: 방패
-  String get helm => items[2].name; // 2: 투구
-  String get hauberk => items[3].name; // 3: 사슬갑옷
-  String get brassairts => items[4].name; // 4: 상완갑
-  String get vambraces => items[5].name; // 5: 전완갑
-  String get gauntlets => items[6].name; // 6: 건틀릿
-  String get gambeson => items[7].name; // 7: 갬비슨
-  String get cuisses => items[8].name; // 8: 허벅지갑
-  String get greaves => items[9].name; // 9: 정강이갑
-  String get sollerets => items[10].name; // 10: 철제신발
-
-  // ============================================================================
-  // EquipmentItem API
-  // ============================================================================
-
-  EquipmentItem get weaponItem => items[0];
-  EquipmentItem get shieldItem => items[1];
-  EquipmentItem get helmItem => items[2];
-  EquipmentItem get hauberkItem => items[3];
-  EquipmentItem get brassairtsItem => items[4];
-  EquipmentItem get vambracesItem => items[5];
-  EquipmentItem get gauntletsItem => items[6];
-  EquipmentItem get gambesonItem => items[7];
-  EquipmentItem get cuissesItem => items[8];
-  EquipmentItem get greavesItem => items[9];
-  EquipmentItem get solleretsItem => items[10];
-
-  /// 모든 장비 스탯 합산
-  ItemStats get totalStats {
-    return items.fold(ItemStats.empty, (sum, item) => sum + item.stats);
-  }
-
-  /// 모든 장비 무게 합산
-  int get totalWeight {
-    return items.fold(0, (sum, item) => sum + item.weight);
-  }
-
-  /// 장착된 아이템 목록 (빈 슬롯 제외)
-  List<EquipmentItem> get equippedItems {
-    return items.where((item) => item.isNotEmpty).toList();
-  }
-
-  // ============================================================================
-  // 팩토리 메서드
-  // ============================================================================
-
-  factory Equipment.empty() {
-    return Equipment(
-      items: [
-        EquipmentItem.defaultWeapon(), // 0: 무기 (Keyboard)
-        EquipmentItem.empty(EquipmentSlot.shield), // 1: 방패
-        EquipmentItem.empty(EquipmentSlot.helm), // 2: 투구
-        EquipmentItem.empty(EquipmentSlot.hauberk), // 3: 사슬갑옷
-        EquipmentItem.empty(EquipmentSlot.brassairts), // 4: 상완갑
-        EquipmentItem.empty(EquipmentSlot.vambraces), // 5: 전완갑
-        EquipmentItem.empty(EquipmentSlot.gauntlets), // 6: 건틀릿
-        EquipmentItem.empty(EquipmentSlot.gambeson), // 7: 갬비슨
-        EquipmentItem.empty(EquipmentSlot.cuisses), // 8: 허벅지갑
-        EquipmentItem.empty(EquipmentSlot.greaves), // 9: 정강이갑
-        EquipmentItem.empty(EquipmentSlot.sollerets), // 10: 철제신발
-      ],
-      bestIndex: 0,
-    );
-  }
-
-  /// 초보자 장비 세트 (모든 슬롯에 기본 방어구 지급)
-  ///
-  /// 원본 PQ에서는 초기 장비가 없지만, 밸런스 개선을 위해
-  /// Act 1 완료 전에도 기본 방어력을 제공.
-  factory Equipment.withStarterGear() {
-    return Equipment(
-      items: [
-        EquipmentItem.defaultWeapon(), // 0: 무기 (Keyboard)
-        _starterArmor('Old Mouse', EquipmentSlot.shield, def: 2),
-        _starterArmor('Cardboard Box', EquipmentSlot.helm, def: 1),
-        _starterArmor('Worn T-Shirt', EquipmentSlot.hauberk, def: 3),
-        _starterArmor('Rubber Band', EquipmentSlot.brassairts, def: 1),
-        _starterArmor('Wristwatch', EquipmentSlot.vambraces, def: 1),
-        _starterArmor('Fingerless Gloves', EquipmentSlot.gauntlets, def: 1),
-        _starterArmor('Hoodie', EquipmentSlot.gambeson, def: 2),
-        _starterArmor('Jeans', EquipmentSlot.cuisses, def: 2),
-        _starterArmor('Knee Pads', EquipmentSlot.greaves, def: 1),
-        _starterArmor('Sneakers', EquipmentSlot.sollerets, def: 1),
-      ],
-      bestIndex: 0,
-    );
-  }
-
-  /// 초보자 방어구 생성 헬퍼
-  static EquipmentItem _starterArmor(
-    String name,
-    EquipmentSlot slot, {
-    required int def,
-  }) {
-    return EquipmentItem(
-      name: name,
-      slot: slot,
-      level: 1,
-      weight: 1,
-      stats: ItemStats(def: def),
-      rarity: ItemRarity.common,
-    );
-  }
-
-  /// 레거시 문자열 기반 생성자 (세이브 파일 호환용)
-  factory Equipment.fromStrings({
-    required String weapon,
-    required String shield,
-    required String helm,
-    required String hauberk,
-    required String brassairts,
-    required String vambraces,
-    required String gauntlets,
-    required String gambeson,
-    required String cuisses,
-    required String greaves,
-    required String sollerets,
-    required int bestIndex,
-  }) {
-    return Equipment(
-      items: [
-        _itemFromString(weapon, EquipmentSlot.weapon),
-        _itemFromString(shield, EquipmentSlot.shield),
-        _itemFromString(helm, EquipmentSlot.helm),
-        _itemFromString(hauberk, EquipmentSlot.hauberk),
-        _itemFromString(brassairts, EquipmentSlot.brassairts),
-        _itemFromString(vambraces, EquipmentSlot.vambraces),
-        _itemFromString(gauntlets, EquipmentSlot.gauntlets),
-        _itemFromString(gambeson, EquipmentSlot.gambeson),
-        _itemFromString(cuisses, EquipmentSlot.cuisses),
-        _itemFromString(greaves, EquipmentSlot.greaves),
-        _itemFromString(sollerets, EquipmentSlot.sollerets),
-      ],
-      bestIndex: bestIndex,
-    );
-  }
-
-  /// 문자열에서 기본 EquipmentItem 생성 (레거시 호환)
-  static EquipmentItem _itemFromString(String name, EquipmentSlot slot) {
-    if (name.isEmpty) {
-      return EquipmentItem.empty(slot);
-    }
-    // 레거시 아이템: 레벨 1, Common, 기본 스탯
-    return EquipmentItem(
-      name: name,
-      slot: slot,
-      level: 1,
-      weight: 5,
-      stats: ItemStats.empty,
-      rarity: ItemRarity.common,
-    );
-  }
-
-  // ============================================================================
-  // 유틸리티 메서드
-  // ============================================================================
-
-  /// 인덱스로 슬롯 이름 가져오기 (기존 API 호환)
-  String getByIndex(int index) {
-    if (index < 0 || index >= slotCount) return '';
-    return items[index].name;
-  }
-
-  /// 인덱스로 EquipmentItem 가져오기
-  EquipmentItem getItemByIndex(int index) {
-    if (index < 0 || index >= slotCount) {
-      return EquipmentItem.empty(EquipmentSlot.weapon);
-    }
-    return items[index];
-  }
-
-  /// 인덱스로 슬롯 값 설정 (문자열, 기존 API 호환)
-  Equipment setByIndex(int index, String value) {
-    if (index < 0 || index >= slotCount) return this;
-    final slot = EquipmentSlot.values[index];
-    final newItem = _itemFromString(value, slot);
-    return setItemByIndex(index, newItem);
-  }
-
-  /// 인덱스로 EquipmentItem 설정
-  Equipment setItemByIndex(int index, EquipmentItem item) {
-    if (index < 0 || index >= slotCount) return this;
-    final newItems = List<EquipmentItem>.from(items);
-    newItems[index] = item;
-    return Equipment(items: newItems, bestIndex: bestIndex);
-  }
-
-  Equipment copyWith({List<EquipmentItem>? items, int? bestIndex}) {
-    return Equipment(
-      items: items ?? List<EquipmentItem>.from(this.items),
-      bestIndex: bestIndex ?? this.bestIndex,
-    );
-  }
-}
-
-class SkillEntry {
-  const SkillEntry({required this.name, required this.rank});
-
-  final String name;
-  final String rank; // e.g., Roman numerals
-
-  SkillEntry copyWith({String? name, String? rank}) {
-    return SkillEntry(name: name ?? this.name, rank: rank ?? this.rank);
-  }
-}
-
-class SkillBook {
-  const SkillBook({required this.skills});
-
-  final List<SkillEntry> skills;
-
-  factory SkillBook.empty() => const SkillBook(skills: []);
-
-  SkillBook copyWith({List<SkillEntry>? skills}) {
-    return SkillBook(skills: skills ?? this.skills);
-  }
-}
-
-class ProgressBarState {
-  const ProgressBarState({required this.position, required this.max});
-
-  final int position;
-  final int max;
-
-  factory ProgressBarState.empty() =>
-      const ProgressBarState(position: 0, max: 1);
-
-  ProgressBarState copyWith({int? position, int? max}) {
-    return ProgressBarState(
-      position: position ?? this.position,
-      max: max ?? this.max,
-    );
-  }
-}
-
-/// 히스토리 엔트리 (Plot/Quest 진행 기록)
-class HistoryEntry {
-  const HistoryEntry({required this.caption, required this.isComplete});
-
-  /// 표시 텍스트 (예: "Prologue", "Act I", "Exterminate the Goblins")
-  final String caption;
-
-  /// 완료 여부 (원본 StateIndex: 0=진행중, 1=완료)
-  final bool isComplete;
-
-  HistoryEntry copyWith({String? caption, bool? isComplete}) {
-    return HistoryEntry(
-      caption: caption ?? this.caption,
-      isComplete: isComplete ?? this.isComplete,
-    );
-  }
-}
-
-/// 현재 퀘스트 몬스터 정보 (원본 fQuest)
-class QuestMonsterInfo {
-  const QuestMonsterInfo({
-    required this.monsterData,
-    required this.monsterIndex,
-  });
-
-  /// 몬스터 데이터 문자열 (예: "Goblin|3|ear")
-  final String monsterData;
-
-  /// 몬스터 인덱스 (Config.monsters에서의 인덱스)
-  final int monsterIndex;
-
-  static const empty = QuestMonsterInfo(monsterData: '', monsterIndex: -1);
-}
-
-/// 최종 보스 상태 (Final Boss State)
-enum FinalBossState {
-  /// 최종 보스 등장 전
-  notSpawned,
-
-  /// 최종 보스 전투 중
-  fighting,
-
-  /// 최종 보스 처치 완료
-  defeated,
-}
-
-class ProgressState {
-  const ProgressState({
-    required this.task,
-    required this.quest,
-    required this.plot,
-    required this.exp,
-    required this.encumbrance,
-    required this.currentTask,
-    required this.plotStageCount,
-    required this.questCount,
-    this.plotHistory = const [],
-    this.questHistory = const [],
-    this.currentQuestMonster,
-    this.currentCombat,
-    this.monstersKilled = 0,
-    this.deathCount = 0,
-    this.finalBossState = FinalBossState.notSpawned,
-    this.pendingActCompletion = false,
-    this.bossLevelingEndTime,
-  });
-
-  final ProgressBarState task;
-  final ProgressBarState quest;
-  final ProgressBarState plot;
-  final ProgressBarState exp;
-  final ProgressBarState encumbrance;
-  final TaskInfo currentTask;
-  final int plotStageCount;
-  final int questCount;
-
-  /// 플롯 히스토리 (Prologue, Act I, Act II, ...)
-  final List<HistoryEntry> plotHistory;
-
-  /// 퀘스트 히스토리 (완료된/진행중인 퀘스트 목록)
-  final List<HistoryEntry> questHistory;
-
-  /// 현재 퀘스트 몬스터 정보 (Exterminate 타입용)
-  final QuestMonsterInfo? currentQuestMonster;
-
-  /// 현재 전투 상태 (킬 태스크 진행 중)
-  final CombatState? currentCombat;
-
-  /// 처치한 몬스터 수
-  final int monstersKilled;
-
-  /// 사망 횟수
-  final int deathCount;
-
-  /// 최종 보스 상태 (Act V)
-  final FinalBossState finalBossState;
-
-  /// Act Boss 처치 대기 중 여부 (처치 후 시네마틱 재생 트리거)
-  final bool pendingActCompletion;
-
-  /// 보스 사망 후 레벨링 모드 종료 시간 (milliseconds since epoch)
-  /// null이면 레벨링 모드 아님, 값이 있으면 해당 시간까지 레벨링
-  final int? bossLevelingEndTime;
-
-  factory ProgressState.empty() => ProgressState(
-    task: ProgressBarState.empty(),
-    quest: ProgressBarState.empty(),
-    plot: ProgressBarState.empty(),
-    exp: ProgressBarState.empty(),
-    encumbrance: ProgressBarState.empty(),
-    currentTask: TaskInfo.empty(),
-    plotStageCount: 1, // Prologue
-    questCount: 0,
-    plotHistory: const [HistoryEntry(caption: 'Prologue', isComplete: false)],
-    questHistory: const [],
-    currentQuestMonster: null,
-    currentCombat: null,
-  );
-
-  ProgressState copyWith({
-    ProgressBarState? task,
-    ProgressBarState? quest,
-    ProgressBarState? plot,
-    ProgressBarState? exp,
-    ProgressBarState? encumbrance,
-    TaskInfo? currentTask,
-    int? plotStageCount,
-    int? questCount,
-    List<HistoryEntry>? plotHistory,
-    List<HistoryEntry>? questHistory,
-    QuestMonsterInfo? currentQuestMonster,
-    CombatState? currentCombat,
-    int? monstersKilled,
-    int? deathCount,
-    FinalBossState? finalBossState,
-    bool? pendingActCompletion,
-    int? bossLevelingEndTime,
-    bool clearBossLevelingEndTime = false,
-  }) {
-    return ProgressState(
-      task: task ?? this.task,
-      quest: quest ?? this.quest,
-      plot: plot ?? this.plot,
-      exp: exp ?? this.exp,
-      encumbrance: encumbrance ?? this.encumbrance,
-      currentTask: currentTask ?? this.currentTask,
-      plotStageCount: plotStageCount ?? this.plotStageCount,
-      questCount: questCount ?? this.questCount,
-      plotHistory: plotHistory ?? this.plotHistory,
-      questHistory: questHistory ?? this.questHistory,
-      currentQuestMonster: currentQuestMonster ?? this.currentQuestMonster,
-      currentCombat: currentCombat ?? this.currentCombat,
-      monstersKilled: monstersKilled ?? this.monstersKilled,
-      deathCount: deathCount ?? this.deathCount,
-      finalBossState: finalBossState ?? this.finalBossState,
-      pendingActCompletion: pendingActCompletion ?? this.pendingActCompletion,
-      bossLevelingEndTime: clearBossLevelingEndTime
-          ? null
-          : (bossLevelingEndTime ?? this.bossLevelingEndTime),
-    );
-  }
-
-  /// 현재 레벨링 모드인지 확인
-  bool get isInBossLevelingMode {
-    if (bossLevelingEndTime == null) return false;
-    return DateTime.now().millisecondsSinceEpoch < bossLevelingEndTime!;
-  }
-}
-
-class QueueEntry {
-  const QueueEntry({
-    required this.kind,
-    required this.durationMillis,
-    required this.caption,
-    this.taskType = TaskType.neutral,
-  });
-
-  final QueueKind kind;
-  final int durationMillis;
-  final String caption;
-  final TaskType taskType;
-}
-
-enum QueueKind { task, plot }
-
-class QueueState {
-  QueueState({Iterable<QueueEntry>? entries})
-    : entries = Queue<QueueEntry>.from(entries ?? const []);
-
-  final Queue<QueueEntry> entries;
-
-  factory QueueState.empty() => QueueState(entries: const []);
-
-  QueueState copyWith({Iterable<QueueEntry>? entries}) {
-    return QueueState(entries: Queue<QueueEntry>.from(entries ?? this.entries));
-  }
-}

lib/src/core/model/game_statistics.dart

@@ -1,6 +1,14 @@
+import 'package:asciineverdie/src/core/model/cumulative_statistics.dart';
+import 'package:asciineverdie/src/core/model/session_statistics.dart';
+
+// 하위 호환성(backward compatibility)을 위한 re-export
+export 'package:asciineverdie/src/core/model/cumulative_statistics.dart';
+export 'package:asciineverdie/src/core/model/session_statistics.dart';
+
 /// 게임 통계 (Game Statistics)
 ///
-/// 세션 및 누적 통계를 추적하는 모델
+/// 세션 및 누적 통계를 추적하는 모델.
+/// 세부 구현은 SessionStatistics와 CumulativeStatistics로 분리됨.
 class GameStatistics {
   const GameStatistics({required this.session, required this.cumulative});
 
@@ -59,558 +67,3 @@ class GameStatistics {
     );
   }
 }
-
-/// 세션 통계 (Session Statistics)
-///
-/// 현재 게임 세션의 통계
-class SessionStatistics {
-  const SessionStatistics({
-    required this.playTimeMs,
-    required this.monstersKilled,
-    required this.goldEarned,
-    required this.goldSpent,
-    required this.skillsUsed,
-    required this.criticalHits,
-    required this.maxCriticalStreak,
-    required this.currentCriticalStreak,
-    required this.totalDamageDealt,
-    required this.totalDamageTaken,
-    required this.potionsUsed,
-    required this.itemsSold,
-    required this.questsCompleted,
-    required this.deathCount,
-    required this.bossesDefeated,
-    required this.levelUps,
-  });
-
-  /// 플레이 시간 (밀리초)
-  final int playTimeMs;
-
-  /// 처치한 몬스터 수
-  final int monstersKilled;
-
-  /// 획득한 골드 총량
-  final int goldEarned;
-
-  /// 소비한 골드 총량
-  final int goldSpent;
-
-  /// 사용한 스킬 횟수
-  final int skillsUsed;
-
-  /// 크리티컬 히트 횟수
-  final int criticalHits;
-
-  /// 최대 연속 크리티컬
-  final int maxCriticalStreak;
-
-  /// 현재 연속 크리티컬 (내부 추적용)
-  final int currentCriticalStreak;
-
-  /// 총 입힌 데미지
-  final int totalDamageDealt;
-
-  /// 총 받은 데미지
-  final int totalDamageTaken;
-
-  /// 사용한 물약 수
-  final int potionsUsed;
-
-  /// 판매한 아이템 수
-  final int itemsSold;
-
-  /// 완료한 퀘스트 수
-  final int questsCompleted;
-
-  /// 사망 횟수
-  final int deathCount;
-
-  /// 처치한 보스 수
-  final int bossesDefeated;
-
-  /// 레벨업 횟수
-  final int levelUps;
-
-  /// 플레이 시간 Duration
-  Duration get playTime => Duration(milliseconds: playTimeMs);
-
-  /// 플레이 시간 포맷 (HH:MM:SS)
-  String get formattedPlayTime {
-    final hours = playTime.inHours;
-    final minutes = playTime.inMinutes % 60;
-    final seconds = playTime.inSeconds % 60;
-    return '${hours.toString().padLeft(2, '0')}:'
-        '${minutes.toString().padLeft(2, '0')}:'
-        '${seconds.toString().padLeft(2, '0')}';
-  }
-
-  /// 평균 DPS (damage per second)
-  double get averageDps {
-    if (playTimeMs <= 0) return 0;
-    return totalDamageDealt / (playTimeMs / 1000);
-  }
-
-  /// 킬당 평균 골드
-  double get goldPerKill {
-    if (monstersKilled <= 0) return 0;
-    return goldEarned / monstersKilled;
-  }
-
-  /// 크리티컬 비율
-  double get criticalRate {
-    if (skillsUsed <= 0) return 0;
-    return criticalHits / skillsUsed;
-  }
-
-  /// 빈 세션 통계
-  factory SessionStatistics.empty() => const SessionStatistics(
-    playTimeMs: 0,
-    monstersKilled: 0,
-    goldEarned: 0,
-    goldSpent: 0,
-    skillsUsed: 0,
-    criticalHits: 0,
-    maxCriticalStreak: 0,
-    currentCriticalStreak: 0,
-    totalDamageDealt: 0,
-    totalDamageTaken: 0,
-    potionsUsed: 0,
-    itemsSold: 0,
-    questsCompleted: 0,
-    deathCount: 0,
-    bossesDefeated: 0,
-    levelUps: 0,
-  );
-
-  // ============================================================================
-  // 이벤트 기록 메서드
-  // ============================================================================
-
-  /// 몬스터 처치 기록
-  SessionStatistics recordKill({bool isBoss = false}) {
-    return copyWith(
-      monstersKilled: monstersKilled + 1,
-      bossesDefeated: isBoss ? bossesDefeated + 1 : bossesDefeated,
-    );
-  }
-
-  /// 골드 획득 기록
-  SessionStatistics recordGoldEarned(int amount) {
-    return copyWith(goldEarned: goldEarned + amount);
-  }
-
-  /// 골드 소비 기록
-  SessionStatistics recordGoldSpent(int amount) {
-    return copyWith(goldSpent: goldSpent + amount);
-  }
-
-  /// 스킬 사용 기록
-  SessionStatistics recordSkillUse({required bool isCritical}) {
-    final newCriticalStreak = isCritical ? currentCriticalStreak + 1 : 0;
-    final newMaxStreak = newCriticalStreak > maxCriticalStreak
-        ? newCriticalStreak
-        : maxCriticalStreak;
-
-    return copyWith(
-      skillsUsed: skillsUsed + 1,
-      criticalHits: isCritical ? criticalHits + 1 : criticalHits,
-      currentCriticalStreak: newCriticalStreak,
-      maxCriticalStreak: newMaxStreak,
-    );
-  }
-
-  /// 데미지 기록
-  SessionStatistics recordDamage({int dealt = 0, int taken = 0}) {
-    return copyWith(
-      totalDamageDealt: totalDamageDealt + dealt,
-      totalDamageTaken: totalDamageTaken + taken,
-    );
-  }
-
-  /// 물약 사용 기록
-  SessionStatistics recordPotionUse() {
-    return copyWith(potionsUsed: potionsUsed + 1);
-  }
-
-  /// 아이템 판매 기록
-  SessionStatistics recordItemSold(int count) {
-    return copyWith(itemsSold: itemsSold + count);
-  }
-
-  /// 퀘스트 완료 기록
-  SessionStatistics recordQuestComplete() {
-    return copyWith(questsCompleted: questsCompleted + 1);
-  }
-
-  /// 사망 기록
-  SessionStatistics recordDeath() {
-    return copyWith(deathCount: deathCount + 1);
-  }
-
-  /// 레벨업 기록
-  SessionStatistics recordLevelUp() {
-    return copyWith(levelUps: levelUps + 1);
-  }
-
-  /// 플레이 시간 업데이트
-  SessionStatistics updatePlayTime(int elapsedMs) {
-    return copyWith(playTimeMs: elapsedMs);
-  }
-
-  SessionStatistics copyWith({
-    int? playTimeMs,
-    int? monstersKilled,
-    int? goldEarned,
-    int? goldSpent,
-    int? skillsUsed,
-    int? criticalHits,
-    int? maxCriticalStreak,
-    int? currentCriticalStreak,
-    int? totalDamageDealt,
-    int? totalDamageTaken,
-    int? potionsUsed,
-    int? itemsSold,
-    int? questsCompleted,
-    int? deathCount,
-    int? bossesDefeated,
-    int? levelUps,
-  }) {
-    return SessionStatistics(
-      playTimeMs: playTimeMs ?? this.playTimeMs,
-      monstersKilled: monstersKilled ?? this.monstersKilled,
-      goldEarned: goldEarned ?? this.goldEarned,
-      goldSpent: goldSpent ?? this.goldSpent,
-      skillsUsed: skillsUsed ?? this.skillsUsed,
-      criticalHits: criticalHits ?? this.criticalHits,
-      maxCriticalStreak: maxCriticalStreak ?? this.maxCriticalStreak,
-      currentCriticalStreak:
-          currentCriticalStreak ?? this.currentCriticalStreak,
-      totalDamageDealt: totalDamageDealt ?? this.totalDamageDealt,
-      totalDamageTaken: totalDamageTaken ?? this.totalDamageTaken,
-      potionsUsed: potionsUsed ?? this.potionsUsed,
-      itemsSold: itemsSold ?? this.itemsSold,
-      questsCompleted: questsCompleted ?? this.questsCompleted,
-      deathCount: deathCount ?? this.deathCount,
-      bossesDefeated: bossesDefeated ?? this.bossesDefeated,
-      levelUps: levelUps ?? this.levelUps,
-    );
-  }
-
-  /// JSON 직렬화
-  Map<String, dynamic> toJson() {
-    return {
-      'playTimeMs': playTimeMs,
-      'monstersKilled': monstersKilled,
-      'goldEarned': goldEarned,
-      'goldSpent': goldSpent,
-      'skillsUsed': skillsUsed,
-      'criticalHits': criticalHits,
-      'maxCriticalStreak': maxCriticalStreak,
-      'totalDamageDealt': totalDamageDealt,
-      'totalDamageTaken': totalDamageTaken,
-      'potionsUsed': potionsUsed,
-      'itemsSold': itemsSold,
-      'questsCompleted': questsCompleted,
-      'deathCount': deathCount,
-      'bossesDefeated': bossesDefeated,
-      'levelUps': levelUps,
-    };
-  }
-
-  /// JSON 역직렬화
-  factory SessionStatistics.fromJson(Map<String, dynamic> json) {
-    return SessionStatistics(
-      playTimeMs: json['playTimeMs'] as int? ?? 0,
-      monstersKilled: json['monstersKilled'] as int? ?? 0,
-      goldEarned: json['goldEarned'] as int? ?? 0,
-      goldSpent: json['goldSpent'] as int? ?? 0,
-      skillsUsed: json['skillsUsed'] as int? ?? 0,
-      criticalHits: json['criticalHits'] as int? ?? 0,
-      maxCriticalStreak: json['maxCriticalStreak'] as int? ?? 0,
-      currentCriticalStreak: 0, // 세션간 유지 안 함
-      totalDamageDealt: json['totalDamageDealt'] as int? ?? 0,
-      totalDamageTaken: json['totalDamageTaken'] as int? ?? 0,
-      potionsUsed: json['potionsUsed'] as int? ?? 0,
-      itemsSold: json['itemsSold'] as int? ?? 0,
-      questsCompleted: json['questsCompleted'] as int? ?? 0,
-      deathCount: json['deathCount'] as int? ?? 0,
-      bossesDefeated: json['bossesDefeated'] as int? ?? 0,
-      levelUps: json['levelUps'] as int? ?? 0,
-    );
-  }
-}
-
-/// 누적 통계 (Cumulative Statistics)
-///
-/// 모든 게임 세션의 누적 통계
-class CumulativeStatistics {
-  const CumulativeStatistics({
-    required this.totalPlayTimeMs,
-    required this.totalMonstersKilled,
-    required this.totalGoldEarned,
-    required this.totalGoldSpent,
-    required this.totalSkillsUsed,
-    required this.totalCriticalHits,
-    required this.bestCriticalStreak,
-    required this.totalDamageDealt,
-    required this.totalDamageTaken,
-    required this.totalPotionsUsed,
-    required this.totalItemsSold,
-    required this.totalQuestsCompleted,
-    required this.totalDeaths,
-    required this.totalBossesDefeated,
-    required this.totalLevelUps,
-    required this.highestLevel,
-    required this.highestGoldHeld,
-    required this.gamesCompleted,
-    required this.gamesStarted,
-  });
-
-  /// 총 플레이 시간 (밀리초)
-  final int totalPlayTimeMs;
-
-  /// 총 처치한 몬스터 수
-  final int totalMonstersKilled;
-
-  /// 총 획득한 골드
-  final int totalGoldEarned;
-
-  /// 총 소비한 골드
-  final int totalGoldSpent;
-
-  /// 총 스킬 사용 횟수
-  final int totalSkillsUsed;
-
-  /// 총 크리티컬 히트 횟수
-  final int totalCriticalHits;
-
-  /// 최고 연속 크리티컬
-  final int bestCriticalStreak;
-
-  /// 총 입힌 데미지
-  final int totalDamageDealt;
-
-  /// 총 받은 데미지
-  final int totalDamageTaken;
-
-  /// 총 사용한 물약 수
-  final int totalPotionsUsed;
-
-  /// 총 판매한 아이템 수
-  final int totalItemsSold;
-
-  /// 총 완료한 퀘스트 수
-  final int totalQuestsCompleted;
-
-  /// 총 사망 횟수
-  final int totalDeaths;
-
-  /// 총 처치한 보스 수
-  final int totalBossesDefeated;
-
-  /// 총 레벨업 횟수
-  final int totalLevelUps;
-
-  /// 최고 달성 레벨
-  final int highestLevel;
-
-  /// 최대 보유 골드
-  final int highestGoldHeld;
-
-  /// 클리어한 게임 수
-  final int gamesCompleted;
-
-  /// 시작한 게임 수
-  final int gamesStarted;
-
-  /// 총 플레이 시간 Duration
-  Duration get totalPlayTime => Duration(milliseconds: totalPlayTimeMs);
-
-  /// 총 플레이 시간 포맷 (HH:MM:SS)
-  String get formattedTotalPlayTime {
-    final hours = totalPlayTime.inHours;
-    final minutes = totalPlayTime.inMinutes % 60;
-    final seconds = totalPlayTime.inSeconds % 60;
-    return '${hours.toString().padLeft(2, '0')}:'
-        '${minutes.toString().padLeft(2, '0')}:'
-        '${seconds.toString().padLeft(2, '0')}';
-  }
-
-  /// 평균 게임당 플레이 시간
-  Duration get averagePlayTimePerGame {
-    if (gamesStarted <= 0) return Duration.zero;
-    return Duration(milliseconds: totalPlayTimeMs ~/ gamesStarted);
-  }
-
-  /// 게임 완료율
-  double get completionRate {
-    if (gamesStarted <= 0) return 0;
-    return gamesCompleted / gamesStarted;
-  }
-
-  /// 빈 누적 통계
-  factory CumulativeStatistics.empty() => const CumulativeStatistics(
-    totalPlayTimeMs: 0,
-    totalMonstersKilled: 0,
-    totalGoldEarned: 0,
-    totalGoldSpent: 0,
-    totalSkillsUsed: 0,
-    totalCriticalHits: 0,
-    bestCriticalStreak: 0,
-    totalDamageDealt: 0,
-    totalDamageTaken: 0,
-    totalPotionsUsed: 0,
-    totalItemsSold: 0,
-    totalQuestsCompleted: 0,
-    totalDeaths: 0,
-    totalBossesDefeated: 0,
-    totalLevelUps: 0,
-    highestLevel: 0,
-    highestGoldHeld: 0,
-    gamesCompleted: 0,
-    gamesStarted: 0,
-  );
-
-  /// 세션 통계 병합
-  CumulativeStatistics mergeSession(SessionStatistics session) {
-    return CumulativeStatistics(
-      totalPlayTimeMs: totalPlayTimeMs + session.playTimeMs,
-      totalMonstersKilled: totalMonstersKilled + session.monstersKilled,
-      totalGoldEarned: totalGoldEarned + session.goldEarned,
-      totalGoldSpent: totalGoldSpent + session.goldSpent,
-      totalSkillsUsed: totalSkillsUsed + session.skillsUsed,
-      totalCriticalHits: totalCriticalHits + session.criticalHits,
-      bestCriticalStreak: session.maxCriticalStreak > bestCriticalStreak
-          ? session.maxCriticalStreak
-          : bestCriticalStreak,
-      totalDamageDealt: totalDamageDealt + session.totalDamageDealt,
-      totalDamageTaken: totalDamageTaken + session.totalDamageTaken,
-      totalPotionsUsed: totalPotionsUsed + session.potionsUsed,
-      totalItemsSold: totalItemsSold + session.itemsSold,
-      totalQuestsCompleted: totalQuestsCompleted + session.questsCompleted,
-      totalDeaths: totalDeaths + session.deathCount,
-      totalBossesDefeated: totalBossesDefeated + session.bossesDefeated,
-      totalLevelUps: totalLevelUps + session.levelUps,
-      highestLevel: highestLevel, // 별도 업데이트 필요
-      highestGoldHeld: highestGoldHeld, // 별도 업데이트 필요
-      gamesCompleted: gamesCompleted, // 별도 업데이트 필요
-      gamesStarted: gamesStarted, // 별도 업데이트 필요
-    );
-  }
-
-  /// 최고 레벨 업데이트
-  CumulativeStatistics updateHighestLevel(int level) {
-    if (level <= highestLevel) return this;
-    return copyWith(highestLevel: level);
-  }
-
-  /// 최대 골드 업데이트
-  CumulativeStatistics updateHighestGold(int gold) {
-    if (gold <= highestGoldHeld) return this;
-    return copyWith(highestGoldHeld: gold);
-  }
-
-  /// 새 게임 시작 기록
-  CumulativeStatistics recordGameStart() {
-    return copyWith(gamesStarted: gamesStarted + 1);
-  }
-
-  /// 게임 클리어 기록
-  CumulativeStatistics recordGameComplete() {
-    return copyWith(gamesCompleted: gamesCompleted + 1);
-  }
-
-  CumulativeStatistics copyWith({
-    int? totalPlayTimeMs,
-    int? totalMonstersKilled,
-    int? totalGoldEarned,
-    int? totalGoldSpent,
-    int? totalSkillsUsed,
-    int? totalCriticalHits,
-    int? bestCriticalStreak,
-    int? totalDamageDealt,
-    int? totalDamageTaken,
-    int? totalPotionsUsed,
-    int? totalItemsSold,
-    int? totalQuestsCompleted,
-    int? totalDeaths,
-    int? totalBossesDefeated,
-    int? totalLevelUps,
-    int? highestLevel,
-    int? highestGoldHeld,
-    int? gamesCompleted,
-    int? gamesStarted,
-  }) {
-    return CumulativeStatistics(
-      totalPlayTimeMs: totalPlayTimeMs ?? this.totalPlayTimeMs,
-      totalMonstersKilled: totalMonstersKilled ?? this.totalMonstersKilled,
-      totalGoldEarned: totalGoldEarned ?? this.totalGoldEarned,
-      totalGoldSpent: totalGoldSpent ?? this.totalGoldSpent,
-      totalSkillsUsed: totalSkillsUsed ?? this.totalSkillsUsed,
-      totalCriticalHits: totalCriticalHits ?? this.totalCriticalHits,
-      bestCriticalStreak: bestCriticalStreak ?? this.bestCriticalStreak,
-      totalDamageDealt: totalDamageDealt ?? this.totalDamageDealt,
-      totalDamageTaken: totalDamageTaken ?? this.totalDamageTaken,
-      totalPotionsUsed: totalPotionsUsed ?? this.totalPotionsUsed,
-      totalItemsSold: totalItemsSold ?? this.totalItemsSold,
-      totalQuestsCompleted: totalQuestsCompleted ?? this.totalQuestsCompleted,
-      totalDeaths: totalDeaths ?? this.totalDeaths,
-      totalBossesDefeated: totalBossesDefeated ?? this.totalBossesDefeated,
-      totalLevelUps: totalLevelUps ?? this.totalLevelUps,
-      highestLevel: highestLevel ?? this.highestLevel,
-      highestGoldHeld: highestGoldHeld ?? this.highestGoldHeld,
-      gamesCompleted: gamesCompleted ?? this.gamesCompleted,
-      gamesStarted: gamesStarted ?? this.gamesStarted,
-    );
-  }
-
-  /// JSON 직렬화
-  Map<String, dynamic> toJson() {
-    return {
-      'totalPlayTimeMs': totalPlayTimeMs,
-      'totalMonstersKilled': totalMonstersKilled,
-      'totalGoldEarned': totalGoldEarned,
-      'totalGoldSpent': totalGoldSpent,
-      'totalSkillsUsed': totalSkillsUsed,
-      'totalCriticalHits': totalCriticalHits,
-      'bestCriticalStreak': bestCriticalStreak,
-      'totalDamageDealt': totalDamageDealt,
-      'totalDamageTaken': totalDamageTaken,
-      'totalPotionsUsed': totalPotionsUsed,
-      'totalItemsSold': totalItemsSold,
-      'totalQuestsCompleted': totalQuestsCompleted,
-      'totalDeaths': totalDeaths,
-      'totalBossesDefeated': totalBossesDefeated,
-      'totalLevelUps': totalLevelUps,
-      'highestLevel': highestLevel,
-      'highestGoldHeld': highestGoldHeld,
-      'gamesCompleted': gamesCompleted,
-      'gamesStarted': gamesStarted,
-    };
-  }
-
-  /// JSON 역직렬화
-  factory CumulativeStatistics.fromJson(Map<String, dynamic> json) {
-    return CumulativeStatistics(
-      totalPlayTimeMs: json['totalPlayTimeMs'] as int? ?? 0,
-      totalMonstersKilled: json['totalMonstersKilled'] as int? ?? 0,
-      totalGoldEarned: json['totalGoldEarned'] as int? ?? 0,
-      totalGoldSpent: json['totalGoldSpent'] as int? ?? 0,
-      totalSkillsUsed: json['totalSkillsUsed'] as int? ?? 0,
-      totalCriticalHits: json['totalCriticalHits'] as int? ?? 0,
-      bestCriticalStreak: json['bestCriticalStreak'] as int? ?? 0,
-      totalDamageDealt: json['totalDamageDealt'] as int? ?? 0,
-      totalDamageTaken: json['totalDamageTaken'] as int? ?? 0,
-      totalPotionsUsed: json['totalPotionsUsed'] as int? ?? 0,
-      totalItemsSold: json['totalItemsSold'] as int? ?? 0,
-      totalQuestsCompleted: json['totalQuestsCompleted'] as int? ?? 0,
-      totalDeaths: json['totalDeaths'] as int? ?? 0,
-      totalBossesDefeated: json['totalBossesDefeated'] as int? ?? 0,
-      totalLevelUps: json['totalLevelUps'] as int? ?? 0,
-      highestLevel: json['highestLevel'] as int? ?? 0,
-      highestGoldHeld: json['highestGoldHeld'] as int? ?? 0,
-      gamesCompleted: json['gamesCompleted'] as int? ?? 0,
-      gamesStarted: json['gamesStarted'] as int? ?? 0,
-    );
-  }
-}

lib/src/core/model/inventory.dart

@@ -0,0 +1,28 @@
+/// 인벤토리 아이템 엔트리 (Inventory Entry)
+class InventoryEntry {
+  const InventoryEntry({required this.name, required this.count});
+
+  final String name;
+  final int count;
+
+  InventoryEntry copyWith({String? name, int? count}) {
+    return InventoryEntry(name: name ?? this.name, count: count ?? this.count);
+  }
+}
+
+/// 인벤토리 (Inventory)
+///
+/// 골드와 아이템 목록을 관리
+class Inventory {
+  const Inventory({required this.gold, required this.items});
+
+  final int gold;
+  final List<InventoryEntry> items;
+
+  /// 초기 골드 1000 지급 (캐릭터 생성 시)
+  factory Inventory.empty() => const Inventory(gold: 1000, items: []);
+
+  Inventory copyWith({int? gold, List<InventoryEntry>? items}) {
+    return Inventory(gold: gold ?? this.gold, items: items ?? this.items);
+  }
+}

lib/src/core/model/item_stats.dart

@@ -41,36 +41,52 @@ class ItemStats with _$ItemStats {
   const factory ItemStats({
     /// 물리 공격력 보정
     @Default(0) int atk,
+
     /// 물리 방어력 보정
     @Default(0) int def,
+
     /// 마법 공격력 보정
     @Default(0) int magAtk,
+
     /// 마법 방어력 보정
     @Default(0) int magDef,
+
     /// 크리티컬 확률 보정 (0.0 ~ 1.0)
     @Default(0.0) double criRate,
+
     /// 회피율 보정 (0.0 ~ 1.0)
     @Default(0.0) double evasion,
+
     /// 방패 방어율 (방패 전용, 0.0 ~ 1.0)
     @Default(0.0) double blockRate,
+
     /// 무기 쳐내기 확률 (무기 전용, 0.0 ~ 1.0)
     @Default(0.0) double parryRate,
+
     /// HP 보너스
     @Default(0) int hpBonus,
+
     /// MP 보너스
     @Default(0) int mpBonus,
+
     /// STR 보너스
     @Default(0) int strBonus,
+
     /// CON 보너스
     @Default(0) int conBonus,
+
     /// DEX 보너스
     @Default(0) int dexBonus,
+
     /// INT 보너스
     @Default(0) int intBonus,
+
     /// WIS 보너스
     @Default(0) int wisBonus,
+
     /// CHA 보너스
     @Default(0) int chaBonus,
+
     /// 무기 공격속도 (밀리초, 무기 전용)
     ///
     /// 0이면 기본값(1000ms) 사용, 값이 클수록 느린 공격.

lib/src/core/model/monetization_state.dart

@@ -23,6 +23,7 @@ class MonetizationState with _$MonetizationState {
     @Default(1) int undoRemaining,
 
     /// 되돌리기용 스탯 히스토리 (JSON 변환 커스텀)
+    // ignore: invalid_annotation_target
     @JsonKey(fromJson: _statsListFromJson, toJson: _statsListToJson)
     List<Stats>? rollHistory,
 
@@ -33,6 +34,7 @@ class MonetizationState with _$MonetizationState {
     int? speedBoostEndMs,
 
     /// 마지막 플레이 시각 (복귀 보상 계산용)
+    // ignore: invalid_annotation_target
     @JsonKey(fromJson: _dateTimeFromJson, toJson: _dateTimeToJson)
     DateTime? lastPlayTime,
 
@@ -119,16 +121,18 @@ class MonetizationState with _$MonetizationState {
 List<Map<String, dynamic>>? _statsListToJson(List<Stats>? stats) {
   if (stats == null) return null;
   return stats
-      .map((s) => {
-            'str': s.str,
-            'con': s.con,
-            'dex': s.dex,
-            'int': s.intelligence,
-            'wis': s.wis,
-            'cha': s.cha,
-            'hpMax': s.hpMax,
-            'mpMax': s.mpMax,
-          })
+      .map(
+        (s) => {
+          'str': s.str,
+          'con': s.con,
+          'dex': s.dex,
+          'int': s.intelligence,
+          'wis': s.wis,
+          'cha': s.cha,
+          'hpMax': s.hpMax,
+          'mpMax': s.mpMax,
+        },
+      )
       .toList();
 }
 

lib/src/core/model/monster_grade.dart

@@ -1,5 +1,3 @@
-import 'package:flutter/material.dart';
-
 /// 몬스터 등급 (드랍 품질 및 UI 표시에 영향)
 enum MonsterGrade {
   /// 일반 몬스터 (85% 확률)
@@ -48,13 +46,13 @@ extension MonsterGradeExtension on MonsterGrade {
     MonsterGrade.boss => 2.5, // +150% 경험치
   };
 
-  /// UI 표시용 색상
-  /// - Normal: 기본 텍스트 색상 (null 반환 → 기본 스타일 사용)
+  /// UI 표시용 색상 코드 (hex)
+  /// - Normal: null (기본 스타일 사용)
   /// - Elite: 파란색 (#7AA2F7)
   /// - Boss: 금색 (#E0AF68)
-  Color? get displayColor => switch (this) {
+  int? get displayColorCode => switch (this) {
     MonsterGrade.normal => null,
-    MonsterGrade.elite => const Color(0xFF7AA2F7), // MP 파랑
-    MonsterGrade.boss => const Color(0xFFE0AF68), // 골드
+    MonsterGrade.elite => 0xFF7AA2F7, // MP 파랑
+    MonsterGrade.boss => 0xFFE0AF68, // 골드
   };
 }

lib/src/core/model/potion.dart

@@ -62,9 +62,7 @@ class Potion {
 ///
 /// 보유 물약 수량 관리 (쿨타임은 CombatState에서 관리)
 class PotionInventory {
-  const PotionInventory({
-    this.potions = const {},
-  });
+  const PotionInventory({this.potions = const {}});
 
   /// 보유 물약 (물약 ID → 수량)
   final Map<String, int> potions;
@@ -99,11 +97,7 @@ class PotionInventory {
   /// 빈 인벤토리
   static const empty = PotionInventory();
 
-  PotionInventory copyWith({
-    Map<String, int>? potions,
-  }) {
-    return PotionInventory(
-      potions: potions ?? this.potions,
-    );
+  PotionInventory copyWith({Map<String, int>? potions}) {
+    return PotionInventory(potions: potions ?? this.potions);
   }
 }

lib/src/core/model/progress_state.dart

@@ -0,0 +1,192 @@
+import 'package:asciineverdie/src/core/model/combat_state.dart';
+import 'package:asciineverdie/src/core/model/task_info.dart';
+
+/// 진행 바 상태 (Progress Bar State)
+class ProgressBarState {
+  const ProgressBarState({required this.position, required this.max});
+
+  final int position;
+  final int max;
+
+  factory ProgressBarState.empty() =>
+      const ProgressBarState(position: 0, max: 1);
+
+  ProgressBarState copyWith({int? position, int? max}) {
+    return ProgressBarState(
+      position: position ?? this.position,
+      max: max ?? this.max,
+    );
+  }
+}
+
+/// 히스토리 엔트리 (Plot/Quest 진행 기록)
+class HistoryEntry {
+  const HistoryEntry({required this.caption, required this.isComplete});
+
+  /// 표시 텍스트 (예: "Prologue", "Act I", "Exterminate the Goblins")
+  final String caption;
+
+  /// 완료 여부 (원본 StateIndex: 0=진행중, 1=완료)
+  final bool isComplete;
+
+  HistoryEntry copyWith({String? caption, bool? isComplete}) {
+    return HistoryEntry(
+      caption: caption ?? this.caption,
+      isComplete: isComplete ?? this.isComplete,
+    );
+  }
+}
+
+/// 현재 퀘스트 몬스터 정보 (원본 fQuest)
+class QuestMonsterInfo {
+  const QuestMonsterInfo({
+    required this.monsterData,
+    required this.monsterIndex,
+  });
+
+  /// 몬스터 데이터 문자열 (예: "Goblin|3|ear")
+  final String monsterData;
+
+  /// 몬스터 인덱스 (Config.monsters에서의 인덱스)
+  final int monsterIndex;
+
+  static const empty = QuestMonsterInfo(monsterData: '', monsterIndex: -1);
+}
+
+/// 최종 보스 상태 (Final Boss State)
+enum FinalBossState {
+  /// 최종 보스 등장 전
+  notSpawned,
+
+  /// 최종 보스 전투 중
+  fighting,
+
+  /// 최종 보스 처치 완료
+  defeated,
+}
+
+/// 진행 상태 (Progress State)
+///
+/// 태스크, 퀘스트, 플롯, 경험치, 무게 등의 진행 상태를 관리
+class ProgressState {
+  const ProgressState({
+    required this.task,
+    required this.quest,
+    required this.plot,
+    required this.exp,
+    required this.encumbrance,
+    required this.currentTask,
+    required this.plotStageCount,
+    required this.questCount,
+    this.plotHistory = const [],
+    this.questHistory = const [],
+    this.currentQuestMonster,
+    this.currentCombat,
+    this.monstersKilled = 0,
+    this.deathCount = 0,
+    this.finalBossState = FinalBossState.notSpawned,
+    this.pendingActCompletion = false,
+    this.bossLevelingEndTime,
+  });
+
+  final ProgressBarState task;
+  final ProgressBarState quest;
+  final ProgressBarState plot;
+  final ProgressBarState exp;
+  final ProgressBarState encumbrance;
+  final TaskInfo currentTask;
+  final int plotStageCount;
+  final int questCount;
+
+  /// 플롯 히스토리 (Prologue, Act I, Act II, ...)
+  final List<HistoryEntry> plotHistory;
+
+  /// 퀘스트 히스토리 (완료된/진행중인 퀘스트 목록)
+  final List<HistoryEntry> questHistory;
+
+  /// 현재 퀘스트 몬스터 정보 (Exterminate 타입용)
+  final QuestMonsterInfo? currentQuestMonster;
+
+  /// 현재 전투 상태 (킬 태스크 진행 중)
+  final CombatState? currentCombat;
+
+  /// 처치한 몬스터 수
+  final int monstersKilled;
+
+  /// 사망 횟수
+  final int deathCount;
+
+  /// 최종 보스 상태 (Act V)
+  final FinalBossState finalBossState;
+
+  /// Act Boss 처치 대기 중 여부 (처치 후 시네마틱 재생 트리거)
+  final bool pendingActCompletion;
+
+  /// 보스 사망 후 레벨링 모드 종료 시간 (milliseconds since epoch)
+  /// null이면 레벨링 모드 아님, 값이 있으면 해당 시간까지 레벨링
+  final int? bossLevelingEndTime;
+
+  factory ProgressState.empty() => ProgressState(
+    task: ProgressBarState.empty(),
+    quest: ProgressBarState.empty(),
+    plot: ProgressBarState.empty(),
+    exp: ProgressBarState.empty(),
+    encumbrance: ProgressBarState.empty(),
+    currentTask: TaskInfo.empty(),
+    plotStageCount: 1, // Prologue
+    questCount: 0,
+    plotHistory: const [HistoryEntry(caption: 'Prologue', isComplete: false)],
+    questHistory: const [],
+    currentQuestMonster: null,
+    currentCombat: null,
+  );
+
+  ProgressState copyWith({
+    ProgressBarState? task,
+    ProgressBarState? quest,
+    ProgressBarState? plot,
+    ProgressBarState? exp,
+    ProgressBarState? encumbrance,
+    TaskInfo? currentTask,
+    int? plotStageCount,
+    int? questCount,
+    List<HistoryEntry>? plotHistory,
+    List<HistoryEntry>? questHistory,
+    QuestMonsterInfo? currentQuestMonster,
+    CombatState? currentCombat,
+    int? monstersKilled,
+    int? deathCount,
+    FinalBossState? finalBossState,
+    bool? pendingActCompletion,
+    int? bossLevelingEndTime,
+    bool clearBossLevelingEndTime = false,
+  }) {
+    return ProgressState(
+      task: task ?? this.task,
+      quest: quest ?? this.quest,
+      plot: plot ?? this.plot,
+      exp: exp ?? this.exp,
+      encumbrance: encumbrance ?? this.encumbrance,
+      currentTask: currentTask ?? this.currentTask,
+      plotStageCount: plotStageCount ?? this.plotStageCount,
+      questCount: questCount ?? this.questCount,
+      plotHistory: plotHistory ?? this.plotHistory,
+      questHistory: questHistory ?? this.questHistory,
+      currentQuestMonster: currentQuestMonster ?? this.currentQuestMonster,
+      currentCombat: currentCombat ?? this.currentCombat,
+      monstersKilled: monstersKilled ?? this.monstersKilled,
+      deathCount: deathCount ?? this.deathCount,
+      finalBossState: finalBossState ?? this.finalBossState,
+      pendingActCompletion: pendingActCompletion ?? this.pendingActCompletion,
+      bossLevelingEndTime: clearBossLevelingEndTime
+          ? null
+          : (bossLevelingEndTime ?? this.bossLevelingEndTime),
+    );
+  }
+
+  /// 현재 레벨링 모드인지 확인
+  bool get isInBossLevelingMode {
+    if (bossLevelingEndTime == null) return false;
+    return DateTime.now().millisecondsSinceEpoch < bossLevelingEndTime!;
+  }
+}

lib/src/core/model/queue_state.dart

@@ -0,0 +1,37 @@
+import 'dart:collection';
+
+import 'package:asciineverdie/src/core/model/task_info.dart';
+
+/// 큐 종류 (Queue Kind)
+enum QueueKind { task, plot }
+
+/// 큐 엔트리 (Queue Entry)
+class QueueEntry {
+  const QueueEntry({
+    required this.kind,
+    required this.durationMillis,
+    required this.caption,
+    this.taskType = TaskType.neutral,
+  });
+
+  final QueueKind kind;
+  final int durationMillis;
+  final String caption;
+  final TaskType taskType;
+}
+
+/// 큐 상태 (Queue State)
+///
+/// 대기 중인 태스크/플롯 이벤트 큐를 관리
+class QueueState {
+  QueueState({Iterable<QueueEntry>? entries})
+    : entries = Queue<QueueEntry>.from(entries ?? const []);
+
+  final Queue<QueueEntry> entries;
+
+  factory QueueState.empty() => QueueState(entries: const []);
+
+  QueueState copyWith({Iterable<QueueEntry>? entries}) {
+    return QueueState(entries: Queue<QueueEntry>.from(entries ?? this.entries));
+  }
+}

lib/src/core/model/race_traits.dart

@@ -20,9 +20,6 @@ enum PassiveType {
 
   /// MP 배율 보너스
   mpBonus,
-
-  /// 사망 시 장비 보존
-  deathEquipmentPreserve,
 }
 
 /// 패시브 능력 (passive ability)

lib/src/core/model/session_statistics.dart

@@ -0,0 +1,279 @@
+/// 세션 통계 (Session Statistics)
+///
+/// GameStatistics에서 분리된 현재 게임 세션의 통계 모델.
+class SessionStatistics {
+  const SessionStatistics({
+    required this.playTimeMs,
+    required this.monstersKilled,
+    required this.goldEarned,
+    required this.goldSpent,
+    required this.skillsUsed,
+    required this.criticalHits,
+    required this.maxCriticalStreak,
+    required this.currentCriticalStreak,
+    required this.totalDamageDealt,
+    required this.totalDamageTaken,
+    required this.potionsUsed,
+    required this.itemsSold,
+    required this.questsCompleted,
+    required this.deathCount,
+    required this.bossesDefeated,
+    required this.levelUps,
+  });
+
+  /// 플레이 시간 (밀리초)
+  final int playTimeMs;
+
+  /// 처치한 몬스터 수
+  final int monstersKilled;
+
+  /// 획득한 골드 총량
+  final int goldEarned;
+
+  /// 소비한 골드 총량
+  final int goldSpent;
+
+  /// 사용한 스킬 횟수
+  final int skillsUsed;
+
+  /// 크리티컬 히트 횟수
+  final int criticalHits;
+
+  /// 최대 연속 크리티컬
+  final int maxCriticalStreak;
+
+  /// 현재 연속 크리티컬 (내부 추적용)
+  final int currentCriticalStreak;
+
+  /// 총 입힌 데미지
+  final int totalDamageDealt;
+
+  /// 총 받은 데미지
+  final int totalDamageTaken;
+
+  /// 사용한 물약 수
+  final int potionsUsed;
+
+  /// 판매한 아이템 수
+  final int itemsSold;
+
+  /// 완료한 퀘스트 수
+  final int questsCompleted;
+
+  /// 사망 횟수
+  final int deathCount;
+
+  /// 처치한 보스 수
+  final int bossesDefeated;
+
+  /// 레벨업 횟수
+  final int levelUps;
+
+  /// 플레이 시간 Duration
+  Duration get playTime => Duration(milliseconds: playTimeMs);
+
+  /// 플레이 시간 포맷 (HH:MM:SS)
+  String get formattedPlayTime {
+    final hours = playTime.inHours;
+    final minutes = playTime.inMinutes % 60;
+    final seconds = playTime.inSeconds % 60;
+    return '${hours.toString().padLeft(2, '0')}:'
+        '${minutes.toString().padLeft(2, '0')}:'
+        '${seconds.toString().padLeft(2, '0')}';
+  }
+
+  /// 평균 DPS (damage per second)
+  double get averageDps {
+    if (playTimeMs <= 0) return 0;
+    return totalDamageDealt / (playTimeMs / 1000);
+  }
+
+  /// 킬당 평균 골드
+  double get goldPerKill {
+    if (monstersKilled <= 0) return 0;
+    return goldEarned / monstersKilled;
+  }
+
+  /// 크리티컬 비율
+  double get criticalRate {
+    if (skillsUsed <= 0) return 0;
+    return criticalHits / skillsUsed;
+  }
+
+  /// 빈 세션 통계
+  factory SessionStatistics.empty() => const SessionStatistics(
+    playTimeMs: 0,
+    monstersKilled: 0,
+    goldEarned: 0,
+    goldSpent: 0,
+    skillsUsed: 0,
+    criticalHits: 0,
+    maxCriticalStreak: 0,
+    currentCriticalStreak: 0,
+    totalDamageDealt: 0,
+    totalDamageTaken: 0,
+    potionsUsed: 0,
+    itemsSold: 0,
+    questsCompleted: 0,
+    deathCount: 0,
+    bossesDefeated: 0,
+    levelUps: 0,
+  );
+
+  // ============================================================================
+  // 이벤트 기록 메서드
+  // ============================================================================
+
+  /// 몬스터 처치 기록
+  SessionStatistics recordKill({bool isBoss = false}) {
+    return copyWith(
+      monstersKilled: monstersKilled + 1,
+      bossesDefeated: isBoss ? bossesDefeated + 1 : bossesDefeated,
+    );
+  }
+
+  /// 골드 획득 기록
+  SessionStatistics recordGoldEarned(int amount) {
+    return copyWith(goldEarned: goldEarned + amount);
+  }
+
+  /// 골드 소비 기록
+  SessionStatistics recordGoldSpent(int amount) {
+    return copyWith(goldSpent: goldSpent + amount);
+  }
+
+  /// 스킬 사용 기록
+  SessionStatistics recordSkillUse({required bool isCritical}) {
+    final newCriticalStreak = isCritical ? currentCriticalStreak + 1 : 0;
+    final newMaxStreak = newCriticalStreak > maxCriticalStreak
+        ? newCriticalStreak
+        : maxCriticalStreak;
+
+    return copyWith(
+      skillsUsed: skillsUsed + 1,
+      criticalHits: isCritical ? criticalHits + 1 : criticalHits,
+      currentCriticalStreak: newCriticalStreak,
+      maxCriticalStreak: newMaxStreak,
+    );
+  }
+
+  /// 데미지 기록
+  SessionStatistics recordDamage({int dealt = 0, int taken = 0}) {
+    return copyWith(
+      totalDamageDealt: totalDamageDealt + dealt,
+      totalDamageTaken: totalDamageTaken + taken,
+    );
+  }
+
+  /// 물약 사용 기록
+  SessionStatistics recordPotionUse() {
+    return copyWith(potionsUsed: potionsUsed + 1);
+  }
+
+  /// 아이템 판매 기록
+  SessionStatistics recordItemSold(int count) {
+    return copyWith(itemsSold: itemsSold + count);
+  }
+
+  /// 퀘스트 완료 기록
+  SessionStatistics recordQuestComplete() {
+    return copyWith(questsCompleted: questsCompleted + 1);
+  }
+
+  /// 사망 기록
+  SessionStatistics recordDeath() {
+    return copyWith(deathCount: deathCount + 1);
+  }
+
+  /// 레벨업 기록
+  SessionStatistics recordLevelUp() {
+    return copyWith(levelUps: levelUps + 1);
+  }
+
+  /// 플레이 시간 업데이트
+  SessionStatistics updatePlayTime(int elapsedMs) {
+    return copyWith(playTimeMs: elapsedMs);
+  }
+
+  SessionStatistics copyWith({
+    int? playTimeMs,
+    int? monstersKilled,
+    int? goldEarned,
+    int? goldSpent,
+    int? skillsUsed,
+    int? criticalHits,
+    int? maxCriticalStreak,
+    int? currentCriticalStreak,
+    int? totalDamageDealt,
+    int? totalDamageTaken,
+    int? potionsUsed,
+    int? itemsSold,
+    int? questsCompleted,
+    int? deathCount,
+    int? bossesDefeated,
+    int? levelUps,
+  }) {
+    return SessionStatistics(
+      playTimeMs: playTimeMs ?? this.playTimeMs,
+      monstersKilled: monstersKilled ?? this.monstersKilled,
+      goldEarned: goldEarned ?? this.goldEarned,
+      goldSpent: goldSpent ?? this.goldSpent,
+      skillsUsed: skillsUsed ?? this.skillsUsed,
+      criticalHits: criticalHits ?? this.criticalHits,
+      maxCriticalStreak: maxCriticalStreak ?? this.maxCriticalStreak,
+      currentCriticalStreak:
+          currentCriticalStreak ?? this.currentCriticalStreak,
+      totalDamageDealt: totalDamageDealt ?? this.totalDamageDealt,
+      totalDamageTaken: totalDamageTaken ?? this.totalDamageTaken,
+      potionsUsed: potionsUsed ?? this.potionsUsed,
+      itemsSold: itemsSold ?? this.itemsSold,
+      questsCompleted: questsCompleted ?? this.questsCompleted,
+      deathCount: deathCount ?? this.deathCount,
+      bossesDefeated: bossesDefeated ?? this.bossesDefeated,
+      levelUps: levelUps ?? this.levelUps,
+    );
+  }
+
+  /// JSON 직렬화
+  Map<String, dynamic> toJson() {
+    return {
+      'playTimeMs': playTimeMs,
+      'monstersKilled': monstersKilled,
+      'goldEarned': goldEarned,
+      'goldSpent': goldSpent,
+      'skillsUsed': skillsUsed,
+      'criticalHits': criticalHits,
+      'maxCriticalStreak': maxCriticalStreak,
+      'totalDamageDealt': totalDamageDealt,
+      'totalDamageTaken': totalDamageTaken,
+      'potionsUsed': potionsUsed,
+      'itemsSold': itemsSold,
+      'questsCompleted': questsCompleted,
+      'deathCount': deathCount,
+      'bossesDefeated': bossesDefeated,
+      'levelUps': levelUps,
+    };
+  }
+
+  /// JSON 역직렬화
+  factory SessionStatistics.fromJson(Map<String, dynamic> json) {
+    return SessionStatistics(
+      playTimeMs: json['playTimeMs'] as int? ?? 0,
+      monstersKilled: json['monstersKilled'] as int? ?? 0,
+      goldEarned: json['goldEarned'] as int? ?? 0,
+      goldSpent: json['goldSpent'] as int? ?? 0,
+      skillsUsed: json['skillsUsed'] as int? ?? 0,
+      criticalHits: json['criticalHits'] as int? ?? 0,
+      maxCriticalStreak: json['maxCriticalStreak'] as int? ?? 0,
+      currentCriticalStreak: 0, // 세션간 유지 안 함
+      totalDamageDealt: json['totalDamageDealt'] as int? ?? 0,
+      totalDamageTaken: json['totalDamageTaken'] as int? ?? 0,
+      potionsUsed: json['potionsUsed'] as int? ?? 0,
+      itemsSold: json['itemsSold'] as int? ?? 0,
+      questsCompleted: json['questsCompleted'] as int? ?? 0,
+      deathCount: json['deathCount'] as int? ?? 0,
+      bossesDefeated: json['bossesDefeated'] as int? ?? 0,
+      levelUps: json['levelUps'] as int? ?? 0,
+    );
+  }
+}

lib/src/core/model/skill_book.dart

@@ -0,0 +1,26 @@
+/// 스킬 엔트리 (Skill Entry)
+class SkillEntry {
+  const SkillEntry({required this.name, required this.rank});
+
+  final String name;
+  final String rank; // 예: 로마 숫자 (Roman numerals)
+
+  SkillEntry copyWith({String? name, String? rank}) {
+    return SkillEntry(name: name ?? this.name, rank: rank ?? this.rank);
+  }
+}
+
+/// 스킬북 (Skill Book)
+///
+/// 캐릭터가 보유한 스킬 목록을 관리
+class SkillBook {
+  const SkillBook({required this.skills});
+
+  final List<SkillEntry> skills;
+
+  factory SkillBook.empty() => const SkillBook(skills: []);
+
+  SkillBook copyWith({List<SkillEntry>? skills}) {
+    return SkillBook(skills: skills ?? this.skills);
+  }
+}

lib/src/core/model/skill_system_state.dart

@@ -0,0 +1,106 @@
+import 'package:asciineverdie/src/core/model/skill.dart';
+import 'package:asciineverdie/src/core/model/skill_slots.dart';
+
+/// 스킬 시스템 상태 (Phase 3)
+///
+/// 스킬 쿨타임, 활성 버프, 게임 경과 시간, 장착 스킬 등을 관리
+class SkillSystemState {
+  const SkillSystemState({
+    required this.skillStates,
+    required this.activeBuffs,
+    required this.elapsedMs,
+    this.equippedSkills = const SkillSlots(),
+    this.globalCooldownEndMs = 0,
+  });
+
+  /// 글로벌 쿨타임 (GCD) 상수: 1500ms
+  static const int globalCooldownDuration = 1500;
+
+  /// 스킬별 쿨타임 상태
+  final List<SkillState> skillStates;
+
+  /// 현재 활성화된 버프 목록
+  final List<ActiveBuff> activeBuffs;
+
+  /// 게임 진행 경과 시간 (밀리초, 스킬 쿨타임 계산용)
+  final int elapsedMs;
+
+  /// 장착된 스킬 슬롯 (타입별 제한 있음)
+  final SkillSlots equippedSkills;
+
+  /// 글로벌 쿨타임 종료 시점 (elapsedMs 기준)
+  final int globalCooldownEndMs;
+
+  /// GCD가 활성화 중인지 확인
+  bool get isGlobalCooldownActive => elapsedMs < globalCooldownEndMs;
+
+  /// 남은 GCD 시간 (ms)
+  int get remainingGlobalCooldown =>
+      isGlobalCooldownActive ? globalCooldownEndMs - elapsedMs : 0;
+
+  factory SkillSystemState.empty() => const SkillSystemState(
+    skillStates: [],
+    activeBuffs: [],
+    elapsedMs: 0,
+    equippedSkills: SkillSlots(),
+    globalCooldownEndMs: 0,
+  );
+
+  /// 특정 스킬 상태 가져오기
+  SkillState? getSkillState(String skillId) {
+    for (final state in skillStates) {
+      if (state.skillId == skillId) return state;
+    }
+    return null;
+  }
+
+  /// 버프 효과 합산 (동일 버프는 중복 적용 안 됨)
+  ({double atkMod, double defMod, double criMod, double evasionMod})
+  get totalBuffModifiers {
+    double atkMod = 0;
+    double defMod = 0;
+    double criMod = 0;
+    double evasionMod = 0;
+
+    final seenBuffIds = <String>{};
+    for (final buff in activeBuffs) {
+      if (seenBuffIds.contains(buff.effect.id)) continue;
+      seenBuffIds.add(buff.effect.id);
+
+      if (!buff.isExpired(elapsedMs)) {
+        atkMod += buff.effect.atkModifier;
+        defMod += buff.effect.defModifier;
+        criMod += buff.effect.criRateModifier;
+        evasionMod += buff.effect.evasionModifier;
+      }
+    }
+
+    return (
+      atkMod: atkMod,
+      defMod: defMod,
+      criMod: criMod,
+      evasionMod: evasionMod,
+    );
+  }
+
+  SkillSystemState copyWith({
+    List<SkillState>? skillStates,
+    List<ActiveBuff>? activeBuffs,
+    int? elapsedMs,
+    SkillSlots? equippedSkills,
+    int? globalCooldownEndMs,
+  }) {
+    return SkillSystemState(
+      skillStates: skillStates ?? this.skillStates,
+      activeBuffs: activeBuffs ?? this.activeBuffs,
+      elapsedMs: elapsedMs ?? this.elapsedMs,
+      equippedSkills: equippedSkills ?? this.equippedSkills,
+      globalCooldownEndMs: globalCooldownEndMs ?? this.globalCooldownEndMs,
+    );
+  }
+
+  /// GCD 시작 (스킬 사용 후 호출)
+  SkillSystemState startGlobalCooldown() {
+    return copyWith(globalCooldownEndMs: elapsedMs + globalCooldownDuration);
+  }
+}

lib/src/core/model/stats.dart

@@ -0,0 +1,75 @@
+/// 캐릭터 스탯 (Stats)
+///
+/// 6대 능력치(STR, CON, DEX, INT, WIS, CHA)와 HP/MP를 관리
+class Stats {
+  const Stats({
+    required this.str,
+    required this.con,
+    required this.dex,
+    required this.intelligence,
+    required this.wis,
+    required this.cha,
+    required this.hpMax,
+    required this.mpMax,
+    this.hpCurrent,
+    this.mpCurrent,
+  });
+
+  final int str;
+  final int con;
+  final int dex;
+  final int intelligence;
+  final int wis;
+  final int cha;
+  final int hpMax;
+  final int mpMax;
+
+  /// 현재 HP (null이면 hpMax와 동일)
+  final int? hpCurrent;
+
+  /// 현재 MP (null이면 mpMax와 동일)
+  final int? mpCurrent;
+
+  /// 실제 현재 HP 값
+  int get hp => hpCurrent ?? hpMax;
+
+  /// 실제 현재 MP 값
+  int get mp => mpCurrent ?? mpMax;
+
+  factory Stats.empty() => const Stats(
+    str: 0,
+    con: 0,
+    dex: 0,
+    intelligence: 0,
+    wis: 0,
+    cha: 0,
+    hpMax: 0,
+    mpMax: 0,
+  );
+
+  Stats copyWith({
+    int? str,
+    int? con,
+    int? dex,
+    int? intelligence,
+    int? wis,
+    int? cha,
+    int? hpMax,
+    int? mpMax,
+    int? hpCurrent,
+    int? mpCurrent,
+  }) {
+    return Stats(
+      str: str ?? this.str,
+      con: con ?? this.con,
+      dex: dex ?? this.dex,
+      intelligence: intelligence ?? this.intelligence,
+      wis: wis ?? this.wis,
+      cha: cha ?? this.cha,
+      hpMax: hpMax ?? this.hpMax,
+      mpMax: mpMax ?? this.mpMax,
+      hpCurrent: hpCurrent ?? this.hpCurrent,
+      mpCurrent: mpCurrent ?? this.mpCurrent,
+    );
+  }
+}

lib/src/core/model/task_info.dart

@@ -0,0 +1,67 @@
+import 'package:asciineverdie/src/shared/animation/monster_size.dart';
+import 'package:asciineverdie/src/core/model/monster_grade.dart';
+
+/// 태스크 타입 (원본 fTask.Caption 값들에 대응)
+enum TaskType {
+  neutral, // heading 등 일반 이동
+  kill, // 몬스터 처치
+  load, // 로딩/초기화
+  plot, // 플롯 진행
+  market, // 시장으로 이동 중
+  sell, // 아이템 판매 중
+  buying, // 장비 구매 중
+}
+
+/// 태스크 정보 (Task Info)
+class TaskInfo {
+  const TaskInfo({
+    required this.caption,
+    required this.type,
+    this.monsterBaseName,
+    this.monsterPart,
+    this.monsterLevel,
+    this.monsterGrade,
+    this.monsterSize,
+  });
+
+  final String caption;
+  final TaskType type;
+
+  /// 킬 태스크의 몬스터 기본 이름 (형용사 제외, 예: "Goblin")
+  final String? monsterBaseName;
+
+  /// 킬 태스크의 전리품 부위 (예: "claw", "tail", "*"는 WinItem)
+  final String? monsterPart;
+
+  /// 킬 태스크의 몬스터 레벨 (전투 스탯 계산용)
+  final int? monsterLevel;
+
+  /// 킬 태스크의 몬스터 등급 (Normal/Elite/Boss)
+  final MonsterGrade? monsterGrade;
+
+  /// 킬 태스크의 몬스터 사이즈 (애니메이션 크기 결정용, Act 기반)
+  final MonsterSize? monsterSize;
+
+  factory TaskInfo.empty() =>
+      const TaskInfo(caption: '', type: TaskType.neutral);
+
+  TaskInfo copyWith({
+    String? caption,
+    TaskType? type,
+    String? monsterBaseName,
+    String? monsterPart,
+    int? monsterLevel,
+    MonsterGrade? monsterGrade,
+    MonsterSize? monsterSize,
+  }) {
+    return TaskInfo(
+      caption: caption ?? this.caption,
+      type: type ?? this.type,
+      monsterBaseName: monsterBaseName ?? this.monsterBaseName,
+      monsterPart: monsterPart ?? this.monsterPart,
+      monsterLevel: monsterLevel ?? this.monsterLevel,
+      monsterGrade: monsterGrade ?? this.monsterGrade,
+      monsterSize: monsterSize ?? this.monsterSize,
+    );
+  }
+}

lib/src/core/model/traits.dart

@@ -0,0 +1,66 @@
+/// 캐릭터 특성 (Traits)
+///
+/// 이름, 종족, 직업, 레벨, 좌우명, 길드 정보를 포함
+class Traits {
+  const Traits({
+    required this.name,
+    required this.race,
+    required this.klass,
+    required this.level,
+    required this.motto,
+    required this.guild,
+    this.raceId = '',
+    this.classId = '',
+  });
+
+  final String name;
+
+  /// 종족 표시 이름 (예: "Kernel Giant")
+  final String race;
+
+  /// 클래스 표시 이름 (예: "Bug Hunter")
+  final String klass;
+
+  final int level;
+  final String motto;
+  final String guild;
+
+  /// 종족 ID (Phase 5, 예: "kernel_giant")
+  final String raceId;
+
+  /// 클래스 ID (Phase 5, 예: "bug_hunter")
+  final String classId;
+
+  factory Traits.empty() => const Traits(
+    name: '',
+    race: '',
+    klass: '',
+    level: 1,
+    motto: '',
+    guild: '',
+    raceId: '',
+    classId: '',
+  );
+
+  Traits copyWith({
+    String? name,
+    String? race,
+    String? klass,
+    int? level,
+    String? motto,
+    String? guild,
+    String? raceId,
+    String? classId,
+  }) {
+    return Traits(
+      name: name ?? this.name,
+      race: race ?? this.race,
+      klass: klass ?? this.klass,
+      level: level ?? this.level,
+      motto: motto ?? this.motto,
+      guild: guild ?? this.guild,
+      raceId: raceId ?? this.raceId,
+      classId: classId ?? this.classId,
+    );
+  }
+}

lib/src/core/model/treasure_chest.dart

@@ -28,10 +28,7 @@ class ChestReward {
 
   /// 장비 보상 생성
   factory ChestReward.equipment(EquipmentItem item) {
-    return ChestReward._(
-      type: ChestRewardType.equipment,
-      equipment: item,
-    );
+    return ChestReward._(type: ChestRewardType.equipment, equipment: item);
   }
 
   /// 포션 보상 생성
@@ -45,18 +42,12 @@ class ChestReward {
 
   /// 골드 보상 생성
   factory ChestReward.gold(int amount) {
-    return ChestReward._(
-      type: ChestRewardType.gold,
-      gold: amount,
-    );
+    return ChestReward._(type: ChestRewardType.gold, gold: amount);
   }
 
   /// 경험치 보상 생성
   factory ChestReward.experience(int amount) {
-    return ChestReward._(
-      type: ChestRewardType.experience,
-      experience: amount,
-    );
+    return ChestReward._(type: ChestRewardType.experience, experience: amount);
   }
 
   /// 보상 타입

lib/src/core/notification/notification_service.dart

@@ -1,5 +1,7 @@
 import 'dart:async';
 
+import 'package:asciineverdie/data/game_text_l10n.dart' as game_l10n;
+
 /// 알림 타입 (Notification Type)
 enum NotificationType {
   levelUp, // 레벨업
@@ -62,8 +64,8 @@ class NotificationService {
     show(
       GameNotification(
         type: NotificationType.levelUp,
-        title: 'LEVEL UP!',
-        subtitle: 'Level $newLevel',
+        title: game_l10n.notifyLevelUp,
+        subtitle: game_l10n.notifyLevel(newLevel),
         data: {'level': newLevel},
         duration: const Duration(seconds: 2),
       ),
@@ -75,7 +77,7 @@ class NotificationService {
     show(
       GameNotification(
         type: NotificationType.questComplete,
-        title: 'QUEST COMPLETE!',
+        title: game_l10n.notifyQuestComplete,
         subtitle: questName,
         data: {'quest': questName},
         duration: const Duration(seconds: 2),
@@ -87,8 +89,8 @@ class NotificationService {
   /// actNumber: 0=프롤로그, 1=Act I, 2=Act II, ...
   void showActComplete(int actNumber) {
     final title = actNumber == 0
-        ? 'PROLOGUE COMPLETE!'
-        : 'ACT $actNumber COMPLETE!';
+        ? game_l10n.notifyPrologueComplete
+        : game_l10n.notifyActComplete(actNumber);
     show(
       GameNotification(
         type: NotificationType.actComplete,
@@ -103,7 +105,7 @@ class NotificationService {
     show(
       GameNotification(
         type: NotificationType.newSpell,
-        title: 'NEW SPELL!',
+        title: game_l10n.notifyNewSpell,
         subtitle: spellName,
         data: {'spell': spellName},
         duration: const Duration(seconds: 2),
@@ -116,7 +118,7 @@ class NotificationService {
     show(
       GameNotification(
         type: NotificationType.newEquipment,
-        title: 'NEW EQUIPMENT!',
+        title: game_l10n.notifyNewEquipment,
         subtitle: equipmentName,
         data: {'equipment': equipmentName, 'slot': slot},
         duration: const Duration(seconds: 2),
@@ -129,7 +131,7 @@ class NotificationService {
     show(
       GameNotification(
         type: NotificationType.bossDefeat,
-        title: 'BOSS DEFEATED!',
+        title: game_l10n.notifyBossDefeated,
         subtitle: bossName,
         data: {'boss': bossName},
         duration: const Duration(seconds: 3),

lib/src/features/arena/arena_battle_screen.dart

@@ -2,23 +2,21 @@ import 'dart:async';
 
 import 'package:flutter/material.dart';
 
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/engine/arena_service.dart';
 import 'package:asciineverdie/src/core/model/arena_match.dart';
 import 'package:asciineverdie/src/core/model/combat_event.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
-import 'package:asciineverdie/src/core/animation/race_character_frames.dart';
+import 'package:asciineverdie/src/shared/animation/race_character_frames.dart';
 import 'package:asciineverdie/src/features/arena/widgets/arena_combat_log.dart';
+import 'package:asciineverdie/src/features/arena/widgets/arena_hp_bar.dart';
 import 'package:asciineverdie/src/features/arena/widgets/arena_result_panel.dart';
 import 'package:asciineverdie/src/shared/widgets/ascii_disintegrate_widget.dart';
 import 'package:asciineverdie/src/features/game/widgets/ascii_animation_card.dart';
 import 'package:asciineverdie/src/features/game/widgets/combat_log.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
-// 임시 문자열 (추후 l10n으로 이동)
-const _battleTitle = 'ARENA BATTLE';
-const _hpLabel = 'HP';
-
 /// 아레나 전투 화면
 ///
 /// ASCII 애니메이션 기반 턴제 전투 표시
@@ -438,7 +436,7 @@ class _ArenaBattleScreenState extends State<ArenaBattleScreen>
       backgroundColor: RetroColors.backgroundOf(context),
       appBar: AppBar(
         title: Text(
-          _battleTitle,
+          L10n.of(context).arenaBattleTitle,
           style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 15),
         ),
         centerTitle: true,
@@ -451,7 +449,18 @@ class _ArenaBattleScreenState extends State<ArenaBattleScreen>
             // 턴 표시
             _buildTurnIndicator(),
             // HP 바 (레트로 세그먼트 스타일)
-            _buildRetroHpBars(),
+            ArenaHpBars(
+              challengerName: widget.match.challenger.characterName,
+              challengerHp: _challengerHp,
+              challengerHpMax: _challengerHpMax,
+              challengerFlashAnimation: _challengerFlashAnimation,
+              challengerHpChange: _challengerHpChange,
+              opponentName: widget.match.opponent.characterName,
+              opponentHp: _opponentHp,
+              opponentHpMax: _opponentHpMax,
+              opponentFlashAnimation: _opponentFlashAnimation,
+              opponentHpChange: _opponentHpChange,
+            ),
             // 전투 이벤트 아이콘 (HP 바와 애니메이션 사이)
             _buildCombatEventIcons(),
             // ASCII 애니메이션 (전투 중 / 종료 분기)
@@ -649,232 +658,6 @@ class _ArenaBattleScreenState extends State<ArenaBattleScreen>
     );
   }
 
-  /// 레트로 스타일 HP 바 (좌우 대칭)
-  Widget _buildRetroHpBars() {
-    return Container(
-      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 6),
-      decoration: BoxDecoration(
-        color: RetroColors.panelBgOf(context),
-        border: Border(
-          bottom: BorderSide(color: RetroColors.borderOf(context), width: 2),
-        ),
-      ),
-      child: Row(
-        children: [
-          // 도전자 HP (좌측, 파란색)
-          Expanded(
-            child: _buildRetroHpBar(
-              name: widget.match.challenger.characterName,
-              hp: _challengerHp,
-              hpMax: _challengerHpMax,
-              fillColor: RetroColors.mpBlue,
-              accentColor: Colors.blue,
-              flashAnimation: _challengerFlashAnimation,
-              hpChange: _challengerHpChange,
-              isReversed: false,
-            ),
-          ),
-          // VS 구분자
-          Padding(
-            padding: const EdgeInsets.symmetric(horizontal: 8),
-            child: Text(
-              'VS',
-              style: TextStyle(
-                fontFamily: 'PressStart2P',
-                fontSize: 13,
-                color: RetroColors.goldOf(context),
-                fontWeight: FontWeight.bold,
-              ),
-            ),
-          ),
-          // 상대 HP (우측, 빨간색)
-          Expanded(
-            child: _buildRetroHpBar(
-              name: widget.match.opponent.characterName,
-              hp: _opponentHp,
-              hpMax: _opponentHpMax,
-              fillColor: RetroColors.hpRed,
-              accentColor: Colors.red,
-              flashAnimation: _opponentFlashAnimation,
-              hpChange: _opponentHpChange,
-              isReversed: true,
-            ),
-          ),
-        ],
-      ),
-    );
-  }
-
-  /// 레트로 세그먼트 HP 바
-  Widget _buildRetroHpBar({
-    required String name,
-    required int hp,
-    required int hpMax,
-    required Color fillColor,
-    required Color accentColor,
-    required Animation<double> flashAnimation,
-    required int hpChange,
-    required bool isReversed,
-  }) {
-    final hpRatio = hpMax > 0 ? hp / hpMax : 0.0;
-    final isLow = hpRatio < 0.2 && hpRatio > 0;
-
-    return AnimatedBuilder(
-      animation: flashAnimation,
-      builder: (context, child) {
-        // 플래시 색상 (데미지=빨강)
-        final isDamage = hpChange < 0;
-        final flashColor = isDamage
-            ? RetroColors.hpRed.withValues(alpha: flashAnimation.value * 0.4)
-            : RetroColors.expGreen.withValues(
-                alpha: flashAnimation.value * 0.4,
-              );
-
-        return Container(
-          padding: const EdgeInsets.all(6),
-          decoration: BoxDecoration(
-            color: flashAnimation.value > 0.1
-                ? flashColor
-                : accentColor.withValues(alpha: 0.1),
-            borderRadius: BorderRadius.circular(4),
-            border: Border.all(color: accentColor, width: 2),
-          ),
-          child: Stack(
-            clipBehavior: Clip.none,
-            children: [
-              Column(
-                crossAxisAlignment: isReversed
-                    ? CrossAxisAlignment.end
-                    : CrossAxisAlignment.start,
-                children: [
-                  // 이름
-                  Text(
-                    name,
-                    style: TextStyle(
-                      fontFamily: 'PressStart2P',
-                      fontSize: 11,
-                      color: RetroColors.textPrimaryOf(context),
-                    ),
-                    maxLines: 1,
-                    overflow: TextOverflow.ellipsis,
-                  ),
-                  const SizedBox(height: 4),
-                  // HP 세그먼트 바
-                  _buildSegmentBar(
-                    ratio: hpRatio,
-                    fillColor: fillColor,
-                    isLow: isLow,
-                    isReversed: isReversed,
-                  ),
-                  const SizedBox(height: 2),
-                  // HP 수치
-                  Row(
-                    mainAxisAlignment: isReversed
-                        ? MainAxisAlignment.end
-                        : MainAxisAlignment.start,
-                    children: [
-                      Text(
-                        _hpLabel,
-                        style: TextStyle(
-                          fontFamily: 'PressStart2P',
-                          fontSize: 12,
-                          color: accentColor.withValues(alpha: 0.8),
-                        ),
-                      ),
-                      const SizedBox(width: 4),
-                      Text(
-                        '$hp/$hpMax',
-                        style: TextStyle(
-                          fontFamily: 'PressStart2P',
-                          fontSize: 12,
-                          color: isLow ? RetroColors.hpRed : fillColor,
-                        ),
-                      ),
-                    ],
-                  ),
-                ],
-              ),
-
-              // 플로팅 데미지 텍스트
-              if (hpChange != 0 && flashAnimation.value > 0.05)
-                Positioned(
-                  left: isReversed ? null : 0,
-                  right: isReversed ? 0 : null,
-                  top: -12,
-                  child: Transform.translate(
-                    offset: Offset(0, -12 * (1 - flashAnimation.value)),
-                    child: Opacity(
-                      opacity: flashAnimation.value,
-                      child: Text(
-                        hpChange > 0 ? '+$hpChange' : '$hpChange',
-                        style: TextStyle(
-                          fontFamily: 'PressStart2P',
-                          fontSize: 13,
-                          fontWeight: FontWeight.bold,
-                          color: isDamage
-                              ? RetroColors.hpRed
-                              : RetroColors.expGreen,
-                          shadows: const [
-                            Shadow(color: Colors.black, blurRadius: 3),
-                            Shadow(color: Colors.black, blurRadius: 6),
-                          ],
-                        ),
-                      ),
-                    ),
-                  ),
-                ),
-            ],
-          ),
-        );
-      },
-    );
-  }
-
-  /// 세그먼트 바 (8-bit 스타일)
-  Widget _buildSegmentBar({
-    required double ratio,
-    required Color fillColor,
-    required bool isLow,
-    required bool isReversed,
-  }) {
-    const segmentCount = 10;
-    final filledSegments = (ratio.clamp(0.0, 1.0) * segmentCount).round();
-
-    final segments = List.generate(segmentCount, (index) {
-      final isFilled = isReversed
-          ? index >= segmentCount - filledSegments
-          : index < filledSegments;
-
-      return Expanded(
-        child: Container(
-          height: 8,
-          decoration: BoxDecoration(
-            color: isFilled
-                ? (isLow ? RetroColors.hpRed : fillColor)
-                : fillColor.withValues(alpha: 0.2),
-            border: Border(
-              right: index < segmentCount - 1
-                  ? BorderSide(
-                      color: RetroColors.borderOf(
-                        context,
-                      ).withValues(alpha: 0.3),
-                      width: 1,
-                    )
-                  : BorderSide.none,
-            ),
-          ),
-        ),
-      );
-    });
-
-    return Container(
-      decoration: BoxDecoration(
-        border: Border.all(color: RetroColors.borderOf(context), width: 1),
-      ),
-      child: Row(children: isReversed ? segments.reversed.toList() : segments),
-    );
-  }
-
   Widget _buildBattleLog() {
     return Container(
       margin: const EdgeInsets.all(12),

lib/src/features/arena/arena_screen.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
 import 'package:asciineverdie/src/core/storage/hall_of_fame_storage.dart';
 import 'package:asciineverdie/src/features/arena/arena_setup_screen.dart';
@@ -7,12 +8,6 @@ import 'package:asciineverdie/src/features/arena/widgets/arena_rank_card.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 import 'package:asciineverdie/src/shared/widgets/retro_panel.dart';
 
-// 임시 문자열 (추후 l10n으로 이동)
-const _arenaTitle = 'LOCAL ARENA';
-const _arenaSubtitle = 'SELECT YOUR FIGHTER';
-const _arenaEmpty = 'Not enough heroes';
-const _arenaEmptyHint = 'Clear the game with 2+ characters';
-
 /// 로컬 아레나 메인 화면
 ///
 /// 순위표 표시 및 도전하기 버튼
@@ -68,11 +63,12 @@ class _ArenaScreenState extends State<ArenaScreen> {
 
   @override
   Widget build(BuildContext context) {
+    final l10n = L10n.of(context);
     return Scaffold(
       backgroundColor: RetroColors.backgroundOf(context),
       appBar: AppBar(
         title: Text(
-          _arenaTitle,
+          l10n.arenaTitle,
           style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 15),
         ),
         centerTitle: true,
@@ -101,6 +97,7 @@ class _ArenaScreenState extends State<ArenaScreen> {
   }
 
   Widget _buildEmptyState() {
+    final l10n = L10n.of(context);
     return Center(
       child: RetroPanel(
         padding: const EdgeInsets.all(24),
@@ -114,7 +111,7 @@ class _ArenaScreenState extends State<ArenaScreen> {
             ),
             const SizedBox(height: 16),
             Text(
-              _arenaEmpty,
+              l10n.arenaEmptyTitle,
               style: TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 14,
@@ -123,7 +120,7 @@ class _ArenaScreenState extends State<ArenaScreen> {
             ),
             const SizedBox(height: 8),
             Text(
-              _arenaEmptyHint,
+              l10n.arenaEmptyHint,
               style: TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 12,
@@ -143,7 +140,7 @@ class _ArenaScreenState extends State<ArenaScreen> {
     return Padding(
       padding: const EdgeInsets.all(12),
       child: RetroGoldPanel(
-        title: _arenaSubtitle,
+        title: L10n.of(context).arenaSelectFighter,
         padding: const EdgeInsets.all(8),
         child: ListView.builder(
           itemCount: rankedEntries.length,

lib/src/features/arena/arena_setup_screen.dart

@@ -1,5 +1,6 @@
 import 'package:flutter/material.dart';
 
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/engine/arena_service.dart';
 import 'package:asciineverdie/src/core/engine/item_service.dart';
 import 'package:asciineverdie/src/core/model/arena_match.dart';
@@ -13,11 +14,6 @@ import 'package:asciineverdie/src/features/arena/widgets/arena_idle_preview.dart
 import 'package:asciineverdie/src/features/arena/widgets/arena_rank_card.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
-// 임시 문자열 (추후 l10n으로 이동)
-const _setupTitle = 'ARENA SETUP';
-const _selectCharacter = 'SELECT YOUR FIGHTER';
-const _startBattleLabel = 'START BATTLE';
-
 /// 아레나 설정 화면
 ///
 /// 캐릭터 선택 및 슬롯 선택
@@ -128,11 +124,12 @@ class _ArenaSetupScreenState extends State<ArenaSetupScreen> {
 
   @override
   Widget build(BuildContext context) {
+    final l10n = L10n.of(context);
     return Scaffold(
       backgroundColor: RetroColors.backgroundOf(context),
       appBar: AppBar(
         title: Text(
-          _setupTitle,
+          l10n.arenaSetupTitle,
           style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 15),
         ),
         centerTitle: true,
@@ -153,7 +150,7 @@ class _ArenaSetupScreenState extends State<ArenaSetupScreen> {
         Padding(
           padding: const EdgeInsets.all(16),
           child: Text(
-            _selectCharacter,
+            L10n.of(context).arenaSelectFighter,
             style: TextStyle(
               fontFamily: 'PressStart2P',
               fontSize: 14,
@@ -371,7 +368,7 @@ class _ArenaSetupScreenState extends State<ArenaSetupScreen> {
               ),
               const SizedBox(width: 8),
               Text(
-                _startBattleLabel,
+                L10n.of(context).arenaStartBattle,
                 style: TextStyle(
                   fontFamily: 'PressStart2P',
                   fontSize: 14,

lib/src/features/arena/widgets/arena_equipment_compare_list.dart

@@ -1,18 +1,12 @@
 import 'package:flutter/material.dart';
 
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/engine/item_service.dart';
 import 'package:asciineverdie/src/core/model/equipment_item.dart';
 import 'package:asciineverdie/src/core/model/equipment_slot.dart';
 import 'package:asciineverdie/src/core/model/item_stats.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
-// 임시 문자열 (추후 l10n으로 이동)
-const _myEquipmentTitle = 'MY EQUIPMENT';
-const _enemyEquipmentTitle = 'ENEMY EQUIPMENT';
-const _selectedLabel = 'SELECTED';
-const _recommendedLabel = 'BEST';
-const _weaponLockedLabel = 'LOCKED';
-
 /// 좌우 대칭 장비 비교 리스트
 ///
 /// 내 장비와 상대 장비를 나란히 표시하고,
@@ -113,6 +107,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
   }
 
   Widget _buildHeader(BuildContext context) {
+    final l10n = L10n.of(context);
     return Row(
       children: [
         // 내 장비 타이틀
@@ -125,7 +120,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
               border: Border.all(color: Colors.blue.withValues(alpha: 0.3)),
             ),
             child: Text(
-              _myEquipmentTitle,
+              l10n.arenaMyEquipment,
               style: const TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 11,
@@ -146,7 +141,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
               border: Border.all(color: Colors.red.withValues(alpha: 0.3)),
             ),
             child: Text(
-              _enemyEquipmentTitle,
+              l10n.arenaEnemyEquipment,
               style: const TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 11,
@@ -402,7 +397,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
           // 잠금 표시 또는 점수 변화
           if (isLocked)
             Text(
-              _weaponLockedLabel,
+              L10n.of(context).arenaWeaponLocked,
               style: TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 11,
@@ -441,7 +436,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
       children: [
         if (isRecommended) ...[
           Text(
-            _recommendedLabel,
+            L10n.of(context).arenaRecommended,
             style: const TextStyle(
               fontFamily: 'PressStart2P',
               fontSize: 11,
@@ -471,21 +466,22 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
     EquipmentItem? enemyItem,
     int scoreDiff,
   ) {
+    final l10n = L10n.of(context);
     final Color resultColor;
     final String resultText;
     final IconData resultIcon;
 
     if (scoreDiff > 0) {
       resultColor = Colors.green;
-      resultText = 'You will GAIN +$scoreDiff';
+      resultText = l10n.arenaScoreGain(scoreDiff);
       resultIcon = Icons.arrow_upward;
     } else if (scoreDiff < 0) {
       resultColor = Colors.red;
-      resultText = 'You will LOSE $scoreDiff';
+      resultText = l10n.arenaScoreLose(scoreDiff);
       resultIcon = Icons.arrow_downward;
     } else {
       resultColor = RetroColors.textMutedOf(context);
-      resultText = 'Even trade';
+      resultText = l10n.arenaEvenTrade;
       resultIcon = Icons.swap_horiz;
     }
 
@@ -563,7 +559,7 @@ class _ArenaEquipmentCompareListState extends State<ArenaEquipmentCompareList> {
                 ),
                 const SizedBox(width: 6),
                 Text(
-                  _selectedLabel,
+                  L10n.of(context).arenaSelected,
                   style: TextStyle(
                     fontFamily: 'PressStart2P',
                     fontSize: 12,

lib/src/features/arena/widgets/arena_hp_bar.dart

@@ -0,0 +1,254 @@
+import 'package:flutter/material.dart';
+
+import 'package:asciineverdie/l10n/app_localizations.dart';
+import 'package:asciineverdie/src/shared/retro_colors.dart';
+
+/// 아레나 전투 HP 바 (좌우 대칭 레이아웃)
+class ArenaHpBars extends StatelessWidget {
+  const ArenaHpBars({
+    super.key,
+    required this.challengerName,
+    required this.challengerHp,
+    required this.challengerHpMax,
+    required this.challengerFlashAnimation,
+    required this.challengerHpChange,
+    required this.opponentName,
+    required this.opponentHp,
+    required this.opponentHpMax,
+    required this.opponentFlashAnimation,
+    required this.opponentHpChange,
+  });
+
+  final String challengerName;
+  final int challengerHp;
+  final int challengerHpMax;
+  final Animation<double> challengerFlashAnimation;
+  final int challengerHpChange;
+
+  final String opponentName;
+  final int opponentHp;
+  final int opponentHpMax;
+  final Animation<double> opponentFlashAnimation;
+  final int opponentHpChange;
+
+  @override
+  Widget build(BuildContext context) {
+    return Container(
+      padding: const EdgeInsets.symmetric(horizontal: 8, vertical: 6),
+      decoration: BoxDecoration(
+        color: RetroColors.panelBgOf(context),
+        border: Border(
+          bottom: BorderSide(color: RetroColors.borderOf(context), width: 2),
+        ),
+      ),
+      child: Row(
+        children: [
+          Expanded(
+            child: _ArenaHpBar(
+              name: challengerName,
+              hp: challengerHp,
+              hpMax: challengerHpMax,
+              fillColor: RetroColors.mpBlue,
+              accentColor: Colors.blue,
+              flashAnimation: challengerFlashAnimation,
+              hpChange: challengerHpChange,
+              isReversed: false,
+            ),
+          ),
+          Padding(
+            padding: const EdgeInsets.symmetric(horizontal: 8),
+            child: Text(
+              'VS',
+              style: TextStyle(
+                fontFamily: 'PressStart2P',
+                fontSize: 13,
+                color: RetroColors.goldOf(context),
+                fontWeight: FontWeight.bold,
+              ),
+            ),
+          ),
+          Expanded(
+            child: _ArenaHpBar(
+              name: opponentName,
+              hp: opponentHp,
+              hpMax: opponentHpMax,
+              fillColor: RetroColors.hpRed,
+              accentColor: Colors.red,
+              flashAnimation: opponentFlashAnimation,
+              hpChange: opponentHpChange,
+              isReversed: true,
+            ),
+          ),
+        ],
+      ),
+    );
+  }
+}
+
+/// 레트로 세그먼트 HP 바 (개별)
+class _ArenaHpBar extends StatelessWidget {
+  const _ArenaHpBar({
+    required this.name,
+    required this.hp,
+    required this.hpMax,
+    required this.fillColor,
+    required this.accentColor,
+    required this.flashAnimation,
+    required this.hpChange,
+    required this.isReversed,
+  });
+
+  final String name;
+  final int hp;
+  final int hpMax;
+  final Color fillColor;
+  final Color accentColor;
+  final Animation<double> flashAnimation;
+  final int hpChange;
+  final bool isReversed;
+
+  @override
+  Widget build(BuildContext context) {
+    final hpRatio = hpMax > 0 ? hp / hpMax : 0.0;
+    final isLow = hpRatio < 0.2 && hpRatio > 0;
+
+    return AnimatedBuilder(
+      animation: flashAnimation,
+      builder: (context, child) {
+        final isDamage = hpChange < 0;
+        final flashColor = isDamage
+            ? RetroColors.hpRed.withValues(alpha: flashAnimation.value * 0.4)
+            : RetroColors.expGreen.withValues(
+                alpha: flashAnimation.value * 0.4,
+              );
+
+        return Container(
+          padding: const EdgeInsets.all(6),
+          decoration: BoxDecoration(
+            color: flashAnimation.value > 0.1
+                ? flashColor
+                : accentColor.withValues(alpha: 0.1),
+            borderRadius: BorderRadius.circular(4),
+            border: Border.all(color: accentColor, width: 2),
+          ),
+          child: Stack(
+            clipBehavior: Clip.none,
+            children: [
+              Column(
+                crossAxisAlignment: isReversed
+                    ? CrossAxisAlignment.end
+                    : CrossAxisAlignment.start,
+                children: [
+                  Text(
+                    name,
+                    style: TextStyle(
+                      fontFamily: 'PressStart2P',
+                      fontSize: 11,
+                      color: RetroColors.textPrimaryOf(context),
+                    ),
+                    maxLines: 1,
+                    overflow: TextOverflow.ellipsis,
+                  ),
+                  const SizedBox(height: 4),
+                  _buildSegmentBar(context, hpRatio, isLow),
+                  const SizedBox(height: 2),
+                  Row(
+                    mainAxisAlignment: isReversed
+                        ? MainAxisAlignment.end
+                        : MainAxisAlignment.start,
+                    children: [
+                      Text(
+                        L10n.of(context).hpLabel,
+                        style: TextStyle(
+                          fontFamily: 'PressStart2P',
+                          fontSize: 12,
+                          color: accentColor.withValues(alpha: 0.8),
+                        ),
+                      ),
+                      const SizedBox(width: 4),
+                      Text(
+                        '$hp/$hpMax',
+                        style: TextStyle(
+                          fontFamily: 'PressStart2P',
+                          fontSize: 12,
+                          color: isLow ? RetroColors.hpRed : fillColor,
+                        ),
+                      ),
+                    ],
+                  ),
+                ],
+              ),
+              if (hpChange != 0 && flashAnimation.value > 0.05)
+                Positioned(
+                  left: isReversed ? null : 0,
+                  right: isReversed ? 0 : null,
+                  top: -12,
+                  child: Transform.translate(
+                    offset: Offset(0, -12 * (1 - flashAnimation.value)),
+                    child: Opacity(
+                      opacity: flashAnimation.value,
+                      child: Text(
+                        hpChange > 0 ? '+$hpChange' : '$hpChange',
+                        style: TextStyle(
+                          fontFamily: 'PressStart2P',
+                          fontSize: 13,
+                          fontWeight: FontWeight.bold,
+                          color: isDamage
+                              ? RetroColors.hpRed
+                              : RetroColors.expGreen,
+                          shadows: const [
+                            Shadow(color: Colors.black, blurRadius: 3),
+                            Shadow(color: Colors.black, blurRadius: 6),
+                          ],
+                        ),
+                      ),
+                    ),
+                  ),
+                ),
+            ],
+          ),
+        );
+      },
+    );
+  }
+
+  /// 세그먼트 바 (8-bit 스타일)
+  Widget _buildSegmentBar(BuildContext context, double ratio, bool isLow) {
+    const segmentCount = 10;
+    final filledSegments = (ratio.clamp(0.0, 1.0) * segmentCount).round();
+
+    final segments = List.generate(segmentCount, (index) {
+      final isFilled = isReversed
+          ? index >= segmentCount - filledSegments
+          : index < filledSegments;
+
+      return Expanded(
+        child: Container(
+          height: 8,
+          decoration: BoxDecoration(
+            color: isFilled
+                ? (isLow ? RetroColors.hpRed : fillColor)
+                : fillColor.withValues(alpha: 0.2),
+            border: Border(
+              right: index < segmentCount - 1
+                  ? BorderSide(
+                      color: RetroColors.borderOf(
+                        context,
+                      ).withValues(alpha: 0.3),
+                      width: 1,
+                    )
+                  : BorderSide.none,
+            ),
+          ),
+        ),
+      );
+    });
+
+    return Container(
+      decoration: BoxDecoration(
+        border: Border.all(color: RetroColors.borderOf(context), width: 1),
+      ),
+      child: Row(children: isReversed ? segments.reversed.toList() : segments),
+    );
+  }
+}

lib/src/features/arena/widgets/arena_idle_preview.dart

@@ -1,10 +1,10 @@
 import 'dart:async';
 
-import 'package:asciineverdie/src/core/animation/canvas/ascii_cell.dart';
-import 'package:asciineverdie/src/core/animation/canvas/ascii_canvas_widget.dart';
-import 'package:asciineverdie/src/core/animation/canvas/ascii_layer.dart';
-import 'package:asciineverdie/src/core/animation/character_frames.dart';
-import 'package:asciineverdie/src/core/animation/race_character_frames.dart';
+import 'package:asciineverdie/src/shared/animation/canvas/ascii_cell.dart';
+import 'package:asciineverdie/src/shared/animation/canvas/ascii_canvas_widget.dart';
+import 'package:asciineverdie/src/shared/animation/canvas/ascii_layer.dart';
+import 'package:asciineverdie/src/shared/animation/character_frames.dart';
+import 'package:asciineverdie/src/shared/animation/race_character_frames.dart';
 import 'package:flutter/material.dart';
 
 /// 아레나 idle 상태 캐릭터 미리보기 위젯

lib/src/features/arena/widgets/arena_rank_card.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 
-import 'package:asciineverdie/src/core/l10n/game_data_l10n.dart';
+import 'package:asciineverdie/l10n/app_localizations.dart';
+import 'package:asciineverdie/src/shared/l10n/game_data_l10n.dart';
 import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
@@ -169,7 +170,7 @@ class ArenaRankCard extends StatelessWidget {
           ),
         ),
         Text(
-          'SCORE',
+          L10n.of(context).arenaScore,
           style: TextStyle(
             fontFamily: 'PressStart2P',
             fontSize: 11,

lib/src/features/arena/widgets/arena_result_dialog.dart

@@ -1,6 +1,7 @@
 import 'package:flutter/material.dart';
 
-import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
+import 'package:asciineverdie/data/game_text_l10n.dart' as game_l10n;
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/engine/item_service.dart';
 import 'package:asciineverdie/src/core/model/arena_match.dart';
 import 'package:asciineverdie/src/core/model/equipment_item.dart';
@@ -8,11 +9,6 @@ import 'package:asciineverdie/src/core/model/equipment_slot.dart';
 import 'package:asciineverdie/src/core/model/item_stats.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
-// 아레나 관련 임시 문자열 (추후 l10n으로 이동)
-const _arenaVictory = 'VICTORY!';
-const _arenaDefeat = 'DEFEAT...';
-const _arenaExchange = 'EQUIPMENT EXCHANGE';
-
 /// 아레나 결과 다이얼로그
 ///
 /// 전투 승패 및 장비 교환 결과 표시
@@ -65,7 +61,7 @@ class ArenaResultDialog extends StatelessWidget {
           onPressed: onClose,
           style: FilledButton.styleFrom(backgroundColor: resultColor),
           child: Text(
-            l10n.buttonConfirm,
+            game_l10n.buttonConfirm,
             style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 13),
           ),
         ),
@@ -74,6 +70,7 @@ class ArenaResultDialog extends StatelessWidget {
   }
 
   Widget _buildTitle(BuildContext context, bool isVictory, Color color) {
+    final l10n = L10n.of(context);
     return Row(
       mainAxisAlignment: MainAxisAlignment.center,
       children: [
@@ -84,7 +81,7 @@ class ArenaResultDialog extends StatelessWidget {
         ),
         const SizedBox(width: 8),
         Text(
-          isVictory ? _arenaVictory : _arenaDefeat,
+          isVictory ? l10n.arenaVictory : l10n.arenaDefeat,
           style: TextStyle(
             fontFamily: 'PressStart2P',
             fontSize: 15,
@@ -152,7 +149,7 @@ class ArenaResultDialog extends StatelessWidget {
           overflow: TextOverflow.ellipsis,
         ),
         Text(
-          isWinner ? 'WINNER' : 'LOSER',
+          isWinner ? L10n.of(context).arenaWinner : L10n.of(context).arenaLoser,
           style: TextStyle(
             fontFamily: 'PressStart2P',
             fontSize: 11,
@@ -196,7 +193,7 @@ class ArenaResultDialog extends StatelessWidget {
             ),
             const SizedBox(width: 8),
             Text(
-              _arenaExchange,
+              L10n.of(context).arenaEquipmentExchange,
               style: TextStyle(
                 fontFamily: 'PressStart2P',
                 fontSize: 14,
@@ -380,17 +377,17 @@ class ArenaResultDialog extends StatelessWidget {
 
   String _getSlotLabel(EquipmentSlot slot) {
     return switch (slot) {
-      EquipmentSlot.weapon => l10n.slotWeapon,
-      EquipmentSlot.shield => l10n.slotShield,
-      EquipmentSlot.helm => l10n.slotHelm,
-      EquipmentSlot.hauberk => l10n.slotHauberk,
-      EquipmentSlot.brassairts => l10n.slotBrassairts,
-      EquipmentSlot.vambraces => l10n.slotVambraces,
-      EquipmentSlot.gauntlets => l10n.slotGauntlets,
-      EquipmentSlot.gambeson => l10n.slotGambeson,
-      EquipmentSlot.cuisses => l10n.slotCuisses,
-      EquipmentSlot.greaves => l10n.slotGreaves,
-      EquipmentSlot.sollerets => l10n.slotSollerets,
+      EquipmentSlot.weapon => game_l10n.slotWeapon,
+      EquipmentSlot.shield => game_l10n.slotShield,
+      EquipmentSlot.helm => game_l10n.slotHelm,
+      EquipmentSlot.hauberk => game_l10n.slotHauberk,
+      EquipmentSlot.brassairts => game_l10n.slotBrassairts,
+      EquipmentSlot.vambraces => game_l10n.slotVambraces,
+      EquipmentSlot.gauntlets => game_l10n.slotGauntlets,
+      EquipmentSlot.gambeson => game_l10n.slotGambeson,
+      EquipmentSlot.cuisses => game_l10n.slotCuisses,
+      EquipmentSlot.greaves => game_l10n.slotGreaves,
+      EquipmentSlot.sollerets => game_l10n.slotSollerets,
     };
   }
 

lib/src/features/arena/widgets/arena_result_panel.dart

@@ -5,7 +5,8 @@ import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 import 'package:path_provider/path_provider.dart';
 
-import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
+import 'package:asciineverdie/data/game_text_l10n.dart' as game_l10n;
+import 'package:asciineverdie/l10n/app_localizations.dart';
 import 'package:asciineverdie/src/core/engine/item_service.dart';
 import 'package:asciineverdie/src/core/model/arena_match.dart';
 import 'package:asciineverdie/src/core/model/equipment_item.dart';
@@ -15,12 +16,6 @@ import 'package:asciineverdie/src/core/model/item_stats.dart';
 import 'package:asciineverdie/src/features/game/widgets/combat_log.dart';
 import 'package:asciineverdie/src/shared/retro_colors.dart';
 
-// 임시 문자열
-const _victory = 'VICTORY!';
-const _defeat = 'DEFEAT...';
-const _exchange = 'EQUIPMENT EXCHANGE';
-const _turns = 'TURNS';
-
 /// 아레나 결과 패널 (인라인)
 ///
 /// 전투 로그 하단에 표시되는 플로팅 결과 패널
@@ -132,7 +127,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
             content: Text(
-              '${l10n.uiSaved}: $fileName',
+              '${game_l10n.uiSaved}: $fileName',
               style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 11),
             ),
             backgroundColor: RetroColors.mpOf(context),
@@ -145,7 +140,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
         ScaffoldMessenger.of(context).showSnackBar(
           SnackBar(
             content: Text(
-              '${l10n.uiError}: $e',
+              '${game_l10n.uiError}: $e',
               style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 11),
             ),
             backgroundColor: RetroColors.hpOf(context),
@@ -353,6 +348,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
   }
 
   Widget _buildTitle(BuildContext context, bool isVictory, Color color) {
+    final l10n = L10n.of(context);
     return Row(
       mainAxisAlignment: MainAxisAlignment.center,
       children: [
@@ -363,7 +359,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
         ),
         const SizedBox(width: 8),
         Text(
-          isVictory ? _victory : _defeat,
+          isVictory ? l10n.arenaVictory : l10n.arenaDefeat,
           style: TextStyle(
             fontFamily: 'PressStart2P',
             fontSize: 14,
@@ -381,67 +377,26 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
   }
 
   Widget _buildBattleSummary(BuildContext context) {
+    final l10n = L10n.of(context);
     final winner = widget.result.isVictory
         ? widget.result.match.challenger.characterName
         : widget.result.match.opponent.characterName;
     final loser = widget.result.isVictory
         ? widget.result.match.opponent.characterName
         : widget.result.match.challenger.characterName;
+    final summaryText = l10n.arenaDefeatedIn(winner, loser, widget.turnCount);
 
-    return Row(
-      mainAxisAlignment: MainAxisAlignment.center,
-      children: [
-        // 승자
-        Text(
-          winner,
-          style: TextStyle(
-            fontFamily: 'PressStart2P',
-            fontSize: 11,
-            color: RetroColors.goldOf(context),
-          ),
+    return Padding(
+      padding: const EdgeInsets.symmetric(horizontal: 8),
+      child: Text(
+        summaryText,
+        style: TextStyle(
+          fontFamily: 'PressStart2P',
+          fontSize: 11,
+          color: RetroColors.textSecondaryOf(context),
         ),
-        Text(
-          ' defeated ',
-          style: TextStyle(
-            fontFamily: 'PressStart2P',
-            fontSize: 11,
-            color: RetroColors.textMutedOf(context),
-          ),
-        ),
-        // 패자
-        Text(
-          loser,
-          style: TextStyle(
-            fontFamily: 'PressStart2P',
-            fontSize: 12,
-            color: RetroColors.textSecondaryOf(context),
-          ),
-        ),
-        Text(
-          ' in ',
-          style: TextStyle(
-            fontFamily: 'PressStart2P',
-            fontSize: 11,
-            color: RetroColors.textMutedOf(context),
-          ),
-        ),
-        // 턴 수
-        Container(
-          padding: const EdgeInsets.symmetric(horizontal: 4, vertical: 2),
-          decoration: BoxDecoration(
-            color: RetroColors.goldOf(context).withValues(alpha: 0.2),
-            borderRadius: BorderRadius.circular(4),
-          ),
-          child: Text(
-            '${widget.turnCount} $_turns',
-            style: TextStyle(
-              fontFamily: 'PressStart2P',
-              fontSize: 12,
-              color: RetroColors.goldOf(context),
-            ),
-          ),
-        ),
-      ],
+        textAlign: TextAlign.center,
+      ),
     );
   }
 
@@ -499,7 +454,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
               ),
               const SizedBox(width: 4),
               Text(
-                _exchange,
+                L10n.of(context).arenaEquipmentExchange,
                 style: TextStyle(
                   fontFamily: 'PressStart2P',
                   fontSize: 12,
@@ -639,7 +594,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
           shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(6)),
         ),
         child: Text(
-          l10n.buttonConfirm,
+          game_l10n.buttonConfirm,
           style: const TextStyle(
             fontFamily: 'PressStart2P',
             fontSize: 13,
@@ -658,7 +613,7 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
         onPressed: _saveBattleLog,
         icon: const Icon(Icons.save_alt, size: 14),
         label: Text(
-          l10n.uiSaveBattleLog,
+          game_l10n.uiSaveBattleLog,
           style: const TextStyle(fontFamily: 'PressStart2P', fontSize: 11),
         ),
         style: OutlinedButton.styleFrom(
@@ -681,17 +636,17 @@ class _ArenaResultPanelState extends State<ArenaResultPanel>
 
   String _getSlotLabel(EquipmentSlot slot) {
     return switch (slot) {
-      EquipmentSlot.weapon => l10n.slotWeapon,
-      EquipmentSlot.shield => l10n.slotShield,
-      EquipmentSlot.helm => l10n.slotHelm,
-      EquipmentSlot.hauberk => l10n.slotHauberk,
-      EquipmentSlot.brassairts => l10n.slotBrassairts,
-      EquipmentSlot.vambraces => l10n.slotVambraces,
-      EquipmentSlot.gauntlets => l10n.slotGauntlets,
-      EquipmentSlot.gambeson => l10n.slotGambeson,
-      EquipmentSlot.cuisses => l10n.slotCuisses,
-      EquipmentSlot.greaves => l10n.slotGreaves,
-      EquipmentSlot.sollerets => l10n.slotSollerets,
+      EquipmentSlot.weapon => game_l10n.slotWeapon,
+      EquipmentSlot.shield => game_l10n.slotShield,
+      EquipmentSlot.helm => game_l10n.slotHelm,
+      EquipmentSlot.hauberk => game_l10n.slotHauberk,
+      EquipmentSlot.brassairts => game_l10n.slotBrassairts,
+      EquipmentSlot.vambraces => game_l10n.slotVambraces,
+      EquipmentSlot.gauntlets => game_l10n.slotGauntlets,
+      EquipmentSlot.gambeson => game_l10n.slotGambeson,
+      EquipmentSlot.cuisses => game_l10n.slotCuisses,
+      EquipmentSlot.greaves => game_l10n.slotGreaves,
+      EquipmentSlot.sollerets => game_l10n.slotSollerets,
     };
   }
 

lib/src/features/front/front_screen.dart

@@ -217,9 +217,9 @@ class _AnimationPanel extends StatelessWidget {
         children: [
           const Icon(Icons.auto_awesome, color: RetroColors.gold, size: 18),
           const SizedBox(width: 10),
-          const Text(
-            'ASCII NEVER DIE',
-            style: TextStyle(
+          Text(
+            L10n.of(context).appTitle.toUpperCase(),
+            style: const TextStyle(
               fontFamily: 'PressStart2P',
               fontSize: 14,
               color: RetroColors.gold,
@@ -272,7 +272,7 @@ class _ActionButtons extends StatelessWidget {
     final l10n = L10n.of(context);
 
     return RetroPanel(
-      title: 'MENU',
+      title: L10n.of(context).menuTitle,
       padding: const EdgeInsets.all(12),
       child: Column(
         crossAxisAlignment: CrossAxisAlignment.stretch,
@@ -321,8 +321,8 @@ class _ActionButtons extends StatelessWidget {
             onPressed: onSettings,
             isPrimary: false,
           ),
-          // IAP 구매 (광고 제거) - 스토어 사용 가능하고 미구매 상태일 때만 표시
-          if (removeAdsPrice != null && !isAdRemovalPurchased) ...[
+          // IAP 구매 (광고 제거) - 스토어 사용 가능할 때 표시 (구매 완료 시 비활성화)
+          if (removeAdsPrice != null) ...[
             const SizedBox(height: 20),
             const Divider(color: RetroColors.panelBorderInner, height: 1),
             const SizedBox(height: 12),
@@ -330,13 +330,12 @@ class _ActionButtons extends StatelessWidget {
               price: removeAdsPrice!,
               onPurchase: onPurchaseRemoveAds,
               onRestore: onRestorePurchase,
+              enabled: !isAdRemovalPurchased,
             ),
           ],
-          // 이미 구매된 경우 표시
+          // 이미 구매된 경우 배지 표시
           if (isAdRemovalPurchased) ...[
-            const SizedBox(height: 20),
-            const Divider(color: RetroColors.panelBorderInner, height: 1),
-            const SizedBox(height: 12),
+            const SizedBox(height: 8),
             _PurchasedBadge(),
           ],
         ],
@@ -412,11 +411,13 @@ class _IapPurchaseButton extends StatelessWidget {
     required this.price,
     this.onPurchase,
     this.onRestore,
+    this.enabled = true,
   });
 
   final String price;
   final VoidCallback? onPurchase;
   final VoidCallback? onRestore;
+  final bool enabled;
 
   void _showPurchaseDialog(BuildContext context) {
     showDialog<void>(
@@ -433,23 +434,33 @@ class _IapPurchaseButton extends StatelessWidget {
 
   @override
   Widget build(BuildContext context) {
+    // 비활성화 상태의 색상
+    final buttonColor = enabled ? RetroColors.gold : RetroColors.textDisabled;
+    final bgGradient = enabled
+        ? const LinearGradient(
+            colors: [Color(0xFF4A3B2A), Color(0xFF3D2E1F)],
+            begin: Alignment.topCenter,
+            end: Alignment.bottomCenter,
+          )
+        : const LinearGradient(
+            colors: [Color(0xFF3A3A3A), Color(0xFF2A2A2A)],
+            begin: Alignment.topCenter,
+            end: Alignment.bottomCenter,
+          );
+
     return Column(
       crossAxisAlignment: CrossAxisAlignment.stretch,
       children: [
         // 구매 버튼 (클릭 시 팝업)
         Container(
           decoration: BoxDecoration(
-            gradient: const LinearGradient(
-              colors: [Color(0xFF4A3B2A), Color(0xFF3D2E1F)],
-              begin: Alignment.topCenter,
-              end: Alignment.bottomCenter,
-            ),
-            border: Border.all(color: RetroColors.gold, width: 2),
+            gradient: bgGradient,
+            border: Border.all(color: buttonColor, width: 2),
           ),
           child: Material(
             color: Colors.transparent,
             child: InkWell(
-              onTap: () => _showPurchaseDialog(context),
+              onTap: enabled ? () => _showPurchaseDialog(context) : null,
               child: Padding(
                 padding: const EdgeInsets.symmetric(
                   horizontal: 16,
@@ -457,7 +468,7 @@ class _IapPurchaseButton extends StatelessWidget {
                 ),
                 child: Row(
                   children: [
-                    const Icon(Icons.block, color: RetroColors.gold, size: 24),
+                    Icon(Icons.block, color: buttonColor, size: 24),
                     const SizedBox(width: 12),
                     Expanded(
                       child: Column(
@@ -465,10 +476,10 @@ class _IapPurchaseButton extends StatelessWidget {
                         children: [
                           Text(
                             game_l10n.iapRemoveAds,
-                            style: const TextStyle(
+                            style: TextStyle(
                               fontFamily: 'PressStart2P',
                               fontSize: 12,
-                              color: RetroColors.gold,
+                              color: buttonColor,
                             ),
                           ),
                           const SizedBox(height: 4),
@@ -484,11 +495,7 @@ class _IapPurchaseButton extends StatelessWidget {
                       ),
                     ),
                     // 화살표 아이콘 (상세 보기)
-                    const Icon(
-                      Icons.arrow_forward_ios,
-                      color: RetroColors.gold,
-                      size: 16,
-                    ),
+                    Icon(Icons.arrow_forward_ios, color: buttonColor, size: 16),
                   ],
                 ),
               ),
@@ -499,7 +506,7 @@ class _IapPurchaseButton extends StatelessWidget {
         // 복원 버튼
         Center(
           child: TextButton(
-            onPressed: onRestore,
+            onPressed: enabled ? onRestore : null,
             child: Text(
               game_l10n.iapRestorePurchase,
               style: const TextStyle(
@@ -569,7 +576,10 @@ class _IapPurchaseDialog extends StatelessWidget {
               const SizedBox(height: 8),
               _BenefitItem(icon: Icons.speed, text: game_l10n.iapBenefit5),
               const SizedBox(height: 8),
-              _BenefitItem(icon: Icons.inventory_2, text: game_l10n.iapBenefit6),
+              _BenefitItem(
+                icon: Icons.inventory_2,
+                text: game_l10n.iapBenefit6,
+              ),
               const SizedBox(height: 20),
               // 가격 + 구매 버튼
               Container(

lib/src/features/front/widgets/hero_vs_boss_animation.dart

@@ -5,7 +5,7 @@ import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
 
 import 'package:asciineverdie/data/race_data.dart';
-import 'package:asciineverdie/src/core/animation/front_screen_animation.dart';
+import 'package:asciineverdie/src/shared/animation/front_screen_animation.dart';
 
 /// 프론트 화면용 Hero vs Glitch God ASCII 애니메이션 위젯
 ///

lib/src/features/game/game_session_controller.dart

@@ -1,28 +1,31 @@
 import 'dart:async';
 
-import 'package:asciineverdie/src/core/engine/ad_service.dart';
-import 'package:asciineverdie/src/core/engine/debug_settings_service.dart';
-import 'package:asciineverdie/src/core/engine/iap_service.dart';
 import 'package:asciineverdie/src/core/engine/progress_loop.dart';
 import 'package:asciineverdie/src/core/engine/progress_service.dart';
-import 'package:asciineverdie/src/core/engine/resurrection_service.dart';
-import 'package:asciineverdie/src/core/engine/return_rewards_service.dart';
-import 'package:asciineverdie/src/core/engine/shop_service.dart';
-import 'package:asciineverdie/src/core/engine/test_character_service.dart';
-import 'package:asciineverdie/src/core/model/combat_stats.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/game_statistics.dart';
-import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
 import 'package:asciineverdie/src/core/model/monetization_state.dart';
 import 'package:asciineverdie/src/core/model/treasure_chest.dart';
 import 'package:asciineverdie/src/core/storage/hall_of_fame_storage.dart';
 import 'package:asciineverdie/src/core/storage/save_manager.dart';
 import 'package:asciineverdie/src/core/storage/statistics_storage.dart';
+import 'package:asciineverdie/src/features/game/managers/game_statistics_manager.dart';
+import 'package:asciineverdie/src/features/game/managers/hall_of_fame_manager.dart';
+import 'package:asciineverdie/src/features/game/managers/resurrection_manager.dart';
+import 'package:asciineverdie/src/features/game/managers/return_rewards_manager.dart';
+import 'package:asciineverdie/src/features/game/managers/speed_boost_manager.dart';
 import 'package:flutter/foundation.dart';
 
 enum GameSessionStatus { idle, loading, running, error, dead, complete }
 
 /// Presentation-friendly wrapper that owns ProgressLoop and SaveManager.
+///
+/// 게임 루프 관리를 담당하며, 대부분의 기능은 매니저에 위임합니다.
+/// - 통계: GameStatisticsManager
+/// - 속도 부스트: SpeedBoostManager
+/// - 복귀 보상: ReturnRewardsManager
+/// - 부활: ResurrectionManager
+/// - 명예의 전당: HallOfFameManager
 class GameSessionController extends ChangeNotifier {
   GameSessionController({
     required this.progressService,
@@ -33,19 +36,42 @@ class GameSessionController extends ChangeNotifier {
     StatisticsStorage? statisticsStorage,
     HallOfFameStorage? hallOfFameStorage,
   }) : _tickInterval = tickInterval,
-       _now = now ?? DateTime.now,
-       _statisticsStorage = statisticsStorage ?? StatisticsStorage(),
-       _hallOfFameStorage = hallOfFameStorage ?? HallOfFameStorage();
+       _now = now ?? DateTime.now {
+    // 매니저 초기화
+    _statisticsManager = GameStatisticsManager(
+      statisticsStorage: statisticsStorage,
+    );
+    _hallOfFameManager = HallOfFameManager(
+      hallOfFameStorage: hallOfFameStorage,
+    );
+    _speedBoostManager = SpeedBoostManager(
+      cheatsEnabledGetter: () => _cheatsEnabled,
+      getAvailableSpeeds: _hallOfFameManager.getAvailableSpeeds,
+    );
+    _returnRewardsManager = ReturnRewardsManager();
+    _resurrectionManager = ResurrectionManager();
+
+    // 매니저 콜백 설정
+    _speedBoostManager.onStateChanged = notifyListeners;
+    _returnRewardsManager.onReturnRewardAvailable = (reward) {
+      onReturnRewardAvailable?.call(reward);
+    };
+  }
 
   final ProgressService progressService;
   final SaveManager saveManager;
   final AutoSaveConfig autoSaveConfig;
-  final StatisticsStorage _statisticsStorage;
-  final HallOfFameStorage _hallOfFameStorage;
 
   final Duration _tickInterval;
   final DateTime Function() _now;
 
+  // 매니저들
+  late final GameStatisticsManager _statisticsManager;
+  late final HallOfFameManager _hallOfFameManager;
+  late final SpeedBoostManager _speedBoostManager;
+  late final ReturnRewardsManager _returnRewardsManager;
+  late final ResurrectionManager _resurrectionManager;
+
   ProgressLoop? _loop;
   StreamSubscription<GameState>? _subscription;
   bool _cheatsEnabled = false;
@@ -54,35 +80,15 @@ class GameSessionController extends ChangeNotifier {
   GameState? _state;
   String? _error;
 
-  // 배속 저장 (pause/resume 시 유지)
-  int _savedSpeedMultiplier = 1;
-
-  // 자동 부활 (Auto-Resurrection) 상태
-  bool _autoResurrect = false;
-
-  // 속도 부스트 상태 (Phase 6)
-  bool _isSpeedBoostActive = false;
-  Timer? _speedBoostTimer;
-  int _speedBoostRemainingSeconds = 0;
-  static const int _speedBoostDuration = 300; // 5분
-
-  /// 광고 배속 배율 (릴리즈: 5x, 디버그빌드+디버그모드: 20x)
-  int get _speedBoostMultiplier => (kDebugMode && _cheatsEnabled) ? 20 : 5;
-
   // 복귀 보상 상태 (Phase 7)
   MonetizationState _monetization = MonetizationState.initial();
-  ReturnChestReward? _pendingReturnReward;
 
   /// 복귀 보상 콜백 (UI에서 다이얼로그 표시용)
   void Function(ReturnChestReward reward)? onReturnRewardAvailable;
 
-  // 통계 관련 필드
-  SessionStatistics _sessionStats = SessionStatistics.empty();
-  CumulativeStatistics _cumulativeStats = CumulativeStatistics.empty();
-  int _previousLevel = 0;
-  int _previousGold = 0;
-  int _previousMonstersKilled = 0;
-  int _previousQuestsCompleted = 0;
+  // ==========================================================================
+  // Getters
+  // ==========================================================================
 
   GameSessionStatus get status => _status;
   GameState? get state => _state;
@@ -91,37 +97,69 @@ class GameSessionController extends ChangeNotifier {
   bool get cheatsEnabled => _cheatsEnabled;
 
   /// 자동 부활 활성화 여부
-  bool get autoResurrect => _autoResurrect;
+  bool get autoResurrect => _resurrectionManager.autoResurrect;
 
   /// 자동 부활 설정
   void setAutoResurrect(bool value) {
-    _autoResurrect = value;
+    _resurrectionManager.autoResurrect = value;
     notifyListeners();
   }
 
   /// 현재 세션 통계
-  SessionStatistics get sessionStats => _sessionStats;
+  SessionStatistics get sessionStats => _statisticsManager.sessionStats;
 
   /// 누적 통계
-  CumulativeStatistics get cumulativeStats => _cumulativeStats;
+  CumulativeStatistics get cumulativeStats =>
+      _statisticsManager.cumulativeStats;
 
   /// 현재 ProgressLoop 인스턴스 (치트 기능용)
   ProgressLoop? get loop => _loop;
 
   /// 광고 배속 배율 (릴리즈: 5x, 디버그빌드+디버그모드: 20x)
-  int get adSpeedMultiplier => _speedBoostMultiplier;
+  int get adSpeedMultiplier => _speedBoostManager.speedBoostMultiplier;
 
   /// 2x 배속 해금 여부 (명예의 전당에 캐릭터가 있으면 true)
   bool get has2xUnlocked => _loop?.availableSpeeds.contains(2) ?? false;
 
+  /// 사망 상태 여부
+  bool get isDead =>
+      _status == GameSessionStatus.dead || (_state?.isDead ?? false);
+
+  /// 게임 클리어 여부
+  bool get isComplete => _status == GameSessionStatus.complete;
+
+  // 속도 부스트 관련 getters (매니저 위임)
+  bool get isSpeedBoostActive => _speedBoostManager.isSpeedBoostActive;
+  bool get isShowingAd => _speedBoostManager.isShowingAd;
+  bool get isRecentlyShowedAd => _speedBoostManager.isRecentlyShowedAd;
+  int get speedBoostMultiplier => _speedBoostManager.speedBoostMultiplier;
+  int get speedBoostDuration => _speedBoostManager.speedBoostDuration;
+
+  int get speedBoostRemainingSeconds => _speedBoostManager.getRemainingSeconds(
+    _monetization,
+    _state?.skillSystem.elapsedMs ?? 0,
+  );
+
+  int get currentSpeedMultiplier =>
+      _speedBoostManager.getCurrentSpeedMultiplier(_loop);
+
+  // 복귀 보상 관련 getters (매니저 위임)
+  MonetizationState get monetization => _monetization;
+  ReturnChestReward? get pendingReturnReward =>
+      _returnRewardsManager.pendingReturnReward;
+
+  // ==========================================================================
+  // 게임 루프 관리
+  // ==========================================================================
+
   Future<void> startNew(
     GameState initialState, {
     bool cheatsEnabled = false,
     bool isNewGame = true,
   }) async {
     // 기존 배속 보존 (부활/재개 시 유지)
-    // _loop가 있으면 현재 배속 사용, 없으면 저장된 배속 사용
-    final previousSpeed = _loop?.speedMultiplier ?? _savedSpeedMultiplier;
+    final previousSpeed =
+        _loop?.speedMultiplier ?? _speedBoostManager.savedSpeedMultiplier;
 
     await _stopLoop(saveOnStop: false);
 
@@ -137,24 +175,29 @@ class GameSessionController extends ChangeNotifier {
 
     // 통계 초기화
     if (isNewGame) {
-      _sessionStats = SessionStatistics.empty();
-      await _statisticsStorage.recordGameStart();
+      await _statisticsManager.initializeForNewGame();
     } else {
-      // 게임 로드 시 저장된 사망 횟수 복원
-      _sessionStats = _sessionStats.copyWith(
-        deathCount: state.progress.deathCount,
-        questsCompleted: state.progress.questCount,
-        monstersKilled: state.progress.monstersKilled,
-        playTimeMs: state.skillSystem.elapsedMs,
-      );
+      _statisticsManager.restoreFromLoadedGame(state);
     }
-    _initPreviousValues(state);
+    _statisticsManager.initPreviousValues(state);
 
-    // 명예의 전당 체크 → 가용 배속 결정
-    final availableSpeeds = await _getAvailableSpeeds();
+    // 명예의 전당 체크 → 기본 가용 배속 결정
+    final baseAvailableSpeeds = await _hallOfFameManager.getAvailableSpeeds();
+    final hasHallOfFame = baseAvailableSpeeds.contains(2);
 
-    // 새 게임이면 1배속, 재개/부활이면 기존 배속 유지
-    final initialSpeed = isNewGame ? 1 : previousSpeed;
+    // 기본 배속 결정 (부스트 미적용 시)
+    final int baseSpeed;
+    if (isNewGame) {
+      baseSpeed = hasHallOfFame ? 2 : 1;
+    } else {
+      baseSpeed = (hasHallOfFame && previousSpeed < 2) ? 2 : previousSpeed;
+    }
+
+    // 배속 부스트 활성화 상태면 부스트 배속 적용, 아니면 기본 배속
+    final speedConfig = _speedBoostManager.calculateInitialSpeeds(
+      baseAvailableSpeeds: baseAvailableSpeeds,
+      baseSpeed: baseSpeed,
+    );
 
     _loop = ProgressLoop(
       initialState: state,
@@ -166,12 +209,15 @@ class GameSessionController extends ChangeNotifier {
       cheatsEnabled: cheatsEnabled,
       onPlayerDied: _onPlayerDied,
       onGameComplete: _onGameComplete,
-      availableSpeeds: availableSpeeds,
-      initialSpeedMultiplier: initialSpeed,
+      availableSpeeds: speedConfig.speeds,
+      initialSpeedMultiplier: speedConfig.initialSpeed,
     );
 
     _subscription = _loop!.stream.listen((next) {
-      _updateStatistics(next);
+      final elapsedMs = next.skillSystem.elapsedMs;
+      // 버프 만료 체크 (게임 시간 기준)
+      _checkBuffExpiries(elapsedMs);
+      _statisticsManager.updateStatistics(next);
       _state = next;
       notifyListeners();
     });
@@ -180,86 +226,36 @@ class GameSessionController extends ChangeNotifier {
     notifyListeners();
   }
 
-  /// 가용 배속 목록 반환
-  ///
-  /// - 기본: [1] (1x만)
-  /// - 명예의 전당에 캐릭터 있으면: [1, 2] (2x 해금)
-  /// - 광고 배속(5x/20x)은 별도 버프로만 활성화
-  Future<List<int>> _getAvailableSpeeds() async {
-    final hallOfFame = await _hallOfFameStorage.load();
-    if (hallOfFame.entries.isNotEmpty) {
-      return [1, 2]; // 명예의 전당 캐릭터 있으면 2x 해금
-    }
-    return [1]; // 기본: 1x만
-  }
-
-  /// 이전 값 초기화 (통계 변화 추적용)
-  void _initPreviousValues(GameState state) {
-    _previousLevel = state.traits.level;
-    _previousGold = state.inventory.gold;
-    _previousMonstersKilled = state.progress.monstersKilled;
-    _previousQuestsCompleted = state.progress.questCount;
-  }
-
-  /// 상태 변화에 따른 통계 업데이트
-  void _updateStatistics(GameState next) {
-    // 플레이 시간 업데이트
-    _sessionStats = _sessionStats.updatePlayTime(next.skillSystem.elapsedMs);
-
-    // 레벨업 감지
-    if (next.traits.level > _previousLevel) {
-      final levelUps = next.traits.level - _previousLevel;
-      for (var i = 0; i < levelUps; i++) {
-        _sessionStats = _sessionStats.recordLevelUp();
-      }
-      _previousLevel = next.traits.level;
-
-      // 최고 레벨 업데이트
-      unawaited(_statisticsStorage.updateHighestLevel(next.traits.level));
+  /// 매 틱마다 버프 만료 체크
+  void _checkBuffExpiries(int elapsedMs) {
+    // 속도 부스트 만료 체크
+    final boostEnded = _speedBoostManager.checkExpiry(
+      elapsedMs: elapsedMs,
+      monetization: _monetization,
+      loop: _loop,
+    );
+    if (boostEnded) {
+      _monetization = _monetization.copyWith(speedBoostEndMs: null);
     }
 
-    // 골드 변화 감지
-    if (next.inventory.gold > _previousGold) {
-      final earned = next.inventory.gold - _previousGold;
-      _sessionStats = _sessionStats.recordGoldEarned(earned);
-
-      // 최대 골드 업데이트
-      unawaited(_statisticsStorage.updateHighestGold(next.inventory.gold));
-    } else if (next.inventory.gold < _previousGold) {
-      final spent = _previousGold - next.inventory.gold;
-      _sessionStats = _sessionStats.recordGoldSpent(spent);
-    }
-    _previousGold = next.inventory.gold;
-
-    // 몬스터 처치 감지
-    if (next.progress.monstersKilled > _previousMonstersKilled) {
-      final kills = next.progress.monstersKilled - _previousMonstersKilled;
-      for (var i = 0; i < kills; i++) {
-        _sessionStats = _sessionStats.recordKill();
-      }
-      _previousMonstersKilled = next.progress.monstersKilled;
-    }
-
-    // 퀘스트 완료 감지
-    if (next.progress.questCount > _previousQuestsCompleted) {
-      final quests = next.progress.questCount - _previousQuestsCompleted;
-      for (var i = 0; i < quests; i++) {
-        _sessionStats = _sessionStats.recordQuestComplete();
-      }
-      _previousQuestsCompleted = next.progress.questCount;
+    // 자동부활 버프 만료 체크
+    final endMs = _monetization.autoReviveEndMs;
+    if (endMs != null && elapsedMs >= endMs) {
+      _monetization = _monetization.copyWith(autoReviveEndMs: null);
+      debugPrint('[GameSession] Auto-revive buff expired');
+      notifyListeners();
     }
   }
 
   /// 누적 통계 로드
   Future<void> loadCumulativeStats() async {
-    _cumulativeStats = await _statisticsStorage.loadCumulative();
+    await _statisticsManager.loadCumulativeStats();
     notifyListeners();
   }
 
   /// 세션 통계를 누적 통계에 병합
   Future<void> mergeSessionStats() async {
-    await _statisticsStorage.mergeSession(_sessionStats);
-    _cumulativeStats = await _statisticsStorage.loadCumulative();
+    await _statisticsManager.mergeSessionStats();
     notifyListeners();
   }
 
@@ -281,7 +277,10 @@ class GameSessionController extends ChangeNotifier {
     _monetization = savedMonetization ?? MonetizationState.initial();
 
     // 복귀 보상 체크 (Phase 7)
-    _checkReturnRewards(loaded);
+    _returnRewardsManager.checkReturnRewards(
+      monetization: _monetization,
+      loaded: loaded,
+    );
 
     // 저장된 치트 모드 상태 복원
     await startNew(loaded, cheatsEnabled: savedCheatsEnabled, isNewGame: false);
@@ -323,7 +322,7 @@ class GameSessionController extends ChangeNotifier {
 
     // 배속 저장 (resume 시 복원용)
     if (loop != null) {
-      _savedSpeedMultiplier = loop.speedMultiplier;
+      _speedBoostManager.savedSpeedMultiplier = loop.speedMultiplier;
     }
 
     _loop = null;
@@ -334,24 +333,22 @@ class GameSessionController extends ChangeNotifier {
     return loop.stop(saveOnStop: saveOnStop);
   }
 
-  // ============================================================================
-  // Phase 4: 사망/부활 처리
-  // ============================================================================
+  // ==========================================================================
+  // 사망/부활 처리
+  // ==========================================================================
 
   /// 플레이어 사망 콜백 (ProgressLoop에서 호출)
   void _onPlayerDied() {
-    _sessionStats = _sessionStats.recordDeath();
+    _statisticsManager.recordDeath();
     _status = GameSessionStatus.dead;
     notifyListeners();
 
-    // 자동 부활 조건 확인:
-    // 1. 수동 토글 자동부활 (_autoResurrect)
-    // 2. 유료 유저 (항상 자동부활)
-    // 3. 광고 부활 버프 활성 (10분간)
+    // 자동 부활 조건 확인
     final elapsedMs = _state?.skillSystem.elapsedMs ?? 0;
-    final shouldAutoResurrect = _autoResurrect ||
-        IAPService.instance.isAdRemovalPurchased ||
-        _monetization.isAutoReviveActive(elapsedMs);
+    final shouldAutoResurrect = _resurrectionManager.shouldAutoResurrect(
+      monetization: _monetization,
+      elapsedMs: elapsedMs,
+    );
 
     if (shouldAutoResurrect) {
       _scheduleAutoResurrect();
@@ -359,17 +356,16 @@ class GameSessionController extends ChangeNotifier {
   }
 
   /// 자동 부활 예약 (Auto-Resurrection Scheduler)
-  ///
-  /// 사망 오버레이를 잠시 표시한 후 자동으로 부활 처리
   void _scheduleAutoResurrect() {
     Future.delayed(const Duration(milliseconds: 800), () async {
       if (_status != GameSessionStatus.dead) return;
 
       // 자동 부활 조건 재확인
       final elapsedMs = _state?.skillSystem.elapsedMs ?? 0;
-      final shouldAutoResurrect = _autoResurrect ||
-          IAPService.instance.isAdRemovalPurchased ||
-          _monetization.isAutoReviveActive(elapsedMs);
+      final shouldAutoResurrect = _resurrectionManager.shouldAutoResurrect(
+        monetization: _monetization,
+        elapsedMs: elapsedMs,
+      );
 
       if (shouldAutoResurrect) {
         await resurrect();
@@ -378,12 +374,58 @@ class GameSessionController extends ChangeNotifier {
     });
   }
 
+  /// 플레이어 부활 처리 (상태만 업데이트, 게임 재개는 별도로)
+  Future<void> resurrect() async {
+    if (_state == null || !_state!.isDead) return;
+
+    final resurrectedState = await _resurrectionManager.processResurrection(
+      state: _state!,
+      saveManager: saveManager,
+      cheatsEnabled: _cheatsEnabled,
+      monetization: _monetization,
+    );
+
+    if (resurrectedState != null) {
+      _state = resurrectedState;
+      _status = GameSessionStatus.idle;
+      notifyListeners();
+    }
+  }
+
+  /// 부활 후 게임 재개
+  Future<void> resumeAfterResurrection() async {
+    if (_state == null) return;
+    await startNew(_state!, cheatsEnabled: _cheatsEnabled, isNewGame: false);
+  }
+
+  /// 광고 부활 (HP 100% + 아이템 복구 + 10분 자동부활 버프)
+  Future<void> adRevive() async {
+    if (_state == null || !_state!.isDead) return;
+
+    final result = await _resurrectionManager.processAdRevive(
+      state: _state!,
+      saveManager: saveManager,
+      cheatsEnabled: _cheatsEnabled,
+      monetization: _monetization,
+    );
+
+    if (result.success) {
+      _state = result.state;
+      _monetization = result.monetization;
+      _status = GameSessionStatus.idle;
+      notifyListeners();
+    }
+  }
+
+  // ==========================================================================
+  // 명예의 전당
+  // ==========================================================================
+
   /// 게임 클리어 콜백 (ProgressLoop에서 호출, Act V 완료 시)
   void _onGameComplete() {
     _status = GameSessionStatus.complete;
     notifyListeners();
 
-    // Hall of Fame 등록 (비동기)
     unawaited(_registerToHallOfFame());
   }
 
@@ -394,454 +436,91 @@ class GameSessionController extends ChangeNotifier {
       return;
     }
 
-    try {
-      debugPrint('[HallOfFame] Starting registration...');
-
-      // 최종 전투 스탯 계산 (CombatStats)
-      final combatStats = CombatStats.fromStats(
-        stats: _state!.stats,
-        equipment: _state!.equipment,
-        level: _state!.traits.level,
-      );
-
-      final entry = HallOfFameEntry.fromGameState(
-        state: _state!,
-        totalDeaths: _state!.progress.deathCount, // GameState에 저장된 값 사용
-        monstersKilled: _state!.progress.monstersKilled,
-        combatStats: combatStats,
-      );
-
-      debugPrint(
-        '[HallOfFame] Entry created: ${entry.characterName} Lv.${entry.level}',
-      );
-
-      final success = await _hallOfFameStorage.addEntry(entry);
-      debugPrint('[HallOfFame] Storage save result: $success');
-
-      // 통계 기록
-      await _statisticsStorage.recordGameComplete();
-      debugPrint('[HallOfFame] Registration complete');
-
-      // 클리어된 세이브 파일 삭제 (중복 등록 방지)
-      if (success) {
-        final deleteResult = await saveManager.deleteSave();
-        debugPrint('[HallOfFame] Save file deleted: ${deleteResult.success}');
-      }
-    } catch (e, st) {
-      debugPrint('[HallOfFame] ERROR: $e');
-      debugPrint('[HallOfFame] StackTrace: $st');
-    }
+    await _hallOfFameManager.registerCharacter(
+      state: _state!,
+      saveManager: saveManager,
+      statisticsManager: _statisticsManager,
+    );
   }
 
   /// 테스트 캐릭터 생성 (디버그 모드 전용)
-  ///
-  /// 현재 캐릭터를 레벨 100, 고급 장비, 다수의 스킬을 가진
-  /// 캐릭터로 변환하여 명예의 전당에 등록하고 세이브를 삭제함.
   Future<bool> createTestCharacter() async {
     if (_state == null) {
       debugPrint('[TestCharacter] _state is null');
       return false;
     }
 
-    try {
-      debugPrint('[TestCharacter] Creating test character...');
+    await _stopLoop(saveOnStop: false);
 
-      // 게임 일시정지
-      await _stopLoop(saveOnStop: false);
+    final success = await _hallOfFameManager.createTestCharacter(
+      state: _state!,
+      saveManager: saveManager,
+    );
 
-      // TestCharacterService로 테스트 캐릭터 생성
-      final testService = TestCharacterService(rng: _state!.rng);
-
-      final entry = testService.createTestCharacter(_state!);
-
-      debugPrint(
-        '[TestCharacter] Entry created: ${entry.characterName} Lv.${entry.level}',
-      );
-
-      // 명예의 전당에 등록
-      final success = await _hallOfFameStorage.addEntry(entry);
-      debugPrint('[TestCharacter] HallOfFame save result: $success');
-
-      if (success) {
-        // 세이브 파일 삭제
-        final deleteResult = await saveManager.deleteSave();
-        debugPrint('[TestCharacter] Save deleted: ${deleteResult.success}');
-      }
-
-      // 상태 초기화
+    if (success) {
       _state = null;
       _status = GameSessionStatus.idle;
       notifyListeners();
-
-      debugPrint('[TestCharacter] Complete');
-      return success;
-    } catch (e, st) {
-      debugPrint('[TestCharacter] ERROR: $e');
-      debugPrint('[TestCharacter] StackTrace: $st');
-      return false;
-    }
-  }
-
-  /// 플레이어 부활 처리 (상태만 업데이트, 게임 재개는 별도로)
-  ///
-  /// HP/MP 회복, 빈 슬롯에 장비 자동 구매
-  /// 게임 재개는 resumeAfterResurrection()으로 별도 호출 필요
-  Future<void> resurrect() async {
-    if (_state == null || !_state!.isDead) return;
-
-    // ResurrectionService를 사용하여 부활 처리
-    final shopService = ShopService(rng: _state!.rng);
-    final resurrectionService = ResurrectionService(shopService: shopService);
-
-    final resurrectedState = resurrectionService.processResurrection(_state!);
-
-    // 상태 업데이트 (게임 재개 없이)
-    _state = resurrectedState;
-    _status = GameSessionStatus.idle; // 사망 상태 해제
-
-    // 저장 (치트 모드 상태 유지)
-    await saveManager.saveState(
-      resurrectedState,
-      cheatsEnabled: _cheatsEnabled,
-      monetization: _monetization,
-    );
-
-    notifyListeners();
-  }
-
-  /// 부활 후 게임 재개
-  ///
-  /// resurrect() 호출 후 애니메이션이 끝난 뒤 호출
-  Future<void> resumeAfterResurrection() async {
-    if (_state == null) return;
-
-    // 게임 재개
-    await startNew(_state!, cheatsEnabled: _cheatsEnabled, isNewGame: false);
-  }
-
-  // ===========================================================================
-  // 광고 부활 (HP 100% + 아이템 복구 + 10분 자동부활)
-  // ===========================================================================
-
-  /// 광고 부활 (HP 100% + 아이템 복구 + 10분 자동부활 버프)
-  ///
-  /// 유료 유저: 광고 없이 부활
-  /// 무료 유저: 리워드 광고 시청 후 부활
-  Future<void> adRevive() async {
-    if (_state == null || !_state!.isDead) return;
-
-    final shopService = ShopService(rng: _state!.rng);
-    final resurrectionService = ResurrectionService(shopService: shopService);
-
-    // 부활 처리 함수
-    void processRevive() {
-      _state = resurrectionService.processAdRevive(_state!);
-      _status = GameSessionStatus.idle;
-
-      // 10분 자동부활 버프 활성화 (elapsedMs 기준)
-      final buffEndMs = _state!.skillSystem.elapsedMs + 600000; // 10분 = 600,000ms
-      _monetization = _monetization.copyWith(
-        autoReviveEndMs: buffEndMs,
-      );
-
-      debugPrint('[GameSession] Ad revive complete, auto-revive buff until $buffEndMs ms');
     }
 
-    // 유료 유저는 광고 없이 부활
-    if (IAPService.instance.isAdRemovalPurchased) {
-      processRevive();
-      await saveManager.saveState(
-        _state!,
-        cheatsEnabled: _cheatsEnabled,
-        monetization: _monetization,
-      );
-      notifyListeners();
-      debugPrint('[GameSession] Ad revive (paid user)');
-      return;
-    }
-
-    // 무료 유저는 리워드 광고 필요
-    final adResult = await AdService.instance.showRewardedAd(
-      adType: AdType.rewardRevive,
-      onRewarded: processRevive,
-    );
-
-    if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
-      await saveManager.saveState(
-        _state!,
-        cheatsEnabled: _cheatsEnabled,
-        monetization: _monetization,
-      );
-      notifyListeners();
-      debugPrint('[GameSession] Ad revive (free user with ad)');
-    } else {
-      debugPrint('[GameSession] Ad revive failed: $adResult');
-    }
+    return success;
   }
 
-  /// 사망 상태 여부
-  bool get isDead =>
-      _status == GameSessionStatus.dead || (_state?.isDead ?? false);
-
-  /// 게임 클리어 여부
-  bool get isComplete => _status == GameSessionStatus.complete;
-
-  // ===========================================================================
+  // ==========================================================================
   // 속도 부스트 (Phase 6)
-  // ===========================================================================
-
-  /// 속도 부스트 활성화 여부
-  bool get isSpeedBoostActive => _isSpeedBoostActive;
-
-  /// 속도 부스트 남은 시간 (초)
-  int get speedBoostRemainingSeconds => _speedBoostRemainingSeconds;
-
-  /// 속도 부스트 배율
-  int get speedBoostMultiplier => _speedBoostMultiplier;
-
-  /// 속도 부스트 지속 시간 (초)
-  int get speedBoostDuration => _speedBoostDuration;
-
-  /// 현재 실제 배속 (부스트 적용 포함)
-  int get currentSpeedMultiplier {
-    if (_isSpeedBoostActive) return _speedBoostMultiplier;
-    return _loop?.speedMultiplier ?? _savedSpeedMultiplier;
-  }
+  // ==========================================================================
 
   /// 속도 부스트 활성화 (광고 시청 후)
-  ///
-  /// 유료 유저: 무료 활성화
-  /// 무료 유저: 인터스티셜 광고 시청 후 활성화
-  /// Returns: 활성화 성공 여부
   Future<bool> activateSpeedBoost() async {
-    if (_isSpeedBoostActive) return false; // 이미 활성화됨
-    if (_loop == null) return false;
+    final (success, updatedMonetization) = await _speedBoostManager
+        .activateSpeedBoost(
+          loop: _loop,
+          monetization: _monetization,
+          currentElapsedMs: _state?.skillSystem.elapsedMs ?? 0,
+        );
 
-    // 유료 유저는 무료 활성화
-    if (IAPService.instance.isAdRemovalPurchased) {
-      _startSpeedBoost();
-      debugPrint('[GameSession] Speed boost activated (paid user)');
-      return true;
-    }
-
-    // 무료 유저는 인터스티셜 광고 필요
-    bool activated = false;
-    final adResult = await AdService.instance.showInterstitialAd(
-      adType: AdType.interstitialSpeed,
-      onComplete: () {
-        _startSpeedBoost();
-        activated = true;
-      },
-    );
-
-    if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
-      debugPrint('[GameSession] Speed boost activated (free user with ad)');
-      return activated;
-    }
-
-    debugPrint('[GameSession] Speed boost activation failed: $adResult');
-    return false;
-  }
-
-  /// 속도 부스트 시작 (내부)
-  void _startSpeedBoost() {
-    if (_loop == null) return;
-
-    // 현재 배속 저장
-    _savedSpeedMultiplier = _loop!.speedMultiplier;
-
-    // 부스트 배속 적용
-    _isSpeedBoostActive = true;
-    _speedBoostRemainingSeconds = _speedBoostDuration;
-
-    // monetization 상태에 종료 시점 저장 (UI 표시용)
-    final currentElapsedMs = _state?.skillSystem.elapsedMs ?? 0;
-    final endMs = currentElapsedMs + (_speedBoostDuration * 1000);
-    _monetization = _monetization.copyWith(speedBoostEndMs: endMs);
-
-    // ProgressLoop에 직접 배속 설정
-    _loop!.updateAvailableSpeeds([_speedBoostMultiplier]);
-
-    // 1초마다 남은 시간 감소
-    _speedBoostTimer?.cancel();
-    _speedBoostTimer = Timer.periodic(const Duration(seconds: 1), (timer) {
-      _speedBoostRemainingSeconds--;
+    if (success) {
+      _monetization = updatedMonetization;
       notifyListeners();
-
-      if (_speedBoostRemainingSeconds <= 0) {
-        _endSpeedBoost();
-      }
-    });
-
-    notifyListeners();
-  }
-
-  /// 속도 부스트 종료 (내부)
-  void _endSpeedBoost() {
-    _speedBoostTimer?.cancel();
-    _speedBoostTimer = null;
-    _isSpeedBoostActive = false;
-    _speedBoostRemainingSeconds = 0;
-
-    // monetization 상태 초기화 (UI 표시 제거)
-    _monetization = _monetization.copyWith(speedBoostEndMs: null);
-
-    // 원래 배속 복원
-    if (_loop != null) {
-      _getAvailableSpeeds().then((speeds) {
-        _loop!.updateAvailableSpeeds(speeds);
-      });
     }
 
-    notifyListeners();
-    debugPrint('[GameSession] Speed boost ended');
+    return success;
   }
 
   /// 속도 부스트 수동 취소
   void cancelSpeedBoost() {
-    if (_isSpeedBoostActive) {
-      _endSpeedBoost();
-    }
+    _monetization = _speedBoostManager.cancelSpeedBoost(
+      loop: _loop,
+      monetization: _monetization,
+    );
+    notifyListeners();
   }
 
-  // ===========================================================================
+  // ==========================================================================
   // 복귀 보상 (Phase 7)
-  // ===========================================================================
-
-  /// 현재 수익화 상태
-  MonetizationState get monetization => _monetization;
-
-  /// 대기 중인 복귀 보상
-  ReturnChestReward? get pendingReturnReward => _pendingReturnReward;
-
-  /// 복귀 보상 체크 (로드 시 호출)
-  void _checkReturnRewards(GameState loaded) {
-    final rewardsService = ReturnRewardsService.instance;
-    final debugSettings = DebugSettingsService.instance;
-
-    // 디버그 모드: 오프라인 시간 시뮬레이션 적용
-    final lastPlayTime = debugSettings.getSimulatedLastPlayTime(
-      _monetization.lastPlayTime,
-    );
-
-    final reward = rewardsService.calculateReward(
-      lastPlayTime: lastPlayTime,
-      currentTime: DateTime.now(),
-      isPaidUser: _monetization.isPaidUser,
-    );
-
-    if (reward.hasReward) {
-      _pendingReturnReward = reward;
-      debugPrint('[ReturnRewards] Reward available: ${reward.chestCount} chests, '
-          '${reward.hoursAway} hours away');
-
-      // UI에서 다이얼로그 표시를 위해 콜백 호출
-      // startNew 후에 호출하도록 딜레이
-      Future<void>.delayed(const Duration(milliseconds: 500), () {
-        if (_pendingReturnReward != null) {
-          onReturnRewardAvailable?.call(_pendingReturnReward!);
-        }
-      });
-    }
-  }
+  // ==========================================================================
 
   /// 복귀 보상 수령 완료 (상자 보상 적용)
-  ///
-  /// [rewards] 오픈된 상자 보상 목록
-  void applyReturnReward(List<ChestReward> rewards) {
+  Future<void> applyReturnReward(List<ChestReward> rewards) async {
     if (_state == null) return;
-    if (rewards.isEmpty) {
-      // 보상 없이 건너뛴 경우
-      _pendingReturnReward = null;
-      debugPrint('[ReturnRewards] Reward skipped');
-      return;
-    }
 
-    var updatedState = _state!;
-
-    // 보상 적용
-    for (final reward in rewards) {
-      switch (reward.type) {
-        case ChestRewardType.equipment:
-          if (reward.equipment != null) {
-            // 현재 장비와 비교하여 더 좋으면 자동 장착
-            final slotIndex = reward.equipment!.slot.index;
-            final currentItem = updatedState.equipment.getItemByIndex(slotIndex);
-            if (currentItem.isEmpty ||
-                reward.equipment!.itemWeight > currentItem.itemWeight) {
-              updatedState = updatedState.copyWith(
-                equipment: updatedState.equipment.setItemByIndex(
-                  slotIndex,
-                  reward.equipment!,
-                ),
-              );
-              debugPrint('[ReturnRewards] Equipped: ${reward.equipment!.name}');
-            } else {
-              // 더 좋지 않으면 판매 (골드로 변환)
-              final sellPrice =
-                  (reward.equipment!.level * 50 * 0.3).round().clamp(1, 99999);
-              updatedState = updatedState.copyWith(
-                inventory: updatedState.inventory.copyWith(
-                  gold: updatedState.inventory.gold + sellPrice,
-                ),
-              );
-              debugPrint('[ReturnRewards] Sold: ${reward.equipment!.name} '
-                  'for $sellPrice gold');
-            }
-          }
-        case ChestRewardType.potion:
-          if (reward.potionId != null) {
-            updatedState = updatedState.copyWith(
-              potionInventory: updatedState.potionInventory.addPotion(
-                reward.potionId!,
-                reward.potionCount ?? 1,
-              ),
-            );
-            debugPrint('[ReturnRewards] Added potion: ${reward.potionId} '
-                'x${reward.potionCount}');
-          }
-        case ChestRewardType.gold:
-          if (reward.gold != null && reward.gold! > 0) {
-            updatedState = updatedState.copyWith(
-              inventory: updatedState.inventory.copyWith(
-                gold: updatedState.inventory.gold + reward.gold!,
-              ),
-            );
-            debugPrint('[ReturnRewards] Added gold: ${reward.gold}');
-          }
-        case ChestRewardType.experience:
-          if (reward.experience != null && reward.experience! > 0) {
-            updatedState = updatedState.copyWith(
-              progress: updatedState.progress.copyWith(
-                exp: updatedState.progress.exp.copyWith(
-                  position:
-                      updatedState.progress.exp.position + reward.experience!,
-                ),
-              ),
-            );
-            debugPrint('[ReturnRewards] Added experience: ${reward.experience}');
-          }
-      }
-    }
-
-    _state = updatedState;
-
-    // 저장
-    unawaited(saveManager.saveState(
-      _state!,
+    final updatedState = await _returnRewardsManager.applyReturnReward(
+      rewards: rewards,
+      state: _state!,
+      loop: _loop,
+      saveManager: saveManager,
       cheatsEnabled: _cheatsEnabled,
       monetization: _monetization,
-    ));
+    );
 
-    _pendingReturnReward = null;
-    notifyListeners();
-
-    debugPrint('[ReturnRewards] Rewards applied: ${rewards.length} items');
+    if (updatedState != null) {
+      _state = updatedState;
+      notifyListeners();
+    }
   }
 
   /// 복귀 보상 건너뛰기
   void skipReturnReward() {
-    _pendingReturnReward = null;
-    debugPrint('[ReturnRewards] Reward skipped by user');
+    _returnRewardsManager.skipReturnReward();
   }
 }

lib/src/features/game/managers/game_statistics_manager.dart

@@ -0,0 +1,150 @@
+import 'dart:async';
+
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/game_statistics.dart';
+import 'package:asciineverdie/src/core/storage/statistics_storage.dart';
+
+/// 게임 통계 추적 및 관리를 담당하는 매니저
+///
+/// 세션 통계와 누적 통계를 관리하고, 게임 상태 변화에 따라
+/// 통계를 자동 업데이트합니다.
+class GameStatisticsManager {
+  GameStatisticsManager({StatisticsStorage? statisticsStorage})
+    : _statisticsStorage = statisticsStorage ?? StatisticsStorage();
+
+  final StatisticsStorage _statisticsStorage;
+
+  // 현재 세션 통계
+  SessionStatistics _sessionStats = SessionStatistics.empty();
+
+  // 누적 통계
+  CumulativeStatistics _cumulativeStats = CumulativeStatistics.empty();
+
+  // 이전 값 (변화 감지용)
+  int _previousLevel = 0;
+  int _previousGold = 0;
+  int _previousMonstersKilled = 0;
+  int _previousQuestsCompleted = 0;
+
+  /// 현재 세션 통계
+  SessionStatistics get sessionStats => _sessionStats;
+
+  /// 누적 통계
+  CumulativeStatistics get cumulativeStats => _cumulativeStats;
+
+  /// 새 게임 시작 시 통계 초기화
+  Future<void> initializeForNewGame() async {
+    _sessionStats = SessionStatistics.empty();
+    await _statisticsStorage.recordGameStart();
+  }
+
+  /// 게임 로드 시 통계 복원
+  void restoreFromLoadedGame(GameState state) {
+    _sessionStats = _sessionStats.copyWith(
+      deathCount: state.progress.deathCount,
+      questsCompleted: state.progress.questCount,
+      monstersKilled: state.progress.monstersKilled,
+      playTimeMs: state.skillSystem.elapsedMs,
+    );
+  }
+
+  /// 이전 값 초기화 (통계 변화 추적용)
+  void initPreviousValues(GameState state) {
+    _previousLevel = state.traits.level;
+    _previousGold = state.inventory.gold;
+    _previousMonstersKilled = state.progress.monstersKilled;
+    _previousQuestsCompleted = state.progress.questCount;
+  }
+
+  /// 상태 변화에 따른 통계 업데이트
+  ///
+  /// 매 틱마다 호출되어 레벨업, 골드, 몬스터 처치, 퀘스트 완료 등을 추적
+  void updateStatistics(GameState next) {
+    // 플레이 시간 업데이트
+    _sessionStats = _sessionStats.updatePlayTime(next.skillSystem.elapsedMs);
+
+    // 레벨업 감지
+    _detectLevelUps(next);
+
+    // 골드 변화 감지
+    _detectGoldChanges(next);
+
+    // 몬스터 처치 감지
+    _detectMonsterKills(next);
+
+    // 퀘스트 완료 감지
+    _detectQuestCompletions(next);
+  }
+
+  /// 레벨업 감지 및 기록
+  void _detectLevelUps(GameState next) {
+    if (next.traits.level > _previousLevel) {
+      final levelUps = next.traits.level - _previousLevel;
+      for (var i = 0; i < levelUps; i++) {
+        _sessionStats = _sessionStats.recordLevelUp();
+      }
+      _previousLevel = next.traits.level;
+
+      // 최고 레벨 업데이트
+      unawaited(_statisticsStorage.updateHighestLevel(next.traits.level));
+    }
+  }
+
+  /// 골드 변화 감지 및 기록
+  void _detectGoldChanges(GameState next) {
+    if (next.inventory.gold > _previousGold) {
+      final earned = next.inventory.gold - _previousGold;
+      _sessionStats = _sessionStats.recordGoldEarned(earned);
+
+      // 최대 골드 업데이트
+      unawaited(_statisticsStorage.updateHighestGold(next.inventory.gold));
+    } else if (next.inventory.gold < _previousGold) {
+      final spent = _previousGold - next.inventory.gold;
+      _sessionStats = _sessionStats.recordGoldSpent(spent);
+    }
+    _previousGold = next.inventory.gold;
+  }
+
+  /// 몬스터 처치 감지 및 기록
+  void _detectMonsterKills(GameState next) {
+    if (next.progress.monstersKilled > _previousMonstersKilled) {
+      final kills = next.progress.monstersKilled - _previousMonstersKilled;
+      for (var i = 0; i < kills; i++) {
+        _sessionStats = _sessionStats.recordKill();
+      }
+      _previousMonstersKilled = next.progress.monstersKilled;
+    }
+  }
+
+  /// 퀘스트 완료 감지 및 기록
+  void _detectQuestCompletions(GameState next) {
+    if (next.progress.questCount > _previousQuestsCompleted) {
+      final quests = next.progress.questCount - _previousQuestsCompleted;
+      for (var i = 0; i < quests; i++) {
+        _sessionStats = _sessionStats.recordQuestComplete();
+      }
+      _previousQuestsCompleted = next.progress.questCount;
+    }
+  }
+
+  /// 사망 기록
+  void recordDeath() {
+    _sessionStats = _sessionStats.recordDeath();
+  }
+
+  /// 게임 클리어 기록
+  Future<void> recordGameComplete() async {
+    await _statisticsStorage.recordGameComplete();
+  }
+
+  /// 누적 통계 로드
+  Future<void> loadCumulativeStats() async {
+    _cumulativeStats = await _statisticsStorage.loadCumulative();
+  }
+
+  /// 세션 통계를 누적 통계에 병합
+  Future<void> mergeSessionStats() async {
+    await _statisticsStorage.mergeSession(_sessionStats);
+    _cumulativeStats = await _statisticsStorage.loadCumulative();
+  }
+}

lib/src/features/game/managers/hall_of_fame_manager.dart

@@ -0,0 +1,134 @@
+import 'package:asciineverdie/src/core/engine/test_character_service.dart';
+import 'package:asciineverdie/src/core/model/combat_stats.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/hall_of_fame.dart';
+import 'package:asciineverdie/src/core/storage/hall_of_fame_storage.dart';
+import 'package:asciineverdie/src/core/storage/save_manager.dart';
+import 'package:asciineverdie/src/features/game/managers/game_statistics_manager.dart';
+import 'package:flutter/foundation.dart';
+
+/// 명예의 전당 관리를 담당하는 매니저
+///
+/// 게임 클리어 시 캐릭터 등록, 테스트 캐릭터 생성 등을 담당합니다.
+class HallOfFameManager {
+  HallOfFameManager({HallOfFameStorage? hallOfFameStorage})
+    : _hallOfFameStorage = hallOfFameStorage ?? HallOfFameStorage();
+
+  final HallOfFameStorage _hallOfFameStorage;
+
+  /// 명예의 전당 데이터 로드
+  Future<HallOfFame> load() async {
+    return _hallOfFameStorage.load();
+  }
+
+  /// 명예의 전당에 캐릭터가 있는지 확인
+  Future<bool> hasEntries() async {
+    final hallOfFame = await _hallOfFameStorage.load();
+    return hallOfFame.entries.isNotEmpty;
+  }
+
+  /// 가용 배속 목록 반환
+  ///
+  /// - 기본: [1] (1x만)
+  /// - 명예의 전당에 캐릭터 있으면: [1, 2] (2x 해금)
+  Future<List<int>> getAvailableSpeeds() async {
+    final hasCharacters = await hasEntries();
+    if (hasCharacters) {
+      return [1, 2]; // 명예의 전당 캐릭터 있으면 2x 해금
+    }
+    return [1]; // 기본: 1x만
+  }
+
+  /// 명예의 전당 등록
+  ///
+  /// 게임 클리어 시 호출되어 캐릭터 정보를 명예의 전당에 등록합니다.
+  /// 등록 성공 시 세이브 파일을 삭제합니다.
+  ///
+  /// Returns: 등록 성공 여부
+  Future<bool> registerCharacter({
+    required GameState state,
+    required SaveManager saveManager,
+    required GameStatisticsManager statisticsManager,
+  }) async {
+    try {
+      debugPrint('[HallOfFame] Starting registration...');
+
+      // 최종 전투 스탯 계산
+      final combatStats = CombatStats.fromStats(
+        stats: state.stats,
+        equipment: state.equipment,
+        level: state.traits.level,
+      );
+
+      final entry = HallOfFameEntry.fromGameState(
+        state: state,
+        totalDeaths: state.progress.deathCount,
+        monstersKilled: state.progress.monstersKilled,
+        combatStats: combatStats,
+      );
+
+      debugPrint(
+        '[HallOfFame] Entry created: ${entry.characterName} Lv.${entry.level}',
+      );
+
+      final success = await _hallOfFameStorage.addEntry(entry);
+      debugPrint('[HallOfFame] Storage save result: $success');
+
+      // 통계 기록
+      await statisticsManager.recordGameComplete();
+      debugPrint('[HallOfFame] Registration complete');
+
+      // 클리어된 세이브 파일 삭제 (중복 등록 방지)
+      if (success) {
+        final deleteResult = await saveManager.deleteSave();
+        debugPrint('[HallOfFame] Save file deleted: ${deleteResult.success}');
+      }
+
+      return success;
+    } catch (e, st) {
+      debugPrint('[HallOfFame] ERROR: $e');
+      debugPrint('[HallOfFame] StackTrace: $st');
+      return false;
+    }
+  }
+
+  /// 테스트 캐릭터 생성 (디버그 모드 전용)
+  ///
+  /// 현재 캐릭터를 레벨 100, 고급 장비, 다수의 스킬을 가진
+  /// 캐릭터로 변환하여 명예의 전당에 등록하고 세이브를 삭제합니다.
+  ///
+  /// Returns: 등록 성공 여부
+  Future<bool> createTestCharacter({
+    required GameState state,
+    required SaveManager saveManager,
+  }) async {
+    try {
+      debugPrint('[TestCharacter] Creating test character...');
+
+      // TestCharacterService로 테스트 캐릭터 생성
+      final testService = TestCharacterService(rng: state.rng);
+      final entry = testService.createTestCharacter(state);
+
+      debugPrint(
+        '[TestCharacter] Entry created: ${entry.characterName} Lv.${entry.level}',
+      );
+
+      // 명예의 전당에 등록
+      final success = await _hallOfFameStorage.addEntry(entry);
+      debugPrint('[TestCharacter] HallOfFame save result: $success');
+
+      if (success) {
+        // 세이브 파일 삭제
+        final deleteResult = await saveManager.deleteSave();
+        debugPrint('[TestCharacter] Save deleted: ${deleteResult.success}');
+      }
+
+      debugPrint('[TestCharacter] Complete');
+      return success;
+    } catch (e, st) {
+      debugPrint('[TestCharacter] ERROR: $e');
+      debugPrint('[TestCharacter] StackTrace: $st');
+      return false;
+    }
+  }
+}

lib/src/features/game/managers/resurrection_manager.dart

@@ -0,0 +1,157 @@
+import 'package:asciineverdie/src/core/engine/ad_service.dart';
+import 'package:asciineverdie/src/core/engine/iap_service.dart';
+import 'package:asciineverdie/src/core/engine/resurrection_service.dart';
+import 'package:asciineverdie/src/core/engine/shop_service.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monetization_state.dart';
+import 'package:asciineverdie/src/core/storage/save_manager.dart';
+import 'package:flutter/foundation.dart';
+
+/// 부활 결과
+class ResurrectionResult {
+  const ResurrectionResult({
+    required this.state,
+    required this.monetization,
+    required this.success,
+  });
+
+  final GameState state;
+  final MonetizationState monetization;
+  final bool success;
+}
+
+/// 사망 및 부활 처리를 담당하는 매니저
+///
+/// 일반 부활, 광고 부활, 자동 부활 등 모든 부활 관련 로직을 담당합니다.
+class ResurrectionManager {
+  ResurrectionManager();
+
+  /// 자동 부활 활성화 여부
+  bool autoResurrect = false;
+
+  /// 자동 부활 조건 확인
+  ///
+  /// 다음 조건 중 하나라도 만족하면 자동 부활:
+  /// 1. 수동 토글 자동부활 (autoResurrect)
+  /// 2. 유료 유저 (IAP 광고 제거 구매)
+  /// 3. 광고 부활 버프 활성 (10분간)
+  bool shouldAutoResurrect({
+    required MonetizationState monetization,
+    required int elapsedMs,
+  }) {
+    return autoResurrect ||
+        IAPService.instance.isAdRemovalPurchased ||
+        monetization.isAutoReviveActive(elapsedMs);
+  }
+
+  /// 일반 부활 처리 (HP 50% 회복)
+  ///
+  /// Returns: 부활된 GameState (부활 불가 시 null)
+  Future<GameState?> processResurrection({
+    required GameState state,
+    required SaveManager saveManager,
+    required bool cheatsEnabled,
+    required MonetizationState monetization,
+  }) async {
+    if (!state.isDead) return null;
+
+    final shopService = ShopService(rng: state.rng);
+    final resurrectionService = ResurrectionService(shopService: shopService);
+
+    final resurrectedState = resurrectionService.processResurrection(state);
+
+    // 저장
+    await saveManager.saveState(
+      resurrectedState,
+      cheatsEnabled: cheatsEnabled,
+      monetization: monetization,
+    );
+
+    debugPrint('[Resurrection] Normal resurrection complete');
+    return resurrectedState;
+  }
+
+  /// 광고 부활 처리 (HP 100% + 아이템 복구 + 10분 자동부활 버프)
+  ///
+  /// 유료 유저: 광고 없이 부활
+  /// 무료 유저: 리워드 광고 시청 후 부활
+  ///
+  /// Returns: ResurrectionResult (부활 불가/실패 시 success=false)
+  Future<ResurrectionResult> processAdRevive({
+    required GameState state,
+    required SaveManager saveManager,
+    required bool cheatsEnabled,
+    required MonetizationState monetization,
+  }) async {
+    if (!state.isDead) {
+      return ResurrectionResult(
+        state: state,
+        monetization: monetization,
+        success: false,
+      );
+    }
+
+    final shopService = ShopService(rng: state.rng);
+    final resurrectionService = ResurrectionService(shopService: shopService);
+
+    // 부활 처리 결과 저장용
+    GameState? revivedState;
+    MonetizationState updatedMonetization = monetization;
+
+    void processRevive() {
+      revivedState = resurrectionService.processAdRevive(state);
+
+      // 10분 자동부활 버프 활성화 (elapsedMs 기준)
+      final buffEndMs =
+          revivedState!.skillSystem.elapsedMs + 600000; // 10분 = 600,000ms
+      updatedMonetization = monetization.copyWith(autoReviveEndMs: buffEndMs);
+
+      debugPrint(
+        '[Resurrection] Ad revive complete, auto-revive buff until $buffEndMs ms',
+      );
+    }
+
+    // 유료 유저는 광고 없이 부활
+    if (IAPService.instance.isAdRemovalPurchased) {
+      processRevive();
+      await saveManager.saveState(
+        revivedState!,
+        cheatsEnabled: cheatsEnabled,
+        monetization: updatedMonetization,
+      );
+      debugPrint('[Resurrection] Ad revive (paid user)');
+      return ResurrectionResult(
+        state: revivedState!,
+        monetization: updatedMonetization,
+        success: true,
+      );
+    }
+
+    // 무료 유저는 리워드 광고 필요
+    final adResult = await AdService.instance.showRewardedAd(
+      adType: AdType.rewardRevive,
+      onRewarded: processRevive,
+    );
+
+    if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
+      await saveManager.saveState(
+        revivedState!,
+        cheatsEnabled: cheatsEnabled,
+        monetization: updatedMonetization,
+      );
+      debugPrint('[Resurrection] Ad revive (free user with ad)');
+      return ResurrectionResult(
+        state: revivedState!,
+        monetization: updatedMonetization,
+        success: true,
+      );
+    }
+
+    debugPrint('[Resurrection] Ad revive failed: $adResult');
+    return ResurrectionResult(
+      state: state,
+      monetization: monetization,
+      success: false,
+    );
+  }
+}

lib/src/features/game/managers/return_rewards_manager.dart

@@ -0,0 +1,203 @@
+import 'dart:async';
+
+import 'package:asciineverdie/src/core/engine/debug_settings_service.dart';
+import 'package:asciineverdie/src/core/engine/progress_loop.dart';
+import 'package:asciineverdie/src/core/engine/return_rewards_service.dart';
+import 'package:asciineverdie/src/core/model/game_state.dart';
+import 'package:asciineverdie/src/core/model/monetization_state.dart';
+import 'package:asciineverdie/src/core/model/treasure_chest.dart';
+import 'package:asciineverdie/src/core/storage/save_manager.dart';
+import 'package:flutter/foundation.dart';
+
+/// 복귀 보상 기능 관리자 (Phase 7)
+///
+/// 장시간 접속하지 않은 유저에게 복귀 보상(상자)을 지급하는
+/// 기능을 담당합니다.
+class ReturnRewardsManager {
+  ReturnRewardsManager();
+
+  // 대기 중인 복귀 보상
+  ReturnChestReward? _pendingReturnReward;
+
+  /// 복귀 보상 콜백 (UI에서 다이얼로그 표시용)
+  void Function(ReturnChestReward reward)? onReturnRewardAvailable;
+
+  /// 대기 중인 복귀 보상
+  ReturnChestReward? get pendingReturnReward => _pendingReturnReward;
+
+  /// 복귀 보상 체크 (로드 시 호출)
+  ///
+  /// 오프라인 시간에 따라 보상을 계산하고, 보상이 있으면
+  /// UI에 알림을 예약합니다.
+  void checkReturnRewards({
+    required MonetizationState monetization,
+    required GameState loaded,
+  }) {
+    final rewardsService = ReturnRewardsService.instance;
+    final debugSettings = DebugSettingsService.instance;
+
+    // 디버그 모드: 오프라인 시간 시뮬레이션 적용
+    final lastPlayTime = debugSettings.getSimulatedLastPlayTime(
+      monetization.lastPlayTime,
+    );
+
+    final reward = rewardsService.calculateReward(
+      lastPlayTime: lastPlayTime,
+      currentTime: DateTime.now(),
+      isPaidUser: monetization.isPaidUser,
+    );
+
+    if (reward.hasReward) {
+      _pendingReturnReward = reward;
+      debugPrint(
+        '[ReturnRewards] Reward available: ${reward.chestCount} chests, '
+        '${reward.hoursAway} hours away',
+      );
+
+      // UI에서 다이얼로그 표시를 위해 콜백 호출
+      // startNew 후에 호출하도록 딜레이
+      Future<void>.delayed(const Duration(milliseconds: 500), () {
+        if (_pendingReturnReward != null) {
+          onReturnRewardAvailable?.call(_pendingReturnReward!);
+        }
+      });
+    }
+  }
+
+  /// 복귀 보상 수령 완료 (상자 보상 적용)
+  ///
+  /// [rewards] 오픈된 상자 보상 목록
+  /// Returns: 보상이 적용된 새로운 GameState
+  Future<GameState?> applyReturnReward({
+    required List<ChestReward> rewards,
+    required GameState state,
+    required ProgressLoop? loop,
+    required SaveManager saveManager,
+    required bool cheatsEnabled,
+    required MonetizationState monetization,
+  }) async {
+    if (rewards.isEmpty) {
+      // 보상 없이 건너뛴 경우
+      _pendingReturnReward = null;
+      debugPrint('[ReturnRewards] Reward skipped');
+      return null;
+    }
+
+    var updatedState = state;
+
+    // 보상 적용
+    for (final reward in rewards) {
+      updatedState = _applySingleReward(updatedState, reward);
+    }
+
+    loop?.replaceState(updatedState); // ProgressLoop 상태도 업데이트
+
+    // 저장
+    unawaited(
+      saveManager.saveState(
+        updatedState,
+        cheatsEnabled: cheatsEnabled,
+        monetization: monetization,
+      ),
+    );
+
+    _pendingReturnReward = null;
+
+    debugPrint('[ReturnRewards] Rewards applied: ${rewards.length} items');
+    return updatedState;
+  }
+
+  /// 단일 보상 적용 (내부)
+  GameState _applySingleReward(GameState state, ChestReward reward) {
+    switch (reward.type) {
+      case ChestRewardType.equipment:
+        return _applyEquipmentReward(state, reward);
+      case ChestRewardType.potion:
+        return _applyPotionReward(state, reward);
+      case ChestRewardType.gold:
+        return _applyGoldReward(state, reward);
+      case ChestRewardType.experience:
+        return _applyExperienceReward(state, reward);
+    }
+  }
+
+  /// 장비 보상 적용
+  GameState _applyEquipmentReward(GameState state, ChestReward reward) {
+    if (reward.equipment == null) return state;
+
+    // 현재 장비와 비교하여 더 좋으면 자동 장착
+    final slotIndex = reward.equipment!.slot.index;
+    final currentItem = state.equipment.getItemByIndex(slotIndex);
+
+    if (currentItem.isEmpty ||
+        reward.equipment!.itemWeight > currentItem.itemWeight) {
+      debugPrint('[ReturnRewards] Equipped: ${reward.equipment!.name}');
+      return state.copyWith(
+        equipment: state.equipment.setItemByIndex(slotIndex, reward.equipment!),
+      );
+    }
+
+    // 더 좋지 않으면 판매 (골드로 변환)
+    final sellPrice = (reward.equipment!.level * 50 * 0.3).round().clamp(
+      1,
+      99999,
+    );
+    debugPrint(
+      '[ReturnRewards] Sold: ${reward.equipment!.name} '
+      'for $sellPrice gold',
+    );
+    return state.copyWith(
+      inventory: state.inventory.copyWith(
+        gold: state.inventory.gold + sellPrice,
+      ),
+    );
+  }
+
+  /// 포션 보상 적용
+  GameState _applyPotionReward(GameState state, ChestReward reward) {
+    if (reward.potionId == null) return state;
+
+    debugPrint(
+      '[ReturnRewards] Added potion: ${reward.potionId} '
+      'x${reward.potionCount}',
+    );
+    return state.copyWith(
+      potionInventory: state.potionInventory.addPotion(
+        reward.potionId!,
+        reward.potionCount ?? 1,
+      ),
+    );
+  }
+
+  /// 골드 보상 적용
+  GameState _applyGoldReward(GameState state, ChestReward reward) {
+    if (reward.gold == null || reward.gold! <= 0) return state;
+
+    debugPrint('[ReturnRewards] Added gold: ${reward.gold}');
+    return state.copyWith(
+      inventory: state.inventory.copyWith(
+        gold: state.inventory.gold + reward.gold!,
+      ),
+    );
+  }
+
+  /// 경험치 보상 적용
+  GameState _applyExperienceReward(GameState state, ChestReward reward) {
+    if (reward.experience == null || reward.experience! <= 0) return state;
+
+    debugPrint('[ReturnRewards] Added experience: ${reward.experience}');
+    return state.copyWith(
+      progress: state.progress.copyWith(
+        exp: state.progress.exp.copyWith(
+          position: state.progress.exp.position + reward.experience!,
+        ),
+      ),
+    );
+  }
+
+  /// 복귀 보상 건너뛰기
+  void skipReturnReward() {
+    _pendingReturnReward = null;
+    debugPrint('[ReturnRewards] Reward skipped by user');
+  }
+}

lib/src/features/game/managers/speed_boost_manager.dart

@@ -0,0 +1,217 @@
+import 'package:asciineverdie/src/core/engine/ad_service.dart';
+import 'package:asciineverdie/src/core/engine/iap_service.dart';
+import 'package:asciineverdie/src/core/engine/progress_loop.dart';
+import 'package:asciineverdie/src/core/model/monetization_state.dart';
+import 'package:flutter/foundation.dart';
+
+/// 속도 부스트(광고 배속) 기능 관리자
+///
+/// 광고 시청 후 일정 시간 동안 게임 속도를 높이는 기능을 담당합니다.
+/// 게임 시간(elapsedMs) 기준으로 종료 시점을 판정합니다.
+class SpeedBoostManager {
+  SpeedBoostManager({
+    required bool Function() cheatsEnabledGetter,
+    required Future<List<int>> Function() getAvailableSpeeds,
+  }) : _cheatsEnabledGetter = cheatsEnabledGetter,
+       _getAvailableSpeeds = getAvailableSpeeds;
+
+  final bool Function() _cheatsEnabledGetter;
+  final Future<List<int>> Function() _getAvailableSpeeds;
+
+  // 속도 부스트 상태
+  bool _isSpeedBoostActive = false;
+  static const int _speedBoostDuration = 300; // 5분 (게임 시간 기준, 초)
+
+  // 광고 표시 중 플래그 (lifecycle reload 방지용)
+  bool _isShowingAd = false;
+  int _adEndTimeMs = 0; // 광고 종료 시점 (밀리초)
+
+  /// 배속 저장 (pause/resume 시 유지)
+  int savedSpeedMultiplier = 1;
+
+  /// 상태 변경 알림 콜백
+  VoidCallback? onStateChanged;
+
+  /// 광고 배속 배율 (릴리즈: 5x, 디버그빌드+디버그모드: 20x)
+  int get speedBoostMultiplier =>
+      (kDebugMode && _cheatsEnabledGetter()) ? 20 : 5;
+
+  /// 속도 부스트 활성화 여부
+  bool get isSpeedBoostActive => _isSpeedBoostActive;
+
+  /// 광고 표시 중 여부 (lifecycle reload 방지용)
+  bool get isShowingAd => _isShowingAd;
+
+  /// 최근 광고를 시청했는지 여부 (1초 이내)
+  bool get isRecentlyShowedAd {
+    if (_adEndTimeMs == 0) return false;
+    return DateTime.now().millisecondsSinceEpoch - _adEndTimeMs < 1000;
+  }
+
+  /// 속도 부스트 지속 시간 (초)
+  int get speedBoostDuration => _speedBoostDuration;
+
+  /// 속도 부스트 남은 시간 (초) - 게임 시간(elapsedMs) 기준 계산
+  int getRemainingSeconds(
+    MonetizationState monetization,
+    int currentElapsedMs,
+  ) {
+    if (!_isSpeedBoostActive) return 0;
+    final endMs = monetization.speedBoostEndMs;
+    if (endMs == null) return 0;
+    final remainingMs = endMs - currentElapsedMs;
+    return remainingMs > 0 ? (remainingMs / 1000).ceil() : 0;
+  }
+
+  /// 현재 실제 배속 (부스트 적용 포함)
+  int getCurrentSpeedMultiplier(ProgressLoop? loop) {
+    if (_isSpeedBoostActive) return speedBoostMultiplier;
+    return loop?.speedMultiplier ?? savedSpeedMultiplier;
+  }
+
+  /// 속도 부스트 활성화 (광고 시청 후)
+  ///
+  /// 유료 유저: 무료 활성화
+  /// 무료 유저: 인터스티셜 광고 시청 후 활성화
+  /// Returns: (활성화 성공 여부, 업데이트된 monetization)
+  Future<(bool, MonetizationState)> activateSpeedBoost({
+    required ProgressLoop? loop,
+    required MonetizationState monetization,
+    required int currentElapsedMs,
+  }) async {
+    if (_isSpeedBoostActive) return (false, monetization);
+    if (loop == null) return (false, monetization);
+
+    // 유료 유저는 무료 활성화
+    if (IAPService.instance.isAdRemovalPurchased) {
+      final updatedMonetization = _startSpeedBoost(
+        loop: loop,
+        monetization: monetization,
+        currentElapsedMs: currentElapsedMs,
+      );
+      debugPrint('[SpeedBoost] Activated (paid user)');
+      return (true, updatedMonetization);
+    }
+
+    // 무료 유저는 인터스티셜 광고 필요
+    MonetizationState updatedMonetization = monetization;
+    bool activated = false;
+    _isShowingAd = true;
+
+    final adResult = await AdService.instance.showInterstitialAd(
+      adType: AdType.interstitialSpeed,
+      onComplete: () {
+        updatedMonetization = _startSpeedBoost(
+          loop: loop,
+          monetization: monetization,
+          currentElapsedMs: currentElapsedMs,
+        );
+        activated = true;
+      },
+    );
+
+    _isShowingAd = false;
+    _adEndTimeMs = DateTime.now().millisecondsSinceEpoch;
+
+    if (adResult == AdResult.completed || adResult == AdResult.debugSkipped) {
+      debugPrint('[SpeedBoost] Activated (free user with ad)');
+      return (activated, updatedMonetization);
+    }
+
+    debugPrint('[SpeedBoost] Activation failed: $adResult');
+    return (false, monetization);
+  }
+
+  /// 속도 부스트 시작 (내부)
+  MonetizationState _startSpeedBoost({
+    required ProgressLoop? loop,
+    required MonetizationState monetization,
+    required int currentElapsedMs,
+  }) {
+    _isSpeedBoostActive = true;
+
+    // loop가 있으면 현재 배속 저장 및 즉시 적용
+    if (loop != null) {
+      savedSpeedMultiplier = loop.speedMultiplier;
+      loop.updateAvailableSpeeds([speedBoostMultiplier]);
+    }
+
+    // 종료 시점 저장 (게임 시간 기준)
+    final endMs = currentElapsedMs + (_speedBoostDuration * 1000);
+    final updatedMonetization = monetization.copyWith(speedBoostEndMs: endMs);
+
+    debugPrint('[SpeedBoost] Started, ends at $endMs ms');
+    onStateChanged?.call();
+
+    return updatedMonetization;
+  }
+
+  /// 매 틱마다 부스트 만료 체크
+  ///
+  /// Returns: 부스트가 종료되었으면 true
+  bool checkExpiry({
+    required int elapsedMs,
+    required MonetizationState monetization,
+    required ProgressLoop? loop,
+  }) {
+    if (!_isSpeedBoostActive) return false;
+
+    final endMs = monetization.speedBoostEndMs;
+    if (endMs != null && elapsedMs >= endMs) {
+      endSpeedBoost(loop: loop);
+      return true;
+    }
+    return false;
+  }
+
+  /// 속도 부스트 종료 (외부 호출 가능)
+  void endSpeedBoost({required ProgressLoop? loop}) {
+    _isSpeedBoostActive = false;
+
+    // 원래 배속 복원
+    if (loop != null) {
+      final savedSpeed = savedSpeedMultiplier;
+
+      _getAvailableSpeeds().then((speeds) {
+        loop.updateAvailableSpeeds(speeds);
+        loop.setSpeed(savedSpeed);
+        debugPrint('[SpeedBoost] Speed restored to ${savedSpeed}x');
+      });
+    }
+
+    onStateChanged?.call();
+    debugPrint('[SpeedBoost] Ended');
+  }
+
+  /// 속도 부스트 수동 취소
+  ///
+  /// Returns: 업데이트된 monetization
+  MonetizationState cancelSpeedBoost({
+    required ProgressLoop? loop,
+    required MonetizationState monetization,
+  }) {
+    if (_isSpeedBoostActive) {
+      endSpeedBoost(loop: loop);
+    }
+    return monetization.copyWith(speedBoostEndMs: null);
+  }
+
+  /// 부스트 상태에 따른 초기 배속 설정 계산
+  ///
+  /// startNew() 호출 시 사용
+  ({List<int> speeds, int initialSpeed}) calculateInitialSpeeds({
+    required List<int> baseAvailableSpeeds,
+    required int baseSpeed,
+  }) {
+    if (_isSpeedBoostActive) {
+      // 부스트 상태: 부스트 배속만 사용, 기본 배속 저장
+      savedSpeedMultiplier = baseSpeed;
+      return (
+        speeds: [speedBoostMultiplier],
+        initialSpeed: speedBoostMultiplier,
+      );
+    }
+    // 일반 상태: 기본 배속 사용
+    return (speeds: baseAvailableSpeeds, initialSpeed: baseSpeed);
+  }
+}

lib/src/features/game/pages/character_sheet_page.dart

@@ -1,7 +1,7 @@
 import 'package:flutter/material.dart';
 
 import 'package:asciineverdie/l10n/app_localizations.dart';
-import 'package:asciineverdie/src/core/l10n/game_data_l10n.dart';
+import 'package:asciineverdie/src/shared/l10n/game_data_l10n.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/features/game/widgets/stats_panel.dart';
 

lib/src/features/game/pages/inventory_page.dart

@@ -2,7 +2,7 @@ import 'package:flutter/material.dart';
 
 import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
 import 'package:asciineverdie/l10n/app_localizations.dart';
-import 'package:asciineverdie/src/core/l10n/game_data_l10n.dart';
+import 'package:asciineverdie/src/shared/l10n/game_data_l10n.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/potion.dart';
 import 'package:asciineverdie/src/features/game/widgets/potion_inventory_panel.dart';
@@ -37,9 +37,7 @@ class InventoryPage extends StatelessWidget {
         _buildSectionHeader(context, l10n.uiPotions),
         Expanded(
           flex: 2,
-          child: PotionInventoryPanel(
-            inventory: potionInventory,
-          ),
+          child: PotionInventoryPanel(inventory: potionInventory),
         ),
 
         // 무게 (Encumbrance)

lib/src/features/game/pages/skills_page.dart

@@ -3,7 +3,7 @@ import 'package:flutter/material.dart';
 import 'package:asciineverdie/data/game_text_l10n.dart' as l10n;
 import 'package:asciineverdie/data/skill_data.dart';
 import 'package:asciineverdie/l10n/app_localizations.dart';
-import 'package:asciineverdie/src/core/l10n/game_data_l10n.dart';
+import 'package:asciineverdie/src/shared/l10n/game_data_l10n.dart';
 import 'package:asciineverdie/src/core/model/game_state.dart';
 import 'package:asciineverdie/src/core/model/skill.dart';
 import 'package:asciineverdie/src/features/game/widgets/active_buff_panel.dart';
@@ -147,7 +147,11 @@ class _SkillTile extends StatelessWidget {
           if (isOnCooldown)
             const Padding(
               padding: EdgeInsets.only(right: 8),
-              child: Icon(Icons.hourglass_empty, size: 14, color: Colors.orange),
+              child: Icon(
+                Icons.hourglass_empty,
+                size: 14,
+                color: Colors.orange,
+              ),
             ),
           _RankBadge(rank: rank),
         ],
@@ -273,10 +277,12 @@ class _SkillStatsGrid extends StatelessWidget {
 
     // 공통: MP, 쿨타임
     entries.add(_StatEntry(l10n.skillMpCost, '${skill.mpCost}'));
-    entries.add(_StatEntry(
-      l10n.skillCooldown,
-      '${(skill.cooldownMs / 1000).toStringAsFixed(1)}${l10n.skillSeconds}',
-    ));
+    entries.add(
+      _StatEntry(
+        l10n.skillCooldown,
+        '${(skill.cooldownMs / 1000).toStringAsFixed(1)}${l10n.skillSeconds}',
+      ),
+    );
 
     // 타입별 스탯 추가
     switch (skill.type) {
@@ -309,33 +315,40 @@ class _SkillStatsGrid extends StatelessWidget {
 
     // DOT 정보
     if (skill.isDot && skill.baseDotDamage != null) {
-      final dotDps = skill.baseDotDamage! *
+      final dotDps =
+          skill.baseDotDamage! *
           (skill.baseDotDurationMs! / skill.baseDotTickMs!);
       entries.add(_StatEntry(l10n.skillDot, '${dotDps.round()}'));
     }
 
     // HP 흡수
     if (skill.lifestealPercent > 0) {
-      entries.add(_StatEntry(
-        l10n.skillLifesteal,
-        '${(skill.lifestealPercent * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillLifesteal,
+          '${(skill.lifestealPercent * 100).round()}%',
+        ),
+      );
     }
 
     // 방어 무시
     if (skill.targetDefReduction > 0) {
-      entries.add(_StatEntry(
-        l10n.skillDefPen,
-        '${(skill.targetDefReduction * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillDefPen,
+          '${(skill.targetDefReduction * 100).round()}%',
+        ),
+      );
     }
 
     // 자해 데미지
     if (skill.selfDamagePercent > 0) {
-      entries.add(_StatEntry(
-        l10n.skillSelfDmg,
-        '${(skill.selfDamagePercent * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillSelfDmg,
+          '${(skill.selfDamagePercent * 100).round()}%',
+        ),
+      );
     }
   }
 
@@ -347,10 +360,12 @@ class _SkillStatsGrid extends StatelessWidget {
 
     // % 회복
     if (skill.healPercent > 0) {
-      entries.add(_StatEntry(
-        l10n.skillHealPercent,
-        '${(skill.healPercent * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillHealPercent,
+          '${(skill.healPercent * 100).round()}%',
+        ),
+      );
     }
 
     // MP 회복
@@ -361,10 +376,12 @@ class _SkillStatsGrid extends StatelessWidget {
     // 부가 버프
     if (skill.buff != null) {
       final buff = skill.buff!;
-      entries.add(_StatEntry(
-        l10n.skillBuffDuration,
-        '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillBuffDuration,
+          '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
+        ),
+      );
     }
   }
 
@@ -373,39 +390,49 @@ class _SkillStatsGrid extends StatelessWidget {
     final buff = skill.buff!;
 
     // 지속시간
-    entries.add(_StatEntry(
-      l10n.skillBuffDuration,
-      '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
-    ));
+    entries.add(
+      _StatEntry(
+        l10n.skillBuffDuration,
+        '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
+      ),
+    );
 
     // 각 보정치
     if (buff.atkModifier != 0) {
       final sign = buff.atkModifier > 0 ? '+' : '';
-      entries.add(_StatEntry(
-        l10n.skillAtkMod,
-        '$sign${(buff.atkModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillAtkMod,
+          '$sign${(buff.atkModifier * 100).round()}%',
+        ),
+      );
     }
     if (buff.defModifier != 0) {
       final sign = buff.defModifier > 0 ? '+' : '';
-      entries.add(_StatEntry(
-        l10n.skillDefMod,
-        '$sign${(buff.defModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillDefMod,
+          '$sign${(buff.defModifier * 100).round()}%',
+        ),
+      );
     }
     if (buff.criRateModifier != 0) {
       final sign = buff.criRateModifier > 0 ? '+' : '';
-      entries.add(_StatEntry(
-        l10n.skillCriMod,
-        '$sign${(buff.criRateModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillCriMod,
+          '$sign${(buff.criRateModifier * 100).round()}%',
+        ),
+      );
     }
     if (buff.evasionModifier != 0) {
       final sign = buff.evasionModifier > 0 ? '+' : '';
-      entries.add(_StatEntry(
-        l10n.skillEvaMod,
-        '$sign${(buff.evasionModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(
+          l10n.skillEvaMod,
+          '$sign${(buff.evasionModifier * 100).round()}%',
+        ),
+      );
     }
   }
 
@@ -414,23 +441,23 @@ class _SkillStatsGrid extends StatelessWidget {
     final buff = skill.buff!;
 
     // 지속시간
-    entries.add(_StatEntry(
-      l10n.skillBuffDuration,
-      '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
-    ));
+    entries.add(
+      _StatEntry(
+        l10n.skillBuffDuration,
+        '${(buff.durationMs / 1000).round()}${l10n.skillSeconds}',
+      ),
+    );
 
     // 디버프 효과 (보통 음수)
     if (buff.atkModifier != 0) {
-      entries.add(_StatEntry(
-        l10n.skillAtkMod,
-        '${(buff.atkModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(l10n.skillAtkMod, '${(buff.atkModifier * 100).round()}%'),
+      );
     }
     if (buff.defModifier != 0) {
-      entries.add(_StatEntry(
-        l10n.skillDefMod,
-        '${(buff.defModifier * 100).round()}%',
-      ));
+      entries.add(
+        _StatEntry(l10n.skillDefMod, '${(buff.defModifier * 100).round()}%'),
+      );
     }
   }
 }