julian/asciinevrdie
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: 초기 커밋

Browse Source 
- Progress Quest 6.4 Flutter 포팅 프로젝트
- 게임 루프, 상태 관리, UI 구현
- 캐릭터 생성, 인벤토리, 장비, 주문 시스템
- 시장/판매/구매 메커니즘
This commit is contained in:
JiWoong Sul
2025-12-09 17:24:04 +09:00
commit 08054d97c1
168 changed files with 12876 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
test/core/engine/progress_loop_test.dart Normal file
View File

@@ -0,0 +1,100 @@
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/progress_loop.dart';
import 'package:askiineverdie/src/core/engine/progress_service.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/storage/save_manager.dart';
import 'package:askiineverdie/src/core/storage/save_repository.dart';
import 'package:askiineverdie/src/core/storage/save_service.dart';
import 'package:flutter_test/flutter_test.dart';
class _FakeSaveManager implements SaveManager {
final List<GameState> savedStates = [];
@override
Future<SaveOutcome> saveState(GameState state, {String? fileName}) async {
savedStates.add(state);
return const SaveOutcome.success();
}
@override
Future<(SaveOutcome, GameState?)> loadState({String? fileName}) async {
return (const SaveOutcome.success(), null);
}
@override
Future<List<SaveFileInfo>> listSaves() async => [];
}
void main() {
late ProgressService service;
setUp(() {
const config = PqConfig();
final mutations = GameMutations(config);
service = ProgressService(
config: config,
mutations: mutations,
rewards: RewardService(mutations),
);
});
test('autosaves on level-up and stop when configured', () async {
final saveManager = _FakeSaveManager();
final initial = GameState.withSeed(
seed: 123,
traits: const Traits(
name: 'LoopHero',
race: 'Orc',
klass: 'Warrior',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 8,
con: 7,
dex: 6,
intelligence: 5,
wis: 4,
cha: 3,
hpMax: 9,
mpMax: 8,
),
progress: const ProgressState(
task: ProgressBarState(position: 1200, max: 1200),
quest: ProgressBarState(position: 0, max: 10),
plot: ProgressBarState(position: 0, max: 10),
exp: ProgressBarState(position: 3, max: 3),
encumbrance: ProgressBarState(position: 0, max: 0),
currentTask: TaskInfo(caption: 'Battle', type: TaskType.kill),
plotStageCount: 1,
questCount: 0,
),
);
final loop = ProgressLoop(
initialState: initial,
progressService: service,
saveManager: saveManager,
autoSaveConfig: const AutoSaveConfig(
onLevelUp: true,
onQuestComplete: true,
onActComplete: true,
onStop: true,
),
now: () => DateTime.fromMillisecondsSinceEpoch(0),
);
final updated = loop.tickOnce(deltaMillis: 50);
expect(saveManager.savedStates.length, 1);
expect(updated.traits.level, 2);
await loop.stop(saveOnStop: true);
expect(saveManager.savedStates.length, 2);
expect(saveManager.savedStates.last, same(updated));
});
}

158
test/core/engine/progress_service_test.dart Normal file
View File

