tilera/Applied-Energistics-2-tilera-Edition
1
1
Fork 0
Code Issues 7 Pull requests Releases 1 Wiki Activity

make it runnable

Browse source
This commit is contained in:
thatsIch 2015-06-17 19:39:18 +02:00
parent 38afde724b
commit a95b9962b9
17 changed files with 1422 additions and 1583 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

12
build.gradle
View file

@ -45,11 +45,7 @@ buildscript {
} }
} }
configurations.all { sourceCompatibility = JavaVersion.VERSION_1_8
resolutionStrategy.cacheDynamicVersionsFor 7200, 'hours'
}
sourceCompatibility = JavaVersion.VERSION_1_6
targetCompatibility = JavaVersion.VERSION_1_6 targetCompatibility = JavaVersion.VERSION_1_6
version = aeversion + "-" + aechannel + "-" + aebuild version = aeversion + "-" + aechannel + "-" + aebuild
@ -87,6 +83,8 @@ minecraft {
// used when launching minecraft in dev env // used when launching minecraft in dev env
runDir = "run" runDir = "run"
mappings = "snapshot_20141130"
} }
sourceSets { sourceSets {
@ -94,6 +92,10 @@ sourceSets {
java { java {
srcDirs += 'src/api/java' srcDirs += 'src/api/java'
srcDirs += 'src/main/java/' srcDirs += 'src/main/java/'
// excludes integration due to not being available upon port
exclude 'appeng/integration/**'
exclude 'appeng/fmp/**'
} }
resources { resources {

8
gradle.properties
View file

@ -1,5 +1,5 @@
aeversion=rv2 aeversion=rv4
aechannel=stable aechannel=alpha
aebuild=0 aebuild=0
aegroup=appeng aegroup=appeng
aebasename=appliedenergistics2 aebasename=appliedenergistics2
@ -7,8 +7,8 @@ aebasename=appliedenergistics2
######################################################### #########################################################
# Versions # # Versions #
######################################################### #########################################################
minecraft_version=1.7.10 minecraft_version=1.8
forge_version=10.13.2.1291 forge_version=11.14.3.1450
######################################################### #########################################################
# Installable # # Installable #

54
gradle/scripts/dependencies.gradle
View file

@ -83,45 +83,45 @@ configurations {
dependencies { dependencies {
// installable // installable
mods "mcp.mobius.waila:Waila:${waila_version}_${minecraft_version}:dev" // mods "mcp.mobius.waila:Waila:${waila_version}_${minecraft_version}:dev"
mods "mcp.mobius.jabba:Jabba:${jabba_version}_${minecraft_version}:dev" // mods "mcp.mobius.jabba:Jabba:${jabba_version}_${minecraft_version}:dev"
mods "codechicken:EnderStorage:${minecraft_version}-${enderstorage_version}:dev" // mods "codechicken:EnderStorage:${minecraft_version}-${enderstorage_version}:dev"
mods "codechicken:Translocator:${minecraft_version}-${translocator_version}:dev" // mods "codechicken:Translocator:${minecraft_version}-${translocator_version}:dev"
mods "net.industrial-craft:industrialcraft-2:${ic2_version}-experimental:dev" // mods "net.industrial-craft:industrialcraft-2:${ic2_version}-experimental:dev"
mods "com.enderio:EnderIO:${minecraft_version}-${enderio_version}:dev" // mods "com.enderio:EnderIO:${minecraft_version}-${enderio_version}:dev"
mods "net.mcft.copy.betterstorage:BetterStorage:${minecraft_version}-${betterstorage_version}:deobf" // mods "net.mcft.copy.betterstorage:BetterStorage:${minecraft_version}-${betterstorage_version}:deobf"
mods "inventorytweaks:InventoryTweaks:${invtweaks_version}:deobf" // mods "inventorytweaks:InventoryTweaks:${invtweaks_version}:deobf"
mods "li.cil.oc:OpenComputers:MC${minecraft_version}-${opencomputers_version}:dev" // mods "li.cil.oc:OpenComputers:MC${minecraft_version}-${opencomputers_version}:dev"
// mods name: 'CoFHLib', version: "[${minecraft_version}]${cofhlib_version}-dev", ext: 'jar' // mods name: 'CoFHLib', version: "[${minecraft_version}]${cofhlib_version}-dev", ext: 'jar'
// mods name: 'CoFHCore', version: "[${minecraft_version}]${cofhcore_version}-dev", ext: 'jar' // mods name: 'CoFHCore', version: "[${minecraft_version}]${cofhcore_version}-dev", ext: 'jar'
// mods name: 'ThermalExpansion', version: "[${minecraft_version}]${texpansion_version}-dev", ext: 'jar' // mods name: 'ThermalExpansion', version: "[${minecraft_version}]${texpansion_version}-dev", ext: 'jar'
// mods name: 'ThermalFoundation', version: "[${minecraft_version}]${tfoundation_version}-dev", ext: 'jar' // mods name: 'ThermalFoundation', version: "[${minecraft_version}]${tfoundation_version}-dev", ext: 'jar'
compile "codechicken:ForgeMultipart:${minecraft_version}-${fmp_version}:dev" // compile "codechicken:ForgeMultipart:${minecraft_version}-${fmp_version}:dev"
compile "codechicken:CodeChickenLib:${minecraft_version}-${code_chicken_lib_version}:dev" // compile "codechicken:CodeChickenLib:${minecraft_version}-${code_chicken_lib_version}:dev"
compile "codechicken:CodeChickenCore:${minecraft_version}-${code_chicken_core_version}:dev" // compile "codechicken:CodeChickenCore:${minecraft_version}-${code_chicken_core_version}:dev"
compile "codechicken:NotEnoughItems:${minecraft_version}-${nei_version}:dev" // compile "codechicken:NotEnoughItems:${minecraft_version}-${nei_version}:dev"
compile "com.mod-buildcraft:buildcraft:${bc_version}:dev" // compile "com.mod-buildcraft:buildcraft:${bc_version}:dev"
// provided APIs // provided APIs
compile "li.cil.oc:OpenComputers:MC${minecraft_version}-${opencomputers_version}:api" // compile "li.cil.oc:OpenComputers:MC${minecraft_version}-${opencomputers_version}:api"
compile "net.industrial-craft:industrialcraft-2:${ic2_version}-experimental:api" // compile "net.industrial-craft:industrialcraft-2:${ic2_version}-experimental:api"
compile "net.mcft.copy.betterstorage:BetterStorage:${minecraft_version}-${betterstorage_version}:api" // compile "net.mcft.copy.betterstorage:BetterStorage:${minecraft_version}-${betterstorage_version}:api"
// self compiled APIs // self compiled APIs
compile "appeng:Waila:${waila_version}_${minecraft_version}:api" // compile "appeng:Waila:${waila_version}_${minecraft_version}:api"
compile "appeng:RotaryCraft:${rotarycraft_version}:api" // compile "appeng:RotaryCraft:${rotarycraft_version}:api"
compile "appeng:mekanism:${minecraft_version}-${mekansim_version}:api" // compile "appeng:mekanism:${minecraft_version}-${mekansim_version}:api"
compile "appeng:InventoryTweaks:${invtweaks_version}:api" // compile "appeng:InventoryTweaks:${invtweaks_version}:api"
// self compiled stubs // self compiled stubs
compile(group: 'api', name: 'coloredlightscore', version: "${api_coloredlightscore_version}") // compile(group: 'api', name: 'coloredlightscore', version: "${api_coloredlightscore_version}")
compile(group: 'api', name: 'craftguide', version: "${api_craftguide_version}") // compile(group: 'api', name: 'craftguide', version: "${api_craftguide_version}")
compile(group: 'api', name: 'immibis', version: "${api_immibis_version}") // compile(group: 'api', name: 'immibis', version: "${api_immibis_version}")
compile(group: 'api', name: 'mfr', version: "${api_mfr_version}") // compile(group: 'api', name: 'mfr', version: "${api_mfr_version}")
compile(group: 'api', name: 'railcraft', version: "${api_railcraft_version}") // compile(group: 'api', name: 'railcraft', version: "${api_railcraft_version}")
compile(group: 'api', name: 'rf', version: "${api_rf_version}") // compile(group: 'api', name: 'rf', version: "${api_rf_version}")
testCompile "junit:junit:4.11" testCompile "junit:junit:4.11"
} }

4
gradle/wrapper/gradle-wrapper.properties vendored
View file

@ -1,6 +1,6 @@
#Sat May 16 13:19:14 CEST 2015 #Wed Jun 17 12:06:23 CEST 2015
distributionBase=GRADLE_USER_HOME distributionBase=GRADLE_USER_HOME
distributionPath=wrapper/dists distributionPath=wrapper/dists
zipStoreBase=GRADLE_USER_HOME zipStoreBase=GRADLE_USER_HOME
zipStorePath=wrapper/dists zipStorePath=wrapper/dists
distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-bin.zip distributionUrl=https\://services.gradle.org/distributions/gradle-2.4-all.zip

229
src/main/java/appeng/items/tools/powered/powersink/IC2.java
View file

@ -19,125 +19,110 @@
package appeng.items.tools.powered.powersink; package appeng.items.tools.powered.powersink;
import com.google.common.base.Optional; //@InterfaceList( value = { @Interface( iface = "ic2.api.item.ISpecialElectricItem", iname = "IC2" ), @Interface( iface = "ic2.api.item.IElectricItemManager", iname = "IC2" ) } )
//public abstract class IC2 extends AERootPoweredItem implements IElectricItemManager, ISpecialElectricItem
import net.minecraft.entity.EntityLivingBase; //{
import net.minecraft.item.Item; // public IC2( double powerCapacity, Optional<String> subName )
import net.minecraft.item.ItemStack; // {
// super( powerCapacity, subName );
import ic2.api.item.IElectricItemManager; // }
import ic2.api.item.ISpecialElectricItem; //
// @Override
import appeng.api.config.PowerUnits; // public double charge( ItemStack is, double amount, int tier, boolean ignoreTransferLimit, boolean simulate )
import appeng.transformer.annotations.Integration.Interface; // {
import appeng.transformer.annotations.Integration.InterfaceList; // double addedAmt = amount;
import appeng.transformer.annotations.Integration.Method; // double limit = this.getTransferLimit( is );
//
// if( !ignoreTransferLimit && amount > limit )
@InterfaceList( value = { @Interface( iface = "ic2.api.item.ISpecialElectricItem", iname = "IC2" ), @Interface( iface = "ic2.api.item.IElectricItemManager", iname = "IC2" ) } ) // {
public abstract class IC2 extends AERootPoweredItem implements IElectricItemManager, ISpecialElectricItem // addedAmt = limit;
{ // }
public IC2( double powerCapacity, Optional<String> subName ) //
{ // return addedAmt - ( (int) this.injectExternalPower( PowerUnits.EU, is, addedAmt, simulate ) );
super( powerCapacity, subName ); // }
} //
// @Override
@Override // public double discharge( ItemStack itemStack, double amount, int tier, boolean ignoreTransferLimit, boolean externally, boolean simulate )
public double charge( ItemStack is, double amount, int tier, boolean ignoreTransferLimit, boolean simulate ) // {
{ // return 0;
double addedAmt = amount; // }
double limit = this.getTransferLimit( is ); //
// @Override
if( !ignoreTransferLimit && amount > limit ) // public double getCharge( ItemStack is )
{ // {
addedAmt = limit; // return (int) PowerUnits.AE.convertTo( PowerUnits.EU, this.getAECurrentPower( is ) );
} // }
//
return addedAmt - ( (int) this.injectExternalPower( PowerUnits.EU, is, addedAmt, simulate ) ); // @Override
} // public boolean canUse( ItemStack is, double amount )
// {
@Override // return this.getCharge( is ) > amount;
public double discharge( ItemStack itemStack, double amount, int tier, boolean ignoreTransferLimit, boolean externally, boolean simulate ) // }
{ //
return 0; // @Override
} // public boolean use( ItemStack is, double amount, EntityLivingBase entity )
// {
@Override // if( this.canUse( is, amount ) )
public double getCharge( ItemStack is ) // {
{ // // use the power..
return (int) PowerUnits.AE.convertTo( PowerUnits.EU, this.getAECurrentPower( is ) ); // this.extractAEPower( is, PowerUnits.EU.convertTo( PowerUnits.AE, amount ) );
} // return true;
// }
@Override // return false;
public boolean canUse( ItemStack is, double amount ) // }
{ //
return this.getCharge( is ) > amount; // @Override
} // public void chargeFromArmor( ItemStack itemStack, EntityLivingBase entity )
// {
@Override // // wtf?
public boolean use( ItemStack is, double amount, EntityLivingBase entity ) // }
{ //
if( this.canUse( is, amount ) ) // @Override
{ // public String getToolTip( ItemStack itemStack )
// use the power.. // {
this.extractAEPower( is, PowerUnits.EU.convertTo( PowerUnits.AE, amount ) ); // return null;
return true; // }
} //
return false; // @Override
} // public boolean canProvideEnergy( ItemStack itemStack )
// {
@Override // return false;
public void chargeFromArmor( ItemStack itemStack, EntityLivingBase entity ) // }
{ //
// wtf? // @Override
} // public Item getChargedItem( ItemStack itemStack )
// {
@Override // return itemStack.getItem();
public String getToolTip( ItemStack itemStack ) // }
{ //
return null; // @Override
} // public Item getEmptyItem( ItemStack itemStack )
// {
@Override // return itemStack.getItem();
public boolean canProvideEnergy( ItemStack itemStack ) // }
{ //
return false; // @Override
} // public double getMaxCharge( ItemStack itemStack )
// {
@Override // return PowerUnits.AE.convertTo( PowerUnits.EU, this.getAEMaxPower( itemStack ) );
public Item getChargedItem( ItemStack itemStack ) // }
{ //
return itemStack.getItem(); // @Override
} // public int getTier( ItemStack itemStack )
// {
@Override // return 1;
public Item getEmptyItem( ItemStack itemStack ) // }
{ //
return itemStack.getItem(); // @Override
} // public double getTransferLimit( ItemStack itemStack )
// {
@Override // return Math.max( 32, this.getMaxCharge( itemStack ) / 200 );
public double getMaxCharge( ItemStack itemStack ) // }
{ //
return PowerUnits.AE.convertTo( PowerUnits.EU, this.getAEMaxPower( itemStack ) ); // @Override
} // @Method( iname = "IC2" )
// public IElectricItemManager getManager( ItemStack itemStack )
@Override // {
public int getTier( ItemStack itemStack ) // return this;
{ // }
return 1; //}
}
@Override
public double getTransferLimit( ItemStack itemStack )
{
return Math.max( 32, this.getMaxCharge( itemStack ) / 200 );
}
@Override
@Method( iname = "IC2" )
public IElectricItemManager getManager( ItemStack itemStack )
{
return this;
}
}

74
src/main/java/appeng/items/tools/powered/powersink/RedstoneFlux.java
View file

@ -19,45 +19,35 @@
package appeng.items.tools.powered.powersink; package appeng.items.tools.powered.powersink;
import com.google.common.base.Optional; //@Interface( iface = "cofh.api.energy.IEnergyContainerItem", iname = "RFItem" )
//public abstract class RedstoneFlux extends IC2 implements IEnergyContainerItem
import net.minecraft.item.ItemStack; //{
// public RedstoneFlux( double powerCapacity, Optional<String> subName )
import cofh.api.energy.IEnergyContainerItem; // {
// super( powerCapacity, subName );
import appeng.api.config.PowerUnits; // }
import appeng.transformer.annotations.Integration.Interface; //
// @Override
// public int receiveEnergy( ItemStack is, int maxReceive, boolean simulate )
@Interface( iface = "cofh.api.energy.IEnergyContainerItem", iname = "RFItem" ) // {
public abstract class RedstoneFlux extends IC2 implements IEnergyContainerItem // return maxReceive - (int) this.injectExternalPower( PowerUnits.RF, is, maxReceive, simulate );
{ // }
public RedstoneFlux( double powerCapacity, Optional<String> subName ) //
{ // @Override
super( powerCapacity, subName ); // public int extractEnergy( ItemStack container, int maxExtract, boolean simulate )
} // {
// return 0;
@Override // }
public int receiveEnergy( ItemStack is, int maxReceive, boolean simulate ) //
{ // @Override
return maxReceive - (int) this.injectExternalPower( PowerUnits.RF, is, maxReceive, simulate ); // public int getEnergyStored( ItemStack is )
} // {
// return (int) PowerUnits.AE.convertTo( PowerUnits.RF, this.getAECurrentPower( is ) );
@Override // }
public int extractEnergy( ItemStack container, int maxExtract, boolean simulate ) //
{ // @Override
return 0; // public int getMaxEnergyStored( ItemStack is )
} // {
// return (int) PowerUnits.AE.convertTo( PowerUnits.RF, this.getAEMaxPower( is ) );
@Override // }
public int getEnergyStored( ItemStack is ) //}
{
return (int) PowerUnits.AE.convertTo( PowerUnits.RF, this.getAECurrentPower( is ) );
}
@Override
public int getMaxEnergyStored( ItemStack is )
{
return (int) PowerUnits.AE.convertTo( PowerUnits.RF, this.getAEMaxPower( is ) );
}
}

464
src/main/java/appeng/parts/p2p/PartP2PIC2Power.java
View file

@ -19,244 +19,226 @@
package appeng.parts.p2p; package appeng.parts.p2p;
import java.util.LinkedList; //@InterfaceList( value = { @Interface( iface = "ic2.api.energy.tile.IEnergySink", iname = "IC2" ), @Interface( iface = "ic2.api.energy.tile.IEnergySource", iname = "IC2" ) } )
//public class PartP2PIC2Power extends PartP2PTunnel<PartP2PIC2Power> implements ic2.api.energy.tile.IEnergySink, ic2.api.energy.tile.IEnergySource
import net.minecraft.client.renderer.texture.TextureAtlasSprite; //{
import net.minecraft.init.Blocks; //
import net.minecraft.item.ItemStack; // // two packet buffering...
import net.minecraft.nbt.NBTTagCompound; // double OutputEnergyA;
import net.minecraft.tileentity.TileEntity; // double OutputEnergyB;
import net.minecraftforge.fml.relauncher.Side; // // two packet buffering...
import net.minecraftforge.fml.relauncher.SideOnly; // double OutputVoltageA;
import appeng.api.config.PowerUnits; // double OutputVoltageB;
import appeng.api.util.ForgeDirection; //
import appeng.me.GridAccessException; // public PartP2PIC2Power( ItemStack is )
import appeng.me.cache.helpers.TunnelCollection; // {
import appeng.transformer.annotations.Integration.Interface; // super( is );
import appeng.transformer.annotations.Integration.InterfaceList; // }
import appeng.util.Platform; //
// @Override
// @SideOnly( Side.CLIENT )
@InterfaceList( value = { @Interface( iface = "ic2.api.energy.tile.IEnergySink", iname = "IC2" ), @Interface( iface = "ic2.api.energy.tile.IEnergySource", iname = "IC2" ) } ) // public TextureAtlasSprite getTypeTexture()
public class PartP2PIC2Power extends PartP2PTunnel<PartP2PIC2Power> implements ic2.api.energy.tile.IEnergySink, ic2.api.energy.tile.IEnergySource // {
{ // return Blocks.diamond_block.getBlockTextureFromSide( 0 );
// }
// two packet buffering... //
double OutputEnergyA; // @Override
double OutputEnergyB; // public void readFromNBT( NBTTagCompound tag )
// two packet buffering... // {
double OutputVoltageA; // super.readFromNBT( tag );
double OutputVoltageB; // this.OutputEnergyA = tag.getDouble( "OutputPacket" );
// this.OutputEnergyB = tag.getDouble( "OutputPacket2" );
public PartP2PIC2Power( ItemStack is ) // this.OutputVoltageA = tag.getDouble( "OutputVoltageA" );
{ // this.OutputVoltageB = tag.getDouble( "OutputVoltageB" );
super( is ); // }
} //
// @Override
@Override // public void writeToNBT( NBTTagCompound tag )
@SideOnly( Side.CLIENT ) // {
public TextureAtlasSprite getTypeTexture() // super.writeToNBT( tag );
{ // tag.setDouble( "OutputPacket", this.OutputEnergyA );
return Blocks.diamond_block.getBlockTextureFromSide( 0 ); // tag.setDouble( "OutputPacket2", this.OutputEnergyB );
} // tag.setDouble( "OutputVoltageA", this.OutputVoltageA );
// tag.setDouble( "OutputVoltageB", this.OutputVoltageB );
@Override // }
public void readFromNBT( NBTTagCompound tag ) //
{ // @Override
super.readFromNBT( tag ); // public void onTunnelConfigChange()
this.OutputEnergyA = tag.getDouble( "OutputPacket" ); // {
this.OutputEnergyB = tag.getDouble( "OutputPacket2" ); // this.getHost().partChanged();
this.OutputVoltageA = tag.getDouble( "OutputVoltageA" ); // }
this.OutputVoltageB = tag.getDouble( "OutputVoltageB" ); //
} // @Override
// public void onTunnelNetworkChange()
@Override // {
public void writeToNBT( NBTTagCompound tag ) // this.getHost().notifyNeighbors();
{ // }
super.writeToNBT( tag ); //
tag.setDouble( "OutputPacket", this.OutputEnergyA ); // @Override
tag.setDouble( "OutputPacket2", this.OutputEnergyB ); // public boolean acceptsEnergyFrom( TileEntity emitter, ForgeDirection direction )
tag.setDouble( "OutputVoltageA", this.OutputVoltageA ); // {
tag.setDouble( "OutputVoltageB", this.OutputVoltageB ); // if( !this.output )
} // {
// return direction == this.side;
@Override // }
public void onTunnelConfigChange() // return false;
{ // }
this.getHost().partChanged(); //
} // @Override
// public boolean emitsEnergyTo( TileEntity receiver, ForgeDirection direction )
@Override // {
public void onTunnelNetworkChange() // if( this.output )
{ // {
this.getHost().notifyNeighbors(); // return direction == this.side;
} // }
// return false;
@Override // }
public boolean acceptsEnergyFrom( TileEntity emitter, ForgeDirection direction ) //
{ // @Override
if( !this.output ) // public double getDemandedEnergy()
{ // {
return direction == this.side; // if( this.output )
} // {
return false; // return 0;
} // }
//
@Override // try
public boolean emitsEnergyTo( TileEntity receiver, ForgeDirection direction ) // {
{ // for( PartP2PIC2Power t : this.getOutputs() )
if( this.output ) // {
{ // if( t.OutputEnergyA <= 0.0001 || t.OutputEnergyB <= 0.0001 )
return direction == this.side; // {
} // return 2048;
return false; // }
} // }
// }
@Override // catch( GridAccessException e )
public double getDemandedEnergy() // {
{ // return 0;
if( this.output ) // }
{ //
return 0; // return 0;
} // }
//
try // @Override
{ // public int getSinkTier()
for( PartP2PIC2Power t : this.getOutputs() ) // {
{ // return 4;
if( t.OutputEnergyA <= 0.0001 || t.OutputEnergyB <= 0.0001 ) // }
{ //
return 2048; // @Override
} // public double injectEnergy( ForgeDirection directionFrom, double amount, double voltage )
} // {
} // TunnelCollection<PartP2PIC2Power> outs;
catch( GridAccessException e ) // try
{ // {
return 0; // outs = this.getOutputs();
} // }
// catch( GridAccessException e )
return 0; // {
} // return amount;
// }
@Override //
public int getSinkTier() // if( outs.isEmpty() )
{ // {
return 4; // return amount;
} // }
//
@Override // LinkedList<PartP2PIC2Power> options = new LinkedList<PartP2PIC2Power>();
public double injectEnergy( ForgeDirection directionFrom, double amount, double voltage ) // for( PartP2PIC2Power o : outs )
{ // {
TunnelCollection<PartP2PIC2Power> outs; // if( o.OutputEnergyA <= 0.01 )
try // {
{ // options.add( o );
outs = this.getOutputs(); // }
} // }
catch( GridAccessException e ) //
{ // if( options.isEmpty() )
return amount; // {
} // for( PartP2PIC2Power o : outs )
// {
if( outs.isEmpty() ) // if( o.OutputEnergyB <= 0.01 )
{ // {
return amount; // options.add( o );
} // }
// }
LinkedList<PartP2PIC2Power> options = new LinkedList<PartP2PIC2Power>(); // }
for( PartP2PIC2Power o : outs ) //
{ // if( options.isEmpty() )
if( o.OutputEnergyA <= 0.01 ) // {
{ // for( PartP2PIC2Power o : outs )
options.add( o ); // {
} // options.add( o );
} // }
// }
if( options.isEmpty() ) //
{ // if( options.isEmpty() )
for( PartP2PIC2Power o : outs ) // {
{ // return amount;
if( o.OutputEnergyB <= 0.01 ) // }
{ //
options.add( o ); // PartP2PIC2Power x = Platform.pickRandom( options );
} //
} // if( x != null && x.OutputEnergyA <= 0.001 )
} // {
// this.queueTunnelDrain( PowerUnits.EU, amount );
if( options.isEmpty() ) // x.OutputEnergyA = amount;
{ // x.OutputVoltageA = voltage;
for( PartP2PIC2Power o : outs ) // return 0;
{ // }
options.add( o ); //
} // if( x != null && x.OutputEnergyB <= 0.001 )
} // {
// this.queueTunnelDrain( PowerUnits.EU, amount );
if( options.isEmpty() ) // x.OutputEnergyB = amount;
{ // x.OutputVoltageB = voltage;
return amount; // return 0;
} // }
//
PartP2PIC2Power x = Platform.pickRandom( options ); // return amount;
// }
if( x != null && x.OutputEnergyA <= 0.001 ) //
{ // public float getPowerDrainPerTick()
this.queueTunnelDrain( PowerUnits.EU, amount ); // {
x.OutputEnergyA = amount; // return 0.5f;
x.OutputVoltageA = voltage; // }
return 0; //
} // @Override
// public double getOfferedEnergy()
if( x != null && x.OutputEnergyB <= 0.001 ) // {
{ // if( this.output )
this.queueTunnelDrain( PowerUnits.EU, amount ); // {
x.OutputEnergyB = amount; // return this.OutputEnergyA;
x.OutputVoltageB = voltage; // }
return 0; // return 0;
} // }
//
return amount; // @Override
} // public void drawEnergy( double amount )
// {
public float getPowerDrainPerTick() // this.OutputEnergyA -= amount;
{ // if( this.OutputEnergyA < 0.001 )
return 0.5f; // {
} // this.OutputEnergyA = this.OutputEnergyB;
// this.OutputEnergyB = 0;
@Override //
public double getOfferedEnergy() // this.OutputVoltageA = this.OutputVoltageB;
{ // this.OutputVoltageB = 0;
if( this.output ) // }
{ // }
return this.OutputEnergyA; //
} // @Override
return 0; // public int getSourceTier()
} // {
// if( this.output )
@Override // {
public void drawEnergy( double amount ) // return this.calculateTierFromVoltage( this.OutputVoltageA );
{ // }
this.OutputEnergyA -= amount; // return 4;
if( this.OutputEnergyA < 0.001 ) // }
{ //
this.OutputEnergyA = this.OutputEnergyB; // private int calculateTierFromVoltage( double voltage )
this.OutputEnergyB = 0; // {
// return ic2.api.energy.EnergyNet.instance.getTierFromPower( voltage );
this.OutputVoltageA = this.OutputVoltageB; // }
this.OutputVoltageB = 0; //}
}
}
@Override
public int getSourceTier()
{
if( this.output )
{
return this.calculateTierFromVoltage( this.OutputVoltageA );
}
return 4;
}
private int calculateTierFromVoltage( double voltage )
{
return ic2.api.energy.EnergyNet.instance.getTierFromPower( voltage );
}
}

420
src/main/java/appeng/parts/p2p/PartP2POpenComputers.java
View file

@ -19,229 +19,197 @@
package appeng.parts.p2p; package appeng.parts.p2p;
import java.util.concurrent.Callable; //@InterfaceList(value = { @Interface(iface = "li.cil.oc.api.network.Environment", iname = "OpenComputers"), @Interface(iface = "li.cil.oc.api.network.SidedEnvironment", iname = "OpenComputers") })
//public final class PartP2POpenComputers extends PartP2PTunnel<PartP2POpenComputers> implements IGridTickable, Environment, SidedEnvironment
import javax.annotation.Nullable; //{
// @Nullable
import net.minecraft.client.renderer.texture.TextureAtlasSprite; // private final Node node;
import net.minecraft.item.ItemStack; //
import net.minecraft.nbt.NBTTagCompound; // private final Callable<Void> updateCallback;
import net.minecraftforge.fml.relauncher.Side; //
import net.minecraftforge.fml.relauncher.SideOnly; // public PartP2POpenComputers(ItemStack is)
import li.cil.oc.api.API; // {
import li.cil.oc.api.Items; // super( is );
import li.cil.oc.api.Network; //
import li.cil.oc.api.network.Environment; // if ( !IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.OpenComputers ) )
import li.cil.oc.api.network.Message; // {
import li.cil.oc.api.network.Node; // throw new RuntimeException( "OpenComputers is not installed!" );
import li.cil.oc.api.network.SidedEnvironment; // }
import li.cil.oc.api.network.Visibility; //
import appeng.api.networking.IGridNode; // // Avoid NPE when called in pre-init phase (part population).
import appeng.api.networking.ticking.IGridTickable; // if ( API.network != null )
import appeng.api.networking.ticking.TickRateModulation; // {
import appeng.api.networking.ticking.TickingRequest; // this.node = Network.newNode( this, Visibility.None ).create();
import appeng.api.util.ForgeDirection; // }
import appeng.core.AELog; // else
import appeng.core.settings.TickRates; // {
import appeng.hooks.TickHandler; // this.node = null; // to satisfy final
import appeng.integration.IntegrationRegistry; // }
import appeng.integration.IntegrationType; //
import appeng.me.GridAccessException; // this.updateCallback = new UpdateCallback();
import appeng.transformer.annotations.Integration.Interface; // }
import appeng.transformer.annotations.Integration.InterfaceList; //
// @Override
// @SideOnly(Side.CLIENT)
@InterfaceList(value = { @Interface(iface = "li.cil.oc.api.network.Environment", iname = "OpenComputers"), @Interface(iface = "li.cil.oc.api.network.SidedEnvironment", iname = "OpenComputers") }) // public TextureAtlasSprite getTypeTexture()
public final class PartP2POpenComputers extends PartP2PTunnel<PartP2POpenComputers> implements IGridTickable, Environment, SidedEnvironment // {
{ // return Items.get( "adapter" ).block().getBlockTextureFromSide( 2 );
@Nullable // }
private final Node node; //
// @Override
private final Callable<Void> updateCallback; // public void removeFromWorld()
// {
public PartP2POpenComputers(ItemStack is) // super.removeFromWorld();
{ // if ( this.node != null)
super( is ); // {
// this.node.remove();
if ( !IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.OpenComputers ) ) // }
{ // }
throw new RuntimeException( "OpenComputers is not installed!" ); //
} // @Override
// public void onTunnelNetworkChange()
// Avoid NPE when called in pre-init phase (part population). // {
if ( API.network != null ) // super.onTunnelNetworkChange();
{ // try
this.node = Network.newNode( this, Visibility.None ).create(); // {
} // this.proxy.getTick().wakeDevice( this.proxy.getNode() );
else // }
{ // catch( GridAccessException e )
this.node = null; // to satisfy final // {
} // // ignore
// }
this.updateCallback = new UpdateCallback(); // }
} //
// @Override
@Override // public void readFromNBT(NBTTagCompound data)
@SideOnly(Side.CLIENT) // {
public TextureAtlasSprite getTypeTexture() // super.readFromNBT( data );
{ // if ( this.node != null)
return Items.get( "adapter" ).block().getBlockTextureFromSide( 2 ); // {
} // this.node.load( data );
// }
@Override // }
public void removeFromWorld() //
{ // @Override
super.removeFromWorld(); // public void writeToNBT(NBTTagCompound data)
if ( this.node != null) // {
{ // super.writeToNBT( data );
this.node.remove(); // if ( this.node != null)
} // {
} // this.node.save( data );
// }
@Override // }
public void onTunnelNetworkChange() //
{ // @Override
super.onTunnelNetworkChange(); // public TickingRequest getTickingRequest( IGridNode node )
try // {
{ // return new TickingRequest( TickRates.OpenComputersTunnel.min, TickRates.OpenComputersTunnel.max, true, false );
this.proxy.getTick().wakeDevice( this.proxy.getNode() ); // }
} //
catch( GridAccessException e ) // @Override
{ // public TickRateModulation tickingRequest( IGridNode node, int ticksSinceLastCall )
// ignore // {
} // try
} // {
// if( !this.proxy.getPath().isNetworkBooting() )
@Override // {
public void readFromNBT(NBTTagCompound data) // if ( this.node() != null ) // Client side doesn't have nodes.
{ // {
super.readFromNBT( data ); // TickHandler.INSTANCE.addCallable( this.tile.getWorld(), this.updateCallback );
if ( this.node != null) // }
{ //
this.node.load( data ); // return TickRateModulation.SLEEP;
} // }
} // }
// catch( GridAccessException e )
@Override // {
public void writeToNBT(NBTTagCompound data) // // ignore
{ // }
super.writeToNBT( data ); //
if ( this.node != null) // return TickRateModulation.IDLE;
{ // }
this.node.save( data ); //
} // private void updateConnections()
} // {
// if ( this.proxy.isPowered() && this.proxy.isActive() )
@Override // {
public TickingRequest getTickingRequest( IGridNode node ) // // Make sure we're connected to existing OC nodes in the world.
{ // Network.joinOrCreateNetwork( this.getTile() );
return new TickingRequest( TickRates.OpenComputersTunnel.min, TickRates.OpenComputersTunnel.max, true, false ); //
} // if ( this.output )
// {
@Override // if ( this.getInput() != null && this.node != null )
public TickRateModulation tickingRequest( IGridNode node, int ticksSinceLastCall ) // {
{ // Network.joinOrCreateNetwork( this.getInput().getTile() );
try // this.node.connect( this.getInput().node() );
{ // }
if( !this.proxy.getPath().isNetworkBooting() ) // }
{ // else
if ( this.node() != null ) // Client side doesn't have nodes. // {
{ // try
TickHandler.INSTANCE.addCallable( this.tile.getWorld(), this.updateCallback ); // {
} // for ( PartP2POpenComputers output : this.getOutputs() )
// {
return TickRateModulation.SLEEP; // if ( this.node != null )
} // {
} // Network.joinOrCreateNetwork( output.getTile() );
catch( GridAccessException e ) // this.node.connect( output.node() );
{ // }
// ignore // }
} // }
// catch ( GridAccessException e )
return TickRateModulation.IDLE; // {
} // AELog.error( e );
// }
private void updateConnections() // }
{ // }
if ( this.proxy.isPowered() && this.proxy.isActive() ) // else if ( this.node != null )
{ // {
// Make sure we're connected to existing OC nodes in the world. // this.node.remove();
Network.joinOrCreateNetwork( this.getTile() ); // }
// }
if ( this.output ) //
{ // @Nullable
if ( this.getInput() != null && this.node != null ) // @Override
{ // public Node node()
Network.joinOrCreateNetwork( this.getInput().getTile() ); // {
this.node.connect( this.getInput().node() ); // return this.node;
} // }
} //
else // @Override
{ // public void onConnect(Node node) {
try // }
{ //
for ( PartP2POpenComputers output : this.getOutputs() ) // @Override
{ // public void onDisconnect(Node node) {
if ( this.node != null ) // }
{ //
Network.joinOrCreateNetwork( output.getTile() ); // @Override
this.node.connect( output.node() ); // public void onMessage(Message message) {
} // }
} //
} // @Nullable
catch ( GridAccessException e ) // @Override
{ // public Node sidedNode(ForgeDirection side)
AELog.error( e ); // {
} // return side == this.side ? this.node : null;
} // }
} //
else if ( this.node != null ) // @Override
{ // public boolean canConnect(ForgeDirection side)
this.node.remove(); // {
} // return side == this.side;
} // }
//
@Nullable // private final class UpdateCallback implements Callable<Void>
@Override // {
public Node node() // @Nullable
{ // @Override
return this.node; // public Void call() throws Exception
} // {
// PartP2POpenComputers.this.updateConnections();
@Override //
public void onConnect(Node node) { // return null;
} // }
// }
@Override //}
public void onDisconnect(Node node) {
}
@Override
public void onMessage(Message message) {
}
@Nullable
@Override
public Node sidedNode(ForgeDirection side)
{
return side == this.side ? this.node : null;
}
@Override
public boolean canConnect(ForgeDirection side)
{
return side == this.side;
}
private final class UpdateCallback implements Callable<Void>
{
@Nullable
@Override
public Void call() throws Exception
{
PartP2POpenComputers.this.updateConnections();
return null;
}
}
}

486
src/main/java/appeng/parts/p2p/PartP2PRFPower.java
View file

@ -19,255 +19,237 @@
package appeng.parts.p2p; package appeng.parts.p2p;
import java.util.Stack; //@InterfaceList( value = { @Interface( iface = "cofh.api.energy.IEnergyReceiver", iname = "RF" ) } )
//public final class PartP2PRFPower extends PartP2PTunnel<PartP2PRFPower> implements IEnergyReceiver
import net.minecraft.client.renderer.texture.TextureAtlasSprite; //{
import net.minecraft.init.Blocks; // private static final ThreadLocal<Stack<PartP2PRFPower>> THREAD_STACK = new ThreadLocal<Stack<PartP2PRFPower>>();
import net.minecraft.item.ItemStack; // /**
import net.minecraft.tileentity.TileEntity; // * Default element based on the null element pattern
import net.minecraftforge.fml.relauncher.Side; // */
import net.minecraftforge.fml.relauncher.SideOnly; // private static final IEnergyReceiver NULL_HANDLER = new NullRFHandler();
import cofh.api.energy.IEnergyReceiver; // private boolean cachedTarget = false;
import appeng.api.config.PowerUnits; // private IEnergyReceiver outputTarget;
import appeng.api.util.ForgeDirection; //
import appeng.integration.modules.helpers.NullRFHandler; // public PartP2PRFPower( ItemStack is )
import appeng.me.GridAccessException; // {
import appeng.transformer.annotations.Integration.Interface; // super( is );
import appeng.transformer.annotations.Integration.InterfaceList; // }
import appeng.util.Platform; //
// @Override
// @SideOnly( Side.CLIENT )
@InterfaceList( value = { @Interface( iface = "cofh.api.energy.IEnergyReceiver", iname = "RF" ) } ) // public TextureAtlasSprite getTypeTexture()
public final class PartP2PRFPower extends PartP2PTunnel<PartP2PRFPower> implements IEnergyReceiver // {
{ // return Blocks.iron_block.getBlockTextureFromSide( 0 );
private static final ThreadLocal<Stack<PartP2PRFPower>> THREAD_STACK = new ThreadLocal<Stack<PartP2PRFPower>>(); // }
/** //
* Default element based on the null element pattern // @Override
*/ // public void onTunnelNetworkChange()
private static final IEnergyReceiver NULL_HANDLER = new NullRFHandler(); // {
private boolean cachedTarget = false; // this.getHost().notifyNeighbors();
private IEnergyReceiver outputTarget; // }
//
public PartP2PRFPower( ItemStack is ) // @Override
{ // public void onNeighborChanged()
super( is ); // {
} // super.onNeighborChanged();
//
@Override // this.cachedTarget = false;
@SideOnly( Side.CLIENT ) // }
public TextureAtlasSprite getTypeTexture() //
{ // @Override
return Blocks.iron_block.getBlockTextureFromSide( 0 ); // public int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate )
} // {
// if( this.output )
@Override // {
public void onTunnelNetworkChange() // return 0;
{ // }
this.getHost().notifyNeighbors(); //
} // if( this.isActive() )
// {
@Override // Stack<PartP2PRFPower> stack = this.getDepth();
public void onNeighborChanged() //
{ // for( PartP2PRFPower t : stack )
super.onNeighborChanged(); // {
// if( t == this )
this.cachedTarget = false; // {
} // return 0;
// }
@Override // }
public int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate ) //
{ // stack.push( this );
if( this.output ) //
{ // int total = 0;
return 0; //
} // try
// {
if( this.isActive() ) // for( PartP2PRFPower t : this.getOutputs() )
{ // {
Stack<PartP2PRFPower> stack = this.getDepth(); // if( Platform.getRandomInt() % 2 > 0 )
// {
for( PartP2PRFPower t : stack ) // int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate );
{ // maxReceive -= receiver;
if( t == this ) // total += receiver;
{ //
return 0; // if( maxReceive <= 0 )
} // {
} // break;
// }
stack.push( this ); // }
// }
int total = 0; //
// if( maxReceive > 0 )
try // {
{ // for( PartP2PRFPower t : this.getOutputs() )
for( PartP2PRFPower t : this.getOutputs() ) // {
{ // int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate );
if( Platform.getRandomInt() % 2 > 0 ) // maxReceive -= receiver;
{ // total += receiver;
int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate ); //
maxReceive -= receiver; // if( maxReceive <= 0 )
total += receiver; // {
// break;
if( maxReceive <= 0 ) // }
{ // }
break; // }
} //
} // this.queueTunnelDrain( PowerUnits.RF, total );
} // }
// catch( GridAccessException ignored )
if( maxReceive > 0 ) // {
{ // }
for( PartP2PRFPower t : this.getOutputs() ) //
{ // if( stack.pop() != this )
int receiver = t.getOutput().receiveEnergy( t.side.getOpposite(), maxReceive, simulate ); // {
maxReceive -= receiver; // throw new IllegalStateException( "Invalid Recursion detected." );
total += receiver; // }
//
if( maxReceive <= 0 ) // return total;
{ // }
break; //
} // return 0;
} // }
} //
// private Stack<PartP2PRFPower> getDepth()
this.queueTunnelDrain( PowerUnits.RF, total ); // {
} // Stack<PartP2PRFPower> s = THREAD_STACK.get();
catch( GridAccessException ignored ) //
{ // if( s == null )
} // {
// THREAD_STACK.set( s = new Stack<PartP2PRFPower>() );
if( stack.pop() != this ) // }
{ //
throw new IllegalStateException( "Invalid Recursion detected." ); // return s;
} // }
//
return total; // private IEnergyReceiver getOutput()
} // {
// if( this.output )
return 0; // {
} // if( !this.cachedTarget )
// {
private Stack<PartP2PRFPower> getDepth() // TileEntity self = this.getTile();
{ // TileEntity te = self.getWorld().getTileEntity( self.xCoord + this.side.offsetX, self.yCoord + this.side.offsetY, self.zCoord + this.side.offsetZ );
Stack<PartP2PRFPower> s = THREAD_STACK.get(); // this.outputTarget = te instanceof IEnergyReceiver ? (IEnergyReceiver) te : null;
// this.cachedTarget = true;
if( s == null ) // }
{ //
THREAD_STACK.set( s = new Stack<PartP2PRFPower>() ); // if( this.outputTarget == null || !this.outputTarget.canConnectEnergy( this.side.getOpposite() ) )
} // {
// return NULL_HANDLER;
return s; // }
} //
// return this.outputTarget;
private IEnergyReceiver getOutput() // }
{ // return NULL_HANDLER;
if( this.output ) // }
{ //
if( !this.cachedTarget ) // @Override
{ // public int getEnergyStored( ForgeDirection from )
TileEntity self = this.getTile(); // {
TileEntity te = self.getWorld().getTileEntity( self.xCoord + this.side.offsetX, self.yCoord + this.side.offsetY, self.zCoord + this.side.offsetZ ); // if( this.output || !this.isActive() )
this.outputTarget = te instanceof IEnergyReceiver ? (IEnergyReceiver) te : null; // {
this.cachedTarget = true; // return 0;
} // }
//
if( this.outputTarget == null || !this.outputTarget.canConnectEnergy( this.side.getOpposite() ) ) // int total = 0;
{ //
return NULL_HANDLER; // Stack<PartP2PRFPower> stack = this.getDepth();
} //
// for( PartP2PRFPower t : stack )
return this.outputTarget; // {
} // if( t == this )
return NULL_HANDLER; // {
} // return 0;
// }
@Override // }
public int getEnergyStored( ForgeDirection from ) //
{ // stack.push( this );
if( this.output || !this.isActive() ) //
{ // try
return 0; // {
} // for( PartP2PRFPower t : this.getOutputs() )
// {
int total = 0; // total += t.getOutput().getEnergyStored( t.side.getOpposite() );
// }
Stack<PartP2PRFPower> stack = this.getDepth(); // }
// catch( GridAccessException e )
for( PartP2PRFPower t : stack ) // {
{ // return 0;
if( t == this ) // }
{ //
return 0; // if( stack.pop() != this )
} // {
} // throw new IllegalStateException( "Invalid Recursion detected." );
// }
stack.push( this ); //
// return total;
try // }
{ //
for( PartP2PRFPower t : this.getOutputs() ) // @Override
{ // public int getMaxEnergyStored( ForgeDirection from )
total += t.getOutput().getEnergyStored( t.side.getOpposite() ); // {
} // if( this.output || !this.isActive() )
} // {
catch( GridAccessException e ) // return 0;
{ // }
return 0; //
} // int total = 0;
//
if( stack.pop() != this ) // Stack<PartP2PRFPower> stack = this.getDepth();
{ //
throw new IllegalStateException( "Invalid Recursion detected." ); // for( PartP2PRFPower t : stack )
} // {
// if( t == this )
return total; // {
} // return 0;
// }
@Override // }
public int getMaxEnergyStored( ForgeDirection from ) //
{ // stack.push( this );
if( this.output || !this.isActive() ) //
{ // try
return 0; // {
} // for( PartP2PRFPower t : this.getOutputs() )
// {
int total = 0; // total += t.getOutput().getMaxEnergyStored( t.side.getOpposite() );
// }
Stack<PartP2PRFPower> stack = this.getDepth(); // }
// catch( GridAccessException e )
for( PartP2PRFPower t : stack ) // {
{ // return 0;
if( t == this ) // }
{ //
return 0; // if( stack.pop() != this )
} // {
} // throw new IllegalStateException( "Invalid Recursion detected." );
// }
stack.push( this ); //
// return total;
try // }
{ //
for( PartP2PRFPower t : this.getOutputs() ) // @Override
{ // public boolean canConnectEnergy( ForgeDirection from )
total += t.getOutput().getMaxEnergyStored( t.side.getOpposite() ); // {
} // return true;
} // }
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;
}
}

191
src/main/java/appeng/tile/powersink/IC2.java
View file

@ -19,105 +19,92 @@
package appeng.tile.powersink; package appeng.tile.powersink;
import java.util.EnumSet; //@Interface( iname = "IC2", iface = "ic2.api.energy.tile.IEnergySink" )
//public abstract class IC2 extends AERootPoweredTile implements IEnergySink
import net.minecraft.tileentity.TileEntity; //{
import ic2.api.energy.tile.IEnergySink; //
import appeng.api.config.PowerUnits; // boolean isInIC2 = false;
import appeng.api.util.ForgeDirection; //
import appeng.integration.IntegrationRegistry; // @Override
import appeng.integration.IntegrationType; // public final boolean acceptsEnergyFrom( TileEntity emitter, ForgeDirection direction )
import appeng.integration.abstraction.IIC2; // {
import appeng.transformer.annotations.Integration.Interface; // return this.getPowerSides().contains( direction );
import appeng.util.Platform; // }
//
// @Override
@Interface( iname = "IC2", iface = "ic2.api.energy.tile.IEnergySink" ) // public final double getDemandedEnergy()
public abstract class IC2 extends AERootPoweredTile implements IEnergySink // {
{ // return this.getExternalPowerDemand( PowerUnits.EU, Double.MAX_VALUE );
// }
boolean isInIC2 = false; //
// @Override
@Override // public final int getSinkTier()
public final boolean acceptsEnergyFrom( TileEntity emitter, ForgeDirection direction ) // {
{ // return Integer.MAX_VALUE;
return this.getPowerSides().contains( direction ); // }
} //
// @Override
@Override // public final double injectEnergy( ForgeDirection directionFrom, double amount, double voltage )
public final double getDemandedEnergy() // {
{ // // just store the excess in the current block, if I return the waste,
return this.getExternalPowerDemand( PowerUnits.EU, Double.MAX_VALUE ); // // IC2 will just disintegrate it - Oct 20th 2013
} // double overflow = PowerUnits.EU.convertTo( PowerUnits.AE, this.injectExternalPower( PowerUnits.EU, amount ) );
// this.internalCurrentPower += overflow;
@Override // return 0; // see above comment.
public final int getSinkTier() // }
{ //
return Integer.MAX_VALUE; // @Override
} // public void invalidate()
// {
@Override // super.invalidate();
public final double injectEnergy( ForgeDirection directionFrom, double amount, double voltage ) // this.removeFromENet();
{ // }
// just store the excess in the current block, if I return the waste, //
// IC2 will just disintegrate it - Oct 20th 2013 // private void removeFromENet()
double overflow = PowerUnits.EU.convertTo( PowerUnits.AE, this.injectExternalPower( PowerUnits.EU, amount ) ); // {
this.internalCurrentPower += overflow; // if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.IC2 ) )
return 0; // see above comment. // {
} // IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.IC2 );
// if( this.isInIC2 && Platform.isServer() && ic2Integration != null )
@Override // {
public void invalidate() // ic2Integration.removeFromEnergyNet( this );
{ // this.isInIC2 = false;
super.invalidate(); // }
this.removeFromENet(); // }
} // }
//
private void removeFromENet() // @Override
{ // public void onChunkUnload()
if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.IC2 ) ) // {
{ // super.onChunkUnload();
IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.IC2 ); // this.removeFromENet();
if( this.isInIC2 && Platform.isServer() && ic2Integration != null ) // }
{ //
ic2Integration.removeFromEnergyNet( this ); // @Override
this.isInIC2 = false; // public void onReady()
} // {
} // super.onReady();
} // this.addToENet();
// }
@Override //
public void onChunkUnload() // private void addToENet()
{ // {
super.onChunkUnload(); // if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.IC2 ) )
this.removeFromENet(); // {
} // IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.IC2 );
// if( !this.isInIC2 && Platform.isServer() && ic2Integration != null )
@Override // {
public void onReady() // ic2Integration.addToEnergyNet( this );
{ // this.isInIC2 = true;
super.onReady(); // }
this.addToENet(); // }
} // }
//
private void addToENet() // @Override
{ // protected void setPowerSides( EnumSet<ForgeDirection> sides )
if( IntegrationRegistry.INSTANCE.isEnabled( IntegrationType.IC2 ) ) // {
{ // super.setPowerSides( sides );
IIC2 ic2Integration = (IIC2) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.IC2 ); // this.removeFromENet();
if( !this.isInIC2 && Platform.isServer() && ic2Integration != null ) // this.addToENet();
{ // }
ic2Integration.addToEnergyNet( this ); //}
this.isInIC2 = true;
}
}
}
@Override
protected void setPowerSides( EnumSet<ForgeDirection> sides )
{
super.setPowerSides( sides );
this.removeFromENet();
this.addToENet();
}
}

