Repo-Mirror/Reforges
9
0
Fork 0
mirror of https://github.com/Auxilor/Reforges.git synced 2025-12-31 04:46:42 +00:00
Code Issues Releases 1 Activity

Rebuilt around libreforge

Browse Source
This commit is contained in:
Auxilor
2021-11-18 13:21:57 +00:00
parent 1929e2f94b
commit 79c821af4e
43 changed files with 36 additions and 1856 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -5,33 +5,28 @@ 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.api.LibReforge;
import com.willfp.libreforge.api.LibReforgeKt;
import com.willfp.libreforge.api.effects.ConfiguredEffect;
import com.willfp.reforges.commands.CommandReforge;
import com.willfp.reforges.commands.CommandReforges;
import com.willfp.reforges.config.ReforgesJson;
import com.willfp.reforges.config.TargetYml;
import com.willfp.reforges.display.ReforgesDisplay;
import com.willfp.reforges.effects.ConfiguredEffect;
import com.willfp.reforges.effects.Effect;
import com.willfp.reforges.effects.Effects;
import com.willfp.reforges.integrations.aureliumskills.AureliumSkillsIntegration;
import com.willfp.reforges.integrations.ecoskills.EcoSkillsIntegration;
import com.willfp.reforges.integrations.talismans.TalismansIntegration;
import com.willfp.reforges.integrations.ultimateskills.UltimateSkillsIntegration;
import com.willfp.reforges.reforges.Reforge;
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.reforges.util.WatcherTriggers;
import com.willfp.reforges.util.AntiPlaceListener;
import com.willfp.reforges.util.DiscoverRecipeListener;
import lombok.Getter;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.event.HandlerList;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
@@ -58,6 +53,7 @@ public class ReforgesPlugin extends EcoPlugin {
*/
public ReforgesPlugin() {
super(1330, 12412, "&3", true);
LibReforge.init(this);
this.targetYml = new TargetYml(this);
this.reforgesJson = new ReforgesJson(this);
instance = this;
@@ -73,7 +69,7 @@ public class ReforgesPlugin extends EcoPlugin {
for (Player player : Bukkit.getOnlinePlayers()) {
for (Reforge value : Reforges.values()) {
for (ConfiguredEffect effect : value.getEffects()) {
effect.getEffect().handleDisabling(player);
effect.getEffect().disableForPlayer(player);
}
}
}
@@ -81,14 +77,10 @@ public class ReforgesPlugin extends EcoPlugin {
@Override
protected void handleReload() {
for (Effect effect : Effects.values()) {
HandlerList.unregisterAll(effect);
this.getScheduler().run(() -> this.getEventManager().registerListener(effect));
}
this.getLogger().info(Reforges.values().size() + " Reforges Loaded");
this.getScheduler().runTimer(() -> {
for (Player player : Bukkit.getOnlinePlayers()) {
ReforgeLookup.updateReforges(player);
LibReforgeKt.updateEffects(player);
}
}, 81, 81);
}
@@ -98,7 +90,6 @@ public class ReforgesPlugin extends EcoPlugin {
return Arrays.asList(
new DiscoverRecipeListener(this),
new AntiPlaceListener(),
new WatcherTriggers(this),
new ReforgeEnableListeners(this)
);
}
@@ -118,12 +109,17 @@ public class ReforgesPlugin extends EcoPlugin {
@Override
protected List<IntegrationLoader> loadIntegrationLoaders() {
return Arrays.asList(
new IntegrationLoader("UltimateCore-Skills", UltimateSkillsIntegration::load),
new IntegrationLoader("EcoSkills", EcoSkillsIntegration::load),
new IntegrationLoader("Talismans", TalismansIntegration::registerProvider),
new IntegrationLoader("AureliumSkills", AureliumSkillsIntegration::load)
List<IntegrationLoader> loaders = new ArrayList<>();
loaders.addAll(LibReforge.getIntegrationLoaders());
loaders.addAll(
Arrays.asList(
new IntegrationLoader("Talismans", TalismansIntegration::registerProvider)
)
);
return loaders;
}
@Override

62
eco-core/core-plugin/src/main/java/com/willfp/reforges/conditions/Condition.java
View File

@@ -1,62 +0,0 @@
package com.willfp.reforges.conditions;
import com.willfp.eco.core.config.interfaces.JSONConfig;
import com.willfp.reforges.ReforgesPlugin;
import lombok.AccessLevel;
import lombok.Getter;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.NotNull;
import java.util.Objects;
public abstract class Condition implements Listener {
/**
* Instance of Reforges.
*/
@Getter(AccessLevel.PROTECTED)
private final ReforgesPlugin plugin = ReforgesPlugin.getInstance();
/**
* The name of the condition.
*/
@Getter
private final String id;
/**
* Create a new condition.
*
* @param id The condition id.
*/
protected Condition(@NotNull final String id) {
this.id = id;
Conditions.addNewCondition(this);
}
/**
* Get if condition is met for a player.
*
* @param player The player.
* @param config The config of the condition.
* @return If met.
*/
public abstract boolean isConditionMet(@NotNull Player player,
@NotNull JSONConfig config);
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Condition condition)) {
return false;
}
return getId().equals(condition.getId());
}
@Override
public int hashCode() {
return Objects.hash(this.getId());
}
}

76
eco-core/core-plugin/src/main/java/com/willfp/reforges/conditions/Conditions.java
View File

@@ -1,76 +0,0 @@
package com.willfp.reforges.conditions;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableList;
import com.willfp.reforges.conditions.conditions.ConditionAboveHealthPercent;
import com.willfp.reforges.conditions.conditions.ConditionAboveHungerPercent;
import com.willfp.reforges.conditions.conditions.ConditionAboveXPLevel;
import com.willfp.reforges.conditions.conditions.ConditionAboveY;
import com.willfp.reforges.conditions.conditions.ConditionBelowHealthPercent;
import com.willfp.reforges.conditions.conditions.ConditionBelowHungerPercent;
import com.willfp.reforges.conditions.conditions.ConditionBelowXPLevel;
import com.willfp.reforges.conditions.conditions.ConditionBelowY;
import com.willfp.reforges.conditions.conditions.ConditionHasPermission;
import com.willfp.reforges.conditions.conditions.ConditionInAir;
import com.willfp.reforges.conditions.conditions.ConditionInBiome;
import com.willfp.reforges.conditions.conditions.ConditionInWater;
import com.willfp.reforges.conditions.conditions.ConditionInWorld;
import com.willfp.reforges.conditions.conditions.ConditionIsSneaking;
import lombok.experimental.UtilityClass;
import org.jetbrains.annotations.NotNull;
import java.util.List;
@UtilityClass
@SuppressWarnings("unused")
public class Conditions {
/**
* All registered conditions.
*/
private static final BiMap<String, Condition> BY_ID = HashBiMap.create();
public static final Condition BELOW_Y = new ConditionBelowY();
public static final Condition ABOVE_Y = new ConditionAboveY();
public static final Condition ABOVE_HEALTH_PERCENT = new ConditionAboveHealthPercent();
public static final Condition BELOW_HEALTH_PERCENT = new ConditionBelowHealthPercent();
public static final Condition IN_WATER = new ConditionInWater();
public static final Condition IN_WORLD = new ConditionInWorld();
public static final Condition ABOVE_XP_LEVEL = new ConditionAboveXPLevel();
public static final Condition BELOW_XP_LEVEL = new ConditionBelowXPLevel();
public static final Condition ABOVE_HUNGER_PERCENT = new ConditionAboveHungerPercent();
public static final Condition BELOW_HUNGER_PERCENT = new ConditionBelowHungerPercent();
public static final Condition IN_BIOME = new ConditionInBiome();
public static final Condition HAS_PERMISSION = new ConditionHasPermission();
public static final Condition IS_SNEAKING = new ConditionIsSneaking();
public static final Condition IN_AIR = new ConditionInAir();
/**
* Get condition matching name.s
*
* @param name The name to query.
* @return The matching condition, or null if not found.
*/
public static Condition getByID(@NotNull final String name) {
return BY_ID.get(name);
}
/**
* List of all registered conditions.
*
* @return The conditions.
*/
public static List<Condition> values() {
return ImmutableList.copyOf(BY_ID.values());
}
/**
* Add new condition to EcoArmor.
*
* @param condition The condition to add.
*/
public static void addNewCondition(@NotNull final Condition condition) {
BY_ID.remove(condition.getId());
BY_ID.put(condition.getId(), condition);
}
}

122
eco-core/core-plugin/src/main/java/com/willfp/reforges/effects/Effect.java
View File

@@ -1,122 +0,0 @@
package com.willfp.reforges.effects;
import com.willfp.eco.core.config.interfaces.JSONConfig;
import com.willfp.reforges.ReforgesPlugin;
import com.willfp.reforges.reforges.util.Watcher;
import org.bukkit.NamespacedKey;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import org.jetbrains.annotations.NotNull;
import java.util.Arrays;
import java.util.Objects;
import java.util.UUID;
public abstract class Effect implements Listener, Watcher {
/**
* Instance of reforges.
*/
private final ReforgesPlugin plugin = ReforgesPlugin.getInstance();
/**
* The effect ID.
*/
private final String id;
/**
* Create a new effect.
*
* @param id The id.
*/
protected Effect(@NotNull final String id) {
this.id = id;
Effects.addNewEffect(this);
}
/**
* Get the effect ID.
*
* @return The ID.
*/
public String getId() {
return id;
}
/**
* Generate a UUID with a specified index.
*
* @param index The index.
* @param extra The extra
* @return The UUID.
*/
protected UUID getUUID(final int index,
@NotNull final Object... extra) {
return UUID.nameUUIDFromBytes((this.id + index + Arrays.hashCode(extra)).getBytes());
}
/**
* Generate a NamespacedKey with a specified index.
*
* @param index The index.
* @return The NamespacedKey.
*/
protected NamespacedKey getNamespacedKey(final int index) {
return this.getPlugin().getNamespacedKeyFactory().create(this.id + "_" + index);
}
/**
* Handle application of a reforge containing this effect.
*
* @param player The player.
* @param config The config.
*/
public final void handleEnabling(@NotNull final Player player,
@NotNull final JSONConfig config) {
PlayerEffectStack.pushEffect(player, this);
this.handleEnable(player, config);
}
protected void handleEnable(@NotNull final Player player,
@NotNull final JSONConfig config) {
// Override when needed.
}
/**
* Handle removal of a reforge containing this effect.
*
* @param player The player.
*/
public final void handleDisabling(@NotNull final Player player) {
this.handleDisable(player);
PlayerEffectStack.popEffect(player, this);
}
protected void handleDisable(@NotNull final Player player) {
// Override when needed.
}
/**
* Get instance of reforges.
* @return The instance.
*/
protected ReforgesPlugin getPlugin() {
return this.plugin;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof Effect effect)) {
return false;
}
return this.getId().equals(effect.getId());
}
@Override
public int hashCode() {
return Objects.hash(this.getId());
}
}

68
eco-core/core-plugin/src/main/java/com/willfp/reforges/effects/Effects.java
View File

@@ -1,68 +0,0 @@
package com.willfp.reforges.effects;
import com.google.common.collect.BiMap;
import com.google.common.collect.HashBiMap;
import com.google.common.collect.ImmutableList;
import com.willfp.reforges.effects.effects.EffectAttackSpeedMultiplier;
import com.willfp.reforges.effects.effects.EffectCritMultiplier;
import com.willfp.reforges.effects.effects.EffectDamageMultiplier;
import com.willfp.reforges.effects.effects.EffectDurabilityMultiplier;
import com.willfp.reforges.effects.effects.EffectIncomingDamageMultiplier;
import com.willfp.reforges.effects.effects.EffectKnockbackMultiplier;
import com.willfp.reforges.effects.effects.EffectMovementSpeedMultiplier;
import com.willfp.reforges.effects.effects.EffectRewardBlockBreak;
import com.willfp.reforges.effects.effects.EffectRewardKill;
import lombok.experimental.UtilityClass;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.List;
@UtilityClass
@SuppressWarnings("unused")
public class Effects {
/**
* All registered effects.
*/
private static final BiMap<String, Effect> BY_ID = HashBiMap.create();
public static final Effect DAMAGE_MULTIPLIER = new EffectDamageMultiplier();
public static final Effect CRIT_MULTIPLIER = new EffectCritMultiplier();
public static final Effect REWARD_KILL = new EffectRewardKill();
public static final Effect KNOCKBACK_MULTIPLIER = new EffectKnockbackMultiplier();
public static final Effect REWARD_BLOCK_BREAK = new EffectRewardBlockBreak();
public static final Effect INCOMING_DAMAGE_MULTIPLIER = new EffectIncomingDamageMultiplier();
public static final Effect ATTACK_SPEED_MULTIPLIER = new EffectAttackSpeedMultiplier();
public static final Effect DURABILITY_MULTIPLIER = new EffectDurabilityMultiplier();
public static final Effect MOVEMENT_SPEED_MULTIPLIER = new EffectMovementSpeedMultiplier();
/**
* Get effect matching id.
*
* @param id The id to query.
* @return The matching effect, or null if not found.
*/
@Nullable
public static Effect getByID(@NotNull final String id) {
return BY_ID.get(id);
}
/**
* List of all registered effects.
*
* @return The effects.
*/
public static List<Effect> values() {
return ImmutableList.copyOf(BY_ID.values());
}
/**
* Add new effect to EcoWeapons.
*
* @param effect The effect to add.
*/
public static void addNewEffect(@NotNull final Effect effect) {
BY_ID.remove(effect.getId());
BY_ID.put(effect.getId(), effect);
}
}

106
eco-core/core-plugin/src/main/java/com/willfp/reforges/events/EffectActivateEvent.java
View File

@@ -1,106 +0,0 @@
package com.willfp.reforges.events;
import com.willfp.reforges.effects.Effect;
import com.willfp.reforges.reforges.Reforge;
import org.bukkit.entity.Player;
import org.bukkit.event.Cancellable;
import org.bukkit.event.HandlerList;
import org.bukkit.event.player.PlayerEvent;
import org.jetbrains.annotations.NotNull;
public class EffectActivateEvent extends PlayerEvent implements Cancellable {
/**
* The reforge.
*/
private final Reforge reforge;
/**
* The effect that activated.
*/
private final Effect effect;
/**
* If the event is cancelled.
*/
private boolean cancelled;
/**
* Bukkit parity.
*/
private static final HandlerList HANDLERS = new HandlerList();
/**
* Create new EffectActivateEvent.
*
* @param who The player.
* @param reforge The reforge.
* @param effect The effect.
*/
public EffectActivateEvent(@NotNull final Player who,
@NotNull final Reforge reforge,
@NotNull final Effect effect) {
super(who);
this.reforge = reforge;
this.effect = effect;
this.cancelled = false;
}
/**
* Get if the effect activation is cancelled.
*
* @return If cancelled.
*/
@Override
public boolean isCancelled() {
return this.cancelled;
}
/**
* Set if the event is cancelled.
*
* @param cancel If cancelled.
*/
@Override
public void setCancelled(final boolean cancel) {
this.cancelled = cancel;
}
/**
* Bukkit parity.
*
* @return The handlers.
*/
@Override
public @NotNull HandlerList getHandlers() {
return HANDLERS;
}
/**
* Get the reforge associated with the event.
*
* @return The reforge.
*/
@NotNull
public Reforge getReforge() {
return this.reforge;
}
/**
* Get the effect associated with the event.
*
* @return The effect.
*/
@NotNull
public Effect getEffect() {
return this.effect;
}
/**
* Bukkit parity.
*
* @return The handler list.
*/
public static HandlerList getHandlerList() {
return HANDLERS;
}
}

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

@@ -1,9 +1,8 @@
package com.willfp.reforges.reforges.util;
import com.willfp.eco.core.EcoPlugin;
import com.willfp.eco.util.ListUtils;
import com.willfp.libreforge.api.LibReforge;
import com.willfp.reforges.ReforgesPlugin;
import com.willfp.reforges.conditions.ConfiguredCondition;
import com.willfp.reforges.reforges.Reforge;
import com.willfp.reforges.reforges.meta.ReforgeTarget;
import org.bukkit.entity.Player;
@@ -39,11 +38,6 @@ public class ReforgeLookup {
*/
private static final Map<UUID, Collection<Reforge>> REFORGE_CACHE = new WeakHashMap<>();
/**
* Previous reforge states.
*/
private static final Map<UUID, Collection<Reforge>> PREVIOUS_STATES = new WeakHashMap<>();
/**
* Instance of Reforges.
*/
@@ -125,100 +119,6 @@ public class ReforgeLookup {
return found;
}
/**
* Clear caches.
*
* @param player The player.
*/
public static void clearCaches(@NotNull final Player player) {
REFORGE_CACHE.remove(player.getUniqueId());
ITEM_CACHE.remove(player.getUniqueId());
}
/**
* Update reforges for a player.
*
* @param player The player.
*/
public static void updateReforges(@NotNull final Player player) {
List<Reforge> before = new ArrayList<>();
if (PREVIOUS_STATES.containsKey(player.getUniqueId())) {
before.addAll(PREVIOUS_STATES.get(player.getUniqueId()));
}
ReforgeLookup.provideReforges(player);
ReforgeLookup.clearCaches(player);
PLUGIN.getScheduler().run(() -> {
List<Reforge> after = ReforgeLookup.provideReforges(player);
PREVIOUS_STATES.put(player.getUniqueId(), after);
Map<Reforge, Integer> beforeFrequency = ListUtils.listToFrequencyMap(before);
Map<Reforge, Integer> afterFrequency = ListUtils.listToFrequencyMap(after);
List<Reforge> added = new ArrayList<>();
List<Reforge> removed = new ArrayList<>();
for (Map.Entry<Reforge, Integer> entry : new HashSet<>(afterFrequency.entrySet())) {
int amount = entry.getValue();
Reforge reforge = entry.getKey();
amount -= beforeFrequency.getOrDefault(reforge, 0);
if (amount < 1) {
continue;
}
for (int i = 0; i < amount; i++) {
added.add(reforge);
}
}
for (Map.Entry<Reforge, Integer> entry : new HashSet<>(beforeFrequency.entrySet())) {
int amount = entry.getValue();
Reforge reforge = entry.getKey();
amount -= afterFrequency.getOrDefault(reforge, 0);
if (amount < 1) {
continue;
}
for (int i = 0; i < amount; i++) {
removed.add(reforge);
}
}
for (Reforge reforge : added) {
boolean areConditionsMet = true;
for (ConfiguredCondition condition : reforge.getConditions()) {
if (!condition.getCondition().isConditionMet(player, condition.getConfig())) {
areConditionsMet = false;
break;
}
}
if (areConditionsMet) {
reforge.handleActivation(player);
}
}
for (Reforge reforge : removed) {
reforge.handleDeactivation(player);
}
for (Reforge reforge : after) {
boolean areConditionsMet = true;
for (ConfiguredCondition condition : reforge.getConditions()) {
if (!condition.getCondition().isConditionMet(player, condition.getConfig())) {
areConditionsMet = false;
break;
}
}
if (!areConditionsMet) {
reforge.handleDeactivation(player);
}
}
});
}
static {
registerProvider(player -> Map.of(
player.getInventory().getItemInMainHand(),
@@ -235,5 +135,7 @@ public class ReforgeLookup {
}
return items;
});
LibReforge.registerHolderProvider(player -> new ArrayList<>(provideReforges(player)));
}
}

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

@@ -1,5 +0,0 @@
package com.willfp.reforges.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
data class ConfiguredCondition(val condition: Condition, val config: JSONConfig)

48
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveHealthPercent.kt
View File

@@ -1,48 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.attribute.Attribute
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.entity.EntityDamageEvent
import org.bukkit.event.entity.EntityRegainHealthEvent
class ConditionAboveHealthPercent: Condition("above_health_percent") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: EntityRegainHealthEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: EntityDamageEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
val maxHealth = player.getAttribute(Attribute.GENERIC_MAX_HEALTH)?.value ?: return false
val health = player.health
return health / maxHealth * 100 >= config.getDouble("percent")
}
}

