Repo-Mirror/Reforges
9
0
Fork 0
mirror of https://github.com/Auxilor/Reforges.git synced 2025-12-28 03:19:29 +00:00
Code Issues Releases 1 Activity

Removed last traces of java

Browse Source
This commit is contained in:
Auxilor
2022-05-22 18:33:35 +01:00
parent 73abe51241
commit cf9cbef409
28 changed files with 927 additions and 1233 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
build.gradle
View File

@@ -49,12 +49,7 @@ allprojects {
implementation 'org.joml:joml:1.10.4'
compileOnly 'org.jetbrains:annotations:23.0.0'
compileOnly 'org.projectlombok:lombok:1.18.20'
annotationProcessor 'org.projectlombok:lombok:1.18.20'
testCompileOnly 'org.projectlombok:lombok:1.18.20'
testAnnotationProcessor 'org.projectlombok:lombok:1.18.20'
compileOnly 'com.github.ben-manes.caffeine:caffeine:3.0.6'
compileOnly 'org.jetbrains.kotlin:kotlin-stdlib:1.6.21'
}

112
eco-core/core-plugin/src/main/java/com/willfp/reforges/ReforgesPlugin.java
View File

@@ -1,112 +0,0 @@
package com.willfp.reforges;
import com.willfp.eco.core.command.impl.PluginCommand;
import com.willfp.eco.core.display.DisplayModule;
import com.willfp.eco.core.integrations.IntegrationLoader;
import com.willfp.eco.core.items.Items;
import com.willfp.libreforge.LibReforgePlugin;
import com.willfp.reforges.commands.CommandReforge;
import com.willfp.reforges.commands.CommandReforges;
import com.willfp.reforges.config.ReforgesYml;
import com.willfp.reforges.config.TargetYml;
import com.willfp.reforges.display.ReforgesDisplay;
import com.willfp.reforges.integrations.talismans.TalismansIntegration;
import com.willfp.reforges.reforges.Reforges;
import com.willfp.reforges.reforges.util.ReforgeArgParser;
import com.willfp.reforges.reforges.util.ReforgeEnableListeners;
import com.willfp.reforges.reforges.util.ReforgeLookup;
import com.willfp.reforges.util.AntiPlaceListener;
import com.willfp.reforges.util.DiscoverRecipeListener;
import lombok.Getter;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Arrays;
import java.util.List;
public class ReforgesPlugin extends LibReforgePlugin {
/**
* Instance of Reforges.
*/
private static ReforgesPlugin instance;
/**
* target.yml.
*/
@Getter
private final TargetYml targetYml;
/**
* reforges.yml.
*/
@Getter
private final ReforgesYml reforgesYml;
/**
* Internal constructor called by bukkit on plugin load.
*/
public ReforgesPlugin() {
this.targetYml = new TargetYml(this);
this.reforgesYml = new ReforgesYml(this);
instance = this;
registerHolderProvider(ReforgeLookup::provideReforges);
}
@Override
public void handleEnableAdditional() {
Items.registerArgParser(new ReforgeArgParser());
}
@Override
public void handleReloadAdditional() {
this.getLogger().info(Reforges.values().size() + " Reforges Loaded");
}
@Override
protected List<Listener> loadListeners() {
return Arrays.asList(
new DiscoverRecipeListener(this),
new AntiPlaceListener(),
new ReforgeEnableListeners(this)
);
}
@Override
protected List<PluginCommand> loadPluginCommands() {
return Arrays.asList(
new CommandReforge(this),
new CommandReforges(this)
);
}
@Override
protected @Nullable DisplayModule createDisplayModule() {
return new ReforgesDisplay(this);
}
@NotNull
@Override
public List<IntegrationLoader> loadAdditionalIntegrations() {
return Arrays.asList(
new IntegrationLoader("Talismans", TalismansIntegration::registerProvider)
);
}
@Override
@NotNull
public String getMinimumEcoVersion() {
return "6.35.1";
}
/**
* Get an instance of Reforges.
*
* @return The instance.
*/
public static ReforgesPlugin getInstance() {
return instance;
}
}

17
eco-core/core-plugin/src/main/java/com/willfp/reforges/config/ReforgesYml.java
View File

@@ -1,17 +0,0 @@
package com.willfp.reforges.config;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.core.config.BaseConfig;
import com.willfp.eco.core.config.ConfigType;
import org.jetbrains.annotations.NotNull;
public class ReforgesYml extends BaseConfig {
/**
* Instantiate reforges.yml.
*
* @param plugin Instance of reforges.
*/
public ReforgesYml(@NotNull final EcoPlugin plugin) {
super("reforges", plugin, true, ConfigType.YAML);
}
}

55
eco-core/core-plugin/src/main/java/com/willfp/reforges/config/TargetYml.java
View File

@@ -1,55 +0,0 @@
package com.willfp.reforges.config;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.core.config.ConfigType;
import com.willfp.eco.core.config.StaticBaseConfig;
import com.willfp.eco.core.items.Items;
import com.willfp.eco.core.items.TestableItem;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import org.jetbrains.annotations.NotNull;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
public class TargetYml extends StaticBaseConfig {
/**
* Instantiate target.yml.
*
* @param plugin Instance of EcoEnchants.
*/
public TargetYml(@NotNull final EcoPlugin plugin) {
super("target", plugin, ConfigType.YAML);
}
/**
* Get all target names.
*
* @return Set of all names.
*/
public List<String> getTargets() {
return this.getKeys(false);
}
/**
* Get all materials from a target name.
*
* @param target The name of the target.
* @return All materials.
*/
public Set<TestableItem> getTargetItems(@NotNull final String target) {
Set<TestableItem> items = new HashSet<>();
this.getStrings(target + ".items").forEach(s -> items.add(Items.lookup(s.toUpperCase())));
return items;
}
/**
* Get all materials from a target name.
*
* @param target The name of the target.
* @return All materials.
*/
public ReforgeTarget.Slot getSlot(@NotNull final String target) {
return ReforgeTarget.Slot.valueOf(this.getString(target + ".slot").toUpperCase());
}
}

92
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/Reforges.java
View File

@@ -1,92 +0,0 @@
package com.willfp.reforges.reforges;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableSet;
import com.willfp.eco.core.config.interfaces.Config;
import com.willfp.eco.core.config.updating.ConfigUpdater;
import com.willfp.libreforge.chains.EffectChains;
import com.willfp.reforges.ReforgesPlugin;
import lombok.experimental.UtilityClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.Set;
@UtilityClass
@SuppressWarnings("unused")
public class Reforges {
private static final BiMap<String, Reforge> BY_KEY = HashBiMap.create();
/**
* Get all registered {@link Reforge}s.
*
* @return A list of all {@link Reforge}s.
*/
public static Set<Reforge> values() {
return ImmutableSet.copyOf(BY_KEY.values());
}
/**
* Get {@link String}s for all registered {@link Reforge}s.
*
* @return A list of all {@link Reforge}s.
*/
public static Set<String> keySet() {
return ImmutableSet.copyOf(BY_KEY.keySet());
}
/**
* Get {@link Reforge} matching key.
*
* @param key The key to search for.
* @return The matching {@link Reforge}, or null if not found.
*/
public static Reforge getByKey(@Nullable final String key) {
if (key == null) {
return null;
}
return BY_KEY.get(key);
}
/**
* Update all {@link Reforge}s.
*
* @param plugin Instance of Reforges.
*/
@ConfigUpdater
public static void update(@NotNull final ReforgesPlugin plugin) {
for (Config config : plugin.getReforgesYml().getSubsections("chains")) {
EffectChains.compile(config, "Chains");
}
for (Reforge reforge : values()) {
removeReforge(reforge);
}
for (Config config : plugin.getReforgesYml().getSubsections("reforges")) {
new Reforge(config, plugin);
}
}
/**
* Add new {@link Reforge} to Reforges.
* <p>
* Only for internal use, reforges are automatically added in the constructor.
*
* @param reforge The {@link Reforge} to add.
*/
public static void addNewReforge(@NotNull final Reforge reforge) {
BY_KEY.remove(reforge.getId());
BY_KEY.put(reforge.getId(), reforge);
}
/**
* Remove {@link Reforge} from Reforges.
*
* @param reforge The {@link Reforge} to remove.
*/
public static void removeReforge(@NotNull final Reforge reforge) {
BY_KEY.remove(reforge.getId());
}
}