90
src/main/java/appeng/tile/powersink/MekJoules.java
View file

@ -19,51 +19,45 @@
package appeng.tile.powersink; package appeng.tile.powersink;
import mekanism.api.energy.IStrictEnergyAcceptor; //@Interface( iname = "Mekanism", iface = "mekanism.api.energy.IStrictEnergyAcceptor" )
import appeng.api.config.PowerUnits; //public abstract class MekJoules extends RedstoneFlux implements IStrictEnergyAcceptor
import appeng.api.util.ForgeDirection; //{
import appeng.transformer.annotations.Integration.Interface; //
// @Override
// public double getEnergy()
@Interface( iname = "Mekanism", iface = "mekanism.api.energy.IStrictEnergyAcceptor" ) // {
public abstract class MekJoules extends RedstoneFlux implements IStrictEnergyAcceptor // return 0;
{ // }
//
@Override // @Override
public double getEnergy() // public void setEnergy( double energy )
{ // {
return 0; // double extra = this.injectExternalPower( PowerUnits.MK, energy );
} // this.internalCurrentPower += PowerUnits.MK.convertTo( PowerUnits.AE, extra );
// }
@Override //
public void setEnergy( double energy ) // @Override
{ // public double getMaxEnergy()
double extra = this.injectExternalPower( PowerUnits.MK, energy ); // {
this.internalCurrentPower += PowerUnits.MK.convertTo( PowerUnits.AE, extra ); // return this.getExternalPowerDemand( PowerUnits.MK, 100000 );
} // }
//
@Override // @Override
public double getMaxEnergy() // public double transferEnergyToAcceptor( ForgeDirection side, double amount )
{ // {
return this.getExternalPowerDemand( PowerUnits.MK, 100000 ); // double demand = this.getExternalPowerDemand( PowerUnits.MK, Double.MAX_VALUE );
} // if( amount > demand )
// {
@Override // amount = demand;
public double transferEnergyToAcceptor( ForgeDirection side, double amount ) // }
{ //
double demand = this.getExternalPowerDemand( PowerUnits.MK, Double.MAX_VALUE ); // double overflow = this.injectExternalPower( PowerUnits.MK, amount );
if( amount > demand ) // return amount - overflow;
{ // }
amount = demand; //
} // @Override
// public boolean canReceiveEnergy( ForgeDirection side )
double overflow = this.injectExternalPower( PowerUnits.MK, amount ); // {
return amount - overflow; // return this.getPowerSides().contains( side );
} // }
//}
@Override
public boolean canReceiveEnergy( ForgeDirection side )
{
return this.getPowerSides().contains( side );
}
}

