2e66562ea2
- ProgressState.copyWith에 clearCurrentCombat 파라미터 추가 - death_handler, resurrection_service에서 clearCurrentCombat 사용 - death_handler 테스트 14개 추가 - item_service 테스트 33개 추가 - skill_data 주석 스킬 개수 70→68 수정
618 lines
21 KiB
Dart
618 lines
21 KiB
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/core/util/deterministic_random.dart';
|
|
import 'package:flutter_test/flutter_test.dart';
|
|
|
|
void main() {
|
|
group('ItemService', () {
|
|
// ========================================================================
|
|
// generateEquipment - 레벨에 맞는 아이템 생성
|
|
// ========================================================================
|
|
group('generateEquipment', () {
|
|
test('지정 레벨/슬롯에 맞는 아이템 생성', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final item = service.generateEquipment(
|
|
name: 'Test Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 10,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
|
|
expect(item.name, equals('Test Sword'));
|
|
expect(item.slot, equals(EquipmentSlot.weapon));
|
|
expect(item.level, equals(10));
|
|
expect(item.rarity, equals(ItemRarity.common));
|
|
expect(item.weight, greaterThan(0));
|
|
expect(item.isEmpty, isFalse);
|
|
});
|
|
|
|
test('높은 레벨 아이템이 낮은 레벨보다 강한 스탯', () {
|
|
final rng1 = DeterministicRandom(42);
|
|
final rng2 = DeterministicRandom(42);
|
|
final service1 = ItemService(rng: rng1);
|
|
final service2 = ItemService(rng: rng2);
|
|
|
|
final lowItem = service1.generateEquipment(
|
|
name: 'Low Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
final highItem = service2.generateEquipment(
|
|
name: 'High Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 50,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
|
|
// 같은 희귀도(common)에서 높은 레벨이 더 높은 점수
|
|
final lowScore = ItemService.calculateEquipmentScore(lowItem);
|
|
final highScore = ItemService.calculateEquipmentScore(highItem);
|
|
expect(highScore, greaterThan(lowScore));
|
|
});
|
|
|
|
test('희귀도(rarity) 미지정 시 자동 결정', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final item = service.generateEquipment(
|
|
name: 'Auto Rarity Item',
|
|
slot: EquipmentSlot.helm,
|
|
level: 10,
|
|
);
|
|
|
|
// 희귀도가 자동 결정되어 유효한 값을 가짐
|
|
expect(ItemRarity.values, contains(item.rarity));
|
|
});
|
|
|
|
test('모든 슬롯에 대해 아이템 생성 가능', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
for (final slot in EquipmentSlot.values) {
|
|
final item = service.generateEquipment(
|
|
name: 'Test ${slot.name}',
|
|
slot: slot,
|
|
level: 5,
|
|
rarity: ItemRarity.uncommon,
|
|
);
|
|
|
|
expect(item.slot, equals(slot));
|
|
expect(item.stats, isNotNull);
|
|
expect(item.weight, greaterThan(0));
|
|
}
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// determineRarity - 희귀도(ItemRarity) 분포 확인
|
|
// ========================================================================
|
|
group('determineRarity', () {
|
|
test('확률 분포가 설계대로 분배됨', () {
|
|
// 대량 샘플로 확률 분포 검증
|
|
final rng = DeterministicRandom(12345);
|
|
final service = ItemService(rng: rng);
|
|
final counts = <ItemRarity, int>{};
|
|
|
|
const trials = 10000;
|
|
for (var i = 0; i < trials; i++) {
|
|
final rarity = service.determineRarity(10);
|
|
counts[rarity] = (counts[rarity] ?? 0) + 1;
|
|
}
|
|
|
|
// 허용 오차(tolerance) ±3%
|
|
final commonPct = counts[ItemRarity.common]! / trials;
|
|
final uncommonPct = counts[ItemRarity.uncommon]! / trials;
|
|
final rarePct = counts[ItemRarity.rare]! / trials;
|
|
final epicPct = counts[ItemRarity.epic]! / trials;
|
|
final legendaryPct = counts[ItemRarity.legendary]! / trials;
|
|
|
|
// Common: 34%, Uncommon: 40%, Rare: 20%, Epic: 5%, Legendary: 1%
|
|
expect(commonPct, closeTo(0.34, 0.03));
|
|
expect(uncommonPct, closeTo(0.40, 0.03));
|
|
expect(rarePct, closeTo(0.20, 0.03));
|
|
expect(epicPct, closeTo(0.05, 0.03));
|
|
expect(legendaryPct, closeTo(0.01, 0.02));
|
|
});
|
|
|
|
test('모든 희귀도가 최소 한 번 등장', () {
|
|
final rng = DeterministicRandom(9999);
|
|
final service = ItemService(rng: rng);
|
|
final seen = <ItemRarity>{};
|
|
|
|
// 충분한 시행으로 모든 희귀도 등장 확인
|
|
for (var i = 0; i < 5000; i++) {
|
|
seen.add(service.determineRarity(10));
|
|
}
|
|
|
|
expect(seen, containsAll(ItemRarity.values));
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// generateItemStats - 아이템에 stats가 있는지
|
|
// ========================================================================
|
|
group('generateItemStats', () {
|
|
test('무기(weapon) 스탯에 atk가 포함됨', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final stats = service.generateItemStats(
|
|
level: 10,
|
|
rarity: ItemRarity.uncommon,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(stats.atk, greaterThan(0));
|
|
expect(stats.attackSpeed, greaterThan(0));
|
|
});
|
|
|
|
test('방패(shield) 스탯에 def와 blockRate가 포함됨', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final stats = service.generateItemStats(
|
|
level: 10,
|
|
rarity: ItemRarity.uncommon,
|
|
slot: EquipmentSlot.shield,
|
|
);
|
|
|
|
expect(stats.def, greaterThan(0));
|
|
expect(stats.blockRate, greaterThan(0.0));
|
|
});
|
|
|
|
test('방어구(armor) 스탯에 def가 포함됨', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
// 모든 방어구 슬롯에 def가 존재하는지 확인
|
|
for (final slot in EquipmentSlot.values) {
|
|
if (!slot.isWeapon && !slot.isShield) {
|
|
final stats = service.generateItemStats(
|
|
level: 10,
|
|
rarity: ItemRarity.uncommon,
|
|
slot: slot,
|
|
);
|
|
expect(stats.def, greaterThan(0), reason: '${slot.name} def > 0');
|
|
}
|
|
}
|
|
});
|
|
|
|
test('높은 희귀도는 더 높은 baseValue를 생성', () {
|
|
final rng1 = DeterministicRandom(42);
|
|
final rng2 = DeterministicRandom(42);
|
|
final service1 = ItemService(rng: rng1);
|
|
final service2 = ItemService(rng: rng2);
|
|
|
|
final commonStats = service1.generateItemStats(
|
|
level: 20,
|
|
rarity: ItemRarity.common,
|
|
slot: EquipmentSlot.hauberk,
|
|
);
|
|
final epicStats = service2.generateItemStats(
|
|
level: 20,
|
|
rarity: ItemRarity.epic,
|
|
slot: EquipmentSlot.hauberk,
|
|
);
|
|
|
|
// Epic(2.2x)이 Common(1.0x)보다 def가 높아야 함
|
|
expect(epicStats.def, greaterThan(commonStats.def));
|
|
});
|
|
|
|
test('Rare 이상 무기에 criRate 보너스 존재', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final stats = service.generateItemStats(
|
|
level: 10,
|
|
rarity: ItemRarity.rare,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(stats.criRate, greaterThan(0.0));
|
|
});
|
|
|
|
test('공속(attackSpeed)이 600~1500ms 범위 내', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
// 여러 번 생성하여 범위 확인
|
|
for (var i = 0; i < 100; i++) {
|
|
final stats = service.generateItemStats(
|
|
level: 10,
|
|
rarity: ItemRarity.uncommon,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(
|
|
stats.attackSpeed,
|
|
inInclusiveRange(600, 1500),
|
|
reason: 'attackSpeed 범위 위반 (시행 $i)',
|
|
);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// calculateEquipmentScore (shouldEquip) - 더 좋은 아이템 판별
|
|
// ========================================================================
|
|
group('calculateEquipmentScore / shouldEquip', () {
|
|
test('높은 점수 아이템이 더 좋은 것으로 판별', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final weakItem = service.generateEquipment(
|
|
name: 'Weak Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 5,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
final strongItem = service.generateEquipment(
|
|
name: 'Strong Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 20,
|
|
rarity: ItemRarity.epic,
|
|
);
|
|
|
|
final weakScore = ItemService.calculateEquipmentScore(weakItem);
|
|
final strongScore = ItemService.calculateEquipmentScore(strongItem);
|
|
|
|
expect(strongScore, greaterThan(weakScore));
|
|
});
|
|
|
|
test('shouldEquip: 더 강한 아이템 장착 허용', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final currentItem = service.generateEquipment(
|
|
name: 'Old Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 5,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
final newItem = service.generateEquipment(
|
|
name: 'New Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 20,
|
|
rarity: ItemRarity.rare,
|
|
);
|
|
|
|
final result = service.shouldEquip(
|
|
newItem: newItem,
|
|
currentItem: currentItem,
|
|
allEquipped: [currentItem],
|
|
str: 20,
|
|
);
|
|
|
|
expect(result, isTrue);
|
|
});
|
|
|
|
test('shouldEquip: 더 약한 아이템 장착 거부', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final currentItem = service.generateEquipment(
|
|
name: 'Strong Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 30,
|
|
rarity: ItemRarity.epic,
|
|
);
|
|
final newItem = service.generateEquipment(
|
|
name: 'Weak Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 5,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
|
|
final result = service.shouldEquip(
|
|
newItem: newItem,
|
|
currentItem: currentItem,
|
|
allEquipped: [currentItem],
|
|
str: 20,
|
|
);
|
|
|
|
expect(result, isFalse);
|
|
});
|
|
|
|
test('shouldEquip: 무게 초과 시 장착 거부', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
// STR 1 → 최대 무게 110
|
|
// 높은 레벨 아이템들로 무게 가득 채우기
|
|
final heavyItems = EquipmentSlot.values.map((slot) {
|
|
return service.generateEquipment(
|
|
name: 'Heavy ${slot.name}',
|
|
slot: slot,
|
|
level: 50,
|
|
rarity: ItemRarity.legendary,
|
|
);
|
|
}).toList();
|
|
|
|
final newItem = service.generateEquipment(
|
|
name: 'Another Heavy Item',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 50,
|
|
rarity: ItemRarity.legendary,
|
|
);
|
|
|
|
final result = service.shouldEquip(
|
|
newItem: newItem,
|
|
currentItem: heavyItems.first, // weapon 슬롯
|
|
allEquipped: heavyItems,
|
|
str: 1, // 낮은 STR → 무게 제한 110
|
|
);
|
|
|
|
// 교체 시 기존 무기 무게 제외 → 장착 가능 여부는 무게에 달림
|
|
// 이 테스트는 무게 제한 로직이 동작하는지 확인
|
|
expect(result, isA<bool>());
|
|
});
|
|
|
|
test('shouldEquip: 빈 슬롯에는 무조건 장착', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final emptyItem = EquipmentItem.empty(EquipmentSlot.weapon);
|
|
final newItem = service.generateEquipment(
|
|
name: 'Any Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
rarity: ItemRarity.common,
|
|
);
|
|
|
|
final result = service.shouldEquip(
|
|
newItem: newItem,
|
|
currentItem: emptyItem,
|
|
allEquipped: [emptyItem],
|
|
str: 10,
|
|
);
|
|
|
|
expect(result, isTrue);
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// calculateWeight - 아이템 무게 계산
|
|
// ========================================================================
|
|
group('calculateWeight', () {
|
|
test('슬롯별 기본 무게가 다름', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
// hauberk(갑옷)이 gauntlets(건틀릿)보다 무거워야 함
|
|
final hauberkWeight = service.calculateWeight(
|
|
level: 1,
|
|
slot: EquipmentSlot.hauberk,
|
|
);
|
|
final gauntletsWeight = service.calculateWeight(
|
|
level: 1,
|
|
slot: EquipmentSlot.gauntlets,
|
|
);
|
|
|
|
expect(hauberkWeight, greaterThan(gauntletsWeight));
|
|
});
|
|
|
|
test('레벨이 높을수록 무게 증가', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
final lowWeight = service.calculateWeight(
|
|
level: 1,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
final highWeight = service.calculateWeight(
|
|
level: 50,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(highWeight, greaterThan(lowWeight));
|
|
});
|
|
|
|
test('무게 공식: baseWeight + (level ~/ 5)', () {
|
|
final rng = DeterministicRandom(42);
|
|
final service = ItemService(rng: rng);
|
|
|
|
// weapon 기본 무게 10, 레벨 25 → 10 + (25 ~/ 5) = 10 + 5 = 15
|
|
final weight = service.calculateWeight(
|
|
level: 25,
|
|
slot: EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(weight, equals(15));
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// calculateMaxWeight / calculateTotalWeight
|
|
// ========================================================================
|
|
group('calculateMaxWeight / calculateTotalWeight', () {
|
|
test('STR 기반 최대 무게: 100 + STR * 10', () {
|
|
expect(ItemService.calculateMaxWeight(10), equals(200));
|
|
expect(ItemService.calculateMaxWeight(0), equals(100));
|
|
expect(ItemService.calculateMaxWeight(50), equals(600));
|
|
});
|
|
|
|
test('장비 목록의 총 무게 합산', () {
|
|
final items = [
|
|
EquipmentItem(
|
|
name: 'Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
weight: 10,
|
|
stats: const ItemStats(atk: 5),
|
|
rarity: ItemRarity.common,
|
|
),
|
|
EquipmentItem(
|
|
name: 'Shield',
|
|
slot: EquipmentSlot.shield,
|
|
level: 1,
|
|
weight: 15,
|
|
stats: const ItemStats(def: 3),
|
|
rarity: ItemRarity.common,
|
|
),
|
|
];
|
|
|
|
expect(ItemService.calculateTotalWeight(items), equals(25));
|
|
});
|
|
|
|
test('빈 목록의 총 무게는 0', () {
|
|
expect(ItemService.calculateTotalWeight([]), equals(0));
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// canEquip - 무게 기반 장착 가능 여부
|
|
// ========================================================================
|
|
group('canEquip', () {
|
|
test('무게 여유 있을 때 장착 가능', () {
|
|
final items = <EquipmentItem>[];
|
|
final newItem = EquipmentItem(
|
|
name: 'Light Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
weight: 10,
|
|
stats: const ItemStats(atk: 5),
|
|
rarity: ItemRarity.common,
|
|
);
|
|
|
|
final result = ItemService.canEquip(
|
|
newItem: newItem,
|
|
currentItems: items,
|
|
str: 10, // 최대 200
|
|
);
|
|
|
|
expect(result, isTrue);
|
|
});
|
|
|
|
test('교체 슬롯(replacingSlot) 지정 시 해당 무게 제외', () {
|
|
final existingWeapon = EquipmentItem(
|
|
name: 'Old Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
weight: 90,
|
|
stats: const ItemStats(atk: 3),
|
|
rarity: ItemRarity.common,
|
|
);
|
|
final newWeapon = EquipmentItem(
|
|
name: 'New Sword',
|
|
slot: EquipmentSlot.weapon,
|
|
level: 1,
|
|
weight: 95,
|
|
stats: const ItemStats(atk: 8),
|
|
rarity: ItemRarity.uncommon,
|
|
);
|
|
|
|
// STR 0 → 최대 100, 기존 90 장착 중
|
|
// 교체 시: 100 - 90 + 95 = 105 > 100 → 불가
|
|
final resultWithoutReplace = ItemService.canEquip(
|
|
newItem: newWeapon,
|
|
currentItems: [existingWeapon],
|
|
str: 0,
|
|
);
|
|
expect(resultWithoutReplace, isFalse);
|
|
|
|
// 교체 슬롯 지정: 0 + 95 = 95 ≤ 100 → 가능
|
|
final resultWithReplace = ItemService.canEquip(
|
|
newItem: newWeapon,
|
|
currentItems: [existingWeapon],
|
|
str: 0,
|
|
replacingSlot: EquipmentSlot.weapon,
|
|
);
|
|
expect(resultWithReplace, isTrue);
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// EquipmentItem.empty - 빈 아이템 처리
|
|
// ========================================================================
|
|
group('EquipmentItem.empty', () {
|
|
test('빈 아이템은 isEmpty가 true', () {
|
|
final empty = EquipmentItem.empty(EquipmentSlot.weapon);
|
|
|
|
expect(empty.isEmpty, isTrue);
|
|
expect(empty.isNotEmpty, isFalse);
|
|
expect(empty.name, isEmpty);
|
|
expect(empty.level, equals(0));
|
|
expect(empty.weight, equals(0));
|
|
expect(empty.rarity, equals(ItemRarity.common));
|
|
});
|
|
|
|
test('빈 아이템의 스탯은 모두 0', () {
|
|
final empty = EquipmentItem.empty(EquipmentSlot.shield);
|
|
final stats = empty.stats;
|
|
|
|
expect(stats.atk, equals(0));
|
|
expect(stats.def, equals(0));
|
|
expect(stats.magAtk, equals(0));
|
|
expect(stats.magDef, equals(0));
|
|
expect(stats.criRate, equals(0.0));
|
|
expect(stats.hpBonus, equals(0));
|
|
expect(stats.attackSpeed, equals(0));
|
|
});
|
|
|
|
test('빈 아이템의 장비 점수는 0', () {
|
|
final empty = EquipmentItem.empty(EquipmentSlot.helm);
|
|
final score = ItemService.calculateEquipmentScore(empty);
|
|
|
|
expect(score, equals(0));
|
|
});
|
|
|
|
test('빈 아이템의 toString은 "(empty)"', () {
|
|
final empty = EquipmentItem.empty(EquipmentSlot.weapon);
|
|
expect(empty.toString(), equals('(empty)'));
|
|
});
|
|
|
|
test('각 슬롯별 빈 아이템 생성', () {
|
|
for (final slot in EquipmentSlot.values) {
|
|
final empty = EquipmentItem.empty(slot);
|
|
expect(empty.slot, equals(slot));
|
|
expect(empty.isEmpty, isTrue);
|
|
}
|
|
});
|
|
});
|
|
|
|
// ========================================================================
|
|
// createDefaultEquipmentForSlot - 기본 장비 생성
|
|
// ========================================================================
|
|
group('createDefaultEquipmentForSlot', () {
|
|
test('기본 무기는 atk와 attackSpeed를 가짐', () {
|
|
final weapon = ItemService.createDefaultEquipmentForSlot(
|
|
EquipmentSlot.weapon,
|
|
);
|
|
|
|
expect(weapon.name, equals('Wooden Stick'));
|
|
expect(weapon.level, equals(1));
|
|
expect(weapon.rarity, equals(ItemRarity.common));
|
|
expect(weapon.stats.atk, equals(2));
|
|
expect(weapon.stats.attackSpeed, equals(1000));
|
|
});
|
|
|
|
test('기본 방패는 def와 blockRate를 가짐', () {
|
|
final shield = ItemService.createDefaultEquipmentForSlot(
|
|
EquipmentSlot.shield,
|
|
);
|
|
|
|
expect(shield.name, equals('Wooden Shield'));
|
|
expect(shield.stats.def, equals(1));
|
|
expect(shield.stats.blockRate, equals(0.05));
|
|
});
|
|
|
|
test('모든 슬롯에 기본 장비 생성 가능', () {
|
|
for (final slot in EquipmentSlot.values) {
|
|
final item = ItemService.createDefaultEquipmentForSlot(slot);
|
|
|
|
expect(item.slot, equals(slot));
|
|
expect(item.name, isNotEmpty);
|
|
expect(item.level, equals(1));
|
|
expect(item.weight, equals(1));
|
|
expect(item.rarity, equals(ItemRarity.common));
|
|
}
|
|
});
|
|
});
|
|
});
|
|
}
|