30
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveHungerPercent.kt
View File

@@ -1,30 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.entity.FoodLevelChangeEvent
class ConditionAboveHungerPercent : Condition("above_hunger_percent") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: FoodLevelChangeEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return (player.foodLevel / 20) * 100 >= config.getDouble("percent")
}
}

26
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveXPLevel.kt
View File

@@ -1,26 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerExpChangeEvent
class ConditionAboveXPLevel : Condition("above_xp_level") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerExpChangeEvent) {
val player = event.player
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.level >= config.getInt("level")
}
}

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionAboveY.kt
View File

@@ -1,29 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionAboveY: Condition("above_y") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
if (event.from.y == event.to.y) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.location.y >= config.getDouble("y")
}
}

48
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowHealthPercent.kt
View File

@@ -1,48 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.attribute.Attribute
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.entity.EntityDamageEvent
import org.bukkit.event.entity.EntityRegainHealthEvent
class ConditionBelowHealthPercent: Condition("below_health_percent") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: EntityRegainHealthEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: EntityDamageEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
val maxHealth = player.getAttribute(Attribute.GENERIC_MAX_HEALTH)?.value ?: return false
val health = player.health
return health / maxHealth * 100 <= config.getDouble("percent")
}
}

30
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowHungerPercent.kt
View File