76
src/main/java/appeng/tile/powersink/RedstoneFlux.java
View file

@ -19,44 +19,38 @@
package appeng.tile.powersink; package appeng.tile.powersink;
import cofh.api.energy.IEnergyReceiver; //@Interface( iname = "RF", iface = "cofh.api.energy.IEnergyReceiver" )
import appeng.api.config.PowerUnits; //public abstract class RedstoneFlux extends RotaryCraft implements IEnergyReceiver
import appeng.api.util.ForgeDirection; //{
import appeng.transformer.annotations.Integration.Interface; // @Override
// public final int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate )
// {
@Interface( iname = "RF", iface = "cofh.api.energy.IEnergyReceiver" ) // final int networkRFDemand = (int) Math.floor( this.getExternalPowerDemand( PowerUnits.RF, maxReceive ) );
public abstract class RedstoneFlux extends RotaryCraft implements IEnergyReceiver // final int usedRF = Math.min( maxReceive, networkRFDemand );
{ //
@Override // if( !simulate )
public final int receiveEnergy( ForgeDirection from, int maxReceive, boolean simulate ) // {
{ // this.injectExternalPower( PowerUnits.RF, usedRF );
final int networkRFDemand = (int) Math.floor( this.getExternalPowerDemand( PowerUnits.RF, maxReceive ) ); // }
final int usedRF = Math.min( maxReceive, networkRFDemand ); //
// return usedRF;
if( !simulate ) // }
{ //
this.injectExternalPower( PowerUnits.RF, usedRF ); // @Override
} // public final int getEnergyStored( ForgeDirection from )
// {
return usedRF; // return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, this.getAECurrentPower() ) );
} // }
//
@Override // @Override
public final int getEnergyStored( ForgeDirection from ) // public final int getMaxEnergyStored( ForgeDirection from )
{ // {
return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, this.getAECurrentPower() ) ); // return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, this.getAEMaxPower() ) );
} // }
//
@Override // @Override
public final int getMaxEnergyStored( ForgeDirection from ) // public final boolean canConnectEnergy( ForgeDirection from )
{ // {
return (int) Math.floor( PowerUnits.AE.convertTo( PowerUnits.RF, this.getAEMaxPower() ) ); // return this.getPowerSides().contains( from );
} // }
//}
@Override
public final boolean canConnectEnergy( ForgeDirection from )
{
return this.getPowerSides().contains( from );
}
}

