diff --git a/client/me/ItemRepo.java b/client/me/ItemRepo.java index 2aa36f78..05890d81 100644 --- a/client/me/ItemRepo.java +++ b/client/me/ItemRepo.java @@ -239,7 +239,7 @@ public class ItemRepo String dspName = Platform.getItemDisplayName( is ); notDone = true; - if ( m.matcher( dspName ).find() ) + if ( m.matcher( dspName.toLowerCase() ).find() ) { view.add( is ); notDone = false; diff --git a/core/Registration.java b/core/Registration.java index 9cfd243e..d5fe5e51 100644 --- a/core/Registration.java +++ b/core/Registration.java @@ -481,29 +481,27 @@ public class Registration recipeHandler.parseRecipes( new JarLoader( "/assets/appliedenergistics2/recipes/" ), "index.recipe" ); IPartHelper ph = AEApi.instance().partHelper(); - ph.registerNewLayer( "appeng.api.parts.layers.LayerISidedInventory", "net.minecraft.inventory.ISidedInventory" ); - ph.registerNewLayer( "appeng.api.parts.layers.LayerIFluidHandler", "net.minecraftforge.fluids.IFluidHandler" ); - ph.registerNewLayer( "appeng.api.parts.layers.LayerITileStorageMonitorable", "appeng.api.implementations.tiles.ITileStorageMonitorable" ); + ph.registerNewLayer( "appeng.parts.layers.LayerISidedInventory", "net.minecraft.inventory.ISidedInventory" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIFluidHandler", "net.minecraftforge.fluids.IFluidHandler" ); + ph.registerNewLayer( "appeng.parts.layers.LayerITileStorageMonitorable", "appeng.api.implementations.tiles.ITileStorageMonitorable" ); if ( AppEng.instance.isIntegrationEnabled( "IC2" ) ) { - ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergySink", "ic2.api.energy.tile.IEnergySink" ); - ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergySource", "ic2.api.energy.tile.IEnergySource" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIEnergySink", "ic2.api.energy.tile.IEnergySink" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIEnergySource", "ic2.api.energy.tile.IEnergySource" ); } if ( AppEng.instance.isIntegrationEnabled( "MJ5" ) ) { - ph.registerNewLayer( "appeng.api.parts.layers.LayerIPowerEmitter", "buildcraft.api.power.IPowerEmitter" ); - ph.registerNewLayer( "appeng.api.parts.layers.LayerIPowerReceptor", "buildcraft.api.power.IPowerReceptor" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIPowerEmitter", "buildcraft.api.power.IPowerEmitter" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIPowerReceptor", "buildcraft.api.power.IPowerReceptor" ); } if ( AppEng.instance.isIntegrationEnabled( "MJ6" ) ) - { - ph.registerNewLayer( "appeng.api.parts.layers.LayerIBatteryProvider", "buildcraft.api.mj.IBatteryProvider" ); - } + ph.registerNewLayer( "appeng.parts.layers.LayerIBatteryProvider", "buildcraft.api.mj.IBatteryProvider" ); if ( AppEng.instance.isIntegrationEnabled( "RF" ) ) - ph.registerNewLayer( "appeng.api.parts.layers.LayerIEnergyHandler", "cofh.api.energy.IEnergyHandler" ); + ph.registerNewLayer( "appeng.parts.layers.LayerIEnergyHandler", "cofh.api.energy.IEnergyHandler" ); FMLCommonHandler.instance().bus().register( TickHandler.instance ); MinecraftForge.EVENT_BUS.register( TickHandler.instance ); diff --git a/core/localization/GuiText.java b/core/localization/GuiText.java index fa4355cf..6f4a0b7c 100644 --- a/core/localization/GuiText.java +++ b/core/localization/GuiText.java @@ -28,7 +28,7 @@ public enum GuiText CopyMode, CopyModeDesc, PatternTerminal, CraftingPattern, ProcessingPattern, Crafts, Creates, And, With, MolecularAssembler, - StoredPower, MaxPower, RequiredPower, Efficiency, InWorldCrafting, inWorldFluix, inWorldPurification, inWorldSingularity, + StoredPower, MaxPower, RequiredPower, Efficiency, InWorldCrafting, inWorldFluix, inWorldPurificationCertus, inWorldPurificationNether, inWorldPurificationFluix, inWorldSingularity, OfSecondOutput, NoSecondOutput, RFTunnel, Stores, Next, SelectAmount, Lumen, Empty; diff --git a/integration/modules/NEIHelpers/NEIWorldCraftingHandler.java b/integration/modules/NEIHelpers/NEIWorldCraftingHandler.java index 332f7634..1a29aad6 100644 --- a/integration/modules/NEIHelpers/NEIWorldCraftingHandler.java +++ b/integration/modules/NEIHelpers/NEIWorldCraftingHandler.java @@ -55,9 +55,9 @@ public class NEIWorldCraftingHandler implements ICraftingHandler, IUsageHandler if ( AEConfig.instance.isFeatureEnabled( AEFeature.inWorldPurification ) ) { - addRecipe( AEApi.instance().materials().materialPureifiedCertusQuartzCrystal, GuiText.inWorldPurification.getLocal() ); - addRecipe( AEApi.instance().materials().materialPureifiedNetherQuartzCrystal, GuiText.inWorldPurification.getLocal() ); - addRecipe( AEApi.instance().materials().materialPureifiedFluixCrystal, GuiText.inWorldPurification.getLocal() ); + addRecipe( AEApi.instance().materials().materialPureifiedCertusQuartzCrystal, GuiText.inWorldPurificationCertus.getLocal() ); + addRecipe( AEApi.instance().materials().materialPureifiedNetherQuartzCrystal, GuiText.inWorldPurificationNether.getLocal() ); + addRecipe( AEApi.instance().materials().materialPureifiedFluixCrystal, GuiText.inWorldPurificationFluix.getLocal() ); } } diff --git a/me/helpers/AENetworkProxy.java b/me/helpers/AENetworkProxy.java index 83eafc26..23b0a24a 100644 --- a/me/helpers/AENetworkProxy.java +++ b/me/helpers/AENetworkProxy.java @@ -36,7 +36,7 @@ public class AENetworkProxy implements IGridBlock final private IGridProxyable gp; final private boolean worldNode; - final private ItemStack myRepInstance; + private ItemStack myRepInstance; private boolean isReady = false; private IGridNode node = null; @@ -57,7 +57,12 @@ public class AENetworkProxy implements IGridBlock { return myRepInstance; } - + + public void setVisualRepresentation( ItemStack is ) + { + myRepInstance = is; + } + public AENetworkProxy(IGridProxyable te, String nbtName, ItemStack visual, boolean inWorld) { this.gp = te; this.nbtName = nbtName; diff --git a/parts/CableBusContainer.java b/parts/CableBusContainer.java index d7b2e43a..e1acae0a 100644 --- a/parts/CableBusContainer.java +++ b/parts/CableBusContainer.java @@ -40,6 +40,7 @@ import appeng.api.util.AEColor; import appeng.api.util.DimensionalCoord; import appeng.client.render.BusRenderHelper; import appeng.client.render.CableRenderHelper; +import appeng.core.AELog; import appeng.core.AppEng; import appeng.facade.FacadeContainer; import appeng.helpers.AEMultiTile; @@ -704,7 +705,9 @@ public class CableBusContainer implements AEMultiTile, ICableBusContainer p.readFromNBT( extra ); } else - throw new RuntimeException( "Invalid NBT For CableBus Container: " + iss.getItem().getClass().getName() + " is not a valid part." ); + { + AELog.warning( "Invalid NBT For CableBus Container: " + iss.getItem().getClass().getName() + " is not a valid part; it was ignored." ); + } } } else diff --git a/parts/automation/PartAnnihilationPlane.java b/parts/automation/PartAnnihilationPlane.java index 47711ed4..afb03ea2 100644 --- a/parts/automation/PartAnnihilationPlane.java +++ b/parts/automation/PartAnnihilationPlane.java @@ -2,6 +2,7 @@ package appeng.parts.automation; import java.io.IOException; import java.util.LinkedList; +import java.util.List; import java.util.concurrent.Callable; import net.minecraft.block.Block; @@ -203,6 +204,14 @@ public class PartAnnihilationPlane extends PartBasicState implements IGridTickab return Buffer.isEmpty(); } + @Override + public void getDrops(List drops, boolean wrenched) + { + for (IAEItemStack is : Buffer) + if ( is != null ) + drops.add( is.getItemStack() ); + } + @MENetworkEventSubscribe public void chanRender(MENetworkChannelsChanged c) { diff --git a/parts/layers/InvSot.java b/parts/layers/InvSot.java new file mode 100644 index 00000000..493492c7 --- /dev/null +++ b/parts/layers/InvSot.java @@ -0,0 +1,47 @@ +package appeng.parts.layers; + +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; + +public class InvSot +{ + + final public ISidedInventory partInv; + final public int index; + + public InvSot(ISidedInventory part, int slot) { + partInv = part; + index = slot; + } + + public ItemStack decrStackSize(int j) + { + return partInv.decrStackSize( index, j ); + } + + public ItemStack getStackInSlot() + { + return partInv.getStackInSlot( index ); + } + + public boolean isItemValidForSlot(ItemStack itemstack) + { + return partInv.isItemValidForSlot( index, itemstack ); + } + + public void setInventorySlotContents(ItemStack itemstack) + { + partInv.setInventorySlotContents( index, itemstack ); + } + + public boolean canExtractItem(ItemStack itemstack, int side) + { + return partInv.canExtractItem( index, itemstack, side ); + } + + public boolean canInsertItem(ItemStack itemstack, int side) + { + return partInv.canInsertItem( index, itemstack, side ); + } + +} diff --git a/parts/layers/LayerIBatteryProvider.java b/parts/layers/LayerIBatteryProvider.java new file mode 100644 index 00000000..f3069076 --- /dev/null +++ b/parts/layers/LayerIBatteryProvider.java @@ -0,0 +1,23 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import buildcraft.api.mj.IBatteryObject; +import buildcraft.api.mj.ISidedBatteryProvider; + +public class LayerIBatteryProvider extends LayerBase implements ISidedBatteryProvider +{ + + @Override + public IBatteryObject getMjBattery(String kind, ForgeDirection direction) + { + IPart p = getPart( direction ); + + if ( p instanceof ISidedBatteryProvider ) + return ((ISidedBatteryProvider) p).getMjBattery( kind, direction ); + + return null; + } + +} diff --git a/parts/layers/LayerIEnergyHandler.java b/parts/layers/LayerIEnergyHandler.java new file mode 100644 index 00000000..75b49d81 --- /dev/null +++ b/parts/layers/LayerIEnergyHandler.java @@ -0,0 +1,61 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import cofh.api.energy.IEnergyHandler; + +public class LayerIEnergyHandler extends LayerBase implements IEnergyHandler +{ + + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) + { + IPart part = getPart( from ); + if ( part instanceof IEnergyHandler ) + return ((IEnergyHandler) part).receiveEnergy( from, maxReceive, simulate ); + + return 0; + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) + { + IPart part = getPart( from ); + if ( part instanceof IEnergyHandler ) + return ((IEnergyHandler) part).extractEnergy( from, maxExtract, simulate ); + + return 0; + } + + @Override + public int getEnergyStored(ForgeDirection from) + { + IPart part = getPart( from ); + if ( part instanceof IEnergyHandler ) + return ((IEnergyHandler) part).getEnergyStored( from ); + + return 0; + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) + { + IPart part = getPart( from ); + if ( part instanceof IEnergyHandler ) + return ((IEnergyHandler) part).getMaxEnergyStored( from ); + + return 0; + } + + @Override + public boolean canConnectEnergy(ForgeDirection from) + { + IPart part = getPart( from ); + if ( part instanceof IEnergyHandler ) + return ((IEnergyHandler) part).canConnectEnergy( from ); + + return false; + } + +} diff --git a/parts/layers/LayerIEnergySink.java b/parts/layers/LayerIEnergySink.java new file mode 100644 index 00000000..e10b9e79 --- /dev/null +++ b/parts/layers/LayerIEnergySink.java @@ -0,0 +1,146 @@ +package appeng.parts.layers; + +import ic2.api.energy.tile.IEnergySink; +import ic2.api.energy.tile.IEnergyTile; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; +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 boolean isInIC2() + { + return getLayerFlags().contains( LayerFlags.IC2_ENET ); + } + + private TileEntity getEnergySinkTile() + { + IPartHost host = (IPartHost) this; + return host.getTile(); + } + + private World getEnergySinkWorld() + { + if ( getEnergySinkTile() == null ) + return null; + + return getEnergySinkTile().getWorldObj(); + } + + final private void addToENet() + { + if ( getEnergySinkWorld() == null ) + return; + + // re-add + removeFromENet(); + + if ( !isInIC2() && Platform.isServer() ) + { + getLayerFlags().add( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergySink) getEnergySinkTile() ) ); + } + } + + final private void removeFromENet() + { + if ( getEnergySinkWorld() == null ) + return; + + if ( isInIC2() && Platform.isServer() ) + { + getLayerFlags().remove( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergySink) getEnergySinkTile() ) ); + } + } + + final private boolean interestedInIC2() + { + int interested = 0; + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergyTile ) + { + interested++; + } + } + return interested == 1;// if more then one tile is interested we need to abandonship... + } + + @Override + public void partChanged() + { + super.partChanged(); + + if ( interestedInIC2() ) + addToENet(); + else + removeFromENet(); + } + + @Override + public boolean acceptsEnergyFrom(TileEntity emitter, ForgeDirection direction) + { + if ( !isInIC2() ) + return false; + + IPart part = getPart( direction ); + if ( part instanceof IEnergySink ) + return ((IEnergySink) part).acceptsEnergyFrom( emitter, direction ); + return false; + } + + @Override + public double demandedEnergyUnits() + { + if ( !isInIC2() ) + return 0; + + // this is a flawed implementation, that requires a change to the IC2 API. + + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergySink ) + { + // use lower number cause ic2 deletes power it sends that isn't recieved. + return ((IEnergySink) part).demandedEnergyUnits(); + } + } + + return 0; + } + + @Override + public double injectEnergyUnits(ForgeDirection directionFrom, double amount) + { + if ( !isInIC2() ) + return amount; + + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergySink ) + { + return ((IEnergySink) part).injectEnergyUnits( directionFrom, amount ); + } + } + + return amount; + } + + @Override + public int getMaxSafeInput() + { + return Integer.MAX_VALUE; // no real options here... + } + +} diff --git a/parts/layers/LayerIEnergySource.java b/parts/layers/LayerIEnergySource.java new file mode 100644 index 00000000..f9a655d4 --- /dev/null +++ b/parts/layers/LayerIEnergySource.java @@ -0,0 +1,139 @@ +package appeng.parts.layers; + +import ic2.api.energy.tile.IEnergyEmitter; +import ic2.api.energy.tile.IEnergySink; +import ic2.api.energy.tile.IEnergySource; +import ic2.api.energy.tile.IEnergyTile; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.common.util.ForgeDirection; +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 boolean isInIC2() + { + return getLayerFlags().contains( LayerFlags.IC2_ENET ); + } + + private TileEntity getEnergySourceTile() + { + IPartHost host = (IPartHost) this; + return host.getTile(); + } + + private World getEnergySourceWorld() + { + if ( getEnergySourceTile() == null ) + return null; + return getEnergySourceTile().getWorldObj(); + } + + final private void addToENet() + { + if ( getEnergySourceWorld() == null ) + return; + + // re-add + removeFromENet(); + + if ( !isInIC2() && Platform.isServer() ) + { + getLayerFlags().add( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileLoadEvent( (IEnergySink) getEnergySourceTile() ) ); + } + } + + final private void removeFromENet() + { + if ( getEnergySourceWorld() == null ) + return; + + if ( isInIC2() && Platform.isServer() ) + { + getLayerFlags().remove( LayerFlags.IC2_ENET ); + MinecraftForge.EVENT_BUS.post( new ic2.api.energy.event.EnergyTileUnloadEvent( (IEnergySink) getEnergySourceTile() ) ); + } + } + + final private boolean interestedInIC2() + { + int interested = 0; + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergyTile ) + { + interested++; + } + } + return interested == 1;// if more then one tile is interested we need to abandonship... + } + + @Override + public void partChanged() + { + super.partChanged(); + + if ( interestedInIC2() ) + addToENet(); + else + removeFromENet(); + } + + @Override + public boolean emitsEnergyTo(TileEntity receiver, ForgeDirection direction) + { + if ( !isInIC2() ) + return false; + + IPart part = getPart( direction ); + if ( part instanceof IEnergySink ) + return ((IEnergyEmitter) part).emitsEnergyTo( receiver, direction ); + return false; + } + + @Override + public double getOfferedEnergy() + { + if ( !isInIC2() ) + return 0; + + // this is a flawed implementation, that requires a change to the IC2 API. + + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergySource ) + { + // use lower number cause ic2 deletes power it sends that isn't recieved. + 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 (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) + { + IPart part = getPart( dir ); + if ( part instanceof IEnergySource ) + { + ((IEnergySource) part).drawEnergy( amount ); + return; + } + } + } + +} diff --git a/parts/layers/LayerIFluidHandler.java b/parts/layers/LayerIFluidHandler.java new file mode 100644 index 00000000..ddc577a4 --- /dev/null +++ b/parts/layers/LayerIFluidHandler.java @@ -0,0 +1,69 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; +import net.minecraftforge.fluids.IFluidHandler; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; + +public class LayerIFluidHandler extends LayerBase implements IFluidHandler +{ + + static final FluidTankInfo[] emptyList = new FluidTankInfo[0]; + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).fill( from, resource, doFill ); + return 0; + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).drain( from, resource, doDrain ); + return null; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).drain( from, maxDrain, doDrain ); + return null; + } + + @Override + public boolean canFill(ForgeDirection from, net.minecraftforge.fluids.Fluid fluid) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).canFill( from, fluid ); + return false; + } + + @Override + public boolean canDrain(ForgeDirection from, net.minecraftforge.fluids.Fluid fluid) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).canDrain( from, fluid ); + return false; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) + { + IPart part = getPart( from ); + if ( part instanceof IFluidHandler ) + return ((IFluidHandler) part).getTankInfo( from ); + return emptyList; + } + +} diff --git a/parts/layers/LayerIPipeConnection.java b/parts/layers/LayerIPipeConnection.java new file mode 100644 index 00000000..8247706b --- /dev/null +++ b/parts/layers/LayerIPipeConnection.java @@ -0,0 +1,21 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import buildcraft.api.transport.IPipeConnection; +import buildcraft.api.transport.IPipeTile.PipeType; + +public class LayerIPipeConnection extends LayerBase implements IPipeConnection +{ + + @Override + public ConnectOverride overridePipeConnection(PipeType type, ForgeDirection with) + { + IPart part = getPart( with ); + if ( part instanceof IPipeConnection ) + return ((IPipeConnection) part).overridePipeConnection( type, with ); + return ConnectOverride.DEFAULT; + } + +} diff --git a/parts/layers/LayerIPowerEmitter.java b/parts/layers/LayerIPowerEmitter.java new file mode 100644 index 00000000..269c07ff --- /dev/null +++ b/parts/layers/LayerIPowerEmitter.java @@ -0,0 +1,19 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import buildcraft.api.power.IPowerEmitter; + +public class LayerIPowerEmitter extends LayerBase implements IPowerEmitter +{ + + @Override + public boolean canEmitPowerFrom(ForgeDirection side) + { + IPart part = getPart( side ); + if ( part instanceof IPowerEmitter ) + return ((IPowerEmitter) part).canEmitPowerFrom( side ); + return false; + } +} diff --git a/parts/layers/LayerIPowerReceptor.java b/parts/layers/LayerIPowerReceptor.java new file mode 100644 index 00000000..b90127a5 --- /dev/null +++ b/parts/layers/LayerIPowerReceptor.java @@ -0,0 +1,36 @@ +package appeng.parts.layers; + +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.api.parts.LayerBase; +import buildcraft.api.power.IPowerReceptor; +import buildcraft.api.power.PowerHandler; +import buildcraft.api.power.PowerHandler.PowerReceiver; + +public class LayerIPowerReceptor extends LayerBase implements IPowerReceptor +{ + + @Override + public PowerReceiver getPowerReceiver(ForgeDirection side) + { + IPart part = getPart( side ); + if ( part instanceof IPowerReceptor ) + return ((IPowerReceptor) part).getPowerReceiver( side ); + return null; + } + + @Override + public void doWork(PowerHandler workProvider) + { + // do nothing, this seems pointless. + } + + @Override + public World getWorld() + { + return ((IPartHost) this).getTile().getWorldObj(); + } + +} diff --git a/parts/layers/LayerISidedInventory.java b/parts/layers/LayerISidedInventory.java new file mode 100644 index 00000000..2b6494ad --- /dev/null +++ b/parts/layers/LayerISidedInventory.java @@ -0,0 +1,228 @@ +package appeng.parts.layers; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.parts.IPart; +import appeng.api.parts.IPartHost; +import appeng.api.parts.LayerBase; + +/** + * Inventory wrapper for parts, + * + * this is considerably more complicated then the other wrappers as it requires creating a "unified inventory". + * + * You must use {@link ISidedInventory} instead of {@link IInventory}. + * + * If your inventory changes in between placement and removal, you must trigger a PartChange on the {@link IPartHost} so + * it can recalculate the inventory wrapper. + */ +public class LayerISidedInventory extends LayerBase implements ISidedInventory +{ + + // a simple empty array for empty stuff.. + private final static int[] nullSides = new int[] {}; + + // cache of inventory state. + private int sides[][] = null; + private List invs = null; + private List slots = null; + + /** + * Recalculate inventory wrapper cache. + */ + @Override + public void partChanged() + { + invs = new ArrayList(); + int slotCount = 0; + + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + { + IPart bp = getPart( side ); + if ( bp instanceof ISidedInventory ) + { + ISidedInventory part = (ISidedInventory) bp; + slotCount += part.getSizeInventory(); + invs.add( part ); + } + } + + if ( invs.isEmpty() || slotCount == 0 ) + { + invs = null; + sides = null; + slots = null; + } + else + { + sides = new int[][] { nullSides, nullSides, nullSides, nullSides, nullSides, nullSides }; + slots = new ArrayList( Collections.nCopies( slotCount, (InvSot) null ) ); + + int offsetForLayer = 0; + int offsetForPart = 0; + for (ISidedInventory sides : invs) + { + offsetForPart = 0; + slotCount = sides.getSizeInventory(); + + ForgeDirection currentSide = ForgeDirection.UNKNOWN; + for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS) + if ( getPart( side ) == sides ) + { + currentSide = side; + break; + } + + int cSidesList[] = this.sides[currentSide.ordinal()] = new int[slotCount]; + for (int cSlot = 0; cSlot < slotCount; cSlot++) + { + cSidesList[cSlot] = offsetForLayer; + slots.set( offsetForLayer++, new InvSot( sides, offsetForPart++ ) ); + } + } + } + + // make sure inventory is updated before we call FMP. + super.partChanged(); + } + + /** + * check if a slot index is valid, prevent crashes from bad code :) + * + * @param slot + * @return true, if the slot exists. + */ + boolean isSlotValid(int slot) + { + return slots != null && slot >= 0 && slot < slots.size(); + } + + @Override + public ItemStack decrStackSize(int slot, int amount) + { + if ( isSlotValid( slot ) ) + return slots.get( slot ).decrStackSize( amount ); + + return null; + } + + @Override + public int getSizeInventory() + { + if ( slots == null ) + return 0; + + return slots.size(); + } + + @Override + public ItemStack getStackInSlot(int slot) + { + if ( isSlotValid( slot ) ) + return slots.get( slot ).getStackInSlot(); + + return null; + } + + @Override + public boolean isItemValidForSlot(int slot, ItemStack itemstack) + { + if ( isSlotValid( slot ) ) + return slots.get( slot ).isItemValidForSlot( itemstack ); + + return false; + } + + @Override + public void setInventorySlotContents(int slot, ItemStack itemstack) + { + if ( isSlotValid( slot ) ) + slots.get( slot ).setInventorySlotContents( itemstack ); + } + + @Override + public boolean canExtractItem(int slot, ItemStack itemstack, int side) + { + if ( isSlotValid( slot ) ) + return slots.get( slot ).canExtractItem( itemstack, side ); + + return false; + } + + @Override + public boolean canInsertItem(int slot, ItemStack itemstack, int side) + { + if ( isSlotValid( slot ) ) + return slots.get( slot ).canInsertItem( itemstack, side ); + + return false; + } + + @Override + public void markDirty() + { + super.markForSave(); + + if ( invs != null ) + { + for (IInventory inv : invs) + inv.markDirty(); + } + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) + { + if ( sides == null || side < 0 || side > 5 ) + return nullSides; + return sides[side]; + } + + @Override + public int getInventoryStackLimit() + { + return 64; // no options here. + } + + @Override + public String getInventoryName() + { + return "AEMultiPart"; + } + + @Override + public boolean hasCustomInventoryName() + { + return false; + } + + @Override + public ItemStack getStackInSlotOnClosing(int slot) + { + return null; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer entityplayer) + { + return false; + } + + @Override + public void closeInventory() + { + } + + @Override + public void openInventory() + { + } + +} diff --git a/parts/layers/LayerITileStorageMonitorable.java b/parts/layers/LayerITileStorageMonitorable.java new file mode 100644 index 00000000..b3cd40bb --- /dev/null +++ b/parts/layers/LayerITileStorageMonitorable.java @@ -0,0 +1,22 @@ +package appeng.parts.layers; + +import net.minecraftforge.common.util.ForgeDirection; +import appeng.api.implementations.tiles.ITileStorageMonitorable; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.parts.IPart; +import appeng.api.parts.LayerBase; +import appeng.api.storage.IStorageMonitorable; + +public class LayerITileStorageMonitorable extends LayerBase implements ITileStorageMonitorable +{ + + @Override + public IStorageMonitorable getMonitorable(ForgeDirection side, BaseActionSource src) + { + IPart part = getPart( side ); + if ( part instanceof ITileStorageMonitorable ) + return ((ITileStorageMonitorable) part).getMonitorable( side, src ); + return null; + } + +} diff --git a/tile/qnb/TileQuantumBridge.java b/tile/qnb/TileQuantumBridge.java index 8258bb37..201f9192 100644 --- a/tile/qnb/TileQuantumBridge.java +++ b/tile/qnb/TileQuantumBridge.java @@ -31,6 +31,8 @@ import appeng.util.Platform; public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock { + final private static ItemStack ring = AEApi.instance().blocks().blockQuantumRing.stack(1); + final int sidesRing[] = new int[] {}; final int sidesLink[] = new int[] { 0 }; @@ -147,6 +149,14 @@ public class TileQuantumBridge extends AENetworkInvTile implements IAEMultiBlock { return !isInvalid(); } + + @Override + public void onReady() + { + super.onReady(); + if ( worldObj.getBlock( xCoord, yCoord, zCoord) == AEApi.instance().blocks().blockQuantumRing.block() ) + gridProxy.setVisualRepresentation( ring ); + } public void updateStatus(QuantumCluster c, byte flags) { diff --git a/util/item/AEItemStack.java b/util/item/AEItemStack.java index 64e7d3f8..1af8d3ce 100644 --- a/util/item/AEItemStack.java +++ b/util/item/AEItemStack.java @@ -53,7 +53,10 @@ public final class AEItemStack extends AEStack implements IAEItemS def = new AEItemDef(); def.item = is.getItem(); - + + if ( def.item == null ) + throw new RuntimeException( "This ItemStack is bad, it has a null item." ); + /* * Prevent an Item from changing the damage value on me... Either, this or a core mod. */ diff --git a/util/item/OreHelper.java b/util/item/OreHelper.java index 2bb61936..802b7f25 100644 --- a/util/item/OreHelper.java +++ b/util/item/OreHelper.java @@ -98,7 +98,8 @@ public class OreHelper // SUMMON AE STACKS! for (ItemStack is : set) - aeset.add( AEItemStack.create( is ) ); + if ( is.getItem() != null ) + aeset.add( AEItemStack.create( is ) ); } }