@@ -0,0 +1,158 @@
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/progress_service.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/util/pq_logic.dart' as pq_logic;
import 'package:flutter_test/flutter_test.dart';
void main() {
late ProgressService service;
late PqConfig config;
setUp(() {
config = const PqConfig();
final mutations = GameMutations(config);
service = ProgressService(
config: config,
mutations: mutations,
rewards: RewardService(mutations),
);
});
test('tick advances task bar and recalculates encumbrance', () {
final state = GameState.withSeed(
seed: 42,
stats: const Stats(
str: 5,
con: 0,
dex: 0,
intelligence: 0,
wis: 0,
cha: 0,
hpMax: 0,
mpMax: 0,
),
inventory: const Inventory(
gold: 5,
items: [
InventoryEntry(name: 'Rock', count: 3),
],
),
progress: const ProgressState(
task: ProgressBarState(position: 0, max: 80),
quest: ProgressBarState(position: 0, max: 10),
plot: ProgressBarState(position: 0, max: 10),
exp: ProgressBarState(position: 0, max: 50),
encumbrance: ProgressBarState(position: 0, max: 0),
currentTask: TaskInfo(caption: 'Test', type: TaskType.kill),
plotStageCount: 1,
questCount: 0,
),
);
final result = service.tick(state, 150);
expect(result.leveledUp, isFalse);
expect(result.completedQuest, isFalse);
expect(result.completedAct, isFalse);
expect(result.state.progress.task.position, 80);
expect(result.state.progress.task.max, 80);
expect(result.state.progress.encumbrance.position, 3);
expect(result.state.progress.encumbrance.max, 15);
expect(result.state.progress.currentTask.caption, 'Test');
});
test('tick levels up when EXP is full during kill task', () {
final initial = GameState.withSeed(
seed: 7,
traits: const Traits(
name: 'Hero',
race: 'Human',
klass: 'Fighter',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 10,
con: 9,
dex: 8,
intelligence: 7,
wis: 6,
cha: 5,
hpMax: 10,
mpMax: 11,
),
progress: const ProgressState(
task: ProgressBarState(position: 1000, max: 1000),
quest: ProgressBarState(position: 0, max: 10),
plot: ProgressBarState(position: 0, max: 10),
exp: ProgressBarState(position: 5, max: 5),
encumbrance: ProgressBarState(position: 0, max: 0),
currentTask: TaskInfo(caption: 'Battle', type: TaskType.kill),
plotStageCount: 1,
questCount: 0,
),
);
final result = service.tick(initial, 50);
expect(result.leveledUp, isTrue);
expect(result.shouldAutosave, isTrue);
expect(result.state.traits.level, 2);
expect(result.state.stats.hpMax, greaterThan(initial.stats.hpMax));
expect(result.state.stats.mpMax, greaterThan(initial.stats.mpMax));
expect(result.state.progress.exp.position, 0);
expect(result.state.progress.exp.max, pq_logic.levelUpTime(2));
// 태스크 완료 후 새 태스크가 자동으로 시작됨
expect(result.state.progress.task.position, 0);
expect(result.state.progress.task.max, greaterThan(0));
});
test('quest completion enqueues next task and resets quest bar', () {
final initial = GameState.withSeed(
seed: 99,
traits: const Traits(
name: 'Questor',
race: 'Elf',
klass: 'Mage',
level: 3,
motto: '',
guild: '',
),
stats: const Stats(
str: 4,
con: 5,
dex: 6,
intelligence: 7,
wis: 8,
cha: 9,
hpMax: 12,
mpMax: 10,
),
progress: const ProgressState(
task: ProgressBarState(position: 2000, max: 2000),
quest: ProgressBarState(position: 4, max: 5),
plot: ProgressBarState(position: 0, max: 20),
exp: ProgressBarState(position: 0, max: 30),
encumbrance: ProgressBarState(position: 0, max: 0),
currentTask: TaskInfo(caption: 'Hunt', type: TaskType.kill),
plotStageCount: 2,
questCount: 1,
),
queue: QueueState(entries: const []),
);
final result = service.tick(initial, 50);
final nextState = result.state;
expect(result.completedQuest, isTrue);
expect(nextState.progress.questCount, 2);
expect(nextState.progress.quest.position, 0);
expect(nextState.progress.quest.max, inInclusiveRange(50, 149));
expect(nextState.progress.currentTask.type, TaskType.neutral);
expect(nextState.progress.task.position, 0);
expect(nextState.queue.entries, isEmpty);
});
}

245
test/core/util/pq_logic_test.dart Normal file
View File