311
src/main/java/appeng/tile/powersink/RotaryCraft.java
View file

@ -19,166 +19,151 @@
package appeng.tile.powersink; package appeng.tile.powersink;
import appeng.transformer.annotations.Integration; //@InterfaceList( value = { @Interface( iname = "RotaryCraft", iface = "Reika.RotaryCraft.API.Power.AdvancedShaftPowerReceiver" ), @Interface( iname = "RotaryCraft", iface = "Reika.RotaryCraft.API.Interfaces.Transducerable") } )
import net.minecraft.world.World; //public abstract class RotaryCraft extends IC2 implements AdvancedShaftPowerReceiver, Transducerable
import Reika.RotaryCraft.API.Interfaces.Transducerable; //{
import Reika.RotaryCraft.API.Power.AdvancedShaftPowerReceiver; //
import appeng.api.config.PowerUnits; // private int omega = 0;
import appeng.api.util.ForgeDirection; // private int torque = 0;
import appeng.tile.TileEvent; // private long power = 0;
import appeng.tile.events.TileEventType; // private int alpha = 0;
import appeng.transformer.annotations.Integration.Interface; //
import appeng.transformer.annotations.Integration.InterfaceList; // private long currentPower = 0;
import appeng.transformer.annotations.Integration.Method; //
import appeng.util.Platform; // @TileEvent( TileEventType.TICK )
// @Method( iname = "RotaryCraft" )
import java.util.ArrayList; // public void Tick_RotaryCraft()
// {
@InterfaceList( value = { @Interface( iname = "RotaryCraft", iface = "Reika.RotaryCraft.API.Power.AdvancedShaftPowerReceiver" ), @Interface( iname = "RotaryCraft", iface = "Reika.RotaryCraft.API.Interfaces.Transducerable") } ) // if( this.worldObj != null && !this.worldObj.isRemote && this.currentPower > 0 )
public abstract class RotaryCraft extends IC2 implements AdvancedShaftPowerReceiver, Transducerable // {
{ // this.injectExternalPower( PowerUnits.WA, this.currentPower );
// this.currentPower = 0;
private int omega = 0; // }
private int torque = 0; // }
private long power = 0; //
private int alpha = 0; // @Override
// public final boolean addPower( int torque, int omega, long power, ForgeDirection side )
private long currentPower = 0; // {
// this.omega = omega;
@TileEvent( TileEventType.TICK ) // this.torque = torque;
@Method( iname = "RotaryCraft" ) // this.power = power;
public void Tick_RotaryCraft() //
{ // this.currentPower += power;
if( this.worldObj != null && !this.worldObj.isRemote && this.currentPower > 0 ) //
{ // return true;
this.injectExternalPower( PowerUnits.WA, this.currentPower ); //
this.currentPower = 0; // }
} //
} // @Override
// public final int getOmega()
@Override // {
public final boolean addPower( int torque, int omega, long power, ForgeDirection side ) // return this.omega;
{ // }
this.omega = omega; //
this.torque = torque; // @Override
this.power = power; // public final int getTorque()
// {
this.currentPower += power; // return this.torque;
// }
return true; //
// @Override
} // public final long getPower()
// {
@Override // return this.power;
public final int getOmega() // }
{ //
return this.omega; // @Override
} // public final String getName()
// {
@Override // return "AE";
public final int getTorque() // }
{ //
return this.torque; // @Override
} // public final int getIORenderAlpha()
// {
@Override // return this.alpha;
public final long getPower() // }
{ //
return this.power; // @Override
} // public final void setIORenderAlpha( int io )
// {
@Override // this.alpha = io;
public final String getName() // }
{ //
return "AE"; // public final boolean canReadFromBlock( int x, int y, int z )
} // {
// ForgeDirection side = ForgeDirection.UNKNOWN;
@Override //
public final int getIORenderAlpha() // if( x == this.xCoord - 1 )
{ // {
return this.alpha; // side = ForgeDirection.WEST;
} // }
// else if( x == this.xCoord + 1 )
@Override // {
public final void setIORenderAlpha( int io ) // side = ForgeDirection.EAST;
{ // }
this.alpha = io; // else if( z == this.zCoord - 1 )
} // {
// side = ForgeDirection.NORTH;
public final boolean canReadFromBlock( int x, int y, int z ) // }
{ // else if( z == this.zCoord + 1 )
ForgeDirection side = ForgeDirection.UNKNOWN; // {
// side = ForgeDirection.SOUTH;
if( x == this.xCoord - 1 ) // }
{ // else if( y == this.yCoord - 1 )
side = ForgeDirection.WEST; // {
} // side = ForgeDirection.DOWN;
else if( x == this.xCoord + 1 ) // }
{ // else if( y == this.yCoord + 1 )
side = ForgeDirection.EAST; // {
} // side = ForgeDirection.UP;
else if( z == this.zCoord - 1 ) // }
{ //
side = ForgeDirection.NORTH; // return this.getPowerSides().contains( side );
} // }
else if( z == this.zCoord + 1 ) //
{ // @Override
side = ForgeDirection.SOUTH; // public final boolean canReadFrom( ForgeDirection side )
} // {
else if( y == this.yCoord - 1 ) // return this.getPowerSides().contains( side );
{ // }
side = ForgeDirection.DOWN; //
} // @Override
else if( y == this.yCoord + 1 ) // public final boolean isReceiving()
{ // {
side = ForgeDirection.UP; // return true;
} // }
//
return this.getPowerSides().contains( side ); // @Override
} // public final int getMinTorque( int available )
// {
@Override // return 1;
public final boolean canReadFrom( ForgeDirection side ) // }
{ //
return this.getPowerSides().contains( side ); // @Override
} // public final ArrayList<String> getMessages( World world, int x, int y, int z, int side )
// {
@Override // String out;
public final boolean isReceiving() // if( power >= 1000000000 )
{ // {
return true; // out = String.format( "Receiving %.3f GW @ %d rad/s.", power / 1000000000.0D, omega );
} // }
// else if( power >= 1000000 )
@Override // {
public final int getMinTorque( int available ) // out = String.format( "Receiving %.3f MW @ %d rad/s.", power / 1000000.0D, omega );
{ // }
return 1; // else if( power >= 1000 )
} // {
// out = String.format( "Receiving %.3f kW @ %d rad/s.", power / 1000.0D, omega );
@Override // }
public final ArrayList<String> getMessages( World world, int x, int y, int z, int side ) // else
{ // {
String out; // out = String.format( "Receiving %d W @ %d rad/s.", power, omega );
if( power >= 1000000000 ) // }
{ //
out = String.format( "Receiving %.3f GW @ %d rad/s.", power / 1000000000.0D, omega ); //
} // ArrayList<String> messages = new ArrayList<String>( 1 );
else if( power >= 1000000 ) // messages.add( out );
{ // return messages;
out = String.format( "Receiving %.3f MW @ %d rad/s.", power / 1000000.0D, omega ); // }
} //}
else if( power >= 1000 )
{
out = String.format( "Receiving %.3f kW @ %d rad/s.", power / 1000.0D, omega );
}
else
{
out = String.format( "Receiving %d W @ %d rad/s.", power, omega );
}
ArrayList<String> messages = new ArrayList<String>( 1 );
messages.add( out );
return messages;
}
}