@@ -1,30 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.entity.FoodLevelChangeEvent
class ConditionBelowHungerPercent : Condition("below_hunger_percent") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: FoodLevelChangeEvent) {
val player = event.entity
if (player !is Player) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return (player.foodLevel / 20) * 100 <= config.getDouble("percent")
}
}

26
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowXPLevel.kt
View File

@@ -1,26 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerExpChangeEvent
class ConditionBelowXPLevel: Condition("below_xp_level") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerExpChangeEvent) {
val player = event.player
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.level < config.getInt("level")
}
}

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionBelowY.kt
View File

@@ -1,29 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionBelowY: Condition("below_y") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
if (event.from.y == event.to.y) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.location.y < config.getDouble("y")
}
}

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

@@ -1,12 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import org.bukkit.entity.Player
class ConditionHasPermission : Condition("is_sneaking") {
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.hasPermission(config.getString("permission"))
}
}

25
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInAir.kt
View File

@@ -1,25 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionInAir: Condition("in_air") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.location.block.isEmpty
}
}

33
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInBiome.kt
View File

@@ -1,33 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionInBiome: Condition("in_biome") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
if (event.from.world?.getBiome(event.from) == event.to.world?.getBiome(event.to)) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return config.getStrings("biomes").contains(player.world.getBiome(
player.location.blockX,
player.location.blockY,
player.location.blockZ
).name.lowercase())
}
}

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInWater.kt
View File