@@ -0,0 +1,245 @@
import 'package:askiineverdie/src/core/model/equipment_slot.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/util/deterministic_random.dart';
import 'package:askiineverdie/src/core/util/pq_logic.dart' as pq_logic;
import 'package:flutter_test/flutter_test.dart';
void main() {
const config = PqConfig();
test('levelUpTime grows with level and matches expected seconds', () {
expect(pq_logic.levelUpTime(1), 1269);
expect(pq_logic.levelUpTime(10), 1443);
});
test('roughTime formats seconds into human-readable strings', () {
// < 120초: seconds
expect(pq_logic.roughTime(60), '60 seconds');
expect(pq_logic.roughTime(119), '119 seconds');
// 120초 ~ 2시간: minutes
expect(pq_logic.roughTime(120), '2 minutes');
expect(pq_logic.roughTime(3600), '60 minutes');
expect(pq_logic.roughTime(7199), '119 minutes');
// 2시간 ~ 48시간: hours
expect(pq_logic.roughTime(7200), '2 hours');
expect(pq_logic.roughTime(86400), '24 hours');
expect(pq_logic.roughTime(172799), '47 hours');
// 48시간 이상: days
expect(pq_logic.roughTime(172800), '2 days');
expect(pq_logic.roughTime(604800), '7 days');
});
test('generateName produces deterministic names per seed', () {
expect(pq_logic.generateName(DeterministicRandom(123)), 'Grunax');
expect(pq_logic.generateName(DeterministicRandom(42)), 'Bregpran');
});
test('indefinite/definite/pluralize honor English rules', () {
expect(pq_logic.indefinite('apple', 1), 'an apple');
expect(pq_logic.indefinite('orc', 3), '3 orcs');
expect(pq_logic.definite('goblin', 2), 'the goblins');
expect(pq_logic.pluralize('baby'), 'babies');
});
test('item and reward helpers are deterministic with seed', () {
expect(pq_logic.boringItem(config, DeterministicRandom(12)), 'egg');
expect(
pq_logic.interestingItem(config, DeterministicRandom(12)),
'Golden Ornament',
);
expect(
pq_logic.specialItem(config, DeterministicRandom(12)),
'Golden Ornament of Efficiency',
);
// 원본 Main.pas:770-774 RandomLow 방식으로 수정됨
expect(
pq_logic.winSpell(config, DeterministicRandom(22), 7, 4),
'Slime Finger|II',
);
expect(
pq_logic.winEquip(
config,
DeterministicRandom(12),
5,
EquipmentSlot.weapon,
),
'Baselard',
);
expect(
pq_logic.winEquip(
config,
DeterministicRandom(15),
2,
EquipmentSlot.armor,
),
'-2 Canvas',
);
expect(
pq_logic.winItem(config, DeterministicRandom(10), 3),
'Golden Hymnal of Cruelty',
);
expect(pq_logic.winItem(config, DeterministicRandom(10), 1000), isEmpty);
});
test('monsterTask picks level-appropriate monsters with modifiers', () {
expect(
pq_logic.monsterTask(config, DeterministicRandom(99), 5, null, null),
'an underage Rakshasa',
);
expect(
pq_logic.monsterTask(config, DeterministicRandom(7), 10, null, null),
'a greater Sphinx',
);
expect(
pq_logic.monsterTask(config, DeterministicRandom(5), 6, 'Goblin|3', 3),
'a Barbed Devil',
);
});
test('completeQuest and completeAct return deterministic results', () {
final quest = pq_logic.completeQuest(config, DeterministicRandom(33), 4);
expect(quest.caption, 'Deliver this chicken');
expect(quest.reward, pq_logic.RewardKind.item);
expect(quest.monsterName, isNull);
final act2 = pq_logic.completeAct(2);
expect(act2.actTitle, 'Act II');
expect(act2.plotBarMaxSeconds, 39600);
expect(act2.rewards, contains(pq_logic.RewardKind.item));
expect(act2.rewards, isNot(contains(pq_logic.RewardKind.equip)));
final act3 = pq_logic.completeAct(3);
expect(
act3.rewards,
containsAll(<pq_logic.RewardKind>{
pq_logic.RewardKind.item,
pq_logic.RewardKind.equip,
}),
);
});
test('dequeue starts next task and drains queue', () {
const progress = ProgressState(
task: ProgressBarState(position: 100, max: 100),
quest: ProgressBarState(position: 0, max: 10),
plot: ProgressBarState(position: 0, max: 10),
exp: ProgressBarState(position: 0, max: 10),
encumbrance: ProgressBarState(position: 0, max: 1),
currentTask: TaskInfo(caption: 'Idle', type: TaskType.neutral),
plotStageCount: 1,
questCount: 0,
);
final queue = QueueState(
entries: const [
QueueEntry(
kind: QueueKind.task,
durationMillis: 120,
caption: 'Fight',
taskType: TaskType.kill,
),
QueueEntry(
kind: QueueKind.plot,
durationMillis: 80,
caption: 'Plot',
taskType: TaskType.plot,
),
],
);
final result = pq_logic.dequeue(progress, queue);
expect(result, isNotNull);
expect(result!.caption, 'Fight...');
expect(result.taskType, TaskType.kill);
expect(result.kind, QueueKind.task);
expect(result.progress.task.position, 0);
expect(result.progress.task.max, 120);
expect(result.queue.entries.length, 1);
expect(result.queue.entries.first.kind, QueueKind.plot);
});
test('impressiveGuy generates deterministic NPC titles', () {
// case 0: "the King of the Elves" 형태
final guy1 = pq_logic.impressiveGuy(config, DeterministicRandom(42));
expect(guy1, contains('of the'));
// case 1: "King Vrognak of Zoxzik" 형태
final guy2 = pq_logic.impressiveGuy(config, DeterministicRandom(7));
expect(guy2, contains(' of '));
// 결정적(deterministic) 결과 확인
expect(
pq_logic.impressiveGuy(config, DeterministicRandom(100)),
pq_logic.impressiveGuy(config, DeterministicRandom(100)),
);
});
test('namedMonster generates named monster with level matching', () {
final monster = pq_logic.namedMonster(config, DeterministicRandom(42), 10);
// "GeneratedName the MonsterType" 형태
expect(monster, contains(' the '));
// 결정적(deterministic) 결과 확인
expect(
pq_logic.namedMonster(config, DeterministicRandom(50), 5),
pq_logic.namedMonster(config, DeterministicRandom(50), 5),
);
});
test('interplotCinematic generates queue entries with plot ending', () {
final entries = pq_logic.interplotCinematic(
config,
DeterministicRandom(42),
10,
3,
);
// 최소 1개 이상의 엔트리 생성
expect(entries, isNotEmpty);
// 마지막은 항상 plot 타입의 'Loading'
expect(entries.last.kind, QueueKind.plot);
expect(entries.last.caption, 'Loading');
expect(entries.last.durationMillis, 2000);
// 나머지는 task 타입
for (var i = 0; i < entries.length - 1; i++) {
expect(entries[i].kind, QueueKind.task);
}
});
test('interplotCinematic has three distinct scenarios', () {
// 여러 시드를 테스트해서 3가지 시나리오가 모두 나오는지 확인
final scenariosFound = <String>{};
for (var seed = 0; seed < 100; seed++) {
final entries = pq_logic.interplotCinematic(
config,
DeterministicRandom(seed),
5,
1,
);
final firstCaption = entries.first.caption;
if (firstCaption.contains('oasis')) {
scenariosFound.add('oasis');
// 오아시스 시나리오: 4개 task + 1개 plot = 5개
expect(entries.length, 5);
} else if (firstCaption.contains('quarry')) {
scenariosFound.add('combat');
// 전투 시나리오: 가변 길이 (combatRounds에 따라)
expect(entries.length, greaterThanOrEqualTo(5));
} else if (firstCaption.contains('sweet relief')) {
scenariosFound.add('betrayal');
// 배신 시나리오: 6개 task + 1개 plot = 7개
expect(entries.length, 7);
}
}
// 3가지 시나리오가 모두 발견되어야 함
expect(scenariosFound, containsAll(['oasis', 'combat', 'betrayal']));
});
}