197
src/main/java/appeng/util/inv/AdaptorBCPipe.java
View file

@ -19,108 +19,95 @@
package appeng.util.inv; package appeng.util.inv;
import java.util.Iterator; //public class AdaptorBCPipe extends InventoryAdaptor
//{
import net.minecraft.item.ItemStack; //
import net.minecraft.tileentity.TileEntity; // private final IBC bc;
import appeng.api.config.FuzzyMode; // private final TileEntity i;
import appeng.api.util.ForgeDirection; // private final ForgeDirection d;
import appeng.integration.IntegrationRegistry; //
import appeng.integration.IntegrationType; // public AdaptorBCPipe( TileEntity s, ForgeDirection dd )
import appeng.integration.abstraction.IBC; // {
import appeng.util.InventoryAdaptor; // this.bc = (IBC) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.BC );
import appeng.util.iterators.NullIterator; // if( this.bc != null )
// {
// if( this.bc.isPipe( s, dd ) )
public class AdaptorBCPipe extends InventoryAdaptor // {
{ // this.i = s;
// this.d = dd;
private final IBC bc; // return;
private final TileEntity i; // }
private final ForgeDirection d; // }
// this.i = null;
public AdaptorBCPipe( TileEntity s, ForgeDirection dd ) // this.d = null;
{ // }
this.bc = (IBC) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.BC ); //
if( this.bc != null ) // @Override
{ // public ItemStack removeItems( int amount, ItemStack filter, IInventoryDestination destination )
if( this.bc.isPipe( s, dd ) ) // {
{ // return null;
this.i = s; // }
this.d = dd; //
return; // @Override
} // public ItemStack simulateRemove( int amount, ItemStack filter, IInventoryDestination destination )
} // {
this.i = null; // return null;
this.d = null; // }
} //
// @Override
@Override // public ItemStack removeSimilarItems( int amount, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination )
public ItemStack removeItems( int amount, ItemStack filter, IInventoryDestination destination ) // {
{ // return null;
return null; // }
} //
// @Override
@Override // public ItemStack simulateSimilarRemove( int amount, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination )
public ItemStack simulateRemove( int amount, ItemStack filter, IInventoryDestination destination ) // {
{ // return null;
return null; // }
} //
// @Override
@Override // public ItemStack addItems( ItemStack toBeAdded )
public ItemStack removeSimilarItems( int amount, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination ) // {
{ // if( this.i == null )
return null; // {
} // return toBeAdded;
// }
@Override // if( toBeAdded == null )
public ItemStack simulateSimilarRemove( int amount, ItemStack filter, FuzzyMode fuzzyMode, IInventoryDestination destination ) // {
{ // return null;
return null; // }
} // if( toBeAdded.stackSize == 0 )
// {
@Override // return null;
public ItemStack addItems( ItemStack toBeAdded ) // }
{ //
if( this.i == null ) // if( this.bc.addItemsToPipe( this.i, toBeAdded, this.d ) )
{ // {
return toBeAdded; // return null;
} // }
if( toBeAdded == null ) // return toBeAdded;
{ // }
return null; //
} // @Override
if( toBeAdded.stackSize == 0 ) // public ItemStack simulateAdd( ItemStack toBeSimulated )
{ // {
return null; // if( this.i == null )
} // {
// return toBeSimulated;
if( this.bc.addItemsToPipe( this.i, toBeAdded, this.d ) ) // }
{ // return null;
return null; // }
} //
return toBeAdded; // @Override
} // public boolean containsItems()
// {
@Override // return false;
public ItemStack simulateAdd( ItemStack toBeSimulated ) // }
{ //
if( this.i == null ) // @Override
{ // public Iterator<ItemSlot> iterator()
return toBeSimulated; // {
} // return new NullIterator<ItemSlot>();
return null; // }
} //}
@Override
public boolean containsItems()
{
return false;
}
@Override
public Iterator<ItemSlot> iterator()
{
return new NullIterator<ItemSlot>();
}
}

