diff --git a/src/main/java/WayofTime/bloodmagic/BloodMagic.java b/src/main/java/WayofTime/bloodmagic/BloodMagic.java index 775618d7..7cfb6c96 100644 --- a/src/main/java/WayofTime/bloodmagic/BloodMagic.java +++ b/src/main/java/WayofTime/bloodmagic/BloodMagic.java @@ -68,6 +68,7 @@ public class BloodMagic { public void init(FMLInitializationEvent event) { AlchemicalWizardryPacketHandler.init(); + ModRecipes.init(); ModRituals.initRituals(); ModRituals.initImperfectRituals(); ConfigHandler.checkRituals(); diff --git a/src/main/java/WayofTime/bloodmagic/api/NBTHolder.java b/src/main/java/WayofTime/bloodmagic/api/NBTHolder.java index 206073ae..1c28f994 100644 --- a/src/main/java/WayofTime/bloodmagic/api/NBTHolder.java +++ b/src/main/java/WayofTime/bloodmagic/api/NBTHolder.java @@ -19,6 +19,7 @@ public class NBTHolder { public static final String NBT_RUNNING = "isRunning"; public static final String NBT_RUNTIME = "runtime"; public static final String NBT_REAGENTTANK = "reagentTanks"; + public static final String NBT_CURRENT_INCENSE = "BM:CurrentIncense"; public static final String NBT_ALTAR_TIER = "upgradeLevel"; public static final String NBT_ALTAR_ACTIVE = "isActive"; public static final String NBT_ALTAR_LIQUID_REQ = "liquidRequired"; diff --git a/src/main/java/WayofTime/bloodmagic/api/event/SacrificeKnifeUsedEvent.java b/src/main/java/WayofTime/bloodmagic/api/event/SacrificeKnifeUsedEvent.java new file mode 100644 index 00000000..de31e70a --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/api/event/SacrificeKnifeUsedEvent.java @@ -0,0 +1,20 @@ +package WayofTime.bloodmagic.api.event; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraftforge.fml.common.eventhandler.Cancelable; +import net.minecraftforge.fml.common.eventhandler.Event; + +@Cancelable +public class SacrificeKnifeUsedEvent extends Event { + public final EntityPlayer player; + public boolean shouldDrainHealth; + public boolean shouldFillAltar; + public final int healthDrained; + + public SacrificeKnifeUsedEvent(EntityPlayer player, boolean shouldDrainHealth, boolean shouldFillAltar, int hp) { + this.player = player; + this.shouldDrainHealth = shouldDrainHealth; + this.shouldFillAltar = shouldFillAltar; + this.healthDrained = hp; + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/api/util/helper/IncenseHelper.java b/src/main/java/WayofTime/bloodmagic/api/util/helper/IncenseHelper.java new file mode 100644 index 00000000..ed632aa8 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/api/util/helper/IncenseHelper.java @@ -0,0 +1,21 @@ +package WayofTime.bloodmagic.api.util.helper; + +import WayofTime.bloodmagic.api.NBTHolder; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; + +public class IncenseHelper { + public static float getCurrentIncense(EntityPlayer player) { + NBTTagCompound data = player.getEntityData(); + if (data.hasKey(NBTHolder.NBT_CURRENT_INCENSE)) { + return data.getFloat(NBTHolder.NBT_CURRENT_INCENSE); + } + + return 0; + } + + public static void setCurrentIncense(EntityPlayer player, float amount) { + NBTTagCompound data = player.getEntityData(); + data.setFloat(NBTHolder.NBT_CURRENT_INCENSE, amount); + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/api/util/helper/PlayerSacrificeHelper.java b/src/main/java/WayofTime/bloodmagic/api/util/helper/PlayerSacrificeHelper.java new file mode 100644 index 00000000..3bcdadb9 --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/api/util/helper/PlayerSacrificeHelper.java @@ -0,0 +1,102 @@ +package WayofTime.bloodmagic.api.util.helper; + +import WayofTime.bloodmagic.api.altar.IBloodAltar; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockPos; +import net.minecraft.world.World; + +public class PlayerSacrificeHelper { + public static float scalingOfSacrifice = 0.001f; + public static int soulFrayDuration = 400; + public static Potion soulFrayId; + + public static float getPlayerIncense(EntityPlayer player) { + return IncenseHelper.getCurrentIncense(player); + } + + public static void setPlayerIncense(EntityPlayer player, float amount) { + IncenseHelper.setCurrentIncense(player, amount); + } + + public static boolean incrementIncense(EntityPlayer player, float min, float max, float increment) { + float amount = getPlayerIncense(player); + if (amount < min || amount >= max) { + return false; + } + + amount = amount + Math.min(increment, max - amount); + setPlayerIncense(player, amount); + +// System.out.println("Amount of incense: " + amount + ", Increment: " + increment); + + return true; + } + + public static boolean sacrificePlayerHealth(EntityPlayer player) { + if (player.isPotionActive(soulFrayId)) { + return false; + } + + float amount = getPlayerIncense(player); + + if (amount >= 0) { + float health = player.getHealth(); + float maxHealth = player.getMaxHealth(); + + if (health > maxHealth / 10.0) { + float sacrificedHealth = health - maxHealth / 10.0f; + + if (findAndFillAltar(player.getEntityWorld(), player, (int) (sacrificedHealth * 100f * getModifier(amount)))) { + player.setHealth(maxHealth / 10.0f); + setPlayerIncense(player, 0); + player.addPotionEffect(new PotionEffect(soulFrayId.id, soulFrayDuration)); + + return true; + } + } + } + + return false; + } + + public static float getModifier(float amount) { + return 1 + amount * scalingOfSacrifice; + } + + public static boolean findAndFillAltar(World world, EntityPlayer player, int amount) { + int posX = (int) Math.round(player.posX - 0.5f); + int posY = (int) player.posY; + int posZ = (int) Math.round(player.posZ - 0.5f); + IBloodAltar altarEntity = getAltar(world, new BlockPos(posX, posY, posZ)); + + if (altarEntity == null) { + return false; + } + + altarEntity.sacrificialDaggerCall(amount, false); + altarEntity.startCycle(); + + return true; + } + + public static IBloodAltar getAltar(World world, BlockPos blockPos) { + TileEntity tileEntity; + + for (int i = -2; i <= 2; i++) { + for (int j = -2; j <= 2; j++) { + for (int k = -2; k <= 1; k++) { + tileEntity = world.getTileEntity(new BlockPos(i + blockPos.getX(), k + blockPos.getY(), j + blockPos.getZ())); + + if (tileEntity instanceof IBloodAltar) { + return (IBloodAltar) tileEntity; + } + } + } + } + + return null; + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/item/ItemSacrificialDagger.java b/src/main/java/WayofTime/bloodmagic/item/ItemSacrificialDagger.java index 679ec1ee..095504a6 100644 --- a/src/main/java/WayofTime/bloodmagic/item/ItemSacrificialDagger.java +++ b/src/main/java/WayofTime/bloodmagic/item/ItemSacrificialDagger.java @@ -1,6 +1,223 @@ package WayofTime.bloodmagic.item; -public class ItemSacrificialDagger -{ - -} +import WayofTime.bloodmagic.BloodMagic; +import WayofTime.bloodmagic.api.DamageSourceBloodMagic; +import WayofTime.bloodmagic.api.altar.IBloodAltar; +import WayofTime.bloodmagic.api.event.SacrificeKnifeUsedEvent; +import WayofTime.bloodmagic.api.util.helper.PlayerHelper; +import WayofTime.bloodmagic.api.util.helper.PlayerSacrificeHelper; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.EnumAction; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumParticleTypes; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import java.util.List; + +public class ItemSacrificialDagger extends Item { + public static String[] names = {"normal", "creative"}; + + public ItemSacrificialDagger() { + super(); + + setUnlocalizedName(BloodMagic.MODID + ".sacrificialDagger."); + setCreativeTab(BloodMagic.tabBloodMagic); + setHasSubtypes(true); + setMaxStackSize(1); + setFull3D(); + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName(stack) + names[stack.getItemDamage()]; + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings("unchecked") + public void getSubItems(Item id, CreativeTabs creativeTab, List list) { + for (int i = 0; i < names.length; i++) + list.add(new ItemStack(id, 1, i)); + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) { +// if (AlchemicalWizardry.wimpySettings) + { +// par3List.add(StatCollector.translateToLocal("tooltip.sacrificialdagger.desc1")); + } +// else + { + par3List.add(StatCollector.translateToLocal("tooltip.sacrificialdagger.desc2")); + par3List.add(StatCollector.translateToLocal("tooltip.sacrificialdagger.desc3")); + } + } + + /** + * called when the player releases the use item button. Args: itemstack, world, entityplayer, itemInUseCount + */ + @Override + public void onPlayerStoppedUsing(ItemStack stack, World world, EntityPlayer player, int itemInUseCount) { +// if(itemInUseCount < 32) +// { +// return; +// } + + PlayerSacrificeHelper.sacrificePlayerHealth(player); + } + + @Override + public int getMaxItemUseDuration(ItemStack stack) { + return 72000; + } + + /** + * returns the action that specifies what animation to play when the items is being used + */ + @Override + public EnumAction getItemUseAction(ItemStack stack) { + return EnumAction.BOW; + } + + @Override + public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) { + if (this.canUseForSacrifice(stack)) { + player.setItemInUse(stack, this.getMaxItemUseDuration(stack)); + return stack; + } + + if (!player.capabilities.isCreativeMode) { + SacrificeKnifeUsedEvent evt = new SacrificeKnifeUsedEvent(player, true, true, 2); + if (MinecraftForge.EVENT_BUS.post(evt)) { + return stack; + } + + if (evt.shouldDrainHealth) { + player.setHealth(player.getHealth() - 2); + } + + if (!evt.shouldFillAltar) { + return stack; + } + } + + if (PlayerHelper.isFakePlayer(player)) { + return stack; + } + + double posX = player.posX; + double posY = player.posY; + double posZ = player.posZ; + world.playSoundEffect((double) ((float) posX + 0.5F), (double) ((float) posY + 0.5F), (double) ((float) posZ + 0.5F), "random.fizz", 0.5F, 2.6F + (world.rand.nextFloat() - world.rand.nextFloat()) * 0.8F); + float f = 1.0F; + float f1 = f * 0.6F + 0.4F; + float f2 = f * f * 0.7F - 0.5F; + float f3 = f * f * 0.6F - 0.7F; + + for (int l = 0; l < 8; ++l) { + world.spawnParticle(EnumParticleTypes.REDSTONE, posX + Math.random() - Math.random(), posY + Math.random() - Math.random(), posZ + Math.random() - Math.random(), f1, f2, f3); + } + + if (!world.isRemote && PlayerHelper.isFakePlayer(player)) { + return stack; + } + +// if (player.isPotionActive(AlchemicalWizardry.customPotionSoulFray)) + { +// findAndFillAltar(world, player, 20); + } +// else + { + findAndFillAltar(world, player, 200); + } + + if (player.getHealth() <= 0.001f) { + player.onDeath(new DamageSourceBloodMagic()); + } + + return stack; + } + + public void findAndFillAltar(World world, EntityPlayer player, int amount) { + BlockPos pos = player.getPosition(); + IBloodAltar altarEntity = getAltar(world, pos); + + if (altarEntity == null) { + return; + } + + altarEntity.sacrificialDaggerCall(amount, false); + altarEntity.startCycle(); + } + + public IBloodAltar getAltar(World world, BlockPos pos) { + TileEntity tileEntity; + + for (int i = -2; i <= 2; i++) { + for (int j = -2; j <= 2; j++) { + for (int k = -2; k <= 1; k++) { + BlockPos newPos = pos.add(i, j, k); + tileEntity = world.getTileEntity(newPos); + + if (tileEntity instanceof IBloodAltar) { + return (IBloodAltar) tileEntity; + } + } + } + } + + return null; + } + + @Override + public void onUpdate(ItemStack stack, World world, Entity entity, int par4, boolean par5) { + if (!world.isRemote && entity instanceof EntityPlayer) { + this.setUseForSacrifice(stack, this.isPlayerPreparedForSacrifice(world, (EntityPlayer) entity)); + } + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { +// if (AlchemicalWizardry.wimpySettings) + { +// return "Sacrificial Orb"; + } + return super.getItemStackDisplayName(stack); + } + + public boolean isPlayerPreparedForSacrifice(World world, EntityPlayer player) { + return !world.isRemote && (PlayerSacrificeHelper.getPlayerIncense(player) > 0); + } + + public boolean canUseForSacrifice(ItemStack stack) { + NBTTagCompound tag = stack.getTagCompound(); + + return tag != null && tag.getBoolean("sacrifice"); + } + + public void setUseForSacrifice(ItemStack stack, boolean sacrifice) { + NBTTagCompound tag = stack.getTagCompound(); + if (tag == null) { + tag = new NBTTagCompound(); + stack.setTagCompound(tag); + } + + tag.setBoolean("sacrifice", sacrifice); + } + + @Override + @SideOnly(Side.CLIENT) + public boolean hasEffect(ItemStack stack) { + return this.canUseForSacrifice(stack) || super.hasEffect(stack); + } +} \ No newline at end of file diff --git a/src/main/java/WayofTime/bloodmagic/registry/ModItems.java b/src/main/java/WayofTime/bloodmagic/registry/ModItems.java index 648e34c8..db9c62b1 100644 --- a/src/main/java/WayofTime/bloodmagic/registry/ModItems.java +++ b/src/main/java/WayofTime/bloodmagic/registry/ModItems.java @@ -8,6 +8,7 @@ import WayofTime.bloodmagic.api.registry.OrbRegistry; import WayofTime.bloodmagic.item.ItemActivationCrystal; import WayofTime.bloodmagic.item.ItemBloodOrb; import WayofTime.bloodmagic.item.ItemBucketEssence; +import WayofTime.bloodmagic.item.ItemSacrificialDagger; import WayofTime.bloodmagic.item.sigil.ItemSigilAir; import WayofTime.bloodmagic.item.sigil.ItemSigilDivination; import WayofTime.bloodmagic.util.helper.InventoryRenderHelper; @@ -28,6 +29,8 @@ public class ModItems { public static Item activationCrystal; + public static Item sacrificialDagger; + public static Item sigilDivination; public static Item sigilAir; @@ -51,6 +54,8 @@ public class ModItems { activationCrystal = registerItem(new ItemActivationCrystal()); + sacrificialDagger = registerItem(new ItemSacrificialDagger()); + sigilDivination = registerItem(new ItemSigilDivination()); sigilAir = registerItem(new ItemSigilAir()); } @@ -72,6 +77,9 @@ public class ModItems { renderHelper.itemRender(activationCrystal, 1); renderHelper.itemRender(activationCrystal, 2, "ItemActivationCrystal0"); + renderHelper.itemRender(sacrificialDagger, 0); + renderHelper.itemRender(sacrificialDagger, 1); + renderHelper.itemRender(sigilDivination); renderHelper.itemRender(sigilAir); } diff --git a/src/main/java/WayofTime/bloodmagic/registry/ModRecipes.java b/src/main/java/WayofTime/bloodmagic/registry/ModRecipes.java new file mode 100644 index 00000000..3690477c --- /dev/null +++ b/src/main/java/WayofTime/bloodmagic/registry/ModRecipes.java @@ -0,0 +1,22 @@ +package WayofTime.bloodmagic.registry; + +import WayofTime.bloodmagic.api.ItemStackWrapper; +import WayofTime.bloodmagic.api.altar.AltarRecipe; +import WayofTime.bloodmagic.api.altar.EnumAltarTier; +import WayofTime.bloodmagic.api.registry.AltarRecipeRegistry; +import net.minecraft.init.Items; + +public class ModRecipes { + public static void init() { + addAltarRecipes(); + } + + public static void addAltarRecipes() { + AltarRecipeRegistry.registerRecipe(new AltarRecipe(new ItemStackWrapper(ModItems.bloodOrb, 0), new ItemStackWrapper(Items.diamond), EnumAltarTier.ONE, 2000, 2, 1, false)); +// AltarRecipeRegistry.registerRecipe(new ItemStack(ModItems.bloodOrb, 1), new ItemStack(Items.emerald), 2, 5000, 5, 5, false); +// AltarRecipeRegistry.registerRecipe(new ItemStack(ModItems.bloodOrb, 2), new ItemStack(Blocks.gold_block), 3, 25000, 20, 20, false); +// AltarRecipeRegistry.registerRecipe(new ItemStack(ModItems.bloodOrb, 3), new ItemStack(ModItems.weakBloodShard), 4, 40000, 30, 50, false); +// AltarRecipeRegistry.registerRecipe(new ItemStack(ModItems.bloodOrb, 4), new ItemStack(ModItems.demonBloodShard), 5, 75000, 50, 100, false); +// AltarRecipeRegistry.registerRecipe(new ItemStack(ModItems.bloodOrb, 5), new ItemStack(ModBlocks.blockCrystal), 6, 200000, 100, 200, false); + } +} diff --git a/src/main/java/WayofTime/bloodmagic/tile/TileAltar.java b/src/main/java/WayofTime/bloodmagic/tile/TileAltar.java index 8c16f9ac..b1ee68d9 100644 --- a/src/main/java/WayofTime/bloodmagic/tile/TileAltar.java +++ b/src/main/java/WayofTime/bloodmagic/tile/TileAltar.java @@ -8,7 +8,9 @@ import WayofTime.bloodmagic.api.altar.AltarRecipe; import WayofTime.bloodmagic.api.altar.AltarUpgrade; import WayofTime.bloodmagic.api.altar.EnumAltarTier; import WayofTime.bloodmagic.api.altar.IBloodAltar; +import WayofTime.bloodmagic.api.orb.IBloodOrb; import WayofTime.bloodmagic.api.registry.AltarRecipeRegistry; +import WayofTime.bloodmagic.api.util.helper.NetworkHelper; import WayofTime.bloodmagic.block.BlockLifeEssence; import com.google.common.base.Enums; import net.minecraft.item.ItemStack; @@ -53,6 +55,9 @@ public class TileAltar extends TileInventory implements IBloodAltar, IUpdatePlay public TileAltar() { super(1, "altar"); + + this.capacity = FluidContainerRegistry.BUCKET_VOLUME * 10; + this.bufferCapacity = FluidContainerRegistry.BUCKET_VOLUME; } @Override @@ -149,20 +154,37 @@ public class TileAltar extends TileInventory implements IBloodAltar, IUpdatePlay } private void everySecond() { - startCycle(); + int syphonMax = (int) (20 * this.dislocationMultiplier); + int fluidInputted; + int fluidOutputted; + fluidInputted = Math.min(syphonMax, -this.fluid.amount + capacity); + fluidInputted = Math.min(this.fluidInput.amount, fluidInputted); + this.fluid.amount += fluidInputted; + this.fluidInput.amount -= fluidInputted; + fluidOutputted = Math.min(syphonMax, this.bufferCapacity - this.fluidOutput.amount); + fluidOutputted = Math.min(this.fluid.amount, fluidOutputted); + this.fluidOutput.amount += fluidOutputted; + this.fluid.amount -= fluidOutputted; } private void everyFiveSeconds() { - checkTier(); + startCycle(); + updat(); } public void startCycle() { if (worldObj != null) worldObj.markBlockForUpdate(pos); + checkTier(); + if (fluid == null || fluid.amount <= 0) return; + if (!isActive) { + progress = 0; + } + if (getStackInSlot(0) != null) { // Do recipes if (AltarRecipeRegistry.getRecipes().containsKey(ItemStackWrapper.getHolder(getStackInSlot(0)))) { @@ -170,13 +192,106 @@ public class TileAltar extends TileInventory implements IBloodAltar, IUpdatePlay if (altarTier.ordinal() >= recipe.getMinTier().ordinal()) { this.liquidRequired = recipe.getSyphon(); -// this.canBeFilled = recipe + this.canBeFilled = recipe.isUseTag(); this.consumptionRate = recipe.getConsumeRate(); this.drainRate = recipe.getDrainRate(); this.isActive = true; } } } + + isActive = false; + } + + private void updat() { + if (!isActive) { + if (cooldownAfterCrafting > 0) { + cooldownAfterCrafting--; + } + } + + if (getStackInSlot(0) == null) { + return; + } + + int worldTime = (int) (worldObj.getWorldTime() % 24000); + + if (worldObj.isRemote) { + return; + } + + if (!canBeFilled) { + if (fluid != null && fluid.amount >= 1) { + int stackSize = getStackInSlot(0).stackSize; + int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? consumptionRate * (1 + consumptionMultiplier) : consumptionRate), fluid.amount); + + if (liquidDrained > (liquidRequired * stackSize - progress)) { + liquidDrained = liquidRequired * stackSize - progress; + } + + fluid.amount = fluid.amount - liquidDrained; + progress += liquidDrained; + + if (worldTime % 4 == 0) { +// SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 1, xCoord, yCoord, zCoord); + } + + if (progress >= liquidRequired * stackSize) { + ItemStack result = AltarRecipeRegistry.getRecipeForInput(ItemStackWrapper.getHolder(getStackInSlot(0))) != null ? (AltarRecipeRegistry.getRecipeForInput(ItemStackWrapper.getHolder(getStackInSlot(0))).getOutput() != null ? AltarRecipeRegistry.getRecipeForInput(ItemStackWrapper.getHolder(getStackInSlot(0))).getOutput().toStack() : null) : null; + if (result != null) { + result.stackSize *= stackSize; + } + + setInventorySlotContents(0, result); + progress = 0; + + for (int i = 0; i < 8; i++) { +// SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 4, xCoord + 0.5f, yCoord + 1.0f, zCoord + 0.5f); + } + this.isActive = false; + } + } else if (progress > 0) { + progress -= (int) (efficiencyMultiplier * drainRate); + + if (worldTime % 2 == 0) { +// SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 2, xCoord, yCoord, zCoord); + } + } + } else { + ItemStack returnedItem = getStackInSlot(0); + + if (!(returnedItem.getItem() instanceof IBloodOrb)) { + return; + } + + IBloodOrb item = (IBloodOrb) (returnedItem.getItem()); + NBTTagCompound itemTag = returnedItem.getTagCompound(); + + if (itemTag == null) { + return; + } + + String ownerName = itemTag.getString("ownerName"); + + if (ownerName.equals("")) { + return; + } + + if (fluid != null && fluid.amount >= 1) { + int liquidDrained = Math.min((int) (altarTier.ordinal() >= 2 ? consumptionRate * (1 + consumptionMultiplier) : consumptionRate), fluid.amount); + + int drain = NetworkHelper.addCurrentEssenceToMaximum(ownerName, liquidDrained, (int) (item.getMaxEssence(returnedItem.getMetadata()) * this.orbCapacityMultiplier)); + + fluid.amount = fluid.amount - drain; + + if (worldTime % 4 == 0) { +// SpellHelper.sendIndexedParticleToAllAround(worldObj, xCoord, yCoord, zCoord, 20, worldObj.provider.dimensionId, 3, xCoord, yCoord, zCoord); + } + } + } + if (worldObj != null) { + worldObj.markBlockForUpdate(pos); + } } private void checkTier() { @@ -280,6 +395,14 @@ public class TileAltar extends TileInventory implements IBloodAltar, IUpdatePlay this.demonBloodDuration = Math.max(0, this.demonBloodDuration - 1); } + public void setActive() { + isActive = false; + } + + public boolean isActive() { + return isActive; + } + @Override public void requestPauseAfterCrafting(int amount) { if (this.isActive) { @@ -357,4 +480,4 @@ public class TileAltar extends TileInventory implements IBloodAltar, IUpdatePlay public FluidStack drain(int maxDrain, boolean doDrain) { return null; } -} +} \ No newline at end of file diff --git a/src/main/resources/assets/bloodmagic/lang/en_US.lang b/src/main/resources/assets/bloodmagic/lang/en_US.lang index 0d8328b3..312dde23 100644 --- a/src/main/resources/assets/bloodmagic/lang/en_US.lang +++ b/src/main/resources/assets/bloodmagic/lang/en_US.lang @@ -6,8 +6,8 @@ item.BloodMagic.activationCrystal.weak.name=Weak Activation Crystal item.BloodMagic.activationCrystal.awakened.name=Awakened Activation Crystal item.BloodMagic.activationCrystal.creative.name=Creative Activation Crystal -item.BloodMagic.dagger.name=Sacrificial Dagger -item.BloodMagic.dagger.creative.name=Creative Sacrificial Dagger +item.BloodMagic.sacrificialDagger.normal.name=Sacrificial Dagger +item.BloodMagic.sacrificialDagger.creative.name=Creative Sacrificial Dagger item.BloodMagic.bucket.lifeEssence.name=Bucket of Life diff --git a/src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger.json b/src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger0.json similarity index 100% rename from src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger.json rename to src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger0.json diff --git a/src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger1.json b/src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger1.json new file mode 100644 index 00000000..7448972c --- /dev/null +++ b/src/main/resources/assets/bloodmagic/models/item/ItemSacrificialDagger1.json @@ -0,0 +1,6 @@ +{ + "parent":"bloodmagic:item/ItemModelBase", + "textures": { + "layer0":"bloodmagic:items/SacrificialDagger" + } +}