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

feat(game): 포션 시스템 및 UI 패널 추가

Browse Source 
- 포션 시스템 구현 (PotionService, Potion 모델)
- 포션 인벤토리 패널 위젯
- 활성 버프 패널 위젯
- 장비 스탯 패널 위젯
- 스킬 시스템 확장
- 일본어 번역 추가
- 전투 이벤트/상태 모델 개선
This commit is contained in:
JiWoong Sul
2025-12-21 23:53:27 +09:00
parent eb71d2a199
commit 7cd8be88df
25 changed files with 5174 additions and 261 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
lib/src/core/engine/game_mutations.dart
View File

@@ -1,3 +1,4 @@
import 'package:askiineverdie/src/core/engine/item_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';
@@ -10,12 +11,24 @@ class GameMutations {
final PqConfig config;
/// 장비 획득 (원본 Main.pas:791-830 WinEquip)
///
/// [slotIndex]: 0-10 (원본 Equips.Items.Count = 11)
/// ItemService를 사용하여 스탯과 공속을 가진 장비 생성
GameState winEquipByIndex(GameState state, int level, int slotIndex) {
final rng = state.rng;
final name = pq_logic.winEquip(config, rng, level, slotIndex);
final slot = EquipmentSlot.values[slotIndex];
// ItemService로 스탯이 있는 장비 생성
final itemService = ItemService(rng: rng);
final newItem = itemService.generateEquipment(
name: name,
slot: slot,
level: level,
);
final updatedEquip = state.equipment
.setByIndex(slotIndex, name)
.setItemByIndex(slotIndex, newItem)
.copyWith(bestIndex: slotIndex);
return state.copyWith(rng: rng, equipment: updatedEquip);
}

92
lib/src/core/engine/item_service.dart
View File

@@ -97,14 +97,35 @@ class ItemService {
}
/// 무기 스탯 생성
///
/// 공속(attackSpeed)과 공격력(atk)은 역비례 관계:
/// - 느린 무기 (1500ms): atk × 1.4
/// - 기본 무기 (1000ms): atk × 1.0
/// - 빠른 무기 (600ms): atk × 0.7
ItemStats _generateWeaponStats(int baseValue, ItemRarity rarity) {
final criBonus = rarity.index >= ItemRarity.rare.index ? 0.02 + rarity.index * 0.01 : 0.0;
final parryBonus = rarity.index >= ItemRarity.uncommon.index ? 0.01 + rarity.index * 0.005 : 0.0;
final criBonus = rarity.index >= ItemRarity.rare.index
? 0.02 + rarity.index * 0.01
: 0.0;
final parryBonus = rarity.index >= ItemRarity.uncommon.index
? 0.01 + rarity.index * 0.005
: 0.0;
// 공속 결정 (600ms ~ 1500ms 범위)
// 희귀도가 높을수록 공속 변동 폭 증가
final speedVariance = 300 + rarity.index * 100; // Common: 300, Legendary: 700
final speedOffset = rng.nextInt(speedVariance * 2) - speedVariance;
final attackSpeed = (1000 + speedOffset).clamp(600, 1500);
// 공속-데미지 역비례 계산
// 기준: 1000ms = 1.0x, 600ms = 0.7x, 1500ms = 1.4x
final speedMultiplier = 0.3 + (attackSpeed / 1000) * 0.7;
final adjustedAtk = (baseValue * speedMultiplier).round();
return ItemStats(
atk: baseValue,
atk: adjustedAtk,
criRate: criBonus,
parryRate: parryBonus,
attackSpeed: attackSpeed,
);
}
@@ -201,13 +222,67 @@ class ItemService {
);
}
// ============================================================================
// 장비 점수 계산
// ============================================================================
/// 장비 점수 계산 (Equipment Score)
///
/// 슬롯별 스탯 가중치를 적용하여 점수 산출.
/// - 무기: 공격력, 크리티컬, 공속 역비례 반영
/// - 방어구: 방어력, HP 보너스
/// - 액세서리: 스탯 보너스
static int calculateEquipmentScore(EquipmentItem item) {
var score = 0;
final stats = item.stats;
// 공격 스탯 (무기 중심)
score += stats.atk * 2;
score += stats.magAtk * 2;
score += (stats.criRate * 200).round();
score += (stats.parryRate * 150).round();
// 방어 스탯
score += (stats.def * 1.5).round();
score += (stats.magDef * 1.5).round();
score += (stats.blockRate * 150).round();
score += (stats.evasion * 150).round();
// 자원 스탯
score += stats.hpBonus;
score += stats.mpBonus;
// 능력치 보너스 (가중치 5배)
score += (stats.strBonus +
stats.conBonus +
stats.dexBonus +
stats.intBonus +
stats.wisBonus +
stats.chaBonus) *
5;
// 무기 공속 보정 (느린 무기 = 높은 데미지 → 높은 점수)
// 기준 1000ms, 느린 무기(1500ms)는 +25점, 빠른 무기(600ms)는 -20점
if (item.slot == EquipmentSlot.weapon && stats.attackSpeed > 0) {
score += ((stats.attackSpeed - 1000) * 0.05).round();
}
// 희귀도 배율 적용
score = (score * item.rarity.multiplier).round();
// 레벨 기본 점수
score += item.level * 5;
return score;
}
// ============================================================================
// 자동 장착
// ============================================================================
/// 새 아이템이 현재 장비보다 좋은지 비교
/// 새 아이템이 현재 장비보다 좋은지 비교 (점수 기반)
///
/// 가중치 기준으로 비교하며, 무게 제한도 고려
/// 장비 점수 기준으로 비교하며, 무게 제한도 고려
bool shouldEquip({
required EquipmentItem newItem,
required EquipmentItem currentItem,
@@ -224,8 +299,11 @@ class ItemService {
);
}
// 새 아이템이 더 좋은지 확인
if (newItem.itemWeight <= currentItem.itemWeight) {
// 점수 비교 (새 아이템이 더 높아야 함)
final newScore = calculateEquipmentScore(newItem);
final currentScore = calculateEquipmentScore(currentItem);
if (newScore <= currentScore) {
return false;
}

497
lib/src/core/engine/potion_service.dart Normal file
View File

@@ -0,0 +1,497 @@
import 'package:askiineverdie/data/potion_data.dart';
import 'package:askiineverdie/src/core/model/potion.dart';
/// 물약 서비스
///
/// 물약 사용, 자동 사용 알고리즘, 인벤토리 관리
class PotionService {
const PotionService();
/// 긴급 물약 사용 HP 임계치 (30%)
static const double emergencyHpThreshold = 0.30;
/// 긴급 물약 사용 MP 임계치 (20%)
static const double emergencyMpThreshold = 0.20;
// ============================================================================
// 물약 사용 가능 여부
// ============================================================================
/// 물약 사용 가능 여부 체크
///
/// [potionId] 물약 ID
/// [inventory] 물약 인벤토리
/// Returns: (사용 가능 여부, 실패 사유)
(bool, PotionUseFailReason?) canUsePotion(
String potionId,
PotionInventory inventory,
) {
// 물약 데이터 존재 체크
final potion = PotionData.getById(potionId);
if (potion == null) {
return (false, PotionUseFailReason.potionNotFound);
}
// 보유 수량 체크
if (!inventory.hasPotion(potionId)) {
return (false, PotionUseFailReason.outOfStock);
}
// 전투당 종류별 1회 제한 체크
if (!inventory.canUseType(potion.type)) {
return (false, PotionUseFailReason.alreadyUsedThisBattle);
}
return (true, null);
}
// ============================================================================
// 물약 사용
// ============================================================================
/// 물약 사용
///
/// [potionId] 물약 ID
/// [inventory] 물약 인벤토리
/// [currentHp] 현재 HP
/// [maxHp] 최대 HP
/// [currentMp] 현재 MP
/// [maxMp] 최대 MP
PotionUseResult usePotion({
required String potionId,
required PotionInventory inventory,
required int currentHp,
required int maxHp,
required int currentMp,
required int maxMp,
}) {
final (canUse, failReason) = canUsePotion(potionId, inventory);
if (!canUse) {
return PotionUseResult.failed(failReason!);
}
final potion = PotionData.getById(potionId)!;
int healedAmount = 0;
int newHp = currentHp;
int newMp = currentMp;
if (potion.isHpPotion) {
healedAmount = potion.calculateHeal(maxHp);
newHp = (currentHp + healedAmount).clamp(0, maxHp);
healedAmount = newHp - currentHp; // 실제 회복량
} else if (potion.isMpPotion) {
healedAmount = potion.calculateHeal(maxMp);
newMp = (currentMp + healedAmount).clamp(0, maxMp);
healedAmount = newMp - currentMp; // 실제 회복량
}
final newInventory = inventory.usePotion(potionId, potion.type);
return PotionUseResult(
success: true,
potion: potion,
healedAmount: healedAmount,
newHp: newHp,
newMp: newMp,
newInventory: newInventory,
);
}
// ============================================================================
// 긴급 물약 자동 사용
// ============================================================================
/// 긴급 HP 물약 선택
///
/// HP가 임계치 이하일 때 사용할 최적의 물약 선택
/// [currentHp] 현재 HP
/// [maxHp] 최대 HP
/// [inventory] 물약 인벤토리
/// [playerLevel] 플레이어 레벨 (적정 티어 판단용)
Potion? selectEmergencyHpPotion({
required int currentHp,
required int maxHp,
required PotionInventory inventory,
required int playerLevel,
}) {
// 임계치 체크
final hpRatio = currentHp / maxHp;
if (hpRatio > emergencyHpThreshold) return null;
// 전투 중 이미 HP 물약 사용했으면 불가
if (!inventory.canUseType(PotionType.hp)) return null;
// 적정 티어 계산
final targetTier = PotionData.tierForLevel(playerLevel);
// 적정 티어부터 낮은 티어 순으로 검색
for (var tier = targetTier; tier >= 1; tier--) {
final potion = PotionData.getHpPotionByTier(tier);
if (potion != null && inventory.hasPotion(potion.id)) {
return potion;
}
}
// 적정 티어 이상도 검색
for (var tier = targetTier + 1; tier <= 5; tier++) {
final potion = PotionData.getHpPotionByTier(tier);
if (potion != null && inventory.hasPotion(potion.id)) {
return potion;
}
}
return null;
}
/// 긴급 MP 물약 선택
///
/// MP가 임계치 이하일 때 사용할 최적의 물약 선택
Potion? selectEmergencyMpPotion({
required int currentMp,
required int maxMp,
required PotionInventory inventory,
required int playerLevel,
}) {
// 임계치 체크
final mpRatio = currentMp / maxMp;
if (mpRatio > emergencyMpThreshold) return null;
// 전투 중 이미 MP 물약 사용했으면 불가
if (!inventory.canUseType(PotionType.mp)) return null;
// 적정 티어 계산
final targetTier = PotionData.tierForLevel(playerLevel);
// 적정 티어부터 낮은 티어 순으로 검색
for (var tier = targetTier; tier >= 1; tier--) {
final potion = PotionData.getMpPotionByTier(tier);
if (potion != null && inventory.hasPotion(potion.id)) {
return potion;
}
}
// 적정 티어 이상도 검색
for (var tier = targetTier + 1; tier <= 5; tier++) {
final potion = PotionData.getMpPotionByTier(tier);
if (potion != null && inventory.hasPotion(potion.id)) {
return potion;
}
}
return null;
}
// ============================================================================
// 인벤토리 관리
// ============================================================================
/// 전투 종료 시 사용 기록 초기화
PotionInventory resetBattleUsage(PotionInventory inventory) {
return inventory.resetBattleUsage();
}
/// 물약 드랍 추가
PotionInventory addPotionDrop(
PotionInventory inventory,
String potionId, [
int count = 1,
]) {
return inventory.addPotion(potionId, count);
}
// ============================================================================
// 물약 구매 시스템
// ============================================================================
/// 물약 구매 가능 여부 체크
///
/// [potionId] 물약 ID
/// [gold] 보유 골드
/// Returns: (구매 가능 여부, 실패 사유)
(bool, PotionPurchaseFailReason?) canPurchasePotion(
String potionId,
int gold,
) {
final potion = PotionData.getById(potionId);
if (potion == null) {
return (false, PotionPurchaseFailReason.potionNotFound);
}
if (gold < potion.price) {
return (false, PotionPurchaseFailReason.insufficientGold);
}
return (true, null);
}
/// 물약 구매
///
/// [potionId] 물약 ID
/// [inventory] 현재 물약 인벤토리
/// [gold] 보유 골드
/// [count] 구매 수량 (기본 1)
PotionPurchaseResult purchasePotion({
required String potionId,
required PotionInventory inventory,
required int gold,
int count = 1,
}) {
final potion = PotionData.getById(potionId);
if (potion == null) {
return PotionPurchaseResult.failed(PotionPurchaseFailReason.potionNotFound);
}
final totalCost = potion.price * count;
if (gold < totalCost) {
return PotionPurchaseResult.failed(PotionPurchaseFailReason.insufficientGold);
}
final newInventory = inventory.addPotion(potionId, count);
final newGold = gold - totalCost;
return PotionPurchaseResult(
success: true,
potion: potion,
quantity: count,
totalCost: totalCost,
newGold: newGold,
newInventory: newInventory,
);
}
/// 레벨에 맞는 물약 자동 구매
///
/// 골드의 일정 비율을 물약 구매에 사용
/// [playerLevel] 플레이어 레벨
/// [inventory] 현재 물약 인벤토리
/// [gold] 보유 골드
/// [spendRatio] 골드 사용 비율 (기본 20%)
PotionPurchaseResult autoPurchasePotions({
required int playerLevel,
required PotionInventory inventory,
required int gold,
double spendRatio = 0.20,
}) {
final tier = PotionData.tierForLevel(playerLevel);
final hpPotion = PotionData.getHpPotionByTier(tier);
final mpPotion = PotionData.getMpPotionByTier(tier);
if (hpPotion == null && mpPotion == null) {
return PotionPurchaseResult.failed(PotionPurchaseFailReason.potionNotFound);
}
// 사용 가능 골드
final spendableGold = (gold * spendRatio).floor();
if (spendableGold <= 0) {
return PotionPurchaseResult.failed(PotionPurchaseFailReason.insufficientGold);
}
var currentInventory = inventory;
var currentGold = gold;
var totalSpent = 0;
var hpPurchased = 0;
var mpPurchased = 0;
// HP 물약 우선 구매 (60%), MP 물약 (40%)
final hpBudget = (spendableGold * 0.6).floor();
final mpBudget = spendableGold - hpBudget;
// HP 물약 구매
if (hpPotion != null && hpBudget >= hpPotion.price) {
final count = hpBudget ~/ hpPotion.price;
final cost = count * hpPotion.price;
currentInventory = currentInventory.addPotion(hpPotion.id, count);
currentGold -= cost;
totalSpent += cost;
hpPurchased = count;
}
// MP 물약 구매
if (mpPotion != null && mpBudget >= mpPotion.price) {
final count = mpBudget ~/ mpPotion.price;
final cost = count * mpPotion.price;
currentInventory = currentInventory.addPotion(mpPotion.id, count);
currentGold -= cost;
totalSpent += cost;
mpPurchased = count;
}
if (totalSpent == 0) {
return PotionPurchaseResult.failed(PotionPurchaseFailReason.insufficientGold);
}
return PotionPurchaseResult(
success: true,
potion: hpPotion ?? mpPotion,
quantity: hpPurchased + mpPurchased,
totalCost: totalSpent,
newGold: currentGold,
newInventory: currentInventory,
);
}
// ============================================================================
// 물약 드랍 시스템
// ============================================================================
/// 기본 물약 드랍 확률 (15%)
static const double baseDropChance = 0.15;
/// 레벨당 드랍 확률 증가 (0.5%씩)
static const double dropChancePerLevel = 0.005;
/// 최대 드랍 확률 (35%)
static const double maxDropChance = 0.35;
/// 물약 드랍 시도
///
/// 전투 승리 시 물약 드랍 여부 결정 및 물약 획득
/// [playerLevel] 플레이어 레벨 (드랍 확률 및 티어 결정)
/// [inventory] 현재 물약 인벤토리
/// [roll] 0~99 범위의 난수 (드랍 확률 판정)
/// [typeRoll] 0~99 범위의 난수 (HP/MP 결정)
/// Returns: (업데이트된 인벤토리, 드랍된 물약 또는 null)
(PotionInventory, Potion?) tryPotionDrop({
required int playerLevel,
required PotionInventory inventory,
required int roll,
required int typeRoll,
}) {
// 드랍 확률 계산
final dropChance = (baseDropChance + playerLevel * dropChancePerLevel)
.clamp(baseDropChance, maxDropChance);
final dropThreshold = (dropChance * 100).round();
// 드랍 실패
if (roll >= dropThreshold) {
return (inventory, null);
}
// 물약 타입 결정 (60% HP, 40% MP)
final isHpPotion = typeRoll < 60;
// 레벨 기반 티어 결정
final tier = PotionData.tierForLevel(playerLevel);
// 물약 선택
final Potion? potion;
if (isHpPotion) {
potion = PotionData.getHpPotionByTier(tier);
} else {
potion = PotionData.getMpPotionByTier(tier);
}
if (potion == null) {
return (inventory, null);
}
// 인벤토리에 추가
final updatedInventory = inventory.addPotion(potion.id);
return (updatedInventory, potion);
}
}
/// 물약 사용 결과
class PotionUseResult {
const PotionUseResult({
required this.success,
this.potion,
this.healedAmount = 0,
this.newHp = 0,
this.newMp = 0,
this.newInventory,
this.failReason,
});
/// 성공 여부
final bool success;
/// 사용한 물약
final Potion? potion;
/// 실제 회복량
final int healedAmount;
/// 사용 후 HP
final int newHp;
/// 사용 후 MP
final int newMp;
/// 업데이트된 인벤토리
final PotionInventory? newInventory;
/// 실패 사유
final PotionUseFailReason? failReason;
/// 실패 결과 생성
factory PotionUseResult.failed(PotionUseFailReason reason) {
return PotionUseResult(
success: false,
failReason: reason,
);
}
}
/// 물약 사용 실패 사유
enum PotionUseFailReason {
/// 물약 없음 (데이터 없음)
potionNotFound,
/// 보유 물약 없음 (재고 부족)
outOfStock,
/// 이번 전투에서 이미 해당 종류 물약 사용
alreadyUsedThisBattle,
}
/// 물약 구매 결과
class PotionPurchaseResult {
const PotionPurchaseResult({
required this.success,
this.potion,
this.quantity = 0,
this.totalCost = 0,
this.newGold = 0,
this.newInventory,
this.failReason,
});
/// 성공 여부
final bool success;
/// 구매한 물약
final Potion? potion;
/// 구매 수량
final int quantity;
/// 총 비용
final int totalCost;
/// 구매 후 골드
final int newGold;
/// 업데이트된 인벤토리
final PotionInventory? newInventory;
/// 실패 사유
final PotionPurchaseFailReason? failReason;
/// 실패 결과 생성
factory PotionPurchaseResult.failed(PotionPurchaseFailReason reason) {
return PotionPurchaseResult(
success: false,
failReason: reason,
);
}
}
/// 물약 구매 실패 사유
enum PotionPurchaseFailReason {
/// 물약 없음 (데이터 없음)
potionNotFound,
/// 골드 부족
insufficientGold,
}

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

@@ -4,6 +4,7 @@ import 'package:askiineverdie/data/game_text_l10n.dart' as l10n;
import 'package:askiineverdie/data/skill_data.dart';
import 'package:askiineverdie/src/core/engine/combat_calculator.dart';
import 'package:askiineverdie/src/core/engine/game_mutations.dart';
import 'package:askiineverdie/src/core/engine/potion_service.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';
@@ -13,7 +14,9 @@ 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/monster_combat_stats.dart';
import 'package:askiineverdie/src/core/model/potion.dart';
import 'package:askiineverdie/src/core/model/pq_config.dart';
import 'package:askiineverdie/src/core/model/skill.dart';
import 'package:askiineverdie/src/core/util/pq_logic.dart' as pq_logic;
class ProgressTickResult {
@@ -186,9 +189,10 @@ class ProgressService {
? progress.task.max
: uncapped;
// 킬 태스크 중 전투 진행 (스킬 자동 사용 포함)
// 킬 태스크 중 전투 진행 (스킬 자동 사용, DOT, 물약 포함)
var updatedCombat = progress.currentCombat;
var updatedSkillSystem = nextState.skillSystem;
var updatedPotionInventory = nextState.potionInventory;
if (progress.currentTask.type == TaskType.kill && updatedCombat != null && updatedCombat.isActive) {
final combatResult = _processCombatTickWithSkills(
nextState,
@@ -198,6 +202,9 @@ class ProgressService {
);
updatedCombat = combatResult.combat;
updatedSkillSystem = combatResult.skillSystem;
if (combatResult.potionInventory != null) {
updatedPotionInventory = combatResult.potionInventory!;
}
// Phase 4: 플레이어 사망 체크
if (!updatedCombat.playerStats.isAlive) {
@@ -216,7 +223,11 @@ class ProgressService {
currentCombat: updatedCombat,
);
nextState = _recalculateEncumbrance(
nextState.copyWith(progress: progress, skillSystem: updatedSkillSystem),
nextState.copyWith(
progress: progress,
skillSystem: updatedSkillSystem,
potionInventory: updatedPotionInventory,
),
);
return ProgressTickResult(state: nextState);
}
@@ -245,11 +256,33 @@ class ProgressService {
}
// 전리품 획득 (원본 Main.pas:625-630)
nextState = _winLoot(nextState);
final lootResult = _winLoot(nextState);
nextState = lootResult.state;
// 전투 상태 초기화
progress = nextState.progress.copyWith(currentCombat: null);
nextState = nextState.copyWith(progress: progress);
// 물약 드랍 시 전투 로그에 이벤트 추가
var combatForReset = progress.currentCombat;
if (lootResult.droppedPotion != null && combatForReset != null) {
final potionDropEvent = CombatEvent.potionDrop(
timestamp: nextState.skillSystem.elapsedMs,
potionName: lootResult.droppedPotion!.name,
isHp: lootResult.droppedPotion!.isHpPotion,
);
final updatedEvents = [...combatForReset.recentEvents, potionDropEvent];
combatForReset = combatForReset.copyWith(
recentEvents: updatedEvents.length > 10
? updatedEvents.sublist(updatedEvents.length - 10)
: updatedEvents,
);
progress = progress.copyWith(currentCombat: combatForReset);
}
// 전투 상태 초기화 및 물약 사용 기록 초기화
progress = progress.copyWith(currentCombat: null);
final resetPotionInventory = nextState.potionInventory.resetBattleUsage();
nextState = nextState.copyWith(
progress: progress,
potionInventory: resetPotionInventory,
);
}
// 시장/판매/구매 태스크 완료 시 처리 (원본 Main.pas:631-649)
@@ -728,39 +761,60 @@ class ProgressService {
}
/// 킬 태스크 완료 시 전리품 획득 (원본 Main.pas:625-630)
GameState _winLoot(GameState state) {
/// 전리품 획득 결과
///
/// [state] 업데이트된 게임 상태
/// [droppedPotion] 드랍된 물약 (없으면 null)
({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 == '*') {
return mutations.winItem(state);
}
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)}';
// 부위가 비어있으면 전리품 없음
if (monsterPart.isEmpty || monsterBaseName.isEmpty) {
return state;
}
// 인벤토리에 추가
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));
}
// 원본: Add(Inventory, LowerCase(Split(fTask.Caption,1) + ' ' +
// ProperCase(Split(fTask.Caption,3))), 1);
// 예: "goblin Claw" 형태로 인벤토리 추가
final itemName =
'${monsterBaseName.toLowerCase()} ${_properCase(monsterPart)}';
// 인벤토리에 추가
final items = [...state.inventory.items];
final existing = items.indexWhere((e) => e.name == itemName);
if (existing >= 0) {
items[existing] = items[existing].copyWith(
count: items[existing].count + 1,
resultState = resultState.copyWith(
inventory: resultState.inventory.copyWith(items: items),
);
} else {
items.add(InventoryEntry(name: itemName, count: 1));
}
return state.copyWith(inventory: state.inventory.copyWith(items: items));
// 물약 드랍 시도
final potionService = const PotionService();
final rng = resultState.rng;
final (updatedPotionInventory, droppedPotion) = potionService.tryPotionDrop(
playerLevel: resultState.traits.level,
inventory: resultState.potionInventory,
roll: rng.nextInt(100),
typeRoll: rng.nextInt(100),
);
return (
state: resultState.copyWith(
rng: rng,
potionInventory: updatedPotionInventory,
),
droppedPotion: droppedPotion,
);
}
/// 첫 글자만 대문자로 변환 (원본 ProperCase)
@@ -796,6 +850,22 @@ class ProgressService {
final slotIndex = nextState.rng.nextInt(Equipment.slotCount);
nextState = mutations.winEquipByIndex(nextState, level, slotIndex);
// 물약 자동 구매 (남은 골드의 20% 사용)
final potionService = const PotionService();
final purchaseResult = potionService.autoPurchasePotions(
playerLevel: level,
inventory: nextState.potionInventory,
gold: nextState.inventory.gold,
spendRatio: 0.20,
);
if (purchaseResult.success && purchaseResult.newInventory != null) {
nextState = nextState.copyWith(
inventory: nextState.inventory.copyWith(gold: purchaseResult.newGold),
potionInventory: purchaseResult.newInventory,
);
}
return nextState;
}
@@ -864,25 +934,30 @@ class ProgressService {
);
}
/// 전투 틱 처리 (스킬 자동 사용 포함)
/// 전투 틱 처리 (스킬 자동 사용, DOT, 물약 포함)
///
/// [state] 현재 게임 상태
/// [combat] 현재 전투 상태
/// [skillSystem] 스킬 시스템 상태
/// [elapsedMs] 경과 시간 (밀리초)
/// Returns: 업데이트된 전투 상태 및 스킬 시스템 상태
({CombatState combat, SkillSystemState skillSystem}) _processCombatTickWithSkills(
/// Returns: 업데이트된 전투 상태, 스킬 시스템 상태, 물약 인벤토리
({
CombatState combat,
SkillSystemState skillSystem,
PotionInventory? potionInventory,
}) _processCombatTickWithSkills(
GameState state,
CombatState combat,
SkillSystemState skillSystem,
int elapsedMs,
) {
if (!combat.isActive || combat.isCombatOver) {
return (combat: combat, skillSystem: skillSystem);
return (combat: combat, skillSystem: skillSystem, potionInventory: null);
}
final calculator = CombatCalculator(rng: state.rng);
final skillService = SkillService(rng: state.rng);
final potionService = const PotionService();
var playerStats = combat.playerStats;
var monsterStats = combat.monsterStats;
var playerAccumulator = combat.playerAttackAccumulatorMs + elapsedMs;
@@ -891,11 +966,90 @@ class ProgressService {
var totalDamageTaken = combat.totalDamageTaken;
var turnsElapsed = combat.turnsElapsed;
var updatedSkillSystem = skillSystem;
var activeDoTs = [...combat.activeDoTs];
var usedPotionTypes = {...combat.usedPotionTypes};
PotionInventory? updatedPotionInventory;
// 새 전투 이벤트 수집
final newEvents = <CombatEvent>[];
final timestamp = updatedSkillSystem.elapsedMs;
// =========================================================================
// DOT 틱 처리
// =========================================================================
var dotDamageThisTick = 0;
final updatedDoTs = <DotEffect>[];
for (final dot in activeDoTs) {
final (updatedDot, ticksTriggered) = dot.tick(elapsedMs);
if (ticksTriggered > 0) {
final damage = dot.damagePerTick * ticksTriggered;
dotDamageThisTick += damage;
// DOT 데미지 이벤트 생성
newEvents.add(CombatEvent.dotTick(
timestamp: timestamp,
skillName: dot.skillId,
damage: damage,
targetName: monsterStats.name,
));
}
// 만료되지 않은 DOT만 유지
if (updatedDot.isActive) {
updatedDoTs.add(updatedDot);
}
}
// DOT 데미지 적용
if (dotDamageThisTick > 0 && monsterStats.isAlive) {
final newMonsterHp = (monsterStats.hpCurrent - dotDamageThisTick)
.clamp(0, monsterStats.hpMax);
monsterStats = monsterStats.copyWith(hpCurrent: newMonsterHp);
totalDamageDealt += dotDamageThisTick;
}
activeDoTs = updatedDoTs;
// =========================================================================
// 긴급 물약 자동 사용 (HP < 30%)
// =========================================================================
final hpRatio = playerStats.hpCurrent / playerStats.hpMax;
if (hpRatio <= PotionService.emergencyHpThreshold) {
final emergencyPotion = potionService.selectEmergencyHpPotion(
currentHp: playerStats.hpCurrent,
maxHp: playerStats.hpMax,
inventory: state.potionInventory,
playerLevel: state.traits.level,
);
if (emergencyPotion != null &&
!usedPotionTypes.contains(PotionType.hp)) {
final result = potionService.usePotion(
potionId: emergencyPotion.id,
inventory: state.potionInventory,
currentHp: playerStats.hpCurrent,
maxHp: playerStats.hpMax,
currentMp: playerStats.mpCurrent,
maxMp: playerStats.mpMax,
);
if (result.success) {
playerStats = playerStats.copyWith(hpCurrent: result.newHp);
usedPotionTypes = {...usedPotionTypes, PotionType.hp};
updatedPotionInventory = result.newInventory;
newEvents.add(CombatEvent.playerPotion(
timestamp: timestamp,
potionName: emergencyPotion.name,
healAmount: result.healedAmount,
isHp: true,
));
}
}
}
// 플레이어 공격 체크
if (playerAccumulator >= playerStats.attackDelayMs) {
// 스킬 자동 선택
@@ -912,6 +1066,7 @@ class ProgressService {
monster: monsterStats,
skillSystem: updatedSkillSystem,
availableSkillIds: availableSkillIds,
activeDoTs: activeDoTs,
);
if (selectedSkill != null && selectedSkill.isAttack) {
@@ -934,6 +1089,30 @@ class ProgressService {
damage: skillResult.result.damage,
targetName: monsterStats.name,
));
} else if (selectedSkill != null && selectedSkill.isDot) {
// DOT 스킬 사용
final skillResult = skillService.useDotSkill(
skill: selectedSkill,
player: playerStats,
skillSystem: updatedSkillSystem,
playerInt: state.stats.intelligence,
playerWis: state.stats.wis,
);
playerStats = skillResult.updatedPlayer;
updatedSkillSystem = skillResult.updatedSkillSystem;
// DOT 효과 추가
if (skillResult.dotEffect != null) {
activeDoTs.add(skillResult.dotEffect!);
}
// DOT 스킬 사용 이벤트 생성
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(
@@ -1053,8 +1232,11 @@ class ProgressService {
turnsElapsed: turnsElapsed,
isActive: isActive,
recentEvents: recentEvents,
activeDoTs: activeDoTs,
usedPotionTypes: usedPotionTypes,
),
skillSystem: updatedSkillSystem,
potionInventory: updatedPotionInventory,
);
}

90
lib/src/core/engine/skill_service.dart
View File

@@ -181,6 +181,60 @@ class SkillService {
);
}
/// DOT 스킬 사용
///
/// DOT 효과를 생성하여 반환. 호출자가 전투 상태의 activeDoTs에 추가해야 함.
/// INT → 틱당 데미지 보정, WIS → 틱 간격 보정
({
SkillUseResult result,
CombatStats updatedPlayer,
SkillSystemState updatedSkillSystem,
DotEffect? dotEffect,
}) useDotSkill({
required Skill skill,
required CombatStats player,
required SkillSystemState skillSystem,
required int playerInt,
required int playerWis,
}) {
if (!skill.isDot) {
return (
result: SkillUseResult.failed(skill, SkillFailReason.invalidState),
updatedPlayer: player,
updatedSkillSystem: skillSystem,
dotEffect: null,
);
}
// DOT 효과 생성 (INT/WIS 보정 적용)
final dotEffect = DotEffect.fromSkill(
skill,
playerInt: playerInt,
playerWis: playerWis,
);
// MP 소모
var updatedPlayer = player.withMp(player.mpCurrent - skill.mpCost);
// 스킬 상태 업데이트 (쿨타임 시작)
final updatedSkillSystem = _updateSkillCooldown(skillSystem, skill.id);
// 예상 총 데미지 계산 (틱 수 × 틱당 데미지)
final expectedTicks = dotEffect.totalDurationMs ~/ dotEffect.tickIntervalMs;
final expectedDamage = expectedTicks * dotEffect.damagePerTick;
return (
result: SkillUseResult(
skill: skill,
success: true,
damage: expectedDamage,
),
updatedPlayer: updatedPlayer,
updatedSkillSystem: updatedSkillSystem,
dotEffect: dotEffect,
);
}
// ============================================================================
// 자동 스킬 선택
// ============================================================================
@@ -189,14 +243,16 @@ class SkillService {
///
/// 우선순위:
/// 1. HP < 30% → 회복 스킬
/// 2. 보스전 (레벨 차이 10 이상) → 가장 강력한 공격 스킬
/// 3. 일반 전투 → MP 효율이 좋은 스킬
/// 4. MP < 20% → null (일반 공격)
/// 2. 몬스터 HP > 50% & DOT 없음 → DOT 스킬 (장기전 유리)
/// 3. 보스전 (레벨 차이 10 이상) → 가장 강력한 공격 스킬
/// 4. 일반 전투 → MP 효율이 좋은 스킬
/// 5. MP < 20% → null (일반 공격)
Skill? selectAutoSkill({
required CombatStats player,
required MonsterCombatStats monster,
required SkillSystemState skillSystem,
required List<String> availableSkillIds,
List<DotEffect> activeDoTs = const [],
}) {
final currentMp = player.mpCurrent;
final mpRatio = player.mpRatio;
@@ -225,6 +281,12 @@ class SkillService {
if (healSkill != null) return healSkill;
}
// 몬스터 HP > 50% & 활성 DOT 없음 → DOT 스킬 사용
if (monster.hpRatio > 0.5 && activeDoTs.isEmpty) {
final dotSkill = _findBestDotSkill(availableSkills, currentMp);
if (dotSkill != null) return dotSkill;
}
// 보스전 판단 (몬스터 레벨이 높음)
final isBossFight = monster.level >= 10 && monster.hpRatio > 0.5;
@@ -237,6 +299,28 @@ class SkillService {
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