feat(combat): add CombatService orchestration and persistence
Wires the pure combat engine, character combat stats, and domain errors into a transactional service that validates the HuntEncounter boundary, snapshots stats into a new Combat row, and persists engine results.
This commit is contained in:
Bastian Wagner
339
apps/api/src/combat/combat.service.ts
Normal file
339
apps/api/src/combat/combat.service.ts
Normal file
@@ -0,0 +1,339 @@
|
||||
import { Injectable } from '@nestjs/common';
|
||||
import { DataSource, Repository } from 'typeorm';
|
||||
import { CharacterCombatStatsService } from '../characters/character-combat-stats.service';
|
||||
import { Character } from '../characters/entities/character.entity';
|
||||
import { Hunt } from '../hunting/entities/hunt.entity';
|
||||
import { HuntEncounter } from '../hunting/entities/hunt-encounter.entity';
|
||||
import { HuntStatus } from '../hunting/hunt-status.enum';
|
||||
import { MonsterDefinition } from '../monsters/entities/monster-definition.entity';
|
||||
import { TravelService } from '../travel/travel.service';
|
||||
import { TravelStatus } from '../travel/travel-status.enum';
|
||||
import { CombatAction } from './combat-action.enum';
|
||||
import { CombatEngineService } from './combat-engine.service';
|
||||
import { CombatEngineState } from './combat-engine.types';
|
||||
import {
|
||||
characterNotFound,
|
||||
characterTravelling,
|
||||
combatAlreadyActive,
|
||||
combatAlreadyFinished,
|
||||
combatNotFound,
|
||||
combatStateInvalid,
|
||||
huntEncounterAlreadyConsumed,
|
||||
huntEncounterNotFound,
|
||||
invalidHuntEncounter,
|
||||
} from './combat.errors';
|
||||
import { CombatStatus } from './combat-status.enum';
|
||||
import { CombatEvent } from './entities/combat-event.entity';
|
||||
import { Combat } from './entities/combat.entity';
|
||||
|
||||
export interface CombatPlayerDto {
|
||||
name: string;
|
||||
maxHp: number;
|
||||
currentHp: number;
|
||||
}
|
||||
|
||||
export interface CombatMonsterDto {
|
||||
key: string;
|
||||
name: string;
|
||||
level: number;
|
||||
maxHp: number;
|
||||
currentHp: number;
|
||||
artworkPath: string;
|
||||
}
|
||||
|
||||
export interface CombatEventDto {
|
||||
round: number;
|
||||
sequence: number;
|
||||
type: string;
|
||||
source: string;
|
||||
target: string;
|
||||
amount?: number;
|
||||
}
|
||||
|
||||
export interface CombatDto {
|
||||
id: string;
|
||||
status: CombatStatus;
|
||||
round: number;
|
||||
player: CombatPlayerDto;
|
||||
monster: CombatMonsterDto;
|
||||
events: CombatEventDto[];
|
||||
}
|
||||
|
||||
@Injectable()
|
||||
export class CombatService {
|
||||
constructor(
|
||||
private readonly dataSource: DataSource,
|
||||
private readonly travelService: TravelService,
|
||||
private readonly combatEngine: CombatEngineService,
|
||||
private readonly characterCombatStats: CharacterCombatStatsService,
|
||||
) {}
|
||||
|
||||
async startCombat(
|
||||
characterId: string,
|
||||
encounterId: string,
|
||||
): Promise<CombatDto> {
|
||||
const travel = await this.travelService.completeTravelIfDue(characterId);
|
||||
if (travel.status === TravelStatus.TRAVELLING) {
|
||||
throw characterTravelling();
|
||||
}
|
||||
|
||||
return this.dataSource.transaction(async (manager) => {
|
||||
const characters = manager.getRepository(Character);
|
||||
const encounters = manager.getRepository(HuntEncounter);
|
||||
const hunts = manager.getRepository(Hunt);
|
||||
const monsters = manager.getRepository(MonsterDefinition);
|
||||
const combats = manager.getRepository(Combat);
|
||||
|
||||
const character = await this.lockCharacter(characters, characterId);
|
||||
|
||||
const encounter = await encounters.findOne({
|
||||
where: { id: encounterId },
|
||||
lock: { mode: 'pessimistic_write' },
|
||||
});
|
||||
if (!encounter) {
|
||||
throw huntEncounterNotFound();
|
||||
}
|
||||
if (encounter.consumedAt) {
|
||||
throw huntEncounterAlreadyConsumed();
|
||||
}
|
||||
|
||||
const hunt = await hunts.findOneBy({ id: encounter.huntId });
|
||||
if (
|
||||
!hunt ||
|
||||
hunt.characterId !== characterId ||
|
||||
hunt.status !== HuntStatus.ACTIVE
|
||||
) {
|
||||
throw invalidHuntEncounter();
|
||||
}
|
||||
|
||||
const existingActiveCombat = await combats.findOne({
|
||||
where: { characterId, status: CombatStatus.ACTIVE },
|
||||
lock: { mode: 'pessimistic_write' },
|
||||
});
|
||||
if (existingActiveCombat) {
|
||||
throw combatAlreadyActive();
|
||||
}
|
||||
|
||||
const monster = await monsters.findOneBy({
|
||||
id: encounter.monsterDefinitionId,
|
||||
});
|
||||
if (!monster) {
|
||||
throw invalidHuntEncounter();
|
||||
}
|
||||
|
||||
const playerStats = this.characterCombatStats.getStats(character);
|
||||
|
||||
const combat = combats.create({
|
||||
characterId,
|
||||
huntEncounterId: encounter.id,
|
||||
monsterDefinitionId: monster.id,
|
||||
status: CombatStatus.ACTIVE,
|
||||
round: 1,
|
||||
playerMaxHp: playerStats.maxHp,
|
||||
playerCurrentHp: playerStats.maxHp,
|
||||
monsterMaxHp: monster.maxHp,
|
||||
monsterCurrentHp: monster.maxHp,
|
||||
playerState: {
|
||||
attack: playerStats.attack,
|
||||
weaponDamage: playerStats.weaponDamage,
|
||||
armor: playerStats.armor,
|
||||
},
|
||||
monsterState: { attack: monster.attack, armor: monster.armor },
|
||||
completedAt: null,
|
||||
});
|
||||
await combats.save(combat);
|
||||
|
||||
encounter.consumedAt = new Date();
|
||||
await encounters.save(encounter);
|
||||
|
||||
return this.toCombatDto(combat, character.name, monster, []);
|
||||
});
|
||||
}
|
||||
|
||||
async getCombat(characterId: string, combatId: string): Promise<CombatDto> {
|
||||
const combats = this.dataSource.getRepository(Combat);
|
||||
const combat = await combats.findOne({
|
||||
where: { id: combatId, characterId },
|
||||
});
|
||||
if (!combat) {
|
||||
throw combatNotFound();
|
||||
}
|
||||
|
||||
const [character, monster, events] = await Promise.all([
|
||||
this.loadCharacter(combat.characterId),
|
||||
this.loadMonster(combat.monsterDefinitionId),
|
||||
this.loadEvents(combat.id),
|
||||
]);
|
||||
|
||||
return this.toCombatDto(combat, character.name, monster, events);
|
||||
}
|
||||
|
||||
async performAction(
|
||||
characterId: string,
|
||||
combatId: string,
|
||||
action: CombatAction,
|
||||
): Promise<CombatDto> {
|
||||
return this.dataSource.transaction(async (manager) => {
|
||||
const combats = manager.getRepository(Combat);
|
||||
const combatEvents = manager.getRepository(CombatEvent);
|
||||
|
||||
const combat = await combats.findOne({
|
||||
where: { id: combatId, characterId },
|
||||
lock: { mode: 'pessimistic_write' },
|
||||
});
|
||||
if (!combat) {
|
||||
throw combatNotFound();
|
||||
}
|
||||
if (combat.status !== CombatStatus.ACTIVE) {
|
||||
throw combatAlreadyFinished();
|
||||
}
|
||||
|
||||
const actionRound = combat.round;
|
||||
const engineState = this.toEngineState(combat);
|
||||
const result = this.combatEngine.resolveAction(engineState, { action });
|
||||
|
||||
combat.round = result.state.round;
|
||||
combat.status = result.state.status;
|
||||
combat.playerCurrentHp = result.state.player.currentHp;
|
||||
combat.monsterCurrentHp = result.state.monster.currentHp;
|
||||
if (combat.status !== CombatStatus.ACTIVE) {
|
||||
combat.completedAt = new Date();
|
||||
}
|
||||
await combats.save(combat);
|
||||
|
||||
const startingSequence = await combatEvents.count({
|
||||
where: { combatId: combat.id },
|
||||
});
|
||||
for (let index = 0; index < result.events.length; index += 1) {
|
||||
const event = result.events[index];
|
||||
const entity = combatEvents.create({
|
||||
combatId: combat.id,
|
||||
round: actionRound,
|
||||
sequence: startingSequence + index + 1,
|
||||
type: event.type,
|
||||
source: event.source,
|
||||
target: event.target,
|
||||
amount: event.amount ?? null,
|
||||
});
|
||||
await combatEvents.save(entity);
|
||||
}
|
||||
|
||||
const [character, monster, events] = await Promise.all([
|
||||
this.loadCharacter(
|
||||
combat.characterId,
|
||||
manager.getRepository(Character),
|
||||
),
|
||||
this.loadMonster(
|
||||
combat.monsterDefinitionId,
|
||||
manager.getRepository(MonsterDefinition),
|
||||
),
|
||||
this.loadEvents(combat.id, combatEvents),
|
||||
]);
|
||||
|
||||
return this.toCombatDto(combat, character.name, monster, events);
|
||||
});
|
||||
}
|
||||
|
||||
private async lockCharacter(
|
||||
characters: Repository<Character>,
|
||||
characterId: string,
|
||||
): Promise<Character> {
|
||||
const character = await characters.findOne({
|
||||
where: { id: characterId },
|
||||
lock: { mode: 'pessimistic_write' },
|
||||
});
|
||||
if (!character) {
|
||||
throw characterNotFound();
|
||||
}
|
||||
return character;
|
||||
}
|
||||
|
||||
private async loadCharacter(
|
||||
characterId: string,
|
||||
repo?: Repository<Character>,
|
||||
): Promise<Character> {
|
||||
const characters = repo ?? this.dataSource.getRepository(Character);
|
||||
const character = await characters.findOneBy({ id: characterId });
|
||||
if (!character) {
|
||||
// combats.character_id is a RESTRICT FK; a persisted combat's
|
||||
// character is guaranteed to exist.
|
||||
throw combatStateInvalid();
|
||||
}
|
||||
return character;
|
||||
}
|
||||
|
||||
private async loadMonster(
|
||||
monsterId: string,
|
||||
repo?: Repository<MonsterDefinition>,
|
||||
): Promise<MonsterDefinition> {
|
||||
const monsters = repo ?? this.dataSource.getRepository(MonsterDefinition);
|
||||
const monster = await monsters.findOneBy({ id: monsterId });
|
||||
if (!monster) {
|
||||
// combats.monster_definition_id is a RESTRICT FK; guaranteed to exist.
|
||||
throw combatStateInvalid();
|
||||
}
|
||||
return monster;
|
||||
}
|
||||
|
||||
private loadEvents(
|
||||
combatId: string,
|
||||
repo?: Repository<CombatEvent>,
|
||||
): Promise<CombatEvent[]> {
|
||||
const combatEvents = repo ?? this.dataSource.getRepository(CombatEvent);
|
||||
return combatEvents.find({
|
||||
where: { combatId },
|
||||
order: { sequence: 'ASC' },
|
||||
});
|
||||
}
|
||||
|
||||
private toEngineState(combat: Combat): CombatEngineState {
|
||||
return {
|
||||
status: combat.status,
|
||||
round: combat.round,
|
||||
player: {
|
||||
currentHp: combat.playerCurrentHp,
|
||||
maxHp: combat.playerMaxHp,
|
||||
stats: combat.playerState,
|
||||
},
|
||||
monster: {
|
||||
currentHp: combat.monsterCurrentHp,
|
||||
maxHp: combat.monsterMaxHp,
|
||||
stats: combat.monsterState,
|
||||
},
|
||||
};
|
||||
}
|
||||
|
||||
private toCombatDto(
|
||||
combat: Combat,
|
||||
playerName: string,
|
||||
monster: MonsterDefinition,
|
||||
events: CombatEvent[],
|
||||
): CombatDto {
|
||||
return {
|
||||
id: combat.id,
|
||||
status: combat.status,
|
||||
round: combat.round,
|
||||
player: {
|
||||
name: playerName,
|
||||
maxHp: combat.playerMaxHp,
|
||||
currentHp: combat.playerCurrentHp,
|
||||
},
|
||||
monster: {
|
||||
key: monster.key,
|
||||
name: monster.name,
|
||||
level: monster.level,
|
||||
maxHp: combat.monsterMaxHp,
|
||||
currentHp: combat.monsterCurrentHp,
|
||||
artworkPath: monster.artworkPath,
|
||||
},
|
||||
events: events.map((event) => ({
|
||||
round: event.round,
|
||||
sequence: event.sequence,
|
||||
type: event.type,
|
||||
source: event.source,
|
||||
target: event.target,
|
||||
amount: event.amount ?? undefined,
|
||||
})),
|
||||
};
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user