Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
Original file line number Diff line number Diff line change
Expand Up @@ -405,9 +405,9 @@ private void loadRewards() {
// Load items for this tier
List<String> tierItems = tiersSection.getStringList(tierName);
for (String itemString : tierItems) {
ItemReward item = parseItemReward(itemString);
if (item != null) {
tier.addItem(item);
List<ItemReward> entry = parseRewardEntry(itemString);
if (entry != null) {
tier.addEntry(entry);
}
}

Expand All @@ -421,6 +421,34 @@ private void loadRewards() {
plugin.getLogger().info("Loaded " + tierRewards.size() + " reward tiers from drop list '" + activeDropList + "'");
}

// ====================================
// One list entry: "item:amount", or several joined with " + " that are
// given together. A broken part skips the whole entry, so it never pays
// only half of what it lists.
// ====================================
private List<ItemReward> parseRewardEntry(String entryString) {
// -1 keeps empty parts, so a dangling or lone "+" is a broken entry
String[] parts = entryString.split("\\+", -1);
if (parts.length > TierReward.MAX_ENTRY_ITEMS) {
plugin.getLogger().warning("Skipping reward entry with more than " + TierReward.MAX_ENTRY_ITEMS
+ " items: " + entryString);
return null;
}
List<ItemReward> entry = new ArrayList<>();
for (String part : parts) {
// A single item is read as written, as before joined entries existed
ItemReward item = parseItemReward(parts.length > 1 ? part.trim() : part);
if (item == null) {
if (parts.length > 1) {
plugin.getLogger().warning("Skipping reward entry with a broken item: " + entryString);
}
return null;
}
entry.add(item);
}
return entry;
}

private ItemReward parseItemReward(String itemString) {
// Split on the last colon to separate item path from amount
int lastColonIndex = itemString.lastIndexOf(':');
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -44,15 +44,17 @@ public CacheMenu(GeigerConfiguration config) {
}

// ====================================
// Show the cache holding <reward>, which may be null for an empty cache
// Show the cache holding <rewards> (empty for an empty cache), centred in
// the middle row. Reward entries hold at most one row of items.
// ====================================
public void open(Player player, ItemStack reward) {
public void open(Player player, List<ItemStack> rewards) {
Holder holder = new Holder();
Inventory inventory = Bukkit.createInventory(holder, SIZE,
LEGACY.deserialize(config.getMessages().get("player.cache-title")));
holder.inventory = inventory;
if (reward != null) {
inventory.setItem(REWARD_SLOT, reward);
int first = REWARD_SLOT - rewards.size() / 2;
for (int index = 0; index < rewards.size(); index++) {
inventory.setItem(first + index, rewards.get(index));
}
// Another plugin may refuse the window; the reward is theirs regardless
if (player.openInventory(inventory) == null) {
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -27,6 +27,7 @@

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
Expand Down Expand Up @@ -464,24 +465,31 @@ private void replaceGeigerWithDeadVersion(Player player, EquipmentSlot geigerSlo
}

// ====================================
// A random reward based on tier weights, or null when there is none
// The items of a random entry based on tier weights; empty when there is
// none. An item whose path does not resolve is left out.
// ====================================
private ItemStack rollReward(Player player) {
private List<ItemStack> rollReward(Player player) {
List<ItemStack> rewards = new ArrayList<>();
List<TierReward> tiers = config.getTierRewards();
if (tiers.isEmpty()) {
return null;
return rewards;
}

// Select a tier based on weights
TierReward selectedTier = selectRandomTier(tiers);
if (selectedTier.isEmpty()) {
return null;
return rewards;
}

// Select a random item from the tier
List<ItemReward> tierItems = selectedTier.getItems();
ItemReward randomItem = tierItems.get(random.nextInt(tierItems.size()));
return rewardItem(player, randomItem, selectedTier.getTierName());
// Select a random entry from the tier
List<List<ItemReward>> entries = selectedTier.getEntries();
for (ItemReward reward : entries.get(random.nextInt(entries.size()))) {
ItemStack item = rewardItem(player, reward, selectedTier.getTierName());
if (item != null) {
rewards.add(item);
}
}
return rewards;
}

// ====================================
Expand Down
34 changes: 21 additions & 13 deletions src/main/java/net/tfminecraft/geigercounters/models/TierReward.java
Original file line number Diff line number Diff line change
Expand Up @@ -4,36 +4,44 @@
import java.util.List;

// ====================================
// Represents a reward tier with its weight and list of possible items
// Represents a reward tier with its weight and list of possible entries.
// One entry is drawn per cache; an entry gives one or more items together.
// ====================================
public class TierReward {
// An entry's items fill one row of the cache window
public static final int MAX_ENTRY_ITEMS = 9;

private final String tierName;
private final double weight;
private final List<ItemReward> items;
private final List<List<ItemReward>> entries;

public TierReward(String tierName, double weight) {
this.tierName = tierName;
this.weight = weight;
this.items = new ArrayList<>();
this.entries = new ArrayList<>();
}

public void addItem(ItemReward item) {
items.add(item);
addEntry(List.of(item));
}

public void addEntry(List<ItemReward> entry) {
entries.add(List.copyOf(entry));
}

public String getTierName() {
return tierName;
}

public double getWeight() {
return weight;
}
public List<ItemReward> getItems() {
return items;

public List<List<ItemReward>> getEntries() {
return entries;
}

public boolean isEmpty() {
return items.isEmpty();
return entries.isEmpty();
}
}
3 changes: 3 additions & 0 deletions src/main/resources/config.yml
Original file line number Diff line number Diff line change
Expand Up @@ -223,6 +223,9 @@ drops:
# Items in each rarity tier
# Format: "item_path:amount"
# Example: m.MATERIALS.ARCANE_DUST:5
# Join up to 9 items with " + " to give them together as one entry:
# "m.MATERIALS.IGNITIUM:32 + v.iron_ingot:32"
# If any item in a joined entry is malformed, the whole entry is skipped.
lists:
default:
tiers:
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -251,16 +251,44 @@ void rewardsChooseNamedListIgnoreDisabledEmptyAndMalformedTiers() {
var tier = configuration.getTierRewards().getFirst();
assertEquals("common", tier.getTierName());
assertEquals(10, tier.getWeight());
assertEquals(2, tier.getItems().size());
assertEquals("m.APPLE", tier.getItems().getFirst().getOutputItem());
assertEquals(2, tier.getItems().getFirst().getOutputAmount());
assertEquals("namespace:item", tier.getItems().getLast().getOutputItem());
assertEquals(3, tier.getItems().getLast().getOutputAmount());
assertEquals(2, tier.getEntries().size());
assertEquals("m.APPLE", tier.getEntries().getFirst().getFirst().getOutputItem());
assertEquals(2, tier.getEntries().getFirst().getFirst().getOutputAmount());
assertEquals("namespace:item", tier.getEntries().getLast().getFirst().getOutputItem());
assertEquals(3, tier.getEntries().getLast().getFirst().getOutputAmount());
load();
assertEquals(
1, configuration.getTierRewards().size(), "Reload must replace rather than append rewards");
}

@Test
void entriesJoinedWithPlusGiveTheirItemsTogetherAndBrokenOrOversizedOnesAreSkipped() {
yaml.set("drops.tier-weights.common", 1);
yaml.set(
"drops.lists.act.tiers.common",
List.of(
"m.MATERIALS.IGNITIUM:32 + v.iron_ingot:32",
"m.A:1 + broken",
"m.A:1 + m.B:x",
"m.A:1 +",
"+",
"m.C:1 ",
String.join(" + ", java.util.Collections.nCopies(10, "m.A:1")),
String.join("+", java.util.Collections.nCopies(9, "m.B:2"))));
yaml.set("drops.active-list", "act");
load();
var entries = configuration.getTierRewards().getFirst().getEntries();
assertEquals(2, entries.size());
var bundle = entries.getFirst();
assertEquals(2, bundle.size());
assertEquals("m.MATERIALS.IGNITIUM", bundle.getFirst().getOutputItem());
assertEquals(32, bundle.getFirst().getOutputAmount());
assertEquals("v.iron_ingot", bundle.getLast().getOutputItem());
assertEquals(32, bundle.getLast().getOutputAmount());
assertEquals(9, entries.getLast().size());
assertEquals("m.B", entries.getLast().getFirst().getOutputItem());
}

@Test
void missingListFallsBackToFirstAvailableAndMissingSectionsProduceNoRewards() {
yaml.createSection("drops.tier-weights");
Expand Down
Original file line number Diff line number Diff line change
Expand Up @@ -49,14 +49,14 @@ void setUp() {
when(player.openInventory(any(Inventory.class))).thenReturn(mock(InventoryView.class));
}

InventoryHolder open(ItemStack reward) {
InventoryHolder open(ItemStack... rewards) {
ArgumentCaptor<InventoryHolder> holder = ArgumentCaptor.forClass(InventoryHolder.class);
ArgumentCaptor<Component> title = ArgumentCaptor.forClass(Component.class);
try (var bukkit = mockStatic(Bukkit.class)) {
bukkit
.when(() -> Bukkit.createInventory(any(InventoryHolder.class), eq(27), any(Component.class)))
.thenReturn(window);
menu.open(player, reward);
menu.open(player, List.of(rewards));
bukkit.verify(() -> Bukkit.createInventory(holder.capture(), eq(27), title.capture()));
}
assertEquals("Arcane Cache", PlainTextComponentSerializer.plainText().serialize(title.getValue()));
Expand All @@ -78,15 +78,40 @@ void theRewardSitsInTheMiddleOfTheCache() {
verify(window).setItem(13, reward);
}

@Test
void severalRewardsAreCentredInTheMiddleRow() {
ItemStack first = item(false), second = item(false), third = item(false);
open(first, second);
verify(window).setItem(12, first);
verify(window).setItem(13, second);
clearInvocations(window, player);
open(first, second, third);
verify(window).setItem(12, first);
verify(window).setItem(13, second);
verify(window).setItem(14, third);
}

@Test
void aFullRowOfRewardsFillsTheWholeMiddleRow() {
ItemStack[] row = new ItemStack[9];
for (int index = 0; index < row.length; index++) {
row[index] = item(false);
}
open(row);
for (int index = 0; index < row.length; index++) {
verify(window).setItem(9 + index, row[index]);
}
}

@Test
void anEmptyCacheStillOpens() {
open(null);
open();
verify(window, never()).setItem(anyInt(), any());
}

@Test
void whateverIsLeftWhenTheCacheClosesGoesToThePlayer() {
InventoryHolder holder = open(null);
InventoryHolder holder = open();
ItemStack left = item(false), air = item(true);
when(window.getHolder()).thenReturn(holder);
when(window.getContents()).thenReturn(new ItemStack[] {null, air, left});
Expand All @@ -101,7 +126,7 @@ void whateverIsLeftWhenTheCacheClosesGoesToThePlayer() {

@Test
void otherWindowsAndNonPlayersAreLeftAlone() {
InventoryHolder holder = open(null);
InventoryHolder holder = open();
InventoryCloseEvent event = mock(InventoryCloseEvent.class);
when(event.getInventory()).thenReturn(window);
when(window.getHolder()).thenReturn(mock(InventoryHolder.class));
Expand All @@ -115,7 +140,7 @@ void otherWindowsAndNonPlayersAreLeftAlone() {

@Test
void openCachesAreHandedBackWhenThePluginStops() {
InventoryHolder holder = open(null);
InventoryHolder holder = open();
ItemStack left = item(false);
when(window.getHolder()).thenReturn(holder);
when(window.getContents()).thenReturn(new ItemStack[] {left});
Expand Down Expand Up @@ -159,7 +184,7 @@ PlayerDeathEvent death(Inventory top, boolean keep, List<ItemStack> drops) {

@Test
void dyingWithTheCacheOpenFillsEmptySlotsForGravesAndAddsToTheDrops() {
InventoryHolder holder = open(null);
InventoryHolder holder = open();
ItemStack held = item(false), gap = item(true);
ItemStack first = item(false), second = item(false);
ItemStack firstCopy = mock(ItemStack.class), secondCopy = mock(ItemStack.class);
Expand All @@ -186,7 +211,7 @@ void lootWithNoFreeSlotFallsWhereThePlayerDied() {
Location at = new Location(world, 1, 2, 3);
when(player.getWorld()).thenReturn(world);
when(player.getLocation()).thenReturn(at);
InventoryHolder holder = open(null);
InventoryHolder holder = open();
ItemStack fits = item(false), spare = item(false), copy = mock(ItemStack.class);
when(fits.clone()).thenReturn(copy);
ItemStack held = item(false);
Expand All @@ -202,7 +227,7 @@ void lootWithNoFreeSlotFallsWhereThePlayerDied() {

@Test
void keptInventoriesKeepTheCacheContentsWithoutDropping() {
InventoryHolder holder = open(null);
InventoryHolder holder = open();
ItemStack left = item(false);
when(pockets.getStorageContents()).thenReturn(new ItemStack[] {null});
when(window.getHolder()).thenReturn(holder);
Expand Down
Loading