194
src/main/java/appeng/util/inv/WrapperBCPipe.java
View file

@ -19,105 +19,95 @@
package appeng.util.inv; package appeng.util.inv;
import net.minecraft.entity.player.EntityPlayer; //public class WrapperBCPipe implements IInventory
import net.minecraft.inventory.IInventory; //{
import net.minecraft.item.ItemStack; //
import net.minecraft.tileentity.TileEntity; // private final IBC bc;
import appeng.api.util.ForgeDirection; // private final TileEntity ad;
import appeng.integration.IntegrationRegistry; // private final ForgeDirection dir;
import appeng.integration.IntegrationType; //
import appeng.integration.abstraction.IBC; // public WrapperBCPipe( TileEntity te, ForgeDirection d )
// {
// this.bc = (IBC) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.BC );
public class WrapperBCPipe implements IInventory // this.ad = te;
{ // this.dir = d;
// }
private final IBC bc; //
private final TileEntity ad; // @Override
private final ForgeDirection dir; // public int getSizeInventory()
// {
public WrapperBCPipe( TileEntity te, ForgeDirection d ) // return 1;
{ // }
this.bc = (IBC) IntegrationRegistry.INSTANCE.getInstance( IntegrationType.BC ); //
this.ad = te; // @Override
this.dir = d; // public ItemStack getStackInSlot( int i )
} // {
// return null;
@Override // }
public int getSizeInventory() //
{ // @Override
return 1; // public ItemStack decrStackSize( int i, int j )
} // {
// return null;
@Override // }
public ItemStack getStackInSlot( int i ) //
{ // @Override
return null; // public ItemStack getStackInSlotOnClosing( int i )
} // {
// return null;
@Override // }
public ItemStack decrStackSize( int i, int j ) //
{ // @Override
return null; // public void setInventorySlotContents( int i, ItemStack itemstack )
} // {
// this.bc.addItemsToPipe( this.ad, itemstack, this.dir );
@Override // }
public ItemStack getStackInSlotOnClosing( int i ) //
{ // @Override
return null; // public String getInventoryName()
} // {
// return "BC Pipe Wrapper";
@Override // }
public void setInventorySlotContents( int i, ItemStack itemstack ) //
{ // @Override
this.bc.addItemsToPipe( this.ad, itemstack, this.dir ); // public boolean hasCustomInventoryName()
} // {
// return false;
@Override // }
public String getInventoryName() //
{ // @Override
return "BC Pipe Wrapper"; // public int getInventoryStackLimit()
} // {
// return 64;
@Override // }
public boolean hasCustomInventoryName() //
{ // @Override
return false; // public void markDirty()
} // {
//
@Override // }
public int getInventoryStackLimit() //
{ // @Override
return 64; // public boolean isUseableByPlayer( EntityPlayer entityplayer )
} // {
// return false;
@Override // }
public void markDirty() //
{ // @Override
// public void openInventory()
} // {
//
@Override // }
public boolean isUseableByPlayer( EntityPlayer entityplayer ) //
{ // @Override
return false; // public void closeInventory()
} // {
//
@Override // }
public void openInventory() //
{ // @Override
// public boolean isItemValidForSlot( int i, ItemStack itemstack )
} // {
// return this.bc.canAddItemsToPipe( this.ad, itemstack, this.dir );
@Override // }
public void closeInventory() //}
{
}
@Override
public boolean isItemValidForSlot( int i, ItemStack itemstack )
{
return this.bc.canAddItemsToPipe( this.ad, itemstack, this.dir );
}
}