199
test/features/game_play_screen_test.dart Normal file
View File

@@ -0,0 +1,199 @@
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/progress_service.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/storage/save_manager.dart';
import 'package:askiineverdie/src/core/storage/save_repository.dart';
import 'package:askiineverdie/src/core/storage/save_service.dart';
import 'package:askiineverdie/src/features/game/game_play_screen.dart';
import 'package:askiineverdie/src/features/game/game_session_controller.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
class _FakeSaveManager implements SaveManager {
@override
Future<SaveOutcome> saveState(GameState state, {String? fileName}) async {
return const SaveOutcome.success();
}
@override
Future<(SaveOutcome, GameState?)> loadState({String? fileName}) async {
return (const SaveOutcome.success(), null);
}
@override
Future<List<SaveFileInfo>> listSaves() async => [];
}
GameState _createTestState() {
return GameState.withSeed(
seed: 42,
traits: const Traits(
name: 'TestHero',
race: 'Elf',
klass: 'Mage',
level: 5,
motto: 'Test Motto',
guild: '',
),
stats: const Stats(
str: 10,
con: 12,
dex: 14,
intelligence: 16,
wis: 11,
cha: 9,
hpMax: 50,
mpMax: 40,
),
progress: const ProgressState(
task: ProgressBarState(position: 500, max: 1000),
quest: ProgressBarState(position: 300, max: 600),
plot: ProgressBarState(position: 1800, max: 3600),
exp: ProgressBarState(position: 500, max: 1500),
encumbrance: ProgressBarState(position: 5, max: 20),
currentTask: TaskInfo(caption: 'Battling a Goblin', type: TaskType.kill),
plotStageCount: 2,
questCount: 3,
),
);
}
GameSessionController _createController() {
const config = PqConfig();
final mutations = GameMutations(config);
return GameSessionController(
progressService: ProgressService(
config: config,
mutations: mutations,
rewards: RewardService(mutations),
),
saveManager: _FakeSaveManager(),
tickInterval: const Duration(seconds: 10), // 느린 틱
);
}
void main() {
testWidgets('GamePlayScreen renders 3-panel layout', (tester) async {
final controller = _createController();
addTearDown(() async {
await controller.pause(saveOnStop: false);
controller.dispose();
});
await controller.startNew(_createTestState(), isNewGame: false);
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// AppBar 타이틀 확인
expect(find.text('Progress Quest - TestHero'), findsOneWidget);
// 3패널 헤더 확인
expect(find.text('Character Sheet'), findsOneWidget);
expect(find.text('Equipment'), findsOneWidget);
expect(find.text('Plot Development'), findsOneWidget);
expect(find.text('Quests'), findsOneWidget);
// 테스트 완료 후 정리
await controller.pause(saveOnStop: false);
});
testWidgets('GamePlayScreen shows character traits', (tester) async {
final controller = _createController();
addTearDown(() async {
await controller.pause(saveOnStop: false);
controller.dispose();
});
await controller.startNew(_createTestState(), isNewGame: false);
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// Traits 섹션 확인
expect(find.text('Traits'), findsOneWidget);
expect(find.text('TestHero'), findsOneWidget);
expect(find.text('Elf'), findsOneWidget);
expect(find.text('Mage'), findsOneWidget);
await controller.pause(saveOnStop: false);
});
testWidgets('GamePlayScreen shows stats', (tester) async {
final controller = _createController();
addTearDown(() async {
await controller.pause(saveOnStop: false);
controller.dispose();
});
await controller.startNew(_createTestState(), isNewGame: false);
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// Stats 섹션 확인
expect(find.text('Stats'), findsOneWidget);
expect(find.text('STR'), findsOneWidget);
expect(find.text('CON'), findsOneWidget);
await controller.pause(saveOnStop: false);
});
testWidgets('GamePlayScreen shows current task caption', (tester) async {
final controller = _createController();
addTearDown(() async {
await controller.pause(saveOnStop: false);
controller.dispose();
});
await controller.startNew(_createTestState(), isNewGame: false);
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// 현재 태스크 캡션 확인 (퀘스트 목록과 하단 패널에 표시됨)
expect(find.text('Battling a Goblin'), findsAtLeast(1));
await controller.pause(saveOnStop: false);
});
testWidgets('GamePlayScreen shows progress bars', (tester) async {
final controller = _createController();
addTearDown(() async {
await controller.pause(saveOnStop: false);
controller.dispose();
});
await controller.startNew(_createTestState(), isNewGame: false);
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// LinearProgressIndicator가 여러 개 표시되는지 확인
expect(find.byType(LinearProgressIndicator), findsAtLeast(4));
await controller.pause(saveOnStop: false);
});
testWidgets('Loading state shows CircularProgressIndicator', (tester) async {
final controller = _createController();
addTearDown(() {
controller.dispose();
});
// 상태 없이 시작 (startNew 호출 안 함)
await tester.pumpWidget(
MaterialApp(home: GamePlayScreen(controller: controller)),
);
// 로딩 인디케이터 확인
expect(find.byType(CircularProgressIndicator), findsOneWidget);
});
}

