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

feat(ui): HP/MP 바 개선 및 전투 시스템 UI 업데이트

Browse Source 
- HP/MP 변화 시 플래시 효과 및 변화량 표시 추가
- 전투 중 몬스터 HP 바 표시 기능 추가
- 몬스터 HP 바 Row 오버플로우 버그 수정 (Flexible 적용)
- 전투 상태 및 이벤트 모델 개선
- 캐릭터 애니메이션 및 전투 컴포저 업데이트
This commit is contained in:
JiWoong Sul
2025-12-18 18:10:22 +09:00
parent 45147da5ec
commit cf8fdaecde
14 changed files with 1220 additions and 153 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
lib/src/core/animation/battle_composer.dart
View File

@@ -93,22 +93,29 @@ class BattleComposer {
_overlaySpriteWithSpaces(canvas, normalizedChar, charX, charY);
// 4. 몬스터 프레임 (정규화하여 오른쪽 정렬)
// idle 프레임 기준 너비로 정렬하여 hit/alert 시 위치 이동 방지
final monsterRefWidth = _getMonsterReferenceWidth(monsterCategory, monsterSize);
final monsterFrames =
_getAnimatedMonsterFrames(monsterCategory, monsterSize, phase);
final monsterFrame = monsterFrames[subFrame % monsterFrames.length];
final normalizedMonster = _normalizeSpriteRight(monsterFrame, monsterWidth);
final normalizedMonster = _normalizeSpriteRight(
monsterFrame,
monsterWidth,
referenceWidth: monsterRefWidth,
);
final monsterX = frameWidth - monsterWidth;
// 바닥 레이어(Y=7) 위에 서있도록 -1
final monsterY = frameHeight - normalizedMonster.length - 1;
_overlaySpriteWithSpaces(canvas, normalizedMonster, monsterX, monsterY);
// 몬스터는 경계 내 완전 렌더링 (내부 공백에 배경이 비치지 않도록)
_overlaySpriteWithBounds(canvas, normalizedMonster, monsterX, monsterY);
// 5. 멀티라인 이펙트 오버레이 (공격/히트 페이즈)
if (phase == BattlePhase.attack || phase == BattlePhase.hit) {
final effect = getWeaponEffect(weaponCategory);
final effectLines = _getEffectLines(effect, phase, subFrame);
if (effectLines.isNotEmpty) {
// 이펙트 Y 위치: 캐릭터 팔 높이 (2번째 줄, 몸통) 기준
final effectY = charY + 1;
// 이펙트 Y 위치: 캐릭터 머리 높이 (1번째 줄) 기준 - 수정됨
final effectY = charY;
// 이펙트 X 위치: 캐릭터 오른쪽에 붙여서 표시
final effectX = charX + 6;
for (var i = 0; i < effectLines.length; i++) {
@@ -129,16 +136,64 @@ class BattleComposer {
return sprite.map((line) => line.padRight(width).substring(0, width)).toList();
}
/// 스프라이트를 지정 폭으로 정규화 (오른쪽 정렬)
List<String> _normalizeSpriteRight(List<String> sprite, int width) {
return sprite.map((line) {
final trimmed = line.trimRight();
if (trimmed.length >= width) return trimmed.substring(0, width);
return trimmed.padLeft(width);
/// 스프라이트를 지정 폭으로 정규화 (오른쪽 정렬, 전체 스프라이트 기준)
///
/// 모든 줄을 동일한 기준점에서 오른쪽 정렬하여
/// 머리와 몸통이 분리되지 않도록 함
///
/// [referenceWidth] 지정 시 해당 너비를 기준으로 정렬 (idle/hit 프레임 일관성용)
List<String> _normalizeSpriteRight(
List<String> sprite,
int width, {
int? referenceWidth,
}) {
// 1. 각 줄의 실제 너비(오른쪽 공백 제외) 계산
final trimmedLines = sprite.map((line) => line.trimRight()).toList();
// 2. 기준 너비 결정 (referenceWidth 있으면 사용, 없으면 현재 스프라이트 기준)
int maxLineWidth;
if (referenceWidth != null) {
maxLineWidth = referenceWidth;
} else {
maxLineWidth = 0;
for (final line in trimmedLines) {
if (line.length > maxLineWidth) {
maxLineWidth = line.length;
}
}
}
// 3. 전체 스프라이트를 오른쪽 정렬 (width 기준)
// 모든 줄에 동일한 왼쪽 패딩 적용
final leftPadding = width - maxLineWidth;
final paddingStr = leftPadding > 0 ? ' ' * leftPadding : '';
return trimmedLines.map((line) {
// 각 줄을 왼쪽에 공통 패딩 추가 후 width로 자르기
final paddedLine = paddingStr + line;
if (paddedLine.length > width) {
return paddedLine.substring(paddedLine.length - width);
}
return paddedLine.padRight(width);
}).toList();
}
/// 스프라이트를 캔버스에 오버레이 (공백도 덮어쓰기 - Z-order용)
/// 몬스터 스프라이트의 기준 너비 계산 (idle 프레임 기준)
int _getMonsterReferenceWidth(MonsterCategory category, MonsterSize size) {
final idleFrames = _getMonsterIdleFrames(category, size);
int maxWidth = 0;
for (final frame in idleFrames) {
for (final line in frame) {
final trimmedLength = line.trimRight().length;
if (trimmedLength > maxWidth) {
maxWidth = trimmedLength;
}
}
}
return maxWidth;
}
/// 스프라이트를 캔버스에 오버레이 (공백은 투명 처리)
void _overlaySpriteWithSpaces(
List<List<String>> canvas,
List<String> sprite,
@@ -163,6 +218,43 @@ class BattleComposer {
}
}
/// 스프라이트를 캔버스에 오버레이 (라인별 경계 내 완전 렌더링)
///
/// 각 라인에서 첫 번째와 마지막 비공백 문자 사이의 모든 문자를 그림.
/// 내부 공백도 그려져서 스크롤링 배경이 비치지 않음.
void _overlaySpriteWithBounds(
List<List<String>> canvas,
List<String> sprite,
int startX,
int startY,
) {
for (var i = 0; i < sprite.length; i++) {
final y = startY + i;
if (y < 0 || y >= frameHeight) continue;
final line = sprite[i];
// 각 라인에서 첫/마지막 비공백 문자 위치 찾기
int firstNonSpace = -1;
int lastNonSpace = -1;
for (var j = 0; j < line.length; j++) {
if (line[j] != ' ') {
if (firstNonSpace == -1) firstNonSpace = j;
lastNonSpace = j;
}
}
if (firstNonSpace == -1) continue; // 빈 라인
// 경계 내 모든 문자 그리기 (공백 포함)
for (var j = firstNonSpace; j <= lastNonSpace; j++) {
final x = startX + j;
if (x < 0 || x >= frameWidth) continue;
canvas[y][x] = line[j];
}
}
}
/// 배경 레이어를 캔버스에 그리기
void _drawBackgroundLayer(
List<List<String>> canvas,

26
lib/src/core/animation/character_frames.dart
View File

@@ -108,7 +108,8 @@ const _prepareFrames = [
// ============================================================================
// 공격 프레임 (전진 + 휘두르기) - 5프레임, 심플 3줄 스타일
// 구조: [머리, 몸통+팔+무기, 다리]
// 구조: [머리+공격, 몸통+팔, 다리]
// 수정: 공격 이펙트를 머리 줄로 통일 (1칸 위로)
// ============================================================================
const _attackFrames = [
CharacterFrame([
@@ -122,13 +123,13 @@ const _attackFrames = [
r' / \ ',
]),
CharacterFrame([
r' o ',
r' /|-- ',
r' o-- ',
r' /| ',
r' / \ ',
]),
CharacterFrame([
r' o ',
r' /|-=>',
r' o-=>',
r' /| ',
r' / \ ',
]),
CharacterFrame([
@@ -140,22 +141,23 @@ const _attackFrames = [
// ============================================================================
// 히트 프레임 (공격 명중) - 3프레임, 심플 3줄 스타일
// 구조: [머리, 몸통+팔+이펙트, 다리]
// 구조: [머리+이펙트, 몸통+팔, 다리]
// 수정: 히트 이펙트를 머리 줄로 통일 (1칸 위로)
// ============================================================================
const _hitFrames = [
CharacterFrame([
r' o ',
r' /|-* ',
r' o-* ',
r' /| ',
r' / \ ',
]),
CharacterFrame([
r' o ',
r' /|=* ',
r' o=* ',
r' /| ',
r' / \ ',
]),
CharacterFrame([
r' o ',
r' /|~* ',
r' o~* ',
r' /| ',
r' / \ ',
]),
];

107
lib/src/core/engine/progress_service.dart
View File

@@ -6,6 +6,7 @@ import 'package:askiineverdie/src/core/engine/combat_calculator.dart';
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/reward_service.dart';
import 'package:askiineverdie/src/core/engine/skill_service.dart';
import 'package:askiineverdie/src/core/model/combat_event.dart';
import 'package:askiineverdie/src/core/model/combat_state.dart';
import 'package:askiineverdie/src/core/model/combat_stats.dart';
import 'package:askiineverdie/src/core/model/equipment_item.dart';
@@ -225,11 +226,19 @@ class ProgressService {
// 킬 태스크 완료 시 전투 결과 반영 및 전리품 획득
if (gain) {
// 전투 결과에 따라 플레이어 HP 업데이트
// 전투 결과에 따라 플레이어 HP 업데이트 + 전투 후 회복
final combat = progress.currentCombat;
if (combat != null && combat.isActive) {
// 전투 중 받은 데미지를 실제 Stats에 반영
final newHp = combat.playerStats.hpCurrent;
// 전투 중 남은 HP
final remainingHp = combat.playerStats.hpCurrent;
final maxHp = combat.playerStats.hpMax;
// 전투 승리 시 HP 회복 (50% + CON/2)
// 아이들 게임 특성상 전투 사이 HP가 회복되어야 지속 플레이 가능
final conBonus = nextState.stats.con ~/ 2;
final healAmount = (maxHp * 0.5).round() + conBonus;
final newHp = (remainingHp + healAmount).clamp(0, maxHp);
nextState = nextState.copyWith(
stats: nextState.stats.copyWith(hpCurrent: newHp),
);
@@ -456,9 +465,17 @@ class ProgressService {
level: level,
);
// 전투용 몬스터 레벨 조정 (밸런스)
// config의 raw 레벨이 플레이어보다 너무 높으면 전투가 불가능
// 플레이어 레벨 ±3 범위로 제한 (최소 1)
final effectiveMonsterLevel = monsterResult.level.clamp(
math.max(1, level - 3),
level + 3,
).toInt();
final monsterCombatStats = MonsterCombatStats.fromLevel(
name: monsterResult.displayName,
level: monsterResult.level,
level: effectiveMonsterLevel,
speedType: MonsterCombatStats.inferSpeedType(monsterResult.baseName),
);
@@ -875,6 +892,10 @@ class ProgressService {
var turnsElapsed = combat.turnsElapsed;
var updatedSkillSystem = skillSystem;
// 새 전투 이벤트 수집
final newEvents = <CombatEvent>[];
final timestamp = updatedSkillSystem.elapsedMs;
// 플레이어 공격 체크
if (playerAccumulator >= playerStats.attackDelayMs) {
// 스킬 자동 선택
@@ -905,6 +926,14 @@ class ProgressService {
monsterStats = skillResult.updatedMonster;
totalDamageDealt += skillResult.result.damage;
updatedSkillSystem = skillResult.updatedSkillSystem;
// 스킬 공격 이벤트 생성
newEvents.add(CombatEvent.playerSkill(
timestamp: timestamp,
skillName: selectedSkill.name,
damage: skillResult.result.damage,
targetName: monsterStats.name,
));
} else if (selectedSkill != null && selectedSkill.isHeal) {
// 회복 스킬 사용
final skillResult = skillService.useHealSkill(
@@ -914,6 +943,13 @@ class ProgressService {
);
playerStats = skillResult.updatedPlayer;
updatedSkillSystem = skillResult.updatedSkillSystem;
// 회복 이벤트 생성
newEvents.add(CombatEvent.playerHeal(
timestamp: timestamp,
healAmount: skillResult.result.healedAmount,
skillName: selectedSkill.name,
));
} else if (selectedSkill != null && selectedSkill.isBuff) {
// 버프 스킬 사용
final skillResult = skillService.useBuffSkill(
@@ -923,6 +959,12 @@ class ProgressService {
);
playerStats = skillResult.updatedPlayer;
updatedSkillSystem = skillResult.updatedSkillSystem;
// 버프 이벤트 생성
newEvents.add(CombatEvent.playerBuff(
timestamp: timestamp,
skillName: selectedSkill.name,
));
} else {
// 일반 공격
final attackResult = calculator.playerAttackMonster(
@@ -931,6 +973,22 @@ class ProgressService {
);
monsterStats = attackResult.updatedDefender;
totalDamageDealt += attackResult.result.damage;
// 일반 공격 이벤트 생성
final result = attackResult.result;
if (result.isEvaded) {
newEvents.add(CombatEvent.monsterEvade(
timestamp: timestamp,
targetName: monsterStats.name,
));
} else {
newEvents.add(CombatEvent.playerAttack(
timestamp: timestamp,
damage: result.damage,
targetName: monsterStats.name,
isCritical: result.isCritical,
));
}
}
playerAccumulator -= playerStats.attackDelayMs;
@@ -946,11 +1004,44 @@ class ProgressService {
playerStats = attackResult.updatedDefender;
totalDamageTaken += attackResult.result.damage;
monsterAccumulator -= monsterStats.attackDelayMs;
// 몬스터 공격 이벤트 생성
final result = attackResult.result;
if (result.isEvaded) {
newEvents.add(CombatEvent.playerEvade(
timestamp: timestamp,
attackerName: monsterStats.name,
));
} else if (result.isBlocked) {
newEvents.add(CombatEvent.playerBlock(
timestamp: timestamp,
reducedDamage: result.damage,
attackerName: monsterStats.name,
));
} else if (result.isParried) {
newEvents.add(CombatEvent.playerParry(
timestamp: timestamp,
reducedDamage: result.damage,
attackerName: monsterStats.name,
));
} else {
newEvents.add(CombatEvent.monsterAttack(
timestamp: timestamp,
damage: result.damage,
attackerName: monsterStats.name,
));
}
}
// 전투 종료 체크
final isActive = playerStats.isAlive && monsterStats.isAlive;
// 기존 이벤트와 합쳐서 최대 10개 유지
final combinedEvents = [...combat.recentEvents, ...newEvents];
final recentEvents = combinedEvents.length > 10
? combinedEvents.sublist(combinedEvents.length - 10)
: combinedEvents;
return (
combat: combat.copyWith(
playerStats: playerStats,
@@ -961,6 +1052,7 @@ class ProgressService {
totalDamageTaken: totalDamageTaken,
turnsElapsed: turnsElapsed,
isActive: isActive,
recentEvents: recentEvents,
),
skillSystem: updatedSkillSystem,
);
@@ -977,6 +1069,10 @@ class ProgressService {
// 상실할 장비 개수 계산
final lostCount = state.equipment.equippedItems.length;
// 사망 직전 전투 이벤트 저장 (최대 10개)
final lastCombatEvents =
state.progress.currentCombat?.recentEvents ?? const [];
// 빈 장비 생성 (기본 무기만 유지)
final emptyEquipment = Equipment(
items: [
@@ -995,7 +1091,7 @@ class ProgressService {
bestIndex: 0,
);
// 사망 정보 생성
// 사망 정보 생성 (전투 로그 포함)
final deathInfo = DeathInfo(
cause: cause,
killerName: killerName,
@@ -1003,6 +1099,7 @@ class ProgressService {
goldAtDeath: state.inventory.gold,
levelAtDeath: state.traits.level,
timestamp: state.skillSystem.elapsedMs,
lastCombatEvents: lastCombatEvents,
);
// 전투 상태 초기화

137
lib/src/core/engine/resurrection_service.dart
View File

@@ -1,7 +1,13 @@
import 'dart:math';
import 'package:askiineverdie/data/class_data.dart';
import 'package:askiineverdie/data/race_data.dart';
import 'package:askiineverdie/src/core/engine/shop_service.dart';
import 'package:askiineverdie/src/core/model/class_traits.dart';
import 'package:askiineverdie/src/core/model/equipment_item.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/race_traits.dart';
/// 부활 시스템 서비스 (Phase 4)
///
@@ -17,7 +23,7 @@ class ResurrectionService {
/// 플레이어 사망 처리
///
/// 1. 모든 장비 제거 (인벤토리로 이동하지 않음 - 상실)
/// 1. 1개의 랜덤 장비 제거 (제물로 바침)
/// 2. 전투 상태 초기화
/// 3. 사망 정보 기록
GameState processDeath({
@@ -25,32 +31,40 @@ class ResurrectionService {
required String killerName,
required DeathCause cause,
}) {
// 상실할 장비 개수 계산
final lostCount = state.equipment.equippedItems.length;
// 제물로 바칠 아이템 선택 (장착된 아이템 중 랜덤 1개)
final equippedItems = <int>[]; // 장착된 아이템의 슬롯 인덱스
for (var i = 0; i < Equipment.slotCount; i++) {
final item = state.equipment.getItemByIndex(i);
// 빈 슬롯과 기본 무기(Keyboard) 제외
if (item.isNotEmpty && item.name != 'Keyboard') {
equippedItems.add(i);
}
}
// 빈 장비 생성 (기본 무기만 유지)
final emptyEquipment = Equipment(
items: [
EquipmentItem.defaultWeapon(), // 무기 슬롯에 기본 Keyboard
EquipmentItem.empty(EquipmentSlot.shield),
EquipmentItem.empty(EquipmentSlot.helm),
EquipmentItem.empty(EquipmentSlot.hauberk),
EquipmentItem.empty(EquipmentSlot.brassairts),
EquipmentItem.empty(EquipmentSlot.vambraces),
EquipmentItem.empty(EquipmentSlot.gauntlets),
EquipmentItem.empty(EquipmentSlot.gambeson),
EquipmentItem.empty(EquipmentSlot.cuisses),
EquipmentItem.empty(EquipmentSlot.greaves),
EquipmentItem.empty(EquipmentSlot.sollerets),
],
bestIndex: 0,
);
String? lostItemName;
var newEquipment = state.equipment;
if (equippedItems.isNotEmpty) {
// 랜덤하게 1개 슬롯 선택
final random = Random();
final slotIndex = equippedItems[random.nextInt(equippedItems.length)];
final lostItem = state.equipment.getItemByIndex(slotIndex);
lostItemName = lostItem.name;
// 해당 슬롯만 빈 아이템으로 교체
final slot = EquipmentSlot.values[slotIndex];
newEquipment = state.equipment.setItemByIndex(
slotIndex,
EquipmentItem.empty(slot),
);
}
// 사망 정보 생성
final deathInfo = DeathInfo(
cause: cause,
killerName: killerName,
lostEquipmentCount: lostCount,
lostEquipmentCount: lostItemName != null ? 1 : 0,
lostItemName: lostItemName,
goldAtDeath: state.inventory.gold,
levelAtDeath: state.traits.level,
timestamp: state.skillSystem.elapsedMs,
@@ -62,7 +76,7 @@ class ResurrectionService {
);
return state.copyWith(
equipment: emptyEquipment,
equipment: newEquipment,
progress: progress,
deathInfo: deathInfo,
);
@@ -74,33 +88,37 @@ class ResurrectionService {
/// 플레이어 부활 처리
///
/// 1. HP/MP 전체 회복
/// 2. 골드로 구매 가능한 장비 자동 구매
/// 1. 골드로 구매 가능한 장비 자동 구매
/// 2. HP/MP 전체 회복 (장비/종족/클래스 보너스 포함)
/// 3. 사망 상태 해제
/// 4. 안전 지역으로 이동 태스크 설정
GameState processResurrection(GameState state) {
if (!state.isDead) return state;
// HP/MP 전체 회복
// 1. 먼저 장비 구매 (HP 계산에 필요)
final autoBuyResult = shopService.autoBuyForEmptySlots(
playerLevel: state.traits.level,
currentGold: state.inventory.gold,
currentEquipment: state.equipment,
);
// 장비 적용
var nextState = state.copyWith(
stats: state.stats.copyWith(
hpCurrent: state.stats.hpMax,
mpCurrent: state.stats.mpMax,
equipment: autoBuyResult.updatedEquipment,
inventory: state.inventory.copyWith(
gold: autoBuyResult.remainingGold,
),
);
// 빈 슬롯에 자동 장비 구매
final autoBuyResult = shopService.autoBuyForEmptySlots(
playerLevel: nextState.traits.level,
currentGold: nextState.inventory.gold,
currentEquipment: nextState.equipment,
);
// 2. 전체 HP/MP 계산 (장비 + 종족 + 클래스 보너스 포함)
final totalHpMax = _calculateTotalHpMax(nextState);
final totalMpMax = _calculateTotalMpMax(nextState);
// 결과 적용
// HP/MP 전체 회복
nextState = nextState.copyWith(
equipment: autoBuyResult.updatedEquipment,
inventory: nextState.inventory.copyWith(
gold: autoBuyResult.remainingGold,
stats: nextState.stats.copyWith(
hpCurrent: totalHpMax,
mpCurrent: totalMpMax,
),
clearDeathInfo: true, // 사망 상태 해제
);
@@ -115,6 +133,49 @@ class ResurrectionService {
return nextState;
}
/// 장비/종족/클래스 보너스를 포함한 전체 HP 계산
int _calculateTotalHpMax(GameState state) {
// 기본 HP + 장비 보너스
var totalHp = state.stats.hpMax + state.equipment.totalStats.hpBonus;
// 종족 HP 보너스 (예: Heap Troll +20%)
final race = RaceData.findById(state.traits.raceId);
if (race != null) {
final raceHpBonus = race.getPassiveValue(PassiveType.hpBonus);
if (raceHpBonus > 0) {
totalHp = (totalHp * (1 + raceHpBonus)).round();
}
}
// 클래스 HP 보너스 (예: Garbage Collector +30%)
final klass = ClassData.findById(state.traits.classId);
if (klass != null) {
final classHpBonus = klass.getPassiveValue(ClassPassiveType.hpBonus);
if (classHpBonus > 0) {
totalHp = (totalHp * (1 + classHpBonus)).round();
}
}
return totalHp;
}
/// 장비/종족/클래스 보너스를 포함한 전체 MP 계산
int _calculateTotalMpMax(GameState state) {
// 기본 MP + 장비 보너스
var totalMp = state.stats.mpMax + state.equipment.totalStats.mpBonus;
// 종족 MP 보너스 (예: Pointer Fairy +20%)
final race = RaceData.findById(state.traits.raceId);
if (race != null) {
final raceMpBonus = race.getPassiveValue(PassiveType.mpBonus);
if (raceMpBonus > 0) {
totalMp = (totalMp * (1 + raceMpBonus)).round();
}
}
return totalMp;
}
// ============================================================================
// 유틸리티
// ============================================================================

191
lib/src/core/model/combat_event.dart Normal file
View File

@@ -0,0 +1,191 @@
/// 전투 이벤트 타입 (Combat Event Type)
enum CombatEventType {
/// 플레이어가 몬스터 공격
playerAttack,
/// 몬스터가 플레이어 공격
monsterAttack,
/// 플레이어 회피
playerEvade,
/// 몬스터 회피
monsterEvade,
/// 플레이어 방패 방어
playerBlock,
/// 플레이어 무기 쳐내기
playerParry,
/// 플레이어 스킬 사용
playerSkill,
/// 플레이어 회복
playerHeal,
/// 플레이어 버프
playerBuff,
}
/// 전투 이벤트 (Combat Event)
///
/// 개별 공격/방어/스킬 사용 등의 전투 행동을 기록
class CombatEvent {
const CombatEvent({
required this.type,
required this.timestamp,
this.damage = 0,
this.healAmount = 0,
this.isCritical = false,
this.skillName,
this.targetName,
});
/// 이벤트 타입
final CombatEventType type;
/// 발생 시간 (elapsedMs)
final int timestamp;
/// 데미지 (0이면 미스/회피)
final int damage;
/// 회복량 (회복 이벤트용)
final int healAmount;
/// 크리티컬 여부
final bool isCritical;
/// 사용한 스킬 이름 (스킬 이벤트용)
final String? skillName;
/// 대상 이름 (몬스터 또는 플레이어)
final String? targetName;
/// 플레이어 공격 이벤트 생성
factory CombatEvent.playerAttack({
required int timestamp,
required int damage,
required String targetName,
bool isCritical = false,
}) {
return CombatEvent(
type: CombatEventType.playerAttack,
timestamp: timestamp,
damage: damage,
targetName: targetName,
isCritical: isCritical,
);
}
/// 몬스터 공격 이벤트 생성
factory CombatEvent.monsterAttack({
required int timestamp,
required int damage,
required String attackerName,
}) {
return CombatEvent(
type: CombatEventType.monsterAttack,
timestamp: timestamp,
damage: damage,
targetName: attackerName,
);
}
/// 플레이어 회피 이벤트 생성
factory CombatEvent.playerEvade({
required int timestamp,
required String attackerName,
}) {
return CombatEvent(
type: CombatEventType.playerEvade,
timestamp: timestamp,
targetName: attackerName,
);
}
/// 몬스터 회피 이벤트 생성
factory CombatEvent.monsterEvade({
required int timestamp,
required String targetName,
}) {
return CombatEvent(
type: CombatEventType.monsterEvade,
timestamp: timestamp,
targetName: targetName,
);
}
/// 플레이어 방패 방어 이벤트 생성
factory CombatEvent.playerBlock({
required int timestamp,
required int reducedDamage,
required String attackerName,
}) {
return CombatEvent(
type: CombatEventType.playerBlock,
timestamp: timestamp,
damage: reducedDamage,
targetName: attackerName,
);
}
/// 플레이어 무기 쳐내기 이벤트 생성
factory CombatEvent.playerParry({
required int timestamp,
required int reducedDamage,
required String attackerName,
}) {
return CombatEvent(
type: CombatEventType.playerParry,
timestamp: timestamp,
damage: reducedDamage,
targetName: attackerName,
);
}
/// 스킬 사용 이벤트 생성
factory CombatEvent.playerSkill({
required int timestamp,
required String skillName,
required int damage,
required String targetName,
bool isCritical = false,
}) {
return CombatEvent(
type: CombatEventType.playerSkill,
timestamp: timestamp,
skillName: skillName,
damage: damage,
targetName: targetName,
isCritical: isCritical,
);
}
/// 회복 이벤트 생성
factory CombatEvent.playerHeal({
required int timestamp,
required int healAmount,
String? skillName,
}) {
return CombatEvent(
type: CombatEventType.playerHeal,
timestamp: timestamp,
healAmount: healAmount,
skillName: skillName,
);
}
/// 버프 이벤트 생성
factory CombatEvent.playerBuff({
required int timestamp,
required String skillName,
}) {
return CombatEvent(
type: CombatEventType.playerBuff,
timestamp: timestamp,
skillName: skillName,
);
}
}

7
lib/src/core/model/combat_state.dart
View File

@@ -1,3 +1,4 @@
import 'package:askiineverdie/src/core/model/combat_event.dart';
import 'package:askiineverdie/src/core/model/combat_stats.dart';
import 'package:askiineverdie/src/core/model/monster_combat_stats.dart';
@@ -15,6 +16,7 @@ class CombatState {
required this.totalDamageTaken,
required this.turnsElapsed,
required this.isActive,
this.recentEvents = const [],
});
/// 플레이어 전투 스탯
@@ -41,6 +43,9 @@ class CombatState {
/// 전투 활성화 여부
final bool isActive;
/// 최근 전투 이벤트 목록 (최대 10개)
final List<CombatEvent> recentEvents;
// ============================================================================
// 유틸리티
// ============================================================================
@@ -69,6 +74,7 @@ class CombatState {
int? totalDamageTaken,
int? turnsElapsed,
bool? isActive,
List<CombatEvent>? recentEvents,
}) {
return CombatState(
playerStats: playerStats ?? this.playerStats,
@@ -81,6 +87,7 @@ class CombatState {
totalDamageTaken: totalDamageTaken ?? this.totalDamageTaken,
turnsElapsed: turnsElapsed ?? this.turnsElapsed,
isActive: isActive ?? this.isActive,
recentEvents: recentEvents ?? this.recentEvents,
);
}

17
lib/src/core/model/game_state.dart
View File

@@ -1,5 +1,6 @@
import 'dart:collection';
import 'package:askiineverdie/src/core/model/combat_event.dart';
import 'package:askiineverdie/src/core/model/combat_state.dart';
import 'package:askiineverdie/src/core/model/equipment_item.dart';
import 'package:askiineverdie/src/core/model/equipment_slot.dart';
@@ -107,7 +108,7 @@ class GameState {
/// 사망 정보 (Phase 4)
///
/// 사망 시점의 정보와 상실한 장비 목록을 기록
/// 사망 시점의 정보와 상실한 아이템을 기록
class DeathInfo {
const DeathInfo({
required this.cause,
@@ -116,6 +117,8 @@ class DeathInfo {
required this.goldAtDeath,
required this.levelAtDeath,
required this.timestamp,
this.lostItemName,
this.lastCombatEvents = const [],
});
/// 사망 원인
@@ -124,9 +127,12 @@ class DeathInfo {
/// 사망시킨 몬스터/원인 이름
final String killerName;
/// 상실한 장비 개수
/// 상실한 장비 개수 (0 또는 1)
final int lostEquipmentCount;
/// 제물로 바친 아이템 이름 (null이면 없음)
final String? lostItemName;
/// 사망 시점 골드
final int goldAtDeath;
@@ -136,21 +142,28 @@ class DeathInfo {
/// 사망 시각 (밀리초)
final int timestamp;
/// 사망 직전 전투 이벤트 (최대 10개)
final List<CombatEvent> lastCombatEvents;
DeathInfo copyWith({
DeathCause? cause,
String? killerName,
int? lostEquipmentCount,
String? lostItemName,
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,
goldAtDeath: goldAtDeath ?? this.goldAtDeath,
levelAtDeath: levelAtDeath ?? this.levelAtDeath,
timestamp: timestamp ?? this.timestamp,
lastCombatEvents: lastCombatEvents ?? this.lastCombatEvents,
);
}
}