@@ -1,29 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionInWater: Condition("in_water") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
if (event.from.world?.getBlockAt(event.from)?.type == event.to.world?.getBlockAt(event.to)?.type) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.isInWater
}
}

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionInWorld.kt
View File

@@ -1,29 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerMoveEvent
class ConditionInWorld: Condition("in_world") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerMoveEvent) {
val player = event.player
if (event.from.world == event.to.world) {
return
}
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.world.name.equals(config.getString("world"), ignoreCase = true)
}
}

25
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/conditions/conditions/ConditionIsSneaking.kt
View File

@@ -1,25 +0,0 @@
package com.willfp.reforges.conditions.conditions
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.conditions.Condition
import com.willfp.reforges.reforges.util.ReforgeLookup
import org.bukkit.entity.Player
import org.bukkit.event.EventHandler
import org.bukkit.event.EventPriority
import org.bukkit.event.player.PlayerToggleSneakEvent
class ConditionIsSneaking: Condition("is_sneaking") {
@EventHandler(
priority = EventPriority.MONITOR,
ignoreCancelled = true
)
fun handle(event: PlayerToggleSneakEvent) {
val player = event.player
ReforgeLookup.updateReforges(player)
}
override fun isConditionMet(player: Player, config: JSONConfig): Boolean {
return player.isSprinting
}
}

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