143
test/features/game_session_controller_test.dart Normal file
View File

@@ -0,0 +1,143 @@
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/progress_service.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/storage/save_manager.dart';
import 'package:askiineverdie/src/core/storage/save_repository.dart';
import 'package:askiineverdie/src/core/storage/save_service.dart';
import 'package:askiineverdie/src/features/game/game_session_controller.dart';
import 'package:fake_async/fake_async.dart';
import 'package:flutter_test/flutter_test.dart';
class FakeSaveManager implements SaveManager {
final List<GameState> savedStates = [];
(SaveOutcome, GameState?) Function(String?)? onLoad;
SaveOutcome saveOutcome = const SaveOutcome.success();
@override
Future<SaveOutcome> saveState(GameState state, {String? fileName}) async {
savedStates.add(state);
return saveOutcome;
}
@override
Future<(SaveOutcome, GameState?)> loadState({String? fileName}) async {
if (onLoad != null) {
return onLoad!(fileName);
}
return (const SaveOutcome.success(), null);
}
@override
Future<List<SaveFileInfo>> listSaves() async => [];
}
void main() {
const config = PqConfig();
final mutations = GameMutations(config);
final progressService = ProgressService(
config: config,
mutations: mutations,
rewards: RewardService(mutations),
);
GameSessionController buildController(
FakeAsync async,
FakeSaveManager saveManager,
) {
return GameSessionController(
progressService: progressService,
saveManager: saveManager,
tickInterval: const Duration(milliseconds: 10),
now: () =>
DateTime.fromMillisecondsSinceEpoch(async.elapsed.inMilliseconds),
);
}
GameState sampleState() {
return GameState.withSeed(
seed: 1,
traits: const Traits(
name: 'Hero',
race: 'Human',
klass: 'Fighter',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 5,
con: 5,
dex: 5,
intelligence: 5,
wis: 5,
cha: 5,
hpMax: 10,
mpMax: 8,
),
progress: const ProgressState(
task: ProgressBarState(position: 0, max: 50),
quest: ProgressBarState(position: 0, max: 1000),
plot: ProgressBarState(position: 0, max: 1000),
exp: ProgressBarState(position: 0, max: 9999),
encumbrance: ProgressBarState(position: 0, max: 1),
currentTask: TaskInfo(caption: 'Battle', type: TaskType.kill),
plotStageCount: 1,
questCount: 0,
),
);
}
test('startNew runs loop and publishes state updates', () {
fakeAsync((async) {
final saveManager = FakeSaveManager();
final controller = buildController(async, saveManager);
controller.startNew(sampleState(), isNewGame: false);
async.flushMicrotasks();
expect(controller.status, GameSessionStatus.running);
expect(controller.state, isNotNull);
async.elapse(const Duration(milliseconds: 30));
async.flushMicrotasks();
expect(controller.state!.progress.task.position, greaterThan(0));
controller.pause();
async.flushMicrotasks();
expect(controller.status, GameSessionStatus.idle);
});
});
test('loadAndStart surfaces save load errors', () {
fakeAsync((async) {
final saveManager = FakeSaveManager()
..onLoad = (_) => (const SaveOutcome.failure('boom'), null);
final controller = buildController(async, saveManager);
controller.loadAndStart(fileName: 'bad.pqf');
async.flushMicrotasks();
expect(controller.status, GameSessionStatus.error);
expect(controller.error, 'boom');
});
});
test('pause saves on stop when requested', () {
fakeAsync((async) {
final saveManager = FakeSaveManager();
final controller = buildController(async, saveManager);
controller.startNew(sampleState(), isNewGame: false);
async.flushMicrotasks();
controller.pause(saveOnStop: true);
async.flushMicrotasks();
expect(controller.status, GameSessionStatus.idle);
expect(saveManager.savedStates.length, 1);
});
});
}

