Skip to content

Instantly share code, notes, and snippets.

@Lanse505

Lanse505/ItemStackModifierHolder.java

Created March 26, 2020 19:38
Show Gist options
  • Save Lanse505/e617efbfe3d2daadb72102f6c80ab720 to your computer and use it in GitHub Desktop.
Save Lanse505/e617efbfe3d2daadb72102f6c80ab720 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
ItemStackModifierHolder.java
package com.teamacronymcoders.essence.capabilities.itemstack;
import com.teamacronymcoders.essence.api.holder.ModifierHolder;
import com.teamacronymcoders.essence.api.holder.ModifierInstance;
import com.teamacronymcoders.essence.api.modified.IModified;
import com.teamacronymcoders.essence.api.modifier.core.Modifier;
import com.teamacronymcoders.essence.utils.helpers.EssenceItemstackModifierHelpers;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.ListNBT;
import net.minecraftforge.common.util.Constants;
import java.util.Arrays;
import java.util.List;
public class ItemStackModifierHolder extends ModifierHolder<ItemStack> {
private ItemStack stack;
public ItemStackModifierHolder() {
super(ItemStack.class);
}
public ItemStackModifierHolder(ItemStack stack) {
super(ItemStack.class);
this.stack = stack;
}
@Override
public boolean addModifierInstance(boolean simulate, ItemStack object, ModifierInstance<ItemStack>... instances) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
for (ModifierInstance<ItemStack> instance : instances) {
if (instance.getModifier().getType() == getType()) {
if (!sim.contains(instance)) {
sim.add(instance);
}
}
}
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
for (ModifierInstance<ItemStack> instance : instances) {
if (instance.getModifier().getType() == getType()) {
if (!getModifierInstances().contains(instance)) {
getModifierInstances().add(instance);
modified.decreaseFreeModifiers(instance.getModifier().getModifierCountValue(instance.getLevel(), object));
}
}
}
return true;
}
return false;
}
@Override
public boolean removeModifierInstance(boolean simulate, ItemStack object, ModifierInstance<ItemStack>... instances) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
Arrays.stream(instances).forEach(sim::remove);
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
int cmc = Arrays.stream(instances).map(instance -> getModifierInstances().stream()
.filter(trueInstance -> trueInstance.getModifier().equals(instance.getModifier()) && trueInstance.getModifierData() == instance.getModifierData())
.map(trueInstance -> {
if (instance.getModifier().getType() == getType()) {
getModifierInstances().remove(trueInstance);
return trueInstance.getModifier().getModifierCountValue(trueInstance.getLevel(), object);
}
return 0;
}).reduce(0, Integer::sum)).reduce(0, Integer::sum);
modified.addModifierWithoutIncreasingAdditional(cmc);
return true;
}
return false;
}
@Override
public boolean levelUpModifier(boolean simulate, ItemStack object, int increase, Modifier<ItemStack>... modifiers) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
Modifier<ItemStack> stackCoreModifier = instance.getModifier();
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
Modifier<ItemStack> stackCoreModifier = instance.getModifier();
int x = stackCoreModifier.getModifierCountValue(instance.getLevel(), object);
int y = stackCoreModifier.getModifierCountValue(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)), object);
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
if (x < y) {
modified.decreaseFreeModifiers(y - x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelUpModifier(boolean simulate, ItemStack object, int increase, ModifierInstance<ItemStack>... modifiersWithData) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
Modifier<ItemStack> stackCoreModifier = instance.getModifier();
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
Modifier<ItemStack> stackCoreModifier = instance.getModifier();
int x = stackCoreModifier.getModifierCountValue(instance.getLevel(), object);
int y = stackCoreModifier.getModifierCountValue(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)), object);
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
if (x < y) {
modified.decreaseFreeModifiers(y - x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelDownModifier(boolean simulate, ItemStack object, int decrease, Modifier<ItemStack>... modifiers) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
sim.remove(instance);
return;
}
instance.setLevel(instance.getLevel() - decrease);
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> modifier == instance.getModifier()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
removeModifierInstance(false, object, instance);
return;
}
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(instance.getLevel() - decrease, object);
instance.setLevel(instance.getLevel() - decrease);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelDownModifier(boolean simulate, ItemStack object, int decrease, ModifierInstance<ItemStack>... modifiersWithData) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
sim.remove(instance);
return;
}
instance.setLevel(instance.getLevel() - decrease);
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
removeModifierInstance(false, object, instance);
return;
}
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(instance.getLevel() - decrease, object);
instance.setLevel(instance.getLevel() - decrease);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelSetModifier(boolean simulate, ItemStack object, int level, Modifier<ItemStack>... modifiers) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
instance.setLevel(level);
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(level, object);
instance.setLevel(level);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
if (x < 0) {
modified.decreaseFreeModifiers(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelSetModifier(boolean simulate, ItemStack object, int level, ModifierInstance<ItemStack>... modifiersWithData) {
if (simulate && object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
List<ModifierInstance<ItemStack>> sim = getModifierInstances();
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
instance.setLevel(level);
}
});
return modified.recheck(object, sim);
}
if (object.getItem() instanceof IModified && ((IModified) object.getItem()).getType() == getType()) {
IModified<ItemStack> modified = (IModified<ItemStack>) object.getItem();
getModifierInstances().stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == getType()) {
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(level, object);
instance.setLevel(level);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
if (x < 0) {
modified.decreaseFreeModifiers(x);
}
}
});
return true;
}
return false;
}
@Override
public ListNBT serializeNBT() {
stack.getOrCreateTag().put(EssenceItemstackModifierHelpers.TAG_MODIFIERS, super.serializeNBT());
return super.serializeNBT();
}
@Override
public void deserializeNBT(ListNBT nbt) {
super.deserializeNBT(stack.getTag() != null ? stack.getTag().getList(EssenceItemstackModifierHelpers.TAG_MODIFIERS, Constants.NBT.TAG_COMPOUND) : new ListNBT());
}
}
Raw
ItemStackModifierProvider.java
package com.teamacronymcoders.essence.capabilities.itemstack;
import com.teamacronymcoders.essence.capabilities.EssenceCoreCapabilities;
import com.teamacronymcoders.essence.utils.helpers.EssenceItemstackModifierHelpers;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.nbt.ListNBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.ICapabilityProvider;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.util.Constants;
import net.minecraftforge.common.util.LazyOptional;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
public class ItemStackModifierProvider implements ICapabilityProvider, ICapabilitySerializable<ListNBT> {
private ItemStackModifierHolder modifierHolder;
private LazyOptional<ItemStackModifierHolder> optional = LazyOptional.of(() -> modifierHolder);
public ItemStackModifierProvider(ItemStack stack) {
modifierHolder = new ItemStackModifierHolder(stack);
}
public ItemStackModifierProvider(ItemStack stack, CompoundNBT nbt) {
modifierHolder = new ItemStackModifierHolder(stack);
modifierHolder.deserializeNBT(nbt.getList(EssenceItemstackModifierHelpers.TAG_MODIFIERS, Constants.NBT.TAG_COMPOUND));
modifierHolder.serializeNBT();
}
@Nonnull
@Override
public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
if (cap == EssenceCoreCapabilities.ITEMSTACK_MODIFIER_HOLDER) {
return optional.cast();
}
return LazyOptional.empty();
}
@Override
public ListNBT serializeNBT() {
return modifierHolder.serializeNBT();
}
@Override
public void deserializeNBT(ListNBT nbt) {
modifierHolder.deserializeNBT(nbt);
}
}
Raw
ModifierHolder.java
package com.teamacronymcoders.essence.api.holder;
import com.teamacronymcoders.essence.api.modified.IModified;
import com.teamacronymcoders.essence.api.modifier.core.Modifier;
import net.minecraft.nbt.CompoundNBT;
import net.minecraft.nbt.ListNBT;
import net.minecraftforge.common.util.INBTSerializable;
import javax.annotation.Nonnull;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public abstract class ModifierHolder<T> implements IModifierHolder<T>, INBTSerializable<ListNBT> {
private List<ModifierInstance<T>> modifiers;
private Class<T> type;
public ModifierHolder(Class<T> type) {
modifiers = new ArrayList<>();
this.type = type;
}
@Override
public boolean addModifierInstance(boolean simulate, T object, ModifierInstance<T>... instances) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = modifiers;
for (ModifierInstance<T> instance : instances) {
if (instance.getModifier().getType() == type) {
if (!sim.contains(instance)) {
sim.add(instance);
}
}
}
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
for (ModifierInstance<T> instance : instances) {
if (instance.getModifier().getType() == type) {
if (!modifiers.contains(instance)) {
modifiers.add(instance);
modified.decreaseFreeModifiers(instance.getModifier().getModifierCountValue(instance.getLevel(), object));
}
}
}
return true;
}
return false;
}
@Override
public boolean removeModifierInstance(boolean simulate, T object, ModifierInstance<T>... instances) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
Arrays.stream(instances).forEach(sim::remove);
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
int cmc = Arrays.stream(instances).map(instance -> modifiers.stream()
.filter(trueInstance -> trueInstance.getModifier().equals(instance.getModifier()) && trueInstance.getModifierData() == instance.getModifierData())
.map(trueInstance -> {
if (instance.getModifier().getType() == type) {
modifiers.remove(trueInstance);
return trueInstance.getModifier().getModifierCountValue(trueInstance.getLevel(), object);
}
return 0;
}).reduce(0, Integer::sum)).reduce(0, Integer::sum);
modified.addModifierWithoutIncreasingAdditional(cmc);
return true;
}
return false;
}
@Override
public boolean levelUpModifier(boolean simulate, T object, int increase, Modifier<T>... modifiers) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
Modifier<T> stackCoreModifier = instance.getModifier();
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
Modifier<T> stackCoreModifier = instance.getModifier();
int x = stackCoreModifier.getModifierCountValue(instance.getLevel(), object);
int y = stackCoreModifier.getModifierCountValue(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)), object);
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
if (x < y) {
modified.decreaseFreeModifiers(y - x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelUpModifier(boolean simulate, T object, int increase, ModifierInstance<T>... modifiersWithData) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
Modifier<T> stackCoreModifier = instance.getModifier();
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
Modifier<T> stackCoreModifier = instance.getModifier();
int x = stackCoreModifier.getModifierCountValue(instance.getLevel(), object);
int y = stackCoreModifier.getModifierCountValue(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)), object);
instance.setLevel(Math.min(instance.getLevel() + increase, stackCoreModifier.getMaxLevel(object)));
if (x < y) {
modified.decreaseFreeModifiers(y - x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelDownModifier(boolean simulate, T object, int decrease, Modifier<T>... modifiers) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
sim.remove(instance);
return;
}
instance.setLevel(instance.getLevel() - decrease);
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> modifier == instance.getModifier()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
removeModifierInstance(false, object, instance);
return;
}
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(instance.getLevel() - decrease, object);
instance.setLevel(instance.getLevel() - decrease);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelDownModifier(boolean simulate, T object, int decrease, ModifierInstance<T>... modifiersWithData) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
sim.remove(instance);
return;
}
instance.setLevel(instance.getLevel() - decrease);
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int level = instance.getLevel();
if (level - decrease < instance.getModifier().getMinLevel(object)) {
removeModifierInstance(false, object, instance);
return;
}
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(instance.getLevel() - decrease, object);
instance.setLevel(instance.getLevel() - decrease);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelSetModifier(boolean simulate, T object, int level, Modifier<T>... modifiers) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
instance.setLevel(level);
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiers).anyMatch(modifier -> instance.getModifier() == modifier))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(level, object);
instance.setLevel(level);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
if (x < 0) {
modified.decreaseFreeModifiers(x);
}
}
});
return true;
}
return false;
}
@Override
public boolean levelSetModifier(boolean simulate, T object, int level, ModifierInstance<T>... modifiersWithData) {
if (simulate && object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
List<ModifierInstance<T>> sim = this.modifiers;
sim.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
instance.setLevel(level);
}
});
return modified.recheck(object, sim);
}
if (object instanceof IModified && ((IModified) object).getType() == type) {
IModified<T> modified = (IModified<T>) object;
this.modifiers.stream()
.filter(instance -> Arrays.stream(modifiersWithData).anyMatch(modifier -> instance.getModifier() == modifier.getModifier() && instance.getModifierData() == modifier.getModifierData()))
.forEach(instance -> {
if (instance.getModifier().getType() == type) {
int x = instance.getModifier().getModifierCountValue(instance.getLevel(), object) - instance.getModifier().getModifierCountValue(level, object);
instance.setLevel(level);
if (x > 0) {
modified.addModifierWithoutIncreasingAdditional(x);
}
if (x < 0) {
modified.decreaseFreeModifiers(x);
}
}
});
return true;
}
return false;
}
@Nonnull
@Override
public List<ModifierInstance<T>> getModifierInstances() {
return modifiers;
}
@Override
public void clearModifiers() {
modifiers.clear();
}
public Class<T> getType() {
return type;
}
@Override
public ListNBT serializeNBT() {
final ListNBT listNBT = new ListNBT();
for (ModifierInstance<T> instance : modifiers) {
listNBT.add(instance.serializeNBT());
}
return listNBT;
}
@Override
public void deserializeNBT(ListNBT nbt) {
for (int i = 0; i < nbt.size(); i++) {
final CompoundNBT compoundNBT = nbt.getCompound(i);
final ModifierInstance<T> instance = new ModifierInstance<>(type);
instance.deserializeNBT(compoundNBT);
if (this.modifiers.stream().noneMatch(tracked -> tracked == instance)) {
this.modifiers.add(instance);
}
}
}
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment