lauchmelder/BloodMagic
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

Reworked Tartaric Gems so that they contain specific demon will types (work for the future)

Browse source
This commit is contained in:
WayofTime 2016-02-18 18:00:02 -05:00
parent e681085d8b
commit 035ba94976
11 changed files with 142 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
src/main/java/WayofTime/bloodmagic/api/Constants.java
View file

@ -90,6 +90,7 @@ public class Constants
public static final String SOUL_SWORD_ACTIVE_DRAIN = "soulSwordActiveDrain";
public static final String SOUL_SWORD_DROP = "soulSwordDrop";
public static final String SOUL_SWORD_STATIC_DROP = "soulSwordStaticDrop";
public static final String WILL_TYPE = "demonWillType";
public static final String SOUL_FORGE_BURN = "burnTime";
public static final String SOUL_FORGE_CONSUMED = "consumedSouls";

10
src/main/java/WayofTime/bloodmagic/api/soul/IDemonWillGem.java
View file

@ -19,14 +19,12 @@ public interface IDemonWillGem
* Returns the number of souls that are left in the soul gem. Returns a
* double because souls can be fractionally drained.
*
* @param willGemStack
* @return
*/
public double getWill(ItemStack willGemStack);
public double getWill(EnumDemonWillType type, ItemStack willGemStack);
public void setWill(ItemStack willGemStack, double amount);
public void setWill(EnumDemonWillType type, ItemStack willGemStack, double amount);
public int getMaxWill(ItemStack willGemStack);
public int getMaxWill(EnumDemonWillType type, ItemStack willGemStack);
public double drainWill(ItemStack stack, double drainAmount);
public double drainWill(EnumDemonWillType type, ItemStack stack, double drainAmount);
}

28
src/main/java/WayofTime/bloodmagic/api/soul/PlayerDemonWillHandler.java
View file

@ -14,7 +14,7 @@ import net.minecraft.item.ItemStack;
*/
public class PlayerDemonWillHandler
{
public static double getTotalDemonWill(EntityPlayer player)
public static double getTotalDemonWill(EnumDemonWillType type, EntityPlayer player)
{
ItemStack[] inventory = player.inventory.mainInventory;
double souls = 0;
@ -29,7 +29,7 @@ public class PlayerDemonWillHandler
souls += ((IDemonWill) stack.getItem()).getWill(stack);
} else if (stack.getItem() instanceof IDemonWillGem)
{
souls += ((IDemonWillGem) stack.getItem()).getWill(stack);
souls += ((IDemonWillGem) stack.getItem()).getWill(type, stack);
}
}
}
@ -42,7 +42,7 @@ public class PlayerDemonWillHandler
* return true.
*
*/
public static boolean isDemonWillFull(EntityPlayer player)
public static boolean isDemonWillFull(EnumDemonWillType type, EntityPlayer player)
{
ItemStack[] inventory = player.inventory.mainInventory;
@ -55,7 +55,7 @@ public class PlayerDemonWillHandler
if (stack.getItem() instanceof IDemonWillGem)
{
hasGem = true;
if (((IDemonWillGem) stack.getItem()).getWill(stack) < ((IDemonWillGem) stack.getItem()).getMaxWill(stack))
if (((IDemonWillGem) stack.getItem()).getWill(type, stack) < ((IDemonWillGem) stack.getItem()).getMaxWill(type, stack))
{
return false;
}
@ -72,7 +72,7 @@ public class PlayerDemonWillHandler
* @param amount
* @return - amount consumed
*/
public static double consumeDemonWill(EntityPlayer player, double amount)
public static double consumeDemonWill(EnumDemonWillType type, EntityPlayer player, double amount)
{
double consumed = 0;
@ -97,7 +97,7 @@ public class PlayerDemonWillHandler
}
} else if (stack.getItem() instanceof IDemonWillGem)
{
consumed += ((IDemonWillGem) stack.getItem()).drainWill(stack, amount - consumed);
consumed += ((IDemonWillGem) stack.getItem()).drainWill(type, stack, amount - consumed);
}
}
}
@ -142,7 +142,7 @@ public class PlayerDemonWillHandler
return soulStack;
}
public static double addDemonWill(EntityPlayer player, double amount)
public static double addDemonWill(EnumDemonWillType type, EntityPlayer player, double amount)
{
ItemStack[] inventory = player.inventory.mainInventory;
double remaining = amount;
@ -154,9 +154,9 @@ public class PlayerDemonWillHandler
{
if (stack.getItem() instanceof IDemonWillGem)
{
double souls = ((IDemonWillGem) stack.getItem()).getWill(stack);
double fill = Math.min(((IDemonWillGem) stack.getItem()).getMaxWill(stack) - souls, remaining);
((IDemonWillGem) stack.getItem()).setWill(stack, fill + souls);
double souls = ((IDemonWillGem) stack.getItem()).getWill(type, stack);
double fill = Math.min(((IDemonWillGem) stack.getItem()).getMaxWill(type, stack) - souls, remaining);
((IDemonWillGem) stack.getItem()).setWill(type, stack, fill + souls);
remaining -= fill;
if (remaining <= 0)
@ -170,7 +170,7 @@ public class PlayerDemonWillHandler
return amount - remaining;
}
public static double addDemonWill(EntityPlayer player, double amount, ItemStack ignored)
public static double addDemonWill(EnumDemonWillType type, EntityPlayer player, double amount, ItemStack ignored)
{
ItemStack[] inventory = player.inventory.mainInventory;
double remaining = amount;
@ -182,9 +182,9 @@ public class PlayerDemonWillHandler
{
if (stack.getItem() instanceof IDemonWillGem)
{
double souls = ((IDemonWillGem) stack.getItem()).getWill(stack);
double fill = Math.min(((IDemonWillGem) stack.getItem()).getMaxWill(stack) - souls, remaining);
((IDemonWillGem) stack.getItem()).setWill(stack, fill + souls);
double souls = ((IDemonWillGem) stack.getItem()).getWill(type, stack);
double fill = Math.min(((IDemonWillGem) stack.getItem()).getMaxWill(type, stack) - souls, remaining);
((IDemonWillGem) stack.getItem()).setWill(type, stack, fill + souls);
remaining -= fill;
if (remaining <= 0)

3
src/main/java/WayofTime/bloodmagic/entity/projectile/EntitySentientArrow.java
View file

@ -5,6 +5,7 @@ import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.projectile.EntityArrow;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
public class EntitySentientArrow extends EntityArrow
@ -37,7 +38,7 @@ public class EntitySentientArrow extends EntityArrow
{
if (this.shootingEntity instanceof EntityPlayer)
{
PlayerDemonWillHandler.addDemonWill((EntityPlayer) this.shootingEntity, reimbursedAmountOnHit);
PlayerDemonWillHandler.addDemonWill(EnumDemonWillType.DEFAULT, (EntityPlayer) this.shootingEntity, reimbursedAmountOnHit);
}
}

12
src/main/java/WayofTime/bloodmagic/item/armour/ItemSentientArmour.java
View file

@ -17,6 +17,7 @@ import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.Constants;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
import WayofTime.bloodmagic.api.util.helper.NBTHelper;
import WayofTime.bloodmagic.registry.ModItems;
@ -33,6 +34,11 @@ public class ItemSentientArmour extends ItemArmor implements ISpecialArmor
setCreativeTab(BloodMagic.tabBloodMagic);
}
public EnumDemonWillType getDemonWillTypeConsumed(ItemStack stack)
{
return EnumDemonWillType.DEFAULT;
}
@Override
public ArmorProperties getProperties(EntityLivingBase player, ItemStack stack, DamageSource source, double damage, int slot)
{
@ -140,11 +146,13 @@ public class ItemSentientArmour extends ItemArmor implements ISpecialArmor
{
EntityPlayer player = (EntityPlayer) entity;
EnumDemonWillType type = getDemonWillTypeConsumed(stack);
double willRequired = this.getCostModifier(stack) * damage;
double willLeft = PlayerDemonWillHandler.getTotalDemonWill(player);
double willLeft = PlayerDemonWillHandler.getTotalDemonWill(type, player);
if (willLeft >= willRequired)
{
PlayerDemonWillHandler.consumeDemonWill(player, willRequired);
PlayerDemonWillHandler.consumeDemonWill(type, player, willRequired);
} else
{
this.revertArmour(player, stack);

8
src/main/java/WayofTime/bloodmagic/item/soul/ItemSentientArmourGem.java
View file

@ -9,6 +9,7 @@ import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.Constants;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
import WayofTime.bloodmagic.item.armour.ItemSentientArmour;
@ -28,6 +29,11 @@ public class ItemSentientArmourGem extends Item
setMaxStackSize(1);
}
public EnumDemonWillType getCurrentType(ItemStack stack)
{
return EnumDemonWillType.DEFAULT;
}
@Override
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
{
@ -46,7 +52,7 @@ public class ItemSentientArmourGem extends Item
ItemSentientArmour.revertAllArmour(player);
} else
{
double will = PlayerDemonWillHandler.getTotalDemonWill(player);
double will = PlayerDemonWillHandler.getTotalDemonWill(getCurrentType(stack), player);
int bracket = getWillBracket(will);

15
src/main/java/WayofTime/bloodmagic/item/soul/ItemSentientSword.java
View file

@ -4,7 +4,6 @@ import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import WayofTime.bloodmagic.api.iface.IActivatable;
import net.minecraft.entity.Entity;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.SharedMonsterAttributes;
@ -19,6 +18,8 @@ import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.Constants;
import WayofTime.bloodmagic.api.iface.IActivatable;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.IDemonWill;
import WayofTime.bloodmagic.api.soul.IDemonWillWeapon;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
@ -46,6 +47,11 @@ public class ItemSentientSword extends ItemSword implements IDemonWillWeapon, IA
setCreativeTab(BloodMagic.tabBloodMagic);
}
public EnumDemonWillType getCurrentType(ItemStack stack)
{
return EnumDemonWillType.DEFAULT;
}
@Override
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
{
@ -54,7 +60,7 @@ public class ItemSentientSword extends ItemSword implements IDemonWillWeapon, IA
if (getActivated(stack))
{
double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(player);
double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(getCurrentType(stack), player);
int level = getLevel(stack, soulsRemaining);
double drain = level >= 0 ? soulDrainPerSwing[level] : 0;
@ -119,7 +125,8 @@ public class ItemSentientSword extends ItemSword implements IDemonWillWeapon, IA
double drain = this.getDrainOfActivatedSword(stack);
if (drain > 0)
{
double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(player);
EnumDemonWillType type = getCurrentType(stack);
double soulsRemaining = PlayerDemonWillHandler.getTotalDemonWill(type, player);
if (drain > soulsRemaining)
{
@ -127,7 +134,7 @@ public class ItemSentientSword extends ItemSword implements IDemonWillWeapon, IA
return false;
} else
{
PlayerDemonWillHandler.consumeDemonWill(player, drain);
PlayerDemonWillHandler.consumeDemonWill(type, player, drain);
}
}
}

77
src/main/java/WayofTime/bloodmagic/item/soul/ItemSoulGem.java
View file

@ -12,6 +12,7 @@ import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import WayofTime.bloodmagic.BloodMagic;
import WayofTime.bloodmagic.api.Constants;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.IDemonWill;
import WayofTime.bloodmagic.api.soul.IDemonWillGem;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
@ -42,10 +43,11 @@ public class ItemSoulGem extends Item implements IDemonWillGem
@Override
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
{
double drain = Math.min(this.getWill(stack), this.getMaxWill(stack) / 10);
EnumDemonWillType type = this.getCurrentType(stack);
double drain = Math.min(this.getWill(type, stack), this.getMaxWill(type, stack) / 10);
double filled = PlayerDemonWillHandler.addDemonWill(player, drain, stack);
this.drainWill(stack, filled);
double filled = PlayerDemonWillHandler.addDemonWill(type, player, drain, stack);
this.drainWill(type, stack, filled);
return stack;
}
@ -58,7 +60,7 @@ public class ItemSoulGem extends Item implements IDemonWillGem
{
ItemStack emptyStack = new ItemStack(this, 1, i);
ItemStack fullStack = new ItemStack(this, 1, i);
setWill(fullStack, getMaxWill(fullStack));
setWill(EnumDemonWillType.DEFAULT, fullStack, getMaxWill(EnumDemonWillType.DEFAULT, fullStack));
list.add(emptyStack);
list.add(fullStack);
}
@ -68,8 +70,9 @@ public class ItemSoulGem extends Item implements IDemonWillGem
@SideOnly(Side.CLIENT)
public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean advanced)
{
EnumDemonWillType type = this.getCurrentType(stack);
tooltip.add(TextHelper.localize("tooltip.BloodMagic.soulGem." + names[stack.getItemDamage()]));
tooltip.add(TextHelper.localize("tooltip.BloodMagic.will", getWill(stack)));
tooltip.add(TextHelper.localize("tooltip.BloodMagic.will", getWill(type, stack)));
super.addInformation(stack, player, tooltip, advanced);
}
@ -83,7 +86,13 @@ public class ItemSoulGem extends Item implements IDemonWillGem
@Override
public double getDurabilityForDisplay(ItemStack stack)
{
return 1.0 - (getWill(stack) / (double) getMaxWill(stack));
EnumDemonWillType type = this.getCurrentType(stack);
double maxWill = getMaxWill(type, stack);
if (maxWill <= 0)
{
return 1;
}
return 1.0 - (getWill(type, stack) / maxWill);
}
@Override
@ -91,15 +100,16 @@ public class ItemSoulGem extends Item implements IDemonWillGem
{
if (soulStack != null && soulStack.getItem() instanceof IDemonWill)
{
EnumDemonWillType thisType = this.getCurrentType(soulGemStack);
IDemonWill soul = (IDemonWill) soulStack.getItem();
double soulsLeft = getWill(soulGemStack);
double soulsLeft = getWill(thisType, soulGemStack);
if (soulsLeft < getMaxWill(soulGemStack))
if (soulsLeft < getMaxWill(thisType, soulGemStack))
{
double newSoulsLeft = Math.min(soulsLeft + soul.getWill(soulStack), getMaxWill(soulGemStack));
double newSoulsLeft = Math.min(soulsLeft + soul.getWill(soulStack), getMaxWill(thisType, soulGemStack));
soul.drainWill(soulStack, newSoulsLeft - soulsLeft);
setWill(soulGemStack, newSoulsLeft);
setWill(thisType, soulGemStack, newSoulsLeft);
if (soul.getWill(soulStack) <= 0)
{
return null;
@ -111,9 +121,12 @@ public class ItemSoulGem extends Item implements IDemonWillGem
}
@Override
public double getWill(ItemStack soulGemStack)
public double getWill(EnumDemonWillType type, ItemStack soulGemStack)
{
NBTHelper.checkNBT(soulGemStack);
if (!type.equals(getCurrentType(soulGemStack)))
{
return 0;
}
NBTTagCompound tag = soulGemStack.getTagCompound();
@ -121,9 +134,9 @@ public class ItemSoulGem extends Item implements IDemonWillGem
}
@Override
public void setWill(ItemStack soulGemStack, double souls)
public void setWill(EnumDemonWillType type, ItemStack soulGemStack, double souls)
{
NBTHelper.checkNBT(soulGemStack);
setCurrentType(type, soulGemStack);
NBTTagCompound tag = soulGemStack.getTagCompound();
@ -131,19 +144,24 @@ public class ItemSoulGem extends Item implements IDemonWillGem
}
@Override
public double drainWill(ItemStack soulGemStack, double drainAmount)
public double drainWill(EnumDemonWillType type, ItemStack soulGemStack, double drainAmount)
{
double souls = getWill(soulGemStack);
double souls = getWill(type, soulGemStack);
double soulsDrained = Math.min(drainAmount, souls);
setWill(soulGemStack, souls - soulsDrained);
setWill(type, soulGemStack, souls - soulsDrained);
return soulsDrained;
}
@Override
public int getMaxWill(ItemStack soulGemStack)
public int getMaxWill(EnumDemonWillType type, ItemStack soulGemStack)
{
if (!type.equals(getCurrentType(soulGemStack)))
{
return 0;
}
switch (soulGemStack.getMetadata())
{
case 0:
@ -159,4 +177,27 @@ public class ItemSoulGem extends Item implements IDemonWillGem
}
return 64;
}
public EnumDemonWillType getCurrentType(ItemStack soulGemStack)
{
NBTHelper.checkNBT(soulGemStack);
NBTTagCompound tag = soulGemStack.getTagCompound();
if (!tag.hasKey(tag.getString(Constants.NBT.WILL_TYPE)))
{
return EnumDemonWillType.DEFAULT;
}
return EnumDemonWillType.valueOf(tag.getString(Constants.NBT.WILL_TYPE));
}
public void setCurrentType(EnumDemonWillType type, ItemStack soulGemStack)
{
NBTHelper.checkNBT(soulGemStack);
NBTTagCompound tag = soulGemStack.getTagCompound();
tag.setString(Constants.NBT.WILL_TYPE, type.toString());
}
}

45
src/main/java/WayofTime/bloodmagic/tile/TileDemonCrucible.java
View file

@ -63,9 +63,6 @@ public class TileDemonCrucible extends TileInventory implements ITickable, IDemo
conduitList.add(newPos.subtract(getPos()));
}
}
System.out.println("List size: " + conduitList.size());
System.out.println("Current amount: " + getCurrentWill(EnumDemonWillType.DEFAULT));
}
internalCounter++;
@ -79,19 +76,22 @@ public class TileDemonCrucible extends TileInventory implements ITickable, IDemo
if (stack.getItem() instanceof IDemonWillGem)
{
IDemonWillGem gemItem = (IDemonWillGem) stack.getItem();
if (willMap.containsKey(EnumDemonWillType.DEFAULT))
for (EnumDemonWillType type : EnumDemonWillType.values())
{
double current = willMap.get(EnumDemonWillType.DEFAULT);
double fillAmount = Math.min(gemDrainRate, Math.min(current, gemItem.getMaxWill(stack) - gemItem.getWill(stack)));
if (fillAmount > 0)
if (willMap.containsKey(type))
{
gemItem.setWill(stack, fillAmount + gemItem.getWill(stack));
if (willMap.get(EnumDemonWillType.DEFAULT) - fillAmount <= 0)
double current = willMap.get(type);
double fillAmount = Math.min(gemDrainRate, Math.min(current, gemItem.getMaxWill(type, stack) - gemItem.getWill(type, stack)));
if (fillAmount > 0)
{
willMap.remove(EnumDemonWillType.DEFAULT);
} else
{
willMap.put(EnumDemonWillType.DEFAULT, willMap.get(EnumDemonWillType.DEFAULT) - fillAmount);
gemItem.setWill(type, stack, fillAmount + gemItem.getWill(type, stack));
if (willMap.get(type) - fillAmount <= 0)
{
willMap.remove(type);
} else
{
willMap.put(type, willMap.get(type) - fillAmount);
}
}
}
}
@ -105,16 +105,19 @@ public class TileDemonCrucible extends TileInventory implements ITickable, IDemo
if (stack.getItem() instanceof IDemonWillGem)
{
IDemonWillGem gemItem = (IDemonWillGem) stack.getItem();
if (!willMap.containsKey(EnumDemonWillType.DEFAULT))
for (EnumDemonWillType type : EnumDemonWillType.values())
{
willMap.put(EnumDemonWillType.DEFAULT, 0d);
}
if (!willMap.containsKey(type))
{
willMap.put(type, 0d);
}
if (willMap.get(EnumDemonWillType.DEFAULT) < maxWill)
{
double drainAmount = Math.min(maxWill - willMap.get(EnumDemonWillType.DEFAULT), gemDrainRate);
double drained = gemItem.drainWill(stack, drainAmount);
willMap.put(EnumDemonWillType.DEFAULT, willMap.get(EnumDemonWillType.DEFAULT) + drained);
if (willMap.get(type) < maxWill)
{
double drainAmount = Math.min(maxWill - willMap.get(type), gemDrainRate);
double drained = gemItem.drainWill(type, stack, drainAmount);
willMap.put(type, willMap.get(type) + drained);
}
}
}
}

16
src/main/java/WayofTime/bloodmagic/tile/TileSoulForge.java
View file

@ -174,7 +174,7 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
if (soulStack.getItem() instanceof IDemonWillGem)
{
IDemonWillGem soul = (IDemonWillGem) soulStack.getItem();
return soul.getWill(soulStack);
return soul.getWill(EnumDemonWillType.DEFAULT, soulStack);
}
}
@ -201,7 +201,7 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
if (soulStack.getItem() instanceof IDemonWillGem)
{
IDemonWillGem soul = (IDemonWillGem) soulStack.getItem();
return soul.drainWill(soulStack, requested);
return soul.drainWill(EnumDemonWillType.DEFAULT, soulStack, requested);
}
}
@ -258,8 +258,8 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
IDemonWillGem willGem = (IDemonWillGem) stack.getItem();
double maxWill = willGem.getMaxWill(stack);
double current = willGem.getWill(stack);
double maxWill = willGem.getMaxWill(type, stack);
double current = willGem.getWill(type, stack);
if (!doFill)
{
@ -270,11 +270,11 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
if (amount < filled)
{
willGem.setWill(stack, current + amount);
willGem.setWill(type, stack, current + amount);
filled = amount;
} else
{
willGem.setWill(stack, maxWill);
willGem.setWill(type, stack, maxWill);
}
return filled;
@ -292,7 +292,7 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
IDemonWillGem willGem = (IDemonWillGem) stack.getItem();
double drained = amount;
double current = willGem.getWill(stack);
double current = willGem.getWill(type, stack);
if (current < drained)
{
drained = current;
@ -300,7 +300,7 @@ public class TileSoulForge extends TileInventory implements ITickable, IDemonWil
if (doDrain)
{
drained = willGem.drainWill(stack, drained);
drained = willGem.drainWill(type, stack, drained);
}
return drained;

3
src/main/java/WayofTime/bloodmagic/util/handler/EventHandler.java
View file

@ -47,6 +47,7 @@ import WayofTime.bloodmagic.api.event.TeleposeEvent;
import WayofTime.bloodmagic.api.iface.IBindable;
import WayofTime.bloodmagic.api.iface.IUpgradeTrainer;
import WayofTime.bloodmagic.api.livingArmour.LivingArmourUpgrade;
import WayofTime.bloodmagic.api.soul.EnumDemonWillType;
import WayofTime.bloodmagic.api.soul.IDemonWill;
import WayofTime.bloodmagic.api.soul.IDemonWillWeapon;
import WayofTime.bloodmagic.api.soul.PlayerDemonWillHandler;
@ -623,7 +624,7 @@ public class EventHandler
ItemStack remainder = PlayerDemonWillHandler.addDemonWill(player, stack);
if (remainder == null || ((IDemonWill) stack.getItem()).getWill(stack) < 0.0001 || PlayerDemonWillHandler.isDemonWillFull(player))
if (remainder == null || ((IDemonWill) stack.getItem()).getWill(stack) < 0.0001 || PlayerDemonWillHandler.isDemonWillFull(EnumDemonWillType.DEFAULT, player))
{
stack.stackSize = 0;
event.setResult(Result.ALLOW);