141
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeEnableListeners.java
View File

@@ -1,141 +0,0 @@
package com.willfp.reforges.reforges.util;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.core.PluginDependent;
import com.willfp.eco.core.events.ArmorChangeEvent;
import com.willfp.libreforge.LibReforgeUtils;
import com.willfp.libreforge.effects.ConfiguredEffect;
import com.willfp.reforges.reforges.Reforge;
import com.willfp.reforges.reforges.Reforges;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityPickupItemEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.player.PlayerDropItemEvent;
import org.bukkit.event.player.PlayerItemHeldEvent;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.jetbrains.annotations.NotNull;
public class ReforgeEnableListeners extends PluginDependent<EcoPlugin> implements Listener {
/**
* Initialize new listeners and link them to a plugin.
*
* @param plugin The plugin to link to.
*/
public ReforgeEnableListeners(@NotNull final EcoPlugin plugin) {
super(plugin);
}
/**
* Called on item pickup.
*
* @param event The event to listen for.
*/
@EventHandler
public void onItemPickup(@NotNull final EntityPickupItemEvent event) {
if (!(event.getEntity() instanceof Player player)) {
return;
}
if (!ReforgeTarget.ALL.matches(event.getItem().getItemStack())) {
return;
}
refreshPlayer(player);
}
/**
* Called on player join.
*
* @param event The event to listen for.
*/
@EventHandler
public void onPlayerJoin(@NotNull final PlayerJoinEvent event) {
refresh();
}
/**
* Called on player leave.
*
* @param event The event to listen for.
*/
@EventHandler
public void onPlayerLeave(@NotNull final PlayerQuitEvent event) {
refresh();
Player player = event.getPlayer();
for (Reforge value : Reforges.values()) {
for (ConfiguredEffect effect : value.getEffects()) {
effect.getEffect().disableForPlayer(player);
}
}
}
/**
* Called on item drop.
*
* @param event The event to listen for.
*/
@EventHandler
public void onInventoryDrop(@NotNull final PlayerDropItemEvent event) {
if (!ReforgeTarget.ALL.matches(event.getItemDrop().getItemStack())) {
return;
}
refreshPlayer(event.getPlayer());
}
/**
* Called on slot change.
*
* @param event The event to listen for.
*/
@EventHandler
public void onChangeSlot(@NotNull final PlayerItemHeldEvent event) {
refreshPlayer(event.getPlayer());
this.getPlugin().getScheduler().run(() -> refreshPlayer(event.getPlayer()));
}
/**
* Called on armor change.
*
* @param event The event to listen for.
*/
@EventHandler
public void onArmorChange(@NotNull final ArmorChangeEvent event) {
refreshPlayer(event.getPlayer());
}
/**
* Called on inventory click.
*
* @param event The event to listen for.
*/
@EventHandler
public void onInventoryClick(@NotNull final InventoryClickEvent event) {
if (!(event.getWhoClicked() instanceof Player)) {
return;
}
refreshPlayer((Player) event.getWhoClicked());
}
/**
* Force refresh all online players.
* <p>
* This is a very expensive method.
*/
public void refresh() {
this.getPlugin().getServer().getOnlinePlayers().forEach(this::refreshPlayer);
}
private void refreshPlayer(@NotNull final Player player) {
ReforgeLookup.clearCache(player);
LibReforgeUtils.updateEffects(player);
}
}

150
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeHandler.java
View File

@@ -1,150 +0,0 @@
package com.willfp.reforges.reforges.util;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.core.PluginDependent;
import com.willfp.eco.core.gui.menu.Menu;
import com.willfp.eco.core.gui.slot.Slot;
import com.willfp.eco.core.integrations.economy.EconomyManager;
import com.willfp.reforges.reforges.PriceMultipliers;
import com.willfp.reforges.reforges.Reforge;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import org.bukkit.Sound;
import org.bukkit.entity.Player;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import java.util.ArrayList;
import java.util.List;
public class ReforgeHandler extends PluginDependent<EcoPlugin> {
/**
* Pass an {@link EcoPlugin} in order to interface with it.
*
* @param plugin The plugin to manage.
*/
public ReforgeHandler(@NotNull EcoPlugin plugin) {
super(plugin);
}
public void handleReforgeClick(@NotNull final InventoryClickEvent event,
@NotNull final Slot slot,
@NotNull final Menu menu) {
Player player = (Player) event.getWhoClicked();
ItemStack toReforge = menu.getCaptiveItems(player).isEmpty() ? null : menu.getCaptiveItems(player).get(0);
if (toReforge == null) {
return;
}
Reforge existingReforge = ReforgeUtils.getReforge(toReforge);
List<ReforgeTarget> target = ReforgeTarget.getForItem(toReforge);
Reforge reforge = null;
boolean usedStone = false;
if (menu.getCaptiveItems(player).size() == 2) {
Reforge stone = ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player).get(1));
if (stone != null) {
if (stone.getTargets().stream().anyMatch(reforgeTarget -> reforgeTarget.matches(toReforge))) {
reforge = stone;
usedStone = true;
}
}
}
if (reforge == null) {
List<Reforge> existing = new ArrayList<>();
if (existingReforge != null) {
existing.add(existingReforge);
}
reforge = ReforgeUtils.getRandomReforge(target, existing);
}
if (reforge == null) {
return;
}
double cost = 0;
if (EconomyManager.hasRegistrations()) {
cost = this.getPlugin().getConfigYml().getDouble("reforge.cost");
int reforges = ReforgeUtils.getReforges(toReforge);
cost *= Math.pow(this.getPlugin().getConfigYml().getDouble("reforge.cost-exponent"), reforges);
if (reforge.getRequiresStone() && reforge.getStonePrice() != -1) {
cost = reforge.getStonePrice();
}
cost *= PriceMultipliers.getForPlayer(player).getMultiplier();
if (!EconomyManager.hasAmount(player, cost)) {
player.sendMessage(this.getPlugin().getLangYml().getMessage("insufficient-money"));
if (this.getPlugin().getConfigYml().getBool("gui.insufficient-money-sound.enabled")) {
player.playSound(
player.getLocation(),
Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.insufficient-money-sound.id").toUpperCase()),
1f,
(float) this.getPlugin().getConfigYml().getDouble("gui.insufficient-money-sound.pitch")
);
}
return;
}
}
int xpCost = this.getPlugin().getConfigYml().getInt("reforge.xp-cost");
int reforges = ReforgeUtils.getReforges(toReforge);
xpCost *= Math.pow(this.getPlugin().getConfigYml().getDouble("reforge.cost-exponent"), reforges);
xpCost *= PriceMultipliers.getForPlayer(player).getMultiplier();
if (player.getLevel() < xpCost) {
player.sendMessage(this.getPlugin().getLangYml().getMessage("insufficient-xp"));
if (this.getPlugin().getConfigYml().getBool("gui.insufficient-money-sound.enabled")) {
player.playSound(
player.getLocation(),
Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.insufficient-money-sound.id").toUpperCase()),
1f,
(float) this.getPlugin().getConfigYml().getDouble("gui.insufficient-money-sound.pitch")
);
}
return;
}
if (EconomyManager.hasRegistrations()) {
EconomyManager.removeMoney(player, cost);
}
player.setLevel(player.getLevel() - xpCost);
player.sendMessage(this.getPlugin().getLangYml().getMessage("applied-reforge").replace("%reforge%", reforge.getName()));
ReforgeUtils.incrementReforges(toReforge);
ReforgeUtils.setReforge(toReforge, reforge);
if (usedStone) {
ItemStack stone = menu.getCaptiveItems(player).get(1);
stone.setItemMeta(null);
stone.setAmount(0);
if (this.getPlugin().getConfigYml().getBool("gui.stone-sound.enabled")) {
player.playSound(
player.getLocation(),
Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.stone-sound.id").toUpperCase()),
1f,
(float) this.getPlugin().getConfigYml().getDouble("gui.stone-sound.pitch")
);
}
}
if (this.getPlugin().getConfigYml().getBool("gui.sound.enabled")) {
player.playSound(
player.getLocation(),
Sound.valueOf(this.getPlugin().getConfigYml().getString("gui.sound.id").toUpperCase()),
1f,
(float) this.getPlugin().getConfigYml().getDouble("gui.sound.pitch")
);
}
}
}

