575 lines
35 KiB
Java
575 lines
35 KiB
Java
package games.dmg.fantasystick.ability;
|
|
|
|
import games.dmg.fantasystick.party.PartyRoster;
|
|
import games.dmg.fantasystick.persistence.CharacterRecord;
|
|
import games.dmg.fantasystick.persistence.CharacterStorage;
|
|
import games.dmg.fantasystick.session.ControlInput;
|
|
import games.dmg.fantasystick.session.EquipmentSessions;
|
|
import java.math.BigInteger;
|
|
import java.time.Clock;
|
|
import java.time.DateTimeException;
|
|
import java.time.Duration;
|
|
import java.time.Instant;
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
import java.util.UUID;
|
|
import java.util.concurrent.CompletableFuture;
|
|
import java.util.function.Consumer;
|
|
import org.bukkit.entity.Entity;
|
|
import org.bukkit.entity.LivingEntity;
|
|
import org.bukkit.entity.Player;
|
|
|
|
/** Shared character mutation, cooldown, target, execution, report and cleanup boundary. */
|
|
public final class AbilityEngine implements Consumer<ControlInput>, AutoCloseable {
|
|
public record Failure(UUID character, String ability, Throwable cause) { }
|
|
public record Mutation(CharacterStorage.AbilityMutationStatus status, CharacterRecord record) { }
|
|
private record Key(UUID character, String ability) { }
|
|
|
|
private final AbilityRegistry registry;
|
|
private final CharacterStorage characters;
|
|
private final EquipmentSessions sessions;
|
|
private final PartyRoster parties;
|
|
private final Clock clock;
|
|
private final Consumer<Runnable> nextTick;
|
|
private final AbilityScheduler scheduler;
|
|
private final Consumer<AbilityReport> reports;
|
|
private final AbilityFeedback feedback;
|
|
private final games.dmg.fantasystick.training.TrainingDamage trainingDamage;
|
|
private final Consumer<Failure> failures;
|
|
private final Map<Key, Object> pending = new HashMap<>();
|
|
private final Set<String> eventOwnedAbilities = new HashSet<>();
|
|
private final Map<Key, Long> generations = new HashMap<>();
|
|
private final Map<Key, Set<Runtime>> active = new HashMap<>();
|
|
private org.bukkit.scheduler.BukkitTask sweepTask;
|
|
private games.dmg.fantasystick.events.AbilityCastEventBridge castEvents;
|
|
private boolean closed;
|
|
|
|
public void attachCastEvents(games.dmg.fantasystick.events.AbilityCastEventBridge events) {
|
|
if (closed || castEvents != null) throw new IllegalStateException("Cast events already attached or engine closed");
|
|
castEvents = Objects.requireNonNull(events);
|
|
}
|
|
|
|
/** An ability owner opts in only after its actual effect-specific event path is delivered. */
|
|
public void enableCastEventsFor(String abilityId) {
|
|
if (closed || registry.find(Objects.requireNonNull(abilityId)).isEmpty())
|
|
throw new IllegalArgumentException("Unknown or closed ability event owner");
|
|
eventOwnedAbilities.add(abilityId);
|
|
}
|
|
|
|
public boolean eventsEnabledFor(String abilityId) { return eventOwnedAbilities.contains(abilityId); }
|
|
|
|
private void resolve(games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit,
|
|
String outcome, String reason) {
|
|
if (castEvents != null) castEvents.resolved(audit, outcome, reason);
|
|
}
|
|
|
|
private void refuseCast(ControlInput input, CharacterRecord record, AbilityDefinition definition, String reason) {
|
|
if (castEvents == null || record == null
|
|
|| !(definition.id().equals("great_sword") || definition.id().equals("longbow")
|
|
|| definition.id().equals("quickstep") || definition.id().equals("second_wind")
|
|
|| definition.id().equals("shield_bash") || definition.id().equals("hex")
|
|
|| definition.id().equals("inspire"))
|
|
|| !eventOwnedAbilities.contains(definition.id())) return;
|
|
resolve(castEvents.begin(input, record, definition), "refused", reason);
|
|
}
|
|
|
|
public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
|
|
PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
|
|
Consumer<AbilityReport> reports, Consumer<Failure> failures) {
|
|
this(registry, characters, sessions, parties, clock, nextTick, scheduler, reports,
|
|
(definition, input, type, target, amount) -> { },
|
|
games.dmg.fantasystick.training.TrainingDamage.passthrough(), failures);
|
|
}
|
|
|
|
public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
|
|
PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
|
|
Consumer<AbilityReport> reports, AbilityFeedback feedback, Consumer<Failure> failures) {
|
|
this(registry, characters, sessions, parties, clock, nextTick, scheduler, reports, feedback,
|
|
games.dmg.fantasystick.training.TrainingDamage.passthrough(), failures);
|
|
}
|
|
|
|
public AbilityEngine(AbilityRegistry registry, CharacterStorage characters, EquipmentSessions sessions,
|
|
PartyRoster parties, Clock clock, Consumer<Runnable> nextTick, AbilityScheduler scheduler,
|
|
Consumer<AbilityReport> reports, AbilityFeedback feedback,
|
|
games.dmg.fantasystick.training.TrainingDamage trainingDamage, Consumer<Failure> failures) {
|
|
this.registry = Objects.requireNonNull(registry); this.characters = Objects.requireNonNull(characters);
|
|
this.sessions = Objects.requireNonNull(sessions); this.parties = Objects.requireNonNull(parties);
|
|
this.clock = Objects.requireNonNull(clock); this.nextTick = Objects.requireNonNull(nextTick);
|
|
this.scheduler = Objects.requireNonNull(scheduler); this.reports = Objects.requireNonNull(reports);
|
|
this.feedback = Objects.requireNonNull(feedback); this.trainingDamage = Objects.requireNonNull(trainingDamage);
|
|
this.failures = Objects.requireNonNull(failures);
|
|
}
|
|
|
|
public void install(org.bukkit.plugin.Plugin plugin) {
|
|
if (closed || sweepTask != null) throw new IllegalStateException("Ability engine is already installed or closed");
|
|
sweepTask = plugin.getServer().getScheduler().runTaskTimer(plugin, this::sweep, 1, 1);
|
|
}
|
|
|
|
public CompletableFuture<Mutation> purchase(ControlInput input, String ability, BigInteger expectedRevision) {
|
|
Objects.requireNonNull(input); Objects.requireNonNull(expectedRevision);
|
|
var definition = registry.find(ability).orElse(null);
|
|
if (closed || definition == null || input.kind() != ControlInput.Kind.BOOK || !input.stillCurrent()) {
|
|
return CompletableFuture.completedFuture(new Mutation(CharacterStorage.AbilityMutationStatus.UNAVAILABLE, null));
|
|
}
|
|
return mutation(input, ability, expectedRevision,
|
|
() -> characters.unlockAbility(input.session().character(), expectedRevision, ability,
|
|
definition.requirements(), definition.pointCost()));
|
|
}
|
|
|
|
public CompletableFuture<Mutation> assign(ControlInput input, String ability, int slot, BigInteger expectedRevision) {
|
|
Objects.requireNonNull(input); Objects.requireNonNull(expectedRevision);
|
|
if (closed || registry.find(ability).isEmpty() || input.kind() != ControlInput.Kind.BOOK || !input.stillCurrent()) {
|
|
return CompletableFuture.completedFuture(new Mutation(CharacterStorage.AbilityMutationStatus.UNAVAILABLE, null));
|
|
}
|
|
return mutation(input, ability, expectedRevision,
|
|
() -> characters.assignAbility(input.session().character(), expectedRevision, ability, slot));
|
|
}
|
|
|
|
public CompletableFuture<Mutation> unlearn(ControlInput input, String ability, BigInteger expectedRevision) {
|
|
Objects.requireNonNull(input); Objects.requireNonNull(expectedRevision);
|
|
if (closed || registry.find(ability).isEmpty() || input.kind() != ControlInput.Kind.BOOK || !input.stillCurrent()) {
|
|
return CompletableFuture.completedFuture(new Mutation(CharacterStorage.AbilityMutationStatus.UNAVAILABLE, null));
|
|
}
|
|
return mutation(input, ability, expectedRevision,
|
|
() -> characters.unlearnAbility(input.session().character(), expectedRevision, ability))
|
|
.thenApply(mutation -> {
|
|
if (mutation.record() != null && !mutation.record().learned().contains(ability)) {
|
|
remove(input.session().character(), ability);
|
|
}
|
|
return mutation;
|
|
});
|
|
}
|
|
|
|
private CompletableFuture<Mutation> mutation(ControlInput input, String ability, BigInteger expectedRevision,
|
|
java.util.function.Supplier<CompletableFuture<CharacterStorage.AbilityMutation>> operation) {
|
|
var result = new CompletableFuture<Mutation>();
|
|
CompletableFuture<CharacterStorage.AbilityMutation> work;
|
|
try { work = operation.get(); }
|
|
catch (RuntimeException failure) { report(input.session().character(), ability, failure); result.completeExceptionally(failure); return result; }
|
|
work.whenComplete((mutation, failure) -> schedule(input.session().character(), ability, result, () -> {
|
|
if (failure != null) { report(input.session().character(), ability, failure); result.completeExceptionally(failure); return; }
|
|
var record = mutation.record().orElse(null);
|
|
if (mutation.status() == CharacterStorage.AbilityMutationStatus.APPLIED) {
|
|
try {
|
|
if (record == null || !input.stillCurrent()
|
|
|| !sessions.acknowledgeProgress(input.session(), expectedRevision, record)) {
|
|
result.complete(new Mutation(CharacterStorage.AbilityMutationStatus.STALE, record)); return;
|
|
}
|
|
} catch (RuntimeException nativeFailure) {
|
|
report(input.session().character(), ability, nativeFailure);
|
|
result.completeExceptionally(nativeFailure); return;
|
|
}
|
|
}
|
|
result.complete(new Mutation(mutation.status(), record));
|
|
}));
|
|
return result;
|
|
}
|
|
|
|
@Override public void accept(ControlInput input) {
|
|
if (closed || input.kind() != ControlInput.Kind.ABILITY || !input.stillCurrent()) return;
|
|
var definition = registry.find(input.ability()).orElse(null);
|
|
if (definition == null || definition.gesture() != input.gesture()) {
|
|
input.player().sendMessage("That ability is unavailable."); return;
|
|
}
|
|
var record = sessions.currentRecord(input.session()).orElse(null);
|
|
if (record == null || !record.learned().contains(definition.id())
|
|
|| input.slot() < 2 || !record.loadout().get(input.slot() - 2).equals(definition.id())) {
|
|
refuseCast(input, record, definition, "not_learned_or_assigned");
|
|
input.player().sendMessage("That ability is not learned and assigned to this control."); return;
|
|
}
|
|
Instant now = clock.instant();
|
|
Instant existing = record.cooldowns().get(definition.id());
|
|
if (existing != null && now.isBefore(existing)) {
|
|
refuseCast(input, record, definition, "cooldown_active");
|
|
input.player().sendMessage("" + definition.name() + " is ready in "
|
|
+ Math.max(1, Duration.between(now, existing).toSeconds()) + " seconds."); return;
|
|
}
|
|
boolean accepted;
|
|
try { accepted = eligible(definition.targetPolicy(), input, input.target()) && definition.effect().accepts(input); }
|
|
catch (RuntimeException invalid) {
|
|
report(input.session().character(), definition.id(), invalid);
|
|
input.player().sendMessage("That target could not be validated for " + definition.name() + "."); return;
|
|
}
|
|
if (!accepted) {
|
|
refuseCast(input, record, definition, "target_ineligible");
|
|
input.player().sendMessage("That target is not eligible for " + definition.name() + "."); return;
|
|
}
|
|
var key = new Key(input.session().character(), definition.id());
|
|
Object token = new Object();
|
|
if (pending.putIfAbsent(key, token) != null) {
|
|
refuseCast(input, record, definition, "save_in_progress");
|
|
input.player().sendMessage("That cast is still being saved."); return;
|
|
}
|
|
long generation = generations.getOrDefault(key, 0L);
|
|
Instant readyAt;
|
|
try { readyAt = now.plus(definition.cooldown()); }
|
|
catch (DateTimeException | ArithmeticException invalid) {
|
|
pending.remove(key, token); report(key.character(), key.ability(), invalid);
|
|
input.player().sendMessage("That ability's cooldown is invalid."); return;
|
|
}
|
|
var audit = castEvents == null || !eventOwnedAbilities.contains(definition.id())
|
|
? null : castEvents.begin(input, record, definition);
|
|
try {
|
|
characters.commitAbilityCooldown(key.character(), record.revision(), key.ability(), readyAt)
|
|
.whenComplete((mutation, failure) -> {
|
|
try {
|
|
nextTick.accept(() -> completeCast(input, definition, record.revision(), readyAt,
|
|
key, token, generation, audit, mutation, failure));
|
|
} catch (RuntimeException rejected) {
|
|
pending.remove(key, token); resolve(audit, "failed", "scheduler_rejected");
|
|
report(key.character(), key.ability(), rejected);
|
|
}
|
|
});
|
|
} catch (RuntimeException failure) {
|
|
pending.remove(key, token); resolve(audit, "failed", "save_rejected");
|
|
report(key.character(), key.ability(), failure);
|
|
}
|
|
}
|
|
|
|
private void completeCast(ControlInput input, AbilityDefinition definition, BigInteger expectedRevision, Instant readyAt,
|
|
Key key, Object token, long generation, games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit,
|
|
CharacterStorage.AbilityMutation mutation, Throwable failure) {
|
|
if (!pending.remove(key, token) || closed) { resolve(audit, "interrupted", "session_or_engine_closed"); return; }
|
|
if (failure != null) {
|
|
resolve(audit, "failed", "save_failed");
|
|
report(key.character(), key.ability(), failure);
|
|
input.player().sendMessage("The cast could not be saved; no effect was applied."); return;
|
|
}
|
|
boolean unchangedDeadline = mutation.status() == CharacterStorage.AbilityMutationStatus.UNCHANGED
|
|
&& mutation.record().map(record -> readyAt.equals(record.cooldowns().get(key.ability()))).orElse(false);
|
|
if ((mutation.status() != CharacterStorage.AbilityMutationStatus.APPLIED && !unchangedDeadline)
|
|
|| mutation.record().isEmpty()) {
|
|
resolve(audit, "refused", mutation.status().name().toLowerCase(java.util.Locale.ROOT));
|
|
input.player().sendMessage(switch (mutation.status()) {
|
|
case COOLDOWN -> "That ability is still on cooldown.";
|
|
case STALE -> "That character changed; retry the cast.";
|
|
case NOT_LEARNED, UNAVAILABLE -> "That ability is no longer available to this character.";
|
|
default -> "The cast was refused without applying an effect.";
|
|
});
|
|
return;
|
|
}
|
|
CharacterRecord saved = mutation.record().orElseThrow();
|
|
boolean deferNativeCast = audit != null && definition.id().equals("quickstep");
|
|
if (castEvents != null && !deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
|
|
boolean synchronizedProgress = unchangedDeadline
|
|
? sessions.currentRecord(input.session()).filter(saved::equals).isPresent()
|
|
: sessions.acknowledgeProgress(input.session(), expectedRevision, saved);
|
|
if (!synchronizedProgress) {
|
|
if (deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
|
|
resolve(audit, "interrupted", "session_publication_changed");
|
|
input.player().sendMessage("The cooldown was saved, but the session changed; no effect was applied."); return;
|
|
}
|
|
if (!input.stillCurrent() || generations.getOrDefault(key, 0L) != generation
|
|
|| !eligible(definition.targetPolicy(), input, input.target())) {
|
|
if (deferNativeCast) castEvents.cast(audit, saved, readyAt, definition);
|
|
resolve(audit, "interrupted", "eligibility_changed");
|
|
input.player().sendMessage("The cooldown was saved, but eligibility changed; no effect was applied."); return;
|
|
}
|
|
var runtime = new Runtime(key, input, definition, generation, audit,
|
|
deferNativeCast ? saved : null, readyAt);
|
|
active.computeIfAbsent(key, ignored -> new HashSet<>()).add(runtime);
|
|
try {
|
|
definition.effect().activate(runtime);
|
|
runtime.publishCast();
|
|
if (definition.activation() == AbilityDefinition.Activation.IMMEDIATE) runtime.finish();
|
|
} catch (RuntimeException effectFailure) {
|
|
runtime.publishCast();
|
|
runtime.resolve("failed"); runtime.close(); report(key.character(), key.ability(), effectFailure);
|
|
input.player().sendMessage("The cooldown was saved, but the ability effect failed safely.");
|
|
}
|
|
}
|
|
|
|
/** Future refund/removal paths invalidate pending callbacks and close only this ability's owned work. */
|
|
public void remove(UUID character, String ability) {
|
|
var key = new Key(Objects.requireNonNull(character), Objects.requireNonNull(ability));
|
|
generations.put(key, generations.getOrDefault(key, 0L) + 1);
|
|
pending.remove(key);
|
|
for (var runtime : List.copyOf(active.getOrDefault(key, Set.of()))) runtime.close();
|
|
}
|
|
|
|
/** Bounded lifecycle sweep; plugin timers may call this without scanning future catalogues. */
|
|
public void sweep() {
|
|
if (closed) return;
|
|
sessions.refreshCooldownControls(64);
|
|
int checked = 0;
|
|
outer: for (var runtimes : List.copyOf(active.values())) {
|
|
for (var runtime : List.copyOf(runtimes)) {
|
|
if (!runtime.stillCurrent()) runtime.close();
|
|
if (++checked == 64) break outer;
|
|
}
|
|
}
|
|
}
|
|
|
|
private boolean eligible(AbilityDefinition.TargetPolicy policy, ControlInput input, Entity target) {
|
|
return switch (policy) {
|
|
case SELF -> target == null || target == input.player();
|
|
case HOSTILE -> hostile(input, target);
|
|
case PROJECTILE_HOSTILE -> target == null || hostile(input, target);
|
|
case ALLY -> target instanceof Player player && fantasy(player);
|
|
case PARTY -> target instanceof Player player
|
|
&& (player == input.player() || fantasy(player) && sameParty(input.player(), player));
|
|
case AREA -> target == null || target instanceof LivingEntity && (!(target instanceof Player player) || fantasy(player));
|
|
case SELECTION -> target == null || target instanceof LivingEntity && (!(target instanceof Player player) || fantasy(player));
|
|
case EXCEPTIONAL_NONCOMBAT -> target instanceof Player && target != input.player();
|
|
case EXCEPTIONAL_NONCOMBAT_SELECTION -> target == null || target instanceof Player && target != input.player();
|
|
};
|
|
}
|
|
|
|
private boolean hostile(ControlInput input, Entity target) {
|
|
return target instanceof LivingEntity && target != input.player()
|
|
&& (!(target instanceof Player player) || fantasy(player) && !sameParty(input.player(), player));
|
|
}
|
|
|
|
private boolean fantasy(Player player) { return sessions.active(player.getUniqueId()).filter(sessions::current).isPresent(); }
|
|
private boolean sameParty(Player source, Player target) {
|
|
return parties.partyOf(source.getUniqueId()).filter(party -> party.members().contains(target.getUniqueId())).isPresent();
|
|
}
|
|
|
|
private <T> void schedule(UUID character, String ability, CompletableFuture<T> result, Runnable action) {
|
|
try { nextTick.accept(action); }
|
|
catch (RuntimeException rejected) {
|
|
report(character, ability, rejected);
|
|
if (result != null) result.completeExceptionally(rejected);
|
|
}
|
|
}
|
|
|
|
private void report(UUID character, String ability, Throwable failure) {
|
|
try { failures.accept(new Failure(character, ability, failure)); }
|
|
catch (RuntimeException ignored) { /* Diagnostics never authorize or replay an effect. */ }
|
|
}
|
|
|
|
private final class Runtime implements AbilityExecution {
|
|
private final Key key;
|
|
private final ControlInput input;
|
|
private final AbilityDefinition definition;
|
|
private final long generation;
|
|
private final games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit;
|
|
private final CharacterRecord deferredCastRecord;
|
|
private final Instant deferredDeadline;
|
|
private final Map<String, Object> castEvidence = new HashMap<>();
|
|
private boolean castPublished;
|
|
private final Map<UUID, String> observedEffects = new HashMap<>();
|
|
private final Map<UUID, Map<String, Object>> observedEndEvidence = new HashMap<>();
|
|
private final Set<AutoCloseable> owned = new HashSet<>();
|
|
private String outcome;
|
|
private Map<String, Object> resolutionEvidence = Map.of();
|
|
private boolean finished;
|
|
private boolean closing;
|
|
private int scheduled;
|
|
|
|
Runtime(Key key, ControlInput input, AbilityDefinition definition, long generation,
|
|
games.dmg.fantasystick.events.AbilityCastEventBridge.Cast audit,
|
|
CharacterRecord deferredCastRecord, Instant deferredDeadline) {
|
|
this.key = key; this.input = input; this.definition = definition; this.generation = generation;
|
|
this.audit = audit; this.deferredCastRecord = deferredCastRecord; this.deferredDeadline = deferredDeadline;
|
|
}
|
|
void publishCast() {
|
|
if (deferredCastRecord == null || castPublished) return;
|
|
castPublished = true;
|
|
if (castEvents != null) castEvents.cast(audit, deferredCastRecord, deferredDeadline, definition,
|
|
Map.copyOf(castEvidence));
|
|
}
|
|
@Override public void castEvidence(Map<String, Object> evidence) {
|
|
if (!castPublished && !finished && deferredCastRecord != null)
|
|
castEvidence.putAll(Objects.requireNonNull(evidence));
|
|
}
|
|
@Override public void resolutionEvidence(Map<String, Object> evidence) {
|
|
if (!finished) {
|
|
var combined = new java.util.LinkedHashMap<>(resolutionEvidence);
|
|
combined.putAll(Objects.requireNonNull(evidence));
|
|
resolutionEvidence = Map.copyOf(combined);
|
|
}
|
|
}
|
|
@Override public AbilityDefinition definition() { return definition; }
|
|
@Override public ControlInput input() { return input; }
|
|
@Override public CharacterRecord character() {
|
|
return sessions.currentRecord(input.session()).orElseThrow(() -> new IllegalStateException("Ability session ended"));
|
|
}
|
|
@Override public boolean stillCurrent() {
|
|
return !closed && !finished && !closing && input.stillCurrent() && sessions.current(input.session())
|
|
&& generations.getOrDefault(key, 0L) == generation
|
|
&& sessions.currentRecord(input.session()).filter(record -> record.learned().contains(key.ability())).isPresent();
|
|
}
|
|
@Override public List<Entity> eligible(Collection<? extends Entity> candidates, int maximum) {
|
|
Objects.requireNonNull(candidates);
|
|
if (maximum < 1 || maximum > 64) throw new IllegalArgumentException("Recipient bound must be 1..64");
|
|
var result = new ArrayList<Entity>(); int inspected = 0;
|
|
for (var candidate : candidates) {
|
|
if (++inspected > 256 || result.size() == maximum) break;
|
|
if (stillCurrent() && AbilityEngine.this.eligible(definition.targetPolicy(), input, candidate)) result.add(candidate);
|
|
}
|
|
return List.copyOf(result);
|
|
}
|
|
@Override public AbilityScheduler.Task later(Duration delay, Runnable action) {
|
|
Objects.requireNonNull(delay); Objects.requireNonNull(action);
|
|
if (delay.isNegative() || delay.compareTo(Duration.ofDays(365)) > 0 || ++scheduled > 64) {
|
|
throw new IllegalArgumentException("Delayed effect is outside the bounded execution contract");
|
|
}
|
|
var task = scheduler.later(delay, () -> {
|
|
if (!stillCurrent() || !AbilityEngine.this.eligible(definition.targetPolicy(), input, input.target())) {
|
|
close(); return;
|
|
}
|
|
try { action.run(); }
|
|
catch (RuntimeException failure) {
|
|
close(); AbilityEngine.this.report(key.character(), key.ability(), failure);
|
|
}
|
|
});
|
|
own(task); return task;
|
|
}
|
|
@Override public void own(AutoCloseable resource) {
|
|
Objects.requireNonNull(resource);
|
|
if (finished || owned.size() >= 64) {
|
|
try { resource.close(); } catch (Exception ignored) { }
|
|
if (!finished) throw new IllegalStateException("Ability owns too many resources");
|
|
return;
|
|
}
|
|
owned.add(resource);
|
|
}
|
|
@Override public boolean trainingDummy(Entity target) { return trainingDamage.target(Objects.requireNonNull(target)); }
|
|
@Override public void damage(org.bukkit.entity.LivingEntity target, double amount,
|
|
org.bukkit.damage.DamageSource source) {
|
|
Objects.requireNonNull(target); Objects.requireNonNull(source);
|
|
games.dmg.fantasystick.training.TrainingDamage.Source metadata = null;
|
|
try {
|
|
var record = sessions.currentRecord(input.session()).orElse(null);
|
|
if (record != null) metadata = new games.dmg.fantasystick.training.TrainingDamage.Source(
|
|
audit == null ? UUID.randomUUID() : audit.actionId(), input.session().player(), record.id(), record.name(),
|
|
input.session().session(), definition.name(), definition.id());
|
|
} catch (RuntimeException ignored) { /* Unavailable audit metadata cannot change the existing effect. */ }
|
|
var measured = trainingDamage.apply(input.player(), target, metadata, () -> target.damage(amount, source));
|
|
measured.ifPresent(value -> report(AbilityReport.Type.DAMAGE, target, value));
|
|
}
|
|
@Override public void report(AbilityReport.Type type, Entity target, java.math.BigDecimal amount) {
|
|
if (!stillCurrent() || definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT
|
|
|| definition.targetPolicy() == AbilityDefinition.TargetPolicy.EXCEPTIONAL_NONCOMBAT_SELECTION
|
|
|| target == null || !AbilityEngine.this.eligible(definition.targetPolicy(), input, target)) return;
|
|
var report = new AbilityReport(type, key.character(), input.session().session(), target.getUniqueId(), amount, clock.instant());
|
|
reports.accept(report);
|
|
try { feedback.report(definition, input, type, target, report.amount()); }
|
|
catch (RuntimeException failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
|
|
}
|
|
@Override public java.time.Instant now() { return clock.instant(); }
|
|
@Override public UUID effectApplied(String effectId, Entity target, Map<String, Object> evidence) {
|
|
if (!stillCurrent()) throw new IllegalStateException("Ability execution ended");
|
|
Objects.requireNonNull(effectId); Objects.requireNonNull(evidence);
|
|
UUID application = castEvents == null ? UUID.randomUUID() : castEvents.effectApplied(audit, effectId, target, evidence);
|
|
observedEffects.put(application, effectId);
|
|
return application;
|
|
}
|
|
@Override public void acceptedDamage(LivingEntity target, double requested, double actual,
|
|
Entity direct, Map<String, Object> evidence) {
|
|
if (castEvents == null || audit == null) return;
|
|
try {
|
|
var details = new java.util.LinkedHashMap<String, Object>(evidence);
|
|
if (target instanceof Player player)
|
|
sessions.active(player.getUniqueId()).filter(sessions::current).ifPresent(active -> {
|
|
details.put("target_character_id", active.character().toString());
|
|
details.put("target_session_id", active.session().toString());
|
|
});
|
|
castEvents.acceptedDamage(audit, target, requested, actual, direct, details);
|
|
} catch (RuntimeException ignored) { /* Recording cannot change accepted native damage. */ }
|
|
}
|
|
@Override public void acceptedHeal(EquipmentSessions.Active aided, Player target,
|
|
CharacterRecord saved, double requested, double actual,
|
|
double before, double after, double maximum) {
|
|
if (castEvents != null && audit != null)
|
|
castEvents.healed(audit, target, aided.character(), aided.session(), saved,
|
|
requested, actual, before, after, maximum);
|
|
}
|
|
@Override public void acceptedCleanse(EquipmentSessions.Active aided, Player target, List<String> removed) {
|
|
if (castEvents != null && audit != null)
|
|
castEvents.cleansed(audit, target, aided.character(), aided.session(), removed);
|
|
}
|
|
@Override public void acceptedPrevention(EquipmentSessions.Active aided, Player ally, Entity attacker,
|
|
double incoming, double actual, double remaining,
|
|
UUID bondApplication) {
|
|
if (castEvents != null && audit != null)
|
|
castEvents.prevented(audit, ally, aided.character(), aided.session(), attacker,
|
|
incoming, actual, remaining, bondApplication);
|
|
}
|
|
@Override public void acceptedOutgoingMitigation(UUID application, Entity debuffedAttacker,
|
|
Entity protectedTarget, double incoming, double remaining, double actual) {
|
|
if (castEvents == null || audit == null) return;
|
|
var evidence = new java.util.LinkedHashMap<String, Object>();
|
|
if (protectedTarget instanceof Player player)
|
|
sessions.active(player.getUniqueId()).filter(sessions::current).ifPresent(active -> {
|
|
evidence.put("protected_character_id", active.character().toString());
|
|
evidence.put("protected_session_id", active.session().toString());
|
|
});
|
|
castEvents.outgoingPrevented(audit, application, debuffedAttacker, protectedTarget,
|
|
incoming, remaining, actual, evidence);
|
|
}
|
|
@Override public void acceptedAbsorption(UUID application, Player target, Entity attacker,
|
|
double incoming, double before, double after,
|
|
double consumed, double remaining,
|
|
org.bukkit.Location targetAtHit, org.bukkit.Location attackerAtHit) {
|
|
if (castEvents == null || audit == null) return;
|
|
try {
|
|
var aided = sessions.active(target.getUniqueId()).filter(sessions::current).orElse(null);
|
|
castEvents.absorbed(audit, application, target, aided, attacker, incoming,
|
|
before, after, consumed, remaining, targetAtHit, attackerAtHit);
|
|
} catch (RuntimeException ignored) { /* Recording cannot change native absorption or support. */ }
|
|
}
|
|
@Override public void acceptedBoost(EquipmentSessions.Active attacking, Player attacker,
|
|
Entity target, double base, double bonus, double finalDamage,
|
|
java.math.BigDecimal percent) {
|
|
if (castEvents != null && audit != null)
|
|
castEvents.boosted(audit, attacking, attacker, target, base, bonus, finalDamage, percent);
|
|
}
|
|
@Override public void effectEnded(UUID application, String reason) {
|
|
effectEnded(application, reason, observedEndEvidence.getOrDefault(application, Map.of()));
|
|
}
|
|
@Override public void effectEndEvidence(UUID application, Map<String, Object> evidence) {
|
|
if (observedEffects.containsKey(application))
|
|
observedEndEvidence.put(application, Map.copyOf(Objects.requireNonNull(evidence)));
|
|
}
|
|
@Override public void effectEnded(UUID application, String reason, Map<String, Object> evidence) {
|
|
Objects.requireNonNull(application); Objects.requireNonNull(reason); Objects.requireNonNull(evidence);
|
|
var effectId = observedEffects.remove(application);
|
|
observedEndEvidence.remove(application);
|
|
if (effectId != null && castEvents != null)
|
|
castEvents.effectEnded(audit, application, effectId, reason, evidence);
|
|
}
|
|
@Override public void resolve(String result) { resolve(result, Map.of()); }
|
|
@Override public void resolve(String result, Map<String, Object> evidence) {
|
|
if (!Set.of("completed", "hit", "miss", "expired", "interrupted", "failed", "cancelled",
|
|
"healed", "cleansed", "protected", "boosted", "obstructed", "replaced").contains(result))
|
|
throw new IllegalArgumentException("Unsupported ability resolution");
|
|
if (!finished) { outcome = result; resolutionEvidence = Map.copyOf(Objects.requireNonNull(evidence)); }
|
|
}
|
|
@Override public void finish() {
|
|
if (outcome == null) outcome = "completed";
|
|
close();
|
|
}
|
|
@Override public void close() {
|
|
if (finished || closing) return;
|
|
closing = true;
|
|
publishCast();
|
|
if (outcome == null) outcome = "interrupted";
|
|
var resources = List.copyOf(owned); owned.clear();
|
|
for (var resource : resources) try { resource.close(); } catch (Exception failure) { AbilityEngine.this.report(key.character(), key.ability(), failure); }
|
|
finished = true;
|
|
for (var application : List.copyOf(observedEffects.keySet())) effectEnded(application, outcome);
|
|
if (castEvents != null) castEvents.resolved(audit, outcome,
|
|
outcome.equals("completed") ? "effect_finished_without_hit_claim" : "effect_ended", resolutionEvidence);
|
|
var runtimes = active.get(key);
|
|
if (runtimes != null) { runtimes.remove(this); if (runtimes.isEmpty()) active.remove(key); }
|
|
}
|
|
}
|
|
|
|
@Override public void close() {
|
|
if (closed) return;
|
|
closed = true;
|
|
if (sweepTask != null) sweepTask.cancel();
|
|
pending.clear();
|
|
for (var runtimes : List.copyOf(active.values())) for (var runtime : List.copyOf(runtimes)) runtime.close();
|
|
active.clear(); generations.clear();
|
|
}
|
|
}
|