diff --git a/build.gradle b/build.gradle index 8fde214cf..398dcd80a 100644 --- a/build.gradle +++ b/build.gradle @@ -9,22 +9,13 @@ buildscript { name = "sonatype" url = "https://oss.sonatype.org/content/repositories/snapshots/" } - maven { - name = "Modmuss50" - url = "http://maven.modmuss50.me/" - } maven { url "https://plugins.gradle.org/m2/" } - maven { - name = 'mojang' - url = 'https://libraries.minecraft.net/' - } } dependencies { classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT' classpath "gradle.plugin.net.minecrell:licenser:0.2.1" - classpath 'ASM-Injector:ASM-Injector:1.0.0.31' } } @@ -311,51 +302,7 @@ task signJar(type: SignJar, dependsOn: reobfJar) { } -//task asmInjectJar { -// doLast { -// def cacheFiles = new File(".gradle/asmInjector") -// if (!cacheFiles.exists()) { -// cacheFiles.mkdirs() -// } -// //Downloads the maven meta data -// def mavenMetadata = new File(cacheFiles, "maven-metadata.xml") -// logger.lifecycle("ASMInjector: Downloading reborn core metadata") -// FileUtils.copyURLToFile(new URL("http://maven.modmuss50.me/RebornCore/RebornCore-1.12/maven-metadata.xml"), mavenMetadata) -// -// def metadata = new XmlSlurper().parseText(FileUtils.readFileToString(mavenMetadata)) -// def rcVersion = metadata.versioning.release -// -// def rebornCoreJar = new File(cacheFiles, "${rcVersion}.jar") -// if(rebornCoreJar.exists()){ -// rebornCoreJar.delete() -// } -// logger.lifecycle("ASMInjector: downloading RebornCore ${rcVersion}") -// FileUtils.copyURLToFile(new URL("http://maven.modmuss50.me/RebornCore/RebornCore-1.12/${rcVersion}/RebornCore-1.12-${rcVersion}-dev.jar"), rebornCoreJar) -// -// logger.lifecycle("ASMInjector: setting up injector") -// def injector = new me.modmuss50.asmInjector.ASMInjector() -// injector.addClasspathFile(jar.archivePath) -// injector.addClasspathFile(rebornCoreJar) -// injector.callSetupClass("reborncore.mixin.implementations.asmInjector.ASMInjectorSetupClass") -// //injector.addClasspathFile(rebornCoreJar) //Done again to load the class data into the setup class -// -// configurations.forgeGradleMc.collect { -// injector.addClasspathFile(it) -// } -// configurations.compile.collect { -// if(!it.getName().contains("RebornCore")){ -// injector.addClasspathFile(it) -// } -// } -// injector.addTransformer("reborncore.mixin.transformer.MixinTransformer") -// logger.lifecycle("ASMInjector: injecting") -// injector.inject(jar.archivePath, jar.archivePath) -// logger.lifecycle("ASMInjector: done") -// } -//} - build.dependsOn signJar -//signJar.dependsOn asmInjectJar apply from: 'https://github.com/FabricMC/fabric-docs/raw/master/gradle/ideconfig.gradle' diff --git a/src/main/java/techreborn/init/TechRebornMixins.java b/src/main/java/techreborn/init/TechRebornMixins.java deleted file mode 100644 index 4e017bab1..000000000 --- a/src/main/java/techreborn/init/TechRebornMixins.java +++ /dev/null @@ -1,61 +0,0 @@ -/* - * This file is part of TechReborn, licensed under the MIT License (MIT). - * - * Copyright (c) 2017 TechReborn - * - * Permission is hereby granted, free of charge, to any person obtaining a copy - * of this software and associated documentation files (the "Software"), to deal - * in the Software without restriction, including without limitation the rights - * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell - * copies of the Software, and to permit persons to whom the Software is - * furnished to do so, subject to the following conditions: - * - * The above copyright notice and this permission notice shall be included in all - * copies or substantial portions of the Software. - * - * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR - * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE - * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER - * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, - * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE - * SOFTWARE. - */ - -package techreborn.init; - -import reborncore.common.powerSystem.PoweredItem; -import reborncore.mixin.api.IMixinRegistry; -import reborncore.mixin.json.MixinTargetData; - -import java.util.ArrayList; -import java.util.List; - -public class TechRebornMixins implements IMixinRegistry { - @Override - public List register() { - List targetData = new ArrayList<>(); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemRockCutter")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.armor.ItemLithiumBatpack")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.armor.ItemLapotronPack")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.battery.ItemLithiumBattery")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.battery.ItemLapotronicOrb")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemOmniTool")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.battery.ItemEnergyCrystal")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.battery.ItemLapotronCrystal")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.battery.ItemReBattery")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemElectricTreetap")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemSteelDrill")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemDiamondDrill")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemAdvancedDrill")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemSteelChainsaw")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemDiamondChainsaw")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemAdvancedChainsaw")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemSteelJackhammer")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemDiamondJackhammer")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemAdvancedJackhammer")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemNanosaber")); - targetData.addAll(PoweredItem.registerPoweredItem("techreborn.items.tools.ItemCloakingDevice")); - return targetData; - } -} diff --git a/src/main/java/techreborn/items/armor/ItemLapotronPack.java b/src/main/java/techreborn/items/armor/ItemLapotronPack.java index 24b05e80f..c95489ca1 100644 --- a/src/main/java/techreborn/items/armor/ItemLapotronPack.java +++ b/src/main/java/techreborn/items/armor/ItemLapotronPack.java @@ -31,17 +31,24 @@ import net.minecraft.inventory.EntityEquipmentSlot; import net.minecraft.item.Item; import net.minecraft.item.ItemArmor; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.NonNullList; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import techreborn.config.ConfigTechReborn; import techreborn.init.ModItems; -public class ItemLapotronPack extends ItemArmor implements IEnergyItemInfo { +import javax.annotation.Nullable; + +public class ItemLapotronPack extends ItemArmor implements IEnergyItemInfo, IEnergyInterfaceItem { public static final int maxCharge = ConfigTechReborn.LapotronPackCharge; public double transferLimit = 100000; @@ -112,4 +119,103 @@ public class ItemLapotronPack extends ItemArmor implements IEnergyItemInfo { } } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/armor/ItemLithiumBatpack.java b/src/main/java/techreborn/items/armor/ItemLithiumBatpack.java index c0e1f17c0..ce7d80776 100644 --- a/src/main/java/techreborn/items/armor/ItemLithiumBatpack.java +++ b/src/main/java/techreborn/items/armor/ItemLithiumBatpack.java @@ -30,17 +30,24 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.EntityEquipmentSlot; import net.minecraft.item.ItemArmor; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.NonNullList; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import techreborn.config.ConfigTechReborn; import techreborn.init.ModItems; -public class ItemLithiumBatpack extends ItemArmor implements IEnergyItemInfo { +import javax.annotation.Nullable; + +public class ItemLithiumBatpack extends ItemArmor implements IEnergyItemInfo, IEnergyInterfaceItem { public static final int maxCharge = ConfigTechReborn.LithiumBatpackCharge; public double transferLimit = 10000; @@ -112,4 +119,103 @@ public class ItemLithiumBatpack extends ItemArmor implements IEnergyItemInfo { itemList.add(charged); } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/battery/ItemBattery.java b/src/main/java/techreborn/items/battery/ItemBattery.java index 1bc126883..9c7d9a2bb 100644 --- a/src/main/java/techreborn/items/battery/ItemBattery.java +++ b/src/main/java/techreborn/items/battery/ItemBattery.java @@ -27,17 +27,22 @@ package techreborn.items.battery; import net.minecraft.entity.EntityLivingBase; import net.minecraft.item.IItemPropertyGetter; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.ResourceLocation; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.items.ItemTR; import javax.annotation.Nullable; -public class ItemBattery extends ItemTR implements IEnergyItemInfo { +public class ItemBattery extends ItemTR implements IEnergyItemInfo, IEnergyInterfaceItem { String name; int maxEnergy = 0; @@ -85,4 +90,103 @@ public class ItemBattery extends ItemTR implements IEnergyItemInfo { public double getMaxTransfer(ItemStack stack) { return maxTransfer; } + + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } } diff --git a/src/main/java/techreborn/items/tools/ItemChainsaw.java b/src/main/java/techreborn/items/tools/ItemChainsaw.java index 64897f138..05950100c 100644 --- a/src/main/java/techreborn/items/tools/ItemChainsaw.java +++ b/src/main/java/techreborn/items/tools/ItemChainsaw.java @@ -32,19 +32,24 @@ import net.minecraft.init.Enchantments; import net.minecraft.item.IItemPropertyGetter; import net.minecraft.item.ItemAxe; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import javax.annotation.Nullable; import java.util.Random; -public class ItemChainsaw extends ItemAxe implements IEnergyItemInfo { +public class ItemChainsaw extends ItemAxe implements IEnergyItemInfo, IEnergyInterfaceItem { public int maxCharge = 1; public int cost = 250; @@ -123,4 +128,103 @@ public class ItemChainsaw extends ItemAxe implements IEnergyItemInfo { return transferLimit; } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/tools/ItemCloakingDevice.java b/src/main/java/techreborn/items/tools/ItemCloakingDevice.java index cc9dc4709..3431d31c0 100644 --- a/src/main/java/techreborn/items/tools/ItemCloakingDevice.java +++ b/src/main/java/techreborn/items/tools/ItemCloakingDevice.java @@ -29,12 +29,17 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.MobEffects; import net.minecraft.inventory.EntityEquipmentSlot; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.NonNullList; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import reborncore.common.registration.RebornRegistry; import reborncore.common.registration.impl.ConfigRegistry; import techreborn.client.TechRebornCreativeTab; @@ -43,8 +48,10 @@ import techreborn.init.ModItems; import techreborn.items.ItemTR; import techreborn.lib.ModInfo; +import javax.annotation.Nullable; + @RebornRegistry(modID = ModInfo.MOD_ID) -public class ItemCloakingDevice extends ItemTR implements IEnergyItemInfo { +public class ItemCloakingDevice extends ItemTR implements IEnergyItemInfo, IEnergyInterfaceItem { @ConfigRegistry(config = "items", category = "cloacking_device", key = "ClockingDeviceEnergyUsage", comment = "Cloacking device energy usesage (Value in EU)") public static int usage = 10; @@ -118,4 +125,103 @@ public class ItemCloakingDevice extends ItemTR implements IEnergyItemInfo { itemList.add(uncharged); itemList.add(charged); } + + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } } diff --git a/src/main/java/techreborn/items/tools/ItemDrill.java b/src/main/java/techreborn/items/tools/ItemDrill.java index 642b728cd..490a1ad29 100644 --- a/src/main/java/techreborn/items/tools/ItemDrill.java +++ b/src/main/java/techreborn/items/tools/ItemDrill.java @@ -31,15 +31,21 @@ import net.minecraft.init.Enchantments; import net.minecraft.init.Items; import net.minecraft.item.ItemPickaxe; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; +import javax.annotation.Nullable; import java.util.Random; -public class ItemDrill extends ItemPickaxe implements IEnergyItemInfo { +public class ItemDrill extends ItemPickaxe implements IEnergyItemInfo, IEnergyInterfaceItem { public int maxCharge = 1; public int cost = 250; @@ -110,4 +116,103 @@ public class ItemDrill extends ItemPickaxe implements IEnergyItemInfo { return transferLimit; } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/tools/ItemElectricTreetap.java b/src/main/java/techreborn/items/tools/ItemElectricTreetap.java index f994e38b1..e2eef7a4c 100644 --- a/src/main/java/techreborn/items/tools/ItemElectricTreetap.java +++ b/src/main/java/techreborn/items/tools/ItemElectricTreetap.java @@ -30,25 +30,32 @@ import net.minecraft.block.state.IBlockState; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.EnumActionResult; import net.minecraft.util.EnumFacing; import net.minecraft.util.EnumHand; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import techreborn.compat.CompatManager; import techreborn.init.ModItems; import techreborn.items.ItemTR; +import javax.annotation.Nullable; + /** * Created by modmuss50 on 05/11/2016. */ -public class ItemElectricTreetap extends ItemTR implements IEnergyItemInfo { +public class ItemElectricTreetap extends ItemTR implements IEnergyItemInfo, IEnergyInterfaceItem { public static final int maxCharge = 5120; public static final int tier = 1; @@ -107,4 +114,103 @@ public class ItemElectricTreetap extends ItemTR implements IEnergyItemInfo { itemList.add(charged); } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/tools/ItemJackhammer.java b/src/main/java/techreborn/items/tools/ItemJackhammer.java index 977ea972a..5eabd0e03 100644 --- a/src/main/java/techreborn/items/tools/ItemJackhammer.java +++ b/src/main/java/techreborn/items/tools/ItemJackhammer.java @@ -33,19 +33,25 @@ import net.minecraft.init.Blocks; import net.minecraft.init.Enchantments; import net.minecraft.item.ItemPickaxe; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import techreborn.utils.OreDictUtils; +import javax.annotation.Nullable; import java.util.Random; -public class ItemJackhammer extends ItemPickaxe implements IEnergyItemInfo { +public class ItemJackhammer extends ItemPickaxe implements IEnergyItemInfo, IEnergyInterfaceItem { public int maxCharge = 1; public int cost = 250; @@ -130,4 +136,103 @@ public class ItemJackhammer extends ItemPickaxe implements IEnergyItemInfo { PoweredItem.setEnergy(getMaxPower(charged), charged); itemList.add(charged); } + + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } } diff --git a/src/main/java/techreborn/items/tools/ItemNanosaber.java b/src/main/java/techreborn/items/tools/ItemNanosaber.java index bc61062d7..af0c00cf9 100644 --- a/src/main/java/techreborn/items/tools/ItemNanosaber.java +++ b/src/main/java/techreborn/items/tools/ItemNanosaber.java @@ -42,10 +42,14 @@ import net.minecraft.util.text.TextComponentString; import net.minecraft.util.text.TextFormatting; import net.minecraft.util.text.translation.I18n; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import reborncore.common.util.ChatUtils; import techreborn.client.TechRebornCreativeTab; import techreborn.init.ModItems; @@ -54,7 +58,7 @@ import techreborn.lib.MessageIDs; import javax.annotation.Nullable; import java.util.List; -public class ItemNanosaber extends ItemSword implements IEnergyItemInfo { +public class ItemNanosaber extends ItemSword implements IEnergyItemInfo, IEnergyInterfaceItem { public int cost = 250; public ItemNanosaber() { @@ -216,4 +220,103 @@ public class ItemNanosaber extends ItemSword implements IEnergyItemInfo { return 512; } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/java/techreborn/items/tools/ItemOmniTool.java b/src/main/java/techreborn/items/tools/ItemOmniTool.java index 889b14e23..879c4813d 100644 --- a/src/main/java/techreborn/items/tools/ItemOmniTool.java +++ b/src/main/java/techreborn/items/tools/ItemOmniTool.java @@ -32,22 +32,28 @@ import net.minecraft.entity.player.EntityPlayer; import net.minecraft.init.Items; import net.minecraft.item.ItemPickaxe; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.*; import net.minecraft.util.math.BlockPos; import net.minecraft.util.text.TextFormatting; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import reborncore.common.util.TorchHelper; import techreborn.client.TechRebornCreativeTab; import techreborn.config.ConfigTechReborn; import techreborn.init.ModItems; +import javax.annotation.Nullable; import java.util.List; -public class ItemOmniTool extends ItemPickaxe implements IEnergyItemInfo { +public class ItemOmniTool extends ItemPickaxe implements IEnergyItemInfo, IEnergyInterfaceItem { public static final int maxCharge = ConfigTechReborn.OmniToolCharge; public int cost = 100; @@ -154,4 +160,103 @@ public class ItemOmniTool extends ItemPickaxe implements IEnergyItemInfo { public void addInformation(ItemStack stack, World world, List tooltip, ITooltipFlag flag) { tooltip.add(TextFormatting.RED + "WIP Coming Soon"); } + + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } } diff --git a/src/main/java/techreborn/items/tools/ItemRockCutter.java b/src/main/java/techreborn/items/tools/ItemRockCutter.java index 2e779a8b9..e58cfe648 100644 --- a/src/main/java/techreborn/items/tools/ItemRockCutter.java +++ b/src/main/java/techreborn/items/tools/ItemRockCutter.java @@ -34,13 +34,18 @@ import net.minecraft.init.Enchantments; import net.minecraft.init.Items; import net.minecraft.item.ItemPickaxe; import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.common.capabilities.ICapabilityProvider; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import reborncore.api.power.IEnergyInterfaceItem; import reborncore.api.power.IEnergyItemInfo; +import reborncore.common.powerSystem.PowerSystem; import reborncore.common.powerSystem.PoweredItem; +import reborncore.common.powerSystem.PoweredItemContainerProvider; import techreborn.client.TechRebornCreativeTab; import techreborn.config.ConfigTechReborn; import techreborn.init.ModItems; @@ -48,7 +53,7 @@ import techreborn.init.ModItems; import javax.annotation.Nullable; import java.util.Random; -public class ItemRockCutter extends ItemPickaxe implements IEnergyItemInfo { +public class ItemRockCutter extends ItemPickaxe implements IEnergyItemInfo, IEnergyInterfaceItem { public static final int maxCharge = ConfigTechReborn.RockCutterCharge; public int cost = 500; @@ -147,4 +152,103 @@ public class ItemRockCutter extends ItemPickaxe implements IEnergyItemInfo { itemList.add(charged); } + @Override + public double getEnergy(ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + if (tagCompound.hasKey("charge")) { + return tagCompound.getDouble("charge"); + } + return 0; + } + + @Override + public void setEnergy(double energy, ItemStack stack) { + NBTTagCompound tagCompound = getOrCreateNbtData(stack); + tagCompound.setDouble("charge", energy); + + if (this.getEnergy(stack) > getMaxPower(stack)) { + this.setEnergy(getMaxPower(stack), stack); + } else if (this.getEnergy(stack) < 0) { + this.setEnergy(0, stack); + } + } + + @Override + public double addEnergy(double energy, ItemStack stack) { + return addEnergy(energy, false, stack); + } + + @Override + public double addEnergy(double energy, boolean simulate, ItemStack stack) { + double energyReceived = Math.min(getMaxPower(stack) - energy, Math.min(this.getMaxPower(stack), energy)); + + if (!simulate) { + setEnergy(energy + energyReceived, stack); + } + return energyReceived; + } + + + @Override + public boolean canUseEnergy(double input, ItemStack stack) { + return input <= getEnergy(stack); + } + + + @Override + public double useEnergy(double energy, ItemStack stack) { + return useEnergy(energy, false, stack); + } + + + @Override + public double useEnergy(double extract, boolean simulate, ItemStack stack) { + double energyExtracted = Math.min(extract, Math.min(this.getMaxTransfer(stack), extract)); + + if (!simulate) { + setEnergy(getEnergy(stack) - energyExtracted, stack); + } + return energyExtracted; + } + + + @Override + public boolean canAddEnergy(double energy, ItemStack stack) { + return this.getEnergy(stack) + energy <= getMaxPower(stack); + } + + + public NBTTagCompound getOrCreateNbtData(ItemStack itemStack) { + NBTTagCompound tagCompound = itemStack.getTagCompound(); + if (tagCompound == null) { + tagCompound = new NBTTagCompound(); + itemStack.setTagCompound(tagCompound); + } + + return tagCompound; + } + + + public double getDurabilityForDisplay(ItemStack stack) { + double charge = (PoweredItem.getEnergy(stack) / getMaxPower(stack)); + return 1 - charge; + } + + + public boolean showDurabilityBar(ItemStack stack) { + return true; + } + + + public int getRGBDurabilityForDisplay(ItemStack stack) { + return PowerSystem.getDisplayPower().colour; + } + + @Nullable + public ICapabilityProvider initCapabilities(ItemStack stack, + @Nullable + NBTTagCompound nbt) { + return new PoweredItemContainerProvider(stack); + } + } diff --git a/src/main/resources/META-INF/services/reborncore.mixin.api.IMixinRegistry b/src/main/resources/META-INF/services/reborncore.mixin.api.IMixinRegistry deleted file mode 100644 index fd7450cea..000000000 --- a/src/main/resources/META-INF/services/reborncore.mixin.api.IMixinRegistry +++ /dev/null @@ -1 +0,0 @@ -techreborn.init.TechRebornMixins