150
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeLookup.java
View File

@@ -1,150 +0,0 @@
package com.willfp.reforges.reforges.util;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.reforges.ReforgesPlugin;
import com.willfp.reforges.reforges.Reforge;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
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.WeakHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;
public class ReforgeLookup {
/**
* All registered providers.
*/
private static final Set<Function<Player, Map<ItemStack, ReforgeTarget.Slot>>> PROVIDERS = new HashSet<>();
/**
* Cached items.
*/
private static final Map<UUID, Map<ItemStack, ReforgeTarget.Slot>> ITEM_CACHE = new WeakHashMap<>();
/**
* Cached reforges.
*/
private static final Map<UUID, Collection<Reforge>> REFORGE_CACHE = new WeakHashMap<>();
/**
* Instance of Reforges.
*/
private static final EcoPlugin PLUGIN = ReforgesPlugin.getInstance();
/**
* Register provider.
*
* @param provider The provider.
*/
public static void registerProvider(@NotNull final Function<Player, Map<ItemStack, ReforgeTarget.Slot>> provider) {
PROVIDERS.add(provider);
}
/**
* Provide ItemStacks.
*
* @param player The player.
* @return The ItemStacks.
*/
public static Map<ItemStack, ReforgeTarget.Slot> provide(@NotNull final Player player) {
if (ITEM_CACHE.containsKey(player.getUniqueId())) {
return new HashMap<>(ITEM_CACHE.get(player.getUniqueId()));
}
Map<ItemStack, ReforgeTarget.Slot> found = new HashMap<>();
for (Function<Player, Map<ItemStack, ReforgeTarget.Slot>> provider : PROVIDERS) {
found.putAll(provider.apply(player));
}
found.keySet().removeIf(Objects::isNull);
ITEM_CACHE.put(player.getUniqueId(), found);
PLUGIN.getScheduler().runLater(() -> ITEM_CACHE.remove(player.getUniqueId()), 40);
return found;
}
/**
* Provide Reforges.
*
* @param player The player.
* @return The Reforges.
*/
public static List<Reforge> provideReforges(@NotNull final Player player) {
if (REFORGE_CACHE.containsKey(player.getUniqueId())) {
return new ArrayList<>(REFORGE_CACHE.get(player.getUniqueId()));
}
List<Reforge> found = new ArrayList<>();
for (Map.Entry<ItemStack, ReforgeTarget.Slot> entry : provide(player).entrySet()) {
ItemStack itemStack = entry.getKey();
ReforgeTarget.Slot slot = entry.getValue();
if (itemStack == null) {
continue;
}
Reforge reforge = ReforgeUtils.getReforge(itemStack);
if (reforge == null) {
continue;
}
if (slot != ReforgeTarget.Slot.ANY) {
if (!reforge.getTargets().stream()
.map(ReforgeTarget::getSlot)
.collect(Collectors.toList())
.contains(slot)) {
continue;
}
}
found.add(reforge);
}
REFORGE_CACHE.put(player.getUniqueId(), found);
PLUGIN.getScheduler().runLater(() -> REFORGE_CACHE.remove(player.getUniqueId()), 40);
return found;
}
/**
* Clear cache.
*
* @param player The player.
*/
public static void clearCache(@NotNull final Player player) {
ITEM_CACHE.remove(player.getUniqueId());
REFORGE_CACHE.remove(player.getUniqueId());
}
static {
registerProvider(player -> Map.of(
player.getInventory().getItemInMainHand(),
ReforgeTarget.Slot.HANDS
));
if (!PLUGIN.getConfigYml().getBool("no-offhand")) {
registerProvider(player -> Map.of(
player.getInventory().getItemInOffHand(),
ReforgeTarget.Slot.HANDS
));
}
registerProvider(player -> {
Map<ItemStack, ReforgeTarget.Slot> items = new HashMap<>();
for (ItemStack stack : player.getInventory().getArmorContents()) {
items.put(stack, ReforgeTarget.Slot.ARMOR);
}
return items;
});
}
}

23
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeStatus.java
View File

@@ -1,23 +0,0 @@
package com.willfp.reforges.reforges.util;
public enum ReforgeStatus {
/**
* Allow the reforge.
*/
ALLOW,
/**
* Allow the reforge with a stone.
*/
ALLOW_STONE,
/**
* Invalid item to reforge.
*/
INVALID_ITEM,
/**
* No item at all.
*/
NO_ITEM
}

333
eco-core/core-plugin/src/main/java/com/willfp/reforges/reforges/util/ReforgeUtils.java
View File

