441 lines
31 KiB
Java
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);
|
|
}
|
|
}
|