107
test/features/new_character_screen_test.dart Normal file
View File

@@ -0,0 +1,107 @@
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/features/new_character/new_character_screen.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
void main() {
testWidgets('NewCharacterScreen renders main sections', (tester) async {
await tester.pumpWidget(
MaterialApp(home: NewCharacterScreen(onCharacterCreated: (_) {})),
);
// 화면 타이틀 확인
expect(find.text('Progress Quest - New Character'), findsOneWidget);
// 종족 섹션 확인
expect(find.text('Race'), findsOneWidget);
// 직업 섹션 확인
expect(find.text('Class'), findsOneWidget);
// 능력치 섹션 확인
expect(find.text('Stats'), findsOneWidget);
expect(find.text('STR'), findsOneWidget);
expect(find.text('CON'), findsOneWidget);
// Sold! 버튼 확인
expect(find.text('Sold!'), findsOneWidget);
});
testWidgets('Unroll button exists and can be tapped', (tester) async {
await tester.pumpWidget(
MaterialApp(home: NewCharacterScreen(onCharacterCreated: (_) {})),
);
// Unroll 버튼 확인
final unrollButton = find.text('Unroll');
expect(unrollButton, findsOneWidget);
// Unroll 버튼 탭
await tester.tap(unrollButton);
await tester.pump();
// Total이 표시되는지 확인
expect(find.textContaining('Total'), findsOneWidget);
});
testWidgets('Sold button creates character with generated name', (
tester,
) async {
GameState? createdState;
await tester.pumpWidget(
MaterialApp(
home: NewCharacterScreen(
onCharacterCreated: (state) {
createdState = state;
},
),
),
);
// Sold! 버튼이 보이도록 스크롤
await tester.scrollUntilVisible(
find.text('Sold!'),
500.0,
scrollable: find.byType(Scrollable).first,
);
await tester.pumpAndSettle();
// Sold! 버튼 탭
await tester.tap(find.text('Sold!'));
await tester.pumpAndSettle();
// 콜백이 호출되었는지 확인
expect(createdState, isNotNull);
expect(createdState!.traits.name.isNotEmpty, isTrue);
expect(createdState!.traits.level, 1);
expect(createdState!.traits.race.isNotEmpty, isTrue);
expect(createdState!.traits.klass.isNotEmpty, isTrue);
});
testWidgets('Stats section displays all six stats', (tester) async {
await tester.pumpWidget(
MaterialApp(home: NewCharacterScreen(onCharacterCreated: (_) {})),
);
// 능력치 라벨들이 표시되는지 확인
expect(find.text('STR'), findsOneWidget);
expect(find.text('CON'), findsOneWidget);
expect(find.text('DEX'), findsOneWidget);
expect(find.text('INT'), findsOneWidget);
expect(find.text('WIS'), findsOneWidget);
expect(find.text('CHA'), findsOneWidget);
// Total 라벨 확인
expect(find.textContaining('Total'), findsOneWidget);
});
testWidgets('Name text field exists', (tester) async {
await tester.pumpWidget(
MaterialApp(home: NewCharacterScreen(onCharacterCreated: (_) {})),
);
// TextField 확인 (이름 입력 필드)
expect(find.byType(TextField), findsOneWidget);
});
}

358
test/regression/deterministic_game_test.dart Normal file
View File