@@ -1,333 +0,0 @@
package com.willfp.reforges.reforges.util;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.core.fast.FastItemStack;
import com.willfp.reforges.ReforgesPlugin;
import com.willfp.reforges.reforges.Reforge;
import com.willfp.reforges.reforges.Reforges;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import lombok.experimental.UtilityClass;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataContainer;
import org.bukkit.persistence.PersistentDataType;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
@UtilityClass
public class ReforgeUtils {
/**
* Instance of StatTrackers.
*/
private static final EcoPlugin PLUGIN = ReforgesPlugin.getInstance();
/**
* The key for storing reforges.
*/
private static final NamespacedKey REFORGE_KEY = PLUGIN.getNamespacedKeyFactory().create("reforge");
/**
* The key for storing reforge amounts.
*/
private static final NamespacedKey REFORGE_AMOUNT = PLUGIN.getNamespacedKeyFactory().create("reforge_amount");
/**
* The key for storing reforge stones.
*/
private static final NamespacedKey REFORGE_STONE_KEY = PLUGIN.getNamespacedKeyFactory().create("reforge_stone");
/**
* Get a random reforge for a target.
*
* @param targets The targets.
*/
@Nullable
public static Reforge getRandomReforge(@NotNull final Collection<ReforgeTarget> targets) {
return getRandomReforge(targets, Collections.emptyList());
}
/**
* Get a random reforge for a target.
*
* @param targets The targets.
* @param disallowed The disallowed reforges.
*/
@Nullable
public static Reforge getRandomReforge(@NotNull final Collection<ReforgeTarget> targets,
@NotNull final Collection<Reforge> disallowed) {
List<Reforge> applicable = new ArrayList<>();
for (Reforge reforge : Reforges.values()) {
for (ReforgeTarget target : targets) {
if (reforge.getTargets().contains(target) && !reforge.getRequiresStone()) {
applicable.add(reforge);
}
}
}
Collections.shuffle(applicable);
applicable.removeAll(disallowed);
if (applicable.isEmpty()) {
return null;
}
return applicable.get(0);
}
public static MetadatedReforgeStatus getStatus(@NotNull final List<ItemStack> captive) {
ItemStack toReforge = captive.isEmpty() ? null : captive.get(0);
ItemStack stone = captive.size() == 2 ? captive.get(1) : null;
ReforgeStatus status = null;
List<ReforgeTarget> target = new ArrayList<>();
if (toReforge == null || toReforge.getType() == Material.AIR) {
status = ReforgeStatus.NO_ITEM;
} else {
target.addAll(ReforgeTarget.getForItem(toReforge));
if (target.isEmpty()) {
status = ReforgeStatus.INVALID_ITEM;
}
}
if (!target.isEmpty()) {
status = ReforgeStatus.ALLOW;
}
double cost = 0;
if (status == ReforgeStatus.ALLOW) {
Reforge reforgeStone = getReforgeStone(stone);
if (reforgeStone != null && reforgeStone.getTargets().stream()
.anyMatch(reforgeTarget -> reforgeTarget.getItems().stream()
.anyMatch(item -> item.matches(toReforge)))) {
cost = reforgeStone.getStonePrice();
status = ReforgeStatus.ALLOW_STONE;
}
}
return new MetadatedReforgeStatus(status, cost);
}
/**
* Get reforge on an item.
*
* @param item The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforge(@Nullable final ItemStack item) {
if (item == null) {
return null;
}
PersistentDataContainer container = FastItemStack.wrap(item).getPersistentDataContainer();
return getReforge(container);
}
/**
* Get reforge on an item.
*
* @param meta The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforge(@Nullable final ItemMeta meta) {
if (meta == null) {
return null;
}
PersistentDataContainer container = meta.getPersistentDataContainer();
if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
return null;
}
String active = container.get(REFORGE_KEY, PersistentDataType.STRING);
return Reforges.getByKey(active);
}
/**
* Get reforge on an item.
*
* @param container The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforge(@Nullable final PersistentDataContainer container) {
if (container == null) {
return null;
}
if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
return null;
}
String active = container.get(REFORGE_KEY, PersistentDataType.STRING);
return Reforges.getByKey(active);
}
/**
* Set reforge on an item.
*
* @param item The item.
* @param reforge The reforge.
*/
public static void setReforge(@NotNull final ItemStack item,
@NotNull final Reforge reforge) {
if (item.getItemMeta() == null) {
return;
}
ItemMeta meta = item.getItemMeta();
setReforge(meta, reforge);
item.setItemMeta(meta);
}
/**
* Set reforge on an item.
*
* @param meta The meta.
* @param reforge The reforge.
*/
public static void setReforge(@NotNull final ItemMeta meta,
@NotNull final Reforge reforge) {
PersistentDataContainer container = meta.getPersistentDataContainer();
container.set(REFORGE_KEY, PersistentDataType.STRING, reforge.getId());
}
/**
* Get reforge stone on an item.
*
* @param item The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforgeStone(@Nullable final ItemStack item) {
if (item == null) {
return null;
}
PersistentDataContainer container = FastItemStack.wrap(item).getPersistentDataContainer();
return getReforgeStone(container);
}
/**
* Get reforge stone on an item.
*
* @param meta The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforgeStone(@Nullable final ItemMeta meta) {
if (meta == null) {
return null;
}
PersistentDataContainer container = meta.getPersistentDataContainer();
if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
return null;
}
String active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING);
return Reforges.getByKey(active);
}
/**
* Get reforge stone on an item.
*
* @param container The item to query.
* @return The found reforge, or null.
*/
public static Reforge getReforgeStone(@Nullable final PersistentDataContainer container) {
if (container == null) {
return null;
}
if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
return null;
}
String active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING);
return Reforges.getByKey(active);
}
/**
* Set an item to be a reforge stone.
*
* @param item The item.
* @param reforge The reforge.
*/
public static void setReforgeStone(@NotNull final ItemStack item,
@NotNull final Reforge reforge) {
if (item.getItemMeta() == null) {
return;
}
ItemMeta meta = item.getItemMeta();
PersistentDataContainer container = meta.getPersistentDataContainer();
container.set(REFORGE_STONE_KEY, PersistentDataType.STRING, reforge.getId());
item.setItemMeta(meta);
}
/**
* Get the amount of reforges done to an item.
*
* @param item The item.
*/
public static int getReforges(@NotNull final ItemStack item) {
ItemMeta meta = item.getItemMeta();
if (meta == null) {
return 0;
}
PersistentDataContainer container = meta.getPersistentDataContainer();
if (!container.has(REFORGE_AMOUNT, PersistentDataType.INTEGER)) {
container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, 0);
item.setItemMeta(meta);
}
Integer amount = container.get(REFORGE_AMOUNT, PersistentDataType.INTEGER);
return amount == null ? 0 : amount;
}
/**
* Get the amount of reforges done to an item.
*
* @param item The item.
*/
public static void incrementReforges(@NotNull final ItemStack item) {
ItemMeta meta = item.getItemMeta();
if (meta == null) {
return;
}
int amount = getReforges(item);
amount++;
PersistentDataContainer container = meta.getPersistentDataContainer();
container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, amount);
item.setItemMeta(meta);
}
}

78
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/ReforgesPlugin.kt Normal file
View File

@@ -0,0 +1,78 @@
package com.willfp.reforges
import com.willfp.eco.core.command.impl.PluginCommand
import com.willfp.eco.core.display.DisplayModule
import com.willfp.eco.core.integrations.IntegrationLoader
import com.willfp.eco.core.items.Items
import com.willfp.libreforge.LibReforgePlugin
import com.willfp.reforges.commands.CommandReforge
import com.willfp.reforges.commands.CommandReforges
import com.willfp.reforges.config.ReforgesYml
import com.willfp.reforges.config.TargetYml
import com.willfp.reforges.display.ReforgesDisplay
import com.willfp.reforges.integrations.talismans.TalismansIntegration
import com.willfp.reforges.reforges.Reforges
import com.willfp.reforges.reforges.util.ReforgeArgParser
import com.willfp.reforges.util.ReforgeEnableListeners
import com.willfp.reforges.util.ReforgeLookup
import com.willfp.reforges.util.AntiPlaceListener
import com.willfp.reforges.util.DiscoverRecipeListener
import org.bukkit.event.Listener
class ReforgesPlugin : LibReforgePlugin() {
val targetYml: TargetYml =
TargetYml(this)
val reforgesYml: ReforgesYml =
ReforgesYml(this)
init {
instance = this
}
override fun handleEnableAdditional() {
Items.registerArgParser(ReforgeArgParser())
registerHolderProvider { ReforgeLookup.provideReforges(it) }
}
override fun handleReloadAdditional() {
logger.info(Reforges.values().size.toString() + " Reforges Loaded")
}
override fun loadListeners(): List<Listener> {
return listOf(
DiscoverRecipeListener(this),
AntiPlaceListener(),
ReforgeEnableListeners(this)
)
}
override fun loadPluginCommands(): List<PluginCommand> {
return listOf(
CommandReforge(this),
CommandReforges(this)
)
}
override fun createDisplayModule(): DisplayModule {
return ReforgesDisplay(this)
}
override fun loadAdditionalIntegrations(): List<IntegrationLoader> {
return listOf(
IntegrationLoader("Talismans") { TalismansIntegration.registerProvider() }
)
}
override fun getMinimumEcoVersion(): String {
return "6.35.1"
}
companion object {
/**
* Instance of Reforges.
*/
@JvmStatic
lateinit var instance: ReforgesPlugin
private set
}
}

2
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/commands/CommandApply.kt
View File

@@ -3,7 +3,7 @@ package com.willfp.reforges.commands
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.command.impl.Subcommand
import com.willfp.reforges.reforges.Reforges
import com.willfp.reforges.reforges.util.ReforgeUtils
import com.willfp.reforges.util.ReforgeUtils
import org.bukkit.Bukkit
import org.bukkit.command.CommandSender
import org.bukkit.entity.Player

7
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/config/ReforgesYml.kt Normal file
View File

@@ -0,0 +1,7 @@
package com.willfp.reforges.config
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.config.BaseConfig
import com.willfp.eco.core.config.ConfigType
class ReforgesYml(plugin: EcoPlugin) : BaseConfig("reforges", plugin, true, ConfigType.YAML)

