diff --git a/src/api/java/appeng/api/config/TunnelType.java b/src/api/java/appeng/api/config/TunnelType.java index b42d28568..a53f390f6 100644 --- a/src/api/java/appeng/api/config/TunnelType.java +++ b/src/api/java/appeng/api/config/TunnelType.java @@ -29,6 +29,7 @@ public enum TunnelType ME, // Network Tunnel IC2_POWER, // EU Tunnel RF_POWER, // RF Tunnel + FE_POWER, // Forge Energy tunnel REDSTONE, // Redstone Tunnel FLUID, // Fluid Tunnel ITEM, // Item Tunnel diff --git a/src/api/java/appeng/api/definitions/IParts.java b/src/api/java/appeng/api/definitions/IParts.java index 5b46233f2..ad816057b 100644 --- a/src/api/java/appeng/api/definitions/IParts.java +++ b/src/api/java/appeng/api/definitions/IParts.java @@ -78,9 +78,9 @@ public interface IParts IItemDefinition p2PTunnelFluids(); - //IItemDefinition p2PTunnelEU(); + IItemDefinition p2PTunnelEU(); - // IItemDefinition p2PTunnelRF(); + IItemDefinition p2PTunnelRF(); IItemDefinition p2PTunnelLight(); diff --git a/src/main/java/appeng/core/Registration.java b/src/main/java/appeng/core/Registration.java index 5d562f3cd..94cc40371 100644 --- a/src/main/java/appeng/core/Registration.java +++ b/src/main/java/appeng/core/Registration.java @@ -27,6 +27,8 @@ import java.util.Set; import javax.annotation.Nonnull; +import appeng.integration.IntegrationRegistry; +import appeng.integration.IntegrationType; import appeng.items.parts.ItemFacade; import appeng.recipes.game.DisassembleRecipe; import com.google.common.base.Preconditions; @@ -299,11 +301,17 @@ public final class Registration partHelper.registerNewLayer( "appeng.parts.layers.LayerIEnergySink", "ic2.api.energy.tile.IEnergySink" ); partHelper.registerNewLayer( "appeng.parts.layers.LayerIEnergySource", "ic2.api.energy.tile.IEnergySource" ); } - // - // if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.RF ) ) - // { - // partHelper.registerNewLayer( "appeng.parts.layers.LayerIEnergyHandler", "cofh.api.energy.IEnergyReceiver" ); - // } + + if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.RF ) ) + { + partHelper.registerNewLayer( "appeng.parts.layers.LayerIEnergyHandler", "cofh.redstoneflux.api.IEnergyReceiver" ); + } + + partHelper.registerNewLayer( "appeng.parts.layers.LayerForgeEnergy", "net.minecraftforge.energy.IEnergyStorage" ); + +// if (IntegrationRegistry.INSTANCE.isEnabled(IntegrationType.RF)) { +// partHelper.registerNewLayer("appeng.parts.layers.LayerIEnergyStorager", "net.minecraftforge.common.capabilities.ICapabilityProvider"); +// } // // if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.OpenComputers ) ) // { @@ -445,9 +453,8 @@ public final class Registration { // TODO : 1.12 Improve - final Api api = Api.INSTANCE; - final IRegistryContainer registries = api.registries(); - ApiDefinitions definitions = api.definitions(); + final IRegistryContainer registries = Api.INSTANCE.registries(); + ApiDefinitions definitions = Api.INSTANCE.definitions(); final IParts parts = definitions.parts(); final IBlocks blocks = definitions.blocks(); final IItems items = definitions.items(); diff --git a/src/main/java/appeng/core/api/definitions/ApiParts.java b/src/main/java/appeng/core/api/definitions/ApiParts.java index 995493870..c2e4f4832 100644 --- a/src/main/java/appeng/core/api/definitions/ApiParts.java +++ b/src/main/java/appeng/core/api/definitions/ApiParts.java @@ -62,8 +62,9 @@ public final class ApiParts implements IParts private final IItemDefinition p2PTunnelRedstone; private final IItemDefinition p2PTunnelItems; private final IItemDefinition p2PTunnelFluids; - // private final IItemDefinition p2PTunnelEU; - // private final IItemDefinition p2PTunnelRF; + private final IItemDefinition p2PTunnelEU; + private final IItemDefinition p2PTunnelRF; + private final IItemDefinition p2PTunnelFE; private final IItemDefinition p2PTunnelLight; // private final IItemDefinition p2PTunnelOpenComputers; private final IItemDefinition cableAnchor; @@ -113,8 +114,9 @@ public final class ApiParts implements IParts this.p2PTunnelRedstone = new DamagedItemDefinition( "part.tunnel.redstone", itemPart.createPart( PartType.P2PTunnelRedstone ) ); this.p2PTunnelItems = new DamagedItemDefinition( "part.tunnel.item", itemPart.createPart( PartType.P2PTunnelItems ) ); this.p2PTunnelFluids = new DamagedItemDefinition( "part.tunnel.fluid", itemPart.createPart( PartType.P2PTunnelFluids ) ); - // this.p2PTunnelEU = new DamagedItemDefinition( "part.tunnel.eu", itemPart.createPart( PartType.P2PTunnelEU ) ); - // this.p2PTunnelRF = new DamagedItemDefinition( itemMultiPart.createPart( PartType.P2PTunnelRF ) ); + this.p2PTunnelEU = new DamagedItemDefinition( "part.tunnel.eu", itemPart.createPart( PartType.P2PTunnelEU ) ); + this.p2PTunnelRF = new DamagedItemDefinition( "part.tunnel.rf", itemPart.createPart( PartType.P2PTunnelRF ) ); + this.p2PTunnelFE = new DamagedItemDefinition( "part.tunnel.fe", itemPart.createPart( PartType.P2PTunnelFE ) ); this.p2PTunnelLight = new DamagedItemDefinition( "part.tunnel.light", itemPart.createPart( PartType.P2PTunnelLight ) ); // this.p2PTunnelOpenComputers = new DamagedItemDefinition( itemMultiPart.createPart( // PartType.P2PTunnelOpenComputers ) ); @@ -286,18 +288,22 @@ public final class ApiParts implements IParts return this.p2PTunnelFluids; } -// @Override -// public IItemDefinition p2PTunnelEU() -// { -// return this.p2PTunnelEU; -// } + @Override + public IItemDefinition p2PTunnelEU() + { + return this.p2PTunnelEU; + } - /* @Override - * public IItemDefinition p2PTunnelRF() - * { - * return this.p2PTunnelRF; - * } - */ + @Override + public IItemDefinition p2PTunnelRF() + { + return this.p2PTunnelRF; + } + + public IItemDefinition p2PTunnelFE() + { + return this.p2PTunnelFE; + } @Override public IItemDefinition p2PTunnelLight() diff --git a/src/main/java/appeng/core/features/AEFeature.java b/src/main/java/appeng/core/features/AEFeature.java index 48d023fdf..2dcb322d9 100644 --- a/src/main/java/appeng/core/features/AEFeature.java +++ b/src/main/java/appeng/core/features/AEFeature.java @@ -118,6 +118,7 @@ public enum AEFeature P2P_TUNNEL_ITEMS( "P2PTunnelItems", Constants.CATEGORY_P2P_TUNNELS ), P2P_TUNNEL_REDSTONE( "P2PTunnelRedstone", Constants.CATEGORY_P2P_TUNNELS ), P2P_TUNNEL_EU( "P2PTunnelEU", Constants.CATEGORY_P2P_TUNNELS ), + P2P_TUNNEL_FE( "P2PTunnelFE", Constants.CATEGORY_P2P_TUNNELS ), P2P_TUNNEL_FLUIDS( "P2PTunnelFluids", Constants.CATEGORY_P2P_TUNNELS ), P2P_TUNNEL_LIGHT( "P2PTunnelLight", Constants.CATEGORY_P2P_TUNNELS ), P2P_TUNNEL_OPEN_COMPUTERS( "P2PTunnelOpenComputers", Constants.CATEGORY_P2P_TUNNELS ), diff --git a/src/main/java/appeng/core/features/registries/P2PTunnelRegistry.java b/src/main/java/appeng/core/features/registries/P2PTunnelRegistry.java index 36fddaba8..b6fa85521 100644 --- a/src/main/java/appeng/core/features/registries/P2PTunnelRegistry.java +++ b/src/main/java/appeng/core/features/registries/P2PTunnelRegistry.java @@ -56,6 +56,27 @@ public final class P2PTunnelRegistry implements IP2PTunnelRegistry this.addNewAttunement( new ItemStack( Blocks.TORCH ), TunnelType.LIGHT ); this.addNewAttunement( new ItemStack( Blocks.GLOWSTONE ), TunnelType.LIGHT ); + /** + * RF tunnel items + */ + + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 0 ), TunnelType.RF_POWER ); // leadstone fluxduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 1 ), TunnelType.RF_POWER ); // hardened fluxduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 2 ), TunnelType.RF_POWER ); // redstone fluxduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 3 ), TunnelType.RF_POWER ); // signalum fluxduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 4 ), TunnelType.RF_POWER ); // resonant fluxduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_0", 5 ), TunnelType.RF_POWER ); // cryo-stabilized fluxduct + + /** + * EU tunnel items + */ + + this.addNewAttunement( this.getModItem( "ic2", "cable", 0 ), TunnelType.IC2_POWER ); // Copper cable + this.addNewAttunement( this.getModItem( "ic2", "cable", 1 ), TunnelType.IC2_POWER ); // Glass fibre cable + this.addNewAttunement( this.getModItem( "ic2", "cable", 2 ), TunnelType.IC2_POWER ); // Gold cable + this.addNewAttunement( this.getModItem( "ic2", "cable", 3 ), TunnelType.IC2_POWER ); // HV cable + this.addNewAttunement( this.getModItem( "ic2", "cable", 4 ), TunnelType.IC2_POWER ); // Tin cable + /** * attune based on most redstone base items. */ @@ -91,7 +112,10 @@ public final class P2PTunnelRegistry implements IP2PTunnelRegistry this.addNewAttunement( this.getModItem( "extrautilities", "extractor_base", 0 ), TunnelType.ITEM ); this.addNewAttunement( this.getModItem( "mekanism", "parttransmitter", 9 ), TunnelType.ITEM ); this.addNewAttunement( this.getModItem( "enderio", "itemitemconduit", OreDictionary.WILDCARD_VALUE ), TunnelType.ITEM ); - this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_32", 0 ), TunnelType.ITEM ); + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_32", 0 ), TunnelType.ITEM ); // itemduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_32", 1 ), TunnelType.ITEM ); // itemduct (opaque) + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_32", 2 ), TunnelType.ITEM ); // impulse itemduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_32", 3 ), TunnelType.ITEM ); // impulse itemduct (opaque) /** * attune based on lots of random item related stuff @@ -105,7 +129,10 @@ public final class P2PTunnelRegistry implements IP2PTunnelRegistry this.addNewAttunement( this.getModItem( "extrautilities", "extractor_base", 6 ), TunnelType.FLUID ); this.addNewAttunement( this.getModItem( "extrautilities", "drum", OreDictionary.WILDCARD_VALUE ), TunnelType.FLUID ); this.addNewAttunement( this.getModItem( "enderio", "itemliquidconduit", OreDictionary.WILDCARD_VALUE ), TunnelType.FLUID ); - this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_16", 0 ), TunnelType.FLUID ); + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_16", 0 ), TunnelType.FLUID ); // fluiduct + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_16", 1 ), TunnelType.FLUID ); // fluiduct (opaque) + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_16", 2 ), TunnelType.FLUID ); // fluiduct hardened + this.addNewAttunement( this.getModItem( "thermaldynamics", "duct_16", 3 ), TunnelType.FLUID ); // fluiduct hardened (opaque) for( final AEColor c : AEColor.values() ) { diff --git a/src/main/java/appeng/core/localization/GuiText.java b/src/main/java/appeng/core/localization/GuiText.java index d9c2f19e9..14dd3b184 100644 --- a/src/main/java/appeng/core/localization/GuiText.java +++ b/src/main/java/appeng/core/localization/GuiText.java @@ -90,6 +90,7 @@ public enum GuiText OCTunnel, LightTunnel, RFTunnel, + FETunnel, PressureTunnel, StoredSize, diff --git a/src/main/java/appeng/integration/Integrations.java b/src/main/java/appeng/integration/Integrations.java index 871b4cb06..85a8da23d 100644 --- a/src/main/java/appeng/integration/Integrations.java +++ b/src/main/java/appeng/integration/Integrations.java @@ -19,11 +19,7 @@ package appeng.integration; -import appeng.integration.abstraction.IIC2; -import appeng.integration.abstraction.IInvTweaks; -import appeng.integration.abstraction.IJEI; -import appeng.integration.abstraction.IMekanism; -import appeng.integration.abstraction.IRC; +import appeng.integration.abstraction.*; /** @@ -42,6 +38,8 @@ public final class Integrations static IInvTweaks invTweaks = new IInvTweaks.Stub(); + static IRF redstoneflux = new IRF.Stub(); + private Integrations() { } @@ -101,4 +99,10 @@ public final class Integrations return invTweaks; } + static IRF setRedstoneFlux( IRF redstoneflux ) + { + Integrations.redstoneflux = redstoneflux; + return redstoneflux; + } + } diff --git a/src/main/java/appeng/integration/abstraction/IRF.java b/src/main/java/appeng/integration/abstraction/IRF.java new file mode 100644 index 000000000..9860d314c --- /dev/null +++ b/src/main/java/appeng/integration/abstraction/IRF.java @@ -0,0 +1,32 @@ +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2017, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.integration.abstraction; + +import appeng.integration.IIntegrationModule; + +/** + * @author GuntherDW + */ +public interface IRF +{ + class Stub extends IIntegrationModule.Stub implements IRF + { + + } +} diff --git a/src/main/java/appeng/integration/modules/ic2/IC2Module.java b/src/main/java/appeng/integration/modules/ic2/IC2Module.java index e736e5c70..80d2beebc 100644 --- a/src/main/java/appeng/integration/modules/ic2/IC2Module.java +++ b/src/main/java/appeng/integration/modules/ic2/IC2Module.java @@ -1,84 +1,81 @@ -///* -// * This file is part of Applied Energistics 2. -// * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. -// * -// * Applied Energistics 2 is free software: you can redistribute it and/or modify -// * it under the terms of the GNU Lesser General Public License as published by -// * the Free Software Foundation, either version 3 of the License, or -// * (at your option) any later version. -// * -// * Applied Energistics 2 is distributed in the hope that it will be useful, -// * but WITHOUT ANY WARRANTY; without even the implied warranty of -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// * GNU Lesser General Public License for more details. -// * -// * You should have received a copy of the GNU Lesser General Public License -// * along with Applied Energistics 2. If not, see . -// */ -// -//package appeng.integration.modules.ic2; -// -// -//import net.minecraft.item.ItemStack; -//import net.minecraft.tileentity.TileEntity; -// -//import ic2.api.recipe.RecipeInputItemStack; -// -//import appeng.api.AEApi; -//import appeng.api.config.TunnelType; -//import appeng.api.features.IP2PTunnelRegistry; -//import appeng.integration.IntegrationHelper; -//import appeng.integration.abstraction.IC2PowerSink; -//import appeng.integration.abstraction.IIC2; -//import appeng.tile.powersink.IExternalPowerSink; -// -// -//public class IC2Module implements IIC2 -//{ -// -// private static final String[] IC2_CABLE_TYPES = { "copper", "glass", "gold", "iron", "tin", "detector", "splitter" }; -// -// public IC2Module() -// { -// IntegrationHelper.testClassExistence( this, ic2.api.energy.tile.IEnergyTile.class ); -// IntegrationHelper.testClassExistence( this, ic2.api.item.IC2Items.class ); -// IntegrationHelper.testClassExistence( this, ic2.api.recipe.Recipes.class ); -// IntegrationHelper.testClassExistence( this, ic2.api.recipe.RecipeInputItemStack.class ); -// } -// -// @Override -// public void postInit() -// { -// final IP2PTunnelRegistry reg = AEApi.instance().registries().p2pTunnel(); -// -// for( String string : IC2_CABLE_TYPES ) -// { -// reg.addNewAttunement( this.getCable( string ), TunnelType.IC2_POWER ); -// } -// } -// -// private ItemStack getItem( final String name, String variant ) -// { -// return ic2.api.item.IC2Items.getItem( name, variant ); -// } -// -// private ItemStack getCable( final String type ) -// { -// return this.getItem( "cable", "type:" + type ); -// } -// -// /** -// * Create an IC2 power sink for the given external sink. -// */ -// @Override -// public IC2PowerSink createPowerSink( TileEntity tileEntity, IExternalPowerSink externalSink ) -// { -// return new IC2PowerSinkAdapter( tileEntity, externalSink ); -// } -// -// @Override -// public void maceratorRecipe( ItemStack in, ItemStack out ) -// { -// ic2.api.recipe.Recipes.macerator.addRecipe( new RecipeInputItemStack( in, in.stackSize ), null, false, out ); -// } -//} +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.integration.modules.ic2; + +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; + +import appeng.api.AEApi; +import appeng.api.config.TunnelType; +import appeng.api.features.IP2PTunnelRegistry; +import appeng.integration.IntegrationHelper; +import appeng.integration.abstraction.IC2PowerSink; +import appeng.integration.abstraction.IIC2; +import appeng.tile.powersink.IExternalPowerSink; + + +public class IC2Module implements IIC2 +{ + + private static final String[] IC2_CABLE_TYPES = { "copper", "glass", "gold", "iron", "tin", "detector", "splitter" }; + + public IC2Module() + { + IntegrationHelper.testClassExistence( this, ic2.api.energy.tile.IEnergyTile.class ); + IntegrationHelper.testClassExistence( this, ic2.api.item.IC2Items.class ); + IntegrationHelper.testClassExistence( this, ic2.api.recipe.Recipes.class ); + IntegrationHelper.testClassExistence( this, ic2.api.recipe.IRecipeInput.class ); + } + + @Override + public void postInit() + { + final IP2PTunnelRegistry reg = AEApi.instance().registries().p2pTunnel(); + + for( String string : IC2_CABLE_TYPES ) + { + reg.addNewAttunement( this.getCable( string ), TunnelType.IC2_POWER ); + } + } + + private ItemStack getItem( final String name, String variant ) + { + return ic2.api.item.IC2Items.getItem( name, variant ); + } + + private ItemStack getCable( final String type ) + { + return this.getItem( "cable", "type:" + type ); + } + + /** + * Create an IC2 power sink for the given external sink. + */ + @Override + public IC2PowerSink createPowerSink( TileEntity tileEntity, IExternalPowerSink externalSink ) + { + return new IC2PowerSinkAdapter( tileEntity, externalSink ); + } + + @Override + public void maceratorRecipe( ItemStack in, ItemStack out ) + { + ic2.api.recipe.Recipes.macerator.addRecipe( new IC2RecipeInput( in, in.getCount() ), null, false, out ); + } +} diff --git a/src/main/java/appeng/integration/modules/ic2/IC2PowerSinkAdapter.java b/src/main/java/appeng/integration/modules/ic2/IC2PowerSinkAdapter.java index 289bd8b67..e9f9c0a02 100644 --- a/src/main/java/appeng/integration/modules/ic2/IC2PowerSinkAdapter.java +++ b/src/main/java/appeng/integration/modules/ic2/IC2PowerSinkAdapter.java @@ -1,94 +1,94 @@ -///* -// * This file is part of Applied Energistics 2. -// * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. -// * -// * Applied Energistics 2 is free software: you can redistribute it and/or modify -// * it under the terms of the GNU Lesser General Public License as published by -// * the Free Software Foundation, either version 3 of the License, or -// * (at your option) any later version. -// * -// * Applied Energistics 2 is distributed in the hope that it will be useful, -// * but WITHOUT ANY WARRANTY; without even the implied warranty of -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// * GNU Lesser General Public License for more details. -// * -// * You should have received a copy of the GNU Lesser General Public License -// * along with Applied Energistics 2. If not, see . -// */ -// -//package appeng.integration.modules.ic2; -// -// -//import java.util.EnumSet; -//import java.util.Set; -// -//import net.minecraft.tileentity.TileEntity; -//import net.minecraft.util.EnumFacing; -// -//import ic2.api.energy.prefab.BasicSink; -//import ic2.api.energy.tile.IEnergyEmitter; -// -//import appeng.api.config.PowerUnits; -//import appeng.integration.abstraction.IC2PowerSink; -//import appeng.tile.powersink.IExternalPowerSink; -// -// -///** -// * The real implementation of IC2PowerSink. -// */ -//public class IC2PowerSinkAdapter extends BasicSink implements IC2PowerSink -//{ -// -// private final IExternalPowerSink powerSink; -// -// private final Set validFaces = EnumSet.allOf( EnumFacing.class ); -// -// public IC2PowerSinkAdapter( TileEntity tileEntity, IExternalPowerSink powerSink ) -// { -// super( tileEntity, 0, Integer.MAX_VALUE ); -// this.powerSink = powerSink; -// } -// -// @Override -// public void invalidate() -// { -// super.onChunkUnload(); -// } -// -// @Override -// public void onChunkUnload() -// { -// super.onChunkUnload(); -// } -// -// @Override -// public void onLoad() -// { -// super.onLoaded(); -// } -// -// @Override -// public double getDemandedEnergy() -// { -// return powerSink.getExternalPowerDemand( PowerUnits.EU, Double.MAX_VALUE ); -// } -// -// @Override -// public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) -// { -// return PowerUnits.EU.convertTo( PowerUnits.AE, powerSink.injectExternalPower( PowerUnits.EU, amount ) ); -// } -// -// @Override -// public boolean acceptsEnergyFrom( IEnergyEmitter iEnergyEmitter, EnumFacing side ) -// { -// return validFaces.contains( side ); -// } -// -// @Override -// public void setValidFaces( Set faces ) -// { -// this.validFaces.clear(); -// this.validFaces.addAll( faces ); -// } -//} +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.integration.modules.ic2; + + +import java.util.EnumSet; +import java.util.Set; + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; + +import ic2.api.energy.prefab.BasicSink; +import ic2.api.energy.tile.IEnergyEmitter; + +import appeng.api.config.PowerUnits; +import appeng.integration.abstraction.IC2PowerSink; +import appeng.tile.powersink.IExternalPowerSink; + + +/** + * The real implementation of IC2PowerSink. + */ +public class IC2PowerSinkAdapter extends BasicSink implements IC2PowerSink +{ + + private final IExternalPowerSink powerSink; + + private final Set validFaces = EnumSet.allOf( EnumFacing.class ); + + public IC2PowerSinkAdapter( TileEntity tileEntity, IExternalPowerSink powerSink ) + { + super( tileEntity, 0, Integer.MAX_VALUE ); + this.powerSink = powerSink; + } + + @Override + public void invalidate() + { + super.onChunkUnload(); + } + + @Override + public void onChunkUnload() + { + super.onChunkUnload(); + } + + @Override + public void onLoad() + { + super.onLoad(); + } + + @Override + public double getDemandedEnergy() + { + return powerSink.getExternalPowerDemand( PowerUnits.EU, Double.MAX_VALUE ); + } + + @Override + public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) + { + return PowerUnits.EU.convertTo( PowerUnits.AE, powerSink.injectExternalPower( PowerUnits.EU, amount ) ); + } + + @Override + public boolean acceptsEnergyFrom( IEnergyEmitter iEnergyEmitter, EnumFacing side ) + { + return validFaces.contains( side ); + } + + @Override + public void setValidFaces( Set faces ) + { + this.validFaces.clear(); + this.validFaces.addAll( faces ); + } +} diff --git a/src/main/java/appeng/integration/modules/ic2/IC2RecipeInput.java b/src/main/java/appeng/integration/modules/ic2/IC2RecipeInput.java new file mode 100644 index 000000000..6c26f97fe --- /dev/null +++ b/src/main/java/appeng/integration/modules/ic2/IC2RecipeInput.java @@ -0,0 +1,61 @@ +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.integration.modules.ic2; + +import ic2.api.recipe.IRecipeInput; +import net.minecraft.item.ItemStack; + +import javax.annotation.Nonnull; +import java.util.Collections; +import java.util.List; + +/** + * Implementation of IRecipeInput for the macerator recipe. + * @author GuntherDW + */ +public class IC2RecipeInput implements IRecipeInput +{ + @Nonnull + private final ItemStack itemstack; + private final int amount; + + public IC2RecipeInput( ItemStack in, int amount ) + { + this.itemstack = in; + this.amount = amount; + } + + @Override + public boolean matches( ItemStack itemStack ) + { + return this.itemstack.isItemEqual( itemStack ); + } + + @Override + public int getAmount() + { + return this.amount; + } + + @Override + public List getInputs() + { + return Collections.unmodifiableList( Collections.singletonList( itemstack ) ); + } +} diff --git a/src/main/java/appeng/integration/modules/rf/RFModule.java b/src/main/java/appeng/integration/modules/rf/RFModule.java new file mode 100644 index 000000000..fa944b979 --- /dev/null +++ b/src/main/java/appeng/integration/modules/rf/RFModule.java @@ -0,0 +1,38 @@ +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2017, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.integration.modules.rf; + +import appeng.integration.IIntegrationModule; +import appeng.integration.IntegrationHelper; + +/** + * @author GuntherDW + */ +public class RFModule implements IIntegrationModule +{ + public RFModule() + { + IntegrationHelper.testClassExistence( this, cofh.redstoneflux.api.IEnergyContainerItem.class ); + IntegrationHelper.testClassExistence( this, cofh.redstoneflux.api.IEnergyProvider.class ); + IntegrationHelper.testClassExistence( this, cofh.redstoneflux.api.IEnergyConnection.class ); + IntegrationHelper.testClassExistence( this, cofh.redstoneflux.api.IEnergyContainerItem.class ); + } + + +} diff --git a/src/main/java/appeng/items/parts/PartType.java b/src/main/java/appeng/items/parts/PartType.java index f78395d71..10d9fcb87 100644 --- a/src/main/java/appeng/items/parts/PartType.java +++ b/src/main/java/appeng/items/parts/PartType.java @@ -28,6 +28,8 @@ import java.util.List; import java.util.Set; import java.util.stream.Collectors; +import appeng.integration.IntegrationHelper; +import appeng.parts.p2p.*; import com.google.common.collect.ImmutableList; import net.minecraft.client.renderer.block.model.ModelResourceLocation; @@ -59,12 +61,6 @@ import appeng.parts.networking.PartCableGlass; import appeng.parts.networking.PartCableSmart; import appeng.parts.networking.PartDenseCable; import appeng.parts.networking.PartQuartzFiber; -import appeng.parts.p2p.PartP2PFluids; -//import appeng.parts.p2p.PartP2PIC2Power; -import appeng.parts.p2p.PartP2PItems; -import appeng.parts.p2p.PartP2PLight; -import appeng.parts.p2p.PartP2PRedstone; -import appeng.parts.p2p.PartP2PTunnelME; import appeng.parts.reporting.PartConversionMonitor; import appeng.parts.reporting.PartCraftingTerminal; import appeng.parts.reporting.PartDarkPanel; @@ -235,19 +231,26 @@ public enum PartType return "P2PTunnel"; } }, -// -// P2PTunnelEU( 465, "p2p_tunnel_ic2", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_EU ), EnumSet -// .of( IntegrationType.IC2 ), PartP2PIC2Power.class, GuiText.EUTunnel ) -// { -// @Override -// String getUnlocalizedName() -// { -// return "P2PTunnel"; -// } -// }, - // P2PTunnelRF( 466, EnumSet.of( AEFeature.P2PTunnel, AEFeature.P2PTunnelRF ), EnumSet.of( IntegrationType.RF ), - // PartP2PRFPower.class, GuiText.RFTunnel ), + P2PTunnelEU( 465, "p2p_tunnel_ic2", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_EU ), EnumSet + .of ( IntegrationType.IC2 ), PartP2PIC2Power.class, GuiText.EUTunnel ) + { + @Override + String getUnlocalizedName() + { + return "P2PTunnel"; + } + }, + + P2PTunnelRF( 466, "p2p_tunnel_rf", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_RF ), EnumSet + .of ( IntegrationType.RF ), PartP2PRFPower.class, GuiText.RFTunnel ) + { + @Override + String getUnlocalizedName() + { + return "P2PTunnel"; + } + }, P2PTunnelLight( 467, "p2p_tunnel_light", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_LIGHT ), EnumSet .noneOf( IntegrationType.class ), PartP2PLight.class, GuiText.LightTunnel ) @@ -259,6 +262,16 @@ public enum PartType } }, + P2PTunnelFE( 469, "p2p_tunnel_fe", EnumSet.of( AEFeature.P2P_TUNNEL, AEFeature.P2P_TUNNEL_FE ), EnumSet + .noneOf( IntegrationType.class ), PartP2PFEPower.class, GuiText.FETunnel ) + { + @Override + String getUnlocalizedName() + { + return "P2PTunnel"; + } + }, + // P2PTunnelOpenComputers( 468, EnumSet.of( AEFeature.P2PTunnel, AEFeature.P2PTunnelOpenComputers ), EnumSet.of( // IntegrationType.OpenComputers ), PartP2POpenComputers.class, GuiText.OCTunnel ), diff --git a/src/main/java/appeng/parts/layers/LayerForgeEnergy.java b/src/main/java/appeng/parts/layers/LayerForgeEnergy.java new file mode 100644 index 000000000..d1613944c --- /dev/null +++ b/src/main/java/appeng/parts/layers/LayerForgeEnergy.java @@ -0,0 +1,141 @@ +/* + * + * * This file is part of Applied Energistics 2. + * * Copyright (c) 2013 - 2017, AlgorithmX2, All rights reserved. + * * + * * Applied Energistics 2 is free software: you can redistribute it and/or modify + * * it under the terms of the GNU Lesser General Public License as published by + * * the Free Software Foundation, either version 3 of the License, or + * * (at your option) any later version. + * * + * * Applied Energistics 2 is distributed in the hope that it will be useful, + * * but WITHOUT ANY WARRANTY; without even the implied warranty of + * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * * GNU Lesser General Public License for more details. + * * + * * You should have received a copy of the GNU Lesser General Public License + * * along with Applied Energistics 2. If not, see . + * + */ + +package appeng.parts.layers; + +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import net.minecraft.util.EnumFacing; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.common.capabilities.ICapabilityProvider; +import net.minecraftforge.energy.CapabilityEnergy; +import net.minecraftforge.energy.IEnergyStorage; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; + +/** + * @author GuntherDW + */ +public class LayerForgeEnergy extends LayerBase implements ICapabilityProvider, IEnergyStorage +{ + + private final EnumFacing facing; + + public LayerForgeEnergy() + { + this.facing = null; + } + + public LayerForgeEnergy( EnumFacing facing ) + { + this.facing = facing; + } + + @Override + public int receiveEnergy( int maxReceive, boolean simulate ) + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).receiveEnergy( maxReceive, simulate ); + } + } + + return 0; + } + + @Override + public int extractEnergy( int maxExtract, boolean simulate ) + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).extractEnergy( maxExtract, simulate ); + } + } + + return 0; + } + + @Override + public int getEnergyStored() + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).getEnergyStored(); + } + } + + return 0; + } + + @Override + public int getMaxEnergyStored() + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).getMaxEnergyStored(); + } + } + + return 0; + } + + @Override + public boolean canExtract() + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).canExtract(); + } + } + + return false; + } + + @Override + public boolean canReceive() + { + if( facing != null) + { + IPart part = getPart( facing ); + if( part instanceof IEnergyStorage ) + { + return ( (IEnergyStorage) part ).canReceive(); + } + } + + return false; + } +} diff --git a/src/main/java/appeng/parts/layers/LayerIEnergyHandler.java b/src/main/java/appeng/parts/layers/LayerIEnergyHandler.java index 3310981f6..698940ca3 100644 --- a/src/main/java/appeng/parts/layers/LayerIEnergyHandler.java +++ b/src/main/java/appeng/parts/layers/LayerIEnergyHandler.java @@ -19,75 +19,75 @@ package appeng.parts.layers; -//import cofh.api.energy.IEnergyConnection; -//import cofh.api.energy.IEnergyHandler; -//import cofh.api.energy.IEnergyProvider; -//import cofh.api.energy.IEnergyReceiver; -//import appeng.api.parts.IPart; -//import appeng.api.parts.LayerBase; -//import appeng.api.util.ForgeDirection; -// -// -//public class LayerIEnergyHandler extends LayerBase implements IEnergyHandler -//{ -// -// @Override -// public int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate ) -// { -// IPart part = this.getPart( from ); -// if( part instanceof IEnergyReceiver ) -// { -// return ( (IEnergyReceiver) part ).receiveEnergy( from, maxReceive, simulate ); -// } -// -// return 0; -// } -// -// @Override -// public int extractEnergy( ForgeDirection from, int maxExtract, boolean simulate ) -// { -// IPart part = this.getPart( from ); -// if( part instanceof IEnergyProvider ) -// { -// return ( (IEnergyProvider) part ).extractEnergy( from, maxExtract, simulate ); -// } -// -// return 0; -// } -// -// @Override -// public int getEnergyStored( ForgeDirection from ) -// { -// IPart part = this.getPart( from ); -// if( part instanceof IEnergyProvider ) -// { -// return ( (IEnergyProvider) part ).getEnergyStored( from ); -// } -// -// return 0; -// } -// -// @Override -// public int getMaxEnergyStored( ForgeDirection from ) -// { -// IPart part = this.getPart( from ); -// if( part instanceof IEnergyProvider ) -// { -// return ( (IEnergyProvider) part ).getMaxEnergyStored( from ); -// } -// -// return 0; -// } -// -// @Override -// public boolean canConnectEnergy( ForgeDirection from ) -// { -// IPart part = this.getPart( from ); -// if( part instanceof IEnergyConnection ) -// { -// return ( (IEnergyConnection) part ).canConnectEnergy( from ); -// } -// -// return false; -// } -// } +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import cofh.redstoneflux.api.IEnergyConnection; +import cofh.redstoneflux.api.IEnergyHandler; +import cofh.redstoneflux.api.IEnergyProvider; +import cofh.redstoneflux.api.IEnergyReceiver; +import net.minecraft.util.EnumFacing; + + +public class LayerIEnergyHandler extends LayerBase implements IEnergyHandler, IEnergyReceiver, IEnergyProvider +{ + + @Override + public int receiveEnergy( EnumFacing from, int maxReceive, boolean simulate ) + { + IPart part = this.getPart( from ); + if( part instanceof IEnergyReceiver ) + { + return ( (IEnergyReceiver) part ).receiveEnergy( from, maxReceive, simulate ); + } + + return 0; + } + + @Override + public int extractEnergy( EnumFacing from, int maxExtract, boolean simulate ) + { + IPart part = this.getPart( from ); + if( part instanceof IEnergyProvider ) + { + return ( (IEnergyProvider) part ).extractEnergy( from, maxExtract, simulate ); + } + + return 0; + } + + @Override + public int getEnergyStored( EnumFacing from ) + { + IPart part = this.getPart( from ); + if( part instanceof IEnergyProvider ) + { + return ( (IEnergyProvider) part ).getEnergyStored( from ); + } + + return 0; + } + + @Override + public int getMaxEnergyStored( EnumFacing from ) + { + IPart part = this.getPart( from ); + if( part instanceof IEnergyProvider ) + { + return ( (IEnergyProvider) part ).getMaxEnergyStored( from ); + } + + return 0; + } + + @Override + public boolean canConnectEnergy( EnumFacing from ) + { + IPart part = this.getPart( from ); + if( part instanceof IEnergyConnection ) + { + return ( (IEnergyConnection) part ).canConnectEnergy( from ); + } + + return false; + } + } diff --git a/src/main/java/appeng/parts/layers/LayerIEnergySink.java b/src/main/java/appeng/parts/layers/LayerIEnergySink.java index 04d0d2087..b000b0882 100644 --- a/src/main/java/appeng/parts/layers/LayerIEnergySink.java +++ b/src/main/java/appeng/parts/layers/LayerIEnergySink.java @@ -1,204 +1,204 @@ -///* -// * This file is part of Applied Energistics 2. -// * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. -// * -// * Applied Energistics 2 is free software: you can redistribute it and/or modify -// * it under the terms of the GNU Lesser General Public License as published by -// * the Free Software Foundation, either version 3 of the License, or -// * (at your option) any later version. -// * -// * Applied Energistics 2 is distributed in the hope that it will be useful, -// * but WITHOUT ANY WARRANTY; without even the implied warranty of -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// * GNU Lesser General Public License for more details. -// * -// * You should have received a copy of the GNU Lesser General Public License -// * along with Applied Energistics 2. If not, see . -// */ -// -//package appeng.parts.layers; -// -// -//import net.minecraft.tileentity.TileEntity; -//import net.minecraft.util.EnumFacing; -//import net.minecraft.world.World; -//import net.minecraftforge.common.MinecraftForge; -// -//import ic2.api.energy.tile.IEnergyAcceptor; -//import ic2.api.energy.tile.IEnergyEmitter; -//import ic2.api.energy.tile.IEnergySink; -//import ic2.api.energy.tile.IEnergyTile; -// -//import appeng.api.parts.IPart; -//import appeng.api.parts.IPartHost; -//import appeng.api.parts.LayerBase; -//import appeng.api.parts.LayerFlags; -//import appeng.util.Platform; -// -// -//public class LayerIEnergySink extends LayerBase implements IEnergySink -//{ -// -// private TileEntity getEnergySinkTile() -// { -// IPartHost host = (IPartHost) this; -// return host.getTile(); -// } -// -// private World getEnergySinkWorld() -// { -// if( this.getEnergySinkTile() == null ) -// { -// return null; -// } -// -// return this.getEnergySinkTile().getWorld(); -// } -// -// private boolean isTileValid() -// { -// TileEntity te = this.getEnergySinkTile(); -// -// if( te == null ) -// { -// return false; -// } -// -// return !te.isInvalid() && te.getWorld().isBlockLoaded( te.getPos() ); -// } -// -// private void addToENet() -// { -// if( this.getEnergySinkWorld() == null ) -// { -// return; -// } -// -// // re-add -// this.removeFromENet(); -// -// if( !this.isInIC2() && Platform.isServer() && this.isTileValid() ) -// { -// this.getLayerFlags().add( LayerFlags.IC2_ENET ); -// MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergyTile) this.getEnergySinkTile() ) ); -// } -// } -// -// private void removeFromENet() -// { -// if( this.getEnergySinkWorld() == null ) -// { -// return; -// } -// -// if( this.isInIC2() && Platform.isServer() ) -// { -// this.getLayerFlags().remove( LayerFlags.IC2_ENET ); -// MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergyTile) this.getEnergySinkTile() ) ); -// } -// } -// -// private boolean interestedInIC2() -// { -// if( !( (IPartHost) this ).isInWorld() ) -// { -// return false; -// } -// -// int interested = 0; -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergyTile ) -// { -// interested++; -// } -// } -// return interested == 1;// if more then one tile is interested we need to abandon... -// } -// -// @Override -// public void partChanged() -// { -// super.partChanged(); -// -// if( this.interestedInIC2() ) -// { -// this.addToENet(); -// } -// else -// { -// this.removeFromENet(); -// } -// } -// -// @Override -// public boolean acceptsEnergyFrom( IEnergyEmitter emitter, EnumFacing direction ) -// { -// if( !this.isInIC2() ) -// { -// return false; -// } -// -// IPart part = this.getPart( direction ); -// if( part instanceof IEnergySink ) -// { -// return ( (IEnergyAcceptor) part ).acceptsEnergyFrom( emitter, direction ); -// } -// return false; -// } -// -// private boolean isInIC2() -// { -// return this.getLayerFlags().contains( LayerFlags.IC2_ENET ); -// } -// -// @Override -// public double getDemandedEnergy() -// { -// if( !this.isInIC2() ) -// { -// return 0; -// } -// -// // this is a flawed implementation, that requires a change to the IC2 API. -// -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergySink ) -// { -// // use lower number cause ic2 deletes power it sends that isn't received. -// return ( (IEnergySink) part ).getDemandedEnergy(); -// } -// } -// -// return 0; -// } -// -// @Override -// public int getSinkTier() -// { -// return Integer.MAX_VALUE; // no real options here... -// } -// -// @Override -// public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) -// { -// if( !this.isInIC2() ) -// { -// return amount; -// } -// -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergySink ) -// { -// return ( (IEnergySink) part ).injectEnergy( directionFrom, amount, voltage ); -// } -// } -// -// return amount; -// } -//} +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.parts.layers; + + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; + +import ic2.api.energy.tile.IEnergyAcceptor; +import ic2.api.energy.tile.IEnergyEmitter; +import ic2.api.energy.tile.IEnergySink; +import ic2.api.energy.tile.IEnergyTile; + +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.api.parts.LayerBase; +import appeng.api.parts.LayerFlags; +import appeng.util.Platform; + + +public class LayerIEnergySink extends LayerBase implements IEnergySink +{ + + private TileEntity getEnergySinkTile() + { + IPartHost host = (IPartHost) this; + return host.getTile(); + } + + private World getEnergySinkWorld() + { + if( this.getEnergySinkTile() == null ) + { + return null; + } + + return this.getEnergySinkTile().getWorld(); + } + + private boolean isTileValid() + { + TileEntity te = this.getEnergySinkTile(); + + if( te == null ) + { + return false; + } + + return !te.isInvalid() && te.getWorld().isBlockLoaded( te.getPos() ); + } + + private void addToENet() + { + if( this.getEnergySinkWorld() == null ) + { + return; + } + + // re-add + this.removeFromENet(); + + if( !this.isInIC2() && Platform.isServer() && this.isTileValid() ) + { + this.getLayerFlags().add( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergyTile) this.getEnergySinkTile() ) ); + } + } + + private void removeFromENet() + { + if( this.getEnergySinkWorld() == null ) + { + return; + } + + if( this.isInIC2() && Platform.isServer() ) + { + this.getLayerFlags().remove( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergyTile) this.getEnergySinkTile() ) ); + } + } + + private boolean interestedInIC2() + { + if( !( (IPartHost) this ).isInWorld() ) + { + return false; + } + + int interested = 0; + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergyTile ) + { + interested++; + } + } + return interested == 1;// if more then one tile is interested we need to abandon... + } + + @Override + public void partChanged() + { + super.partChanged(); + + if( this.interestedInIC2() ) + { + this.addToENet(); + } + else + { + this.removeFromENet(); + } + } + + @Override + public boolean acceptsEnergyFrom( IEnergyEmitter emitter, EnumFacing direction ) + { + if( !this.isInIC2() ) + { + return false; + } + + IPart part = this.getPart( direction ); + if( part instanceof IEnergySink ) + { + return ( (IEnergyAcceptor) part ).acceptsEnergyFrom( emitter, direction ); + } + return false; + } + + private boolean isInIC2() + { + return this.getLayerFlags().contains( LayerFlags.IC2_ENET ); + } + + @Override + public double getDemandedEnergy() + { + if( !this.isInIC2() ) + { + return 0; + } + + // this is a flawed implementation, that requires a change to the IC2 API. + + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergySink ) + { + // use lower number cause ic2 deletes power it sends that isn't received. + return ( (IEnergySink) part ).getDemandedEnergy(); + } + } + + return 0; + } + + @Override + public int getSinkTier() + { + return Integer.MAX_VALUE; // no real options here... + } + + @Override + public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) + { + if( !this.isInIC2() ) + { + return amount; + } + + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergySink ) + { + return ( (IEnergySink) part ).injectEnergy( directionFrom, amount, voltage ); + } + } + + return amount; + } +} diff --git a/src/main/java/appeng/parts/layers/LayerIEnergySource.java b/src/main/java/appeng/parts/layers/LayerIEnergySource.java index d81acd087..652492b7e 100644 --- a/src/main/java/appeng/parts/layers/LayerIEnergySource.java +++ b/src/main/java/appeng/parts/layers/LayerIEnergySource.java @@ -1,207 +1,207 @@ -///* -// * This file is part of Applied Energistics 2. -// * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. -// * -// * Applied Energistics 2 is free software: you can redistribute it and/or modify -// * it under the terms of the GNU Lesser General Public License as published by -// * the Free Software Foundation, either version 3 of the License, or -// * (at your option) any later version. -// * -// * Applied Energistics 2 is distributed in the hope that it will be useful, -// * but WITHOUT ANY WARRANTY; without even the implied warranty of -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// * GNU Lesser General Public License for more details. -// * -// * You should have received a copy of the GNU Lesser General Public License -// * along with Applied Energistics 2. If not, see . -// */ -// -//package appeng.parts.layers; -// -// -//import net.minecraft.tileentity.TileEntity; -//import net.minecraft.util.EnumFacing; -//import net.minecraft.world.World; -//import net.minecraftforge.common.MinecraftForge; -// -//import ic2.api.energy.tile.IEnergyAcceptor; -//import ic2.api.energy.tile.IEnergyEmitter; -//import ic2.api.energy.tile.IEnergySource; -//import ic2.api.energy.tile.IEnergyTile; -// -//import appeng.api.parts.IPart; -//import appeng.api.parts.IPartHost; -//import appeng.api.parts.LayerBase; -//import appeng.api.parts.LayerFlags; -//import appeng.util.Platform; -// -// -//public class LayerIEnergySource extends LayerBase implements IEnergySource -//{ -// -// private TileEntity getEnergySourceTile() -// { -// IPartHost host = (IPartHost) this; -// return host.getTile(); -// } -// -// private World getEnergySourceWorld() -// { -// if( this.getEnergySourceTile() == null ) -// { -// return null; -// } -// return this.getEnergySourceTile().getWorld(); -// } -// -// private boolean isTileValid() -// { -// TileEntity te = this.getEnergySourceTile(); -// return te != null && !te.isInvalid(); -// } -// -// private void addToENet() -// { -// if( this.getEnergySourceWorld() == null ) -// { -// return; -// } -// -// // re-add -// this.removeFromENet(); -// -// if( !this.isInIC2() && Platform.isServer() && this.isTileValid() ) -// { -// this.getLayerFlags().add( LayerFlags.IC2_ENET ); -// MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergyTile) this.getEnergySourceTile() ) ); -// } -// } -// -// private void removeFromENet() -// { -// if( this.getEnergySourceWorld() == null ) -// { -// return; -// } -// -// if( this.isInIC2() && Platform.isServer() ) -// { -// this.getLayerFlags().remove( LayerFlags.IC2_ENET ); -// MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergyTile) this.getEnergySourceTile() ) ); -// } -// } -// -// private boolean interestedInIC2() -// { -// if( !( (IPartHost) this ).isInWorld() ) -// { -// return false; -// } -// -// int interested = 0; -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergyTile ) -// { -// interested++; -// } -// } -// return interested == 1;// if more then one tile is interested we need to abandon... -// } -// -// @Override -// public void partChanged() -// { -// super.partChanged(); -// -// if( this.interestedInIC2() ) -// { -// this.addToENet(); -// } -// else -// { -// this.removeFromENet(); -// } -// } -// -// @Override -// public boolean emitsEnergyTo( IEnergyAcceptor receiver, EnumFacing direction ) -// { -// if( !this.isInIC2() ) -// { -// return false; -// } -// -// IPart part = this.getPart( direction ); -// if( part instanceof IEnergyEmitter ) -// { -// return ( (IEnergyEmitter) part ).emitsEnergyTo( receiver, direction ); -// } -// return false; -// } -// -// private boolean isInIC2() -// { -// return this.getLayerFlags().contains( LayerFlags.IC2_ENET ); -// } -// -// @Override -// public double getOfferedEnergy() -// { -// if( !this.isInIC2() ) -// { -// return 0; -// } -// -// // this is a flawed implementation, that requires a change to the IC2 API. -// -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergySource ) -// { -// // use lower number cause ic2 deletes power it sends that isn't received. -// return ( (IEnergySource) part ).getOfferedEnergy(); -// } -// } -// -// return 0; -// } -// -// @Override -// public void drawEnergy( double amount ) -// { -// // this is a flawed implementation, that requires a change to the IC2 API. -// -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergySource ) -// { -// ( (IEnergySource) part ).drawEnergy( amount ); -// return; -// } -// } -// } -// -// @Override -// public int getSourceTier() -// { -// // this is a flawed implementation, that requires a change to the IC2 API. -// -// for( EnumFacing dir : EnumFacing.values() ) -// { -// IPart part = this.getPart( dir ); -// if( part instanceof IEnergySource ) -// { -// return ( (IEnergySource) part ).getSourceTier(); -// } -// } -// -// return 0; -// } -// -// -// -//} +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2014, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.parts.layers; + + +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumFacing; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; + +import ic2.api.energy.tile.IEnergyAcceptor; +import ic2.api.energy.tile.IEnergyEmitter; +import ic2.api.energy.tile.IEnergySource; +import ic2.api.energy.tile.IEnergyTile; + +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.api.parts.LayerBase; +import appeng.api.parts.LayerFlags; +import appeng.util.Platform; + + +public class LayerIEnergySource extends LayerBase implements IEnergySource +{ + + private TileEntity getEnergySourceTile() + { + IPartHost host = (IPartHost) this; + return host.getTile(); + } + + private World getEnergySourceWorld() + { + if( this.getEnergySourceTile() == null ) + { + return null; + } + return this.getEnergySourceTile().getWorld(); + } + + private boolean isTileValid() + { + TileEntity te = this.getEnergySourceTile(); + return te != null && !te.isInvalid(); + } + + private void addToENet() + { + if( this.getEnergySourceWorld() == null ) + { + return; + } + + // re-add + this.removeFromENet(); + + if( !this.isInIC2() && Platform.isServer() && this.isTileValid() ) + { + this.getLayerFlags().add( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergyTile) this.getEnergySourceTile() ) ); + } + } + + private void removeFromENet() + { + if( this.getEnergySourceWorld() == null ) + { + return; + } + + if( this.isInIC2() && Platform.isServer() ) + { + this.getLayerFlags().remove( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergyTile) this.getEnergySourceTile() ) ); + } + } + + private boolean interestedInIC2() + { + if( !( (IPartHost) this ).isInWorld() ) + { + return false; + } + + int interested = 0; + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergyTile ) + { + interested++; + } + } + return interested == 1;// if more then one tile is interested we need to abandon... + } + + @Override + public void partChanged() + { + super.partChanged(); + + if( this.interestedInIC2() ) + { + this.addToENet(); + } + else + { + this.removeFromENet(); + } + } + + @Override + public boolean emitsEnergyTo( IEnergyAcceptor receiver, EnumFacing direction ) + { + if( !this.isInIC2() ) + { + return false; + } + + IPart part = this.getPart( direction ); + if( part instanceof IEnergyEmitter ) + { + return ( (IEnergyEmitter) part ).emitsEnergyTo( receiver, direction ); + } + return false; + } + + private boolean isInIC2() + { + return this.getLayerFlags().contains( LayerFlags.IC2_ENET ); + } + + @Override + public double getOfferedEnergy() + { + if( !this.isInIC2() ) + { + return 0; + } + + // this is a flawed implementation, that requires a change to the IC2 API. + + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergySource ) + { + // use lower number cause ic2 deletes power it sends that isn't received. + return ( (IEnergySource) part ).getOfferedEnergy(); + } + } + + return 0; + } + + @Override + public void drawEnergy( double amount ) + { + // this is a flawed implementation, that requires a change to the IC2 API. + + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergySource ) + { + ( (IEnergySource) part ).drawEnergy( amount ); + return; + } + } + } + + @Override + public int getSourceTier() + { + // this is a flawed implementation, that requires a change to the IC2 API. + + for( EnumFacing dir : EnumFacing.values() ) + { + IPart part = this.getPart( dir ); + if( part instanceof IEnergySource ) + { + return ( (IEnergySource) part ).getSourceTier(); + } + } + + return 0; + } + + + +} diff --git a/src/main/java/appeng/parts/p2p/PartP2PFEPower.java b/src/main/java/appeng/parts/p2p/PartP2PFEPower.java new file mode 100644 index 000000000..7f8019a02 --- /dev/null +++ b/src/main/java/appeng/parts/p2p/PartP2PFEPower.java @@ -0,0 +1,250 @@ +/* + * + * * This file is part of Applied Energistics 2. + * * Copyright (c) 2013 - 2017, AlgorithmX2, All rights reserved. + * * + * * Applied Energistics 2 is free software: you can redistribute it and/or modify + * * it under the terms of the GNU Lesser General Public License as published by + * * the Free Software Foundation, either version 3 of the License, or + * * (at your option) any later version. + * * + * * Applied Energistics 2 is distributed in the hope that it will be useful, + * * but WITHOUT ANY WARRANTY; without even the implied warranty of + * * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * * GNU Lesser General Public License for more details. + * * + * * You should have received a copy of the GNU Lesser General Public License + * * along with Applied Energistics 2. If not, see . + * + */ + +package appeng.parts.p2p; + +import appeng.api.config.PowerUnits; +import appeng.api.parts.IPartModel; +import appeng.items.parts.PartModels; +import appeng.me.GridAccessException; +import appeng.util.Platform; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.energy.CapabilityEnergy; +import net.minecraftforge.energy.IEnergyStorage; + +import javax.annotation.Nonnull; +import javax.annotation.Nullable; +import java.util.List; + +/** + * @author GuntherDW + */ +public class PartP2PFEPower extends PartP2PTunnel implements IEnergyStorage +{ + private static final P2PModels MODELS = new P2PModels( "part/p2p/p2p_tunnel_fe" ); + + private boolean cachedTarget = false; + + private IEnergyStorage outputTarget; + + @PartModels + public static List getModels() + { + return MODELS.getModels(); + } + + @Override + public IPartModel getStaticModels() + { + return MODELS.getModel( isPowered(), isActive() ); + } + + public PartP2PFEPower( ItemStack is ) + { + super( is ); + } + + @Override + public void onTunnelNetworkChange() + { + this.getHost().notifyNeighbors(); + } + + @Override + public void onNeighborChanged() + { + super.onNeighborChanged(); + + this.cachedTarget = false; + } + + @Override + public int receiveEnergy( int maxReceive, boolean simulate ) + { + if( this.isOutput() ) + { + return 0; + } + + if( this.isActive() ) + { + int total = 0; + + try + { + for( PartP2PFEPower t : this.getOutputs() ) + { + if( Platform.getRandomInt() % 2 > 0 ) + { + int receiver = t.getOutput().receiveEnergy( maxReceive, simulate ); + maxReceive -= receiver; + total += receiver; + + if( maxReceive <= 0 ) + { + break; + } + } + } + + if( maxReceive > 0 ) + { + for( PartP2PFEPower t : this.getOutputs() ) + { + int receiver = t.getOutput().receiveEnergy( maxReceive, simulate ); + maxReceive -= receiver; + total += receiver; + + if( maxReceive <= 0 ) + { + break; + } + } + } + + this.queueTunnelDrain( PowerUnits.RF, total ); + } + catch( GridAccessException ignored ) + { + } + + return total; + } + + return 0; + } + + @Override + public int extractEnergy( int maxExtract, boolean simulate ) + { + return 0; + } + + private IEnergyStorage getOutput() + { + if( this.isOutput() ) + { + if( !this.cachedTarget ) + { + TileEntity self = this.getTile(); + TileEntity te = self.getWorld().getTileEntity( new BlockPos( self.getPos().getX() + this.getSide().xOffset, self.getPos().getY() + this.getSide().yOffset, self.getPos().getZ() + this.getSide().zOffset ) ); + this.outputTarget = te.hasCapability( CapabilityEnergy.ENERGY, this.getSide().getOpposite().getFacing() ) ? te.getCapability( CapabilityEnergy.ENERGY, this.getSide().getOpposite().getFacing() ) : null; + this.cachedTarget = true; + } + + if( this.outputTarget == null || !this.outputTarget.canReceive() ) + { + return null; + } + + return this.outputTarget; + } + return null; + } + + @Override + public int getEnergyStored() + { + if( this.isOutput() || !this.isActive() ) + { + return 0; + } + + int total = 0; + + try + { + for( PartP2PFEPower t : this.getOutputs() ) + { + total += t.getOutput().getEnergyStored(); + } + } + catch( GridAccessException e ) + { + return 0; + } + + + return total; + } + + @Override + public int getMaxEnergyStored() + { + if( this.isOutput() || !this.isActive() ) + { + return 0; + } + + int total = 0; + + try + { + for( PartP2PFEPower t : this.getOutputs() ) + { + total += t.getOutput().getMaxEnergyStored(); + } + } + catch( GridAccessException e ) + { + return 0; + } + + return total; + } + + @Override + public boolean canExtract() + { + return false; + } + + @Override + public boolean canReceive() + { + return true; + } + + @Override + public boolean hasCapability( @Nonnull Capability capability ) + { + if( capability == CapabilityEnergy.ENERGY ) + { + return true; + } + + return super.hasCapability( capability ); + } + + @Nullable + @Override + public T getCapability( @Nonnull Capability capability ) + { + if( capability == CapabilityEnergy.ENERGY ) + { + return (T) this; + } + + return super.getCapability( capability ); + } +} diff --git a/src/main/java/appeng/parts/p2p/PartP2PIC2Power.java b/src/main/java/appeng/parts/p2p/PartP2PIC2Power.java index 7b102c83d..3a9d480e6 100644 --- a/src/main/java/appeng/parts/p2p/PartP2PIC2Power.java +++ b/src/main/java/appeng/parts/p2p/PartP2PIC2Power.java @@ -1,263 +1,263 @@ -///* -// * This file is part of Applied Energistics 2. -// * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved. -// * -// * Applied Energistics 2 is free software: you can redistribute it and/or modify -// * it under the terms of the GNU Lesser General Public License as published by -// * the Free Software Foundation, either version 3 of the License, or -// * (at your option) any later version. -// * -// * Applied Energistics 2 is distributed in the hope that it will be useful, -// * but WITHOUT ANY WARRANTY; without even the implied warranty of -// * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -// * GNU Lesser General Public License for more details. -// * -// * You should have received a copy of the GNU Lesser General Public License -// * along with Applied Energistics 2. If not, see . -// */ -// -//package appeng.parts.p2p; -// -// -//import java.util.LinkedList; -//import java.util.List; -// -//import net.minecraft.item.ItemStack; -//import net.minecraft.nbt.NBTTagCompound; -//import net.minecraft.util.EnumFacing; -// -//import ic2.api.energy.tile.IEnergyAcceptor; -//import ic2.api.energy.tile.IEnergyEmitter; -//import ic2.api.energy.tile.IEnergySink; -// -//import appeng.api.config.PowerUnits; -//import appeng.api.networking.energy.IEnergySource; -//import appeng.api.parts.IPartModel; -//import appeng.coremod.annotations.Integration.Interface; -//import appeng.coremod.annotations.Integration.InterfaceList; -//import appeng.integration.IntegrationType; -//import appeng.items.parts.PartModels; -//import appeng.me.GridAccessException; -//import appeng.me.cache.helpers.TunnelCollection; -//import appeng.util.Platform; -// -// -//@InterfaceList( value = { -// @Interface( iface = "ic2.api.energy.tile.IEnergySink", iname = IntegrationType.IC2 ), -// @Interface( iface = "ic2.api.energy.tile.IEnergySource", iname = IntegrationType.IC2 ) -//} ) -//public class PartP2PIC2Power extends PartP2PTunnel implements IEnergySink, IEnergySource -//{ -// -// private static final String TAG_BUFFERED_ENERGY_1 = "bufferedEnergy1"; -// private static final String TAG_BUFFERED_ENERGY_2 = "bufferedEnergy2"; -// private static final String TAG_BUFFERED_VOLTAGE_1 = "outputPacket1"; -// private static final String TAG_BUFFERED_VOLTAGE_2 = "outputPacket2"; -// -// private static final P2PModels MODELS = new P2PModels( "part/p2p/p2p_tunnel_ic2" ); -// -// @PartModels -// public static List getModels() -// { -// return MODELS.getModels(); -// } -// -// // Buffer the energy + voltage for two IC2 ENET packets -// private double bufferedEnergy1; -// private double bufferedVoltage1; -// private double bufferedEnergy2; -// private double bufferedVoltage2; -// -// public PartP2PIC2Power( ItemStack is ) -// { -// super( is ); -// } -// -// @Override -// public void readFromNBT( NBTTagCompound tag ) -// { -// super.readFromNBT( tag ); -// this.bufferedEnergy1 = tag.getDouble( TAG_BUFFERED_ENERGY_1 ); -// this.bufferedEnergy2 = tag.getDouble( TAG_BUFFERED_ENERGY_2 ); -// this.bufferedVoltage1 = tag.getDouble( TAG_BUFFERED_VOLTAGE_1 ); -// this.bufferedVoltage2 = tag.getDouble( TAG_BUFFERED_VOLTAGE_2 ); -// } -// -// @Override -// public void writeToNBT( NBTTagCompound tag ) -// { -// super.writeToNBT( tag ); -// tag.setDouble( TAG_BUFFERED_ENERGY_1, this.bufferedEnergy1 ); -// tag.setDouble( TAG_BUFFERED_ENERGY_2, this.bufferedEnergy2 ); -// tag.setDouble( TAG_BUFFERED_VOLTAGE_1, this.bufferedVoltage1 ); -// tag.setDouble( TAG_BUFFERED_VOLTAGE_2, this.bufferedVoltage2 ); -// } -// -// @Override -// public void onTunnelConfigChange() -// { -// this.getHost().partChanged(); -// } -// -// @Override -// public void onTunnelNetworkChange() -// { -// this.getHost().notifyNeighbors(); -// } -// -// @Override -// public boolean acceptsEnergyFrom( IEnergyEmitter emitter, EnumFacing direction ) -// { -// return !this.isOutput() && direction == this.getSide().getFacing(); -// } -// -// @Override -// public boolean emitsEnergyTo( IEnergyAcceptor receiver, EnumFacing direction ) -// { -// return this.isOutput() && direction == this.getSide().getFacing(); -// } -// -// @Override -// public double getDemandedEnergy() -// { -// if( this.isOutput() ) -// { -// return 0; -// } -// -// try -// { -// for( PartP2PIC2Power t : this.getOutputs() ) -// { -// if( t.bufferedEnergy1 <= 0.0001 || t.bufferedEnergy2 <= 0.0001 ) -// { -// return 2048; -// } -// } -// } -// catch( GridAccessException e ) -// { -// return 0; -// } -// -// return 0; -// } -// -// @Override -// public int getSinkTier() -// { -// return 4; -// } -// -// @Override -// public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) -// { -// TunnelCollection outs; -// try -// { -// outs = this.getOutputs(); -// } -// catch( GridAccessException e ) -// { -// return amount; -// } -// -// if( outs.isEmpty() ) -// { -// return amount; -// } -// -// LinkedList options = new LinkedList<>(); -// for( PartP2PIC2Power o : outs ) -// { -// if( o.bufferedEnergy1 <= 0.01 ) -// { -// options.add( o ); -// } -// } -// -// if( options.isEmpty() ) -// { -// for( PartP2PIC2Power o : outs ) -// { -// if( o.bufferedEnergy2 <= 0.01 ) -// { -// options.add( o ); -// } -// } -// } -// -// if( options.isEmpty() ) -// { -// for( PartP2PIC2Power o : outs ) -// { -// options.add( o ); -// } -// } -// -// if( options.isEmpty() ) -// { -// return amount; -// } -// -// PartP2PIC2Power x = Platform.pickRandom( options ); -// -// if( x != null && x.bufferedEnergy1 <= 0.001 ) -// { -// this.queueTunnelDrain( PowerUnits.EU, amount ); -// x.bufferedEnergy1 = amount; -// x.bufferedVoltage1 = voltage; -// return 0; -// } -// -// if( x != null && x.bufferedEnergy2 <= 0.001 ) -// { -// this.queueTunnelDrain( PowerUnits.EU, amount ); -// x.bufferedEnergy2 = amount; -// x.bufferedVoltage2 = voltage; -// return 0; -// } -// -// return amount; -// } -// -// @Override -// public double getOfferedEnergy() -// { -// if( this.isOutput() ) -// { -// return this.bufferedEnergy1; -// } -// return 0; -// } -// -// @Override -// public void drawEnergy( double amount ) -// { -// this.bufferedEnergy1 -= amount; -// if( this.bufferedEnergy1 < 0.001 ) -// { -// this.bufferedEnergy1 = this.bufferedEnergy2; -// this.bufferedEnergy2 = 0; -// -// this.bufferedVoltage1 = this.bufferedVoltage2; -// this.bufferedVoltage2 = 0; -// } -// } -// -// @Override -// public int getSourceTier() -// { -// // Sadly IC2 doesn't support changing the tier once we're registered, so we -// // go with the highest here... At this point it's somewhat unclear as to what effect -// // this realistically has. -// return 4; -// } -// -// @Override -// public IPartModel getStaticModels() -// { -// return MODELS.getModel( isPowered(), isActive() ); -// } -// -//} \ No newline at end of file +/* + * This file is part of Applied Energistics 2. + * Copyright (c) 2013 - 2015, AlgorithmX2, All rights reserved. + * + * Applied Energistics 2 is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * Applied Energistics 2 is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public License + * along with Applied Energistics 2. If not, see . + */ + +package appeng.parts.p2p; + + +import java.util.LinkedList; +import java.util.List; + +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; + +import ic2.api.energy.tile.IEnergyAcceptor; +import ic2.api.energy.tile.IEnergyEmitter; +import ic2.api.energy.tile.IEnergySink; +import ic2.api.energy.tile.IEnergySource; + +import appeng.api.config.PowerUnits; +import appeng.api.parts.IPartModel; +import appeng.coremod.annotations.Integration.Interface; +import appeng.coremod.annotations.Integration.InterfaceList; +import appeng.integration.IntegrationType; +import appeng.items.parts.PartModels; +import appeng.me.GridAccessException; +import appeng.me.cache.helpers.TunnelCollection; +import appeng.util.Platform; + + +@InterfaceList( value = { + @Interface( iface = "ic2.api.energy.tile.IEnergySink", iname = IntegrationType.IC2 ), + @Interface( iface = "ic2.api.energy.tile.IEnergySource", iname = IntegrationType.IC2 ) +} ) +public class PartP2PIC2Power extends PartP2PTunnel implements IEnergySink, IEnergySource +{ + + private static final String TAG_BUFFERED_ENERGY_1 = "bufferedEnergy1"; + private static final String TAG_BUFFERED_ENERGY_2 = "bufferedEnergy2"; + private static final String TAG_BUFFERED_VOLTAGE_1 = "outputPacket1"; + private static final String TAG_BUFFERED_VOLTAGE_2 = "outputPacket2"; + + private static final P2PModels MODELS = new P2PModels( "part/p2p/p2p_tunnel_ic2" ); + + @PartModels + public static List getModels() + { + return MODELS.getModels(); + } + + // Buffer the energy + voltage for two IC2 ENET packets + private double bufferedEnergy1; + private double bufferedVoltage1; + private double bufferedEnergy2; + private double bufferedVoltage2; + + public PartP2PIC2Power( ItemStack is ) + { + super( is ); + } + + @Override + public void readFromNBT( NBTTagCompound tag ) + { + super.readFromNBT( tag ); + this.bufferedEnergy1 = tag.getDouble( TAG_BUFFERED_ENERGY_1 ); + this.bufferedEnergy2 = tag.getDouble( TAG_BUFFERED_ENERGY_2 ); + this.bufferedVoltage1 = tag.getDouble( TAG_BUFFERED_VOLTAGE_1 ); + this.bufferedVoltage2 = tag.getDouble( TAG_BUFFERED_VOLTAGE_2 ); + } + + @Override + public void writeToNBT( NBTTagCompound tag ) + { + super.writeToNBT( tag ); + tag.setDouble( TAG_BUFFERED_ENERGY_1, this.bufferedEnergy1 ); + tag.setDouble( TAG_BUFFERED_ENERGY_2, this.bufferedEnergy2 ); + tag.setDouble( TAG_BUFFERED_VOLTAGE_1, this.bufferedVoltage1 ); + tag.setDouble( TAG_BUFFERED_VOLTAGE_2, this.bufferedVoltage2 ); + } + + @Override + public void onTunnelConfigChange() + { + this.getHost().partChanged(); + } + + @Override + public void onTunnelNetworkChange() + { + this.getHost().notifyNeighbors(); + } + + @Override + public boolean acceptsEnergyFrom( IEnergyEmitter emitter, EnumFacing direction ) + { + return !this.isOutput() && direction == this.getSide().getFacing(); + } + + @Override + public boolean emitsEnergyTo( IEnergyAcceptor receiver, EnumFacing direction ) + { + return this.isOutput() && direction == this.getSide().getFacing(); + } + + @Override + public double getDemandedEnergy() + { + if( this.isOutput() ) + { + return 0; + } + + try + { + for( PartP2PIC2Power t : this.getOutputs() ) + { + if( t.bufferedEnergy1 <= 0.0001 || t.bufferedEnergy2 <= 0.0001 ) + { + return 2048; + } + } + } + catch( GridAccessException e ) + { + return 0; + } + + return 0; + } + + @Override + public int getSinkTier() + { + return 4; + } + + @Override + public double injectEnergy( EnumFacing directionFrom, double amount, double voltage ) + { + TunnelCollection outs; + try + { + outs = this.getOutputs(); + } + catch( GridAccessException e ) + { + return amount; + } + + if( outs.isEmpty() ) + { + return amount; + } + + LinkedList options = new LinkedList<>(); + for( PartP2PIC2Power o : outs ) + { + if( o.bufferedEnergy1 <= 0.01 ) + { + options.add( o ); + } + } + + if( options.isEmpty() ) + { + for( PartP2PIC2Power o : outs ) + { + if( o.bufferedEnergy2 <= 0.01 ) + { + options.add( o ); + } + } + } + + if( options.isEmpty() ) + { + for( PartP2PIC2Power o : outs ) + { + options.add( o ); + } + } + + if( options.isEmpty() ) + { + return amount; + } + + PartP2PIC2Power x = Platform.pickRandom( options ); + + if( x != null && x.bufferedEnergy1 <= 0.001 ) + { + this.queueTunnelDrain( PowerUnits.EU, amount ); + x.bufferedEnergy1 = amount; + x.bufferedVoltage1 = voltage; + return 0; + } + + if( x != null && x.bufferedEnergy2 <= 0.001 ) + { + this.queueTunnelDrain( PowerUnits.EU, amount ); + x.bufferedEnergy2 = amount; + x.bufferedVoltage2 = voltage; + return 0; + } + + return amount; + } + + @Override + public double getOfferedEnergy() + { + if( this.isOutput() ) + { + return this.bufferedEnergy1; + } + return 0; + } + + @Override + public void drawEnergy( double amount ) + { + this.bufferedEnergy1 -= amount; + if( this.bufferedEnergy1 < 0.001 ) + { + this.bufferedEnergy1 = this.bufferedEnergy2; + this.bufferedEnergy2 = 0; + + this.bufferedVoltage1 = this.bufferedVoltage2; + this.bufferedVoltage2 = 0; + } + } + + @Override + public int getSourceTier() + { + // Sadly IC2 doesn't support changing the tier once we're registered, so we + // go with the highest here... At this point it's somewhat unclear as to what effect + // this realistically has. + return 4; + } + + @Override + public IPartModel getStaticModels() + { + return MODELS.getModel( isPowered(), isActive() ); + } + +} \ No newline at end of file diff --git a/src/main/java/appeng/parts/p2p/PartP2PRFPower.java b/src/main/java/appeng/parts/p2p/PartP2PRFPower.java index 1fb3f6ef2..d0c4ec82e 100644 --- a/src/main/java/appeng/parts/p2p/PartP2PRFPower.java +++ b/src/main/java/appeng/parts/p2p/PartP2PRFPower.java @@ -18,260 +18,197 @@ package appeng.parts.p2p; +import java.util.List; +import java.util.Stack; -//import java.util.Stack; -// -//import net.minecraft.init.Blocks; -//import net.minecraft.item.ItemStack; -//import net.minecraft.tileentity.TileEntity; -//import net.minecraft.util.IIcon; -//import net.minecraftforge.common.util.ForgeDirection; -// -//import cpw.mods.fml.relauncher.Side; -//import cpw.mods.fml.relauncher.SideOnly; -// -//import cofh.api.energy.IEnergyReceiver; -// -//import appeng.api.config.PowerUnits; -//import appeng.integration.IntegrationType; -//import appeng.integration.modules.helpers.NullRFHandler; -//import appeng.me.GridAccessException; -//import appeng.coremod.annotations.Integration.Interface; -//import appeng.coremod.annotations.Integration.InterfaceList; -//import appeng.util.Platform; -// -// -//@InterfaceList( value = { @Interface( iface = "cofh.api.energy.IEnergyReceiver", iname = IntegrationType.RF ) } ) -//public final class PartP2PRFPower extends PartP2PTunnel implements IEnergyReceiver -//{ -// private static final ThreadLocal> THREAD_STACK = new ThreadLocal>(); -// /** -// * Default element based on the null element pattern -// */ -// private static final IEnergyReceiver NULL_HANDLER = new NullRFHandler(); -// private boolean cachedTarget = false; -// private IEnergyReceiver outputTarget; -// -// public PartP2PRFPower( ItemStack is ) -// { -// super( is ); -// } -// -// @Override -// @SideOnly( Side.CLIENT ) -// public IIcon getTypeTexture() -// { -// return Blocks.iron_block.getBlockTextureFromSide( 0 ); -// } -// -// @Override -// public void onTunnelNetworkChange() -// { -// this.getHost().notifyNeighbors(); -// } -// -// @Override -// public void onNeighborChanged() -// { -// super.onNeighborChanged(); -// -// this.cachedTarget = false; -// } -// -// @Override -// public int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate ) -// { -// if( this.output ) -// { -// return 0; -// } -// -// if( this.isActive() ) -// { -// Stack stack = this.getDepth(); -// -// for( PartP2PRFPower t : stack ) -// { -// if( t == this ) -// { -// return 0; -// } -// } -// -// stack.push( this ); -// -// int total = 0; -// -// try -// { -// for( PartP2PRFPower t : this.getOutputs() ) -// { -// if( Platform.getRandomInt() % 2 > 0 ) -// { -// int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate ); -// maxReceive -= receiver; -// total += receiver; -// -// if( maxReceive <= 0 ) -// { -// break; -// } -// } -// } -// -// if( maxReceive > 0 ) -// { -// for( PartP2PRFPower t : this.getOutputs() ) -// { -// int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate ); -// maxReceive -= receiver; -// total += receiver; -// -// if( maxReceive <= 0 ) -// { -// break; -// } -// } -// } -// -// this.queueTunnelDrain( PowerUnits.RF, total ); -// } -// catch( GridAccessException ignored ) -// { -// } -// -// if( stack.pop() != this ) -// { -// throw new IllegalStateException( "Invalid Recursion detected." ); -// } -// -// return total; -// } -// -// return 0; -// } -// -// private Stack getDepth() -// { -// Stack s = THREAD_STACK.get(); -// -// if( s == null ) -// { -// THREAD_STACK.set( s = new Stack() ); -// } -// -// return s; -// } -// -// private IEnergyReceiver getOutput() -// { -// if( this.output ) -// { -// if( !this.cachedTarget ) -// { -// TileEntity self = this.getTile(); -// TileEntity te = self.getworld().getTileEntity( self.x + this.side.offsetX, self.y + this.side.offsetY, self.z + this.side.offsetZ ); -// this.outputTarget = te instanceof IEnergyReceiver ? (IEnergyReceiver) te : null; -// this.cachedTarget = true; -// } -// -// if( this.outputTarget == null || !this.outputTarget.canConnectEnergy( this.side.getOpposite() ) ) -// { -// return NULL_HANDLER; -// } -// -// return this.outputTarget; -// } -// return NULL_HANDLER; -// } -// -// @Override -// public int getEnergyStored( ForgeDirection from ) -// { -// if( this.output || !this.isActive() ) -// { -// return 0; -// } -// -// int total = 0; -// -// Stack stack = this.getDepth(); -// -// for( PartP2PRFPower t : stack ) -// { -// if( t == this ) -// { -// return 0; -// } -// } -// -// stack.push( this ); -// -// try -// { -// for( PartP2PRFPower t : this.getOutputs() ) -// { -// total += t.getOutput().getEnergyStored( t.side.getOpposite() ); -// } -// } -// catch( GridAccessException e ) -// { -// return 0; -// } -// -// if( stack.pop() != this ) -// { -// throw new IllegalStateException( "Invalid Recursion detected." ); -// } -// -// return total; -// } -// -// @Override -// public int getMaxEnergyStored( ForgeDirection from ) -// { -// if( this.output || !this.isActive() ) -// { -// return 0; -// } -// -// int total = 0; -// -// Stack stack = this.getDepth(); -// -// for( PartP2PRFPower t : stack ) -// { -// if( t == this ) -// { -// return 0; -// } -// } -// -// stack.push( this ); -// -// try -// { -// for( PartP2PRFPower t : this.getOutputs() ) -// { -// total += t.getOutput().getMaxEnergyStored( t.side.getOpposite() ); -// } -// } -// catch( GridAccessException e ) -// { -// return 0; -// } -// -// if( stack.pop() != this ) -// { -// throw new IllegalStateException( "Invalid Recursion detected." ); -// } -// -// return total; -// } -// -// @Override -// public boolean canConnectEnergy( ForgeDirection from ) -// { -// return true; -// } -// } +import appeng.api.parts.IPartModel; +import appeng.items.parts.PartModels; +import cofh.redstoneflux.api.IEnergyReceiver; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; + + +import appeng.api.config.PowerUnits; +import appeng.integration.IntegrationType; +import appeng.me.GridAccessException; +import appeng.coremod.annotations.Integration.Interface; +import appeng.coremod.annotations.Integration.InterfaceList; +import appeng.util.Platform; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; + + +@InterfaceList( value = { @Interface( iface = "cofh.redstoneflux.api.IEnergyReceiver", iname = IntegrationType.RF ) } ) +public final class PartP2PRFPower extends PartP2PTunnel implements IEnergyReceiver +{ + private static final P2PModels MODELS = new P2PModels( "part/p2p/p2p_tunnel_rf" ); + + private boolean cachedTarget = false; + + private IEnergyReceiver outputTarget; + + public PartP2PRFPower( ItemStack is ) + { + super( is ); + } + + @PartModels + public static List getModels() + { + return MODELS.getModels(); + } + + @Override + public IPartModel getStaticModels() + { + return MODELS.getModel( isPowered(), isActive() ); + } + + @Override + public void onTunnelNetworkChange() + { + this.getHost().notifyNeighbors(); + } + + @Override + public void onNeighborChanged() + { + super.onNeighborChanged(); + + this.cachedTarget = false; + } + + @Override + public int receiveEnergy( EnumFacing from, int maxReceive, boolean simulate ) + { + if( this.isOutput() ) + { + return 0; + } + + if( this.isActive() ) + { + int total = 0; + + try + { + for( PartP2PRFPower t : this.getOutputs() ) + { + if( Platform.getRandomInt() % 2 > 0 ) + { + int receiver = t.getOutput().receiveEnergy( t.getSide().getFacing().getOpposite(), maxReceive, simulate ); + maxReceive -= receiver; + total += receiver; + + if( maxReceive <= 0 ) + { + break; + } + } + } + + if( maxReceive > 0 ) + { + for( PartP2PRFPower t : this.getOutputs() ) + { + int receiver = t.getOutput().receiveEnergy( t.getSide().getFacing().getOpposite(), maxReceive, simulate ); + maxReceive -= receiver; + total += receiver; + + if( maxReceive <= 0 ) + { + break; + } + } + } + + this.queueTunnelDrain( PowerUnits.RF, total ); + } + catch( GridAccessException ignored ) + { + } + + return total; + } + + return 0; + } + + private IEnergyReceiver getOutput() + { + if( this.isOutput() ) + { + if( !this.cachedTarget ) + { + TileEntity self = this.getTile(); + TileEntity te = self.getWorld().getTileEntity( new BlockPos( self.getPos().getX() + this.getSide().xOffset, self.getPos().getY() + this.getSide().yOffset, self.getPos().getZ() + this.getSide().zOffset ) ); + this.outputTarget = te instanceof IEnergyReceiver ? (IEnergyReceiver) te : null; + this.cachedTarget = true; + } + + if( this.outputTarget == null || !this.outputTarget.canConnectEnergy( this.getSide().getOpposite().getFacing() ) ) + { + return null; + } + + return this.outputTarget; + } + return null; + } + + @Override + public int getEnergyStored( EnumFacing from ) + { + if( this.isOutput() || !this.isActive() ) + { + return 0; + } + + int total = 0; + + try + { + for( PartP2PRFPower t : this.getOutputs() ) + { + total += t.getOutput().getEnergyStored( this.getSide().getOpposite().getFacing() ); + } + } + catch( GridAccessException e ) + { + return 0; + } + + return total; + } + + @Override + public int getMaxEnergyStored( EnumFacing from ) + { + if( this.isOutput() || !this.isActive() ) + { + return 0; + } + + int total = 0; + + try + { + for( PartP2PRFPower t : this.getOutputs() ) + { + total += t.getOutput().getMaxEnergyStored( this.getSide().getOpposite().getFacing() ); + } + } + catch( GridAccessException e ) + { + return 0; + } + + return total; + } + + @Override + public boolean canConnectEnergy( EnumFacing from ) + { + return true; + } + } diff --git a/src/main/java/appeng/parts/p2p/PartP2PTunnel.java b/src/main/java/appeng/parts/p2p/PartP2PTunnel.java index 4331c8254..72ada9cc9 100644 --- a/src/main/java/appeng/parts/p2p/PartP2PTunnel.java +++ b/src/main/java/appeng/parts/p2p/PartP2PTunnel.java @@ -222,22 +222,17 @@ public abstract class PartP2PTunnel extends PartBasicSt newType = parts.p2PTunnelLight().maybeStack( 1 ).orElse( ItemStack.EMPTY ); break; - /* - * case RF_POWER: - * for( ItemStack stack : parts.p2PTunnelRF().maybeStack( 1 ).asSet() ) - * { - * newType = stack; - * } - * break; - */ + case RF_POWER: + newType = parts.p2PTunnelRF().maybeStack( 1 ).orElse( ItemStack.EMPTY ); + break; case FLUID: newType = parts.p2PTunnelFluids().maybeStack( 1 ).orElse( ItemStack.EMPTY ); break; - //case IC2_POWER: - // newType = parts.p2PTunnelEU().maybeStack( 1 ).orElse( ItemStack.EMPTY ); - // break; + case IC2_POWER: + newType = parts.p2PTunnelEU().maybeStack( 1 ).orElse( ItemStack.EMPTY ); + break; case ITEM: newType = parts.p2PTunnelItems().maybeStack( 1 ).orElse( ItemStack.EMPTY ); diff --git a/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_fe.json b/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_fe.json new file mode 100644 index 000000000..c5991b254 --- /dev/null +++ b/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_fe.json @@ -0,0 +1,6 @@ +{ + "parent": "appliedenergistics2:item/part/p2p_tunnel", + "textures": { + "type": "minecraft:blocks/gold_block" + } +} diff --git a/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_rf.json b/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_rf.json new file mode 100644 index 000000000..4a01da8fd --- /dev/null +++ b/src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_rf.json @@ -0,0 +1,6 @@ +{ + "parent": "appliedenergistics2:item/part/p2p_tunnel", + "textures": { + "type": "minecraft:blocks/iron_block" + } +} diff --git a/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_fe.json b/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_fe.json new file mode 100644 index 000000000..a96b2b83c --- /dev/null +++ b/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_fe.json @@ -0,0 +1,6 @@ +{ + "parent": "appliedenergistics2:part/p2p/p2p_tunnel_base", + "textures": { + "type": "minecraft:blocks/gold_block" + } +} diff --git a/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_rf.json b/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_rf.json new file mode 100644 index 000000000..2cc350537 --- /dev/null +++ b/src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_rf.json @@ -0,0 +1,6 @@ +{ + "parent": "appliedenergistics2:part/p2p/p2p_tunnel_base", + "textures": { + "type": "minecraft:blocks/iron_block" + } +}