From 12fcaa770c52e2a649dc39d198e22268d2c51c2c Mon Sep 17 00:00:00 2001 From: Timo Ley Date: Sun, 16 Oct 2022 16:08:02 +0200 Subject: [PATCH] ported Basic Components --- .gitignore | 3 +- build.gradle | 6 +- gradlew | 0 .../client/ModelCopperWire.java | 117 +++++++ .../client/RenderCopperWire.java | 57 +++ .../client/gui/GuiBatteryBox.java | 52 +++ .../client/gui/GuiCoalGenerator.java | 55 +++ .../client/gui/GuiElectricFurnace.java | 60 ++++ .../basiccomponents/common/BCGuiHandler.java | 57 +++ .../common/BasicComponents.java | 328 +++++++++++++++++ .../basiccomponents/common/CommonProxy.java | 11 + .../common/block/BlockBase.java | 17 + .../common/block/BlockBasicMachine.java | 288 +++++++++++++++ .../common/block/BlockCopperWire.java | 45 +++ .../common/container/ContainerBatteryBox.java | 82 +++++ .../container/ContainerCoalGenerator.java | 77 ++++ .../container/ContainerElectricFurnace.java | 95 +++++ .../basiccomponents/common/item/ItemBase.java | 17 + .../common/item/ItemBattery.java | 32 ++ .../common/item/ItemBlockBasicMachine.java | 33 ++ .../common/item/ItemBlockCopperWire.java | 44 +++ .../common/item/ItemCircuit.java | 34 ++ .../common/item/ItemInfiniteBattery.java | 53 +++ .../common/item/ItemIngot.java | 11 + .../common/item/ItemPlate.java | 11 + .../common/item/ItemWrench.java | 51 +++ .../tileentity/TileEntityBatteryBox.java | 251 +++++++++++++ .../tileentity/TileEntityCoalGenerator.java | 263 ++++++++++++++ .../tileentity/TileEntityCopperWire.java | 36 ++ .../tileentity/TileEntityElectricFurnace.java | 267 ++++++++++++++ .../core/UniversalElectricity.java | 36 ++ .../core/block/IConductor.java | 11 + .../core/block/IConnectionProvider.java | 11 + .../core/block/IConnector.java | 8 + .../core/block/IElectricityStorage.java | 11 + .../core/block/INetworkProvider.java | 10 + .../core/block/IVoltage.java | 7 + .../core/electricity/ElectricityDisplay.java | 97 +++++ .../core/electricity/ElectricityNetwork.java | 330 ++++++++++++++++++ .../electricity/ElectricityNetworkHelper.java | 140 ++++++++ .../core/electricity/ElectricityPack.java | 102 ++++++ .../core/electricity/IConductorRegistry.java | 15 + .../core/electricity/IElectricityNetwork.java | 57 +++ .../core/item/ElectricItemHelper.java | 60 ++++ .../core/item/IItemElectric.java | 17 + .../core/item/IItemElectricityStorage.java | 12 + .../core/item/IItemVoltage.java | 8 + .../core/item/ItemElectric.java | 92 +++++ .../core/path/IPathCallBack.java | 12 + .../core/path/Pathfinder.java | 51 +++ .../core/path/PathfinderAStar.java | 112 ++++++ .../core/path/PathfinderChecker.java | 43 +++ .../core/vector/Vector2.java | 101 ++++++ .../core/vector/Vector3.java | 286 +++++++++++++++ .../core/vector/VectorHelper.java | 26 ++ .../prefab/CustomDamageSource.java | 32 ++ .../universalelectricity/prefab/GuiBase.java | 131 +++++++ .../prefab/RecipeHelper.java | 131 +++++++ .../prefab/SlotSpecific.java | 74 ++++ .../prefab/TranslationHelper.java | 49 +++ .../prefab/block/BlockAdvanced.java | 154 ++++++++ .../prefab/block/BlockConductor.java | 34 ++ .../prefab/block/BlockRotatable.java | 51 +++ .../prefab/implement/IDisableable.java | 9 + .../prefab/implement/IRedstoneProvider.java | 10 + .../prefab/implement/IRedstoneReceptor.java | 9 + .../prefab/implement/IRotatable.java | 12 + .../prefab/implement/ITier.java | 9 + .../prefab/implement/IToolConfigurator.java | 10 + .../prefab/multiblock/BlockMulti.java | 110 ++++++ .../prefab/multiblock/IBlockActivate.java | 8 + .../prefab/multiblock/IMultiBlock.java | 12 + .../prefab/multiblock/TileEntityMulti.java | 106 ++++++ .../prefab/ore/OreGenBase.java | 60 ++++ .../prefab/ore/OreGenReplace.java | 99 ++++++ .../prefab/ore/OreGenReplaceStone.java | 16 + .../prefab/ore/OreGenerator.java | 60 ++++ .../prefab/potion/CustomPotion.java | 22 ++ .../prefab/potion/CustomPotionEffect.java | 27 ++ .../prefab/tile/TileEntityAdvanced.java | 42 +++ .../prefab/tile/TileEntityConductor.java | 144 ++++++++ .../prefab/tile/TileEntityDisableable.java | 27 ++ .../prefab/tile/TileEntityElectrical.java | 19 + .../tile/TileEntityElectricityRunnable.java | 48 +++ .../tile/TileEntityElectricityStorage.java | 67 ++++ .../prefab/vector/Region2.java | 27 ++ .../prefab/vector/Region3.java | 94 +++++ .../languages/de_DE.properties | 34 ++ .../languages/en_US.properties | 36 ++ .../languages/es_ES.properties | 37 ++ .../languages/it_IT.properties | 33 ++ .../languages/nl_NL.properties | 35 ++ .../languages/pl_PL.properties | 35 ++ .../languages/zh_CN.properties | 38 ++ .../textures/blocks/batteryBox.png | Bin 0 -> 4591 bytes .../textures/blocks/coalGenerator.png | Bin 0 -> 4968 bytes .../textures/blocks/copperWire.png | Bin 0 -> 3751 bytes .../textures/blocks/electricFurnace.png | Bin 0 -> 5323 bytes .../textures/blocks/machine.png | Bin 0 -> 4557 bytes .../textures/blocks/machine_input.png | Bin 0 -> 4623 bytes .../textures/blocks/machine_output.png | Bin 0 -> 4585 bytes .../textures/blocks/machine_side.png | Bin 0 -> 4817 bytes .../textures/blocks/oreCopper.png | Bin 0 -> 3402 bytes .../textures/blocks/oreTin.png | Bin 0 -> 3332 bytes .../textures/gui/battery_box.png | Bin 0 -> 4383 bytes .../textures/gui/coal_generator.png | Bin 0 -> 3956 bytes .../textures/gui/electric_furnace.png | Bin 0 -> 3979 bytes .../textures/items/battery.png | Bin 0 -> 3754 bytes .../textures/items/circuitAdvanced.png | Bin 0 -> 3655 bytes .../textures/items/circuitBasic.png | Bin 0 -> 3652 bytes .../textures/items/circuitElite.png | Bin 0 -> 3633 bytes .../textures/items/dustBronze.png | Bin 0 -> 3312 bytes .../textures/items/dustSteel.png | Bin 0 -> 3645 bytes .../textures/items/infiniteBattery.png | Bin 0 -> 3920 bytes .../textures/items/ingotBronze.png | Bin 0 -> 3029 bytes .../textures/items/ingotCopper.png | Bin 0 -> 3032 bytes .../textures/items/ingotSteel.png | Bin 0 -> 3038 bytes .../textures/items/ingotTin.png | Bin 0 -> 3048 bytes .../basiccomponents/textures/items/motor.png | Bin 0 -> 3909 bytes .../textures/items/plateBronze.png | Bin 0 -> 3726 bytes .../textures/items/plateCopper.png | Bin 0 -> 3727 bytes .../textures/items/plateGold.png | Bin 0 -> 3747 bytes .../textures/items/plateIron.png | Bin 0 -> 3630 bytes .../textures/items/plateSteel.png | Bin 0 -> 3572 bytes .../textures/items/plateTin.png | Bin 0 -> 3715 bytes .../basiccomponents/textures/items/wrench.png | Bin 0 -> 3225 bytes .../textures/models/copperWire.png | Bin 0 -> 798 bytes 127 files changed, 6055 insertions(+), 4 deletions(-) mode change 100644 => 100755 gradlew create mode 100644 src/main/java/basiccomponents/client/ModelCopperWire.java create mode 100644 src/main/java/basiccomponents/client/RenderCopperWire.java create mode 100644 src/main/java/basiccomponents/client/gui/GuiBatteryBox.java create mode 100644 src/main/java/basiccomponents/client/gui/GuiCoalGenerator.java create mode 100644 src/main/java/basiccomponents/client/gui/GuiElectricFurnace.java create mode 100644 src/main/java/basiccomponents/common/BCGuiHandler.java create mode 100644 src/main/java/basiccomponents/common/BasicComponents.java create mode 100644 src/main/java/basiccomponents/common/CommonProxy.java create mode 100644 src/main/java/basiccomponents/common/block/BlockBase.java create mode 100644 src/main/java/basiccomponents/common/block/BlockBasicMachine.java create mode 100644 src/main/java/basiccomponents/common/block/BlockCopperWire.java create mode 100644 src/main/java/basiccomponents/common/container/ContainerBatteryBox.java create mode 100644 src/main/java/basiccomponents/common/container/ContainerCoalGenerator.java create mode 100644 src/main/java/basiccomponents/common/container/ContainerElectricFurnace.java create mode 100644 src/main/java/basiccomponents/common/item/ItemBase.java create mode 100644 src/main/java/basiccomponents/common/item/ItemBattery.java create mode 100644 src/main/java/basiccomponents/common/item/ItemBlockBasicMachine.java create mode 100644 src/main/java/basiccomponents/common/item/ItemBlockCopperWire.java create mode 100644 src/main/java/basiccomponents/common/item/ItemCircuit.java create mode 100644 src/main/java/basiccomponents/common/item/ItemInfiniteBattery.java create mode 100644 src/main/java/basiccomponents/common/item/ItemIngot.java create mode 100644 src/main/java/basiccomponents/common/item/ItemPlate.java create mode 100644 src/main/java/basiccomponents/common/item/ItemWrench.java create mode 100644 src/main/java/basiccomponents/common/tileentity/TileEntityBatteryBox.java create mode 100644 src/main/java/basiccomponents/common/tileentity/TileEntityCoalGenerator.java create mode 100644 src/main/java/basiccomponents/common/tileentity/TileEntityCopperWire.java create mode 100644 src/main/java/basiccomponents/common/tileentity/TileEntityElectricFurnace.java create mode 100644 src/main/java/universalelectricity/core/UniversalElectricity.java create mode 100644 src/main/java/universalelectricity/core/block/IConductor.java create mode 100644 src/main/java/universalelectricity/core/block/IConnectionProvider.java create mode 100644 src/main/java/universalelectricity/core/block/IConnector.java create mode 100644 src/main/java/universalelectricity/core/block/IElectricityStorage.java create mode 100644 src/main/java/universalelectricity/core/block/INetworkProvider.java create mode 100644 src/main/java/universalelectricity/core/block/IVoltage.java create mode 100644 src/main/java/universalelectricity/core/electricity/ElectricityDisplay.java create mode 100644 src/main/java/universalelectricity/core/electricity/ElectricityNetwork.java create mode 100644 src/main/java/universalelectricity/core/electricity/ElectricityNetworkHelper.java create mode 100644 src/main/java/universalelectricity/core/electricity/ElectricityPack.java create mode 100644 src/main/java/universalelectricity/core/electricity/IConductorRegistry.java create mode 100644 src/main/java/universalelectricity/core/electricity/IElectricityNetwork.java create mode 100644 src/main/java/universalelectricity/core/item/ElectricItemHelper.java create mode 100644 src/main/java/universalelectricity/core/item/IItemElectric.java create mode 100644 src/main/java/universalelectricity/core/item/IItemElectricityStorage.java create mode 100644 src/main/java/universalelectricity/core/item/IItemVoltage.java create mode 100644 src/main/java/universalelectricity/core/item/ItemElectric.java create mode 100644 src/main/java/universalelectricity/core/path/IPathCallBack.java create mode 100644 src/main/java/universalelectricity/core/path/Pathfinder.java create mode 100644 src/main/java/universalelectricity/core/path/PathfinderAStar.java create mode 100644 src/main/java/universalelectricity/core/path/PathfinderChecker.java create mode 100644 src/main/java/universalelectricity/core/vector/Vector2.java create mode 100644 src/main/java/universalelectricity/core/vector/Vector3.java create mode 100644 src/main/java/universalelectricity/core/vector/VectorHelper.java create mode 100644 src/main/java/universalelectricity/prefab/CustomDamageSource.java create mode 100644 src/main/java/universalelectricity/prefab/GuiBase.java create mode 100644 src/main/java/universalelectricity/prefab/RecipeHelper.java create mode 100644 src/main/java/universalelectricity/prefab/SlotSpecific.java create mode 100644 src/main/java/universalelectricity/prefab/TranslationHelper.java create mode 100644 src/main/java/universalelectricity/prefab/block/BlockAdvanced.java create mode 100644 src/main/java/universalelectricity/prefab/block/BlockConductor.java create mode 100644 src/main/java/universalelectricity/prefab/block/BlockRotatable.java create mode 100644 src/main/java/universalelectricity/prefab/implement/IDisableable.java create mode 100644 src/main/java/universalelectricity/prefab/implement/IRedstoneProvider.java create mode 100644 src/main/java/universalelectricity/prefab/implement/IRedstoneReceptor.java create mode 100644 src/main/java/universalelectricity/prefab/implement/IRotatable.java create mode 100644 src/main/java/universalelectricity/prefab/implement/ITier.java create mode 100644 src/main/java/universalelectricity/prefab/implement/IToolConfigurator.java create mode 100644 src/main/java/universalelectricity/prefab/multiblock/BlockMulti.java create mode 100644 src/main/java/universalelectricity/prefab/multiblock/IBlockActivate.java create mode 100644 src/main/java/universalelectricity/prefab/multiblock/IMultiBlock.java create mode 100644 src/main/java/universalelectricity/prefab/multiblock/TileEntityMulti.java create mode 100644 src/main/java/universalelectricity/prefab/ore/OreGenBase.java create mode 100644 src/main/java/universalelectricity/prefab/ore/OreGenReplace.java create mode 100644 src/main/java/universalelectricity/prefab/ore/OreGenReplaceStone.java create mode 100644 src/main/java/universalelectricity/prefab/ore/OreGenerator.java create mode 100644 src/main/java/universalelectricity/prefab/potion/CustomPotion.java create mode 100644 src/main/java/universalelectricity/prefab/potion/CustomPotionEffect.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityAdvanced.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityConductor.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityDisableable.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityElectrical.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityElectricityRunnable.java create mode 100644 src/main/java/universalelectricity/prefab/tile/TileEntityElectricityStorage.java create mode 100644 src/main/java/universalelectricity/prefab/vector/Region2.java create mode 100644 src/main/java/universalelectricity/prefab/vector/Region3.java create mode 100644 src/main/resources/assets/basiccomponents/languages/de_DE.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/en_US.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/es_ES.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/it_IT.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/nl_NL.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/pl_PL.properties create mode 100644 src/main/resources/assets/basiccomponents/languages/zh_CN.properties create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/batteryBox.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/coalGenerator.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/copperWire.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/electricFurnace.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/machine.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/machine_input.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/machine_output.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/machine_side.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/oreCopper.png create mode 100644 src/main/resources/assets/basiccomponents/textures/blocks/oreTin.png create mode 100644 src/main/resources/assets/basiccomponents/textures/gui/battery_box.png create mode 100644 src/main/resources/assets/basiccomponents/textures/gui/coal_generator.png create mode 100644 src/main/resources/assets/basiccomponents/textures/gui/electric_furnace.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/battery.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/circuitAdvanced.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/circuitBasic.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/circuitElite.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/dustBronze.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/dustSteel.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/infiniteBattery.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/ingotBronze.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/ingotCopper.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/ingotSteel.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/ingotTin.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/motor.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateBronze.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateCopper.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateGold.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateIron.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateSteel.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/plateTin.png create mode 100644 src/main/resources/assets/basiccomponents/textures/items/wrench.png create mode 100644 src/main/resources/assets/basiccomponents/textures/models/copperWire.png diff --git a/.gitignore b/.gitignore index 8d16946..23c3dc7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ .gradle -.idea build run +bin +off diff --git a/build.gradle b/build.gradle index 7c2d31b..5b0dc6c 100644 --- a/build.gradle +++ b/build.gradle @@ -17,9 +17,9 @@ buildscript { apply plugin: 'forge' -version = "1.0" -group= "modgroup" -archivesBaseName = "modid" +version = "1.0.0-dirty" +group= "universalelectricity" +archivesBaseName = "basiccomponents" minecraft { version = "1.7.10-10.13.4.1614-1.7.10" diff --git a/gradlew b/gradlew old mode 100644 new mode 100755 diff --git a/src/main/java/basiccomponents/client/ModelCopperWire.java b/src/main/java/basiccomponents/client/ModelCopperWire.java new file mode 100644 index 0000000..58235f5 --- /dev/null +++ b/src/main/java/basiccomponents/client/ModelCopperWire.java @@ -0,0 +1,117 @@ +package basiccomponents.client; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.entity.Entity; + +@SideOnly(Side.CLIENT) +public class ModelCopperWire extends ModelBase { + + ModelRenderer Middle; + ModelRenderer Right; + ModelRenderer Left; + ModelRenderer Back; + ModelRenderer Front; + ModelRenderer Top; + ModelRenderer Bottom; + + + public ModelCopperWire() { + super.textureWidth = 64; + super.textureHeight = 32; + this.Middle = new ModelRenderer(this, 0, 0); + this.Middle.addBox(-1.0F, -1.0F, -1.0F, 4, 4, 4); + this.Middle.setRotationPoint(-1.0F, 15.0F, -1.0F); + this.Middle.setTextureSize(64, 32); + this.Middle.mirror = true; + this.setRotation(this.Middle, 0.0F, 0.0F, 0.0F); + this.Right = new ModelRenderer(this, 21, 0); + this.Right.addBox(0.0F, 0.0F, 0.0F, 6, 4, 4); + this.Right.setRotationPoint(2.0F, 14.0F, -2.0F); + this.Right.setTextureSize(64, 32); + this.Right.mirror = true; + this.setRotation(this.Right, 0.0F, 0.0F, 0.0F); + this.Left = new ModelRenderer(this, 21, 0); + this.Left.addBox(0.0F, 0.0F, 0.0F, 6, 4, 4); + this.Left.setRotationPoint(-8.0F, 14.0F, -2.0F); + this.Left.setTextureSize(64, 32); + this.Left.mirror = true; + this.setRotation(this.Left, 0.0F, 0.0F, 0.0F); + this.Back = new ModelRenderer(this, 0, 11); + this.Back.addBox(0.0F, 0.0F, 0.0F, 4, 4, 6); + this.Back.setRotationPoint(-2.0F, 14.0F, 2.0F); + this.Back.setTextureSize(64, 32); + this.Back.mirror = true; + this.setRotation(this.Back, 0.0F, 0.0F, 0.0F); + this.Front = new ModelRenderer(this, 0, 11); + this.Front.addBox(0.0F, 0.0F, 0.0F, 4, 4, 6); + this.Front.setRotationPoint(-2.0F, 14.0F, -8.0F); + this.Front.setTextureSize(64, 32); + this.Front.mirror = true; + this.setRotation(this.Front, 0.0F, 0.0F, 0.0F); + this.Top = new ModelRenderer(this, 21, 11); + this.Top.addBox(0.0F, 0.0F, 0.0F, 4, 6, 4); + this.Top.setRotationPoint(-2.0F, 8.0F, -2.0F); + this.Top.setTextureSize(64, 32); + this.Top.mirror = true; + this.setRotation(this.Top, 0.0F, 0.0F, 0.0F); + this.Bottom = new ModelRenderer(this, 21, 11); + this.Bottom.addBox(0.0F, 0.0F, 0.0F, 4, 6, 4); + this.Bottom.setRotationPoint(-2.0F, 18.0F, -2.0F); + this.Bottom.setTextureSize(64, 32); + this.Bottom.mirror = true; + this.setRotation(this.Bottom, 0.0F, 0.0F, 0.0F); + } + + public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) { + super.render(entity, f, f1, f2, f3, f4, f5); + this.setRotationAngles(f, f1, f2, f3, f4, f5, entity); + this.renderMiddle(); + this.renderBottom(); + this.renderTop(); + this.renderLeft(); + this.renderRight(); + this.renderBack(); + this.renderFront(); + } + + public void renderMiddle() { + this.Middle.render(0.0625F); + } + + public void renderBottom() { + this.Bottom.render(0.0625F); + } + + public void renderTop() { + this.Top.render(0.0625F); + } + + public void renderLeft() { + this.Left.render(0.0625F); + } + + public void renderRight() { + this.Right.render(0.0625F); + } + + public void renderBack() { + this.Back.render(0.0625F); + } + + public void renderFront() { + this.Front.render(0.0625F); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } + + public void setRotationAngles(float x, float y, float z, float f3, float f4, float f5, Entity entity) { + super.setRotationAngles(x, y, z, f3, f4, f5, entity); + } +} diff --git a/src/main/java/basiccomponents/client/RenderCopperWire.java b/src/main/java/basiccomponents/client/RenderCopperWire.java new file mode 100644 index 0000000..a1a314d --- /dev/null +++ b/src/main/java/basiccomponents/client/RenderCopperWire.java @@ -0,0 +1,57 @@ +package basiccomponents.client; + +import basiccomponents.client.ModelCopperWire; +import basiccomponents.common.tileentity.TileEntityCopperWire; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.ResourceLocation; + +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public class RenderCopperWire extends TileEntitySpecialRenderer { + + public static final ModelCopperWire model = new ModelCopperWire(); + + + public void renderModelAt(TileEntityCopperWire tileEntity, double d, double d1, double d2, float f) { + this.bindTexture(new ResourceLocation("basiccomponents", "textures/models/copperWire.png")); + GL11.glPushMatrix(); + GL11.glTranslatef((float)d + 0.5F, (float)d1 + 1.5F, (float)d2 + 0.5F); + GL11.glScalef(1.0F, -1.0F, -1.0F); + if(tileEntity.visuallyConnected[0]) { + model.renderBottom(); + } + + if(tileEntity.visuallyConnected[1]) { + model.renderTop(); + } + + if(tileEntity.visuallyConnected[2]) { + model.renderBack(); + } + + if(tileEntity.visuallyConnected[3]) { + model.renderFront(); + } + + if(tileEntity.visuallyConnected[4]) { + model.renderLeft(); + } + + if(tileEntity.visuallyConnected[5]) { + model.renderRight(); + } + + model.renderMiddle(); + GL11.glPopMatrix(); + } + + @Override + public void renderTileEntityAt(TileEntity tileEntity, double var2, double var4, double var6, float var8) { + this.renderModelAt((TileEntityCopperWire)tileEntity, var2, var4, var6, var8); + } + +} diff --git a/src/main/java/basiccomponents/client/gui/GuiBatteryBox.java b/src/main/java/basiccomponents/client/gui/GuiBatteryBox.java new file mode 100644 index 0000000..e5bc2ad --- /dev/null +++ b/src/main/java/basiccomponents/client/gui/GuiBatteryBox.java @@ -0,0 +1,52 @@ +package basiccomponents.client.gui; + +import basiccomponents.common.container.ContainerBatteryBox; +import basiccomponents.common.tileentity.TileEntityBatteryBox; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.electricity.ElectricityDisplay; + +@SideOnly(Side.CLIENT) +public class GuiBatteryBox extends GuiContainer { + + private TileEntityBatteryBox tileEntity; + private int containerWidth; + private int containerHeight; + + + public GuiBatteryBox(InventoryPlayer par1InventoryPlayer, TileEntityBatteryBox batteryBox) { + super(new ContainerBatteryBox(par1InventoryPlayer, batteryBox)); + this.tileEntity = batteryBox; + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 65, 6, 4210752); + String displayJoules = ElectricityDisplay.getDisplayShort(this.tileEntity.getJoules(), ElectricityDisplay.ElectricUnit.JOULES); + String displayMaxJoules = ElectricityDisplay.getDisplay(this.tileEntity.getMaxJoules(), ElectricityDisplay.ElectricUnit.JOULES); + if(this.tileEntity.isDisabled()) { + displayMaxJoules = "Disabled"; + } + + this.fontRendererObj.drawString(displayJoules + " of", 98 - displayJoules.length(), 30, 4210752); + this.fontRendererObj.drawString(displayMaxJoules, 78, 40, 4210752); + this.fontRendererObj.drawString("Voltage: " + (int)this.tileEntity.getVoltage(), 90, 60, 4210752); + this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + this.mc.renderEngine.bindTexture(new ResourceLocation("basiccomponents", "textures/gui/battery_box.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, this.xSize, this.ySize); + int scale = (int)(this.tileEntity.getJoules() / this.tileEntity.getMaxJoules() * 72.0D); + this.drawTexturedModalRect(this.containerWidth + 87, this.containerHeight + 52, 176, 0, scale, 20); + } +} diff --git a/src/main/java/basiccomponents/client/gui/GuiCoalGenerator.java b/src/main/java/basiccomponents/client/gui/GuiCoalGenerator.java new file mode 100644 index 0000000..41d179c --- /dev/null +++ b/src/main/java/basiccomponents/client/gui/GuiCoalGenerator.java @@ -0,0 +1,55 @@ +package basiccomponents.client.gui; + +import basiccomponents.common.container.ContainerCoalGenerator; +import basiccomponents.common.tileentity.TileEntityCoalGenerator; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.electricity.ElectricityDisplay; + +@SideOnly(Side.CLIENT) +public class GuiCoalGenerator extends GuiContainer { + + private TileEntityCoalGenerator tileEntity; + private int containerWidth; + private int containerHeight; + + + public GuiCoalGenerator(InventoryPlayer par1InventoryPlayer, TileEntityCoalGenerator tileEntity) { + super(new ContainerCoalGenerator(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 55, 6, 4210752); + this.fontRendererObj.drawString("Generating", 90, 33, 4210752); + String displayText = ""; + if(this.tileEntity.isDisabled()) { + displayText = "Disabled"; + } else if(this.tileEntity.generateWatts <= 0.0D) { + displayText = "Not Generating"; + } else if(this.tileEntity.generateWatts < 100.0D) { + displayText = "Hull Heat: " + (int)(this.tileEntity.generateWatts / 100.0D * 100.0D) + "%"; + } else { + displayText = ElectricityDisplay.getDisplay(this.tileEntity.generateWatts, ElectricityDisplay.ElectricUnit.WATT); + } + + this.fontRendererObj.drawString(displayText, (int)(100.0D - (double)displayText.length() * 1.25D), 45, 4210752); + this.fontRendererObj.drawString("Voltage: " + (int)this.tileEntity.getVoltage(), 85, 60, 4210752); + this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + this.mc.renderEngine.bindTexture(new ResourceLocation("basiccomponents", "textures/gui/coal_generator.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, this.xSize, this.ySize); + } +} diff --git a/src/main/java/basiccomponents/client/gui/GuiElectricFurnace.java b/src/main/java/basiccomponents/client/gui/GuiElectricFurnace.java new file mode 100644 index 0000000..31a18da --- /dev/null +++ b/src/main/java/basiccomponents/client/gui/GuiElectricFurnace.java @@ -0,0 +1,60 @@ +package basiccomponents.client.gui; + +import basiccomponents.common.container.ContainerElectricFurnace; +import basiccomponents.common.tileentity.TileEntityElectricFurnace; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import org.lwjgl.opengl.GL11; +import universalelectricity.core.electricity.ElectricityDisplay; + +@SideOnly(Side.CLIENT) +public class GuiElectricFurnace extends GuiContainer { + + private TileEntityElectricFurnace tileEntity; + private int containerWidth; + private int containerHeight; + + + public GuiElectricFurnace(InventoryPlayer par1InventoryPlayer, TileEntityElectricFurnace tileEntity) { + super(new ContainerElectricFurnace(par1InventoryPlayer, tileEntity)); + this.tileEntity = tileEntity; + } + + @Override + protected void drawGuiContainerForegroundLayer(int par1, int par2) { + this.fontRendererObj.drawString(this.tileEntity.getInventoryName(), 45, 6, 4210752); + this.fontRendererObj.drawString("Smelting:", 10, 28, 4210752); + this.fontRendererObj.drawString("Battery:", 10, 53, 4210752); + String displayText = ""; + if(this.tileEntity.isDisabled()) { + displayText = "Disabled!"; + } else if(this.tileEntity.processTicks > 0) { + displayText = "Smelting"; + } else { + displayText = "Idle"; + } + + this.fontRendererObj.drawString("Status: " + displayText, 82, 45, 4210752); + this.fontRendererObj.drawString(ElectricityDisplay.getDisplay(10000.0D, ElectricityDisplay.ElectricUnit.WATT), 82, 56, 4210752); + this.fontRendererObj.drawString(ElectricityDisplay.getDisplay(this.tileEntity.getVoltage(), ElectricityDisplay.ElectricUnit.VOLTAGE), 82, 68, 4210752); + this.fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 8, this.ySize - 96 + 2, 4210752); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float par1, int par2, int par3) { + this.mc.renderEngine.bindTexture(new ResourceLocation("basiccomponents", "textures/gui/electric_furnace.png")); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.containerWidth = (this.width - this.xSize) / 2; + this.containerHeight = (this.height - this.ySize) / 2; + this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, this.xSize, this.ySize); + if(this.tileEntity.processTicks > 0) { + int scale = (int)((double)this.tileEntity.processTicks / 130.0D * 23.0D); + this.drawTexturedModalRect(this.containerWidth + 77, this.containerHeight + 24, 176, 0, 23 - scale, 20); + } + + } +} diff --git a/src/main/java/basiccomponents/common/BCGuiHandler.java b/src/main/java/basiccomponents/common/BCGuiHandler.java new file mode 100644 index 0000000..f462a4e --- /dev/null +++ b/src/main/java/basiccomponents/common/BCGuiHandler.java @@ -0,0 +1,57 @@ +package basiccomponents.common; + +import basiccomponents.client.gui.GuiBatteryBox; +import basiccomponents.client.gui.GuiCoalGenerator; +import basiccomponents.client.gui.GuiElectricFurnace; +import basiccomponents.common.container.ContainerBatteryBox; +import basiccomponents.common.container.ContainerCoalGenerator; +import basiccomponents.common.container.ContainerElectricFurnace; +import basiccomponents.common.tileentity.TileEntityBatteryBox; +import basiccomponents.common.tileentity.TileEntityCoalGenerator; +import basiccomponents.common.tileentity.TileEntityElectricFurnace; +import cpw.mods.fml.common.network.IGuiHandler; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class BCGuiHandler implements IGuiHandler { + + public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity != null) { + if(tileEntity instanceof TileEntityBatteryBox) { + return new GuiBatteryBox(player.inventory, (TileEntityBatteryBox)tileEntity); + } + + if(tileEntity instanceof TileEntityCoalGenerator) { + return new GuiCoalGenerator(player.inventory, (TileEntityCoalGenerator)tileEntity); + } + + if(tileEntity instanceof TileEntityElectricFurnace) { + return new GuiElectricFurnace(player.inventory, (TileEntityElectricFurnace)tileEntity); + } + } + + return null; + } + + public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + System.out.println("Open GUI"); + if(tileEntity != null) { + if(tileEntity instanceof TileEntityBatteryBox) { + return new ContainerBatteryBox(player.inventory, (TileEntityBatteryBox)tileEntity); + } + + if(tileEntity instanceof TileEntityCoalGenerator) { + return new ContainerCoalGenerator(player.inventory, (TileEntityCoalGenerator)tileEntity); + } + + if(tileEntity instanceof TileEntityElectricFurnace) { + return new ContainerElectricFurnace(player.inventory, (TileEntityElectricFurnace)tileEntity); + } + } + + return null; + } +} diff --git a/src/main/java/basiccomponents/common/BasicComponents.java b/src/main/java/basiccomponents/common/BasicComponents.java new file mode 100644 index 0000000..97b0468 --- /dev/null +++ b/src/main/java/basiccomponents/common/BasicComponents.java @@ -0,0 +1,328 @@ +package basiccomponents.common; + +import basiccomponents.client.RenderCopperWire; +import basiccomponents.common.BCGuiHandler; +import basiccomponents.common.CommonProxy; +import basiccomponents.common.block.BlockBase; +import basiccomponents.common.block.BlockBasicMachine; +import basiccomponents.common.block.BlockCopperWire; +import basiccomponents.common.item.ItemBase; +import basiccomponents.common.item.ItemBattery; +import basiccomponents.common.item.ItemBlockBasicMachine; +import basiccomponents.common.item.ItemBlockCopperWire; +import basiccomponents.common.item.ItemInfiniteBattery; +import basiccomponents.common.item.ItemIngot; +import basiccomponents.common.item.ItemPlate; +import basiccomponents.common.item.ItemWrench; +import basiccomponents.common.tileentity.TileEntityBatteryBox; +import basiccomponents.common.tileentity.TileEntityCoalGenerator; +import basiccomponents.common.tileentity.TileEntityCopperWire; +import basiccomponents.common.tileentity.TileEntityElectricFurnace; +import cpw.mods.fml.client.registry.ClientRegistry; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.network.NetworkRegistry; +import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper; +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.ReflectionHelper; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.io.File; +import java.lang.reflect.Field; +import java.util.ArrayList; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.oredict.OreDictionary; +import net.minecraftforge.oredict.ShapedOreRecipe; +import net.minecraftforge.oredict.ShapelessOreRecipe; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.prefab.RecipeHelper; +import universalelectricity.prefab.TranslationHelper; +import universalelectricity.prefab.ore.OreGenBase; +import universalelectricity.prefab.ore.OreGenReplaceStone; +import universalelectricity.prefab.ore.OreGenerator; + +@Mod(modid = BasicComponents.MODID, name = BasicComponents.NAME, version = BasicComponents.VERSION) +public class BasicComponents { + + public static final String NAME = "Basic Components"; + public static final String MODID = "basiccomponents"; + public static final String VERSION = "1.0.0-dirty"; + public static String CHANNEL = ""; + public static final String RESOURCE_PATH = "/mods/basiccomponents/"; + public static CommonProxy proxy; + public static final Configuration CONFIGURATION = new Configuration(new File(Loader.instance().getConfigDir(), "BasicComponents.cfg")); + public static final String TEXTURE_DIRECTORY = "/mods/basiccomponents/textures/"; + public static final String GUI_DIRECTORY = "/mods/basiccomponents/textures/gui/"; + public static final String BLOCK_TEXTURE_DIRECTORY = "/mods/basiccomponents/textures/blocks/"; + public static final String ITEM_TEXTURE_DIRECTORY = "/mods/basiccomponents/textures/items/"; + public static final String MODEL_TEXTURE_DIRECTORY = "/mods/basiccomponents/textures/models/"; + public static final String TEXTURE_NAME_PREFIX = "basiccomponents:"; + public static final String LANGUAGE_PATH = "/mods/basiccomponents/languages/"; + private static final String[] LANGUAGES_SUPPORTED = new String[]{"en_US", "zh_CN", "es_ES", "it_IT", "nl_NL", "de_DE"}; + public static Block blockOreCopper; + public static Block blockOreTin; + public static Block blockCopperWire; + public static Block blockMachine; + public static Item itemBattery; + public static Item itemInfiniteBattery; + public static Item itemWrench; + public static Item itemMotor; + public static Item itemCircuitBasic; + public static Item itemCircuitAdvanced; + public static Item itemCircuitElite; + public static Item itemPlateCopper; + public static Item itemPlateTin; + public static Item itemPlateBronze; + public static Item itemPlateSteel; + public static Item itemPlateIron; + public static Item itemPlateGold; + public static Item itemIngotCopper; + public static Item itemIngotTin; + public static Item itemIngotSteel; + public static Item itemIngotBronze; + public static Item itemDustSteel; + public static Item itemDustBronze; + public static OreGenBase generationOreCopper; + public static OreGenBase generationOreTin; + public static final ArrayList bcDependants = new ArrayList(); + public static SimpleNetworkWrapper NETWRAPPER = NetworkRegistry.INSTANCE.newSimpleChannel("basiccomponents"); + @Mod.Instance + public static BasicComponents INSTANCE; + + @Mod.EventHandler + public void preInit(FMLPreInitializationEvent e) { + + } + + @Mod.EventHandler + public void init(FMLInitializationEvent e) { + System.out.println("Basic Components Loaded: " + TranslationHelper.loadLanguages("/assets/basiccomponents/languages/", LANGUAGES_SUPPORTED) + " Languages."); + NetworkRegistry.INSTANCE.registerGuiHandler(INSTANCE, new BCGuiHandler()); + CONFIGURATION.load(); + registerIngots(); + registerPlates(); + registerDusts(); + + registerBattery(); + registerWrench(); + + registerTileEntities(); + registerOres(); + registerCopperWire(); + registerCircuits(); + registerMachines(); + CONFIGURATION.save(); + } + + @Mod.EventHandler + public void postInit(FMLPostInitializationEvent e) { + + } + + public static void registerDusts() { + if (OreDictionary.getOres("dustBronze").isEmpty()) { + itemDustBronze = new ItemBase("dustBronze"); + itemDustBronze.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemDustBronze, "dustBronze"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemDustBronze), new Object[]{"!#!", Character.valueOf('!'), "ingotCopper", Character.valueOf('#'), "ingotTin"}), CONFIGURATION, true); + GameRegistry.addSmelting(itemDustBronze, (ItemStack)OreDictionary.getOres("ingotBronze").get(0), 0.6F); + } + if (OreDictionary.getOres("dustSteel").isEmpty()) { + itemDustSteel = new ItemBase("dustSteel"); + itemDustSteel.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemDustSteel, "dustSteel"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemDustSteel), new Object[]{" C ", "CIC", " C ", Character.valueOf('I'), Items.iron_ingot, Character.valueOf('C'), Items.coal}), CONFIGURATION, true); + GameRegistry.addSmelting(itemDustSteel, (ItemStack)OreDictionary.getOres("ingotSteel").get(0), 0.6F); + } + } + + public static void registerPlates() { + if (OreDictionary.getOres("plateCopper").isEmpty()) { + itemPlateCopper = new ItemPlate("plateCopper"); + GameRegistry.registerItem(itemPlateCopper, "plateCopper"); + OreDictionary.registerOre("plateCopper", itemPlateCopper); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateCopper), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotCopper"}), CONFIGURATION, true); + } + if (OreDictionary.getOres("plateTin").isEmpty()) { + itemPlateTin = new ItemPlate("plateTin"); + GameRegistry.registerItem(itemPlateTin, "plateTin"); + OreDictionary.registerOre("plateTin", itemPlateTin); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateTin), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotTin"}), CONFIGURATION, true); + } + if (OreDictionary.getOres("plateIron").isEmpty()) { + itemPlateIron = new ItemPlate("plateIron"); + GameRegistry.registerItem(itemPlateIron, "plateIron"); + OreDictionary.registerOre("plateIron", itemPlateIron); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateIron), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotIron"}), CONFIGURATION, true); + } + if (OreDictionary.getOres("plateGold").isEmpty()) { + itemPlateGold = new ItemPlate("plateGold"); + GameRegistry.registerItem(itemPlateGold, "plateGold"); + OreDictionary.registerOre("plateGold", itemPlateGold); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateGold), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotGold"}), CONFIGURATION, true); + } + if (OreDictionary.getOres("plateBronze").isEmpty()) { + itemPlateBronze = new ItemPlate("plateBronze"); + GameRegistry.registerItem(itemPlateBronze, "plateBronze"); + OreDictionary.registerOre("plateBronze", itemPlateBronze); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateBronze), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotBronze"}), CONFIGURATION, true); + } + if (OreDictionary.getOres("plateSteel").isEmpty()) { + itemPlateSteel = new ItemPlate("plateSteel"); + GameRegistry.registerItem(itemPlateSteel, "plateSteel"); + OreDictionary.registerOre("plateSteel", itemPlateSteel); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemPlateSteel), new Object[]{"!!", "!!", Character.valueOf('!'), "ingotSteel"}), CONFIGURATION, true); + } + } + + public static void registerIngots() { + if (OreDictionary.getOres("ingotCopper").isEmpty()) { + itemIngotCopper = new ItemIngot("ingotCopper"); + GameRegistry.registerItem(itemIngotCopper, "ingotCopper"); + OreDictionary.registerOre("ingotCopper", itemIngotCopper); + } + if (OreDictionary.getOres("ingotTin").isEmpty()) { + itemIngotTin = new ItemIngot("ingotTin"); + GameRegistry.registerItem(itemIngotTin, "ingotTin"); + OreDictionary.registerOre("ingotTin", itemIngotTin); + } + if (OreDictionary.getOres("ingotBronze").isEmpty()) { + itemIngotBronze = new ItemIngot("ingotBronze"); + GameRegistry.registerItem(itemIngotBronze, "ingotBronze"); + OreDictionary.registerOre("ingotBronze", itemIngotBronze); + } + if (OreDictionary.getOres("ingotSteel").isEmpty()) { + itemIngotSteel = new ItemIngot("ingotSteel"); + GameRegistry.registerItem(itemIngotSteel, "ingotSteel"); + OreDictionary.registerOre("ingotSteel", itemIngotSteel); + } + } + + public static void registerCircuits() { + itemCircuitBasic = new ItemBase("circuitBasic"); + itemCircuitBasic.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemCircuitBasic, "circuitBasic"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemCircuitBasic), new Object[]{"!#!", "#@#", "!#!", Character.valueOf('@'), "plateBronze", Character.valueOf('#'), Items.redstone, Character.valueOf('!'), "copperWire"}), CONFIGURATION, true); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemCircuitBasic), new Object[]{"!#!", "#@#", "!#!", Character.valueOf('@'), "plateSteel", Character.valueOf('#'), Items.redstone, Character.valueOf('!'), "copperWire"}), CONFIGURATION, true); + OreDictionary.registerOre("circuitBasic", itemCircuitBasic); + itemCircuitAdvanced = new ItemBase("circuitAdvanced"); + itemCircuitAdvanced.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemCircuitAdvanced, "circuitAdvanced"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemCircuitAdvanced), new Object[]{"@@@", "#?#", "@@@", Character.valueOf('@'), Items.redstone, Character.valueOf('?'), Items.diamond, Character.valueOf('#'), "circuitBasic"}), CONFIGURATION, true); + OreDictionary.registerOre("circuitAdvanced", itemCircuitAdvanced); + itemCircuitElite = new ItemBase("circuitElite"); + itemCircuitElite.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemCircuitElite, "circuitElite"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemCircuitAdvanced), new Object[]{"@@@", "?#?", "@@@", Character.valueOf('@'), Items.gold_ingot, Character.valueOf('?'), "circuitAdvanced", Character.valueOf('#'), Blocks.lapis_block}), CONFIGURATION, true); + OreDictionary.registerOre("circuitElite", itemCircuitElite); + itemMotor = new ItemBase("motor"); + itemMotor.setCreativeTab(CreativeTabs.tabMaterials); + GameRegistry.registerItem(itemMotor, "motor"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemMotor), new Object[]{"@!@", "!#!", "@!@", Character.valueOf('!'), "ingotSteel", Character.valueOf('#'), Items.iron_ingot, Character.valueOf('@'), "copperWire"}), CONFIGURATION, true); + OreDictionary.registerOre("motor", itemMotor); + } + + public static void registerWrench() { + itemWrench = new ItemWrench(); + GameRegistry.registerItem(itemWrench, "wrench"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemWrench), new Object[]{" S ", " SS", "S ", Character.valueOf('S'), Items.iron_ingot}), CONFIGURATION, true); + } + + public static void registerBattery() { + itemInfiniteBattery = new ItemInfiniteBattery("infiniteBattery"); + GameRegistry.registerItem(itemInfiniteBattery, "infiniteBattery"); + itemBattery = new ItemBattery("battery"); + GameRegistry.registerItem(itemBattery, "battery"); + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(itemBattery), new Object[]{" T ", "TRT", "TCT", Character.valueOf('T'), "ingotTin", Character.valueOf('R'), Items.redstone, Character.valueOf('C'), Items.coal}), CONFIGURATION, true); + OreDictionary.registerOre("battery", ElectricItemHelper.getUncharged(itemBattery)); + + } + + public static void registerOres() { + for (ItemStack stack : OreDictionary.getOres("oreCopper")) { + if (stack.getItem() instanceof ItemBlock) { + blockOreCopper = Block.getBlockFromItem(stack.getItem()); + break; + } + } + for (ItemStack stack : OreDictionary.getOres("oreTin")) { + if (stack.getItem() instanceof ItemBlock) { + blockOreTin = Block.getBlockFromItem(stack.getItem()); + break; + } + } + if (blockOreCopper == null) { + blockOreCopper = new BlockBase("oreCopper"); + GameRegistry.registerBlock(blockOreCopper, "oreCopper"); + GameRegistry.addSmelting(blockOreCopper, OreDictionary.getOres("ingotCopper").get(0), 0.6F); + generationOreCopper = new OreGenReplaceStone("oreCopper", "oreCopper", new ItemStack(blockOreCopper), 60, 22, 4); + OreGenerator.addOre(generationOreCopper); + } + if (blockOreTin == null) { + blockOreTin = new BlockBase("oreTin"); + GameRegistry.registerBlock(blockOreTin, "oreTin"); + GameRegistry.addSmelting(blockOreTin, OreDictionary.getOres("ingotTin").get(0), 0.6F); + generationOreTin = new OreGenReplaceStone("oreTin", "oreTin", new ItemStack(blockOreTin), 60, 22, 4); + OreGenerator.addOre(generationOreTin); + } + } + + public static void registerCopperWire() { + blockCopperWire = new BlockCopperWire(); + GameRegistry.registerBlock(blockCopperWire, ItemBlockCopperWire.class, "copperWire"); + if(FMLCommonHandler.instance().getEffectiveSide() == Side.CLIENT) { + try { + registerCopperWireRenderer(); + } catch (Exception var8) { + FMLLog.severe("Basic Components copper wire registry error!", new Object[0]); + var8.printStackTrace(); + } + } + RecipeHelper.addRecipe(new ShapedOreRecipe(new ItemStack(blockCopperWire, 6), new Object[]{"WWW", "CCC", "WWW", Character.valueOf('W'), Blocks.wool, Character.valueOf('C'), "ingotCopper"}), CONFIGURATION, true); + UniversalElectricity.isNetworkActive = true; + OreDictionary.registerOre("copperWire", blockCopperWire); + } + + @SideOnly(Side.CLIENT) + private static void registerCopperWireRenderer() throws Exception { + ClientRegistry.bindTileEntitySpecialRenderer(TileEntityCopperWire.class, new RenderCopperWire()); + } + + public static ItemStack registerMachines() { + blockMachine = new BlockBasicMachine(0); + GameRegistry.registerBlock(blockMachine, ItemBlockBasicMachine.class, "basicMachine"); + ItemStack generator = ((BlockBasicMachine)blockMachine).getCoalGenerator(); + ItemStack bbox = ((BlockBasicMachine)blockMachine).getBatteryBox(); + ItemStack efurnace = ((BlockBasicMachine)blockMachine).getElectricFurnace(); + OreDictionary.registerOre("coalGenerator", generator.copy()); + OreDictionary.registerOre("batteryBox", bbox.copy()); + OreDictionary.registerOre("electricFurnace", efurnace.copy()); + RecipeHelper.addRecipe(new ShapedOreRecipe(bbox.copy(), new Object[]{"SSS", "BBB", "SSS", Character.valueOf('B'), "battery", Character.valueOf('S'), "ingotSteel"}), CONFIGURATION, true); + RecipeHelper.addRecipe(new ShapedOreRecipe(generator.copy(), new Object[]{"MMM", "MOM", "MCM", Character.valueOf('M'), "ingotSteel", Character.valueOf('C'), "motor", Character.valueOf('O'), Blocks.furnace}), CONFIGURATION, true); + RecipeHelper.addRecipe(new ShapedOreRecipe(generator.copy(), new Object[]{"MMM", "MOM", "MCM", Character.valueOf('M'), "ingotBronze", Character.valueOf('C'), "motor", Character.valueOf('O'), Blocks.furnace}), CONFIGURATION, true); + RecipeHelper.addRecipe(new ShapedOreRecipe(efurnace.copy(), new Object[]{"SSS", "SCS", "SMS", Character.valueOf('S'), "ingotSteel", Character.valueOf('C'), "circuitAdvanced", Character.valueOf('M'), "motor"}), CONFIGURATION, true); + + return new ItemStack(blockMachine); + } + + public static void registerTileEntities() { + GameRegistry.registerTileEntity(TileEntityBatteryBox.class, "UEBatteryBox"); + GameRegistry.registerTileEntity(TileEntityCoalGenerator.class, "UECoalGenerator"); + GameRegistry.registerTileEntity(TileEntityElectricFurnace.class, "UEElectricFurnace"); + GameRegistry.registerTileEntity(TileEntityCopperWire.class, "copperWire"); + } + +} diff --git a/src/main/java/basiccomponents/common/CommonProxy.java b/src/main/java/basiccomponents/common/CommonProxy.java new file mode 100644 index 0000000..9b46b83 --- /dev/null +++ b/src/main/java/basiccomponents/common/CommonProxy.java @@ -0,0 +1,11 @@ +package basiccomponents.common; + +import basiccomponents.common.tileentity.TileEntityCopperWire; +import cpw.mods.fml.common.registry.GameRegistry; + +public class CommonProxy { + + public void registerCopperWireTileEntity() { + GameRegistry.registerTileEntity(TileEntityCopperWire.class, "copperWire"); + } +} diff --git a/src/main/java/basiccomponents/common/block/BlockBase.java b/src/main/java/basiccomponents/common/block/BlockBase.java new file mode 100644 index 0000000..13e984c --- /dev/null +++ b/src/main/java/basiccomponents/common/block/BlockBase.java @@ -0,0 +1,17 @@ +package basiccomponents.common.block; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +public class BlockBase extends Block { + + public BlockBase(String name) { + super(Material.rock); + this.setCreativeTab(CreativeTabs.tabBlock); + this.setBlockName("basiccomponents:" + name); + this.setHardness(2.0F); + this.setBlockTextureName("basiccomponents:" + name); + + } +} diff --git a/src/main/java/basiccomponents/common/block/BlockBasicMachine.java b/src/main/java/basiccomponents/common/block/BlockBasicMachine.java new file mode 100644 index 0000000..b7ff418 --- /dev/null +++ b/src/main/java/basiccomponents/common/block/BlockBasicMachine.java @@ -0,0 +1,288 @@ +package basiccomponents.common.block; + +import basiccomponents.common.BasicComponents; +import basiccomponents.common.tileentity.TileEntityBatteryBox; +import basiccomponents.common.tileentity.TileEntityCoalGenerator; +import basiccomponents.common.tileentity.TileEntityElectricFurnace; +import java.util.List; +import java.util.Random; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.prefab.block.BlockAdvanced; + +public class BlockBasicMachine extends BlockAdvanced { + + public static final int COAL_GENERATOR_METADATA = 0; + public static final int BATTERY_BOX_METADATA = 4; + public static final int ELECTRIC_FURNACE_METADATA = 8; + private IIcon iconMachineSide; + private IIcon iconInput; + private IIcon iconOutput; + private IIcon iconCoalGenerator; + private IIcon iconBatteryBox; + private IIcon iconElectricFurnace; + + + public BlockBasicMachine(int textureIndex) { + super(UniversalElectricity.machine); + this.setBlockName("basiccomponents:bcMachine"); + this.setCreativeTab(CreativeTabs.tabDecorations); + this.setStepSound(soundTypeMetal); //TODO Metal Footstep + } + + @Override + public void registerBlockIcons(IIconRegister par1IconRegister) { + this.blockIcon = par1IconRegister.registerIcon("basiccomponents:machine"); + this.iconInput = par1IconRegister.registerIcon("basiccomponents:machine_input"); + this.iconOutput = par1IconRegister.registerIcon("basiccomponents:machine_output"); + this.iconMachineSide = par1IconRegister.registerIcon("basiccomponents:machine_side"); + this.iconCoalGenerator = par1IconRegister.registerIcon("basiccomponents:coalGenerator"); + this.iconBatteryBox = par1IconRegister.registerIcon("basiccomponents:batteryBox"); + this.iconElectricFurnace = par1IconRegister.registerIcon("basiccomponents:electricFurnace"); + } + + @Override + public void randomDisplayTick(World par1World, int x, int y, int z, Random par5Random) { + TileEntity tile = par1World.getTileEntity(x, y, z); + if(tile instanceof TileEntityCoalGenerator) { + TileEntityCoalGenerator tileEntity = (TileEntityCoalGenerator)tile; + if(tileEntity.generateWatts > 0.0D) { + int metadata = par1World.getBlockMetadata(x, y, z); + float var7 = (float)x + 0.5F; + float var8 = (float)y + 0.0F + par5Random.nextFloat() * 6.0F / 16.0F; + float var9 = (float)z + 0.5F; + float var10 = 0.52F; + float var11 = par5Random.nextFloat() * 0.6F - 0.3F; + if(metadata == 3) { + par1World.spawnParticle("smoke", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 - var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + } else if(metadata == 2) { + par1World.spawnParticle("smoke", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var10), (double)var8, (double)(var9 + var11), 0.0D, 0.0D, 0.0D); + } else if(metadata == 1) { + par1World.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 - var10), 0.0D, 0.0D, 0.0D); + } else if(metadata == 0) { + par1World.spawnParticle("smoke", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D); + par1World.spawnParticle("flame", (double)(var7 + var11), (double)var8, (double)(var9 + var10), 0.0D, 0.0D, 0.0D); + } + } + } + + } + + @Override + public IIcon getIcon(int side, int metadata) { + if(side != 0 && side != 1) { + if(metadata >= 8) { + metadata -= 8; + if(side == metadata + 2) { + return this.iconInput; + } + + if(side == ForgeDirection.getOrientation(metadata + 2).getOpposite().ordinal()) { + return this.iconElectricFurnace; + } + } else { + if(metadata >= 4) { + metadata -= 4; + if(side == metadata + 2) { + return this.iconOutput; + } + + if(side == ForgeDirection.getOrientation(metadata + 2).getOpposite().ordinal()) { + return this.iconInput; + } + + return this.iconBatteryBox; + } + + if(side == metadata + 2) { + return this.iconOutput; + } + + if(side == ForgeDirection.getOrientation(metadata + 2).getOpposite().ordinal()) { + return this.iconCoalGenerator; + } + } + + return this.iconMachineSide; + } else { + return this.blockIcon; + } + } + + @Override + public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLiving, ItemStack itemStack) { + int metadata = world.getBlockMetadata(x, y, z); + int angle = MathHelper.floor_double((double)(entityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3; + byte change = 0; + switch(angle) { + case 0: + change = 1; + break; + case 1: + change = 2; + break; + case 2: + change = 0; + break; + case 3: + change = 3; + } + + if(metadata >= 8) { + world.setBlockMetadataWithNotify(x, y, z, 8 + change, 3); + } else if(metadata >= 4) { + switch(angle) { + case 0: + change = 3; + break; + case 1: + change = 1; + break; + case 2: + change = 2; + break; + case 3: + change = 0; + } + + world.setBlockMetadataWithNotify(x, y, z, 4 + change, 3); + } else { + world.setBlockMetadataWithNotify(x, y, z, 0 + change, 3); + } + + } + + public boolean onUseWrench(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + int metadata = par1World.getBlockMetadata(x, y, z); + int original = metadata; + int change = 0; + if(metadata >= 8) { + original = metadata - 8; + } else if(metadata >= 4) { + original = metadata - 4; + } + + switch(original) { + case 0: + change = 3; + break; + case 1: + change = 2; + break; + case 2: + change = 0; + break; + case 3: + change = 1; + } + + if(metadata >= 8) { + change += 8; + } else if(metadata >= 4) { + change += 4; + } + + par1World.setBlockMetadataWithNotify(x, y, z, change, 3); + return true; + } + + public boolean onMachineActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + int metadata = par1World.getBlockMetadata(x, y, z); + if(!par1World.isRemote) { + if(metadata >= 8) { + par5EntityPlayer.openGui(BasicComponents.INSTANCE, -1, par1World, x, y, z); + return true; + } else if(metadata >= 4) { + par5EntityPlayer.openGui(BasicComponents.INSTANCE, -1, par1World, x, y, z); + return true; + } else { + par5EntityPlayer.openGui(BasicComponents.INSTANCE, -1, par1World, x, y, z); + return true; + } + } else { + return true; + } + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public TileEntity createNewTileEntity(World world, int metadata) { + System.out.println("Create TE"); + return (TileEntity)(metadata >= 8?new TileEntityElectricFurnace():(metadata >= 4?new TileEntityBatteryBox():new TileEntityCoalGenerator())); + } + + @Override + public TileEntity createTileEntity(World var1, int meta) { + return createNewTileEntity(var1, meta); + } + + @Override + public boolean hasTileEntity(int metadata) { + return true; + } + + public ItemStack getCoalGenerator() { + return new ItemStack(Item.getItemFromBlock(this), 1, 0); + } + + public ItemStack getBatteryBox() { + return new ItemStack(Item.getItemFromBlock(this), 1, 4); + } + + public ItemStack getElectricFurnace() { + return new ItemStack(Item.getItemFromBlock(this), 1, 8); + } + + @Override + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + par3List.add(this.getCoalGenerator()); + par3List.add(this.getBatteryBox()); + par3List.add(this.getElectricFurnace()); + } + + @Override + public int damageDropped(int metadata) { + return metadata >= 8?8:(metadata >= 4?4:0); + } + + //TODO WTF + /*@Override + public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) { + int id = this.func_71922_a(world, x, y, z); + if(id == 0) { + return null; + } else { + Item item = Item.field_77698_e[id]; + if(item == null) { + return null; + } else { + int metadata = this.func_71873_h(world, x, y, z); + return new ItemStack(id, 1, metadata); + } + } + }*/ +} diff --git a/src/main/java/basiccomponents/common/block/BlockCopperWire.java b/src/main/java/basiccomponents/common/block/BlockCopperWire.java new file mode 100644 index 0000000..da32e63 --- /dev/null +++ b/src/main/java/basiccomponents/common/block/BlockCopperWire.java @@ -0,0 +1,45 @@ +package basiccomponents.common.block; + +import basiccomponents.common.BasicComponents; +import basiccomponents.common.tileentity.TileEntityCopperWire; +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.prefab.block.BlockConductor; + +public class BlockCopperWire extends BlockConductor { + + public BlockCopperWire() { + super(Material.cloth); + this.setBlockName("basiccomponents:copperWire"); + this.setStepSound(soundTypeCloth); + this.setResistance(0.2F); + this.setHardness(0.1F); + this.setBlockBounds(0.3F, 0.3F, 0.3F, 0.7F, 0.7F, 0.7F); + this.setCreativeTab(CreativeTabs.tabRedstone); + //TODO this + //Block.setBurnProperties(this.field_71990_ca, 30, 60); + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public int getRenderType() { + return -1; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TileEntityCopperWire(); + } +} diff --git a/src/main/java/basiccomponents/common/container/ContainerBatteryBox.java b/src/main/java/basiccomponents/common/container/ContainerBatteryBox.java new file mode 100644 index 0000000..06a30e6 --- /dev/null +++ b/src/main/java/basiccomponents/common/container/ContainerBatteryBox.java @@ -0,0 +1,82 @@ +package basiccomponents.common.container; + +import basiccomponents.common.tileentity.TileEntityBatteryBox; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.SlotSpecific; + +public class ContainerBatteryBox extends Container { + + private TileEntityBatteryBox tileEntity; + + + public ContainerBatteryBox(InventoryPlayer par1InventoryPlayer, TileEntityBatteryBox batteryBox) { + this.tileEntity = batteryBox; + this.addSlotToContainer(new SlotSpecific(batteryBox, 0, 33, 24, new Class[]{IItemElectric.class})); + this.addSlotToContainer(new SlotSpecific(batteryBox, 1, 33, 48, new Class[]{IItemElectric.class})); + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + this.tileEntity.playersUsing.add(par1InventoryPlayer.player); + } + + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.playersUsing.remove(entityplayer); + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int slotID) { + ItemStack returnStack = null; + Slot slot = (Slot)super.inventorySlots.get(slotID); + if(slot != null && slot.getHasStack()) { + ItemStack itemStack = slot.getStack(); + returnStack = itemStack.copy(); + if(slotID != 0 && slotID != 1) { + if(this.getSlot(0).isItemValid(itemStack)) { + if(((IItemElectric)itemStack.getItem()).getProvideRequest(itemStack).getWatts() > 0.0D) { + if(!this.mergeItemStack(itemStack, 1, 2, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, 0, 1, false)) { + return null; + } + } else if(slotID >= 30 && slotID < 38 && !this.mergeItemStack(itemStack, 3, 30, false)) { + return null; + } + } else if(!this.mergeItemStack(itemStack, 3, 38, false)) { + return null; + } + + if(itemStack.stackSize == 0) { + slot.putStack((ItemStack)null); + } else { + slot.onSlotChanged(); + } + + if(itemStack.stackSize == returnStack.stackSize) { + return null; + } + + slot.onPickupFromSlot(par1EntityPlayer, itemStack); + } + + return returnStack; + } +} diff --git a/src/main/java/basiccomponents/common/container/ContainerCoalGenerator.java b/src/main/java/basiccomponents/common/container/ContainerCoalGenerator.java new file mode 100644 index 0000000..a666020 --- /dev/null +++ b/src/main/java/basiccomponents/common/container/ContainerCoalGenerator.java @@ -0,0 +1,77 @@ +package basiccomponents.common.container; + +import basiccomponents.common.tileentity.TileEntityCoalGenerator; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class ContainerCoalGenerator extends Container { + + private TileEntityCoalGenerator tileEntity; + + + public ContainerCoalGenerator(InventoryPlayer par1InventoryPlayer, TileEntityCoalGenerator tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer(new Slot(tileEntity, 0, 33, 34)); + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + tileEntity.playersUsing.add(par1InventoryPlayer.player); + } + + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.playersUsing.remove(entityplayer); + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(par1); + if(var3 != null && var3.getHasStack()) { + ItemStack var4 = var3.getStack(); + var2 = var4.copy(); + if(par1 != 0) { + if(var4.getItem() == Items.coal) { + if(!this.mergeItemStack(var4, 0, 1, false)) { + return null; + } + } else if(par1 >= 30 && par1 < 37 && !this.mergeItemStack(var4, 3, 30, false)) { + return null; + } + } else if(!this.mergeItemStack(var4, 3, 37, false)) { + return null; + } + + if(var4.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(var4.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, var4); + } + + return var2; + } +} diff --git a/src/main/java/basiccomponents/common/container/ContainerElectricFurnace.java b/src/main/java/basiccomponents/common/container/ContainerElectricFurnace.java new file mode 100644 index 0000000..8a46660 --- /dev/null +++ b/src/main/java/basiccomponents/common/container/ContainerElectricFurnace.java @@ -0,0 +1,95 @@ +package basiccomponents.common.container; + +import basiccomponents.common.tileentity.TileEntityElectricFurnace; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.inventory.Slot; +import net.minecraft.inventory.SlotFurnace; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.FurnaceRecipes; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.SlotSpecific; + +public class ContainerElectricFurnace extends Container { + + private TileEntityElectricFurnace tileEntity; + + + public ContainerElectricFurnace(InventoryPlayer par1InventoryPlayer, TileEntityElectricFurnace tileEntity) { + this.tileEntity = tileEntity; + this.addSlotToContainer(new SlotSpecific(tileEntity, 0, 55, 49, new Class[]{IItemElectric.class})); + this.addSlotToContainer(new Slot(tileEntity, 1, 55, 25)); + this.addSlotToContainer(new SlotFurnace(par1InventoryPlayer.player, tileEntity, 2, 108, 25)); + + int var3; + for(var3 = 0; var3 < 3; ++var3) { + for(int var4 = 0; var4 < 9; ++var4) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var4 + var3 * 9 + 9, 8 + var4 * 18, 84 + var3 * 18)); + } + } + + for(var3 = 0; var3 < 9; ++var3) { + this.addSlotToContainer(new Slot(par1InventoryPlayer, var3, 8 + var3 * 18, 142)); + } + + tileEntity.playersUsing.add(par1InventoryPlayer.player); + } + + public void onContainerClosed(EntityPlayer entityplayer) { + super.onContainerClosed(entityplayer); + this.tileEntity.playersUsing.remove(entityplayer); + } + + public boolean canInteractWith(EntityPlayer par1EntityPlayer) { + return this.tileEntity.isUseableByPlayer(par1EntityPlayer); + } + + public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par1) { + ItemStack var2 = null; + Slot var3 = (Slot)super.inventorySlots.get(par1); + if(var3 != null && var3.getHasStack()) { + ItemStack var4 = var3.getStack(); + var2 = var4.copy(); + if(par1 == 2) { + if(!this.mergeItemStack(var4, 3, 39, true)) { + return null; + } + + var3.onSlotChange(var4, var2); + } else if(par1 != 1 && par1 != 0) { + if(var4.getItem() instanceof IItemElectric) { + if(!this.mergeItemStack(var4, 0, 1, false)) { + return null; + } + } else if(FurnaceRecipes.smelting().getSmeltingResult(var4) != null) { + if(!this.mergeItemStack(var4, 1, 2, false)) { + return null; + } + } else if(par1 >= 3 && par1 < 30) { + if(!this.mergeItemStack(var4, 30, 39, false)) { + return null; + } + } else if(par1 >= 30 && par1 < 39 && !this.mergeItemStack(var4, 3, 30, false)) { + return null; + } + } else if(!this.mergeItemStack(var4, 3, 39, false)) { + return null; + } + + if(var4.stackSize == 0) { + var3.putStack((ItemStack)null); + } else { + var3.onSlotChanged(); + } + + if(var4.stackSize == var2.stackSize) { + return null; + } + + var3.onPickupFromSlot(par1EntityPlayer, var4); + } + + return var2; + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemBase.java b/src/main/java/basiccomponents/common/item/ItemBase.java new file mode 100644 index 0000000..50b9576 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemBase.java @@ -0,0 +1,17 @@ +package basiccomponents.common.item; + +import basiccomponents.common.BasicComponents; +import net.minecraft.item.Item; +import net.minecraft.util.IIcon; + +public class ItemBase extends Item { + + protected final IIcon[] icons = new IIcon[256]; + + public ItemBase(String name) { + super(); + this.setUnlocalizedName("basiccomponents:" + name); + this.setTextureName("basiccomponents:" + name); + this.setNoRepair(); + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemBattery.java b/src/main/java/basiccomponents/common/item/ItemBattery.java new file mode 100644 index 0000000..61e9b89 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemBattery.java @@ -0,0 +1,32 @@ +package basiccomponents.common.item; + +import basiccomponents.common.BasicComponents; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; +import universalelectricity.core.item.ItemElectric; + +public class ItemBattery extends ItemElectric { + + public ItemBattery(String name) { + super(); + this.setUnlocalizedName("basiccomponents:" + name); + this.setCreativeTab(CreativeTabs.tabRedstone); + } + + @SideOnly(Side.CLIENT) + @Override + public void registerIcons(IIconRegister iconRegister) { + this.itemIcon = iconRegister.registerIcon(this.getUnlocalizedName().replace("item.", "")); + } + + public double getMaxJoules(ItemStack itemStack) { + return 1000000.0D; + } + + public double getVoltage(ItemStack itemStack) { + return 25.0D; + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemBlockBasicMachine.java b/src/main/java/basiccomponents/common/item/ItemBlockBasicMachine.java new file mode 100644 index 0000000..a40525f --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemBlockBasicMachine.java @@ -0,0 +1,33 @@ +package basiccomponents.common.item; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class ItemBlockBasicMachine extends ItemBlock { + + public ItemBlockBasicMachine(Block block) { + super(block); + this.setMaxDamage(0); + this.setHasSubtypes(true); + } + + public int getMetadata(int damage) { + return damage; + } + + public String getUnlocalizedName(ItemStack itemstack) { + byte metadata = 0; + if(itemstack.getItemDamage() >= 8) { + metadata = 2; + } else if(itemstack.getItemDamage() >= 4) { + metadata = 1; + } + + return this.field_150939_a.getUnlocalizedName() + "." + metadata; + } + + public String getUnlocalizedName() { + return this.field_150939_a.getUnlocalizedName() + ".0"; + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemBlockCopperWire.java b/src/main/java/basiccomponents/common/item/ItemBlockCopperWire.java new file mode 100644 index 0000000..211bae9 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemBlockCopperWire.java @@ -0,0 +1,44 @@ +package basiccomponents.common.item; + +import basiccomponents.common.tileentity.TileEntityCopperWire; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import universalelectricity.core.electricity.ElectricityDisplay; + +public class ItemBlockCopperWire extends ItemBlock { + + IIcon icon; + + public ItemBlockCopperWire(Block block) { + super(block); + this.setMaxDamage(0); + this.setHasSubtypes(true); + this.setTextureName("basiccomponents:copperWire"); + } + + @SideOnly(Side.CLIENT) + @Override + public IIcon getIconFromDamage(int meta) { + return icon; + } + + @SideOnly(Side.CLIENT) + @Override + public void registerIcons(IIconRegister reg) { + icon = reg.registerIcon("basiccomponents:copperWire"); + } + + public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) { + par3List.add("Resistance: " + ElectricityDisplay.getDisplay(TileEntityCopperWire.RESISTANCE, ElectricityDisplay.ElectricUnit.RESISTANCE)); + par3List.add("Max Amps: " + ElectricityDisplay.getDisplay(TileEntityCopperWire.MAX_AMPS, ElectricityDisplay.ElectricUnit.AMPERE)); + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemCircuit.java b/src/main/java/basiccomponents/common/item/ItemCircuit.java new file mode 100644 index 0000000..5cae031 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemCircuit.java @@ -0,0 +1,34 @@ +package basiccomponents.common.item; + +import basiccomponents.common.item.ItemBase; +import java.util.List; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.ItemStack; + +public class ItemCircuit extends ItemBase { + + public static final String[] TYPES = new String[]{"circuitBasic", "circuitAdvanced", "circuitElite"}; + + + public ItemCircuit(int texture) { + super("circuit"); + this.setMaxDamage(0); + this.setHasSubtypes(true); + } + + public int getMetadata(int damage) { + return damage; + } + + public String getUnlocalizedName(ItemStack itemStack) { + return "item.basiccomponents:" + TYPES[itemStack.getItemDamage()]; + } + + public void func_77633_a(int par1, CreativeTabs par2CreativeTabs, List list) { + for(int i = 0; i < TYPES.length; ++i) { + list.add(new ItemStack(this, 1, i)); + } + + } + +} diff --git a/src/main/java/basiccomponents/common/item/ItemInfiniteBattery.java b/src/main/java/basiccomponents/common/item/ItemInfiniteBattery.java new file mode 100644 index 0000000..be8aa2b --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemInfiniteBattery.java @@ -0,0 +1,53 @@ +package basiccomponents.common.item; + +import basiccomponents.common.item.ItemBase; +import java.util.List; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.IItemElectric; + +public class ItemInfiniteBattery extends ItemBase implements IItemElectric { + + public ItemInfiniteBattery(String name) { + super(name); + this.setMaxStackSize(1); + this.setNoRepair(); + this.setCreativeTab(CreativeTabs.tabRedstone); + } + + public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4) { + par3List.add("§2Infinite"); + } + + public double getJoules(ItemStack itemStack) { + return this.getMaxJoules(itemStack); + } + + public void setJoules(double joules, ItemStack itemStack) {} + + public double getMaxJoules(ItemStack itemStack) { + return Double.POSITIVE_INFINITY; + } + + public double getVoltage(ItemStack itemStack) { + return 25.0D; + } + + public ElectricityPack onReceive(ElectricityPack electricityPack, ItemStack itemStack) { + return electricityPack; + } + + public ElectricityPack onProvide(ElectricityPack electricityPack, ItemStack itemStack) { + return electricityPack; + } + + public ElectricityPack getReceiveRequest(ItemStack itemStack) { + return new ElectricityPack(Double.POSITIVE_INFINITY, this.getVoltage(itemStack)); + } + + public ElectricityPack getProvideRequest(ItemStack itemStack) { + return new ElectricityPack(Double.POSITIVE_INFINITY, this.getVoltage(itemStack)); + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemIngot.java b/src/main/java/basiccomponents/common/item/ItemIngot.java new file mode 100644 index 0000000..afb4796 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemIngot.java @@ -0,0 +1,11 @@ +package basiccomponents.common.item; + +import net.minecraft.creativetab.CreativeTabs; + +public class ItemIngot extends ItemBase { + + public ItemIngot(String name) { + super(name); + this.setCreativeTab(CreativeTabs.tabMaterials); + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemPlate.java b/src/main/java/basiccomponents/common/item/ItemPlate.java new file mode 100644 index 0000000..c1ad6a6 --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemPlate.java @@ -0,0 +1,11 @@ +package basiccomponents.common.item; + +import net.minecraft.creativetab.CreativeTabs; + +public class ItemPlate extends ItemBase { + + public ItemPlate(String name) { + super(name); + this.setCreativeTab(CreativeTabs.tabMaterials); + } +} diff --git a/src/main/java/basiccomponents/common/item/ItemWrench.java b/src/main/java/basiccomponents/common/item/ItemWrench.java new file mode 100644 index 0000000..4ca912a --- /dev/null +++ b/src/main/java/basiccomponents/common/item/ItemWrench.java @@ -0,0 +1,51 @@ +package basiccomponents.common.item; + +import basiccomponents.common.item.ItemBase; +import net.minecraft.block.Block; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.prefab.implement.IToolConfigurator; + +public class ItemWrench extends ItemBase implements IToolConfigurator { + + public ItemWrench() { + super("wrench"); + this.setMaxStackSize(1); + this.setCreativeTab(CreativeTabs.tabTools); + } + + public boolean canWrench(EntityPlayer entityPlayer, int x, int y, int z) { + return true; + } + + public void wrenchUsed(EntityPlayer entityPlayer, int x, int y, int z) {} + + public boolean onItemUseFirst(ItemStack stack, EntityPlayer entityPlayer, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) { + Block block = world.getBlock(x, y, z); + if(block != Blocks.furnace && block != Blocks.lit_furnace && block != Blocks.dropper && block != Blocks.hopper && block != Blocks.dispenser && block != Blocks.piston && block != Blocks.sticky_piston) { + return false; + } else { + int metadata = world.getBlockMetadata(x, y, z); + int[] rotationMatrix = new int[]{1, 2, 3, 4, 5, 0}; + if(block == Blocks.furnace || block == Blocks.lit_furnace) { + rotationMatrix = ForgeDirection.ROTATION_MATRIX[0]; + } + + world.setBlockMetadataWithNotify(x, y, z, ForgeDirection.getOrientation(rotationMatrix[metadata]).ordinal(), 3); + this.wrenchUsed(entityPlayer, x, y, z); + return true; + } + } + + public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) { + return false; + } + + public boolean shouldPassSneakingClickToBlock(World world, int x, int y, int z) { + return true; + } +} diff --git a/src/main/java/basiccomponents/common/tileentity/TileEntityBatteryBox.java b/src/main/java/basiccomponents/common/tileentity/TileEntityBatteryBox.java new file mode 100644 index 0000000..43f4940 --- /dev/null +++ b/src/main/java/basiccomponents/common/tileentity/TileEntityBatteryBox.java @@ -0,0 +1,251 @@ +package basiccomponents.common.tileentity; + +import basiccomponents.common.BasicComponents; +import com.google.common.io.ByteArrayDataInput; +import cpw.mods.fml.common.registry.LanguageRegistry; +import java.util.EnumSet; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IElectricityStorage; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.core.electricity.IElectricityNetwork; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; +import universalelectricity.prefab.tile.TileEntityElectricityStorage; + +public class TileEntityBatteryBox extends TileEntityElectricityStorage implements IElectricityStorage, ISidedInventory { + + private ItemStack[] containingItems = new ItemStack[2]; + public final Set playersUsing = new HashSet(); + + + @Override + public void updateEntity() { + super.updateEntity(); + if(!this.isDisabled() && !this.worldObj.isRemote) { + this.setJoules(this.getJoules() - ElectricItemHelper.chargeItem(this.containingItems[0], this.getJoules(), this.getVoltage())); + this.setJoules(this.getJoules() + ElectricItemHelper.dechargeItem(this.containingItems[1], this.getMaxJoules() - this.getJoules(), this.getVoltage())); + ForgeDirection i$ = ForgeDirection.getOrientation(this.getBlockMetadata() - 4 + 2); + TileEntity player = VectorHelper.getConnectorFromSide(this.worldObj, new Vector3(this), i$.getOpposite()); + TileEntity outputTile = VectorHelper.getConnectorFromSide(this.worldObj, new Vector3(this), i$); + IElectricityNetwork inputNetwork = ElectricityNetworkHelper.getNetworkFromTileEntity(player, i$.getOpposite()); + IElectricityNetwork outputNetwork = ElectricityNetworkHelper.getNetworkFromTileEntity(outputTile, i$); + if(outputNetwork != null && inputNetwork != outputNetwork) { + double outputWatts = Math.min(outputNetwork.getRequest(new TileEntity[]{this}).getWatts(), Math.min(this.getJoules(), 10000.0D)); + if(this.getJoules() > 0.0D && outputWatts > 0.0D) { + outputNetwork.startProducing(this, outputWatts / this.getVoltage(), this.getVoltage()); + this.setJoules(this.getJoules() - outputWatts); + } else { + outputNetwork.stopProducing(this); + } + } + } + + this.setJoules(this.getJoules() - 5.0E-5D); + if(!this.worldObj.isRemote && super.ticks % 3L == 0L) { + /*Iterator i$1 = this.playersUsing.iterator(); + + while(i$1.hasNext()) { + EntityPlayer player1 = (EntityPlayer)i$1.next(); + + PacketDispatcher.sendPacketToPlayer(this.func_70319_e(), (Player)player1); + }*/ + this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + + } + + public boolean canConnect(ForgeDirection direction) { + return direction == ForgeDirection.getOrientation(this.getBlockMetadata() - 4 + 2) || direction == ForgeDirection.getOrientation(this.getBlockMetadata() - 4 + 2).getOpposite(); + } + + protected EnumSet getConsumingSides() { + return EnumSet.of(ForgeDirection.getOrientation(this.getBlockMetadata() - 4 + 2).getOpposite()); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setDouble("joules", this.getJoules()); + nbt.setInteger("disabledTicks", super.disabledTicks); + //return PacketManager.getPacket(BasicComponents.CHANNEL, this, new Object[]{Double.valueOf(this.getJoules()), Integer.valueOf(super.disabledTicks)}); + return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, getBlockMetadata(), nbt); + } + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + if (this.worldObj.isRemote) { + NBTTagCompound nbt = pkt.func_148857_g(); + this.setJoules(nbt.getDouble("joules")); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + } + + /*public void handlePacketData(INetworkManager network, int type, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) { + try { + this.setJoules(dataStream.readDouble()); + super.disabledTicks = dataStream.readInt(); + } catch (Exception var7) { + var7.printStackTrace(); + } + + }*/ + + + + @Override + public void openInventory() {} + + @Override + public void closeInventory() {} + + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) { + super.readFromNBT(par1NBTTagCompound); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items", 10); + this.containingItems = new ItemStack[this.getSizeInventory()]; + + for(int var3 = 0; var3 < var2.tagCount(); ++var3) { + NBTTagCompound var4 = (NBTTagCompound)var2.getCompoundTagAt(var3); + byte var5 = var4.getByte("Slot"); + if(var5 >= 0 && var5 < this.containingItems.length) { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + NBTTagList var2 = new NBTTagList(); + + for(int var3 = 0; var3 < this.containingItems.length; ++var3) { + if(this.containingItems[var3] != null) { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + + par1NBTTagCompound.setTag("Items", var2); + } + + public int getSizeInventory() { + return this.containingItems.length; + } + + public ItemStack getStackInSlot(int par1) { + return this.containingItems[par1]; + } + + public ItemStack decrStackSize(int par1, int par2) { + if(this.containingItems[par1] != null) { + ItemStack var3; + if(this.containingItems[par1].stackSize <= par2) { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } else { + var3 = this.containingItems[par1].splitStack(par2); + if(this.containingItems[par1].stackSize == 0) { + this.containingItems[par1] = null; + } + + return var3; + } + } else { + return null; + } + } + + public ItemStack getStackInSlotOnClosing(int par1) { + if(this.containingItems[par1] != null) { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } else { + return null; + } + } + + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { + this.containingItems[par1] = par2ItemStack; + if(par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + + } + + @Override + public String getInventoryName() { + return LanguageRegistry.instance().getStringLocalization("tile.basiccomponents:bcMachine.1.name"); + } + + public int getInventoryStackLimit() { + return 1; + } + + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this?false:par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + + public double getMaxJoules() { + return 5000000.0D; + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + public boolean isItemValidForSlot(int slotID, ItemStack itemstack) { + return itemstack.getItem() instanceof IItemElectric; + } + + public int[] getAccessibleSlotsFromSide(int slotID) { + return new int[]{0, 1}; + } + + public boolean canInsertItem(int slotID, ItemStack itemstack, int side) { + if(this.isItemValidForSlot(slotID, itemstack)) { + if(slotID == 0) { + return ((IItemElectric)itemstack.getItem()).getReceiveRequest(itemstack).getWatts() > 0.0D; + } + + if(slotID == 1) { + return ((IItemElectric)itemstack.getItem()).getProvideRequest(itemstack).getWatts() > 0.0D; + } + } + + return false; + } + + public boolean canExtractItem(int slotID, ItemStack itemstack, int side) { + if(this.isItemValidForSlot(slotID, itemstack)) { + if(slotID == 0) { + return ((IItemElectric)itemstack.getItem()).getReceiveRequest(itemstack).getWatts() <= 0.0D; + } + + if(slotID == 1) { + return ((IItemElectric)itemstack.getItem()).getProvideRequest(itemstack).getWatts() <= 0.0D; + } + } + + return false; + } +} diff --git a/src/main/java/basiccomponents/common/tileentity/TileEntityCoalGenerator.java b/src/main/java/basiccomponents/common/tileentity/TileEntityCoalGenerator.java new file mode 100644 index 0000000..e5f7ce0 --- /dev/null +++ b/src/main/java/basiccomponents/common/tileentity/TileEntityCoalGenerator.java @@ -0,0 +1,263 @@ +package basiccomponents.common.tileentity; + +import basiccomponents.common.BasicComponents; +import com.google.common.io.ByteArrayDataInput; + +import cpw.mods.fml.common.network.simpleimpl.IMessage; +import cpw.mods.fml.common.registry.LanguageRegistry; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IConductor; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.core.electricity.IElectricityNetwork; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; +import universalelectricity.prefab.tile.TileEntityElectrical; + +public class TileEntityCoalGenerator extends TileEntityElectrical implements IInventory, ISidedInventory { + + public static final int MAX_GENERATE_WATTS = 10000; + public static final int MIN_GENERATE_WATTS = 100; + private static final float BASE_ACCELERATION = 0.3F; + public double prevGenerateWatts; + public double generateWatts = 0.0D; + public IConductor connectedElectricUnit = null; + public int itemCookTime = 0; + private ItemStack[] containingItems = new ItemStack[1]; + public final Set playersUsing = new HashSet(); + + + public boolean canConnect(ForgeDirection direction) { + return direction == ForgeDirection.getOrientation(this.getBlockMetadata() - 0 + 2); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if(!this.worldObj.isRemote) { + this.prevGenerateWatts = this.generateWatts; + ForgeDirection outputDirection = ForgeDirection.getOrientation(this.getBlockMetadata() - 0 + 2); + TileEntity outputTile = VectorHelper.getConnectorFromSide(this.worldObj, new Vector3((double)this.xCoord, (double)this.yCoord, (double)this.zCoord), outputDirection); + IElectricityNetwork network = ElectricityNetworkHelper.getNetworkFromTileEntity(outputTile, outputDirection); + if(network != null) { + if(network.getRequest(new TileEntity[0]).getWatts() > 0.0D) { + this.connectedElectricUnit = (IConductor)outputTile; + } else { + this.connectedElectricUnit = null; + } + } else { + this.connectedElectricUnit = null; + } + + if(!this.isDisabled()) { + if(this.itemCookTime > 0) { + --this.itemCookTime; + if(this.connectedElectricUnit != null) { + this.generateWatts = Math.min(this.generateWatts + Math.min(this.generateWatts * 0.005D + 0.30000001192092896D, 5.0D), 10000.0D); + } + } + + if(this.containingItems[0] != null && this.connectedElectricUnit != null && this.containingItems[0].getItem() == Items.coal && this.itemCookTime <= 0) { //TODO DON'T HARDCOE FUEL!!! + this.itemCookTime = 320; + this.decrStackSize(0, 1); + } + + if(this.connectedElectricUnit == null || this.itemCookTime <= 0) { + this.generateWatts = Math.max(this.generateWatts - 8.0D, 0.0D); + } + + if(this.connectedElectricUnit != null) { + if(this.generateWatts > 100.0D) { + this.connectedElectricUnit.getNetwork().startProducing(this, this.generateWatts / this.getVoltage() / 20.0D, this.getVoltage()); + } else { + this.connectedElectricUnit.getNetwork().stopProducing(this); + } + } + } + + if(super.ticks % 3L == 0L) { + /*Iterator i$ = this.playersUsing.iterator(); + + while(i$.hasNext()) { + EntityPlayer player = (EntityPlayer)i$.next(); + PacketDispatcher.sendPacketToPlayer(this.func_70319_e(), (Player)player); + }*/ + this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + + if(this.prevGenerateWatts <= 0.0D && this.generateWatts > 0.0D || this.prevGenerateWatts > 0.0D && this.generateWatts <= 0.0D) { + //PacketManager.sendPacketToClients(this.func_70319_e(), this.field_70331_k); + this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + } + + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setDouble("generateWatts", this.generateWatts); + nbt.setInteger("itemCookTime", this.itemCookTime); + nbt.setInteger("disabledTicks", super.disabledTicks); + return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, getBlockMetadata(), nbt); + //return PacketManager.getPacket(BasicComponents.CHANNEL, this, new Object[]{Double.valueOf(this.generateWatts), Integer.valueOf(this.itemCookTime), Integer.valueOf(super.disabledTicks)}); + } + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + if (this.worldObj.isRemote) { + NBTTagCompound nbt = pkt.func_148857_g(); + this.generateWatts = nbt.getDouble("generateWatts"); + this.itemCookTime = nbt.getInteger("itemCookTime"); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + } + + /*public void handlePacketData(INetworkManager network, int type, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) { + try { + if(this.field_70331_k.isRemote) { + this.generateWatts = dataStream.readDouble(); + this.itemCookTime = dataStream.readInt(); + super.disabledTicks = dataStream.readInt(); + } + } catch (Exception var7) { + var7.printStackTrace(); + } + + }*/ + + public void openInventory() {} + + public void closeInventory() {} + + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) { + super.readFromNBT(par1NBTTagCompound); + this.itemCookTime = par1NBTTagCompound.getInteger("itemCookTime"); + this.generateWatts = par1NBTTagCompound.getDouble("generateRate"); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items", 10); + this.containingItems = new ItemStack[this.getSizeInventory()]; + + for(int var3 = 0; var3 < var2.tagCount(); ++var3) { + NBTTagCompound var4 = (NBTTagCompound)var2.getCompoundTagAt(var3); + byte var5 = var4.getByte("Slot"); + if(var5 >= 0 && var5 < this.containingItems.length) { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setInteger("itemCookTime", this.itemCookTime); + par1NBTTagCompound.setDouble("generateRate", this.generateWatts); + NBTTagList var2 = new NBTTagList(); + + for(int var3 = 0; var3 < this.containingItems.length; ++var3) { + if(this.containingItems[var3] != null) { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + + par1NBTTagCompound.setTag("Items", var2); + } + + public int getSizeInventory() { + return this.containingItems.length; + } + + public ItemStack getStackInSlot(int par1) { + return this.containingItems[par1]; + } + + public ItemStack decrStackSize(int par1, int par2) { + if(this.containingItems[par1] != null) { + ItemStack var3; + if(this.containingItems[par1].stackSize <= par2) { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } else { + var3 = this.containingItems[par1].splitStack(par2); + if(this.containingItems[par1].stackSize == 0) { + this.containingItems[par1] = null; + } + + return var3; + } + } else { + return null; + } + } + + public ItemStack getStackInSlotOnClosing(int par1) { + if(this.containingItems[par1] != null) { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } else { + return null; + } + } + + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { + this.containingItems[par1] = par2ItemStack; + if(par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + + } + + @Override + public String getInventoryName() { + return LanguageRegistry.instance().getStringLocalization("tile.basiccomponents:bcMachine.0.name"); + } + + public int getInventoryStackLimit() { + return 64; + } + + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this?false:par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + public boolean isItemValidForSlot(int slotID, ItemStack itemstack) { + return itemstack.getItem() == Items.coal; //TODO WTF + } + + public int[] getAccessibleSlotsFromSide(int var1) { + return new int[]{0}; + } + + public boolean canInsertItem(int slotID, ItemStack itemstack, int j) { + return this.isItemValidForSlot(slotID, itemstack); + } + + public boolean canExtractItem(int slotID, ItemStack itemstack, int j) { + return slotID == 0; + } +} diff --git a/src/main/java/basiccomponents/common/tileentity/TileEntityCopperWire.java b/src/main/java/basiccomponents/common/tileentity/TileEntityCopperWire.java new file mode 100644 index 0000000..b9f41df --- /dev/null +++ b/src/main/java/basiccomponents/common/tileentity/TileEntityCopperWire.java @@ -0,0 +1,36 @@ +package basiccomponents.common.tileentity; + +import basiccomponents.common.BasicComponents; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.tileentity.TileEntity; +import universalelectricity.prefab.tile.TileEntityConductor; + +public class TileEntityCopperWire extends TileEntityConductor { + + public static double RESISTANCE = 0.05D; + public static double MAX_AMPS = 200.0D; + + + public TileEntityCopperWire() { + super.channel = BasicComponents.CHANNEL; + } + + public double getResistance() { + return RESISTANCE; + } + + public double getCurrentCapcity() { + return MAX_AMPS; + } + + @Override + public void updateEntity() { + super.updateEntity(); + if(this.getNetwork() != null && super.ticks % 20L == 0L && this.getNetwork().getProduced(new TileEntity[0]).amperes > this.getCurrentCapcity() && !this.worldObj.isRemote) { + this.worldObj.setBlock(this.xCoord, this.yCoord, this.zCoord, Blocks.fire); + } + + } + +} diff --git a/src/main/java/basiccomponents/common/tileentity/TileEntityElectricFurnace.java b/src/main/java/basiccomponents/common/tileentity/TileEntityElectricFurnace.java new file mode 100644 index 0000000..40f0287 --- /dev/null +++ b/src/main/java/basiccomponents/common/tileentity/TileEntityElectricFurnace.java @@ -0,0 +1,267 @@ +package basiccomponents.common.tileentity; + +import basiccomponents.common.BasicComponents; +import com.google.common.io.ByteArrayDataInput; +import cpw.mods.fml.common.registry.LanguageRegistry; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.FurnaceRecipes; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.core.item.IItemElectric; +import universalelectricity.prefab.tile.TileEntityElectricityRunnable; + +public class TileEntityElectricFurnace extends TileEntityElectricityRunnable implements IInventory, ISidedInventory { + + public static final double WATTS_PER_TICK = 500.0D; + public static final int PROCESS_TIME_REQUIRED = 130; + public int processTicks = 0; + private ItemStack[] containingItems = new ItemStack[3]; + public final Set playersUsing = new HashSet(); + + @Override + public void updateEntity() { + super.updateEntity(); + super.wattsReceived += ElectricItemHelper.dechargeItem(this.containingItems[0], 500.0D, this.getVoltage()); + if(!this.worldObj.isRemote) { + if(this.canProcess()) { + if(super.wattsReceived >= 500.0D) { + if(this.processTicks == 0) { + this.processTicks = 130; + } else if(this.processTicks > 0) { + --this.processTicks; + if(this.processTicks < 1) { + this.smeltItem(); + this.processTicks = 0; + } + } else { + this.processTicks = 0; + } + } else { + this.processTicks = 0; + } + + super.wattsReceived = Math.max(super.wattsReceived - 125.0D, 0.0D); + } else { + this.processTicks = 0; + } + + if(super.ticks % 3L == 0L) { + /*Iterator i$ = this.playersUsing.iterator(); + + while(i$.hasNext()) { + EntityPlayer player = (EntityPlayer)i$.next(); + PacketDispatcher.sendPacketToPlayer(this.func_70319_e(), (Player)player); + }*/ + + this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + } + + } + + public boolean canConnect(ForgeDirection direction) { + return direction == ForgeDirection.getOrientation(this.getBlockMetadata() - 8 + 2); + } + + public ElectricityPack getRequest() { + return this.canProcess()?new ElectricityPack(500.0D / this.getVoltage(), this.getVoltage()):new ElectricityPack(); + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setInteger("processTicks", this.processTicks); + nbt.setInteger("disabledTicks", super.disabledTicks); + return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, getBlockMetadata(), nbt); + //return PacketManager.getPacket(BasicComponents.CHANNEL, this, new Object[]{Integer.valueOf(this.processTicks), Integer.valueOf(super.disabledTicks)}); + } + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + if (this.worldObj.isRemote) { + NBTTagCompound nbt = pkt.func_148857_g(); + this.processTicks = nbt.getInteger("processTicks"); + super.disabledTicks = nbt.getInteger("disabledTicks"); + } + } + + /*public void handlePacketData(INetworkManager network, int type, Packet250CustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) { + try { + this.processTicks = dataStream.readInt(); + super.disabledTicks = dataStream.readInt(); + } catch (Exception var7) { + var7.printStackTrace(); + } + + }*/ + + public void openInventory() {} + + public void closeInventory() {} + + public boolean canProcess() { + if (this.containingItems[1] == null) { + return false; + } else if(FurnaceRecipes.smelting().getSmeltingResult(this.containingItems[1]) == null) { + return false; + } else if(this.containingItems[1] == null) { + return false; + } else { + if(this.containingItems[2] != null) { + if(!this.containingItems[2].isItemEqual(FurnaceRecipes.smelting().getSmeltingResult(this.containingItems[1]))) { + return false; + } + + if(this.containingItems[2].stackSize + 1 > 64) { + return false; + } + } + + return true; + } + } + + public void smeltItem() { + if(this.canProcess()) { + ItemStack resultItemStack = FurnaceRecipes.smelting().getSmeltingResult(this.containingItems[1]); + if(this.containingItems[2] == null) { + this.containingItems[2] = resultItemStack.copy(); + } else if(this.containingItems[2].isItemEqual(resultItemStack)) { + ++this.containingItems[2].stackSize; + } + + --this.containingItems[1].stackSize; + if(this.containingItems[1].stackSize <= 0) { + this.containingItems[1] = null; + } + } + + } + + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) { + super.readFromNBT(par1NBTTagCompound); + this.processTicks = par1NBTTagCompound.getInteger("smeltingTicks"); + NBTTagList var2 = par1NBTTagCompound.getTagList("Items", 10); + this.containingItems = new ItemStack[this.getSizeInventory()]; + + for(int var3 = 0; var3 < var2.tagCount(); ++var3) { + NBTTagCompound var4 = (NBTTagCompound)var2.getCompoundTagAt(var3); + byte var5 = var4.getByte("Slot"); + if(var5 >= 0 && var5 < this.containingItems.length) { + this.containingItems[var5] = ItemStack.loadItemStackFromNBT(var4); + } + } + + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setInteger("smeltingTicks", this.processTicks); + NBTTagList var2 = new NBTTagList(); + + for(int var3 = 0; var3 < this.containingItems.length; ++var3) { + if(this.containingItems[var3] != null) { + NBTTagCompound var4 = new NBTTagCompound(); + var4.setByte("Slot", (byte)var3); + this.containingItems[var3].writeToNBT(var4); + var2.appendTag(var4); + } + } + + par1NBTTagCompound.setTag("Items", var2); + } + + public int getSizeInventory() { + return this.containingItems.length; + } + + public ItemStack getStackInSlot(int par1) { + return this.containingItems[par1]; + } + + public ItemStack decrStackSize(int par1, int par2) { + if(this.containingItems[par1] != null) { + ItemStack var3; + if(this.containingItems[par1].stackSize <= par2) { + var3 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var3; + } else { + var3 = this.containingItems[par1].splitStack(par2); + if(this.containingItems[par1].stackSize == 0) { + this.containingItems[par1] = null; + } + + return var3; + } + } else { + return null; + } + } + + public ItemStack getStackInSlotOnClosing(int par1) { + if(this.containingItems[par1] != null) { + ItemStack var2 = this.containingItems[par1]; + this.containingItems[par1] = null; + return var2; + } else { + return null; + } + } + + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) { + this.containingItems[par1] = par2ItemStack; + if(par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + + } + + @Override + public String getInventoryName() { + return LanguageRegistry.instance().getStringLocalization("tile.basiccomponents:bcMachine.2.name"); + } + + public int getInventoryStackLimit() { + return 64; + } + + public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) { + return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this?false:par1EntityPlayer.getDistanceSq((double)this.xCoord + 0.5D, (double)this.yCoord + 0.5D, (double)this.zCoord + 0.5D) <= 64.0D; + } + + @Override + public boolean hasCustomInventoryName() { + return true; + } + + public boolean isItemValidForSlot(int slotID, ItemStack itemStack) { + return slotID == 1?FurnaceRecipes.smelting().getSmeltingResult(itemStack) != null:(slotID == 0?itemStack.getItem() instanceof IItemElectric:false); + } + + public int[] getAccessibleSlotsFromSide(int side) { + return side == 0?new int[]{2}:(side == 1?new int[]{0, 1}:new int[]{0}); + } + + public boolean canInsertItem(int slotID, ItemStack par2ItemStack, int par3) { + return this.isItemValidForSlot(slotID, par2ItemStack); + } + + public boolean canExtractItem(int slotID, ItemStack par2ItemStack, int par3) { + return slotID == 2; + } +} diff --git a/src/main/java/universalelectricity/core/UniversalElectricity.java b/src/main/java/universalelectricity/core/UniversalElectricity.java new file mode 100644 index 0000000..93c5f81 --- /dev/null +++ b/src/main/java/universalelectricity/core/UniversalElectricity.java @@ -0,0 +1,36 @@ +package universalelectricity.core; + +import cpw.mods.fml.common.Loader; +import java.io.File; +import net.minecraft.block.material.MapColor; +import net.minecraft.block.material.Material; +import net.minecraftforge.common.config.Configuration; + +public class UniversalElectricity { + + public static final String MAJOR_VERSION = "0"; + public static final String MINOR_VERSION = "6"; + public static final String REVISION_VERSION = "2"; + public static final String BUILD_VERSION = "117"; + public static final String VERSION = "0.6.2"; + public static final Configuration CONFIGURATION = new Configuration(new File(Loader.instance().getConfigDir(), "UniversalElectricity.cfg")); + public static double IC2_RATIO = 40.0D; + public static double BC3_RATIO = 100.0D; + public static double TO_IC2_RATIO = 1.0D / IC2_RATIO; + public static double TO_BC_RATIO = 1.0D / BC3_RATIO; + public static boolean isVoltageSensitive = false; + public static boolean isNetworkActive = false; + public static final Material machine = new Material(MapColor.ironColor); + + + static { + CONFIGURATION.load(); + IC2_RATIO = CONFIGURATION.get("Compatiblity", "IndustrialCraft Conversion Ratio", IC2_RATIO).getDouble(IC2_RATIO); + BC3_RATIO = CONFIGURATION.get("Compatiblity", "BuildCraft Conversion Ratio", BC3_RATIO).getDouble(BC3_RATIO); + TO_IC2_RATIO = 1.0D / IC2_RATIO; + TO_BC_RATIO = 1.0D / BC3_RATIO; + isVoltageSensitive = CONFIGURATION.get("Compatiblity", "Is Voltage Sensitive", isVoltageSensitive).getBoolean(isVoltageSensitive); + isNetworkActive = CONFIGURATION.get("Compatiblity", "Is Network Active", isNetworkActive).getBoolean(isNetworkActive); + CONFIGURATION.save(); + } +} diff --git a/src/main/java/universalelectricity/core/block/IConductor.java b/src/main/java/universalelectricity/core/block/IConductor.java new file mode 100644 index 0000000..4a182b9 --- /dev/null +++ b/src/main/java/universalelectricity/core/block/IConductor.java @@ -0,0 +1,11 @@ +package universalelectricity.core.block; + +import universalelectricity.core.block.IConnectionProvider; +import universalelectricity.core.block.INetworkProvider; + +public interface IConductor extends INetworkProvider, IConnectionProvider { + + double getResistance(); + + double getCurrentCapcity(); +} diff --git a/src/main/java/universalelectricity/core/block/IConnectionProvider.java b/src/main/java/universalelectricity/core/block/IConnectionProvider.java new file mode 100644 index 0000000..653d6e6 --- /dev/null +++ b/src/main/java/universalelectricity/core/block/IConnectionProvider.java @@ -0,0 +1,11 @@ +package universalelectricity.core.block; + +import net.minecraft.tileentity.TileEntity; +import universalelectricity.core.block.IConnector; + +public interface IConnectionProvider extends IConnector { + + TileEntity[] getAdjacentConnections(); + + void updateAdjacentConnections(); +} diff --git a/src/main/java/universalelectricity/core/block/IConnector.java b/src/main/java/universalelectricity/core/block/IConnector.java new file mode 100644 index 0000000..c903fba --- /dev/null +++ b/src/main/java/universalelectricity/core/block/IConnector.java @@ -0,0 +1,8 @@ +package universalelectricity.core.block; + +import net.minecraftforge.common.util.ForgeDirection; + +public interface IConnector { + + boolean canConnect(ForgeDirection var1); +} diff --git a/src/main/java/universalelectricity/core/block/IElectricityStorage.java b/src/main/java/universalelectricity/core/block/IElectricityStorage.java new file mode 100644 index 0000000..98b5192 --- /dev/null +++ b/src/main/java/universalelectricity/core/block/IElectricityStorage.java @@ -0,0 +1,11 @@ +package universalelectricity.core.block; + + +public interface IElectricityStorage { + + double getJoules(); + + void setJoules(double var1); + + double getMaxJoules(); +} diff --git a/src/main/java/universalelectricity/core/block/INetworkProvider.java b/src/main/java/universalelectricity/core/block/INetworkProvider.java new file mode 100644 index 0000000..5c190bd --- /dev/null +++ b/src/main/java/universalelectricity/core/block/INetworkProvider.java @@ -0,0 +1,10 @@ +package universalelectricity.core.block; + +import universalelectricity.core.electricity.IElectricityNetwork; + +public interface INetworkProvider { + + IElectricityNetwork getNetwork(); + + void setNetwork(IElectricityNetwork var1); +} diff --git a/src/main/java/universalelectricity/core/block/IVoltage.java b/src/main/java/universalelectricity/core/block/IVoltage.java new file mode 100644 index 0000000..be0c0d2 --- /dev/null +++ b/src/main/java/universalelectricity/core/block/IVoltage.java @@ -0,0 +1,7 @@ +package universalelectricity.core.block; + + +public interface IVoltage { + + double getVoltage(); +} diff --git a/src/main/java/universalelectricity/core/electricity/ElectricityDisplay.java b/src/main/java/universalelectricity/core/electricity/ElectricityDisplay.java new file mode 100644 index 0000000..88ecc8a --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/ElectricityDisplay.java @@ -0,0 +1,97 @@ +package universalelectricity.core.electricity; + + +public class ElectricityDisplay { + + public static String getDisplay(double value, ElectricityDisplay.ElectricUnit unit, int decimalPlaces, boolean isShort) { + String unitName = unit.name; + if(isShort) { + unitName = unit.symbol; + } else if(value > 1.0D) { + unitName = unit.getPlural(); + } + + return value == 0.0D?value + " " + unitName:(value <= ElectricityDisplay.MeasurementUnit.MILLI.value?roundDecimals(ElectricityDisplay.MeasurementUnit.MICRO.process(value), decimalPlaces) + " " + ElectricityDisplay.MeasurementUnit.MICRO.getName(isShort) + unitName:(value < 1.0D?roundDecimals(ElectricityDisplay.MeasurementUnit.MILLI.process(value), decimalPlaces) + " " + ElectricityDisplay.MeasurementUnit.MILLI.getName(isShort) + unitName:(value > ElectricityDisplay.MeasurementUnit.MEGA.value?roundDecimals(ElectricityDisplay.MeasurementUnit.MEGA.process(value), decimalPlaces) + " " + ElectricityDisplay.MeasurementUnit.MEGA.getName(isShort) + unitName:(value > ElectricityDisplay.MeasurementUnit.KILO.value?roundDecimals(ElectricityDisplay.MeasurementUnit.KILO.process(value), decimalPlaces) + " " + ElectricityDisplay.MeasurementUnit.KILO.getName(isShort) + unitName:roundDecimals(value, decimalPlaces) + " " + unitName)))); + } + + public static String getDisplay(double value, ElectricityDisplay.ElectricUnit unit) { + return getDisplay(value, unit, 2, false); + } + + public static String getDisplayShort(double value, ElectricityDisplay.ElectricUnit unit) { + return getDisplay(value, unit, 2, true); + } + + public static String getDisplayShort(double value, ElectricityDisplay.ElectricUnit unit, int decimalPlaces) { + return getDisplay(value, unit, decimalPlaces, true); + } + + public static String getDisplaySimple(double value, ElectricityDisplay.ElectricUnit unit, int decimalPlaces) { + return value > 1.0D?(decimalPlaces < 1?(int)value + " " + unit.getPlural():roundDecimals(value, decimalPlaces) + " " + unit.getPlural()):(decimalPlaces < 1?(int)value + " " + unit.name:roundDecimals(value, decimalPlaces) + " " + unit.name); + } + + public static double roundDecimals(double d, int decimalPlaces) { + int j = (int)(d * Math.pow(10.0D, (double)decimalPlaces)); + return (double)j / Math.pow(10.0D, (double)decimalPlaces); + } + + public static double roundDecimals(double d) { + return roundDecimals(d, 2); + } + + public static enum ElectricUnit { + + AMPERE("AMPERE", 0, "Amp", "I"), + AMP_HOUR("AMP_HOUR", 1, "Amp Hour", "Ah"), + VOLTAGE("VOLTAGE", 2, "Volt", "V"), + WATT("WATT", 3, "Watt", "W"), + WATT_HOUR("WATT_HOUR", 4, "Watt Hour", "Wh"), + RESISTANCE("RESISTANCE", 5, "Ohm", "R"), + CONDUCTANCE("CONDUCTANCE", 6, "Siemen", "S"), + JOULES("JOULES", 7, "Joule", "J"); + public String name; + public String symbol; + // $FF: synthetic field + private static final ElectricityDisplay.ElectricUnit[] $VALUES = new ElectricityDisplay.ElectricUnit[]{AMPERE, AMP_HOUR, VOLTAGE, WATT, WATT_HOUR, RESISTANCE, CONDUCTANCE, JOULES}; + + + private ElectricUnit(String var1, int var2, String name, String symbol) { + this.name = name; + this.symbol = symbol; + } + + public String getPlural() { + return this.name + "s"; + } + + } + + public static enum MeasurementUnit { + + MICRO("MICRO", 0, "Micro", "mi", 1.0E-6D), + MILLI("MILLI", 1, "Milli", "m", 0.001D), + KILO("KILO", 2, "Kilo", "k", 1000.0D), + MEGA("MEGA", 3, "Mega", "M", 1000000.0D); + public String name; + public String symbol; + public double value; + // $FF: synthetic field + private static final ElectricityDisplay.MeasurementUnit[] $VALUES = new ElectricityDisplay.MeasurementUnit[]{MICRO, MILLI, KILO, MEGA}; + + + private MeasurementUnit(String var1, int var2, String name, String symbol, double value) { + this.name = name; + this.symbol = symbol; + this.value = value; + } + + public String getName(boolean isSymbol) { + return isSymbol?this.symbol:this.name; + } + + public double process(double value) { + return value / this.value; + } + + } +} diff --git a/src/main/java/universalelectricity/core/electricity/ElectricityNetwork.java b/src/main/java/universalelectricity/core/electricity/ElectricityNetwork.java new file mode 100644 index 0000000..a269201 --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/ElectricityNetwork.java @@ -0,0 +1,330 @@ +package universalelectricity.core.electricity; + +import cpw.mods.fml.common.FMLLog; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.List; +import java.util.Set; +import java.util.Map.Entry; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IConductor; +import universalelectricity.core.block.IConnectionProvider; +import universalelectricity.core.block.INetworkProvider; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.electricity.IElectricityNetwork; +import universalelectricity.core.path.PathfinderChecker; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; + +public class ElectricityNetwork implements IElectricityNetwork { + + private final HashMap producers = new HashMap(); + private final HashMap consumers = new HashMap(); + private final Set conductors = new HashSet(); + + + public ElectricityNetwork() {} + + public ElectricityNetwork(IConductor ... conductors) { + this.conductors.addAll(Arrays.asList(conductors)); + } + + public void startProducing(TileEntity tileEntity, ElectricityPack electricityPack) { + if(tileEntity != null && electricityPack.getWatts() > 0.0D) { + this.producers.put(tileEntity, electricityPack); + } + + } + + public void startProducing(TileEntity tileEntity, double amperes, double voltage) { + this.startProducing(tileEntity, new ElectricityPack(amperes, voltage)); + } + + public boolean isProducing(TileEntity tileEntity) { + return this.producers.containsKey(tileEntity); + } + + public void stopProducing(TileEntity tileEntity) { + this.producers.remove(tileEntity); + } + + public void startRequesting(TileEntity tileEntity, ElectricityPack electricityPack) { + if(tileEntity != null && electricityPack.getWatts() > 0.0D) { + this.consumers.put(tileEntity, electricityPack); + } + + } + + public void startRequesting(TileEntity tileEntity, double amperes, double voltage) { + this.startRequesting(tileEntity, new ElectricityPack(amperes, voltage)); + } + + public boolean isRequesting(TileEntity tileEntity) { + return this.consumers.containsKey(tileEntity); + } + + public void stopRequesting(TileEntity tileEntity) { + this.consumers.remove(tileEntity); + } + + public ElectricityPack getProduced(TileEntity ... ignoreTiles) { + ElectricityPack totalElectricity = new ElectricityPack(0.0D, 0.0D); + Iterator it = this.producers.entrySet().iterator(); + + label47: + while(it.hasNext()) { + Entry pairs = (Entry)it.next(); + if(pairs != null) { + TileEntity tileEntity = (TileEntity)pairs.getKey(); + if(tileEntity == null) { + it.remove(); + } else if(tileEntity.isInvalid()) { + it.remove(); + } else if(tileEntity.getWorldObj().getTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord) != tileEntity) { + it.remove(); + } else { + if(ignoreTiles != null) { + TileEntity[] pack = ignoreTiles; + int newWatts = ignoreTiles.length; + + for(int i$ = 0; i$ < newWatts; ++i$) { + TileEntity newVoltage = pack[i$]; + if(tileEntity == newVoltage) { + continue label47; + } + } + } + + ElectricityPack var11 = (ElectricityPack)pairs.getValue(); + if(pairs.getKey() != null && pairs.getValue() != null && var11 != null) { + double var12 = totalElectricity.getWatts() + var11.getWatts(); + double var13 = Math.max(totalElectricity.voltage, var11.voltage); + totalElectricity.amperes = var12 / var13; + totalElectricity.voltage = var13; + } + } + } + } + + return totalElectricity; + } + + public ElectricityPack getRequest(TileEntity ... ignoreTiles) { + ElectricityPack totalElectricity = this.getRequestWithoutReduction(); + totalElectricity.amperes = Math.max(totalElectricity.amperes - this.getProduced(ignoreTiles).amperes, 0.0D); + return totalElectricity; + } + + public ElectricityPack getRequestWithoutReduction() { + ElectricityPack totalElectricity = new ElectricityPack(0.0D, 0.0D); + Iterator it = this.consumers.entrySet().iterator(); + + while(it.hasNext()) { + Entry pairs = (Entry)it.next(); + if(pairs != null) { + TileEntity tileEntity = (TileEntity)pairs.getKey(); + if(tileEntity == null) { + it.remove(); + } else if(tileEntity.isInvalid()) { + it.remove(); + } else if(tileEntity.getWorldObj().getTileEntity(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord) != tileEntity) { + it.remove(); + } else { + ElectricityPack pack = (ElectricityPack)pairs.getValue(); + if(pack != null) { + totalElectricity.amperes += pack.amperes; + totalElectricity.voltage = Math.max(totalElectricity.voltage, pack.voltage); + } + } + } + } + + return totalElectricity; + } + + public ElectricityPack consumeElectricity(TileEntity tileEntity) { + ElectricityPack totalElectricity = new ElectricityPack(0.0D, 0.0D); + + try { + ElectricityPack e = (ElectricityPack)this.consumers.get(tileEntity); + if(this.consumers.containsKey(tileEntity) && e != null) { + totalElectricity = this.getProduced(new TileEntity[0]); + if(totalElectricity.getWatts() > 0.0D) { + ElectricityPack totalRequest = this.getRequestWithoutReduction(); + totalElectricity.amperes *= e.amperes / totalRequest.amperes; + int distance = this.conductors.size(); + double ampsReceived = totalElectricity.amperes - totalElectricity.amperes * totalElectricity.amperes * this.getTotalResistance() / totalElectricity.voltage; + double voltsReceived = totalElectricity.voltage - totalElectricity.amperes * this.getTotalResistance(); + totalElectricity.amperes = ampsReceived; + totalElectricity.voltage = voltsReceived; + return totalElectricity; + } + } + } catch (Exception var10) { + FMLLog.severe("Failed to consume electricity!", new Object[0]); + var10.printStackTrace(); + } + + return totalElectricity; + } + + public HashMap getProducers() { + return this.producers; + } + + public List getProviders() { + ArrayList providers = new ArrayList(); + providers.addAll(this.producers.keySet()); + return providers; + } + + public HashMap getConsumers() { + return this.consumers; + } + + public List getReceivers() { + ArrayList receivers = new ArrayList(); + receivers.addAll(this.consumers.keySet()); + return receivers; + } + + public void cleanUpConductors() { + Iterator it = this.conductors.iterator(); + + while(it.hasNext()) { + IConductor conductor = (IConductor)it.next(); + if(conductor == null) { + it.remove(); + } else if(((TileEntity)conductor).isInvalid()) { + it.remove(); + } else { + conductor.setNetwork(this); + } + } + + } + + public void refreshConductors() { + this.cleanUpConductors(); + + try { + Iterator e = this.conductors.iterator(); + + while(e.hasNext()) { + IConductor conductor = (IConductor)e.next(); + conductor.updateAdjacentConnections(); + } + } catch (Exception var3) { + FMLLog.severe("Universal Electricity: Failed to refresh conductor.", new Object[0]); + var3.printStackTrace(); + } + + } + + public double getTotalResistance() { + double resistance = 0.0D; + + IConductor conductor; + for(Iterator i$ = this.conductors.iterator(); i$.hasNext(); resistance += conductor.getResistance()) { + conductor = (IConductor)i$.next(); + } + + return resistance; + } + + public double getLowestCurrentCapacity() { + double lowestAmp = 0.0D; + Iterator i$ = this.conductors.iterator(); + + while(i$.hasNext()) { + IConductor conductor = (IConductor)i$.next(); + if(lowestAmp == 0.0D || conductor.getCurrentCapcity() < lowestAmp) { + lowestAmp = conductor.getCurrentCapcity(); + } + } + + return lowestAmp; + } + + public Set getConductors() { + return this.conductors; + } + + public void mergeConnection(IElectricityNetwork network) { + if(network != null && network != this) { + ElectricityNetwork newNetwork = new ElectricityNetwork(); + newNetwork.getConductors().addAll(this.getConductors()); + newNetwork.getConductors().addAll(network.getConductors()); + newNetwork.cleanUpConductors(); + } + + } + + public void splitNetwork(IConnectionProvider splitPoint) { + if(splitPoint instanceof TileEntity) { + this.getConductors().remove(splitPoint); + ForgeDirection[] connectedBlocks = ForgeDirection.values(); + int i = connectedBlocks.length; + + for(int connectedBlockA = 0; connectedBlockA < i; ++connectedBlockA) { + ForgeDirection ii = connectedBlocks[connectedBlockA]; + if(ii != ForgeDirection.UNKNOWN) { + Vector3 connectedBlockB = new Vector3((TileEntity)splitPoint); + TileEntity finder = VectorHelper.getTileEntityFromSide(((TileEntity)splitPoint).getWorldObj(), connectedBlockB, ii); + if(this.producers.containsKey(finder)) { + this.stopProducing(finder); + this.stopRequesting(finder); + } + } + } + + TileEntity[] var12 = splitPoint.getAdjacentConnections(); + + for(i = 0; i < var12.length; ++i) { + TileEntity var13 = var12[i]; + if(var13 instanceof IConnectionProvider) { + for(int var14 = 0; var14 < var12.length; ++var14) { + TileEntity var15 = var12[var14]; + if(var13 != var15 && var15 instanceof IConnectionProvider) { + PathfinderChecker var16 = new PathfinderChecker(((TileEntity)splitPoint).getWorldObj(), (IConnectionProvider)var15, new IConnectionProvider[]{splitPoint}); + var16.init(new Vector3(var13)); + if(var16.results.size() > 0) { + Iterator newNetwork = var16.closedSet.iterator(); + + while(newNetwork.hasNext()) { + Vector3 i$ = (Vector3)newNetwork.next(); + TileEntity node = i$.getTileEntity(((TileEntity)splitPoint).getWorldObj()); + if(node instanceof INetworkProvider && node != splitPoint) { + ((INetworkProvider)node).setNetwork(this); + } + } + } else { + ElectricityNetwork var17 = new ElectricityNetwork(); + Iterator var18 = var16.closedSet.iterator(); + + while(var18.hasNext()) { + Vector3 var19 = (Vector3)var18.next(); + TileEntity nodeTile = var19.getTileEntity(((TileEntity)splitPoint).getWorldObj()); + if(nodeTile instanceof INetworkProvider && nodeTile != splitPoint) { + var17.getConductors().add((IConductor)nodeTile); + } + } + + var17.cleanUpConductors(); + } + } + } + } + } + } + + } + + public String toString() { + return "ElectricityNetwork[" + this.hashCode() + "|Wires:" + this.conductors.size() + "]"; + } +} diff --git a/src/main/java/universalelectricity/core/electricity/ElectricityNetworkHelper.java b/src/main/java/universalelectricity/core/electricity/ElectricityNetworkHelper.java new file mode 100644 index 0000000..9d143a5 --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/ElectricityNetworkHelper.java @@ -0,0 +1,140 @@ +package universalelectricity.core.electricity; + +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.Iterator; +import java.util.List; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IConnector; +import universalelectricity.core.block.INetworkProvider; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.electricity.IElectricityNetwork; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; + +public class ElectricityNetworkHelper { + + public static void invalidate(TileEntity tileEntity) { + for(int i = 0; i < 6; ++i) { + ForgeDirection direction = ForgeDirection.getOrientation(i); + TileEntity checkTile = VectorHelper.getConnectorFromSide(tileEntity.getWorldObj(), new Vector3(tileEntity), direction); + if(checkTile instanceof INetworkProvider) { + IElectricityNetwork network = ((INetworkProvider)checkTile).getNetwork(); + if(network != null) { + network.stopRequesting(tileEntity); + network.stopProducing(tileEntity); + } + } + } + + } + + public static EnumSet getDirections(TileEntity tileEntity) { + EnumSet possibleSides = EnumSet.noneOf(ForgeDirection.class); + if(tileEntity instanceof IConnector) { + for(int i = 0; i < 6; ++i) { + ForgeDirection direction = ForgeDirection.getOrientation(i); + if(((IConnector)tileEntity).canConnect(direction)) { + possibleSides.add(direction); + } + } + } + + return possibleSides; + } + + public static ElectricityPack produceFromMultipleSides(TileEntity tileEntity, ElectricityPack electricityPack) { + return produceFromMultipleSides(tileEntity, getDirections(tileEntity), electricityPack); + } + + public static ElectricityPack produceFromMultipleSides(TileEntity tileEntity, EnumSet approachingDirection, ElectricityPack producingPack) { + ElectricityPack remainingElectricity = producingPack.clone(); + if(tileEntity != null && approachingDirection != null) { + List connectedNetworks = getNetworksFromMultipleSides(tileEntity, approachingDirection); + if(connectedNetworks.size() > 0) { + double wattsPerSide = producingPack.getWatts() / (double)connectedNetworks.size(); + double voltage = producingPack.voltage; + Iterator i$ = connectedNetworks.iterator(); + + while(i$.hasNext()) { + IElectricityNetwork network = (IElectricityNetwork)i$.next(); + if(wattsPerSide > 0.0D && producingPack.getWatts() > 0.0D) { + double amperes = Math.min(wattsPerSide / voltage, network.getRequest(new TileEntity[]{tileEntity}).amperes); + if(amperes > 0.0D) { + network.startProducing(tileEntity, amperes, voltage); + remainingElectricity.amperes -= amperes; + } + } else { + network.stopProducing(tileEntity); + } + } + } + } + + return remainingElectricity; + } + + public static ElectricityPack consumeFromMultipleSides(TileEntity tileEntity, ElectricityPack electricityPack) { + return consumeFromMultipleSides(tileEntity, getDirections(tileEntity), electricityPack); + } + + public static ElectricityPack consumeFromMultipleSides(TileEntity tileEntity, EnumSet approachingDirection, ElectricityPack requestPack) { + ElectricityPack consumedPack = new ElectricityPack(); + if(tileEntity != null && approachingDirection != null) { + List connectedNetworks = getNetworksFromMultipleSides(tileEntity, approachingDirection); + if(connectedNetworks.size() > 0) { + double wattsPerSide = requestPack.getWatts() / (double)connectedNetworks.size(); + double voltage = requestPack.voltage; + Iterator i$ = connectedNetworks.iterator(); + + while(i$.hasNext()) { + IElectricityNetwork network = (IElectricityNetwork)i$.next(); + if(wattsPerSide > 0.0D && requestPack.getWatts() > 0.0D) { + network.startRequesting(tileEntity, wattsPerSide / voltage, voltage); + ElectricityPack receivedPack = network.consumeElectricity(tileEntity); + consumedPack.amperes += receivedPack.amperes; + consumedPack.voltage = Math.max(consumedPack.voltage, receivedPack.voltage); + } else { + network.stopRequesting(tileEntity); + } + } + } + } + + return consumedPack; + } + + public static List getNetworksFromMultipleSides(TileEntity tileEntity, EnumSet approachingDirection) { + ArrayList connectedNetworks = new ArrayList(); + + for(int i = 0; i < 6; ++i) { + ForgeDirection direction = ForgeDirection.getOrientation(i); + if(approachingDirection.contains(direction)) { + Vector3 position = new Vector3(tileEntity); + position.modifyPositionFromSide(direction); + TileEntity outputConductor = position.getTileEntity(tileEntity.getWorldObj()); + IElectricityNetwork electricityNetwork = getNetworkFromTileEntity(outputConductor, direction); + if(electricityNetwork != null && !connectedNetworks.contains(connectedNetworks)) { + connectedNetworks.add(electricityNetwork); + } + } + } + + return connectedNetworks; + } + + public static IElectricityNetwork getNetworkFromTileEntity(TileEntity tileEntity, ForgeDirection approachDirection) { + if(tileEntity != null && tileEntity instanceof INetworkProvider) { + if(!(tileEntity instanceof IConnector)) { + return ((INetworkProvider)tileEntity).getNetwork(); + } + + if(((IConnector)tileEntity).canConnect(approachDirection.getOpposite())) { + return ((INetworkProvider)tileEntity).getNetwork(); + } + } + + return null; + } +} diff --git a/src/main/java/universalelectricity/core/electricity/ElectricityPack.java b/src/main/java/universalelectricity/core/electricity/ElectricityPack.java new file mode 100644 index 0000000..1560db0 --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/ElectricityPack.java @@ -0,0 +1,102 @@ +package universalelectricity.core.electricity; + + +public class ElectricityPack implements Cloneable { + + public double amperes; + public double voltage; + + + public ElectricityPack(double amperes, double voltage) { + this.amperes = amperes; + this.voltage = voltage; + } + + public ElectricityPack() { + this(0.0D, 0.0D); + } + + public static ElectricityPack getFromWatts(double watts, double voltage) { + return new ElectricityPack(watts / voltage, voltage); + } + + public double getWatts() { + return getWatts(this.amperes, this.voltage); + } + + public double getConductance() { + return getConductance(this.amperes, this.voltage); + } + + public double getResistance() { + return getResistance(this.amperes, this.voltage); + } + + public static double getJoules(double watts, double seconds) { + return watts * seconds; + } + + public static double getJoules(double amps, double voltage, double seconds) { + return amps * voltage * seconds; + } + + public static double getWattsFromJoules(double joules, double seconds) { + return joules / seconds; + } + + public static double getAmps(double watts, double voltage) { + return watts / voltage; + } + + public static double getAmps(double ampHours) { + return ampHours * 3600.0D; + } + + public static double getAmpsFromWattHours(double wattHours, double voltage) { + return getWatts(wattHours) / voltage; + } + + public static double getWattHoursFromAmpHours(double ampHours, double voltage) { + return ampHours * voltage; + } + + public static double getAmpHours(double amps) { + return amps / 3600.0D; + } + + public static double getWatts(double amps, double voltage) { + return amps * voltage; + } + + public static double getWatts(double wattHours) { + return wattHours * 3600.0D; + } + + public static double getWattHours(double watts) { + return watts / 3600.0D; + } + + public static double getWattHours(double amps, double voltage) { + return getWattHours(getWatts(amps, voltage)); + } + + public static double getResistance(double amps, double voltage) { + return voltage / amps; + } + + public static double getConductance(double amps, double voltage) { + return amps / voltage; + } + + public String toString() { + return "ElectricityPack [Amps:" + this.amperes + " Volts:" + this.voltage + "]"; + } + + public ElectricityPack clone() { + return new ElectricityPack(this.amperes, this.voltage); + } + + public boolean isEqual(ElectricityPack electricityPack) { + return this.amperes == electricityPack.amperes && this.voltage == electricityPack.voltage; + } +} diff --git a/src/main/java/universalelectricity/core/electricity/IConductorRegistry.java b/src/main/java/universalelectricity/core/electricity/IConductorRegistry.java new file mode 100644 index 0000000..79aa9db --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/IConductorRegistry.java @@ -0,0 +1,15 @@ +package universalelectricity.core.electricity; + +import java.util.List; +import universalelectricity.core.block.IConductor; + +public interface IConductorRegistry { + + void register(IConductor var1); + + void cleanConductors(); + + void resetAllConnections(); + + List getConductors(); +} diff --git a/src/main/java/universalelectricity/core/electricity/IElectricityNetwork.java b/src/main/java/universalelectricity/core/electricity/IElectricityNetwork.java new file mode 100644 index 0000000..d0d95c6 --- /dev/null +++ b/src/main/java/universalelectricity/core/electricity/IElectricityNetwork.java @@ -0,0 +1,57 @@ +package universalelectricity.core.electricity; + +import java.util.HashMap; +import java.util.List; +import java.util.Set; +import net.minecraft.tileentity.TileEntity; +import universalelectricity.core.block.IConnectionProvider; +import universalelectricity.core.electricity.ElectricityPack; + +public interface IElectricityNetwork { + + void startProducing(TileEntity var1, ElectricityPack var2); + + void startProducing(TileEntity var1, double var2, double var4); + + boolean isProducing(TileEntity var1); + + void stopProducing(TileEntity var1); + + void startRequesting(TileEntity var1, ElectricityPack var2); + + void startRequesting(TileEntity var1, double var2, double var4); + + boolean isRequesting(TileEntity var1); + + void stopRequesting(TileEntity var1); + + ElectricityPack getProduced(TileEntity ... var1); + + ElectricityPack getRequest(TileEntity ... var1); + + ElectricityPack getRequestWithoutReduction(); + + ElectricityPack consumeElectricity(TileEntity var1); + + HashMap getProducers(); + + List getProviders(); + + HashMap getConsumers(); + + List getReceivers(); + + Set getConductors(); + + double getTotalResistance(); + + double getLowestCurrentCapacity(); + + void cleanUpConductors(); + + void refreshConductors(); + + void mergeConnection(IElectricityNetwork var1); + + void splitNetwork(IConnectionProvider var1); +} diff --git a/src/main/java/universalelectricity/core/item/ElectricItemHelper.java b/src/main/java/universalelectricity/core/item/ElectricItemHelper.java new file mode 100644 index 0000000..6a3c16f --- /dev/null +++ b/src/main/java/universalelectricity/core/item/ElectricItemHelper.java @@ -0,0 +1,60 @@ +package universalelectricity.core.item; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.IItemElectric; + +public class ElectricItemHelper { + + public static double chargeItem(ItemStack itemStack, double joules, double voltage) { + if(itemStack != null && itemStack.getItem() instanceof IItemElectric) { + IItemElectric electricItem = (IItemElectric)itemStack.getItem(); + double providingWatts = Math.min(joules, electricItem.getReceiveRequest(itemStack).getWatts()); + if(providingWatts > 0.0D) { + ElectricityPack providedElectricity = electricItem.onReceive(ElectricityPack.getFromWatts(providingWatts, voltage), itemStack); + return providedElectricity.getWatts(); + } + } + + return 0.0D; + } + + public static double dechargeItem(ItemStack itemStack, double joules, double voltage) { + if(itemStack != null && itemStack.getItem() instanceof IItemElectric) { + IItemElectric electricItem = (IItemElectric)itemStack.getItem(); + double requestingWatts = Math.min(joules, electricItem.getProvideRequest(itemStack).getWatts()); + if(requestingWatts > 0.0D) { + ElectricityPack receivedElectricity = electricItem.onProvide(ElectricityPack.getFromWatts(requestingWatts, voltage), itemStack); + return receivedElectricity.getWatts(); + } + } + + return 0.0D; + } + + public static ItemStack getWithCharge(ItemStack itemStack, double joules) { + if(itemStack != null && itemStack.getItem() instanceof IItemElectric) { + ((IItemElectric)itemStack.getItem()).setJoules(joules, itemStack); + return itemStack; + } else { + return itemStack; + } + } + + public static ItemStack getWithCharge(Item item, double joules) { + return getWithCharge(new ItemStack(item), joules); + } + + public static ItemStack getCloneWithCharge(ItemStack itemStack, double joules) { + return getWithCharge(itemStack.copy(), joules); + } + + public static ItemStack getUncharged(ItemStack itemStack) { + return getWithCharge(itemStack, 0.0D); + } + + public static ItemStack getUncharged(Item item) { + return getUncharged(new ItemStack(item)); + } +} diff --git a/src/main/java/universalelectricity/core/item/IItemElectric.java b/src/main/java/universalelectricity/core/item/IItemElectric.java new file mode 100644 index 0000000..17eb647 --- /dev/null +++ b/src/main/java/universalelectricity/core/item/IItemElectric.java @@ -0,0 +1,17 @@ +package universalelectricity.core.item; + +import net.minecraft.item.ItemStack; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.IItemElectricityStorage; +import universalelectricity.core.item.IItemVoltage; + +public interface IItemElectric extends IItemElectricityStorage, IItemVoltage { + + ElectricityPack onReceive(ElectricityPack var1, ItemStack var2); + + ElectricityPack onProvide(ElectricityPack var1, ItemStack var2); + + ElectricityPack getReceiveRequest(ItemStack var1); + + ElectricityPack getProvideRequest(ItemStack var1); +} diff --git a/src/main/java/universalelectricity/core/item/IItemElectricityStorage.java b/src/main/java/universalelectricity/core/item/IItemElectricityStorage.java new file mode 100644 index 0000000..5a88ab4 --- /dev/null +++ b/src/main/java/universalelectricity/core/item/IItemElectricityStorage.java @@ -0,0 +1,12 @@ +package universalelectricity.core.item; + +import net.minecraft.item.ItemStack; + +public interface IItemElectricityStorage { + + double getJoules(ItemStack var1); + + void setJoules(double var1, ItemStack var3); + + double getMaxJoules(ItemStack var1); +} diff --git a/src/main/java/universalelectricity/core/item/IItemVoltage.java b/src/main/java/universalelectricity/core/item/IItemVoltage.java new file mode 100644 index 0000000..b5b577d --- /dev/null +++ b/src/main/java/universalelectricity/core/item/IItemVoltage.java @@ -0,0 +1,8 @@ +package universalelectricity.core.item; + +import net.minecraft.item.ItemStack; + +public interface IItemVoltage { + + double getVoltage(ItemStack var1); +} diff --git a/src/main/java/universalelectricity/core/item/ItemElectric.java b/src/main/java/universalelectricity/core/item/ItemElectric.java new file mode 100644 index 0000000..eac9b03 --- /dev/null +++ b/src/main/java/universalelectricity/core/item/ItemElectric.java @@ -0,0 +1,92 @@ +package universalelectricity.core.item; + +import java.util.List; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.world.World; +import universalelectricity.core.electricity.ElectricityDisplay; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.core.item.ElectricItemHelper; +import universalelectricity.core.item.IItemElectric; + +public abstract class ItemElectric extends Item implements IItemElectric { + + public ItemElectric() { + super(); + this.setMaxStackSize(1); + this.setMaxDamage(100); + this.setNoRepair(); + } + + public void addInformation(ItemStack itemStack, EntityPlayer entityPlayer, List list, boolean par4) { + String color = ""; + double joules = this.getJoules(itemStack); + if(joules <= this.getMaxJoules(itemStack) / 3.0D) { + color = "§4"; + } else if(joules > this.getMaxJoules(itemStack) * 2.0D / 3.0D) { + color = "§2"; + } else { + color = "§6"; + } + + list.add(color + ElectricityDisplay.getDisplay(joules, ElectricityDisplay.ElectricUnit.JOULES) + "/" + ElectricityDisplay.getDisplay(this.getMaxJoules(itemStack), ElectricityDisplay.ElectricUnit.JOULES)); + } + + public void onCreated(ItemStack itemStack, World par2World, EntityPlayer par3EntityPlayer) { + this.setJoules(0.0D, itemStack); + } + + public ElectricityPack onReceive(ElectricityPack electricityPack, ItemStack itemStack) { + double rejectedElectricity = Math.max(this.getJoules(itemStack) + electricityPack.getWatts() - this.getMaxJoules(itemStack), 0.0D); + double joulesToStore = electricityPack.getWatts() - rejectedElectricity; + this.setJoules(this.getJoules(itemStack) + joulesToStore, itemStack); + return ElectricityPack.getFromWatts(joulesToStore, this.getVoltage(itemStack)); + } + + public ElectricityPack onProvide(ElectricityPack electricityPack, ItemStack itemStack) { + double electricityToUse = Math.min(this.getJoules(itemStack), electricityPack.getWatts()); + this.setJoules(this.getJoules(itemStack) - electricityToUse, itemStack); + return ElectricityPack.getFromWatts(electricityToUse, this.getVoltage(itemStack)); + } + + public ElectricityPack getReceiveRequest(ItemStack itemStack) { + return ElectricityPack.getFromWatts(Math.min(this.getMaxJoules(itemStack) - this.getJoules(itemStack), this.getTransferRate(itemStack)), this.getVoltage(itemStack)); + } + + public ElectricityPack getProvideRequest(ItemStack itemStack) { + return ElectricityPack.getFromWatts(Math.min(this.getJoules(itemStack), this.getTransferRate(itemStack)), this.getVoltage(itemStack)); + } + + public double getTransferRate(ItemStack itemStack) { + return this.getMaxJoules(itemStack) * 0.01D; + } + + public void setJoules(double joules, ItemStack itemStack) { + if(itemStack.getTagCompound() == null) { + itemStack.setTagCompound(new NBTTagCompound()); + } + + double electricityStored = Math.max(Math.min(joules, this.getMaxJoules(itemStack)), 0.0D); + itemStack.getTagCompound().setDouble("electricity", electricityStored); + itemStack.setItemDamage((int)(100.0D - electricityStored / this.getMaxJoules(itemStack) * 100.0D)); + } + + public double getJoules(ItemStack itemStack) { + if(itemStack.getTagCompound() == null) { + return 0.0D; + } else { + double electricityStored = itemStack.getTagCompound().getDouble("electricity"); + itemStack.setItemDamage((int)(100.0D - electricityStored / this.getMaxJoules(itemStack) * 100.0D)); + return electricityStored; + } + } + + public void func_77633_a(int par1, CreativeTabs par2CreativeTabs, List par3List) { + par3List.add(ElectricItemHelper.getUncharged(new ItemStack(this))); + ItemStack chargedItem = new ItemStack(this); + par3List.add(ElectricItemHelper.getWithCharge(chargedItem, this.getMaxJoules(chargedItem))); + } +} diff --git a/src/main/java/universalelectricity/core/path/IPathCallBack.java b/src/main/java/universalelectricity/core/path/IPathCallBack.java new file mode 100644 index 0000000..fc20f3b --- /dev/null +++ b/src/main/java/universalelectricity/core/path/IPathCallBack.java @@ -0,0 +1,12 @@ +package universalelectricity.core.path; + +import java.util.Set; +import universalelectricity.core.path.Pathfinder; +import universalelectricity.core.vector.Vector3; + +public interface IPathCallBack { + + Set getConnectedNodes(Pathfinder var1, Vector3 var2); + + boolean onSearch(Pathfinder var1, Vector3 var2); +} diff --git a/src/main/java/universalelectricity/core/path/Pathfinder.java b/src/main/java/universalelectricity/core/path/Pathfinder.java new file mode 100644 index 0000000..e137fde --- /dev/null +++ b/src/main/java/universalelectricity/core/path/Pathfinder.java @@ -0,0 +1,51 @@ +package universalelectricity.core.path; + +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import universalelectricity.core.path.IPathCallBack; +import universalelectricity.core.vector.Vector3; + +public class Pathfinder { + + public IPathCallBack callBackCheck; + public Set closedSet; + public Set results; + + + public Pathfinder(IPathCallBack callBack) { + this.callBackCheck = callBack; + this.reset(); + } + + public boolean findNodes(Vector3 currentNode) { + this.closedSet.add(currentNode); + if(this.callBackCheck.onSearch(this, currentNode)) { + return false; + } else { + Iterator i$ = this.callBackCheck.getConnectedNodes(this, currentNode).iterator(); + + Vector3 node; + do { + if(!i$.hasNext()) { + return false; + } + + node = (Vector3)i$.next(); + } while(this.closedSet.contains(node) || !this.findNodes(node)); + + return true; + } + } + + public Pathfinder init(Vector3 startNode) { + this.findNodes(startNode); + return this; + } + + public Pathfinder reset() { + this.closedSet = new HashSet(); + this.results = new HashSet(); + return this; + } +} diff --git a/src/main/java/universalelectricity/core/path/PathfinderAStar.java b/src/main/java/universalelectricity/core/path/PathfinderAStar.java new file mode 100644 index 0000000..51eae44 --- /dev/null +++ b/src/main/java/universalelectricity/core/path/PathfinderAStar.java @@ -0,0 +1,112 @@ +package universalelectricity.core.path; + +import java.util.HashMap; +import java.util.HashSet; +import java.util.Iterator; +import java.util.Set; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.path.IPathCallBack; +import universalelectricity.core.path.Pathfinder; +import universalelectricity.core.vector.Vector3; + +public class PathfinderAStar extends Pathfinder { + + public IPathCallBack callBackCheck; + public Set openSet; + public HashMap navigationMap; + public HashMap gScore; + public HashMap fScore; + public Vector3 goal; + + + public PathfinderAStar(IPathCallBack callBack, Vector3 goal) { + super(callBack); + this.goal = goal; + } + + public boolean findNodes(Vector3 start) { + this.openSet.add(start); + this.gScore.put(start, Double.valueOf(0.0D)); + this.fScore.put(start, Double.valueOf(((Double)this.gScore.get(start)).doubleValue() + this.getHeuristicEstimatedCost(start, this.goal))); + + while(!this.openSet.isEmpty()) { + Vector3 currentNode = null; + double lowestFScore = 0.0D; + Iterator i$ = this.openSet.iterator(); + + Vector3 neighbor; + while(i$.hasNext()) { + neighbor = (Vector3)i$.next(); + if(currentNode == null || ((Double)this.fScore.get(neighbor)).doubleValue() < lowestFScore) { + currentNode = neighbor; + lowestFScore = ((Double)this.fScore.get(neighbor)).doubleValue(); + } + } + + if(currentNode == null) { + break; + } + + if(this.callBackCheck.onSearch(this, currentNode)) { + return false; + } + + if(currentNode.equals(this.goal)) { + super.results = this.reconstructPath(this.navigationMap, this.goal); + return true; + } + + this.openSet.remove(currentNode); + super.closedSet.add(currentNode); + i$ = this.getNeighborNodes(currentNode).iterator(); + + while(i$.hasNext()) { + neighbor = (Vector3)i$.next(); + double tentativeGScore = ((Double)this.gScore.get(currentNode)).doubleValue() + currentNode.distanceTo(neighbor); + if((!super.closedSet.contains(neighbor) || tentativeGScore < ((Double)this.gScore.get(neighbor)).doubleValue()) && (!this.openSet.contains(neighbor) || tentativeGScore < ((Double)this.gScore.get(neighbor)).doubleValue())) { + this.navigationMap.put(neighbor, currentNode); + this.gScore.put(neighbor, Double.valueOf(tentativeGScore)); + this.fScore.put(neighbor, Double.valueOf(((Double)this.gScore.get(neighbor)).doubleValue() + this.getHeuristicEstimatedCost(neighbor, this.goal))); + this.openSet.add(neighbor); + } + } + } + + return false; + } + + public Pathfinder reset() { + this.openSet = new HashSet(); + this.navigationMap = new HashMap(); + return super.reset(); + } + + public Set reconstructPath(HashMap nagivationMap, Vector3 current_node) { + HashSet path = new HashSet(); + path.add(current_node); + if(nagivationMap.containsKey(current_node)) { + path.addAll(this.reconstructPath(nagivationMap, (Vector3)nagivationMap.get(current_node))); + return path; + } else { + return path; + } + } + + public double getHeuristicEstimatedCost(Vector3 start, Vector3 goal) { + return start.distanceTo(goal); + } + + public Set getNeighborNodes(Vector3 vector) { + if(this.callBackCheck != null) { + return this.callBackCheck.getConnectedNodes(this, vector); + } else { + HashSet neighbors = new HashSet(); + + for(int i = 0; i < 6; ++i) { + neighbors.add(vector.clone().modifyPositionFromSide(ForgeDirection.getOrientation(i))); + } + + return neighbors; + } + } +} diff --git a/src/main/java/universalelectricity/core/path/PathfinderChecker.java b/src/main/java/universalelectricity/core/path/PathfinderChecker.java new file mode 100644 index 0000000..7e7bd08 --- /dev/null +++ b/src/main/java/universalelectricity/core/path/PathfinderChecker.java @@ -0,0 +1,43 @@ +package universalelectricity.core.path; + +import java.util.Arrays; +import java.util.HashSet; +import java.util.Set; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IConductor; +import universalelectricity.core.block.IConnectionProvider; +import universalelectricity.core.path.IPathCallBack; +import universalelectricity.core.path.Pathfinder; +import universalelectricity.core.vector.Vector3; + +public class PathfinderChecker extends Pathfinder { + + public PathfinderChecker(final World world, final IConnectionProvider targetConnector, final IConnectionProvider ... ignoreConnector) { + super(new IPathCallBack() { + public Set getConnectedNodes(Pathfinder finder, Vector3 currentNode) { + HashSet neighbors = new HashSet(); + + for(int i = 0; i < 6; ++i) { + ForgeDirection direction = ForgeDirection.getOrientation(i); + Vector3 position = currentNode.clone().modifyPositionFromSide(direction); + TileEntity connectedBlock = position.getTileEntity(world); + if(connectedBlock instanceof IConductor && !Arrays.asList(ignoreConnector).contains(connectedBlock) && ((IConductor)connectedBlock).canConnect(direction.getOpposite())) { + neighbors.add(position); + } + } + + return neighbors; + } + public boolean onSearch(Pathfinder finder, Vector3 node) { + if(node.getTileEntity(world) == targetConnector) { + finder.results.add(node); + return true; + } else { + return false; + } + } + }); + } +} diff --git a/src/main/java/universalelectricity/core/vector/Vector2.java b/src/main/java/universalelectricity/core/vector/Vector2.java new file mode 100644 index 0000000..4b9e35f --- /dev/null +++ b/src/main/java/universalelectricity/core/vector/Vector2.java @@ -0,0 +1,101 @@ +package universalelectricity.core.vector; + +import net.minecraft.util.MathHelper; + +public class Vector2 implements Cloneable { + + public double x; + public double y; + + + public Vector2() { + this(0.0D, 0.0D); + } + + public Vector2(double x, double y) { + this.x = x; + this.y = y; + } + + public int intX() { + return (int)Math.floor(this.x); + } + + public int intY() { + return (int)Math.floor(this.y); + } + + public Vector2 clone() { + return new Vector2(this.x, this.y); + } + + public static double distance(Vector2 point1, Vector2 point2) { + double xDifference = point1.x - point2.x; + double yDiference = point1.y - point2.y; + return (double)MathHelper.sqrt_double(xDifference * xDifference + yDiference * yDiference); + } + + public static double slope(Vector2 point1, Vector2 point2) { + double xDifference = point1.x - point2.x; + double yDiference = point1.y - point2.y; + return yDiference / xDifference; + } + + public double distanceTo(Vector2 target) { + double xDifference = this.x - target.x; + double yDifference = this.y - target.y; + return (double)MathHelper.sqrt_double(xDifference * xDifference + yDifference * yDifference); + } + + public Vector2 add(Vector2 par1) { + this.x += par1.x; + this.y += par1.y; + return this; + } + + public Vector2 add(double par1) { + this.x += par1; + this.y += par1; + return this; + } + + public Vector2 invert() { + this.multiply(-1.0D); + return this; + } + + public Vector2 multiply(double amount) { + this.x *= amount; + this.y *= amount; + return this; + } + + public Vector2 round() { + return new Vector2((double)Math.round(this.x), (double)Math.round(this.y)); + } + + public Vector2 ceil() { + return new Vector2(Math.ceil(this.x), Math.ceil(this.y)); + } + + public Vector2 floor() { + return new Vector2(Math.floor(this.x), Math.floor(this.y)); + } + + public int hashCode() { + return ("X:" + this.x + "Y:" + this.y).hashCode(); + } + + public boolean equals(Object o) { + if(!(o instanceof Vector2)) { + return false; + } else { + Vector2 vector = (Vector2)o; + return this.x == vector.x && this.y == vector.y; + } + } + + public String toString() { + return "Vector2 [" + this.x + "," + this.y + "]"; + } +} diff --git a/src/main/java/universalelectricity/core/vector/Vector3.java b/src/main/java/universalelectricity/core/vector/Vector3.java new file mode 100644 index 0000000..766e7ae --- /dev/null +++ b/src/main/java/universalelectricity/core/vector/Vector3.java @@ -0,0 +1,286 @@ +package universalelectricity.core.vector; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.Entity; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.ChunkCoordinates; +import net.minecraft.util.MathHelper; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.Vec3; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +public class Vector3 implements Cloneable { + + public double x; + public double y; + public double z; + + + public Vector3() { + this(0.0D, 0.0D, 0.0D); + } + + public Vector3(double x, double y, double z) { + this.x = x; + this.y = y; + this.z = z; + } + + public Vector3(Entity par1) { + this.x = par1.posX; + this.y = par1.posY; + this.z = par1.posZ; + } + + public Vector3(TileEntity par1) { + this.x = (double)par1.xCoord; + this.y = (double)par1.yCoord; + this.z = (double)par1.zCoord; + } + + public Vector3(Vec3 par1) { + this.x = par1.xCoord; + this.y = par1.yCoord; + this.z = par1.zCoord; + } + + public Vector3(MovingObjectPosition par1) { + this.x = (double)par1.blockX; + this.y = (double)par1.blockY; + this.z = (double)par1.blockZ; + } + + public Vector3(ChunkCoordinates par1) { + this.x = (double)par1.posX; + this.y = (double)par1.posY; + this.z = (double)par1.posZ; + } + + public Vector3(ForgeDirection direction) { + this.x = (double)direction.offsetX; + this.y = (double)direction.offsetY; + this.z = (double)direction.offsetZ; + } + + public int intX() { + return (int)Math.floor(this.x); + } + + public int intY() { + return (int)Math.floor(this.y); + } + + public int intZ() { + return (int)Math.floor(this.z); + } + + public Vector3 clone() { + return new Vector3(this.x, this.y, this.z); + } + + public Block getBlock(IBlockAccess world) { + return world.getBlock(this.intX(), this.intY(), this.intZ()); + } + + public int getBlockMetadata(IBlockAccess world) { + return world.getBlockMetadata(this.intX(), this.intY(), this.intZ()); + } + + public TileEntity getTileEntity(IBlockAccess world) { + return world.getTileEntity(this.intX(), this.intY(), this.intZ()); + } + + public boolean setBlock(World world, Block block, int metadata, int notify) { + return world.setBlock(this.intX(), this.intY(), this.intZ(), block, metadata, notify); + } + + public boolean setBlock(World world, Block block, int metadata) { + return this.setBlock(world, block, metadata, 3); + } + + public boolean setBlock(World world, Block block) { + return this.setBlock(world, block, 0); + } + + public Vector2 toVector2() { + return new Vector2(this.x, this.z); + } + + public Vec3 toVec3() { + return Vec3.createVectorHelper(this.x, this.y, this.z); + } + + public double getMagnitude() { + return Math.sqrt(this.getMagnitudeSquared()); + } + + public double getMagnitudeSquared() { + return this.x * this.x + this.y * this.y + this.z * this.z; + } + + public Vector3 normalize() { + double d = this.getMagnitude(); + if(d != 0.0D) { + this.multiply(1.0D / d); + } + + return this; + } + + public static double distance(Vector3 par1, Vector3 par2) { + double var2 = par1.x - par2.x; + double var4 = par1.y - par2.y; + double var6 = par1.z - par2.z; + return (double)MathHelper.sqrt_double(var2 * var2 + var4 * var4 + var6 * var6); + } + + public double distanceTo(Vector3 vector3) { + double var2 = vector3.x - this.x; + double var4 = vector3.y - this.y; + double var6 = vector3.z - this.z; + return (double)MathHelper.sqrt_double(var2 * var2 + var4 * var4 + var6 * var6); + } + + public Vector3 add(Vector3 par1) { + this.x += par1.x; + this.y += par1.y; + this.z += par1.z; + return this; + } + + public Vector3 add(double par1) { + this.x += par1; + this.y += par1; + this.z += par1; + return this; + } + + public Vector3 subtract(Vector3 amount) { + this.x -= amount.x; + this.y -= amount.y; + this.z -= amount.z; + return this; + } + + public Vector3 invert() { + this.multiply(-1.0D); + return this; + } + + public Vector3 multiply(double amount) { + this.x *= amount; + this.y *= amount; + this.z *= amount; + return this; + } + + public Vector3 multiply(Vector3 vec) { + this.x *= vec.x; + this.y *= vec.y; + this.z *= vec.z; + return this; + } + + public static Vector3 subtract(Vector3 par1, Vector3 par2) { + return new Vector3(par1.x - par2.x, par1.y - par2.y, par1.z - par2.z); + } + + public static Vector3 add(Vector3 par1, Vector3 par2) { + return new Vector3(par1.x + par2.x, par1.y + par2.y, par1.z + par2.z); + } + + public static Vector3 add(Vector3 par1, double par2) { + return new Vector3(par1.x + par2, par1.y + par2, par1.z + par2); + } + + public static Vector3 multiply(Vector3 vec1, Vector3 vec2) { + return new Vector3(vec1.x * vec2.x, vec1.y * vec2.y, vec1.z * vec2.z); + } + + public static Vector3 multiply(Vector3 vec1, double vec2) { + return new Vector3(vec1.x * vec2, vec1.y * vec2, vec1.z * vec2); + } + + public Vector3 round() { + return new Vector3((double)Math.round(this.x), (double)Math.round(this.y), (double)Math.round(this.z)); + } + + public Vector3 ceil() { + return new Vector3(Math.ceil(this.x), Math.ceil(this.y), Math.ceil(this.z)); + } + + public Vector3 floor() { + return new Vector3(Math.floor(this.x), Math.floor(this.y), Math.floor(this.z)); + } + + public List getEntitiesWithin(World worldObj, Class par1Class) { + return worldObj.getEntitiesWithinAABB(par1Class, AxisAlignedBB.getBoundingBox((double)this.intX(), (double)this.intY(), (double)this.intZ(), (double)(this.intX() + 1), (double)(this.intY() + 1), (double)(this.intZ() + 1))); + } + + public Vector3 modifyPositionFromSide(ForgeDirection side, double amount) { + switch(side.ordinal()) { + case 0: + this.y -= amount; + break; + case 1: + this.y += amount; + break; + case 2: + this.z -= amount; + break; + case 3: + this.z += amount; + break; + case 4: + this.x -= amount; + break; + case 5: + this.x += amount; + } + + return this; + } + + public Vector3 modifyPositionFromSide(ForgeDirection side) { + this.modifyPositionFromSide(side, 1.0D); + return this; + } + + public static Vector3 readFromNBT(NBTTagCompound nbtCompound) { + Vector3 tempVector = new Vector3(); + tempVector.x = nbtCompound.getDouble("x"); + tempVector.y = nbtCompound.getDouble("y"); + tempVector.z = nbtCompound.getDouble("z"); + return tempVector; + } + + public NBTTagCompound writeToNBT(NBTTagCompound par1NBTTagCompound) { + par1NBTTagCompound.setDouble("x", this.x); + par1NBTTagCompound.setDouble("y", this.y); + par1NBTTagCompound.setDouble("z", this.z); + return par1NBTTagCompound; + } + + public int hashCode() { + return ("X:" + this.x + "Y:" + this.y + "Z:" + this.z).hashCode(); + } + + public boolean equals(Object o) { + if(!(o instanceof Vector3)) { + return false; + } else { + Vector3 vector3 = (Vector3)o; + return this.x == vector3.x && this.y == vector3.y && this.z == vector3.z; + } + } + + public String toString() { + return "Vector3 [" + this.x + "," + this.y + "," + this.z + "]"; + } +} diff --git a/src/main/java/universalelectricity/core/vector/VectorHelper.java b/src/main/java/universalelectricity/core/vector/VectorHelper.java new file mode 100644 index 0000000..0013758 --- /dev/null +++ b/src/main/java/universalelectricity/core/vector/VectorHelper.java @@ -0,0 +1,26 @@ +package universalelectricity.core.vector; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.core.block.IConnector; + +public class VectorHelper { + + public static final int[][] RELATIVE_MATRIX = new int[][]{{3, 2, 1, 0, 5, 4}, {4, 5, 0, 1, 2, 3}, {0, 1, 3, 2, 4, 5}, {0, 1, 2, 3, 5, 4}, {0, 1, 5, 4, 3, 2}, {0, 1, 4, 5, 2, 3}}; + + + public static ForgeDirection getOrientationFromSide(ForgeDirection front, ForgeDirection side) { + return front != ForgeDirection.UNKNOWN && side != ForgeDirection.UNKNOWN?ForgeDirection.getOrientation(RELATIVE_MATRIX[front.ordinal()][side.ordinal()]):ForgeDirection.UNKNOWN; + } + + public static TileEntity getConnectorFromSide(World world, Vector3 position, ForgeDirection side) { + TileEntity tileEntity = getTileEntityFromSide(world, position, side); + return tileEntity instanceof IConnector && ((IConnector)tileEntity).canConnect(getOrientationFromSide(side, ForgeDirection.NORTH))?tileEntity:null; + } + + public static TileEntity getTileEntityFromSide(World world, Vector3 position, ForgeDirection side) { + return position.clone().modifyPositionFromSide(side).getTileEntity(world); + } + +} diff --git a/src/main/java/universalelectricity/prefab/CustomDamageSource.java b/src/main/java/universalelectricity/prefab/CustomDamageSource.java new file mode 100644 index 0000000..3ea4c78 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/CustomDamageSource.java @@ -0,0 +1,32 @@ +package universalelectricity.prefab; + +import cpw.mods.fml.common.registry.LanguageRegistry; +import net.minecraft.util.DamageSource; + +public class CustomDamageSource extends DamageSource { + + public static final CustomDamageSource electrocution = ((CustomDamageSource)(new CustomDamageSource("electrocution")).setDamageBypassesArmor()).setDeathMessage("%1$s got electrocuted!"); + + + public CustomDamageSource(String damageType) { + super(damageType); + } + + public CustomDamageSource setDeathMessage(String deathMessage) { + LanguageRegistry.instance().addStringLocalization("death.attack." + super.damageType, deathMessage); + return this; + } + + public DamageSource setDamageBypassesArmor() { + return super.setDamageBypassesArmor(); + } + + public DamageSource setDamageAllowedInCreativeMode() { + return super.setDamageAllowedInCreativeMode(); + } + + public DamageSource setFireDamage() { + return super.setFireDamage(); + } + +} diff --git a/src/main/java/universalelectricity/prefab/GuiBase.java b/src/main/java/universalelectricity/prefab/GuiBase.java new file mode 100644 index 0000000..d7ba311 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/GuiBase.java @@ -0,0 +1,131 @@ +package universalelectricity.prefab; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.RenderHelper; +import org.lwjgl.opengl.GL11; + +@SideOnly(Side.CLIENT) +public abstract class GuiBase extends GuiScreen { + + protected int xSize = 176; + protected int ySize = 166; + protected int guiLeft; + protected int guiTop; + + + public void initGui() { + super.initGui(); + this.guiLeft = (this.width - this.xSize) / 2; + this.guiTop = (this.height - this.ySize) / 2; + } + + public void drawScreen(int par1, int par2, float par3) { + this.drawDefaultBackground(); + int var4 = this.guiLeft; + int var5 = this.guiTop; + this.drawBackgroundLayer(par1, par2, par3); + GL11.glPushMatrix(); + GL11.glTranslatef((float)var4, (float)var5, 0.0F); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glEnable('\u803a'); + short var7 = 240; + short var8 = 240; + OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, (float)var7 / 1.0F, (float)var8 / 1.0F); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + this.drawForegroundLayer(par1, par2, par3); + GL11.glDisable('\u803a'); + GL11.glDisable(2896); + GL11.glDisable(2929); + GL11.glPopMatrix(); + super.drawScreen(par1, par2, par3); + GL11.glEnable(2896); + GL11.glEnable(2929); + } + + protected abstract void drawForegroundLayer(int var1, int var2, float var3); + + protected abstract void drawBackgroundLayer(int var1, int var2, float var3); + + protected void keyTyped(char x, int y) { + if(y == 1 || y == this.mc.gameSettings.keyBindInventory.getKeyCode()) { + this.mc.thePlayer.closeScreen(); + } + + } + + public boolean doesGuiPauseGame() { + return false; + } + + public void updateScreen() { + super.updateScreen(); + if(!this.mc.thePlayer.isEntityAlive() || this.mc.thePlayer.isDead) { + this.mc.thePlayer.closeScreen(); + } + + } + + public void drawTooltip(int x, int y, String ... toolTips) { + GL11.glDisable('\u803a'); + RenderHelper.disableStandardItemLighting(); + GL11.glDisable(2896); + GL11.glDisable(2929); + if(toolTips != null) { + int var5 = 0; + + int var6; + int var7; + for(var6 = 0; var6 < toolTips.length; ++var6) { + var7 = this.fontRendererObj.getStringWidth(toolTips[var6]); + if(var7 > var5) { + var5 = var7; + } + } + + var6 = x + 12; + var7 = y - 12; + int var9 = 8; + if(toolTips.length > 1) { + var9 += 2 + (toolTips.length - 1) * 10; + } + + if(this.guiTop + var7 + var9 + 6 > this.height) { + var7 = this.height - var9 - this.guiTop - 6; + } + + super.zLevel = 300.0F; + int var10 = -267386864; + this.drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, var10, var10); + this.drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, var7 + var9 + 4, var10, var10); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 + var9 + 3, var10, var10); + this.drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, var10, var10); + this.drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, var7 + var9 + 3, var10, var10); + int var11 = 1347420415; + int var12 = (var11 & 16711422) >> 1 | var11 & -16777216; + this.drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, var7 + var9 + 3 - 1, var11, var12); + this.drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, var11, var11); + this.drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, var7 + var9 + 3, var12, var12); + + for(int var13 = 0; var13 < toolTips.length; ++var13) { + String var14 = toolTips[var13]; + this.fontRendererObj.drawStringWithShadow(var14, var6, var7, -1); + if(var13 == 0) { + var7 += 2; + } + + var7 += 10; + } + + super.zLevel = 0.0F; + } + + GL11.glEnable(2929); + GL11.glEnable(2896); + RenderHelper.enableGUIStandardItemLighting(); + GL11.glEnable('\u803a'); + } +} diff --git a/src/main/java/universalelectricity/prefab/RecipeHelper.java b/src/main/java/universalelectricity/prefab/RecipeHelper.java new file mode 100644 index 0000000..7ee0a03 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/RecipeHelper.java @@ -0,0 +1,131 @@ +package universalelectricity.prefab; + +import cpw.mods.fml.common.registry.GameRegistry; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import net.minecraft.item.ItemStack; +import net.minecraft.item.crafting.CraftingManager; +import net.minecraft.item.crafting.IRecipe; +import net.minecraftforge.common.config.Configuration; + +public class RecipeHelper { + + public static List getRecipesByOutput(ItemStack output) { + ArrayList list = new ArrayList(); + Iterator i$ = CraftingManager.getInstance().getRecipeList().iterator(); + + while(i$.hasNext()) { + Object obj = i$.next(); + if(obj instanceof IRecipe && ((IRecipe)obj).getRecipeOutput() == output) { + list.add((IRecipe)obj); + } + } + + return list; + } + + public static boolean replaceRecipe(IRecipe recipe, IRecipe newRecipe) { + Iterator i$ = CraftingManager.getInstance().getRecipeList().iterator(); + + Object obj; + do { + do { + if(!i$.hasNext()) { + return false; + } + + obj = i$.next(); + } while(!(obj instanceof IRecipe)); + } while(!((IRecipe)obj).equals(recipe) && obj != recipe); + + CraftingManager.getInstance().getRecipeList().remove(obj); + CraftingManager.getInstance().getRecipeList().add(newRecipe); + return true; + } + + public static boolean replaceRecipe(ItemStack recipe, IRecipe newRecipe) { + if(removeRecipe(recipe)) { + CraftingManager.getInstance().getRecipeList().add(newRecipe); + return true; + } else { + return false; + } + } + + public static boolean removeRecipe(IRecipe recipe) { + Iterator i$ = CraftingManager.getInstance().getRecipeList().iterator(); + + Object obj; + do { + do { + do { + if(!i$.hasNext()) { + return false; + } + + obj = i$.next(); + } while(obj == null); + } while(!(obj instanceof IRecipe)); + } while(!((IRecipe)obj).equals(recipe) && obj != recipe); + + CraftingManager.getInstance().getRecipeList().remove(obj); + return true; + } + + public static boolean removeRecipe(ItemStack stack) { + Iterator i$ = CraftingManager.getInstance().getRecipeList().iterator(); + + Object obj; + do { + if(!i$.hasNext()) { + return false; + } + + obj = i$.next(); + } while(obj == null || !(obj instanceof IRecipe) || ((IRecipe)obj).getRecipeOutput() == null || !((IRecipe)obj).getRecipeOutput().isItemEqual(stack)); + + CraftingManager.getInstance().getRecipeList().remove(obj); + return true; + } + + public static boolean removeRecipes(ItemStack ... itemStacks) { + boolean didRemove = false; + Iterator itr = CraftingManager.getInstance().getRecipeList().iterator(); + + while(itr.hasNext()) { + Object obj = itr.next(); + if(obj != null && obj instanceof IRecipe && ((IRecipe)obj).getRecipeOutput() != null) { + ItemStack[] arr$ = itemStacks; + int len$ = itemStacks.length; + + for(int i$ = 0; i$ < len$; ++i$) { + ItemStack itemStack = arr$[i$]; + if(((IRecipe)obj).getRecipeOutput().isItemEqual(itemStack)) { + itr.remove(); + didRemove = true; + break; + } + } + } + } + + return didRemove; + } + + public static void addRecipe(IRecipe recipe, String name, Configuration configuration, boolean defaultBoolean) { + if(configuration != null) { + configuration.load(); + if(configuration.get("Crafting", "Allow " + name + " Crafting", defaultBoolean).getBoolean(defaultBoolean)) { + GameRegistry.addRecipe(recipe); + } + + configuration.save(); + } + + } + + public static void addRecipe(IRecipe recipe, Configuration config, boolean defaultBoolean) { + addRecipe(recipe, recipe.getRecipeOutput().getUnlocalizedName(), config, defaultBoolean); + } +} diff --git a/src/main/java/universalelectricity/prefab/SlotSpecific.java b/src/main/java/universalelectricity/prefab/SlotSpecific.java new file mode 100644 index 0000000..12e53ba --- /dev/null +++ b/src/main/java/universalelectricity/prefab/SlotSpecific.java @@ -0,0 +1,74 @@ +package universalelectricity.prefab; + +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +public class SlotSpecific extends Slot { + + public ItemStack[] validItemStacks = new ItemStack[0]; + public Class[] validClasses = new Class[0]; + public boolean isInverted = false; + public boolean isMetadataSensitive = false; + + + public SlotSpecific(IInventory par2IInventory, int par3, int par4, int par5, ItemStack ... itemStacks) { + super(par2IInventory, par3, par4, par5); + this.setItemStacks(itemStacks); + } + + public SlotSpecific(IInventory par2IInventory, int par3, int par4, int par5, Class ... validClasses) { + super(par2IInventory, par3, par4, par5); + this.setClasses(validClasses); + } + + public SlotSpecific setMetadataSensitive() { + this.isMetadataSensitive = true; + return this; + } + + public SlotSpecific setItemStacks(ItemStack ... validItemStacks) { + this.validItemStacks = validItemStacks; + return this; + } + + public SlotSpecific setClasses(Class ... validClasses) { + this.validClasses = validClasses; + return this; + } + + public SlotSpecific toggleInverted() { + this.isInverted = !this.isInverted; + return this; + } + + public boolean isItemValid(ItemStack compareStack) { + boolean returnValue = false; + ItemStack[] arr$ = this.validItemStacks; + int len$ = arr$.length; + + int i$; + for(i$ = 0; i$ < len$; ++i$) { + ItemStack clazz = arr$[i$]; + if(compareStack.isItemEqual(clazz) || !this.isMetadataSensitive && compareStack.getItem() == clazz.getItem()) { + returnValue = true; + break; + } + } + + if(!returnValue) { + Class[] var7 = this.validClasses; + len$ = var7.length; + + for(i$ = 0; i$ < len$; ++i$) { + Class var8 = var7[i$]; + if(var8.equals(compareStack.getItem().getClass()) || var8.isInstance(compareStack.getItem())) { + returnValue = true; + break; + } + } + } + + return this.isInverted?!returnValue:returnValue; + } +} diff --git a/src/main/java/universalelectricity/prefab/TranslationHelper.java b/src/main/java/universalelectricity/prefab/TranslationHelper.java new file mode 100644 index 0000000..6456da6 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/TranslationHelper.java @@ -0,0 +1,49 @@ +package universalelectricity.prefab; + +import cpw.mods.fml.common.FMLLog; +import cpw.mods.fml.common.registry.LanguageRegistry; + +public class TranslationHelper { + + public static int loadLanguages(String languagePath, String[] languageSupported) { + int languages = 0; + String[] arr$ = languageSupported; + int len$ = languageSupported.length; + + for(int i$ = 0; i$ < len$; ++i$) { + String language = arr$[i$]; + LanguageRegistry.instance().loadLocalization(languagePath + language + ".properties", language, false); + if(LanguageRegistry.instance().getStringLocalization("children", language) != "") { + try { + String[] e = LanguageRegistry.instance().getStringLocalization("children", language).split(","); + String[] arr$1 = e; + int len$1 = e.length; + + for(int i$1 = 0; i$1 < len$1; ++i$1) { + String child = arr$1[i$1]; + if(child != "" || child != null) { + LanguageRegistry.instance().loadLocalization(languagePath + language + ".properties", child, false); + ++languages; + } + } + } catch (Exception var12) { + FMLLog.severe("Failed to load a child language file.", new Object[0]); + var12.printStackTrace(); + } + } + + ++languages; + } + + return languages; + } + + public static String getLocal(String key) { + String text = LanguageRegistry.instance().getStringLocalization(key); + if(text == null || text == "") { + text = LanguageRegistry.instance().getStringLocalization(key, "en_US"); + } + + return text; + } +} diff --git a/src/main/java/universalelectricity/prefab/block/BlockAdvanced.java b/src/main/java/universalelectricity/prefab/block/BlockAdvanced.java new file mode 100644 index 0000000..bed7a7c --- /dev/null +++ b/src/main/java/universalelectricity/prefab/block/BlockAdvanced.java @@ -0,0 +1,154 @@ +package universalelectricity.prefab.block; + +import java.lang.reflect.Method; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public abstract class BlockAdvanced extends BlockContainer { + + public BlockAdvanced(Material material) { + super(material); + this.setHardness(0.6F); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) { + world.getBlockMetadata(x, y, z); + if(this.isUsableWrench(entityPlayer, entityPlayer.inventory.getCurrentItem(), x, y, z)) { + this.damageWrench(entityPlayer, entityPlayer.inventory.getCurrentItem(), x, y, z); + if(entityPlayer.isSneaking() && this.onSneakUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ)) { + return true; + } + + if(this.onUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ)) { + return true; + } + } + + return entityPlayer.isSneaking() && this.onSneakMachineActivated(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ)?true:this.onMachineActivated(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ); + } + + public boolean isUsableWrench(EntityPlayer entityPlayer, ItemStack itemStack, int x, int y, int z) { + if(entityPlayer != null && itemStack != null) { + Class wrenchClass = itemStack.getItem().getClass(); + + try { + Method e = wrenchClass.getMethod("canWrench", new Class[]{EntityPlayer.class, Integer.TYPE, Integer.TYPE, Integer.TYPE}); + return ((Boolean)e.invoke(itemStack.getItem(), new Object[]{entityPlayer, Integer.valueOf(x), Integer.valueOf(y), Integer.valueOf(z)})).booleanValue(); + } catch (NoClassDefFoundError var8) { + ; + } catch (Exception var9) { + ; + } + + try { + if(wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrench") || wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrenchElectric")) { + return itemStack.getItemDamage() < itemStack.getMaxDamage(); + } + } catch (Exception var10) { + ; + } + } + + return false; + } + + public boolean damageWrench(EntityPlayer entityPlayer, ItemStack itemStack, int x, int y, int z) { + if(this.isUsableWrench(entityPlayer, itemStack, x, y, z)) { + Class wrenchClass = itemStack.getItem().getClass(); + + Method e; + try { + e = wrenchClass.getMethod("wrenchUsed", new Class[]{EntityPlayer.class, Integer.TYPE, Integer.TYPE, Integer.TYPE}); + e.invoke(itemStack.getItem(), new Object[]{entityPlayer, Integer.valueOf(x), Integer.valueOf(y), Integer.valueOf(z)}); + return true; + } catch (Exception var9) { + try { + if(wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrench") || wrenchClass == Class.forName("ic2.core.item.tool.ItemToolWrenchElectric")) { + e = wrenchClass.getMethod("damage", new Class[]{ItemStack.class, Integer.TYPE, EntityPlayer.class}); + e.invoke(itemStack.getItem(), new Object[]{itemStack, Integer.valueOf(1), entityPlayer}); + return true; + } + } catch (Exception var8) { + ; + } + } + } + + return false; + } + + public boolean onMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) { + return false; + } + + public boolean onSneakMachineActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) { + return false; + } + + public boolean onUseWrench(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) { + return false; + } + + public boolean onSneakUseWrench(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float hitX, float hitY, float hitZ) { + return this.onUseWrench(world, x, y, z, entityPlayer, side, hitX, hitY, hitZ); + } + + @Override + public TileEntity createTileEntity(World var1, int meta) { + return null; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) { + this.dropEntireInventory(world, x, y, z, par5, par6); + super.breakBlock(world, x, y, z, par5, par6); + } + + public void dropEntireInventory(World world, int x, int y, int z, Block par5, int par6) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity != null && tileEntity instanceof IInventory) { + IInventory inventory = (IInventory)tileEntity; + + for(int var6 = 0; var6 < inventory.getSizeInventory(); ++var6) { + ItemStack var7 = inventory.getStackInSlot(var6); + if(var7 != null) { + Random random = new Random(); + float var8 = random.nextFloat() * 0.8F + 0.1F; + float var9 = random.nextFloat() * 0.8F + 0.1F; + float var10 = random.nextFloat() * 0.8F + 0.1F; + + while(var7.stackSize > 0) { + int var11 = random.nextInt(21) + 10; + if(var11 > var7.stackSize) { + var11 = var7.stackSize; + } + + var7.stackSize -= var11; + EntityItem var12 = new EntityItem(world, (double)((float)x + var8), (double)((float)y + var9), (double)((float)z + var10), new ItemStack(var7.getItem(), var11, var7.getItemDamage())); + if(var7.hasTagCompound()) { + var12.getEntityItem().setTagCompound((NBTTagCompound)var7.getTagCompound().copy()); + } + + float var13 = 0.05F; + var12.motionX = (double)((float)random.nextGaussian() * var13); + var12.motionY = (double)((float)random.nextGaussian() * var13 + 0.2F); + var12.motionZ = (double)((float)random.nextGaussian() * var13); + world.spawnEntityInWorld(var12); + } + } + } + } + + } +} diff --git a/src/main/java/universalelectricity/prefab/block/BlockConductor.java b/src/main/java/universalelectricity/prefab/block/BlockConductor.java new file mode 100644 index 0000000..48ab516 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/block/BlockConductor.java @@ -0,0 +1,34 @@ +package universalelectricity.prefab.block; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.block.IConductor; + +public abstract class BlockConductor extends BlockContainer { + + public BlockConductor(Material material) { + super(material); + } + + @Override + public void onBlockAdded(World world, int x, int y, int z) { + super.onBlockAdded(world, x, y, z); + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity instanceof IConductor) { + ((IConductor)tileEntity).updateAdjacentConnections(); + } + + } + + @Override + public void onNeighborBlockChange(World world, int x, int y, int z, Block blockID) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity instanceof IConductor) { + ((IConductor)tileEntity).updateAdjacentConnections(); + } + + } +} diff --git a/src/main/java/universalelectricity/prefab/block/BlockRotatable.java b/src/main/java/universalelectricity/prefab/block/BlockRotatable.java new file mode 100644 index 0000000..da83333 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/block/BlockRotatable.java @@ -0,0 +1,51 @@ +package universalelectricity.prefab.block; + +import net.minecraft.block.material.Material; +import net.minecraft.entity.EntityLiving; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import universalelectricity.prefab.implement.IRotatable; + +public abstract class BlockRotatable extends BlockAdvanced implements IRotatable { + + public BlockRotatable(Material material) { + super(material); + } + + public void func_71860_a(World world, int x, int y, int z, EntityLiving entityLiving, ItemStack itemStack) { + int angle = MathHelper.floor_double((double)(entityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3; + byte change = 3; + switch(angle) { + case 0: + change = 2; + break; + case 1: + change = 5; + break; + case 2: + change = 3; + break; + case 3: + change = 4; + } + + this.setDirection(world, x, y, z, ForgeDirection.getOrientation(change)); + } + + public boolean onUseWrench(World world, int x, int y, int z, EntityPlayer par5EntityPlayer, int side, float hitX, float hitY, float hitZ) { + this.setDirection(world, x, y, z, ForgeDirection.getOrientation(ForgeDirection.ROTATION_MATRIX[0][this.getDirection(world, x, y, z).ordinal()])); + return true; + } + + public ForgeDirection getDirection(IBlockAccess world, int x, int y, int z) { + return ForgeDirection.getOrientation(world.getBlockMetadata(x, y, z)); + } + + public void setDirection(World world, int x, int y, int z, ForgeDirection facingDirection) { + world.setBlockMetadataWithNotify(x, y, z, facingDirection.ordinal(), 3); + } +} diff --git a/src/main/java/universalelectricity/prefab/implement/IDisableable.java b/src/main/java/universalelectricity/prefab/implement/IDisableable.java new file mode 100644 index 0000000..c4e3d16 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/IDisableable.java @@ -0,0 +1,9 @@ +package universalelectricity.prefab.implement; + + +public interface IDisableable { + + void onDisable(int var1); + + boolean isDisabled(); +} diff --git a/src/main/java/universalelectricity/prefab/implement/IRedstoneProvider.java b/src/main/java/universalelectricity/prefab/implement/IRedstoneProvider.java new file mode 100644 index 0000000..7631422 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/IRedstoneProvider.java @@ -0,0 +1,10 @@ +package universalelectricity.prefab.implement; + +import net.minecraftforge.common.util.ForgeDirection; + +public interface IRedstoneProvider { + + boolean isPoweringTo(ForgeDirection var1); + + boolean isIndirectlyPoweringTo(ForgeDirection var1); +} diff --git a/src/main/java/universalelectricity/prefab/implement/IRedstoneReceptor.java b/src/main/java/universalelectricity/prefab/implement/IRedstoneReceptor.java new file mode 100644 index 0000000..22c9001 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/IRedstoneReceptor.java @@ -0,0 +1,9 @@ +package universalelectricity.prefab.implement; + + +public interface IRedstoneReceptor { + + void onPowerOn(); + + void onPowerOff(); +} diff --git a/src/main/java/universalelectricity/prefab/implement/IRotatable.java b/src/main/java/universalelectricity/prefab/implement/IRotatable.java new file mode 100644 index 0000000..e007baf --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/IRotatable.java @@ -0,0 +1,12 @@ +package universalelectricity.prefab.implement; + +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +public interface IRotatable { + + ForgeDirection getDirection(IBlockAccess var1, int var2, int var3, int var4); + + void setDirection(World var1, int var2, int var3, int var4, ForgeDirection var5); +} diff --git a/src/main/java/universalelectricity/prefab/implement/ITier.java b/src/main/java/universalelectricity/prefab/implement/ITier.java new file mode 100644 index 0000000..9a84564 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/ITier.java @@ -0,0 +1,9 @@ +package universalelectricity.prefab.implement; + + +public interface ITier { + + int getTier(); + + void setTier(int var1); +} diff --git a/src/main/java/universalelectricity/prefab/implement/IToolConfigurator.java b/src/main/java/universalelectricity/prefab/implement/IToolConfigurator.java new file mode 100644 index 0000000..c8f3e32 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/implement/IToolConfigurator.java @@ -0,0 +1,10 @@ +package universalelectricity.prefab.implement; + +import net.minecraft.entity.player.EntityPlayer; + +public interface IToolConfigurator { + + boolean canWrench(EntityPlayer var1, int var2, int var3, int var4); + + void wrenchUsed(EntityPlayer var1, int var2, int var3, int var4); +} diff --git a/src/main/java/universalelectricity/prefab/multiblock/BlockMulti.java b/src/main/java/universalelectricity/prefab/multiblock/BlockMulti.java new file mode 100644 index 0000000..839bca4 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/multiblock/BlockMulti.java @@ -0,0 +1,110 @@ +package universalelectricity.prefab.multiblock; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.world.World; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.vector.Vector3; + +public class BlockMulti extends BlockContainer { + + public String textureName = null; + public String channel = ""; + + + public BlockMulti() { + super(UniversalElectricity.machine); + this.setHardness(0.8F); + //TODO WTF + //this.setUnlocalizedName("multiBlock"); + } + + public BlockMulti setChannel(String channel) { + this.channel = channel; + return this; + } + + public BlockMulti setTextureName(String name) { + this.textureName = name; + return this; + } + + public void makeFakeBlock(World worldObj, Vector3 position, Vector3 mainBlock) { + worldObj.setBlock(position.intX(), position.intY(), position.intZ(), this); + ((TileEntityMulti)worldObj.getTileEntity(position.intX(), position.intY(), position.intZ())).setMainBlock(mainBlock); + } + + @SideOnly(Side.CLIENT) + @Override + public void registerBlockIcons(IIconRegister iconRegister) { + if(this.textureName != null) { + this.blockIcon = iconRegister.registerIcon(this.textureName); + } else { + super.registerBlockIcons(iconRegister); + } + + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if(tileEntity instanceof TileEntityMulti) { + ((TileEntityMulti)tileEntity).onBlockRemoval(); + } + + super.breakBlock(world, x, y, z, par5, par6); + } + + @Override + public boolean onBlockActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer, int par6, float par7, float par8, float par9) { + TileEntityMulti tileEntity = (TileEntityMulti)par1World.getTileEntity(x, y, z); + return tileEntity.onBlockActivated(par1World, x, y, z, par5EntityPlayer); + } + + @Override + public int quantityDropped(Random par1Random) { + return 0; + } + + @Override + public int getRenderType() { + return -1; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public TileEntity createNewTileEntity(World var1, int meta) { + return new TileEntityMulti(this.channel); + } + + public ItemStack getPickBlock(MovingObjectPosition target, World par1World, int x, int y, int z) { + TileEntity tileEntity = par1World.getTileEntity(x, y, z); + Vector3 mainBlockPosition = ((TileEntityMulti)tileEntity).mainBlockPosition; + if(mainBlockPosition != null) { + Block mainBlockID = par1World.getBlock(mainBlockPosition.intX(), mainBlockPosition.intY(), mainBlockPosition.intZ()); + if(mainBlockID != Blocks.air) { + return mainBlockID.getPickBlock(target, par1World, mainBlockPosition.intX(), mainBlockPosition.intY(), mainBlockPosition.intZ()); + } + } + + return null; + } +} diff --git a/src/main/java/universalelectricity/prefab/multiblock/IBlockActivate.java b/src/main/java/universalelectricity/prefab/multiblock/IBlockActivate.java new file mode 100644 index 0000000..7657fca --- /dev/null +++ b/src/main/java/universalelectricity/prefab/multiblock/IBlockActivate.java @@ -0,0 +1,8 @@ +package universalelectricity.prefab.multiblock; + +import net.minecraft.entity.player.EntityPlayer; + +public interface IBlockActivate { + + boolean onActivated(EntityPlayer var1); +} diff --git a/src/main/java/universalelectricity/prefab/multiblock/IMultiBlock.java b/src/main/java/universalelectricity/prefab/multiblock/IMultiBlock.java new file mode 100644 index 0000000..820c5cc --- /dev/null +++ b/src/main/java/universalelectricity/prefab/multiblock/IMultiBlock.java @@ -0,0 +1,12 @@ +package universalelectricity.prefab.multiblock; + +import net.minecraft.tileentity.TileEntity; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.multiblock.IBlockActivate; + +public interface IMultiBlock extends IBlockActivate { + + void onCreate(Vector3 var1); + + void onDestroy(TileEntity var1); +} diff --git a/src/main/java/universalelectricity/prefab/multiblock/TileEntityMulti.java b/src/main/java/universalelectricity/prefab/multiblock/TileEntityMulti.java new file mode 100644 index 0000000..b518d6c --- /dev/null +++ b/src/main/java/universalelectricity/prefab/multiblock/TileEntityMulti.java @@ -0,0 +1,106 @@ +package universalelectricity.prefab.multiblock; + +import com.google.common.io.ByteArrayDataInput; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.network.play.server.S3FPacketCustomPayload; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.multiblock.BlockMulti; +import universalelectricity.prefab.multiblock.IMultiBlock; + +public class TileEntityMulti extends TileEntity { + + public Vector3 mainBlockPosition; + public String channel; + + + public TileEntityMulti() {} + + public TileEntityMulti(String channel) { + this.channel = channel; + } + + public void setMainBlock(Vector3 mainBlock) { + this.mainBlockPosition = mainBlock; + if(!this.worldObj.isRemote) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + + } + + /*@Override + public Packet getDescriptionPacket() { + if(this.mainBlockPosition == null) { + return null; + } else { + if(this.channel == null || this.channel == "" && this.getBlockType() instanceof BlockMulti) { + this.channel = ((BlockMulti)this.getBlockType()).channel; + } + + return PacketManager.getPacket(this.channel, this, new Object[]{Integer.valueOf(this.mainBlockPosition.intX()), Integer.valueOf(this.mainBlockPosition.intY()), Integer.valueOf(this.mainBlockPosition.intZ())}); + } + }*/ + + public void onBlockRemoval() { + if(this.mainBlockPosition != null) { + TileEntity tileEntity = this.worldObj.getTileEntity(this.mainBlockPosition.intX(), this.mainBlockPosition.intY(), this.mainBlockPosition.intZ()); + if(tileEntity != null && tileEntity instanceof IMultiBlock) { + IMultiBlock mainBlock = (IMultiBlock)tileEntity; + if(mainBlock != null) { + mainBlock.onDestroy(this); + } + } + } + + } + + public boolean onBlockActivated(World par1World, int x, int y, int z, EntityPlayer par5EntityPlayer) { + if(this.mainBlockPosition != null) { + TileEntity tileEntity = this.worldObj.getTileEntity(this.mainBlockPosition.intX(), this.mainBlockPosition.intY(), this.mainBlockPosition.intZ()); + if(tileEntity != null && tileEntity instanceof IMultiBlock) { + return ((IMultiBlock)tileEntity).onActivated(par5EntityPlayer); + } + } + + return false; + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + super.readFromNBT(nbt); + this.mainBlockPosition = Vector3.readFromNBT(nbt.getCompoundTag("mainBlockPosition")); + } + + @Override + public void writeToNBT(NBTTagCompound nbt) { + super.writeToNBT(nbt); + if(this.mainBlockPosition != null) { + nbt.setTag("mainBlockPosition", this.mainBlockPosition.writeToNBT(new NBTTagCompound())); + } + + } + + public boolean canUpdate() { + return false; + } + + /*@Override + public void handlePacketData(NetworkManager network, int packetType, S3FPacketCustomPayload packet, EntityPlayer player, ByteArrayDataInput dataStream) { + try { + this.mainBlockPosition = new Vector3((double)dataStream.readInt(), (double)dataStream.readInt(), (double)dataStream.readInt()); + } catch (Exception var7) { + var7.printStackTrace(); + } + }*/ + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + + } + +} diff --git a/src/main/java/universalelectricity/prefab/ore/OreGenBase.java b/src/main/java/universalelectricity/prefab/ore/OreGenBase.java new file mode 100644 index 0000000..26388a1 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/ore/OreGenBase.java @@ -0,0 +1,60 @@ +package universalelectricity.prefab.ore; + +import cpw.mods.fml.common.FMLLog; +import java.util.Random; +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.config.Configuration; +import net.minecraftforge.oredict.OreDictionary; + +public abstract class OreGenBase { + + public String name; + public String oreDictionaryName; + public boolean shouldGenerate = false; + public int blockIndexTexture; + public ItemStack oreStack; + public Block oreID; + public int oreMeta; + public int harvestLevel; + public String harvestTool; + + + public OreGenBase(String name, String oreDiectionaryName, ItemStack stack, String harvestTool, int harvestLevel) { + if(stack != null) { + this.name = name; + this.harvestTool = harvestTool; + this.harvestLevel = harvestLevel; + this.oreDictionaryName = oreDiectionaryName; + this.oreStack = stack; + this.oreID = Block.getBlockFromItem(stack.getItem()); + this.oreMeta = stack.getItemDamage(); + OreDictionary.registerOre(this.oreDictionaryName, stack); + oreID.setHarvestLevel(harvestTool, harvestLevel, stack.getItemDamage()); + + } else { + FMLLog.severe("ItemStack is null while registering ore generation!", new Object[0]); + } + + } + + public OreGenBase enable(Configuration config) { + this.shouldGenerate = shouldGenerateOre(config, this.name); + return this; + } + + private static boolean shouldGenerateOre(Configuration configuration, String oreName) { + configuration.load(); + boolean shouldGenerate = configuration.get("Ore_Generation", "Generate " + oreName, true).getBoolean(true); + configuration.save(); + return shouldGenerate; + } + + public abstract void generate(World var1, Random var2, int var3, int var4); + + public abstract boolean isOreGeneratedInWorld(World var1, IChunkProvider var2); +} diff --git a/src/main/java/universalelectricity/prefab/ore/OreGenReplace.java b/src/main/java/universalelectricity/prefab/ore/OreGenReplace.java new file mode 100644 index 0000000..39cc980 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/ore/OreGenReplace.java @@ -0,0 +1,99 @@ +package universalelectricity.prefab.ore; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.MathHelper; +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import net.minecraft.world.gen.ChunkProviderEnd; +import net.minecraft.world.gen.ChunkProviderGenerate; +import net.minecraft.world.gen.ChunkProviderHell; + +public class OreGenReplace extends OreGenBase { + + public int minGenerateLevel; + public int maxGenerateLevel; + public int amountPerChunk; + public int amountPerBranch; + public Block replaceID; + public boolean ignoreSurface = false; + public boolean ignoreNether = true; + public boolean ignoreEnd = true; + + + public OreGenReplace(String name, String oreDiectionaryName, ItemStack stack, Block replaceID, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) { + super(name, oreDiectionaryName, stack, harvestTool, harvestLevel); + this.minGenerateLevel = minGenerateLevel; + this.maxGenerateLevel = maxGenerateLevel; + this.amountPerChunk = amountPerChunk; + this.amountPerBranch = amountPerBranch; + this.replaceID = replaceID; + } + + public void generate(World world, Random random, int varX, int varZ) { + try { + for(int e = 0; e < this.amountPerChunk; ++e) { + int x = varX + random.nextInt(16); + int z = varZ + random.nextInt(16); + int y = random.nextInt(Math.max(this.maxGenerateLevel - this.minGenerateLevel, 0)) + this.minGenerateLevel; + this.generateReplace(world, random, x, y, z); + } + } catch (Exception var9) { + System.out.println("Error generating ore: " + super.name); + var9.printStackTrace(); + } + + } + + public boolean generateReplace(World par1World, Random par2Random, int par3, int par4, int par5) { + float var6 = par2Random.nextFloat() * 3.1415927F; + double var7 = (double)((float)(par3 + 8) + MathHelper.sin(var6) * (float)this.amountPerBranch / 8.0F); + double var9 = (double)((float)(par3 + 8) - MathHelper.sin(var6) * (float)this.amountPerBranch / 8.0F); + double var11 = (double)((float)(par5 + 8) + MathHelper.cos(var6) * (float)this.amountPerBranch / 8.0F); + double var13 = (double)((float)(par5 + 8) - MathHelper.cos(var6) * (float)this.amountPerBranch / 8.0F); + double var15 = (double)(par4 + par2Random.nextInt(3) - 2); + double var17 = (double)(par4 + par2Random.nextInt(3) - 2); + + for(int var19 = 0; var19 <= this.amountPerBranch; ++var19) { + double var20 = var7 + (var9 - var7) * (double)var19 / (double)this.amountPerBranch; + double var22 = var15 + (var17 - var15) * (double)var19 / (double)this.amountPerBranch; + double var24 = var11 + (var13 - var11) * (double)var19 / (double)this.amountPerBranch; + double var26 = par2Random.nextDouble() * (double)this.amountPerBranch / 16.0D; + double var28 = (double)(MathHelper.sin((float)var19 * 3.1415927F / (float)this.amountPerBranch) + 1.0F) * var26 + 1.0D; + double var30 = (double)(MathHelper.sin((float)var19 * 3.1415927F / (float)this.amountPerBranch) + 1.0F) * var26 + 1.0D; + int var32 = MathHelper.floor_double(var20 - var28 / 2.0D); + int var33 = MathHelper.floor_double(var22 - var30 / 2.0D); + int var34 = MathHelper.floor_double(var24 - var28 / 2.0D); + int var35 = MathHelper.floor_double(var20 + var28 / 2.0D); + int var36 = MathHelper.floor_double(var22 + var30 / 2.0D); + int var37 = MathHelper.floor_double(var24 + var28 / 2.0D); + + for(int var38 = var32; var38 <= var35; ++var38) { + double var39 = ((double)var38 + 0.5D - var20) / (var28 / 2.0D); + if(var39 * var39 < 1.0D) { + for(int var41 = var33; var41 <= var36; ++var41) { + double var42 = ((double)var41 + 0.5D - var22) / (var30 / 2.0D); + if(var39 * var39 + var42 * var42 < 1.0D) { + for(int var44 = var34; var44 <= var37; ++var44) { + double var45 = ((double)var44 + 0.5D - var24) / (var28 / 2.0D); + Block block = par1World.getBlock(var38, var41, var44); + if(var39 * var39 + var42 * var42 + var45 * var45 < 1.0D && (this.replaceID == Blocks.air || block == this.replaceID)) { + par1World.setBlock(var38, var41, var44, super.oreID, super.oreMeta, 2); + } + } + } + } + } + } + } + + return true; + } + + public boolean isOreGeneratedInWorld(World world, IChunkProvider chunkGenerator) { + return !super.shouldGenerate?false:(this.ignoreSurface && chunkGenerator instanceof ChunkProviderGenerate?false:(this.ignoreNether && chunkGenerator instanceof ChunkProviderHell?false:!this.ignoreEnd || !(chunkGenerator instanceof ChunkProviderEnd))); + } +} diff --git a/src/main/java/universalelectricity/prefab/ore/OreGenReplaceStone.java b/src/main/java/universalelectricity/prefab/ore/OreGenReplaceStone.java new file mode 100644 index 0000000..8e033e8 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/ore/OreGenReplaceStone.java @@ -0,0 +1,16 @@ +package universalelectricity.prefab.ore; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import universalelectricity.prefab.ore.OreGenReplace; + +public class OreGenReplaceStone extends OreGenReplace { + + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int minGenerateLevel, int maxGenerateLevel, int amountPerChunk, int amountPerBranch, String harvestTool, int harvestLevel) { + super(name, oreDiectionaryName, stack, Blocks.stone, minGenerateLevel, maxGenerateLevel, amountPerChunk, amountPerBranch, harvestTool, harvestLevel); + } + + public OreGenReplaceStone(String name, String oreDiectionaryName, ItemStack stack, int maxGenerateLevel, int amountPerChunk, int amountPerBranch) { + this(name, oreDiectionaryName, stack, 0, maxGenerateLevel, amountPerChunk, amountPerBranch, "pickaxe", 1); + } +} diff --git a/src/main/java/universalelectricity/prefab/ore/OreGenerator.java b/src/main/java/universalelectricity/prefab/ore/OreGenerator.java new file mode 100644 index 0000000..4b0d74a --- /dev/null +++ b/src/main/java/universalelectricity/prefab/ore/OreGenerator.java @@ -0,0 +1,60 @@ +package universalelectricity.prefab.ore; + +import cpw.mods.fml.common.IWorldGenerator; +import cpw.mods.fml.common.registry.GameRegistry; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Random; +import net.minecraft.world.World; +import net.minecraft.world.chunk.IChunkProvider; +import universalelectricity.prefab.ore.OreGenBase; + +public class OreGenerator implements IWorldGenerator { + + public static boolean isInitiated = false; + private static final List ORES_TO_GENERATE = new ArrayList(); + + + public static void addOre(OreGenBase data) { + if(!isInitiated) { + GameRegistry.registerWorldGenerator(new OreGenerator(), 10); //TODO figure out the right value instead of 10 + } + + ORES_TO_GENERATE.add(data); + } + + public static boolean oreExists(String oreName) { + Iterator i$ = ORES_TO_GENERATE.iterator(); + + OreGenBase ore; + do { + if(!i$.hasNext()) { + return false; + } + + ore = (OreGenBase)i$.next(); + } while(ore.oreDictionaryName != oreName); + + return true; + } + + public static void removeOre(OreGenBase data) { + ORES_TO_GENERATE.remove(data); + } + + public void generate(Random rand, int chunkX, int chunkZ, World world, IChunkProvider chunkGenerator, IChunkProvider chunkProvider) { + chunkX <<= 4; + chunkZ <<= 4; + Iterator i$ = ORES_TO_GENERATE.iterator(); + + while(i$.hasNext()) { + OreGenBase oreData = (OreGenBase)i$.next(); + if(oreData.shouldGenerate && oreData.isOreGeneratedInWorld(world, chunkGenerator)) { + oreData.generate(world, rand, chunkX, chunkZ); + } + } + + } + +} diff --git a/src/main/java/universalelectricity/prefab/potion/CustomPotion.java b/src/main/java/universalelectricity/prefab/potion/CustomPotion.java new file mode 100644 index 0000000..3f46380 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/potion/CustomPotion.java @@ -0,0 +1,22 @@ +package universalelectricity.prefab.potion; + +import net.minecraft.potion.Potion; + +public abstract class CustomPotion extends Potion { + + public CustomPotion(int id, boolean isBadEffect, int color, String name) { + super(id, isBadEffect, color); + this.setPotionName("potion." + name); + Potion.potionTypes[this.getId()] = this; + } + + public Potion setIconIndex(int par1, int par2) { + super.setIconIndex(par1, par2); + return this; + } + + protected Potion setEffectiveness(double par1) { + super.setEffectiveness(par1); + return this; + } +} diff --git a/src/main/java/universalelectricity/prefab/potion/CustomPotionEffect.java b/src/main/java/universalelectricity/prefab/potion/CustomPotionEffect.java new file mode 100644 index 0000000..02579f6 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/potion/CustomPotionEffect.java @@ -0,0 +1,27 @@ +package universalelectricity.prefab.potion; + +import java.util.ArrayList; +import java.util.List; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; + +public class CustomPotionEffect extends PotionEffect { + + public CustomPotionEffect(int potionID, int duration, int amplifier) { + super(potionID, duration, amplifier); + } + + public CustomPotionEffect(Potion potion, int duration, int amplifier) { + this(potion.getId(), duration, amplifier); + } + + public CustomPotionEffect(int potionID, int duration, int amplifier, List curativeItems) { + super(potionID, duration, amplifier); + if(curativeItems == null) { + this.setCurativeItems(new ArrayList()); + } else { + this.setCurativeItems(curativeItems); + } + + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityAdvanced.java b/src/main/java/universalelectricity/prefab/tile/TileEntityAdvanced.java new file mode 100644 index 0000000..6bd2c3e --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityAdvanced.java @@ -0,0 +1,42 @@ +package universalelectricity.prefab.tile; + +import net.minecraft.block.Block; +import net.minecraft.tileentity.TileEntity; + +public abstract class TileEntityAdvanced extends TileEntity { + + protected long ticks = 0L; + + @Override + public void updateEntity() { + if(this.ticks == 0L) { + this.initiate(); + } + + if(this.ticks >= Long.MAX_VALUE) { + this.ticks = 1L; + } + + ++this.ticks; + } + + public void initiate() {} + + @Override + public int getBlockMetadata() { + if(this.blockMetadata == -1) { + this.blockMetadata = this.worldObj.getBlockMetadata(this.xCoord, this.yCoord, this.zCoord); + } + + return this.blockMetadata; + } + + @Override + public Block getBlockType() { + if(this.blockType == null) { + this.blockType = this.worldObj.getBlock(this.xCoord, this.yCoord, this.zCoord); + } + + return this.blockType; + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityConductor.java b/src/main/java/universalelectricity/prefab/tile/TileEntityConductor.java new file mode 100644 index 0000000..df053ab --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityConductor.java @@ -0,0 +1,144 @@ +package universalelectricity.prefab.tile; + +import java.util.Arrays; + +import com.google.common.io.ByteArrayDataInput; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.network.play.server.S3FPacketCustomPayload; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraftforge.common.util.ForgeDirection; + +import universalelectricity.core.block.IConductor; +import universalelectricity.core.block.IConnector; +import universalelectricity.core.block.INetworkProvider; +import universalelectricity.core.electricity.ElectricityNetwork; +import universalelectricity.core.electricity.IElectricityNetwork; +import universalelectricity.core.vector.Vector3; +import universalelectricity.core.vector.VectorHelper; + +public abstract class TileEntityConductor extends TileEntityAdvanced implements IConductor { + + private IElectricityNetwork network; + public boolean[] visuallyConnected = new boolean[]{false, false, false, false, false, false}; + public TileEntity[] connectedBlocks = new TileEntity[]{null, null, null, null, null, null}; + protected String channel = ""; + + + public void updateConnection(TileEntity tileEntity, ForgeDirection side) { + if(!this.worldObj.isRemote) { + if(tileEntity instanceof IConnector && ((IConnector)tileEntity).canConnect(side.getOpposite())) { + this.connectedBlocks[side.ordinal()] = tileEntity; + this.visuallyConnected[side.ordinal()] = true; + if(tileEntity.getClass() == this.getClass() && tileEntity instanceof INetworkProvider) { + this.getNetwork().mergeConnection(((INetworkProvider)tileEntity).getNetwork()); + } + + return; + } + + if(this.connectedBlocks[side.ordinal()] != null) { + this.getNetwork().stopProducing(this.connectedBlocks[side.ordinal()]); + this.getNetwork().stopRequesting(this.connectedBlocks[side.ordinal()]); + } + + this.connectedBlocks[side.ordinal()] = null; + this.visuallyConnected[side.ordinal()] = false; + } + + } + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + if(this.worldObj.isRemote) { + NBTTagCompound nbt = pkt.func_148857_g(); + this.visuallyConnected[0] = nbt.getBoolean("bottom"); + this.visuallyConnected[1] = nbt.getBoolean("top"); + this.visuallyConnected[2] = nbt.getBoolean("back"); + this.visuallyConnected[3] = nbt.getBoolean("front"); + this.visuallyConnected[4] = nbt.getBoolean("left"); + this.visuallyConnected[5] = nbt.getBoolean("right"); + } + } + + public void initiate() { + this.updateAdjacentConnections(); + } + + @Override + public void invalidate() { + if(!this.worldObj.isRemote) { + this.getNetwork().splitNetwork(this); + } + + super.invalidate(); + } + + @Override + public void updateEntity() { + super.updateEntity(); + if(!this.worldObj.isRemote && super.ticks % 300L == 0L) { + this.updateAdjacentConnections(); + } + + } + + public void updateAdjacentConnections() { + if(this.worldObj != null && !this.worldObj.isRemote) { + boolean[] previousConnections = (boolean[])this.visuallyConnected.clone(); + + for(byte i = 0; i < 6; ++i) { + this.updateConnection(VectorHelper.getConnectorFromSide(this.worldObj, new Vector3(this), ForgeDirection.getOrientation(i)), ForgeDirection.getOrientation(i)); + } + + if(!Arrays.equals(previousConnections, this.visuallyConnected)) { + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + } + + } + + @Override + public Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setBoolean("bottom", this.visuallyConnected[0]); + nbt.setBoolean("top", this.visuallyConnected[1]); + nbt.setBoolean("back", this.visuallyConnected[2]); + nbt.setBoolean("front", this.visuallyConnected[3]); + nbt.setBoolean("left", this.visuallyConnected[4]); + nbt.setBoolean("right", this.visuallyConnected[5]); + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.getBlockMetadata(), nbt); + //return PacketManager.getPacket(this.channel, this, new Object[]{Boolean.valueOf(this.visuallyConnected[0]), Boolean.valueOf(this.visuallyConnected[1]), Boolean.valueOf(this.visuallyConnected[2]), Boolean.valueOf(this.visuallyConnected[3]), Boolean.valueOf(this.visuallyConnected[4]), Boolean.valueOf(this.visuallyConnected[5])}); + } + + public IElectricityNetwork getNetwork() { + if(this.network == null) { + this.setNetwork(new ElectricityNetwork(new IConductor[]{this})); + } + + return this.network; + } + + public void setNetwork(IElectricityNetwork network) { + this.network = network; + } + + public TileEntity[] getAdjacentConnections() { + return this.connectedBlocks; + } + + public boolean canConnect(ForgeDirection direction) { + return true; + } + + @SideOnly(Side.CLIENT) + public AxisAlignedBB getRenderBoundingBox() { + return AxisAlignedBB.getBoundingBox((double)this.xCoord, (double)this.yCoord, (double)this.zCoord, (double)(this.xCoord + 1), (double)(this.yCoord + 1), (double)(this.zCoord + 1)); + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityDisableable.java b/src/main/java/universalelectricity/prefab/tile/TileEntityDisableable.java new file mode 100644 index 0000000..1f9b3c9 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityDisableable.java @@ -0,0 +1,27 @@ +package universalelectricity.prefab.tile; + +import universalelectricity.prefab.implement.IDisableable; + +public abstract class TileEntityDisableable extends TileEntityAdvanced implements IDisableable { + + protected int disabledTicks = 0; + + @Override + public void updateEntity() { + super.updateEntity(); + if(this.disabledTicks > 0) { + --this.disabledTicks; + this.whileDisable(); + } + } + + protected void whileDisable() {} + + public void onDisable(int duration) { + this.disabledTicks = duration; + } + + public boolean isDisabled() { + return this.disabledTicks > 0; + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityElectrical.java b/src/main/java/universalelectricity/prefab/tile/TileEntityElectrical.java new file mode 100644 index 0000000..9771f5b --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityElectrical.java @@ -0,0 +1,19 @@ +package universalelectricity.prefab.tile; + +import universalelectricity.core.block.IConnector; +import universalelectricity.core.block.IVoltage; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.prefab.tile.TileEntityDisableable; + +public abstract class TileEntityElectrical extends TileEntityDisableable implements IConnector, IVoltage { + + public double getVoltage() { + return 120.0D; + } + + @Override + public void invalidate() { + ElectricityNetworkHelper.invalidate(this); + super.invalidate(); + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityRunnable.java b/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityRunnable.java new file mode 100644 index 0000000..899bd20 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityRunnable.java @@ -0,0 +1,48 @@ +package universalelectricity.prefab.tile; + +import java.util.EnumSet; +import net.minecraft.entity.Entity; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.core.electricity.ElectricityPack; + +public abstract class TileEntityElectricityRunnable extends TileEntityElectrical { + + public double prevWatts; + public double wattsReceived = 0.0D; + + @Override + public void updateEntity() { + super.updateEntity(); + this.prevWatts = this.wattsReceived; + if(!this.worldObj.isRemote) { + if(!this.isDisabled()) { + ElectricityPack electricityPack = ElectricityNetworkHelper.consumeFromMultipleSides(this, this.getConsumingSides(), this.getRequest()); + this.onReceive(electricityPack); + } else { + ElectricityNetworkHelper.consumeFromMultipleSides(this, new ElectricityPack()); + } + } + + } + + protected EnumSet getConsumingSides() { + return ElectricityNetworkHelper.getDirections(this); + } + + public ElectricityPack getRequest() { + return new ElectricityPack(); + } + + public void onReceive(ElectricityPack electricityPack) { + if(UniversalElectricity.isVoltageSensitive && electricityPack.voltage > this.getVoltage()) { + this.worldObj.createExplosion((Entity)null, (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, 1.5F, true); + } else { + this.wattsReceived = Math.min(this.wattsReceived + electricityPack.getWatts(), this.getWattBuffer()); + } + } + + public double getWattBuffer() { + return this.getRequest().getWatts() * 2.0D; + } +} diff --git a/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityStorage.java b/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityStorage.java new file mode 100644 index 0000000..3f48d3b --- /dev/null +++ b/src/main/java/universalelectricity/prefab/tile/TileEntityElectricityStorage.java @@ -0,0 +1,67 @@ +package universalelectricity.prefab.tile; + +import java.util.EnumSet; +import net.minecraft.entity.Entity; +import net.minecraft.nbt.NBTTagCompound; +import universalelectricity.core.UniversalElectricity; +import universalelectricity.core.block.IElectricityStorage; +import universalelectricity.core.electricity.ElectricityNetworkHelper; +import universalelectricity.core.electricity.ElectricityPack; +import universalelectricity.prefab.tile.TileEntityElectrical; + +public abstract class TileEntityElectricityStorage extends TileEntityElectrical implements IElectricityStorage { + + private double joules = 0.0D; + public double prevJoules = 0.0D; + + @Override + public void updateEntity() { + super.updateEntity(); + this.prevJoules = this.joules; + if(!this.worldObj.isRemote) { + if(!this.isDisabled()) { + ElectricityPack electricityPack = ElectricityNetworkHelper.consumeFromMultipleSides(this, this.getConsumingSides(), this.getRequest()); + this.onReceive(electricityPack); + } else { + ElectricityNetworkHelper.consumeFromMultipleSides(this, new ElectricityPack()); + } + } + + } + + protected EnumSet getConsumingSides() { + return ElectricityNetworkHelper.getDirections(this); + } + + public ElectricityPack getRequest() { + return new ElectricityPack((this.getMaxJoules() - this.getJoules()) / this.getVoltage(), this.getVoltage()); + } + + public void onReceive(ElectricityPack electricityPack) { + if(UniversalElectricity.isVoltageSensitive && electricityPack.voltage > this.getVoltage()) { + this.worldObj.createExplosion((Entity)null, (double)this.xCoord, (double)this.yCoord, (double)this.zCoord, 1.5F, true); + } else { + this.setJoules(this.getJoules() + electricityPack.getWatts()); + } + } + + @Override + public void readFromNBT(NBTTagCompound par1NBTTagCompound) { + super.readFromNBT(par1NBTTagCompound); + this.joules = par1NBTTagCompound.getDouble("joules"); + } + + @Override + public void writeToNBT(NBTTagCompound par1NBTTagCompound) { + super.writeToNBT(par1NBTTagCompound); + par1NBTTagCompound.setDouble("joules", this.joules); + } + + public double getJoules() { + return this.joules; + } + + public void setJoules(double joules) { + this.joules = Math.max(Math.min(joules, this.getMaxJoules()), 0.0D); + } +} diff --git a/src/main/java/universalelectricity/prefab/vector/Region2.java b/src/main/java/universalelectricity/prefab/vector/Region2.java new file mode 100644 index 0000000..8becb39 --- /dev/null +++ b/src/main/java/universalelectricity/prefab/vector/Region2.java @@ -0,0 +1,27 @@ +package universalelectricity.prefab.vector; + +import universalelectricity.core.vector.Vector2; + +public class Region2 { + + public Vector2 min; + public Vector2 max; + + + public Region2() { + this(new Vector2(), new Vector2()); + } + + public Region2(Vector2 min, Vector2 max) { + this.min = min; + this.max = max; + } + + public boolean isIn(Vector2 point) { + return point.x > this.min.x && point.x < this.max.x && point.y > this.min.y && point.y < this.max.y; + } + + public boolean isIn(Region2 region) { + return region.max.x > this.min.x && region.min.x < this.max.x?region.max.y > this.min.y && region.min.y < this.max.y:false; + } +} diff --git a/src/main/java/universalelectricity/prefab/vector/Region3.java b/src/main/java/universalelectricity/prefab/vector/Region3.java new file mode 100644 index 0000000..ba83c0b --- /dev/null +++ b/src/main/java/universalelectricity/prefab/vector/Region3.java @@ -0,0 +1,94 @@ +package universalelectricity.prefab.vector; + +import java.util.ArrayList; +import java.util.List; +import net.minecraft.entity.Entity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.world.World; +import universalelectricity.core.vector.Vector3; +import universalelectricity.prefab.vector.Region2; + +public class Region3 { + + public Vector3 min; + public Vector3 max; + + + public Region3() { + this(new Vector3(), new Vector3()); + } + + public Region3(Vector3 min, Vector3 max) { + this.min = min; + this.max = max; + } + + public Region3(AxisAlignedBB aabb) { + this.min = new Vector3(aabb.minX, aabb.minY, aabb.minZ); + this.max = new Vector3(aabb.maxX, aabb.maxY, aabb.maxZ); + } + + public AxisAlignedBB toAABB() { + return AxisAlignedBB.getBoundingBox(this.min.x, this.min.y, this.min.z, this.max.x, this.max.y, this.max.z); + } + + public Region2 toRegion2() { + return new Region2(this.min.toVector2(), this.max.toVector2()); + } + + public boolean isIn(Vector3 point) { + return point.x > this.min.x && point.x < this.max.x && point.y > this.min.y && point.y < this.max.y && point.z > this.min.z && point.z < this.max.z; + } + + public boolean isIn(Region3 region) { + return region.max.x > this.min.x && region.min.x < this.max.x?(region.max.y > this.min.y && region.min.y < this.max.y?region.max.z > this.min.z && region.min.z < this.max.z:false):false; + } + + public void expand(Vector3 difference) { + this.min.subtract(difference); + this.max.add(difference); + } + + public List getVectors() { + ArrayList vectors = new ArrayList(); + + for(int x = this.min.intX(); x < this.max.intX(); ++x) { + for(int y = this.min.intY(); x < this.max.intY(); ++y) { + for(int z = this.min.intZ(); x < this.max.intZ(); ++z) { + vectors.add(new Vector3((double)x, (double)y, (double)z)); + } + } + } + + return vectors; + } + + public List getVectors(Vector3 center, int radius) { + ArrayList vectors = new ArrayList(); + + for(int x = this.min.intX(); x < this.max.intX(); ++x) { + for(int y = this.min.intY(); x < this.max.intY(); ++y) { + for(int z = this.min.intZ(); x < this.max.intZ(); ++z) { + Vector3 vector3 = new Vector3((double)x, (double)y, (double)z); + if(center.distanceTo(vector3) <= (double)radius) { + vectors.add(vector3); + } + } + } + } + + return vectors; + } + + public List getEntities(World world, Class entityClass) { + return world.getEntitiesWithinAABB(entityClass, this.toAABB()); + } + + public List getEntitiesExlude(World world, Entity entity) { + return world.getEntitiesWithinAABBExcludingEntity(entity, this.toAABB()); + } + + public List getEntities(World world) { + return this.getEntities(world, Entity.class); + } +} diff --git a/src/main/resources/assets/basiccomponents/languages/de_DE.properties b/src/main/resources/assets/basiccomponents/languages/de_DE.properties new file mode 100644 index 0000000..460c1db --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/de_DE.properties @@ -0,0 +1,34 @@ +# Basic Components Language Properties +# @author Calclavia +# @translator TheVanoq + +# Blocks +tile.basiccomponents\:basiccomponents\:bcOre.0.name=Kupfererz +tile.basiccomponents\:basiccomponents\:bcOre.1.name=Zinnerz +tile.basiccomponents\:basiccomponents\:copperWire.name=Kupferkabel +tile.basiccomponents\:basiccomponents\:bcMachine.0.name=Kohle Generator +tile.basiccomponents\:basiccomponents\:bcMachine.1.name=Batteriekasten +tile.basiccomponents\:basiccomponents\:bcMachine.2.name=Elektro-Ofen + +# Items +item.basiccomponents\:battery.name=Batterie +item.basiccomponents\:circuit.name=Schaltkreis +item.basiccomponents\:circuit.0.name=Einfacher Schaltkreis +item.basiccomponents\:circuit.1.name=Erweiterter Schaltkreis +item.basiccomponents\:circuit.2.name=Elite Schaltkreis +item.basiccomponents\:bucketOil.name=Eimer mit Öl +item.basiccomponents\:wrench.name=Schraubenschlüssel +item.basiccomponents\:motor.name=Motor + +item.basiccomponents\:plateCopper.name=Kupferplatte +item.basiccomponents\:plateTin.name=Zinnplatte +item.basiccomponents\:plateBronze.name=Bronzeplatte +item.basiccomponents\:plateSteel.name=Stahlplatte + +item.basiccomponents\:ingotCopper.name=Kupferbarren +item.basiccomponents\:ingotTin.name=Zinnbarren +item.basiccomponents\:ingotBronze.name=Bronzebarren +item.basiccomponents\:ingotSteel.name=Stahlbarren + +item.basiccomponents\:dustBronze.name=Bronzestaub +item.basiccomponents\:dustSteel.name=Stahlstaub diff --git a/src/main/resources/assets/basiccomponents/languages/en_US.properties b/src/main/resources/assets/basiccomponents/languages/en_US.properties new file mode 100644 index 0000000..eb808b4 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/en_US.properties @@ -0,0 +1,36 @@ +# Basic Components Language Properties +# @author Calclavia + +itemGroup.BasicComponents=Basic Components + +# Blocks +tile.basiccomponents\:oreCopper.name=Copper Ore +tile.basiccomponents\:oreTin.name=Tin Ore +tile.basiccomponents\:copperWire.name=Copper Wire +tile.basiccomponents\:bcMachine.0.name=Coal Generator +tile.basiccomponents\:bcMachine.1.name=Battery Box +tile.basiccomponents\:bcMachine.2.name=Electric Furnace + +# Items +item.basiccomponents\:battery.name=Battery +item.basiccomponents\:infiniteBattery.name=Infinite Battery +item.basiccomponents\:circuitBasic.name=Basic Circuit +item.basiccomponents\:circuitAdvanced.name=Advanced Circuit +item.basiccomponents\:circuitElite.name=Elite Circuit +item.basiccomponents\:wrench.name=Wrench +item.basiccomponents\:motor.name=Motor + +item.basiccomponents\:plateCopper.name=Copper Plate +item.basiccomponents\:plateTin.name=Tin Plate +item.basiccomponents\:plateBronze.name=Bronze Plate +item.basiccomponents\:plateSteel.name=Steel Plate +item.basiccomponents\:plateIron.name=Iron Plate +item.basiccomponents\:plateGold.name=Gold Plate + +item.basiccomponents\:ingotCopper.name=Copper Ingot +item.basiccomponents\:ingotTin.name=Tin Ingot +item.basiccomponents\:ingotBronze.name=Bronze Ingot +item.basiccomponents\:ingotSteel.name=Steel Ingot + +item.basiccomponents\:dustBronze.name=Bronze Dust +item.basiccomponents\:dustSteel.name=Steel Dust \ No newline at end of file diff --git a/src/main/resources/assets/basiccomponents/languages/es_ES.properties b/src/main/resources/assets/basiccomponents/languages/es_ES.properties new file mode 100644 index 0000000..7668f16 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/es_ES.properties @@ -0,0 +1,37 @@ +# Basic Components Language Properties +# @author francogp + +children=es_AR,es_MX,es_UY,es_VE + +# Blocks +tile.basiccomponents\:bcOre.0.name=Mineral de Cobre +tile.basiccomponents\:bcOre.1.name=Mineral de Esta\u00F1o +tile.basiccomponents\:oilMoving.name=Petr\u00F3leo +tile.basiccomponents\:oilStill.name=Petr\u00F3leo +tile.basiccomponents\:copperWire.name=Cable de Cobre +tile.basiccomponents\:bcMachine.0.name=Generador a Carb\u00F3n +tile.basiccomponents\:bcMachine.1.name=Caja de Bater\u00EDa +tile.basiccomponents\:bcMachine.2.name=Horno El\u00E9ctrico + +# Items +item.basiccomponents\:battery.name=Bater\u00EDa +item.basiccomponents\:circuit.name=Circuito +item.basiccomponents\:circuit.0.name=Circuito B\u00E1sico +item.basiccomponents\:circuit.1.name=Circuito Avanzado +item.basiccomponents\:circuit.2.name=Circuito \u00E9lite +item.basiccomponents\:bucketOil.name=Balde de Petr\u00F3leo +item.basiccomponents\:wrench.name=Llave Inglesa +item.basiccomponents\:motor.name=Motor + +item.basiccomponents\:plateCopper.name=Placa de Cobre +item.basiccomponents\:plateTin.name=Placa de Esta\u00F1o +item.basiccomponents\:plateBronze.name=Placa de Bronce +item.basiccomponents\:plateSteel.name=Placa de Acero + +item.basiccomponents\:ingotCopper.name=Lingote de Cobre +item.basiccomponents\:ingotTin.name=Lingote de Esta\u00F1o +item.basiccomponents\:ingotBronze.name=Lingote de Bronce +item.basiccomponents\:ingotSteel.name=Lingote de Acero + +item.basiccomponents\:dustBronze.name=Polvo de Bronce +item.basiccomponents\:dustSteel.name=Polvo de Acero \ No newline at end of file diff --git a/src/main/resources/assets/basiccomponents/languages/it_IT.properties b/src/main/resources/assets/basiccomponents/languages/it_IT.properties new file mode 100644 index 0000000..c5dca55 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/it_IT.properties @@ -0,0 +1,33 @@ +# Basic Components Language Properties +# @author Calclavia + +# Blocks +tile.basiccomponents\:bcOre.0.name=Minerale Di Rame +tile.basiccomponents\:bcOre.1.name=Minerale Di Stagno +tile.basiccomponents\:copperWire.name=Cavo Di Rame +tile.basiccomponents\:bcMachine.0.name=Generatore A Carbone +tile.basiccomponents\:bcMachine.1.name=Scatola Batteria +tile.basiccomponents\:bcMachine.2.name=Fornace Elettrica + +# Items +item.basiccomponents\:battery.name=Batteria +item.basiccomponents\:circuit.name=Circuito +item.basiccomponents\:circuit.0.name=Circuito Base +item.basiccomponents\:circuit.1.name=Circuito Avanzato +item.basiccomponents\:circuit.2.name=Circuito Elite +item.basiccomponents\:bucketOil.name=Secchio Di Petrolio +item.basiccomponents\:wrench.name=Chiave Inglese +item.basiccomponents\:motor.name=Motore + +item.basiccomponents\:plateCopper.name=Piastra Di Rame +item.basiccomponents\:plateTin.name=Piastra Di Stagno +item.basiccomponents\:plateBronze.name=Piastra Di Bronzo +item.basiccomponents\:plateSteel.name=Piastra D'Acciaio + +item.basiccomponents\:ingotCopper.name=Lingotto Di Rame +item.basiccomponents\:ingotTin.name=Lingotto Di Stagno +item.basiccomponents\:ingotBronze.name=Lingotto Di Bronzo +item.basiccomponents\:ingotSteel.name=Lingotto D'Acciaio + +item.basiccomponents\:dustBronze.name=Polvere Di Bronzo +item.basiccomponents\:dustSteel.name=Polvere D'Acciaio \ No newline at end of file diff --git a/src/main/resources/assets/basiccomponents/languages/nl_NL.properties b/src/main/resources/assets/basiccomponents/languages/nl_NL.properties new file mode 100644 index 0000000..3b903a0 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/nl_NL.properties @@ -0,0 +1,35 @@ +# Basic Components Language Properties +# @author Kees Nijenhuis + +# Blocks +tile.basiccomponents\:bcOre.0.name=Koper Erts +tile.basiccomponents\:bcOre.1.name=Tin Erts +tile.basiccomponents\:oilMoving.name=Olie +tile.basiccomponents\:oilStill.name=Olie +tile.basiccomponents\:copperWire.name=Koper Draad +tile.basiccomponents\:bcMachine.0.name=Kool Generator +tile.basiccomponents\:bcMachine.1.name=Batterijen Doos +tile.basiccomponents\:bcMachine.2.name=Elektrische Oven + +# Items +item.basiccomponents\:battery.name=Batterij +item.basiccomponents\:circuit.name=Stroomkring +item.basiccomponents\:circuit.0.name=Basis Stroomkring +item.basiccomponents\:circuit.1.name=Geavanceerde Stroomkring +item.basiccomponents\:circuit.2.name=Elite Stroomkring +item.basiccomponents\:bucketOil.name=Emmer Olie +item.basiccomponents\:wrench.name=Moersleutel +item.basiccomponents\:motor.name=Moter + +item.basiccomponents\:plateCopper.name=Koperen Plaat +item.basiccomponents\:plateTin.name=Tinnen Plaat +item.basiccomponents\:plateBronze.name=Bronzen Plaat +item.basiccomponents\:plateSteel.name=Stalen Plaat + +item.basiccomponents\:ingotCopper.name=Koper Staaf +item.basiccomponents\:ingotTin.name=Tin Staaf +item.basiccomponents\:ingotBronze.name=Brons Staaf +item.basiccomponents\:ingotSteel.name=Staal Staaf + +item.basiccomponents\:dustBronze.name=Brons Poeder +item.basiccomponents\:dustSteel.name=Staal Poede diff --git a/src/main/resources/assets/basiccomponents/languages/pl_PL.properties b/src/main/resources/assets/basiccomponents/languages/pl_PL.properties new file mode 100644 index 0000000..b9d2179 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/pl_PL.properties @@ -0,0 +1,35 @@ +# Basic Components Language Properties +# @author unekpl + +# Bloki +tile.basiccomponents\:bcOre.0.name=Ruda miedzi +tile.basiccomponents\:bcOre.1.name=Ruda cyny +tile.basiccomponents\:oilMoving.name=Ropa naftowa +tile.basiccomponents\:oilStill.name=Ropa naftowa +tile.basiccomponents\:copperWire.name=Miedziany kabel +tile.basiccomponents\:bcMachine.0.name=Generator cieplny +tile.basiccomponents\:bcMachine.1.name=Akumulator +tile.basiccomponents\:bcMachine.2.name=Piec elektryczny + +# Przedmioty +item.basiccomponents\:battery.name=Ogniwo +item.basiccomponents\:circuit.name=Obw\u00F3d elektroniczny +item.basiccomponents\:circuit.0.name=Prosty obw\u00F3d elektroniczny +item.basiccomponents\:circuit.1.name=Zaawansowany obw\u00F3d elektroniczny +item.basiccomponents\:circuit.2.name=Skomplikowany obw\u00F3d elektroniczny +item.basiccomponents\:bucketOil.name=Wiadro ropy +item.basiccomponents\:wrench.name=Klucz +item.basiccomponents\:motor.name=Silnik + +item.basiccomponents\:plateCopper.name=Miedziana p\u0142ytka +item.basiccomponents\:plateTin.name=Cynowa p\u0142ytka +item.basiccomponents\:plateBronze.name=Br\u0105zowa p\u0142ytka +item.basiccomponents\:plateSteel.name=Stalowa p\u0142ytka + +item.basiccomponents\:ingotCopper.name=Sztabka miedzi +item.basiccomponents\:ingotTin.name=Sztabka cyny +item.basiccomponents\:ingotBronze.name=Sztabka br\u0105zu +item.basiccomponents\:ingotSteel.name=Sztabka stali + +item.basiccomponents\:dustBronze.name=Py\u0142 br\u0105zu +item.basiccomponents\:dustSteel.name=Py\u0142 stali \ No newline at end of file diff --git a/src/main/resources/assets/basiccomponents/languages/zh_CN.properties b/src/main/resources/assets/basiccomponents/languages/zh_CN.properties new file mode 100644 index 0000000..84fed92 --- /dev/null +++ b/src/main/resources/assets/basiccomponents/languages/zh_CN.properties @@ -0,0 +1,38 @@ +#Basic Components Language Properties +#@author Calclavia + +children=zh_TW + +itemGroup.BasicComponents=\u901A\u7528\u7535\u529B-\u57FA\u672C\u7EC4\u4EF6 + +# Blocks +tile.basiccomponents\:bcOre.0.name=\u94DC\u77FF\u77F3 +tile.basiccomponents\:bcOre.1.name=\u9521\u77FF\u77F3 +tile.basiccomponents\:copperWire.name=\u94DC\u7EBF +tile.basiccomponents\:bcMachine.0.name=\u706B\u529B\u53D1\u7535\u673A +tile.basiccomponents\:bcMachine.1.name=\u7535\u6C60\u7BB1 +tile.basiccomponents\:bcMachine.2.name=\u7535\u7089 + +# Items +item.basiccomponents\:battery.name=\u7535\u6C60 +item.basiccomponents\:infiniteBattery.name=\u65E0\u9650\u5BB9\u91CF\u7535\u6C60 +item.basiccomponents\:circuitBasic.name=\u57FA\u672C\u7535\u8DEF +item.basiccomponents\:circuitAdvanced.name=\u8FDB\u9636\u7535\u8DEF +item.basiccomponents\:circuitElite.name=\u9AD8\u7EA7\u7535\u8DEF +item.basiccomponents\:wrench.name=\u6273\u624B +item.basiccomponents\:motor.name=\u7535\u52A8\u673A + +item.basiccomponents\:plateCopper.name=\u94DC\u677F +item.basiccomponents\:plateTin.name=\u9521\u677F +item.basiccomponents\:plateBronze.name=\u9752\u94DC\u677F +item.basiccomponents\:plateSteel.name=\u94A2\u677F +item.basiccomponents\:plateIron.name=\u94C1\u677F +item.basiccomponents\:plateGold.name=\u91D1\u677F + +item.basiccomponents\:ingotCopper.name=\u94DC\u952D +item.basiccomponents\:ingotTin.name=\u9521\u952D +item.basiccomponents\:ingotBronze.name=\u9752\u94DC\u952D +item.basiccomponents\:ingotSteel.name=\u94A2\u952D + +item.basiccomponents\:dustBronze.name=\u9752\u94DC\u7C89 +item.basiccomponents\:dustSteel.name=\u94A2\u7C89 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/batteryBox.png b/src/main/resources/assets/basiccomponents/textures/blocks/batteryBox.png new file mode 100644 index 0000000000000000000000000000000000000000..5795f1c03a4c9de5a8a49f460f42a0c1a43c1855 GIT binary patch literal 4591 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/machine.png b/src/main/resources/assets/basiccomponents/textures/blocks/machine.png new file mode 100644 index 0000000000000000000000000000000000000000..28e43c0fd00e1db7ed03a3e2fcc17a3de80dbd43 GIT binary patch literal 4557 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/machine_input.png b/src/main/resources/assets/basiccomponents/textures/blocks/machine_input.png new file mode 100644 index 0000000000000000000000000000000000000000..df5fde3c953556aa452826d354b47d1e4896ef11 GIT binary patch literal 4623 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 FV1oatwVwb0 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/machine_output.png b/src/main/resources/assets/basiccomponents/textures/blocks/machine_output.png new file mode 100644 index 0000000000000000000000000000000000000000..76348943432cb238e895bcb0b701d9a59748c57e GIT binary patch literal 4585 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/oreCopper.png b/src/main/resources/assets/basiccomponents/textures/blocks/oreCopper.png new file mode 100644 index 0000000000000000000000000000000000000000..94736cb645e4dfc15cd18037f511a395dea7933d GIT binary patch literal 3402 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/blocks/oreTin.png b/src/main/resources/assets/basiccomponents/textures/blocks/oreTin.png new file mode 100644 index 0000000000000000000000000000000000000000..914647c782c0c26b3254cb3c08bb218ecc4a2f36 GIT binary patch literal 3332 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 aAOm%08K!bioNB=N(Ya};QLXOy=)VA1;FZ+? literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/gui/coal_generator.png b/src/main/resources/assets/basiccomponents/textures/gui/coal_generator.png new file mode 100644 index 0000000000000000000000000000000000000000..aaa65afb33361c3e40eb0932b0913b76a0abe0e3 GIT binary patch literal 3956 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 E7neq(asU7T literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/gui/electric_furnace.png b/src/main/resources/assets/basiccomponents/textures/gui/electric_furnace.png new file mode 100644 index 0000000000000000000000000000000000000000..3563c6b0ef78df2da726a8534160ab6f8e448944 GIT binary patch literal 3979 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 LSfXkWuDAXJO8c@5 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/battery.png b/src/main/resources/assets/basiccomponents/textures/items/battery.png new file mode 100644 index 0000000000000000000000000000000000000000..60fcdb6291fd42058ad92d01a68eb3dd57756bc3 GIT binary patch literal 3754 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 UYu1CNzW@LL07*qoM6N<$f=c%J<^TWy literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/circuitAdvanced.png b/src/main/resources/assets/basiccomponents/textures/items/circuitAdvanced.png new file mode 100644 index 0000000000000000000000000000000000000000..1402e4f32195549eddf552ab0697ce9ba68f86db GIT binary patch literal 3655 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 X22NQyZ8g0000000NkvXXu0mjfU{IF9 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/ingotCopper.png b/src/main/resources/assets/basiccomponents/textures/items/ingotCopper.png new file mode 100644 index 0000000000000000000000000000000000000000..62758ef071a4dc67fd8d1a63a4af99baa3dea9af GIT binary patch literal 3032 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 To4q(`00000NkvXXu0mjf94tMI literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/plateBronze.png b/src/main/resources/assets/basiccomponents/textures/items/plateBronze.png new file mode 100644 index 0000000000000000000000000000000000000000..85fa709f5f3b440cd973943aa8798dc0e6ea6695 GIT binary patch literal 3726 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 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/plateCopper.png b/src/main/resources/assets/basiccomponents/textures/items/plateCopper.png new file mode 100644 index 0000000000000000000000000000000000000000..f036fd8bf501616f65b5e1e8ac1623b777513c21 GIT binary patch literal 3727 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 N002ovPDHLkV1g@f1El}} literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/plateIron.png b/src/main/resources/assets/basiccomponents/textures/items/plateIron.png new file mode 100644 index 0000000000000000000000000000000000000000..f3b08a2d90c12f38502dfc2062969e062f221708 GIT binary patch literal 3630 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 A`2YX_ literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/plateSteel.png b/src/main/resources/assets/basiccomponents/textures/items/plateSteel.png new file mode 100644 index 0000000000000000000000000000000000000000..9f65ea2b646e88922767ad6ba63fe5a1db98f699 GIT binary patch literal 3572 zcmVKLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z0009YNklr*dz#-=7dxU97$osN`(CBf*@%uL@|k2rAZ?M zbGX0eRkP1Cns?C$7Vk}!yWH;QJKxzE?gSCxCnLcR$A1Bee+VIJEy(kn0O0BANqiSh zM7ueV=Q*`nEsV!wbh};ps}9tGXIX}RzYhQykH-K&05F@)zU+qJHr!SMh8INvAq0pB zWm(4mZ*OlgnM}l2N}%dwespw%qA1|K2LOZ+5JHI093LM?H+B`W)d7YNhr-8E*lE7LUH)c57&iAC0kWxZx4evd) z)|KQ~2#cr;qCC$@DTRK&Ux5QaS(ee>BuOHifh>qKX188nU!&Dr%G1+RoS&c5#u+#~ zJjB`A8OpMRwHE938d6G>Wr=393FjP?Qt`Bh5aKlvRm6l4qFdHlu*=Rlc<<5ecKK|G z=)iKh#MRXm(lo`(%L|M#D9bWts+2;SrqEi$IR~vZhzLX!ttKLP@1qOedxQ|80KPYy z%`lx#HxFT!Wz^|((ChW^{QQh&vsr=jN#`~1Ys?+M?l|XS<{<=l@A2^Pfa!FK#bO~g z=D=dH5CF&+gVAV&5JDWe#+aBr+x>ocu_N3qLI_xEqmcXid(7u^=6pU0vn(S3=yW<5 z3!0TyCg{}E$O|7lrp-*4sZv} z=W{$hK33qh1bpU*QmT?ELpit&z4y4gyZaEnlYozebvuT`YMNwe2TA|TsU^1Ef5x(;)Ssfw0UT-J(w*|bP uA3Ra(!Z(J;cZ1KyE^P7t+wh+k@M{2f8X~93GOxJ+0000KLZ*U+IBfRsybQWXdwQbLP>6pAqfylh#{fb6;Z(vMMVS~$e@S=j*ftg6;Uhf59&ghTmgWD0l;*T zI709Y^p6lP1rIRMx#05C~cW=H_Aw*bJ-5DT&Z2n+x)QHX^p z00esgV8|mQcmRZ%02D^@S3L16t`O%c004NIvOKvYIYoh62rY33S640`D9%Y2D-rV&neh&#Q1i z007~1e$oCcFS8neI|hJl{-P!B1ZZ9hpmq0)X0i`JwE&>$+E?>%_LC6RbVIkUx0b+_+BaR3cnT7Zv!AJxW zizFb)h!jyGOOZ85F;a?DAXP{m@;!0_IfqH8(HlgRxt7s3}k3K`kFu>>-2Q$QMFfPW!La{h336o>X zu_CMttHv6zR;&ZNiS=X8v3CR#fknUxHUxJ0uoBa_M6WNWeqIg~6QE69c9o#eyhGvpiOA@W-aonk<7r1(?fC{oI5N*U!4 zfg=2N-7=cNnjjOr{yriy6mMFgG#l znCF=fnQv8CDz++o6_Lscl}eQ+l^ZHARH>?_s@|##Rr6KLRFA1%Q+=*RRWnoLsR`7U zt5vFIcfW3@?wFpwUVxrVZ>QdQz32KIeJ}k~{cZZE^+ya? z2D1z#2HOnI7(B%_ac?{wFUQ;QQA1tBKtrWrm0_3Rgps+?Jfqb{jYbcQX~taRB;#$y zZN{S}1|}gUOHJxc?wV3fxuz+mJ4`!F$IZ;mqRrNsHJd##*D~ju=bP7?-?v~|cv>vB zsJ6IeNwVZxrdjT`yl#bBIa#GxRa#xMMy;K#CDyyGyQdMSxlWT#tDe?p!?5wT$+oGt z8L;Kp2HUQ-ZMJ=3XJQv;x5ci*?vuTfeY$;({XGW_huIFR9a(?@3)XSs8O^N5RyOM=TTmp(3=8^+zpz2r)C z^>JO{deZfso3oq3?Wo(Y?l$ge?uXo;%ru`Vo>?<<(8I_>;8Eq#KMS9gFl*neeosSB zfoHYnBQIkwkyowPu(zdms`p{<7e4kra-ZWq<2*OsGTvEV%s0Td$hXT+!*8Bnh2KMe zBmZRodjHV?r+_5^X9J0WL4jKW`}lf%A-|44I@@LTvf1rHjG(ze6+w@Jt%Bvjts!X0 z?2xS?_ve_-kiKB_KiJlZ$9G`c^=E@oNG)mWWaNo-3TIW8)$Hg0Ub-~8?KhvJ>$ z3*&nim@mj(aCxE5!t{lw7O5^0EIO7zOo&c6l<+|iDySBWCGrz@C5{St!X3hAA}`T4 z(TLbXTq+(;@<=L8dXnssyft|w#WSTW<++3>sgS%(4NTpeI-VAqb|7ssJvzNHgOZVu zaYCvgO_R1~>SyL=cFU|~g|hy|Zi}}s9+d~lYqOB71z9Z$wnC=pR9Yz4DhIM>Wmjgu z&56o6maCpC&F##y%G;1PobR9i?GnNg;gYtchD%p19a!eQtZF&3JaKv33gZ<8D~47E ztUS1iwkmDaPpj=$m#%)jCVEY4fnLGNg2A-`YwHVD3gv};>)hAvT~AmqS>Lr``i7kw zJ{5_It`yrBmlc25DBO7E8;5VoznR>Ww5hAaxn$2~(q`%A-YuS64wkBy=9dm`4cXeX z4c}I@?e+FW+b@^RDBHV(wnMq2zdX3SWv9u`%{xC-q*U}&`cyXV(%rRT*Z6MH?i+i& z_B8C(+grT%{XWUQ+f@NoP1R=AW&26{v-dx)iK^-Nmiuj8txj!m?Z*Ss1N{dh4z}01 z)YTo*JycSU)+_5r4#yw9{+;i4Ee$peRgIj+;v;ZGdF1K$3E%e~4LaI(jC-u%2h$&R z9cLXcYC@Xwnns&bn)_Q~Te?roKGD|d-g^8;+aC{{G(1^(O7m37Y1-+6)01cN&y1aw zoqc{T`P^XJqPBbIW6s}d4{z_f5Om?vMgNQEJG?v2T=KYd^0M3I6IZxbny)%vZR&LD zJpPl@Psh8QyPB@KTx+@RdcC!KX7}kEo;S|j^u2lU7XQ}Oo;f|;z4Ll+_r>@1-xl3| zawq-H%e&ckC+@AhPrP6BKT#_XdT7&;F71j}Joy zkC~6lh7E@6o;W@^IpRNZ{ptLtL(gQ-CY~4mqW;US7Zxvm_|@yz&e53Bp_lTPlfP|z zrTyx_>lv@x#=^!PzR7qqF<$gm`|ZJZ+;<)Cqu&ot2z=0000WV@Og>004R=004l4008;_004mL004C`008P>0026e000+nl3&F} z000B7NkllCdFrN|38hHjvJ>Ha;yU-eEjAT!sWm;NdRd7^Nh;q#Y4MEHh=huL4|nl zj}}nEuPiNMO$vas7Vq~@F4ew)Dh%^Etr0@-$K87;3OOPipygR=3H1Kb zKx?cqgw-l4Py_-#S-H(lynAA3dK@U>S8m?G8UsS&51ia3hG1wYUlZh2tfL5_6j9;G zxoVYAD!g=9O((cVYmylDK0ggdJl>kCkQ$T*KY(;U~EPpC9S4BDFQfrZgBe5|>341nwdC&zvu@fE? zQaVyvFSTMwhh0#u6uU{nP?4CsdwT%bIA(kO5zSv8cEJY{aFioLDZF=-_u1j14eytn zDOzSm^ZsgI_^AZ+6H;r;P^rDuDZ^68pzt#Z=qCiAzHmJ+&7u#GWo+EJ%T9CaNch0_ zfqvt_rk##fU$~Cl-GxB$=e_SvgrE9KHi(e={M@PFFD&4Y5MOrGLE)V^ysXc&GB-}c h7O%ez|Mvp^8vsh3AQYtLv}6DP002ovPDHLkV1lno=LY}) literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/items/wrench.png b/src/main/resources/assets/basiccomponents/textures/items/wrench.png new file mode 100644 index 0000000000000000000000000000000000000000..ad13e8a8a1aef658ecaabebac9dc59b669ac8de7 GIT binary patch literal 3225 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 LNkvXXu0mjffk^a0 literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/basiccomponents/textures/models/copperWire.png b/src/main/resources/assets/basiccomponents/textures/models/copperWire.png new file mode 100644 index 0000000000000000000000000000000000000000..c92754d8aef86b6595fc196afaf764fd2791eb1a GIT binary patch literal 798 zcmV+(1L6FMP)004R= z004l4008;_004mL004C`008P>0026e000+nl3&F}00009a7bBm000iZ000iZ0XPLy zBme*a8gxZibW?9;ba!ELWdKlNX>N2bPDNB8b~7$DE-^4L^m3s900MqVL_t(&L+zMr zY63A7g9m>jVH)p10tS$D>11m|v|{*9aJmMm_={gT1U~u5|(cA9`Kj z&*yV80WndKLUQsm3VF1E+mHwR>2&e}0hi0g3;o04P)Z11#q07s8UpaRjR5wrIK6!BDyhM4AX8!G^@S!gP zR4X6>se>cg#u6YBLhyJVv19=LUIYl7&3Q!tfY}@HB8f;)1fY2ioeZwdgJqs40tD8E zy!AZbu`AodrhwY2{&l|we?~wZlCn)^;2$zT4qDMEE#JY+L+NMQS1lR&667_6Zag}{afsKj8 zQd@yjnA?}PRoeoc*cKqVfItFmfH7`?F^<<|Ya>7vUJ;;NE{ekEIhP#TXwA{KeT}0V zgNj+e-of?XoGP@f*kKAN0u=f-e{bcv^>mo`b?ZwEwrraj$P8o#G6R``%s^%!Gmsg` c4BTYk3usN|`Kgy1+W-In07*qoM6N<$f~@mmjQ{`u literal 0 HcmV?d00001