43
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/config/TargetYml.kt Normal file
View File

@@ -0,0 +1,43 @@
package com.willfp.reforges.config
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.config.ConfigType
import com.willfp.eco.core.config.StaticBaseConfig
import com.willfp.eco.core.items.Items
import com.willfp.eco.core.items.TestableItem
import com.willfp.reforges.reforges.ReforgeTarget
import java.util.*
import java.util.function.Consumer
class TargetYml(plugin: EcoPlugin) : StaticBaseConfig("target", plugin, ConfigType.YAML) {
/**
* Get all target names.
*
* @return Set of all names.
*/
val targets: List<String>
get() = getKeys(false)
/**
* Get all materials from a target name.
*
* @param target The name of the target.
* @return All materials.
*/
fun getTargetItems(target: String): Set<TestableItem> {
val items: MutableSet<TestableItem> = HashSet()
this.getStrings("$target.items")
.forEach(Consumer { s: String -> items.add(Items.lookup(s.uppercase(Locale.getDefault()))) })
return items
}
/**
* Get all materials from a target name.
*
* @param target The name of the target.
* @return All materials.
*/
fun getSlot(target: String): ReforgeTarget.Slot {
return ReforgeTarget.Slot.valueOf(this.getString("$target.slot").uppercase(Locale.getDefault()))
}
}

4
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/display/ReforgesDisplay.kt
View File

@@ -8,8 +8,8 @@ import com.willfp.eco.core.fast.fast
import com.willfp.eco.util.SkullUtils
import com.willfp.eco.util.StringUtils
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.reforges.meta.ReforgeTarget
import com.willfp.reforges.reforges.util.ReforgeUtils
import com.willfp.reforges.reforges.ReforgeTarget
import com.willfp.reforges.util.ReforgeUtils
import net.kyori.adventure.text.TextReplacementConfig
import net.kyori.adventure.text.format.TextDecoration
import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer

12
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/gui/ReforgeGUI.kt
View File

@@ -14,9 +14,9 @@ import com.willfp.eco.core.items.builder.ItemStackBuilder
import com.willfp.eco.util.NumberUtils
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.reforges.PriceMultipliers
import com.willfp.reforges.reforges.util.ReforgeHandler
import com.willfp.reforges.reforges.util.ReforgeStatus
import com.willfp.reforges.reforges.util.ReforgeUtils
import com.willfp.reforges.util.ReforgeHandler
import com.willfp.reforges.util.ReforgeStatus
import com.willfp.reforges.util.ReforgeUtils
import org.bukkit.Material
import org.bukkit.entity.Player
import org.bukkit.inventory.ItemStack
@@ -28,7 +28,7 @@ object ReforgeGUI {
lateinit var menu: Menu
init {
update(ReforgesPlugin.getInstance())
update(ReforgesPlugin.instance)
}
@JvmStatic
@@ -92,7 +92,7 @@ object ReforgeGUI {
meta.lore = plugin.configYml.getFormattedStrings("gui.allow-stone.lore").map {
it.replace("%cost%", NumberUtils.format(cost))
.replace("%xpcost%", NumberUtils.format(xpCost.toDouble()))
.replace("%stone%", ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1]).name)
.replace("%stone%", ReforgeUtils.getReforgeStone(menu.getCaptiveItems(player)[1])!!.name)
}
}
ReforgeStatus.NO_ITEM -> {
@@ -109,7 +109,7 @@ object ReforgeGUI {
previous.itemMeta = meta
}
onLeftClick(handler::handleReforgeClick)
onLeftClick { event, _, menu -> handler.handleReforgeClick(event, menu) }
}
val maskPattern = plugin.configYml.getStrings("gui.mask.pattern").toTypedArray()

6
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/talismans/TalismansIntegration.kt
View File

