Files
purpur-fantasy-stick/src/nativeTest/java/games/dmg/fantasystick/MendingLightNativeTest.java
T
dmg 13828054e5
Release / release (push) Failing after 14m7s
feat(events): audit combat feedback preferences
2026-09-25 09:48:27 -04:00

441 lines
31 KiB
Java

package games.dmg.fantasystick;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import games.dmg.fantasystick.ability.AbilityExecution;
import games.dmg.fantasystick.ability.MendingLight;
import games.dmg.fantasystick.party.PartyRoster;
import games.dmg.fantasystick.persistence.CharacterRecord;
import games.dmg.fantasystick.persistence.CharacterStorage;
import games.dmg.fantasystick.persistence.MendingLightSettings;
import games.dmg.fantasystick.persistence.YamlCharacterRepository;
import games.dmg.fantasystick.progression.Stat;
import games.dmg.fantasystick.session.ControlInput;
import games.dmg.fantasystick.session.EquipmentSessions;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.List;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.TimeUnit;
import net.minecraft.network.chat.ClickEvent;
import org.bukkit.Location;
import org.bukkit.attribute.Attribute;
import org.bukkit.attribute.AttributeInstance;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.entity.EntityDamageByEntityEvent;
import org.bukkit.event.entity.EntityDeathEvent;
import org.bukkit.event.entity.EntityRegainHealthEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.inventory.EquipmentSlot;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.io.TempDir;
class MendingLightNativeTest {
@TempDir Path data;
@BeforeAll static void bootstrap() throws Exception { NativeRuntime.bootstrap(); }
@Test void bookAcquisitionAimedPartyHealPersistsCapsAndKeepsCooldownAcrossReloadAndRelearn() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var caster = new FantasyStickLifecycleNativeTest.Actor(data);
var ally = new FantasyStickLifecycleNativeTest.Actor(data);
prepareCaster(data, caster, false);
setHealth(data, ally, BigDecimal.valueOf(4));
fixture.players.put(caster.core.id, caster.player);
fixture.players.put(ally.core.id, ally.player);
fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
String text = PartyBookNativeTest.text(caster).replaceAll("\\s+", "");
assertTrue(text.contains("MendingLight")); assertTrue(text.contains("WIS12"));
assertTrue(text.contains("CHR10")); assertFalse(text.contains("Cost:"));
assertTrue(text.contains("12")); assertTrue(text.contains("8"));
PartyBookNativeTest.click(fixture, caster, button(caster, "[Learn]", "mending_light"));
drain(fixture, 2);
use(fixture, caster); drain(fixture, 3);
var storage = storage(fixture);
var healed = storage.find(ally.core.record.id()).get().orElseThrow();
assertEquals(0, BigDecimal.TEN.compareTo(healed.health()), "6 + WIS modifier caps at ally maximum");
assertEquals(10, ally.player.getHealth());
String feedback = "Mending Light healed " + ally.core.record.name() + " for 6 health.";
assertEquals(1, caster.messages.stream().filter(feedback::equals).count());
assertEquals(1, ally.messages.stream().filter(feedback::equals).count());
var deadline = storage.find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light");
assertNotNull(deadline);
caster.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, caster);
var unlearn = button(caster, "[Unlearn]", "mending_light");
PartyBookNativeTest.click(fixture, caster, unlearn); PartyBookNativeTest.click(fixture, caster, unlearn);
drain(fixture, 2);
assertEquals(deadline, storage.find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light"));
learnAndAssign(fixture, caster); use(fixture, caster);
assertTrue(caster.messages.stream().anyMatch(message -> message.contains("ready in")));
var allySheet = ally.core.inventory.getItemInOffHand().clone();
ally.core.inventory.setItemInOffHand(null); fixture.changed(ally); drain(fixture, 1); fixture.awaitCharacterAndReceipt(ally);
var resumed = new FantasyStickLifecycleNativeTest.Actor(data);
resumed.core.inventory.setItemInOffHand(allySheet); fixture.players.put(resumed.core.id, resumed.player); fixture.activate(resumed);
assertEquals(10, resumed.player.getHealth(), "Healed health survives exit, transfer and resume");
}
var records = events(data);
for (var type : List.of("ability.learned", "ability.assigned", "ability.cast", "ability.resolved", "combat.healed"))
assertEquals(type.equals("ability.learned") || type.equals("ability.assigned") ? 2 : 1,
records.stream().filter(event -> event.get("type").getAsString().endsWith(type)
&& event.getAsJsonObject("data").has("ability_id")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).count(), type);
var cast = records.stream().filter(event -> event.get("type").getAsString().endsWith("ability.cast")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).findFirst().orElseThrow();
var healed = records.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).findFirst().orElseThrow();
assertEquals(cast.getAsJsonObject("data").get("action_id").getAsString(),
healed.getAsJsonObject("data").get("action_id").getAsString());
assertEquals("6", healed.getAsJsonObject("data").get("actual_amount").getAsString());
assertEquals("4", healed.getAsJsonObject("data").get("health_before").getAsString());
assertEquals("10", healed.getAsJsonObject("data").get("health_after").getAsString());
}
@Test void accountFeedbackOptOutCannotHideAnAcceptedNativeHealEvent() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var caster = new FantasyStickLifecycleNativeTest.Actor(data);
var ally = new FantasyStickLifecycleNativeTest.Actor(data);
prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(4));
fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
assertTrue(fixture.playerCommand.getExecutor().onCommand(caster.player, fixture.playerCommand,
"fstick", new String[]{"feedback", "off"}));
fixture.tick();
use(fixture, caster); drain(fixture, 3);
assertFalse(caster.messages.contains("Mending Light healed " + ally.core.record.name() + " for 6 health."));
assertTrue(ally.messages.contains("Mending Light healed " + ally.core.record.name() + " for 6 health."));
fixture.plugin.setEnabled(false);
}
var records = events(data);
assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("combat.healed")
&& e.getAsJsonObject("data").has("ability_id")
&& e.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).count());
assertEquals(1, records.stream().filter(e -> e.get("type").getAsString().endsWith("preference.changed")
&& e.getAsJsonObject("data").get("preference_key").getAsString().equals("combat_feedback")).count());
}
@Test void actualHealingCreatesOnePersistedSupportShareForAnAllyDirectContributor() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var caster = new FantasyStickLifecycleNativeTest.Actor(data);
var ally = new FantasyStickLifecycleNativeTest.Actor(data);
prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(4));
fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
use(fixture, caster); drain(fixture, 3);
var sourceSheet = caster.core.inventory.getItemInOffHand().clone();
caster.core.inventory.setItemInOffHand(null); fixture.changed(caster); drain(fixture, 1); fixture.awaitCharacterAndReceipt(caster);
var currentHolder = new FantasyStickLifecycleNativeTest.Actor(data);
currentHolder.core.inventory.setItemInOffHand(sourceSheet);
fixture.players.put(currentHolder.core.id, currentHolder.player); fixture.activate(currentHolder);
var enemy = mock(LivingEntity.class);
when(enemy.getUniqueId()).thenReturn(UUID.randomUUID());
when(enemy.getType()).thenReturn(org.bukkit.entity.EntityType.ZOMBIE);
when(caster.world.getUID()).thenReturn(UUID.randomUUID());
when(enemy.getLocation()).thenReturn(new Location(caster.world, 8, 64, 0));
var source = org.bukkit.damage.DamageSource.builder(org.bukkit.damage.DamageType.PLAYER_ATTACK)
.withCausingEntity(ally.player).withDirectEntity(ally.player).build();
fixture.dispatcher.accept(new EntityDamageByEntityEvent(ally.player, enemy,
org.bukkit.event.entity.EntityDamageEvent.DamageCause.ENTITY_ATTACK, source, 3));
fixture.dispatcher.accept(new EntityDeathEvent(enemy, source, new ArrayList<>(), 0));
drain(fixture, 4);
assertEquals(BigInteger.valueOf(5), storage(fixture).find(caster.core.record.id()).get().orElseThrow().experience());
assertEquals(BigInteger.valueOf(5), storage(fixture).find(ally.core.record.id()).get().orElseThrow().experience());
assertTrue(currentHolder.messages.stream().anyMatch(message -> message.contains("5") && message.contains("XP")),
"Persistent character membership follows the transferred sheet while support itself creates no unit");
}
}
private static List<com.google.gson.JsonObject> events(Path root) throws Exception {
var values = new ArrayList<com.google.gson.JsonObject>();
try (var files = java.nio.file.Files.walk(root.resolve("events"))) {
for (var file : files.filter(path -> path.toString().endsWith(".jsonl")).toList())
for (var line : java.nio.file.Files.readAllLines(file))
if (!line.isBlank()) values.add(com.google.gson.JsonParser.parseString(line).getAsJsonObject());
}
return values;
}
@Test void selfOrdinaryNonPartyFullHealthRangeAndLineOfSightRefuseBeforeCooldown() throws Exception {
for (int route = 0; route < 6; route++) {
var directory = data.resolve("refusal-" + route);
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
fixture.plugin.setEnabled(true);
var caster = new FantasyStickLifecycleNativeTest.Actor(directory); prepareCaster(directory, caster, true);
fixture.players.put(caster.core.id, caster.player); fixture.activate(caster);
Player target;
if (route == 0) target = caster.player;
else if (route == 1) { target = mock(Player.class); when(target.getUniqueId()).thenReturn(UUID.randomUUID()); }
else {
var ally = new FantasyStickLifecycleNativeTest.Actor(directory);
setHealth(directory, ally, route == 3 ? BigDecimal.TEN : BigDecimal.valueOf(4));
fixture.players.put(ally.core.id, ally.player); fixture.activate(ally); target = ally.player;
if (route != 2) party(fixture, caster, ally);
}
aim(caster, target, route == 4 ? 13 : 8, route != 5);
use(fixture, caster); drain(fixture, 2);
assertFalse(storage(fixture).find(caster.core.record.id()).get().orElseThrow()
.cooldowns().containsKey("mending_light"), "route " + route + " must refuse before cooldown");
}
assertEquals(0, events(directory).stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")
&& event.getAsJsonObject("data").has("ability_id")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).count());
}
}
@Test void cancelledHealingConsumesCooldownButAppliesNoHealthOrSupport() throws Exception {
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var caster = new FantasyStickLifecycleNativeTest.Actor(data);
var ally = new FantasyStickLifecycleNativeTest.Actor(data);
prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(4));
fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 8, true);
class Veto implements org.bukkit.event.Listener {
@org.bukkit.event.EventHandler public void heal(EntityRegainHealthEvent event) {
if (event.getEntity() == ally.player) event.setCancelled(true);
}
}
fixture.dispatcher.register(new Veto(), fixture.plugin);
use(fixture, caster); drain(fixture, 3);
assertEquals(4, ally.player.getHealth());
assertNotNull(storage(fixture).find(caster.core.record.id()).get().orElseThrow().cooldowns().get("mending_light"));
}
var observed = events(data);
assertEquals(0, observed.stream().filter(event -> event.get("type").getAsString().endsWith("combat.healed")
&& event.getAsJsonObject("data").has("ability_id")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")).count());
assertEquals(1, observed.stream().filter(event -> event.get("type").getAsString().endsWith("ability.resolved")
&& event.getAsJsonObject("data").has("ability_id")
&& event.getAsJsonObject("data").get("ability_id").getAsString().equals("mending_light")
&& event.getAsJsonObject("data").get("outcome").getAsString().equals("cancelled")).count());
}
@Test void targetSaveFailureOrSessionReplacementPublishesNoNativeHealingOrSupport() {
var characters = mock(CharacterStorage.class); var sessions = mock(EquipmentSessions.class);
var parties = mock(PartyRoster.class); var source = mock(Player.class); var target = mock(Player.class);
var attribute = mock(AttributeInstance.class); when(target.getAttribute(Attribute.MAX_HEALTH)).thenReturn(attribute);
when(attribute.getValue()).thenReturn(10.0); when(target.getHealth()).thenReturn(4.0);
when(source.getUniqueId()).thenReturn(UUID.randomUUID()); when(target.getUniqueId()).thenReturn(UUID.randomUUID());
var world = mock(org.bukkit.World.class);
when(source.getLocation()).thenReturn(new Location(world, 0, 64, 0));
when(target.getLocation()).thenReturn(new Location(world, 8, 64, 0));
when(source.hasLineOfSight(target)).thenReturn(true);
var casterRecord = recordWith(UUID.randomUUID(), "mending_light", BigDecimal.TEN);
var targetRecord = recordWith(UUID.randomUUID(), null, BigDecimal.valueOf(4));
var casterActive = new EquipmentSessions.Active(source.getUniqueId(), UUID.randomUUID(), casterRecord.id());
var targetActive = new EquipmentSessions.Active(target.getUniqueId(), UUID.randomUUID(), targetRecord.id());
when(sessions.active(target.getUniqueId())).thenReturn(java.util.Optional.of(targetActive));
when(sessions.current(targetActive)).thenReturn(true); when(sessions.currentRecord(targetActive)).thenReturn(java.util.Optional.of(targetRecord));
var party = new PartyRoster.Party(UUID.randomUUID(), source.getUniqueId(), List.of(source.getUniqueId(), target.getUniqueId()));
when(parties.partyOf(source.getUniqueId())).thenReturn(java.util.Optional.of(party));
when(parties.partyOf(target.getUniqueId())).thenReturn(java.util.Optional.of(party));
var input = mock(ControlInput.class); when(input.player()).thenReturn(source); when(input.target()).thenReturn(target); when(input.session()).thenReturn(casterActive);
var execution = mock(AbilityExecution.class); when(execution.stillCurrent()).thenReturn(true);
when(execution.input()).thenReturn(input); when(execution.character()).thenReturn(casterRecord);
var supports = new ArrayList<MendingLight.Support>();
var effect = new MendingLight(MendingLight.Settings.defaults(), characters, sessions, parties, Runnable::run,
ignored -> {}, () -> BigDecimal.valueOf(1024), supports::add);
when(execution.definition()).thenReturn(effect.definition());
var failed = new CompletableFuture<java.util.Optional<CharacterRecord>>();
when(characters.saveHealth(eq(targetRecord.id()), eq(targetRecord.revision()), any(), any())).thenReturn(failed);
effect.activate(execution); failed.completeExceptionally(new java.io.IOException("simulated"));
verify(target, never()).setHealth(anyDouble()); assertTrue(supports.isEmpty()); verify(execution).finish();
var acknowledged = new CharacterRecord(targetRecord.id(), targetRecord.name(), targetRecord.revision().add(BigInteger.ONE),
targetRecord.stats(), targetRecord.level(), targetRecord.experience(), targetRecord.unspentPoints(), BigDecimal.TEN,
targetRecord.learned(), targetRecord.loadout(), targetRecord.cooldowns(), targetRecord.restrictedKills(), false, null, null);
var delayed = new CompletableFuture<java.util.Optional<CharacterRecord>>();
when(characters.saveHealth(eq(targetRecord.id()), eq(targetRecord.revision()), any(), any())).thenReturn(delayed);
when(sessions.current(targetActive)).thenReturn(true);
effect.activate(execution);
when(sessions.current(targetActive)).thenReturn(false);
delayed.complete(java.util.Optional.of(acknowledged));
verify(target, never()).setHealth(anyDouble()); assertTrue(supports.isEmpty());
verify(sessions, never()).acknowledgeProgress(eq(targetActive), any(), any());
verify(execution, times(2)).finish();
verify(execution, never()).acceptedHeal(any(), any(), any(), anyDouble(), anyDouble(),
anyDouble(), anyDouble(), anyDouble());
}
@Test void configuredDefinitionAdminRestartAndFutureCastCoverEverySetting() throws Exception {
java.nio.file.Files.writeString(data.resolve("config.yml"),
"mending-light-base-healing: 8\nmending-light-cooldown-seconds: 0\nmending-light-range-blocks: 16\n");
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(data)) {
fixture.plugin.setEnabled(true);
var registry = (games.dmg.fantasystick.ability.AbilityRegistry)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
var definition = registry.find("mending_light").orElseThrow();
assertEquals(java.time.Duration.ZERO, definition.cooldown());
assertEquals(new BigDecimal("8"), definition.parameters().get("base-healing"));
assertEquals(0, new BigDecimal("16").compareTo(definition.parameters().get("range")));
var sender = new EquipmentAdminCommandNativeTest.Sender(); sender.allowed = false;
assertTrue(fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "mending-light-"}).isEmpty());
fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9"});
assertTrue(sender.messages.getLast().contains("Permission denied")); sender.allowed = true;
assertEquals(List.of("mending-light-base-healing", "mending-light-cooldown-seconds", "mending-light-range-blocks"),
fixture.command.tabComplete(sender.port, "fantasystick", new String[]{"config", "mending-light-"}));
assertEquals(List.of("6", "8"), fixture.command.tabComplete(sender.port, "fantasystick",
new String[]{"config", "mending-light-base-healing", ""}));
fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing"});
assertTrue(sender.messages.getLast().contains("=8"));
fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9"});
var response = fixture.tasks.poll(5, TimeUnit.SECONDS); assertNotNull(response); response.run();
assertEquals(new BigDecimal("9"), registry.find("mending_light").orElseThrow().parameters().get("base-healing"));
var caster = new FantasyStickLifecycleNativeTest.Actor(data); var ally = new FantasyStickLifecycleNativeTest.Actor(data);
prepareCaster(data, caster, true); setHealth(data, ally, BigDecimal.valueOf(1));
fixture.players.put(caster.core.id, caster.player); fixture.players.put(ally.core.id, ally.player);
fixture.activate(caster); fixture.activate(ally); party(fixture, caster, ally); aim(caster, ally, 15, true);
use(fixture, caster); drain(fixture, 3); assertEquals(10, ally.player.getHealth());
try (var channel = java.nio.channels.FileChannel.open(data.resolve(".config.lock"),
java.nio.file.StandardOpenOption.CREATE, java.nio.file.StandardOpenOption.WRITE);
var lock = channel.lock()) {
assertTrue(lock.isValid());
fixture.command.execute(sender.port, "fstickadmin",
new String[]{"config", "mending-light-base-healing", "10"});
var failed = fixture.tasks.poll(5, TimeUnit.SECONDS);
assertNotNull(failed); failed.run();
}
assertEquals("9", ((MendingLightSettings)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "mendingLightSettings"))
.value("mending-light-base-healing"));
assertTrue(sender.messages.getLast().contains("save failed"));
fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "-1"});
assertTrue(sender.messages.getLast().contains("invalid"));
fixture.command.execute(sender.port, "fantasystick", new String[]{"config", "mending-light-base-healing", "9", "extra"});
assertTrue(sender.messages.getLast().contains("Usage"));
fixture.plugin.setEnabled(false); fixture.plugin.setEnabled(true);
var reloaded = (games.dmg.fantasystick.ability.AbilityRegistry)
FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "abilityRegistry");
assertEquals(new BigDecimal("9"), reloaded.find("mending_light").orElseThrow().parameters().get("base-healing"));
}
var config = events(data).stream().filter(event -> event.get("type").getAsString().endsWith("config.read")
|| event.get("type").getAsString().endsWith("config.changed"))
.filter(event -> event.getAsJsonObject("data").has("key")
&& event.getAsJsonObject("data").get("key").getAsString().equals("mending-light-base-healing")).toList();
assertEquals(2, config.size());
assertEquals("8", config.getFirst().getAsJsonObject("data").get("after").getAsString());
assertEquals("8", config.getLast().getAsJsonObject("data").get("before").getAsString());
assertEquals("9", config.getLast().getAsJsonObject("data").get("after").getAsString());
assertEquals("console", config.getLast().getAsJsonObject("data").get("actor_kind").getAsString());
for (String invalid : List.of("mending-light-base-healing: -1\n", "mending-light-cooldown-seconds: -1\n",
"mending-light-range-blocks: 0\n")) {
var directory = data.resolve(Integer.toHexString(invalid.hashCode())); java.nio.file.Files.createDirectories(directory);
java.nio.file.Files.writeString(directory.resolve("config.yml"), invalid);
try (var fixture = new FantasyStickLifecycleNativeTest.Fixture(directory)) {
assertThrows(IllegalArgumentException.class, () -> fixture.plugin.setEnabled(true)); assertTrue(fixture.order.isEmpty());
}
}
}
@Test void exactFormulaSupportsUncappedWisdomAndFloorDivision() {
assertEquals(BigInteger.valueOf(7), MendingLight.healing(BigInteger.valueOf(12)));
assertEquals(BigInteger.valueOf(5), MendingLight.healing(BigInteger.valueOf(9)));
var huge = BigInteger.TEN.pow(500);
assertEquals(huge.subtract(BigInteger.TEN).divide(BigInteger.TWO).add(BigInteger.valueOf(6)), MendingLight.healing(huge));
}
private static void learnAndAssign(FantasyStickLifecycleNativeTest.Fixture fixture,
FantasyStickLifecycleNativeTest.Actor actor) throws Exception {
actor.core.inventory.getInventory().setSelectedSlot(0); PartyBookNativeTest.open(fixture, actor);
PartyBookNativeTest.click(fixture, actor, button(actor, "[Learn]", "mending_light")); drain(fixture, 2);
}
private static PartyRoster.Party party(FantasyStickLifecycleNativeTest.Fixture fixture,
FantasyStickLifecycleNativeTest.Actor caster,
FantasyStickLifecycleNativeTest.Actor ally) {
var parties = PartyLifecycleNativeTest.parties(fixture); var group = parties.create(caster.core.id).orElseThrow();
assertTrue(parties.accept(ally.core.id, parties.invite(caster.core.id, group.id(), ally.core.id).orElseThrow().id()));
return parties.partyOf(caster.core.id).orElseThrow();
}
private static void aim(FantasyStickLifecycleNativeTest.Actor caster,
FantasyStickLifecycleNativeTest.Actor target, double distance, boolean visible) {
aim(caster, target.player, distance, visible);
}
private static void aim(FantasyStickLifecycleNativeTest.Actor caster, Player target, double distance, boolean visible) {
doReturn(new Location(caster.world, 0, 64, 0)).when(caster.player).getLocation();
doReturn(new Location(caster.world, distance, 64, 0)).when(target).getLocation();
doReturn(visible).when(caster.player).hasLineOfSight(target);
doReturn(target).when(caster.player).getTargetEntity(64);
}
private static void use(FantasyStickLifecycleNativeTest.Fixture fixture,
FantasyStickLifecycleNativeTest.Actor actor) {
actor.core.inventory.getInventory().setSelectedSlot(2);
fixture.dispatcher.accept(new PlayerInteractEvent(actor.player, org.bukkit.event.block.Action.RIGHT_CLICK_AIR,
actor.core.inventory.getItem(2), null, org.bukkit.block.BlockFace.SELF, EquipmentSlot.HAND));
}
private static void drain(FantasyStickLifecycleNativeTest.Fixture fixture, int count) throws Exception {
for (int index = 0; index < count; index++) PartyBookNativeTest.drain(fixture);
}
private static CharacterStorage storage(FantasyStickLifecycleNativeTest.Fixture fixture) {
return (CharacterStorage) FantasyStickLifecycleNativeTest.Fixture.field(fixture.plugin, "characters");
}
private static ClickEvent.Custom button(FantasyStickLifecycleNativeTest.Actor actor, String label, String ability) {
var book = org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(actor.books.getLast())
.get(net.minecraft.core.component.DataComponents.WRITTEN_BOOK_CONTENT);
assertNotNull(book);
for (var page : book.pages()) { var found = button(page.raw(), label, ability); if (found != null) return found; }
throw new AssertionError("Missing " + label + " for " + ability);
}
private static ClickEvent.Custom button(net.minecraft.network.chat.Component component, String label, String ability) {
if (component.getString().equals(label) && component.getStyle().getClickEvent() instanceof ClickEvent.Custom custom
&& custom.payload().orElse(null) instanceof net.minecraft.nbt.StringTag payload
&& payload.value().contains(":" + ability)) return custom;
for (var child : component.getSiblings()) { var found = button(child, label, ability); if (found != null) return found; }
return null;
}
private static void prepareCaster(Path directory, FantasyStickLifecycleNativeTest.Actor actor, boolean learned) throws Exception {
java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
var old = repository.load(actor.core.record.id()).orElseThrow(); var stats = new EnumMap<>(old.stats());
stats.put(Stat.WIS, BigInteger.valueOf(12)); stats.put(Stat.CHR, BigInteger.TEN);
repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), stats,
old.level(), old.experience(), BigInteger.valueOf(learned ? 39 : 40), old.health(),
learned ? Set.of("mending_light") : old.learned(),
learned ? List.of("mending_light", "", "", "", "", "", "") : old.loadout(),
old.cooldowns(), old.restrictedKills(), false, null, null), old.revision());
}
private static void setHealth(Path directory, FantasyStickLifecycleNativeTest.Actor actor, BigDecimal health) throws Exception {
java.nio.file.Files.createDirectories(directory); var repository = new YamlCharacterRepository(directory);
var old = repository.load(actor.core.record.id()).orElseThrow();
repository.replace(new CharacterRecord(old.id(), old.name(), old.revision().add(BigInteger.ONE), old.stats(),
old.level(), old.experience(), old.unspentPoints(), health, old.learned(), old.loadout(), old.cooldowns(),
old.restrictedKills(), false, null, null), old.revision());
}
private static CharacterRecord recordWith(UUID id, String ability, BigDecimal health) {
var base = new games.dmg.fantasystick.crafting.CharacterFactory().create(
games.dmg.fantasystick.progression.ProgressionRules.defaults());
var stats = new EnumMap<>(base.stats()); stats.put(Stat.WIS, BigInteger.valueOf(12)); stats.put(Stat.CHR, BigInteger.TEN);
return new CharacterRecord(id, base.name(), base.revision(), stats, base.level(), base.experience(), base.unspentPoints(),
health, ability == null ? Set.of() : Set.of(ability), ability == null ? base.loadout() : List.of(ability, "", "", "", "", "", ""),
base.cooldowns(), base.restrictedKills(), false, null, null);
}
}