187
src/main/java/appeng/util/inv/WrapperTEPipe.java
View file

@ -19,100 +19,93 @@
package appeng.util.inv; package appeng.util.inv;
import appeng.api.util.ForgeDirection; //public class WrapperTEPipe implements IInventory
import net.minecraft.entity.player.EntityPlayer; //{
import net.minecraft.inventory.IInventory; //
import net.minecraft.item.ItemStack; // final TileEntity ad;
import net.minecraft.tileentity.TileEntity; // final ForgeDirection dir;
//
// public WrapperTEPipe( TileEntity te, ForgeDirection d )
public class WrapperTEPipe implements IInventory // {
{ // this.ad = te;
// this.dir = d;
final TileEntity ad; // }
final ForgeDirection dir; //
// @Override
public WrapperTEPipe( TileEntity te, ForgeDirection d ) // public int getSizeInventory()
{ // {
this.ad = te; // return 1;
this.dir = d; // }
} //
// @Override
@Override // public ItemStack getStackInSlot( int i )
public int getSizeInventory() // {
{ // return null;
return 1; // }
} //
// @Override
@Override // public ItemStack decrStackSize( int i, int j )
public ItemStack getStackInSlot( int i ) // {
{ // return null;
return null; // }
} //
// @Override
@Override // public ItemStack getStackInSlotOnClosing( int i )
public ItemStack decrStackSize( int i, int j ) // {
{ // return null;
return null; // }
} //
// @Override
@Override // public void setInventorySlotContents( int i, ItemStack itemstack )
public ItemStack getStackInSlotOnClosing( int i ) // {
{ // // ITE.addItemsToPipe( ad, itemstack, dir );
return null; // }
} //
// @Override
@Override // public String getInventoryName()
public void setInventorySlotContents( int i, ItemStack itemstack ) // {
{ // return null;
// ITE.addItemsToPipe( ad, itemstack, dir ); // }
} //
// @Override
@Override // public boolean hasCustomInventoryName()
public String getInventoryName() // {
{ // return false;
return null; // }
} //
// @Override
@Override // public int getInventoryStackLimit()
public boolean hasCustomInventoryName() // {
{ // return 64;
return false; // }
} //
// @Override
@Override // public void markDirty()
public int getInventoryStackLimit() // {
{ //
return 64; // }
} //
// @Override
@Override // public boolean isUseableByPlayer( EntityPlayer entityplayer )
public void markDirty() // {
{ // return false;
// }
} //
// @Override
@Override // public void openInventory()
public boolean isUseableByPlayer( EntityPlayer entityplayer ) // {
{ //
return false; // }
} //
// @Override
@Override // public void closeInventory()
public void openInventory() // {
{ //
// }
} //
// @Override
@Override // public boolean isItemValidForSlot( int i, ItemStack itemstack )
public void closeInventory() // {
{ // return false;
// }
} //}
@Override
public boolean isItemValidForSlot( int i, ItemStack itemstack )
{
return false;
}
}