@@ -0,0 +1,358 @@
/// 원본 대비 회귀 테스트 (Regression Test)
///
/// 동일 시드에서 원본 Progress Quest와 동일한 결과가 나오는지 확인합니다.
/// 이 테스트는 게임 로직의 결정적(deterministic) 특성을 보장합니다.
library;
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/progress_service.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/model/equipment_slot.dart';
import 'package:askiineverdie/src/core/model/game_state.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/util/deterministic_random.dart';
import 'package:askiineverdie/src/core/util/pq_logic.dart' as pq_logic;
import 'package:flutter_test/flutter_test.dart';
void main() {
const config = PqConfig();
final mutations = GameMutations(config);
late ProgressService service;
setUp(() {
service = ProgressService(
config: config,
mutations: mutations,
rewards: RewardService(mutations),
);
});
group('Deterministic Game Flow - Seed 42', () {
// 고정 시드 42에서의 예상 결과값 (스냅샷)
const testSeed = 42;
test('generateName produces consistent names', () {
// 시드 42에서 생성되는 이름들 검증
expect(pq_logic.generateName(DeterministicRandom(testSeed)), 'Bregpran');
expect(pq_logic.generateName(DeterministicRandom(100)), 'Grotlaex');
expect(pq_logic.generateName(DeterministicRandom(999)), 'Idfrok');
});
test('monsterTask produces consistent monster names', () {
// 시드 42, 레벨 5에서의 몬스터 이름
expect(
pq_logic.monsterTask(
config,
DeterministicRandom(testSeed),
5,
null,
null,
),
'an underage Su-monster',
);
// 시드 42, 레벨 10에서의 몬스터 이름
expect(
pq_logic.monsterTask(
config,
DeterministicRandom(testSeed),
10,
null,
null,
),
'a cursed Troll',
);
// 시드 42, 레벨 1에서의 몬스터 이름
expect(
pq_logic.monsterTask(
config,
DeterministicRandom(testSeed),
1,
null,
null,
),
'a greater Crayfish',
);
});
test('winEquip produces consistent equipment', () {
// 시드 42에서 무기 획득
expect(
pq_logic.winEquip(
config,
DeterministicRandom(testSeed),
5,
EquipmentSlot.weapon,
),
'Longiron',
);
// 시드 42에서 방어구 획득
expect(
pq_logic.winEquip(
config,
DeterministicRandom(testSeed),
5,
EquipmentSlot.armor,
),
'-1 Holey Mildewed Bearskin',
);
// 시드 42에서 방패 획득
expect(
pq_logic.winEquip(
config,
DeterministicRandom(testSeed),
5,
EquipmentSlot.shield,
),
'Round Shield',
);
});
test('winSpell produces consistent spells', () {
// 원본 Main.pas:770-774 RandomLow 방식 적용
// 시드 42에서 주문 획득 (레벨 5, 지능 10)
expect(
pq_logic.winSpell(config, DeterministicRandom(testSeed), 5, 10),
'Aqueous Humor|II',
);
// 시드 100에서 주문 획득
expect(
pq_logic.winSpell(config, DeterministicRandom(100), 10, 15),
'Shoelaces|II',
);
});
test('winItem produces consistent items', () {
// 시드 42에서 아이템 획득
expect(
pq_logic.winItem(config, DeterministicRandom(testSeed), 5),
'Ormolu Garnet of Nervousness',
);
// 시드 100에서 아이템 획득
expect(
pq_logic.winItem(config, DeterministicRandom(100), 10),
'Fearsome Gemstone of Fortune',
);
});
test('completeQuest produces consistent rewards', () {
// 시드 42에서 퀘스트 완료
final quest = pq_logic.completeQuest(
config,
DeterministicRandom(testSeed),
5,
);
expect(quest.caption, 'Fetch me a canoe');
expect(quest.reward, pq_logic.RewardKind.spell);
// 시드 100에서 퀘스트 완료
final quest2 = pq_logic.completeQuest(
config,
DeterministicRandom(100),
3,
);
expect(quest2.caption, 'Placate the Bunnies');
expect(quest2.reward, pq_logic.RewardKind.stat);
});
test('interplotCinematic produces consistent storylines', () {
// 시드 42에서 시네마틱 이벤트
final entries = pq_logic.interplotCinematic(
config,
DeterministicRandom(testSeed),
10,
3,
);
// 첫 번째 엔트리 확인 (시나리오 타입에 따라 다름)
expect(entries.isNotEmpty, isTrue);
expect(entries.last.caption, 'Loading');
expect(entries.last.kind, QueueKind.plot);
});
test('namedMonster produces consistent named monsters', () {
expect(
pq_logic.namedMonster(config, DeterministicRandom(testSeed), 10),
'Groxiex the Otyugh',
);
expect(
pq_logic.namedMonster(config, DeterministicRandom(100), 5),
'Druckmox the Koala',
);
});
test('impressiveGuy produces consistent NPC titles', () {
final guy1 = pq_logic.impressiveGuy(
config,
DeterministicRandom(testSeed),
);
// 시드 42에서의 NPC 타이틀 확인
expect(guy1.isNotEmpty, isTrue);
expect(guy1, contains('of'));
final guy2 = pq_logic.impressiveGuy(config, DeterministicRandom(100));
expect(guy2.isNotEmpty, isTrue);
});
});
group('Game State Progression - Deterministic', () {
test('initial game state is consistent for same seed', () {
final state1 = GameState.withSeed(
seed: 42,
traits: const Traits(
name: 'Hero',
race: 'Elf',
klass: 'Mage',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 10,
con: 10,
dex: 10,
intelligence: 10,
wis: 10,
cha: 10,
hpMax: 20,
mpMax: 15,
),
);
final state2 = GameState.withSeed(
seed: 42,
traits: const Traits(
name: 'Hero',
race: 'Elf',
klass: 'Mage',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 10,
con: 10,
dex: 10,
intelligence: 10,
wis: 10,
cha: 10,
hpMax: 20,
mpMax: 15,
),
);
// 동일 시드로 생성된 상태는 동일한 RNG 시퀀스를 가짐
expect(state1.rng.nextInt(100), state2.rng.nextInt(100));
});
test('tick produces consistent state changes', () {
final initialState = GameState.withSeed(
seed: 42,
traits: const Traits(
name: 'TestHero',
race: 'Human',
klass: 'Fighter',
level: 1,
motto: '',
guild: '',
),
stats: const Stats(
str: 12,
con: 10,
dex: 8,
intelligence: 6,
wis: 7,
cha: 9,
hpMax: 10,
mpMax: 8,
),
progress: const ProgressState(
task: ProgressBarState(position: 0, max: 1000),
quest: ProgressBarState(position: 0, max: 10000),
plot: ProgressBarState(position: 0, max: 36000),
exp: ProgressBarState(position: 0, max: 1269),
encumbrance: ProgressBarState(position: 0, max: 22),
currentTask: TaskInfo(caption: 'Battle', type: TaskType.kill),
plotStageCount: 1,
questCount: 0,
),
);
// 첫 번째 틱 (100ms)
final result1 = service.tick(initialState, 100);
// 동일한 초기 상태에서 동일한 증분으로 틱
final result1b = service.tick(initialState, 100);
// 태스크 진행이 동일해야 함
expect(
result1.state.progress.task.position,
result1b.state.progress.task.position,
);
});
test('levelUp stat gains are deterministic', () {
// 레벨업 시 스탯 증가 검증
final baseStats = const Stats(
str: 10,
con: 10,
dex: 10,
intelligence: 10,
wis: 10,
cha: 10,
hpMax: 20,
mpMax: 15,
);
// 동일 시드에서 winStat은 동일한 결과를 반환해야 함
final stat1 = pq_logic.winStat(baseStats, DeterministicRandom(42));
final stat2 = pq_logic.winStat(baseStats, DeterministicRandom(42));
expect(stat1.str, stat2.str);
expect(stat1.con, stat2.con);
expect(stat1.dex, stat2.dex);
expect(stat1.intelligence, stat2.intelligence);
expect(stat1.wis, stat2.wis);
expect(stat1.cha, stat2.cha);
});
});
group('Config Data Integrity', () {
test('races list matches original count', () {
// 원본 Config.dfm의 Races 개수: 21
expect(config.races.length, 21);
});
test('klasses list matches original count', () {
// 원본 Config.dfm의 Klasses 개수: 18
expect(config.klasses.length, 18);
});
test('monsters list matches original count', () {
// 원본 Config.dfm의 Monsters 개수: 231 (540-770줄)
expect(config.monsters.length, 231);
});
test('spells list is not empty', () {
expect(config.spells.isNotEmpty, isTrue);
});
test('weapons list is not empty', () {
expect(config.weapons.isNotEmpty, isTrue);
});
test('armors list is not empty', () {
expect(config.armors.isNotEmpty, isTrue);
});
test('shields list is not empty', () {
expect(config.shields.isNotEmpty, isTrue);
});
});
}

24
test/widget_test.dart Normal file
View File

@@ -0,0 +1,24 @@
import 'package:askiineverdie/src/app.dart';
import 'package:flutter_test/flutter_test.dart';
void main() {
testWidgets('Front screen renders and navigates to new character', (
tester,
) async {
await tester.pumpWidget(const AskiiNeverDieApp());
// 프런트 화면이 렌더링되었는지 확인
expect(find.text('Ascii Never Die'), findsOneWidget);
expect(find.textContaining('Offline Progress Quest'), findsOneWidget);
// "New character" 버튼 탭
await tester.tap(find.text('New character'));
await tester.pumpAndSettle();
// NewCharacterScreen으로 이동했는지 확인
expect(find.text('Progress Quest - New Character'), findsOneWidget);
expect(find.text('Race'), findsOneWidget);
expect(find.text('Class'), findsOneWidget);
expect(find.text('Sold!'), findsOneWidget);
});
}