fujin/Applied-Energistics-2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Re-enabled the RF and IC2 handler, as well as their P2P tunnels. Added Forge Energy P2P tunnel.

Browse Source
This commit is contained in:
Gunther De Wachter
2017-07-14 21:52:04 +02:00
parent fdab91323c
commit 66c87a2fa2
26 changed files with 1776 additions and 1241 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/api/java/appeng/api/config/TunnelType.java
+1
View File
@@ -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
src/api/java/appeng/api/definitions/IParts.java
+2 -2
View File
@@ -78,9 +78,9 @@ public interface IParts
IItemDefinition p2PTunnelFluids();
//IItemDefinition p2PTunnelEU();
IItemDefinition p2PTunnelEU();
// IItemDefinition p2PTunnelRF();
IItemDefinition p2PTunnelRF();
IItemDefinition p2PTunnelLight();
src/main/java/appeng/core/Registration.java
+15 -8
View File
@@ -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();
src/main/java/appeng/core/api/definitions/ApiParts.java
+21 -15
View File
@@ -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()
src/main/java/appeng/core/features/AEFeature.java
+1
View File
@@ -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 ),
src/main/java/appeng/core/features/registries/P2PTunnelRegistry.java
+29 -2
View File
@@ -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() )
{
src/main/java/appeng/core/localization/GuiText.java
+1
View File
@@ -90,6 +90,7 @@ public enum GuiText
OCTunnel,
LightTunnel,
RFTunnel,
FETunnel,
PressureTunnel,
StoredSize,
src/main/java/appeng/integration/Integrations.java
+9 -5
View File
@@ -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;
}
}
src/main/java/appeng/integration/abstraction/IRF.java
+32
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
*/
package appeng.integration.abstraction;
import appeng.integration.IIntegrationModule;
/**
* @author GuntherDW
*/
public interface IRF
{
class Stub extends IIntegrationModule.Stub implements IRF
{
}
}
src/main/java/appeng/integration/modules/ic2/IC2Module.java
+81 -84
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
// */
//
//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 <http://www.gnu.org/licenses/lgpl>.
*/
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 );
}
}
src/main/java/appeng/integration/modules/ic2/IC2PowerSinkAdapter.java
+94 -94
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
// */
//
//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<EnumFacing> 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<EnumFacing> 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 <http://www.gnu.org/licenses/lgpl>.
*/
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<EnumFacing> 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<EnumFacing> faces )
{
this.validFaces.clear();
this.validFaces.addAll( faces );
}
}
src/main/java/appeng/integration/modules/ic2/IC2RecipeInput.java
+61
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
*/
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<ItemStack> getInputs()
{
return Collections.unmodifiableList( Collections.singletonList( itemstack ) );
}
}
src/main/java/appeng/integration/modules/rf/RFModule.java
+38
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
*/
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 );
}
}
src/main/java/appeng/items/parts/PartType.java
+31 -18
View File
@@ -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 ),
src/main/java/appeng/parts/layers/LayerForgeEnergy.java
+141
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
*
*/
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;
}
}
src/main/java/appeng/parts/layers/LayerIEnergyHandler.java
+72 -72
View File
@@ -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;
}
}
src/main/java/appeng/parts/layers/LayerIEnergySink.java
+204 -204
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
// */
//
//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 <http://www.gnu.org/licenses/lgpl>.
*/
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;
}
}
src/main/java/appeng/parts/layers/LayerIEnergySource.java
+207 -207
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
// */
//
//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 <http://www.gnu.org/licenses/lgpl>.
*/
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;
}
}
src/main/java/appeng/parts/p2p/PartP2PFEPower.java
+250
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
*
*/
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<PartP2PFEPower> 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<IPartModel> 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> T getCapability( @Nonnull Capability<T> capability )
{
if( capability == CapabilityEnergy.ENERGY )
{
return (T) this;
}
return super.getCapability( capability );
}
}
src/main/java/appeng/parts/p2p/PartP2PIC2Power.java
+263 -263
View File
@@ -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 <http://www.gnu.org/licenses/lgpl>.
// */
//
//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<PartP2PIC2Power> 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<IPartModel> 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<PartP2PIC2Power> outs;
// try
// {
// outs = this.getOutputs();
// }
// catch( GridAccessException e )
// {
// return amount;
// }
//
// if( outs.isEmpty() )
// {
// return amount;
// }
//
// LinkedList<PartP2PIC2Power> 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() );
// }
//
//}
/*
* 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 <http://www.gnu.org/licenses/lgpl>.
*/
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<PartP2PIC2Power> 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<IPartModel> 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<PartP2PIC2Power> outs;
try
{
outs = this.getOutputs();
}
catch( GridAccessException e )
{
return amount;
}
if( outs.isEmpty() )
{
return amount;
}
LinkedList<PartP2PIC2Power> 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() );
}
}
src/main/java/appeng/parts/p2p/PartP2PRFPower.java
+193 -256
View File
@@ -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<PartP2PRFPower> implements IEnergyReceiver
//{
// private static final ThreadLocal<Stack<PartP2PRFPower>> THREAD_STACK = new ThreadLocal<Stack<PartP2PRFPower>>();
// /**
// * 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<PartP2PRFPower> 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<PartP2PRFPower> getDepth()
// {
// Stack<PartP2PRFPower> s = THREAD_STACK.get();
//
// if( s == null )
// {
// THREAD_STACK.set( s = new Stack<PartP2PRFPower>() );
// }
//
// 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<PartP2PRFPower> 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<PartP2PRFPower> 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<PartP2PRFPower> 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<IPartModel> 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;
}
}
src/main/java/appeng/parts/p2p/PartP2PTunnel.java
+6 -11
View File
@@ -222,22 +222,17 @@ public abstract class PartP2PTunnel<T extends 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 );
src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_fe.json
+6
View File
@@ -0,0 +1,6 @@
{
"parent": "appliedenergistics2:item/part/p2p_tunnel",
"textures": {
"type": "minecraft:blocks/gold_block"
}
}
src/main/resources/assets/appliedenergistics2/models/item/part/p2p_tunnel_rf.json
+6
View File
@@ -0,0 +1,6 @@
{
"parent": "appliedenergistics2:item/part/p2p_tunnel",
"textures": {
"type": "minecraft:blocks/iron_block"
}
}
src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_fe.json
+6
View File
@@ -0,0 +1,6 @@
{
"parent": "appliedenergistics2:part/p2p/p2p_tunnel_base",
"textures": {
"type": "minecraft:blocks/gold_block"
}
}
src/main/resources/assets/appliedenergistics2/models/part/p2p/p2p_tunnel_rf.json
+6
View File
@@ -0,0 +1,6 @@
{
"parent": "appliedenergistics2:part/p2p/p2p_tunnel_base",
"textures": {
"type": "minecraft:blocks/iron_block"
}
}