diff --git a/resources/assets/enderio/lang/en_US.lang b/resources/assets/enderio/lang/en_US.lang index 46d26f80..c6d432d0 100644 --- a/resources/assets/enderio/lang/en_US.lang +++ b/resources/assets/enderio/lang/en_US.lang @@ -123,6 +123,7 @@ item.darkSteel_helmet.name=Dark Helm item.darkSteel_chestplate.name=Dark Plate item.darkSteel_leggings.name=Dark Leggings item.darkSteel_boots.name=Dark Boots +item.darkSteel_sword.name=The Ender //------GUI diff --git a/src/main/java/crazypants/enderio/ClientProxy.java b/src/main/java/crazypants/enderio/ClientProxy.java index dfbc5c7c..97c9bc36 100644 --- a/src/main/java/crazypants/enderio/ClientProxy.java +++ b/src/main/java/crazypants/enderio/ClientProxy.java @@ -36,7 +36,7 @@ import crazypants.enderio.conduit.render.DefaultConduitRenderer; import crazypants.enderio.conduit.render.ItemConduitRenderer; import crazypants.enderio.enderface.EnderIoRenderer; import crazypants.enderio.enderface.TileEnderIO; -import crazypants.enderio.item.DarkSteelArmorRenderer; +import crazypants.enderio.item.PoweredItemRenderer; import crazypants.enderio.item.YetaWrenchOverlayRenderer; import crazypants.enderio.item.YetaWrenchTickHandler; import crazypants.enderio.machine.hypercube.HyperCubeRenderer; @@ -181,11 +181,12 @@ public class ClientProxy extends CommonProxy { MinecraftForge.EVENT_BUS.register(TravelController.instance); FMLCommonHandler.instance().bus().register(TravelController.instance); - DarkSteelArmorRenderer dsr = new DarkSteelArmorRenderer(); + PoweredItemRenderer dsr = new PoweredItemRenderer(); MinecraftForgeClient.registerItemRenderer(EnderIO.itemDarkSteelBoots, dsr); MinecraftForgeClient.registerItemRenderer(EnderIO.itemDarkSteelLeggings, dsr); MinecraftForgeClient.registerItemRenderer(EnderIO.itemDarkSteelChestplate, dsr); MinecraftForgeClient.registerItemRenderer(EnderIO.itemDarkSteelHelmet, dsr); + MinecraftForgeClient.registerItemRenderer(EnderIO.itemDarkSteelSword, dsr); } diff --git a/src/main/java/crazypants/enderio/Config.java b/src/main/java/crazypants/enderio/Config.java index 1d87f618..e61564fa 100644 --- a/src/main/java/crazypants/enderio/Config.java +++ b/src/main/java/crazypants/enderio/Config.java @@ -1,12 +1,8 @@ package crazypants.enderio; import java.io.File; -import java.io.IOException; import net.minecraftforge.common.config.Configuration; - -import org.apache.commons.io.FileUtils; - import cpw.mods.fml.common.event.FMLPreInitializationEvent; import crazypants.vecmath.VecmathUtil; @@ -95,23 +91,20 @@ public final class Config { public static boolean darkSteelDrainPowerFromInventory = true; public static int darkSteelBootsJumpPowerCost = 100; + public static float darkSteelSwordWitherSkullChance = 0.05f; + public static float darkSteelSwordWitherSkullLootingModifier = 0.167f / 3f; //at looting 3, have a 1 in 6 chance of getting a skull + public static float darkSteelSwordSkullChance = 0.2f; + public static float darkSteelSwordSkullLootingModifier = 0.15f; + public static float vanillaSwordSkullLootingModifier = 0.1f; + public static int darkSteelSwordPowerUsePerHit = 250; + public static void load(FMLPreInitializationEvent event) { configDirectory = new File(event.getModConfigurationDirectory(), "enderio"); if(!configDirectory.exists()) { configDirectory.mkdir(); } - File deprecatedFile = event.getSuggestedConfigurationFile(); - File configFile = new File(configDirectory, "EnderIO.cfg"); - if(deprecatedFile.exists()) { - try { - FileUtils.moveFile(deprecatedFile, configFile); - } catch (IOException e) { - Log.warn("Could not move old config file to new directory: " + e); - } - } - Configuration cfg = new Configuration(configFile); try { cfg.load(); @@ -270,6 +263,24 @@ public final class Config { darkSteelBootsJumpPowerCost = config.get("Settings", "darkSteelBootsJumpPowerCost", darkSteelBootsJumpPowerCost, "Base amount of power used per jump (RF) dark steel boots. The second jump in a 'double jump' uses 2x this etc").getInt(darkSteelBootsJumpPowerCost); + darkSteelSwordSkullChance = (float) config.get("Settings", "darkSteelSwordSkullChance", darkSteelSwordSkullChance, + "The base chance a skull will be dropped when using a powered dark steel sword (0 = no chance, 1 = 100% chance)").getDouble(darkSteelSwordSkullChance); + darkSteelSwordSkullLootingModifier = (float) config.get("Settings", "darkSteelSwordSkullLootingModifier", darkSteelSwordSkullLootingModifier, + "The chance per looting level that a skull will be dropped when using a powered dark steel sword (0 = no chance, 1 = 100% chance)").getDouble( + darkSteelSwordSkullLootingModifier); + darkSteelSwordWitherSkullChance = (float) config.get("Settings", "darkSteelSwordWitherSkullChance", darkSteelSwordWitherSkullChance, + "The base chance a wither skull will be dropped when using a powered dark steel sword (0 = no chance, 1 = 100% chance)").getDouble( + darkSteelSwordWitherSkullChance); + darkSteelSwordWitherSkullLootingModifier = (float) config.get("Settings", "darkSteelSwordWitherSkullLootingModifie", + darkSteelSwordWitherSkullLootingModifier, + "The chance per looting level that a wither skull will be dropped when using a powered dark steel sword (0 = no chance, 1 = 100% chance)").getDouble( + darkSteelSwordWitherSkullLootingModifier); + vanillaSwordSkullLootingModifier = (float) config.get("Settings", "vanillaSwordSkullLootingModifier", vanillaSwordSkullLootingModifier, + "The chance per looting level that a skull will be dropped when using a non-dark steel sword (0 = no chance, 1 = 100% chance)").getDouble( + vanillaSwordSkullLootingModifier); + darkSteelSwordPowerUsePerHit = config.get("Settings", "darkSteelSwordPowerUsePerHit", darkSteelSwordPowerUsePerHit, + "The amount of power (RF) used per hit.").getInt(darkSteelSwordPowerUsePerHit); + //TODO: Debug renderCapBankGauge = config.get("Debug", "renderCapBankGauge", renderCapBankGauge, "If not true capacitor banks will not render the level gauge at all.") .getBoolean(renderCapBankGauge); diff --git a/src/main/java/crazypants/enderio/EnderIO.java b/src/main/java/crazypants/enderio/EnderIO.java index 4bb8594c..52953625 100644 --- a/src/main/java/crazypants/enderio/EnderIO.java +++ b/src/main/java/crazypants/enderio/EnderIO.java @@ -28,6 +28,7 @@ import crazypants.enderio.enderface.BlockEnderIO; import crazypants.enderio.enderface.EnderfaceRecipes; import crazypants.enderio.enderface.ItemEnderface; import crazypants.enderio.item.ItemDarkSteelArmor; +import crazypants.enderio.item.ItemDarkSteelSword; import crazypants.enderio.item.ItemRecipes; import crazypants.enderio.item.ItemYetaWrench; import crazypants.enderio.machine.MachineRecipes; @@ -136,6 +137,7 @@ public class EnderIO { public static ItemDarkSteelArmor itemDarkSteelChestplate; public static ItemDarkSteelArmor itemDarkSteelLeggings; public static ItemDarkSteelArmor itemDarkSteelBoots; + public static ItemDarkSteelSword itemDarkSteelSword; // public static ITrigger triggerNoEnergy; // public static ITrigger triggerHasEnergy; @@ -205,6 +207,8 @@ public class EnderIO { itemDarkSteelLeggings = ItemDarkSteelArmor.create(2); itemDarkSteelBoots = ItemDarkSteelArmor.create(3); + itemDarkSteelSword = ItemDarkSteelSword.create(); + MaterialRecipes.registerOresInDictionary(); } diff --git a/src/main/java/crazypants/enderio/item/DarkSteelController.java b/src/main/java/crazypants/enderio/item/DarkSteelController.java index 51425d13..dafc2ef5 100644 --- a/src/main/java/crazypants/enderio/item/DarkSteelController.java +++ b/src/main/java/crazypants/enderio/item/DarkSteelController.java @@ -24,9 +24,13 @@ public class DarkSteelController { private AttributeModifier walkModifier = new AttributeModifier(new UUID(12879874982l, 320981923), "generic.movementSpeed", Config.darkSteelLeggingWalkModifier, 1); + private AttributeModifier sprintModifier = new AttributeModifier(new UUID(6, 320981923), "generic.movementSpeed", Config.darkSteelLeggingSprintModifier, 1); + private AttributeModifier swordDamageModifierPowered = new AttributeModifier(new UUID(63242325, 320981923), "Weapon modifier", + 2, 0); + private boolean wasJumping; private int jumpCount; private int ticksSinceLastJump; @@ -70,6 +74,17 @@ public class DarkSteelController { } } + //sword + if(ItemDarkSteelSword.isEquipped(player)) { + IAttributeInstance attackInst = player.getAttributeMap().getAttributeInstance(SharedMonsterAttributes.attackDamage); + attackInst.removeModifier(swordDamageModifierPowered); + + ItemStack sword = player.getCurrentEquippedItem(); + if(Config.darkSteelSwordPowerUsePerHit <= 0 || EnderIO.itemDarkSteelSword.getEnergyStored(sword) >= Config.darkSteelSwordPowerUsePerHit) { + attackInst.applyModifier(swordDamageModifierPowered); + } + } + } void usePlayerEnergy(EntityPlayer player, ItemDarkSteelArmor armor, int cost) { diff --git a/src/main/java/crazypants/enderio/item/EnergyContainer.java b/src/main/java/crazypants/enderio/item/EnergyContainer.java new file mode 100644 index 00000000..5a94d76e --- /dev/null +++ b/src/main/java/crazypants/enderio/item/EnergyContainer.java @@ -0,0 +1,87 @@ +package crazypants.enderio.item; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class EnergyContainer { + + private int capacityRF; + private int maxReceiveRF; + private int maxExtractRF; + + public EnergyContainer(int capacityRF, int maxReceiveRF, int maxExtractRF) { + this.capacityRF = capacityRF; + this.maxReceiveRF = maxReceiveRF; + this.maxExtractRF = maxExtractRF; + } + + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + + if(container.stackTagCompound == null) { + container.stackTagCompound = new NBTTagCompound(); + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyReceived = Math.min(capacityRF - energy, Math.min(this.maxReceiveRF, maxReceive)); + + if(!simulate) { + energy += energyReceived; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyReceived; + } + + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + + if(container == null || container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + int energy = container.stackTagCompound.getInteger("Energy"); + int energyExtracted = Math.min(energy, Math.min(this.maxExtractRF, maxExtract)); + + if(!simulate) { + energy -= energyExtracted; + container.stackTagCompound.setInteger("Energy", energy); + } + return energyExtracted; + } + + public static int getEnergyStored(ItemStack container) { + if(container == null || container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { + return 0; + } + return container.stackTagCompound.getInteger("Energy"); + } + + public int getMaxEnergyStored(ItemStack container) { + return capacityRF; + } + + public static void setEnergy(ItemStack container, int energy) { + if(container.stackTagCompound == null) { + container.stackTagCompound = new NBTTagCompound(); + } + container.stackTagCompound.setInteger("Energy", energy); + } + + public void setFull(ItemStack container) { + setEnergy(container, capacityRF); + } + + public boolean isAbsorbDamageWithPower(ItemStack is) { + NBTTagCompound root = is.getTagCompound(); + if(root == null) { + return false; + } + return root.getBoolean("absorbWithPower"); + } + + public void setAbsorbDamageWithPower(ItemStack is, boolean val) { + NBTTagCompound root = is.getTagCompound(); + if(root == null) { + root = new NBTTagCompound(); + is.setTagCompound(root); + } + root.setBoolean("absorbWithPower", val); + } + +} diff --git a/src/main/java/crazypants/enderio/item/ItemDarkSteelArmor.java b/src/main/java/crazypants/enderio/item/ItemDarkSteelArmor.java index fcf10047..095ed43e 100644 --- a/src/main/java/crazypants/enderio/item/ItemDarkSteelArmor.java +++ b/src/main/java/crazypants/enderio/item/ItemDarkSteelArmor.java @@ -7,7 +7,6 @@ import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemArmor; import net.minecraft.item.ItemStack; -import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.DamageSource; import net.minecraftforge.common.ISpecialArmor; import net.minecraftforge.common.util.EnumHelper; @@ -56,11 +55,8 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte return res; } - private int capacityRF; - private int maxReceiveRF; - private int maxExtractRF; - private int powerPerDamagePoint; + private EnergyContainer energyCont; protected ItemDarkSteelArmor(int armorType) { super(MATERIAL, 0, armorType); @@ -70,11 +66,9 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte setUnlocalizedName(str); setTextureName("enderIO:" + str); - capacityRF = CAPACITY[armorType]; - maxReceiveRF = CAPACITY[0] / 5; - maxExtractRF = maxReceiveRF; + energyCont = new EnergyContainer(CAPACITY[armorType], Config.darkSteelPowerStorage / 5, Config.darkSteelPowerStorage / 5); - powerPerDamagePoint = capacityRF / MATERIAL.getDurability(armorType); + powerPerDamagePoint = Config.darkSteelPowerStorage / MATERIAL.getDurability(armorType); } protected void init() { @@ -84,8 +78,8 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte @Override public void addInformation(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag) { list.add("Durability: " + (itemstack.getMaxDamage() - itemstack.getItemDamage()) + "/" + itemstack.getMaxDamage()); - String str = "Power: " + PowerDisplayUtil.formatPower(getEnergyStored(itemstack)) + "/" - + PowerDisplayUtil.formatPower(getMaxEnergyStored(itemstack)) + " " + PowerDisplayUtil.abrevation(); + String str = "Power: " + PowerDisplayUtil.formatPower(getEnergyStored(itemstack) / 10) + "/" + + PowerDisplayUtil.formatPower(getMaxEnergyStored(itemstack) / 10) + " " + PowerDisplayUtil.abrevation(); list.add(str); } @@ -104,70 +98,10 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte public ItemStack createItemStack() { ItemStack res = new ItemStack(this); - setEnergy(res, 0); + energyCont.setEnergy(res, 0); return res; } - @Override - public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { - - if(container.stackTagCompound == null) { - container.stackTagCompound = new NBTTagCompound(); - } - int energy = container.stackTagCompound.getInteger("Energy"); - int energyReceived = Math.min(capacityRF - energy, Math.min(this.maxReceiveRF, maxReceive)); - - if(!simulate) { - energy += energyReceived; - container.stackTagCompound.setInteger("Energy", energy); - } - return energyReceived; - } - - @Override - public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { - - if(container == null || container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { - return 0; - } - int energy = container.stackTagCompound.getInteger("Energy"); - int energyExtracted = Math.min(energy, Math.min(this.maxExtractRF, maxExtract)); - - if(!simulate) { - energy -= energyExtracted; - container.stackTagCompound.setInteger("Energy", energy); - } - return energyExtracted; - } - - @Override - public int getEnergyStored(ItemStack container) { - if(container == null || container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) { - return 0; - } - return container.stackTagCompound.getInteger("Energy"); - } - - @Override - public int getMaxEnergyStored(ItemStack container) { - return capacityRF; - } - - void setEnergy(ItemStack container, int energy) { - if(container.stackTagCompound == null) { - container.stackTagCompound = new NBTTagCompound(); - } - container.stackTagCompound.setInteger("Energy", energy); - } - - public void setFull(ItemStack container) { - setEnergy(container, capacityRF); - } - - public boolean isJustCrafted(ItemStack stack) { - return getEnergyStored(stack) == 0 && getDisplayDamage(stack) == 0; - } - @Override public ArmorProperties getProperties(EntityLivingBase player, ItemStack armor, DamageSource source, double damage, int slot) { double damageRatio = damageReduceAmount + (getEnergyStored(armor) > 0 ? 1 : 0); @@ -184,8 +118,7 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte @Override public void damageArmor(EntityLivingBase entity, ItemStack stack, DamageSource source, int damage, int slot) { ItemDarkSteelArmor am = (ItemDarkSteelArmor) stack.getItem(); - - boolean abs = absorbWithPower(stack); + boolean abs = energyCont.isAbsorbDamageWithPower(stack); if(abs && getEnergyStored(stack) > 0) { extractEnergy(stack, damage * powerPerDamagePoint, false); } else { @@ -195,8 +128,7 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte } stack.setItemDamage(damage); } - setAbsorbWithPower(stack, !abs); - + energyCont.setAbsorbDamageWithPower(stack, !abs); } @Override @@ -204,21 +136,24 @@ public class ItemDarkSteelArmor extends ItemArmor implements IEnergyContainerIte return i2 != null && i2.getItem() == EnderIO.itemAlloy && i2.getItemDamage() == Alloy.DARK_STEEL.ordinal(); } - private boolean absorbWithPower(ItemStack is) { - NBTTagCompound root = is.getTagCompound(); - if(root == null) { - return false; - } - return root.getBoolean("absorbWithPower"); + @Override + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + return energyCont.receiveEnergy(container, maxReceive, simulate); } - private void setAbsorbWithPower(ItemStack is, boolean val) { - NBTTagCompound root = is.getTagCompound(); - if(root == null) { - root = new NBTTagCompound(); - is.setTagCompound(root); - } - root.setBoolean("absorbWithPower", val); + @Override + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + return energyCont.extractEnergy(container, maxExtract, simulate); + } + + @Override + public int getEnergyStored(ItemStack container) { + return energyCont.getEnergyStored(container); + } + + @Override + public int getMaxEnergyStored(ItemStack container) { + return energyCont.getMaxEnergyStored(container); } //Idea from Mekanism diff --git a/src/main/java/crazypants/enderio/item/ItemDarkSteelSword.java b/src/main/java/crazypants/enderio/item/ItemDarkSteelSword.java new file mode 100644 index 00000000..d38a1d5f --- /dev/null +++ b/src/main/java/crazypants/enderio/item/ItemDarkSteelSword.java @@ -0,0 +1,233 @@ +package crazypants.enderio.item; + +import java.util.List; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.monster.EntityCreeper; +import net.minecraft.entity.monster.EntityEnderman; +import net.minecraft.entity.monster.EntitySkeleton; +import net.minecraft.entity.monster.EntityZombie; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.MovementInput; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.EnumHelper; +import net.minecraftforge.event.entity.living.EnderTeleportEvent; +import net.minecraftforge.event.entity.living.LivingDropsEvent; +import cofh.api.energy.IEnergyContainerItem; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.registry.GameRegistry; +import crazypants.enderio.Config; +import crazypants.enderio.EnderIO; +import crazypants.enderio.EnderIOTab; +import crazypants.enderio.machine.power.PowerDisplayUtil; +import crazypants.enderio.material.Alloy; +import crazypants.util.Util; + +public class ItemDarkSteelSword extends ItemSword implements IEnergyContainerItem { + + static final ToolMaterial MATERIAL = EnumHelper.addToolMaterial("darkSteel", 3, 1561, 7, 2, 25); + + public static boolean isEquipped(EntityPlayer player) { + if(player == null) { + return false; + } + ItemStack equipped = player.getCurrentEquippedItem(); + if(equipped == null) { + return false; + } + return equipped.getItem() == EnderIO.itemDarkSteelSword; + } + + public static boolean isEquippedAndPowered(EntityPlayer player, int requiredPower) { + if(!isEquipped(player)) { + return false; + } + return EnderIO.itemDarkSteelSword.getEnergyStored(player.getCurrentEquippedItem()) >= requiredPower; + } + + public static ItemDarkSteelSword create() { + ItemDarkSteelSword res = new ItemDarkSteelSword(); + res.init(); + MinecraftForge.EVENT_BUS.register(res); + return res; + } + + private int powerPerDamagePoint = Config.darkSteelPowerStorage / MATERIAL.getMaxUses(); + + private EnergyContainer energyCont = new EnergyContainer(Config.darkSteelPowerStorage, Config.darkSteelPowerStorage / 10, Config.darkSteelPowerStorage / 10); + + public ItemDarkSteelSword() { + super(MATERIAL); + setCreativeTab(EnderIOTab.tabEnderIO); + + String str = "darkSteel_sword"; + setUnlocalizedName(str); + setTextureName("enderIO:" + str); + } + + @Override + public boolean isDamaged(ItemStack stack) { + return false; + } + + @SubscribeEvent + public void onEnderTeleport(EnderTeleportEvent evt) { + if(evt.entityLiving.getEntityData().getBoolean("hitByDarkSteelSword")) { + System.out.println("ItemDarkSteelSword.onEnderTeleport: cancelled teleport"); + evt.setCanceled(true); + } + } + + @SubscribeEvent + public void onEntityDrop(LivingDropsEvent evt) { + + if(evt.source.getEntity() instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) evt.source.getEntity(); + + double skullDropChance = getSkullDropChance(player, evt); + if(Math.random() >= skullDropChance) { + ItemStack skull = getSkullForEntity(evt.entityLiving); + if(skull != null && !containsDrop(evt, skull)) { + //TODO: Shouldn't I add this to the list in the event? + Util.dropItems(player.worldObj, skull, evt.entityLiving.posX, evt.entityLiving.posY, evt.entityLiving.posZ, true); + } + } + if(isEquipped(player)) { + if(evt.entityLiving instanceof EntityEnderman) { + int numPearls = 1; + for (int i = 0; i < evt.lootingLevel; i++) { + if(Math.random() > 0.2) { //TODO: Config + numPearls++; + } + } + //TODO: Shouldn't I add this to the list in the event? + Util.dropItems(player.worldObj, new ItemStack(Items.ender_pearl, numPearls, 0), evt.entityLiving.posX, evt.entityLiving.posY, evt.entityLiving.posZ, + true); + } + + } + + } + } + + private double getSkullDropChance(EntityPlayer player, LivingDropsEvent evt) { + if(evt.entityLiving instanceof EntitySkeleton && ((EntitySkeleton) evt.entityLiving).getSkeletonType() == 1) { + if(isEquippedAndPowered(player, Config.darkSteelSwordPowerUsePerHit)) { + return Config.darkSteelSwordWitherSkullChance + (Config.darkSteelSwordWitherSkullLootingModifier * evt.lootingLevel); + } else { + return 0; + } + } + float fromWeapon = 0; + float fromLooting = 0; + if(isEquippedAndPowered(player, Config.darkSteelSwordPowerUsePerHit)) { + fromWeapon = Config.darkSteelSwordSkullChance; + fromLooting = Config.darkSteelSwordSkullLootingModifier * evt.lootingLevel; + } else { + fromLooting = Config.vanillaSwordSkullLootingModifier * evt.lootingLevel; + } + return fromWeapon + fromLooting; + } + + private boolean containsDrop(LivingDropsEvent evt, ItemStack skull) { + for (EntityItem ei : evt.drops) { + if(ei != null && ei.getEntityItem() != null && ei.getEntityItem().getItem() == skull.getItem() + && ei.getEntityItem().getItemDamage() == skull.getItemDamage()) { + return true; + } + } + return false; + } + + private ItemStack getSkullForEntity(EntityLivingBase entityLiving) { + if(entityLiving instanceof EntitySkeleton) { + int type = ((EntitySkeleton) entityLiving).getSkeletonType(); + if(type == 1) { + return new ItemStack(Items.skull, 1, 1); + } else { + return new ItemStack(Items.skull, 1, 0); + } + } else if(entityLiving instanceof EntityZombie) { + return new ItemStack(Items.skull, 1, 2); + } else if(entityLiving instanceof EntityCreeper) { + return new ItemStack(Items.skull, 1, 4); + } + + return null; + } + + protected void init() { + GameRegistry.registerItem(this, getUnlocalizedName()); + } + + @Override + public boolean hitEntity(ItemStack par1ItemStack, EntityLivingBase entity, EntityLivingBase playerEntity) { + + if(playerEntity instanceof EntityPlayer) { + EntityPlayer player = (EntityPlayer) playerEntity; + ItemStack sword = player.getCurrentEquippedItem(); + boolean absorbPower = energyCont.isAbsorbDamageWithPower(sword); + if(isEquippedAndPowered(player, powerPerDamagePoint) && absorbPower) { + extractEnergy(player.getCurrentEquippedItem(), powerPerDamagePoint, false); + } else { + super.hitEntity(par1ItemStack, entity, playerEntity); + } + energyCont.setAbsorbDamageWithPower(sword, !absorbPower); + + if(isEquippedAndPowered(player, Config.darkSteelSwordPowerUsePerHit)) { + extractEnergy(player.getCurrentEquippedItem(), Config.darkSteelSwordPowerUsePerHit, false); + if(entity instanceof EntityEnderman) { + entity.getEntityData().setBoolean("hitByDarkSteelSword", true); + } + } + } + return true; + } + + @Override + public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) { + return energyCont.receiveEnergy(container, maxReceive, simulate); + } + + @Override + public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) { + return energyCont.extractEnergy(container, maxExtract, simulate); + } + + @Override + public int getEnergyStored(ItemStack container) { + return energyCont.getEnergyStored(container); + } + + @Override + public int getMaxEnergyStored(ItemStack container) { + return energyCont.getMaxEnergyStored(container); + } + + @Override + public boolean getIsRepairable(ItemStack i1, ItemStack i2) { + return i2 != null && i2.getItem() == EnderIO.itemAlloy && i2.getItemDamage() == Alloy.DARK_STEEL.ordinal(); + } + + @Override + public void addInformation(ItemStack itemstack, EntityPlayer entityplayer, List list, boolean flag) { + //TODO: Localize + list.add("Durability: " + (itemstack.getMaxDamage() - itemstack.getItemDamage()) + "/" + itemstack.getMaxDamage()); + String str = "Power: " + PowerDisplayUtil.formatPower(getEnergyStored(itemstack) / 10) + "/" + + PowerDisplayUtil.formatPower(getMaxEnergyStored(itemstack) / 10) + " " + PowerDisplayUtil.abrevation(); + list.add(str); + MovementInput input = Minecraft.getMinecraft().thePlayer.movementInput; + list.add("Increased skull and ender pearl drops."); + list.add("Enderman can't teleport once hit."); + list.add(""); + list.add(EnumChatFormatting.BLUE + "+1 Damage when Powered"); + + } + +} diff --git a/src/main/java/crazypants/enderio/item/DarkSteelArmorRenderer.java b/src/main/java/crazypants/enderio/item/PoweredItemRenderer.java similarity index 84% rename from src/main/java/crazypants/enderio/item/DarkSteelArmorRenderer.java rename to src/main/java/crazypants/enderio/item/PoweredItemRenderer.java index 6e5b38d6..e39c3d1f 100644 --- a/src/main/java/crazypants/enderio/item/DarkSteelArmorRenderer.java +++ b/src/main/java/crazypants/enderio/item/PoweredItemRenderer.java @@ -10,11 +10,12 @@ import net.minecraftforge.client.IItemRenderer; import org.lwjgl.opengl.GL11; +import cofh.api.energy.IEnergyContainerItem; import crazypants.render.ColorUtil; import crazypants.render.RenderUtil; import crazypants.vecmath.Vector4f; -public class DarkSteelArmorRenderer implements IItemRenderer { +public class PoweredItemRenderer implements IItemRenderer { private RenderItem ri = new RenderItem(); @@ -40,11 +41,13 @@ public class DarkSteelArmorRenderer implements IItemRenderer { Minecraft mc = Minecraft.getMinecraft(); ri.renderItemIntoGUI(mc.fontRenderer, mc.getTextureManager(), item, 0, 0, true); - ItemDarkSteelArmor armor = (ItemDarkSteelArmor) item.getItem(); - if(armor.isJustCrafted(item)) { + IEnergyContainerItem armor = (IEnergyContainerItem) item.getItem(); + if(isJustCrafted(item)) { return; } + //System.out.println("PoweredItemRenderer.renderToInventory: 22" + item); + // GL11.glEnable(GL11.GL_BLEND); // GL11.glBlendFunc(GL11.GL_CONSTANT_ALPHA, GL11.GL_CONSTANT_ALPHA); // GL14.glBlendColor(1, 1, 1, 0.75f); @@ -62,6 +65,9 @@ public class DarkSteelArmorRenderer implements IItemRenderer { maxDam = armor.getMaxEnergyStored(item); dispDamage = armor.getEnergyStored(item); + + //System.out.println("PoweredItemRenderer.renderToInventory: " + dispDamage + " / " + maxDam); + r = 0.4f; g = 0.4f; b = 1f; @@ -72,6 +78,10 @@ public class DarkSteelArmorRenderer implements IItemRenderer { } + private boolean isJustCrafted(ItemStack item) { + return EnergyContainer.getEnergyStored(item) == 0 && item.getItemDamageForDisplay() == 0; + } + private void renderBar(int y, double maxDam, double dispDamage, Color full, Color empty) { double ratio = dispDamage / maxDam; Vector4f fg = ColorUtil.toFloat(full); diff --git a/src/main/java/crazypants/util/Util.java b/src/main/java/crazypants/util/Util.java index 985fbbd5..47bafb69 100644 --- a/src/main/java/crazypants/util/Util.java +++ b/src/main/java/crazypants/util/Util.java @@ -101,6 +101,30 @@ public class Util { } + public static void dropItems(World world, ItemStack stack, double x, double y, double z, boolean doRandomSpread) { + if(stack.stackSize <= 0) { + return; + } + + if(doRandomSpread) { + float f1 = 0.7F; + double d = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D; + double d1 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D; + double d2 = (world.rand.nextFloat() * f1) + (1.0F - f1) * 0.5D; + EntityItem entityitem = new EntityItem(world, x + d, y + d1, z + d2, stack); + entityitem.delayBeforeCanPickup = 10; + world.spawnEntityInWorld(entityitem); + } else { + EntityItem entityitem = new EntityItem(world, x, y, z, stack); + entityitem.motionX = 0; + entityitem.motionY = 0; + entityitem.motionZ = 0; + entityitem.delayBeforeCanPickup = 0; + world.spawnEntityInWorld(entityitem); + } + + } + public static void dropItems(World world, ItemStack stack, int x, int y, int z, boolean doRandomSpread) { if(stack.stackSize <= 0) { return;