8
src/main/java/appeng/util/item/AEFluidStack.java
View file

@ -19,22 +19,22 @@
package appeng.util.item; package appeng.util.item;
import io.netty.buffer.ByteBuf;
import java.io.ByteArrayInputStream; import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.io.DataInputStream; import java.io.DataInputStream;
import java.io.DataOutputStream; import java.io.DataOutputStream;
import java.io.IOException; import java.io.IOException;
import javax.annotation.Nonnull; import javax.annotation.Nonnull;
import io.netty.buffer.ByteBuf;
import net.minecraft.item.ItemStack; import net.minecraft.item.ItemStack;
import net.minecraft.nbt.CompressedStreamTools; import net.minecraft.nbt.CompressedStreamTools;
import net.minecraft.nbt.NBTBase; import net.minecraft.nbt.NBTBase;
import net.minecraft.nbt.NBTTagCompound; import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack; import net.minecraftforge.fluids.FluidStack;
import appeng.api.config.FuzzyMode; import appeng.api.config.FuzzyMode;
import appeng.api.storage.StorageChannel; import appeng.api.storage.StorageChannel;
import appeng.api.storage.data.IAEFluidStack; import appeng.api.storage.data.IAEFluidStack;
@ -302,7 +302,7 @@ public final class AEFluidStack extends AEStack<IAEFluidStack> implements IAEFlu
{ {
FluidStack is = (FluidStack) ia; FluidStack is = (FluidStack) ia;
if( is.fluidID == this.fluid.getID() ) if( is.getFluidID() == this.fluid.getID() )
{ {
NBTTagCompound ta = (NBTTagCompound) this.tagCompound; NBTTagCompound ta = (NBTTagCompound) this.tagCompound;
NBTTagCompound tb = is.tag; NBTTagCompound tb = is.tag;