@@ -1,5 +0,0 @@
package com.willfp.reforges.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
data class ConfiguredEffect(val effect: Effect, val config: JSONConfig)

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/PlayerEffectStack.kt
View File

@@ -1,29 +0,0 @@
@file:JvmName("PlayerEffectStack")
package com.willfp.reforges.effects
import org.bukkit.entity.Player
import java.util.*
private val effectStack = mutableMapOf<UUID, MutableMap<Effect, Int>>()
fun Player.pushEffect(effect: Effect) {
val stack = effectStack[this.uniqueId] ?: mutableMapOf()
var amount = stack[effect] ?: 0
amount++
stack[effect] = amount
effectStack[this.uniqueId] = stack
}
fun Player.popEffect(effect: Effect) {
val stack = effectStack[this.uniqueId] ?: mutableMapOf()
var amount = stack[effect] ?: 0
amount--
stack[effect] = if (amount < 0) 0 else amount
effectStack[this.uniqueId] = stack
}
fun Player.getEffectAmount(effect: Effect): Int {
val stack = effectStack[this.uniqueId] ?: mutableMapOf()
return stack[effect] ?: 0
}

36
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectAttackSpeedMultiplier.kt
View File

@@ -1,36 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import com.willfp.reforges.effects.getEffectAmount
import org.bukkit.attribute.Attribute
import org.bukkit.attribute.AttributeModifier
import org.bukkit.entity.Player
class EffectAttackSpeedMultiplier : Effect("attack_speed_multiplier") {
override fun handleEnable(player: Player, config: JSONConfig) {
val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED) ?: return
val uuid = this.getUUID(player.getEffectAmount(this))
attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
attribute.addModifier(
AttributeModifier(
uuid,
this.id,
config.getDouble("multiplier") - 1,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
override fun handleDisable(player: Player) {
val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_SPEED) ?: return
attribute.removeModifier(
AttributeModifier(
this.getUUID(player.getEffectAmount(this)),
this.id,
0.0,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
}

21
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectCritMultiplier.kt
View File

@@ -1,21 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import org.bukkit.entity.LivingEntity
import org.bukkit.entity.Player
import org.bukkit.event.entity.EntityDamageByEntityEvent
class EffectCritMultiplier : Effect("crit_multiplier") {
override fun onAnyDamage(
attacker: Player,
victim: LivingEntity,
event: EntityDamageByEntityEvent,
config: JSONConfig
) {
if (attacker.velocity.y >= 0) {
return
}
event.damage *= config.getDouble("multiplier")
}
}

18
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectDamageMultiplier.kt
View File

@@ -1,18 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import org.bukkit.entity.LivingEntity
import org.bukkit.entity.Player
import org.bukkit.event.entity.EntityDamageByEntityEvent
class EffectDamageMultiplier : Effect("damage_multiplier") {
override fun onAnyDamage(
attacker: Player,
victim: LivingEntity,
event: EntityDamageByEntityEvent,
config: JSONConfig
) {
event.damage *= config.getDouble("multiplier")
}
}

30
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectDurabilityMultiplier.kt
View File

@@ -1,30 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.eco.util.NumberUtils
import com.willfp.reforges.effects.Effect
import org.bukkit.event.player.PlayerItemDamageEvent
import kotlin.math.ceil
class EffectDurabilityMultiplier : Effect("durability_multiplier") {
override fun onDurabilityDamage(
event: PlayerItemDamageEvent,
config: JSONConfig
) {
val multiplier = config.getDouble("multiplier")
if (multiplier == 0.0) {
event.isCancelled = true
return
}
if (multiplier < 1) {
event.damage *= ceil(1 / multiplier).toInt()
return
}
val chance = 1 - (1 / multiplier)
if (NumberUtils.randFloat(0.0, 1.0) < chance) {
event.isCancelled = true
}
}
}

16
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectIncomingDamageMultiplier.kt
View File

@@ -1,16 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import org.bukkit.entity.Player
import org.bukkit.event.entity.EntityDamageEvent
class EffectIncomingDamageMultiplier : Effect("incoming_damage_multiplier") {
override fun onDamageWearingArmor(
victim: Player,
event: EntityDamageEvent,
config: JSONConfig
) {
event.damage *= config.getDouble("multiplier")
}
}

39
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectKnockbackMultiplier.kt
View File

@@ -1,39 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import com.willfp.reforges.effects.getEffectAmount
import org.bukkit.attribute.Attribute
import org.bukkit.attribute.AttributeModifier
import org.bukkit.entity.Player
class EffectKnockbackMultiplier : Effect("knockback_multiplier") {
override fun handleEnable(
player: Player,
config: JSONConfig
) {
val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_KNOCKBACK) ?: return
val uuid = this.getUUID(player.getEffectAmount(this))
attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
attribute.addModifier(
AttributeModifier(
uuid,
this.id,
config.getDouble("multiplier") - 1,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
override fun handleDisable(player: Player) {
val attribute = player.getAttribute(Attribute.GENERIC_ATTACK_KNOCKBACK) ?: return
attribute.removeModifier(
AttributeModifier(
this.getUUID(player.getEffectAmount(this)),
this.id,
0.0,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
}

39
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectMovementSpeedMultiplier.kt
View File

@@ -1,39 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import com.willfp.reforges.effects.getEffectAmount
import org.bukkit.attribute.Attribute
import org.bukkit.attribute.AttributeModifier
import org.bukkit.entity.Player
class EffectMovementSpeedMultiplier : Effect("movement_speed_multiplier") {
override fun handleEnable(
player: Player,
config: JSONConfig
) {
val attribute = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED) ?: return
val uuid = this.getUUID(player.getEffectAmount(this))
attribute.removeModifier(AttributeModifier(uuid, this.id, 0.0, AttributeModifier.Operation.MULTIPLY_SCALAR_1))
attribute.addModifier(
AttributeModifier(
uuid,
this.id,
config.getDouble("multiplier") - 1,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
override fun handleDisable(player: Player) {
val attribute = player.getAttribute(Attribute.GENERIC_MOVEMENT_SPEED) ?: return
attribute.removeModifier(
AttributeModifier(
this.getUUID(player.getEffectAmount(this)),
this.id,
0.0,
AttributeModifier.Operation.MULTIPLY_SCALAR_1
)
)
}
}

19
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectRewardBlockBreak.kt
View File

@@ -1,19 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.eco.core.integrations.economy.EconomyManager
import com.willfp.reforges.effects.Effect
import org.bukkit.block.Block
import org.bukkit.entity.Player
import org.bukkit.event.block.BlockBreakEvent
class EffectRewardBlockBreak : Effect("reward_block_break") {
override fun onBlockBreak(
player: Player,
block: Block,
event: BlockBreakEvent,
config: JSONConfig
) {
EconomyManager.giveMoney(player, config.getDouble("amount"))
}
}

17
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/effects/effects/EffectRewardKill.kt
View File

@@ -1,17 +0,0 @@
package com.willfp.reforges.effects.effects
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.eco.core.events.EntityDeathByEntityEvent
import com.willfp.eco.core.integrations.economy.EconomyManager
import com.willfp.reforges.effects.Effect
import org.bukkit.entity.LivingEntity
import org.bukkit.entity.Player
class EffectRewardKill : Effect("reward_kill") {
override fun onKill(killer: Player,
victim: LivingEntity,
event: EntityDeathByEntityEvent,
config: JSONConfig) {
EconomyManager.giveMoney(killer, config.getDouble("amount"))
}
}

17
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/aureliumskills/AureliumSkillsIntegration.kt
View File

@@ -1,17 +0,0 @@
package com.willfp.reforges.integrations.aureliumskills
import com.willfp.eco.core.integrations.Integration
import com.willfp.reforges.effects.Effect
object AureliumSkillsIntegration : Integration {
private lateinit var ADD_STAT: Effect
@JvmStatic
fun load() {
ADD_STAT = EffectAddStat()
}
override fun getPluginName(): String {
return "AureliumSkills"
}
}

29
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/aureliumskills/EffectAddStat.kt
View File

@@ -1,29 +0,0 @@
package com.willfp.reforges.integrations.aureliumskills
import com.archyx.aureliumskills.api.AureliumAPI
import com.archyx.aureliumskills.stats.Stats
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.reforges.effects.Effect
import com.willfp.reforges.effects.getEffectAmount
import org.bukkit.entity.Player
class EffectAddStat : Effect("add_stat") {
override fun handleEnable(
player: Player,
config: JSONConfig
) {
AureliumAPI.addStatModifier(
player,
this.getNamespacedKey(player.getEffectAmount(this)).key,
Stats.valueOf(config.getString("stat", false)),
config.getDouble("amount")
)
}
override fun handleDisable(player: Player) {
AureliumAPI.removeStatModifier(
player,
this.getNamespacedKey(player.getEffectAmount(this)).key,
)
}
}

17
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ecoskills/EcoSkillsIntegration.kt
View File

@@ -1,17 +0,0 @@
package com.willfp.reforges.integrations.ecoskills
import com.willfp.eco.core.integrations.Integration
import com.willfp.reforges.effects.Effect
object EcoSkillsIntegration : Integration {
private lateinit var ADD_STAT: Effect
@JvmStatic
fun load() {
ADD_STAT = EffectAddStat()
}
override fun getPluginName(): String {
return "EcoSkills"
}
}

38
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ecoskills/EffectAddStat.kt
View File

@@ -1,38 +0,0 @@
package com.willfp.reforges.integrations.ecoskills
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.ecoskills.api.EcoSkillsAPI
import com.willfp.ecoskills.api.modifier.PlayerStatModifier
import com.willfp.ecoskills.stats.Stats
import com.willfp.reforges.effects.Effect
import com.willfp.reforges.effects.getEffectAmount
import org.bukkit.entity.Player
class EffectAddStat : Effect("add_stat") {
private val api = EcoSkillsAPI.getInstance()
override fun handleEnable(
player: Player,
config: JSONConfig
) {
api.addStatModifier(
player,
PlayerStatModifier(
this.getNamespacedKey(player.getEffectAmount(this)),
Stats.getByID(config.getString("stat", false)) ?: Stats.WISDOM,
config.getInt("amount")
)
)
}
override fun handleDisable(player: Player) {
api.removeStatModifier(
player,
PlayerStatModifier(
this.getNamespacedKey(player.getEffectAmount(this)),
Stats.STRENGTH,
0
)
)
}
}

39
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/EffectAddAbility.kt
View File

@@ -1,39 +0,0 @@
package com.willfp.reforges.integrations.ultimateskills
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.eco.util.NumberUtils
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.effects.Effect
import mc.ultimatecore.skills.HyperSkills
import mc.ultimatecore.skills.objects.abilities.Ability
import org.bukkit.entity.Player
import org.bukkit.persistence.PersistentDataType
class EffectAddAbility : Effect("add_ultimateskills_ability") {
override fun handleEnable(
player: Player,
config: JSONConfig
) {
HyperSkills.getInstance().api.addAbility(
player.uniqueId,
Ability.valueOf(config.getString("ability", false)),
config.getDouble("amount")
)
player.persistentDataContainer.set(
ReforgesPlugin.getInstance().namespacedKeyFactory.create("addAbility"),
PersistentDataType.STRING,
NumberUtils.format(config.getDouble("amount")) + "::" + config.getString("ability", false)
)
}
override fun handleDisable(player: Player) {
player.persistentDataContainer.get(this.plugin.namespacedKeyFactory.create("addAbility"), PersistentDataType.STRING)
?.let {
HyperSkills.getInstance().api.removeAbility(
player.uniqueId,
Ability.valueOf(it.split("::")[1]),
it.split("::")[0].toDouble()
)
}
}
}

36
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/EffectAddPerk.kt
View File

@@ -1,36 +0,0 @@
package com.willfp.reforges.integrations.ultimateskills
import com.willfp.eco.core.config.interfaces.JSONConfig
import com.willfp.eco.util.NumberUtils
import com.willfp.reforges.effects.Effect
import mc.ultimatecore.skills.HyperSkills
import mc.ultimatecore.skills.objects.perks.Perk
import org.bukkit.entity.Player
import org.bukkit.persistence.PersistentDataType
class EffectAddPerk : Effect("add_ultimateskills_perk") {
override fun handleEnable(
player: Player,
config: JSONConfig
) {
HyperSkills.getInstance().api.addPerk(
player.uniqueId,
Perk.valueOf(config.getString("perk", false)),
config.getDouble("amount")
)
player.persistentDataContainer.set(this.plugin.namespacedKeyFactory.create("addPerk"), PersistentDataType.STRING,
NumberUtils.format(config.getDouble("amount")) + "::" + config.getString("perk", false)
)
}
override fun handleDisable(player: Player) {
player.persistentDataContainer.get(this.plugin.namespacedKeyFactory.create("addPerk"), PersistentDataType.STRING)
?.let {
HyperSkills.getInstance().api.removePerk(
player.uniqueId,
Perk.valueOf(it.split("::")[1]),
it.split("::")[0].toDouble()
)
}
}
}

19
eco-core/core-plugin/src/main/kotlin/com/willfp/reforges/integrations/ultimateskills/UltimateSkillsIntegration.kt
View File

@@ -1,19 +0,0 @@
package com.willfp.reforges.integrations.ultimateskills
import com.willfp.eco.core.integrations.Integration
import com.willfp.reforges.effects.Effect
object UltimateSkillsIntegration : Integration {
private lateinit var ADD_PERK: Effect
private lateinit var ADD_ABILITY: Effect
@JvmStatic
fun load() {
ADD_PERK = EffectAddPerk()
ADD_ABILITY = EffectAddAbility()
}
override fun getPluginName(): String {
return "UltimateSkills"
}
}

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

@@ -5,22 +5,22 @@ import com.willfp.eco.core.display.Display
import com.willfp.eco.core.items.CustomItem
import com.willfp.eco.core.items.builder.SkullBuilder
import com.willfp.eco.core.recipe.Recipes
import com.willfp.libreforge.api.conditions.Conditions
import com.willfp.libreforge.api.conditions.ConfiguredCondition
import com.willfp.libreforge.api.effects.ConfiguredEffect
import com.willfp.libreforge.api.effects.Effects
import com.willfp.libreforge.api.provider.Holder
import com.willfp.reforges.ReforgesPlugin
import com.willfp.reforges.conditions.Conditions
import com.willfp.reforges.conditions.ConfiguredCondition
import com.willfp.reforges.effects.ConfiguredEffect
import com.willfp.reforges.effects.Effects
import com.willfp.reforges.reforges.meta.ReforgeTarget
import com.willfp.reforges.reforges.util.ReforgeUtils
import org.bukkit.entity.Player
import org.bukkit.inventory.ItemStack
import java.util.*
import java.util.Objects
@Suppress("DEPRECATION")
class Reforge(
internal val config: JSONConfig,
private val plugin: ReforgesPlugin
) {
plugin: ReforgesPlugin
) : Holder {
val id = config.getString("id")
val name = config.getFormattedString("name")
@@ -29,12 +29,12 @@ class Reforge(
val targets = config.getStrings("targets").map { ReforgeTarget.getByName(it) }.toSet()
val effects = config.getSubsections("effects").map {
override val effects = config.getSubsections("effects").map {
val effect = Effects.getByID(it.getString("id")) ?: return@map null
ConfiguredEffect(effect, it)
}.filterNotNull().toSet()
val conditions = config.getSubsections("conditions").map {
override val conditions = config.getSubsections("conditions").map {
val condition = Conditions.getByID(it.getString("id")) ?: return@map null
ConfiguredCondition(condition, it)
}.filterNotNull().toSet()
@@ -75,18 +75,6 @@ class Reforge(
}
}
fun handleActivation(player: Player) {
for ((effect, config) in this.effects) {
effect.handleEnabling(player, config)
}
}
fun handleDeactivation(player: Player) {
for ((effect, _) in this.effects) {
effect.handleDisabling(player)
}
}
override fun equals(other: Any?): Boolean {
if (this === other) {
return true

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

@@ -1,388 +0,0 @@
package com.willfp.reforges.reforges.util
import com.willfp.eco.core.EcoPlugin
import com.willfp.eco.core.events.EntityDeathByEntityEvent
import com.willfp.eco.core.events.PlayerJumpEvent
import com.willfp.eco.core.integrations.antigrief.AntigriefManager
import com.willfp.eco.core.integrations.mcmmo.McmmoManager
import com.willfp.eco.util.NumberUtils
import com.willfp.reforges.events.EffectActivateEvent
import org.bukkit.entity.*
import org.bukkit.event.EventHandler
import org.bukkit.event.Listener
import org.bukkit.event.block.BlockBreakEvent
import org.bukkit.event.entity.EntityDamageByEntityEvent
import org.bukkit.event.entity.EntityDamageEvent
import org.bukkit.event.entity.ProjectileHitEvent
import org.bukkit.event.entity.ProjectileLaunchEvent
import org.bukkit.event.player.PlayerItemDamageEvent
class WatcherTriggers(
private val plugin: EcoPlugin
) : Listener {
@EventHandler(ignoreCancelled = true)
fun onBlockBreak(event: BlockBreakEvent) {
if (McmmoManager.isFake(event)) {
return
}
val player = event.player
val block = event.block
if (!AntigriefManager.canBreakBlock(player, block)) {
return
}
for (reforge in ReforgeLookup.provideReforges(player)) {
for ((key, value) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (value.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(player, reforge, key)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
key.onBlockBreak(player, block, event, value)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onArrowDamage(event: EntityDamageByEntityEvent) {
if (McmmoManager.isFake(event)) {
return
}
val arrow = event.damager
val victim = event.entity
if (arrow !is Arrow) {
return
}
if (victim !is LivingEntity) {
return
}
val shooter = arrow.shooter
if (shooter !is Player) {
return
}
if (!AntigriefManager.canInjure(shooter, victim)) {
return
}
if (event.isCancelled) {
return
}
for (reforge in ReforgeLookup.provideReforges(shooter)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(shooter, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onArrowDamage(shooter, victim, arrow, event, config)
effect.onAnyDamage(shooter, victim, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onTridentDamage(event: EntityDamageByEntityEvent) {
if (McmmoManager.isFake(event)) {
return
}
val trident = event.damager
val victim = event.entity
if (trident !is Trident) {
return
}
if (victim !is LivingEntity) {
return
}
val shooter = trident.shooter
if (shooter !is Player) {
return
}
val item = trident.item
if (!AntigriefManager.canInjure(shooter, victim)) {
return
}
if (event.isCancelled) {
return
}
val tridentReforge = ReforgeUtils.getReforge(item)
val add = if (tridentReforge == null) emptyList() else listOf(tridentReforge)
for (reforge in ReforgeLookup.provideReforges(shooter) union add) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(shooter, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onTridentDamage(shooter, victim, trident, event, config)
effect.onAnyDamage(shooter, victim, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onJump(event: PlayerJumpEvent) {
if (McmmoManager.isFake(event)) {
return
}
val player = event.player
for (reforge in ReforgeLookup.provideReforges(player)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(player, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onJump(player, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onMeleeAttack(event: EntityDamageByEntityEvent) {
if (McmmoManager.isFake(event)) {
return
}
val attacker = event.damager
if (attacker !is Player) {
return
}
val victim = event.entity
if (victim !is LivingEntity) {
return
}
if (event.isCancelled) {
return
}
if (event.cause == EntityDamageEvent.DamageCause.THORNS) {
return
}
if (!AntigriefManager.canInjure(attacker, victim)) {
return
}
for (reforge in ReforgeLookup.provideReforges(attacker)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(attacker, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onMeleeAttack(attacker, victim, event, config)
effect.onAnyDamage(attacker, victim, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onKill(event: EntityDeathByEntityEvent) {
if (McmmoManager.isFake(event)) {
return
}
var killer: Any? = null
if (event.killer is Player) {
killer = event.killer
} else if (event.killer is Projectile) {
if ((event.killer as Projectile).shooter is Player) {
killer = (event.killer as Projectile).shooter
}
}
if (killer !is Player) {
return
}
val victim = event.victim
if (!AntigriefManager.canInjure(killer, victim)) {
return
}
val trident = if (event.killer is Trident) (event.killer as Trident).item else null
val tridentReforge = if (trident == null) null else ReforgeUtils.getReforge(trident)
val add = if (tridentReforge == null) emptyList() else listOf(tridentReforge)
for (reforge in ReforgeLookup.provideReforges(killer) union add) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(killer, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
(effect as Watcher).onKill(killer, victim, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onProjectileLaunch(event: ProjectileLaunchEvent) {
if (McmmoManager.isFake(event)) {
return
}
val shooter = event.entity.shooter
if (shooter !is Player) {
return
}
for (reforge in ReforgeLookup.provideReforges(shooter)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(shooter, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onProjectileLaunch(shooter, event.entity, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onFallDamage(event: EntityDamageEvent) {
if (McmmoManager.isFake(event)) {
return
}
if (event.cause != EntityDamageEvent.DamageCause.FALL) {
return
}
val victim = event.entity
if (victim !is Player) {
return
}
for (reforge in ReforgeLookup.provideReforges(victim)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(victim, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onFallDamage(victim, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onProjectileHit(event: ProjectileHitEvent) {
if (McmmoManager.isFake(event)) {
return
}
val projectile = event.entity
val shooter = projectile.shooter
if (shooter !is Player) {
return
}
val trident = if (projectile is Trident) projectile.item else null
val tridentReforge = if (trident == null) null else ReforgeUtils.getReforge(trident)
val add = if (tridentReforge == null) emptyList() else listOf(tridentReforge)
for (reforge in ReforgeLookup.provideReforges(shooter) union add) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(shooter, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onProjectileHit(shooter, event, config)
}
}
}
}
@EventHandler(ignoreCancelled = true)
fun onDurabilityDamage(event: PlayerItemDamageEvent) {
if (McmmoManager.isFake(event)) {
return
}
val item = event.item
val reforge = ReforgeUtils.getReforge(item) ?: return
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(event.player, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onDurabilityDamage(event, config)
}
}
}
@EventHandler(ignoreCancelled = true)
fun onDamageWearingArmor(event: EntityDamageEvent) {
if (McmmoManager.isFake(event)) {
return
}
val victim = event.entity
if (victim !is Player) {
return
}
for (reforge in ReforgeLookup.provideReforges(victim)) {
for ((effect, config) in reforge.effects) {
if (NumberUtils.randFloat(0.0, 100.0) > (config.getDoubleOrNull("chance") ?: 100.0)) {
continue
}
val aEvent = EffectActivateEvent(victim, reforge, effect)
this.plugin.server.pluginManager.callEvent(aEvent)
if (!aEvent.isCancelled) {
effect.onDamageWearingArmor(victim, event, config)
}
}
}
}
}