@@ -1,8 +1,8 @@
package com.willfp.reforges.integrations.talismans
import com.willfp.eco.core.integrations.Integration
import com.willfp.reforges.reforges.meta.ReforgeTarget
import com.willfp.reforges.reforges.util.ReforgeLookup
import com.willfp.reforges.reforges.ReforgeTarget
import com.willfp.reforges.util.ReforgeLookup
import com.willfp.talismans.talismans.util.TalismanChecks
import org.bukkit.inventory.ItemStack
@@ -10,7 +10,7 @@ object TalismansIntegration : Integration {
@JvmStatic
fun registerProvider() {
ReforgeLookup.registerProvider { player ->
val provided = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
val provided = mutableMapOf<ItemStack?, ReforgeTarget.Slot?>()
for (itemStack in TalismanChecks.getTalismanItemsOnPlayer(player)) {
provided[itemStack] = ReforgeTarget.Slot.ANY
}

5
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforge.kt
View File

@@ -10,8 +10,7 @@ import com.willfp.libreforge.Holder
import com.willfp.libreforge.conditions.Conditions
import com.willfp.libreforge.effects.Effects
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.reforges.meta.ReforgeTarget
import com.willfp.reforges.reforges.util.ReforgeUtils
import com.willfp.reforges.util.ReforgeUtils
import org.bukkit.inventory.ItemStack
import java.util.*
@@ -26,7 +25,7 @@ class Reforge(
val description: List<String> = config.getFormattedStrings("description")
val targets = config.getStrings("targets").map { ReforgeTarget.getByName(it) }.toSet()
val targets = config.getStrings("targets").mapNotNull { ReforgeTarget.getByName(it) }.toSet()
override val effects = config.getSubsections("effects").mapNotNull {
Effects.compile(it, "Reforge ID $id")

229
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/ReforgeTarget.kt
View File

@@ -1,152 +1,105 @@
package com.willfp.reforges.reforges.meta;
package com.willfp.reforges.reforges
import com.google.common.collect.ImmutableSet;
import com.willfp.eco.core.config.updating.ConfigUpdater;
import com.willfp.eco.core.items.TestableItem;
import com.willfp.eco.core.recipe.parts.EmptyTestableItem;
import com.willfp.reforges.ReforgesPlugin;
import lombok.Getter;
import org.bukkit.inventory.ItemStack;
import org.jetbrains.annotations.NotNull;
import com.google.common.collect.ImmutableSet
import com.willfp.eco.core.config.updating.ConfigUpdater
import com.willfp.eco.core.items.TestableItem
import com.willfp.eco.core.recipe.parts.EmptyTestableItem
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.ReforgesPlugin.Companion.instance
import org.bukkit.inventory.ItemStack
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
public class ReforgeTarget {
/**
* Target containing the materials from all other targets.
*/
public static final ReforgeTarget ALL = new ReforgeTarget("all", Slot.ANY, new HashSet<>());
/**
* All registered targets.
*/
private static final Map<String, ReforgeTarget> REGISTERED = new HashMap<>();
static {
REGISTERED.put("all", ALL);
update(ReforgesPlugin.getInstance());
class ReforgeTarget(
val name: String,
val slot: Slot,
val items: MutableSet<TestableItem>
) {
init {
items.removeIf { it is EmptyTestableItem }
}
/**
* The name of the target.
*/
@Getter
private final String name;
/**
* The materials of the target.
*/
@Getter
private final Set<TestableItem> items;
/**
* The slot for the target.
*/
@Getter
private final Slot slot;
/**
* Create new target.
*
* @param name The name of the target.
* @param items The items for the target.
*/
public ReforgeTarget(@NotNull final String name,
@NotNull final Slot slot,
@NotNull final Set<TestableItem> items) {
this.name = name;
items.removeIf(item -> item instanceof EmptyTestableItem);
this.items = items;
this.slot = slot;
}
/**
* If an item matches the target.
*
* @param itemStack The ItemStack.
* @return If matches.
*/
public boolean matches(@NotNull final ItemStack itemStack) {
for (TestableItem item : this.items) {
fun matches(itemStack: ItemStack): Boolean {
for (item in items) {
if (item.matches(itemStack)) {
return true;
return true
}
}
return false;
return false
}
/**
* Get ReforgeTarget matching name.
*
* @param name The name to search for.
* @return The matching ReforgeTarget, or null if not found.
*/
public static ReforgeTarget getByName(@NotNull final String name) {
return REGISTERED.get(name);
}
/**
* Get target from item.
*
* @param item The item.
* @return The target.
*/
public static List<ReforgeTarget> getForItem(@NotNull final ItemStack item) {
return REGISTERED.values().stream()
.filter(target -> !target.getName().equalsIgnoreCase("all"))
.filter(target -> target.matches(item))
.collect(Collectors.toList());
}
/**
* Update all targets.
*
* @param plugin Instance of Reforges.
*/
@ConfigUpdater
public static void update(@NotNull final ReforgesPlugin plugin) {
ALL.items.clear();
for (String id : new ArrayList<>(REGISTERED.keySet())) {
if (id.equalsIgnoreCase("all")) {
continue;
}
REGISTERED.remove(id);
}
for (String id : plugin.getTargetYml().getTargets()) {
ReforgeTarget target = new ReforgeTarget(
id,
plugin.getTargetYml().getSlot(id),
plugin.getTargetYml().getTargetItems(id)
);
REGISTERED.put(id, target);
ALL.items.addAll(target.items);
}
}
/**
* Get all targets.
*
* @return A set of all targets.
*/
public static Set<ReforgeTarget> values() {
return ImmutableSet.copyOf(REGISTERED.values());
}
/**
* Reforge slots.
*/
public enum Slot {
enum class Slot {
HANDS,
ARMOR,
ANY
}
companion object {
private val registered = mutableMapOf<String, ReforgeTarget>()
val ALL = ReforgeTarget("all", Slot.ANY, HashSet())
init {
registered["all"] = ALL
update(instance)
}
/**
* Get ReforgeTarget matching name.
*
* @param name The name to search for.
* @return The matching ReforgeTarget, or null if not found.
*/
@JvmStatic
fun getByName(name: String): ReforgeTarget? {
return registered[name]
}
/**
* Get target from item.
*
* @param item The item.
* @return The target.
*/
@JvmStatic
fun getForItem(item: ItemStack): List<ReforgeTarget> {
return registered.values
.filter { !it.name.equals("all", ignoreCase = true) }
.filter { it.matches(item) }
}
/**
* Update all targets.
*
* @param plugin Instance of Reforges.
*/
@ConfigUpdater
@JvmStatic
fun update(plugin: ReforgesPlugin) {
ALL.items.clear()
for (id in ArrayList(registered.keys)) {
if (id.equals("all", ignoreCase = true)) {
continue
}
registered.remove(id)
}
for (id in plugin.targetYml.targets) {
val target = ReforgeTarget(
id,
plugin.targetYml.getSlot(id),
plugin.targetYml.getTargetItems(id).toMutableSet()
)
registered[id] = target
ALL.items.addAll(target.items)
}
}
/**
* Get all targets.
*
* @return A set of all targets.
*/
@JvmStatic
fun values(): Set<ReforgeTarget> {
return ImmutableSet.copyOf(registered.values)
}
}
}

86
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/Reforges.kt Normal file
View File

@@ -0,0 +1,86 @@
package com.willfp.reforges.reforges
import com.google.common.collect.HashBiMap
import com.google.common.collect.ImmutableSet
import com.willfp.eco.core.config.updating.ConfigUpdater
import com.willfp.libreforge.chains.EffectChains.compile
import com.willfp.reforges.ReforgesPlugin
@Suppress("UNUSED")
object Reforges {
private val BY_KEY = HashBiMap.create<String, Reforge>()
/**
* Get all registered [Reforge]s.
*
* @return A list of all [Reforge]s.
*/
@JvmStatic
fun values(): Set<Reforge> {
return ImmutableSet.copyOf(BY_KEY.values)
}
/**
* Get [String]s for all registered [Reforge]s.
*
* @return A list of all [Reforge]s.
*/
@JvmStatic
fun keySet(): Set<String> {
return ImmutableSet.copyOf(BY_KEY.keys)
}
/**
* Get [Reforge] matching key.
*
* @param key The key to search for.
* @return The matching [Reforge], or null if not found.
*/
@JvmStatic
fun getByKey(key: String?): Reforge? {
return if (key == null) {
null
} else BY_KEY[key]
}
/**
* Update all [Reforge]s.
*
* @param plugin Instance of Reforges.
*/
@ConfigUpdater
@JvmStatic
fun update(plugin: ReforgesPlugin) {
for (config in plugin.reforgesYml.getSubsections("chains")) {
compile(config!!, "Chains")
}
for (reforge in values()) {
removeReforge(reforge)
}
for (config in plugin.reforgesYml.getSubsections("reforges")) {
Reforge(config!!, plugin)
}
}
/**
* Remove [Reforge] from Reforges.
*
* @param reforge The [Reforge] to remove.
*/
@JvmStatic
fun removeReforge(reforge: Reforge) {
BY_KEY.remove(reforge.id)
}
/**
* Add new [Reforge] to Reforges.
*
* Only for internal use, reforges are automatically added in the constructor.
*
* @param reforge The [Reforge] to add.
*/
internal fun addNewReforge(reforge: Reforge) {
BY_KEY.remove(reforge.id)
BY_KEY[reforge.id] = reforge
}
}

2
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/MetadatedReforgeStatus.kt
View File

@@ -1,3 +1,5 @@
package com.willfp.reforges.reforges.util
import com.willfp.reforges.util.ReforgeStatus
data class MetadatedReforgeStatus(val status: ReforgeStatus, val cost: Double)

1
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/reforges/util/ReforgeArgParser.kt
View File

@@ -3,6 +3,7 @@ package com.willfp.reforges.reforges.util
import com.willfp.eco.core.items.args.LookupArgParser
import com.willfp.reforges.reforges.Reforge
import com.willfp.reforges.reforges.Reforges
import com.willfp.reforges.util.ReforgeUtils
import org.bukkit.inventory.ItemStack
import org.bukkit.inventory.meta.ItemMeta
import java.util.function.Predicate

1
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/AntiPlaceListener.kt
View File

@@ -1,6 +1,5 @@
package com.willfp.reforges.util
import com.willfp.reforges.reforges.util.ReforgeUtils
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.block.BlockPlaceEvent

83
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeEnableListeners.kt Normal file
View File

@@ -0,0 +1,83 @@
package com.willfp.reforges.util
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.events.ArmorChangeEvent
import com.willfp.libreforge.updateEffects
import com.willfp.reforges.reforges.Reforges.values
import com.willfp.reforges.reforges.ReforgeTarget
import com.willfp.reforges.util.ReforgeLookup.clearCache
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.entity.EntityPickupItemEvent
import org.bukkit.event.inventory.InventoryClickEvent
import org.bukkit.event.player.PlayerDropItemEvent
import org.bukkit.event.player.PlayerItemHeldEvent
import org.bukkit.event.player.PlayerJoinEvent
import org.bukkit.event.player.PlayerQuitEvent
class ReforgeEnableListeners(private val plugin: EcoPlugin) : Listener {
@EventHandler
fun onItemPickup(event: EntityPickupItemEvent) {
if (event.entity !is Player) {
return
}
val player = event.entity as Player
if (!ReforgeTarget.ALL.matches(event.item.itemStack)) {
return
}
refreshPlayer(player)
}
@EventHandler
fun onPlayerJoin(event: PlayerJoinEvent) {
refresh()
}
@EventHandler
fun onPlayerLeave(event: PlayerQuitEvent) {
refresh()
val player = event.player
for (value in values()) {
for ((effect1) in value.effects) {
effect1.disableForPlayer(player)
}
}
}
@EventHandler
fun onInventoryDrop(event: PlayerDropItemEvent) {
if (!ReforgeTarget.ALL.matches(event.itemDrop.itemStack)) {
return
}
refreshPlayer(event.player)
}
@EventHandler
fun onChangeSlot(event: PlayerItemHeldEvent) {
refreshPlayer(event.player)
plugin.scheduler.run { refreshPlayer(event.player) }
}
@EventHandler
fun onArmorChange(event: ArmorChangeEvent) {
refreshPlayer(event.player)
}
@EventHandler
fun onInventoryClick(event: InventoryClickEvent) {
if (event.whoClicked !is Player) {
return
}
refreshPlayer(event.whoClicked as Player)
}
private fun refresh() {
plugin.server.onlinePlayers.forEach { player: Player -> refreshPlayer(player) }
}
private fun refreshPlayer(player: Player) {
clearCache(player)
player.updateEffects()
}
}

123
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeHandler.kt Normal file
View File

@@ -0,0 +1,123 @@
package com.willfp.reforges.util
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.gui.menu.Menu
import com.willfp.eco.core.integrations.economy.EconomyManager
import com.willfp.reforges.reforges.PriceMultipliers.getForPlayer
import com.willfp.reforges.reforges.Reforge
import com.willfp.reforges.reforges.ReforgeTarget.Companion.getForItem
import com.willfp.reforges.util.ReforgeUtils.getRandomReforge
import com.willfp.reforges.util.ReforgeUtils.getReforge
import com.willfp.reforges.util.ReforgeUtils.getReforgeStone
import com.willfp.reforges.util.ReforgeUtils.getReforges
import com.willfp.reforges.util.ReforgeUtils.incrementReforges
import com.willfp.reforges.util.ReforgeUtils.setReforge
import org.bukkit.Sound
import org.bukkit.entity.Player
import org.bukkit.event.inventory.InventoryClickEvent
import java.util.*
import kotlin.math.pow
class ReforgeHandler(private val plugin: EcoPlugin) {
fun handleReforgeClick(
event: InventoryClickEvent,
menu: Menu
) {
val player = event.whoClicked as Player
val toReforge =
(if (menu.getCaptiveItems(player).isEmpty()) null else menu.getCaptiveItems(player)[0]) ?: return
val existingReforge = getReforge(toReforge)
val target = getForItem(toReforge)
var reforge: Reforge? = null
var usedStone = false
if (menu.getCaptiveItems(player).size == 2) {
val stone = getReforgeStone(menu.getCaptiveItems(player)[1])
if (stone != null) {
if (stone.targets.any { it.matches(toReforge) }) {
reforge = stone
usedStone = true
}
}
}
if (reforge == null) {
val existing: MutableList<Reforge> = ArrayList()
if (existingReforge != null) {
existing.add(existingReforge)
}
reforge = getRandomReforge(target, existing)
}
if (reforge == null) {
return
}
var cost = 0.0
if (EconomyManager.hasRegistrations()) {
cost = plugin.configYml.getDouble("reforge.cost")
val reforges = getReforges(toReforge)
cost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble())
if (reforge.requiresStone && reforge.stonePrice != -1) {
cost = reforge.stonePrice.toDouble()
}
cost *= getForPlayer(player).multiplier
if (!EconomyManager.hasAmount(player, cost)) {
player.sendMessage(plugin.langYml.getMessage("insufficient-money"))
if (plugin.configYml.getBool("gui.insufficient-money-sound.enabled")) {
player.playSound(
player.location,
Sound.valueOf(
plugin.configYml.getString("gui.insufficient-money-sound.id").uppercase(Locale.getDefault())
),
1f, plugin.configYml.getDouble("gui.insufficient-money-sound.pitch").toFloat()
)
}
return
}
}
var xpCost = plugin.configYml.getInt("reforge.xp-cost")
val reforges = getReforges(toReforge)
xpCost *= plugin.configYml.getDouble("reforge.cost-exponent").pow(reforges.toDouble()).toInt()
xpCost *= getForPlayer(player).multiplier.toInt()
if (player.level < xpCost) {
player.sendMessage(plugin.langYml.getMessage("insufficient-xp"))
if (plugin.configYml.getBool("gui.insufficient-money-sound.enabled")) {
player.playSound(
player.location,
Sound.valueOf(
plugin.configYml.getString("gui.insufficient-money-sound.id").uppercase(Locale.getDefault())
),
1f, plugin.configYml.getDouble("gui.insufficient-money-sound.pitch").toFloat()
)
}
return
}
if (EconomyManager.hasRegistrations()) {
EconomyManager.removeMoney(player, cost)
}
player.level = player.level - xpCost
player.sendMessage(plugin.langYml.getMessage("applied-reforge").replace("%reforge%", reforge.name))
incrementReforges(toReforge)
setReforge(toReforge, reforge)
if (usedStone) {
val stone = menu.getCaptiveItems(player)[1]
stone.itemMeta = null
stone.amount = 0
if (plugin.configYml.getBool("gui.stone-sound.enabled")) {
player.playSound(
player.location,
Sound.valueOf(plugin.configYml.getString("gui.stone-sound.id").uppercase(Locale.getDefault())),
1f, plugin.configYml.getDouble("gui.stone-sound.pitch").toFloat()
)
}
}
if (plugin.configYml.getBool("gui.sound.enabled")) {
player.playSound(
player.location,
Sound.valueOf(plugin.configYml.getString("gui.sound.id").uppercase(Locale.getDefault())),
1f, plugin.configYml.getDouble("gui.sound.pitch").toFloat()
)
}
}
}

107
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeLookup.kt Normal file
View File

@@ -0,0 +1,107 @@
package com.willfp.reforges.util
import com.github.benmanes.caffeine.cache.Caffeine
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.reforges.Reforge
import com.willfp.reforges.reforges.ReforgeTarget
import com.willfp.reforges.util.ReforgeUtils.getReforge
import org.bukkit.entity.Player
import org.bukkit.inventory.ItemStack
import java.util.concurrent.TimeUnit
typealias SlotProvider = (Player) -> Map<ItemStack?, ReforgeTarget.Slot?>
object ReforgeLookup {
private val plugin = ReforgesPlugin.instance
private val slotProviders = mutableSetOf<(Player) -> Map<ItemStack, ReforgeTarget.Slot>>()
private val itemCache = Caffeine.newBuilder()
.expireAfterWrite(2, TimeUnit.SECONDS)
.build<Player, Map<ItemStack, ReforgeTarget.Slot>>()
private val reforgeCache = Caffeine.newBuilder()
.expireAfterWrite(2, TimeUnit.SECONDS)
.build<Player, Collection<Reforge>>()
@JvmStatic
fun registerProvider(provider: SlotProvider) {
slotProviders.add {
val found = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
for ((item, slot) in provider(it)) {
if (item != null && slot != null) {
found[item] = slot
}
}
found
}
}
private fun provide(player: Player): Map<ItemStack, ReforgeTarget.Slot> {
return itemCache.get(player) {
val found = mutableMapOf<ItemStack, ReforgeTarget.Slot>()
for (provider in slotProviders) {
found.putAll(provider(player))
}
found
}
}
fun provideReforges(player: Player): List<Reforge> {
return reforgeCache.get(player) {
val found = mutableListOf<Reforge>()
for ((itemStack, slot) in provide(player)) {
val reforge = getReforge(itemStack) ?: continue
if (slot != ReforgeTarget.Slot.ANY) {
if (!reforge.targets.map { it.slot }.contains(slot)) {
continue
}
}
found.add(reforge)
}
found
}.toList()
}
/**
* Clear cache.
*
* @param player The player.
*/
@JvmStatic
fun clearCache(player: Player) {
itemCache.invalidate(player)
reforgeCache.invalidate(player)
}
init {
registerProvider {
mapOf(
Pair(
it.inventory.itemInMainHand,
ReforgeTarget.Slot.HANDS
)
)
}
if (!plugin.configYml.getBool("no-offhand")) {
registerProvider {
mapOf(
Pair(
it.inventory.itemInOffHand,
ReforgeTarget.Slot.HANDS
)
)
}
}
registerProvider {
val items = mutableMapOf<ItemStack?, ReforgeTarget.Slot?>()
for (stack in it.inventory.armorContents) {
items[stack] = ReforgeTarget.Slot.ARMOR
}
items
}
}
}

8
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeStatus.kt Normal file
View File

@@ -0,0 +1,8 @@
package com.willfp.reforges.util
enum class ReforgeStatus {
ALLOW,
ALLOW_STONE,
INVALID_ITEM,
NO_ITEM
}

283
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/util/ReforgeUtils.kt Normal file
View File

@@ -0,0 +1,283 @@
package com.willfp.reforges.util
import com.willfp.eco.core.fast.FastItemStack
import com.willfp.eco.core.items.TestableItem
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.reforges.Reforge
import com.willfp.reforges.reforges.Reforges.getByKey
import com.willfp.reforges.reforges.Reforges.values
import com.willfp.reforges.reforges.ReforgeTarget
import com.willfp.reforges.reforges.util.MetadatedReforgeStatus
import org.bukkit.Material
import org.bukkit.inventory.ItemStack
import org.bukkit.inventory.meta.ItemMeta
import org.bukkit.persistence.PersistentDataContainer
import org.bukkit.persistence.PersistentDataType
object ReforgeUtils {
private val PLUGIN = ReforgesPlugin.instance
/**
* The key for storing reforges.
*/
private val REFORGE_KEY = PLUGIN.namespacedKeyFactory.create("reforge")
/**
* The key for storing reforge amounts.
*/
private val REFORGE_AMOUNT = PLUGIN.namespacedKeyFactory.create("reforge_amount")
/**
* The key for storing reforge stones.
*/
private val REFORGE_STONE_KEY = PLUGIN.namespacedKeyFactory.create("reforge_stone")
/**
* Get a random reforge for a target.
*
* @param targets The targets.
*/
fun getRandomReforge(targets: Collection<ReforgeTarget>): Reforge? {
return getRandomReforge(targets, emptyList())
}
/**
* Get a random reforge for a target.
*
* @param targets The targets.
* @param disallowed The disallowed reforges.
*/
@JvmStatic
fun getRandomReforge(
targets: Collection<ReforgeTarget>,
disallowed: Collection<Reforge>
): Reforge? {
val applicable = mutableListOf<Reforge>()
for (reforge in values()) {
for (target in targets) {
if (reforge.targets.contains(target) && !reforge.requiresStone) {
applicable.add(reforge)
}
}
}
applicable.shuffle()
applicable.removeAll(disallowed)
return if (applicable.isEmpty()) {
null
} else applicable[0]
}
fun getStatus(captive: List<ItemStack?>): MetadatedReforgeStatus {
val toReforge = if (captive.isEmpty()) null else captive[0]
val stone = if (captive.size == 2) captive[1] else null
var status: ReforgeStatus? = null
val target: MutableList<ReforgeTarget> = ArrayList()
if (toReforge == null || toReforge.type == Material.AIR) {
status = ReforgeStatus.NO_ITEM
} else {
target.addAll(ReforgeTarget.getForItem(toReforge))
if (target.isEmpty()) {
status = ReforgeStatus.INVALID_ITEM
}
}
if (target.isNotEmpty()) {
status = ReforgeStatus.ALLOW
}
var cost = 0.0
if (status == ReforgeStatus.ALLOW) {
val reforgeStone = getReforgeStone(stone)
if (reforgeStone != null && reforgeStone.targets.stream()
.anyMatch { reforgeTarget: ReforgeTarget ->
reforgeTarget.items.stream()
.anyMatch { item: TestableItem -> item.matches(toReforge) }
}
) {
cost = reforgeStone.stonePrice.toDouble()
status = ReforgeStatus.ALLOW_STONE
}
}
return MetadatedReforgeStatus(status!!, cost)
}
/**
* Get reforge on an item.
*
* @param item The item to query.
* @return The found reforge, or null.
*/
fun getReforge(item: ItemStack?): Reforge? {
if (item == null) {
return null
}
val container = FastItemStack.wrap(item).persistentDataContainer
return getReforge(container)
}
/**
* Get reforge on an item.
*
* @param meta The item to query.
* @return The found reforge, or null.
*/
fun getReforge(meta: ItemMeta?): Reforge? {
if (meta == null) {
return null
}
val container = meta.persistentDataContainer
if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
return null
}
val active = container.get(REFORGE_KEY, PersistentDataType.STRING)
return getByKey(active)
}
/**
* Get reforge on an item.
*
* @param container The item to query.
* @return The found reforge, or null.
*/
fun getReforge(container: PersistentDataContainer?): Reforge? {
if (container == null) {
return null
}
if (!container.has(REFORGE_KEY, PersistentDataType.STRING)) {
return null
}
val active = container.get(REFORGE_KEY, PersistentDataType.STRING)
return getByKey(active)
}
/**
* Set reforge on an item.
*
* @param item The item.
* @param reforge The reforge.
*/
fun setReforge(
item: ItemStack,
reforge: Reforge
) {
if (item.itemMeta == null) {
return
}
val meta = item.itemMeta
setReforge(meta, reforge)
item.itemMeta = meta
}
/**
* Set reforge on an item.
*
* @param meta The meta.
* @param reforge The reforge.
*/
fun setReforge(
meta: ItemMeta,
reforge: Reforge
) {
val container = meta.persistentDataContainer
container.set(REFORGE_KEY, PersistentDataType.STRING, reforge.id)
}
/**
* Get reforge stone on an item.
*
* @param item The item to query.
* @return The found reforge, or null.
*/
fun getReforgeStone(item: ItemStack?): Reforge? {
if (item == null) {
return null
}
val container = FastItemStack.wrap(item).persistentDataContainer
return getReforgeStone(container)
}
/**
* Get reforge stone on an item.
*
* @param meta The item to query.
* @return The found reforge, or null.
*/
fun getReforgeStone(meta: ItemMeta?): Reforge? {
if (meta == null) {
return null
}
val container = meta.persistentDataContainer
if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
return null
}
val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING)
return getByKey(active)
}
/**
* Get reforge stone on an item.
*
* @param container The item to query.
* @return The found reforge, or null.
*/
fun getReforgeStone(container: PersistentDataContainer?): Reforge? {
if (container == null) {
return null
}
if (!container.has(REFORGE_STONE_KEY, PersistentDataType.STRING)) {
return null
}
val active = container.get(REFORGE_STONE_KEY, PersistentDataType.STRING)
return getByKey(active)
}
/**
* Set an item to be a reforge stone.
*
* @param item The item.
* @param reforge The reforge.
*/
fun setReforgeStone(
item: ItemStack,
reforge: Reforge
) {
if (item.itemMeta == null) {
return
}
val meta = item.itemMeta
val container = meta.persistentDataContainer
container.set(REFORGE_STONE_KEY, PersistentDataType.STRING, reforge.id)
item.itemMeta = meta
}
/**
* Get the amount of reforges done to an item.
*
* @param item The item.
*/
@JvmStatic
fun getReforges(item: ItemStack): Int {
val meta = item.itemMeta ?: return 0
val container = meta.persistentDataContainer
if (!container.has(REFORGE_AMOUNT, PersistentDataType.INTEGER)) {
container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, 0)
item.itemMeta = meta
}
val amount = container.get(REFORGE_AMOUNT, PersistentDataType.INTEGER)
return amount ?: 0
}
/**
* Get the amount of reforges done to an item.
*
* @param item The item.
*/
@JvmStatic
fun incrementReforges(item: ItemStack) {
val meta = item.itemMeta ?: return
var amount = getReforges(item)
amount++
val container = meta.persistentDataContainer
container.set(REFORGE_AMOUNT, PersistentDataType.INTEGER, amount)
item.itemMeta = meta
}
}