dave/refinedstorage
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

initial 1.8 port

Browse Source
This commit is contained in:
Raoul Van den Berge
2015-12-25 18:51:58 +01:00
parent 8acd72fffc
commit 6c3c113521
74 changed files with 6796 additions and 7094 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/main/java/cofh/api/CoFHAPIProps.java
View File

@@ -1,11 +0,0 @@
package cofh.api;
public class CoFHAPIProps {
private CoFHAPIProps() {
}
public static final String VERSION = "1.7.10R1.0.2";
}

4
src/main/java/cofh/api/energy/IEnergyConnection.java
View File

@@ -1,6 +1,6 @@
package cofh.api.energy;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraft.util.EnumFacing;
/**
* Implement this interface on TileEntities which should connect to energy transportation blocks. This is intended for blocks which generate energy but do not
@@ -16,6 +16,6 @@ public interface IEnergyConnection {
/**
* Returns TRUE if the TileEntity can connect on a given side.
*/
boolean canConnectEnergy(ForgeDirection from);
boolean canConnectEnergy(EnumFacing facing);
}

11
src/main/java/cofh/api/energy/IEnergyHandler.java
View File

@@ -1,6 +1,7 @@
package cofh.api.energy;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraft.util.EnumFacing;
/**
* Implement this interface on Tile Entities which should handle energy, generally storing it in one or more internal {@link IEnergyStorage} objects.
@@ -26,7 +27,7 @@ public interface IEnergyHandler extends IEnergyProvider, IEnergyReceiver {
* @return Amount of energy that was (or would have been, if simulated) received.
*/
@Override
int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate);
int receiveEnergy(EnumFacing facing, int maxReceive, boolean simulate);
/**
* Remove energy from an IEnergyProvider, internal distribution is left entirely to the IEnergyProvider.
@@ -40,19 +41,19 @@ public interface IEnergyHandler extends IEnergyProvider, IEnergyReceiver {
* @return Amount of energy that was (or would have been, if simulated) extracted.
*/
@Override
int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate);
int extractEnergy(EnumFacing facing, int maxExtract, boolean simulate);
/**
* Returns the amount of energy currently stored.
*/
@Override
int getEnergyStored(ForgeDirection from);
int getEnergyStored(EnumFacing facing);
/**
* Returns the maximum amount of energy that can be stored.
*/
@Override
int getMaxEnergyStored(ForgeDirection from);
int getMaxEnergyStored(EnumFacing facing);
}

9
src/main/java/cofh/api/energy/IEnergyProvider.java
View File

@@ -1,6 +1,7 @@
package cofh.api.energy;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraft.util.EnumFacing;
/**
* Implement this interface on Tile Entities which should provide energy, generally storing it in one or more internal {@link IEnergyStorage} objects.
@@ -23,16 +24,16 @@ public interface IEnergyProvider extends IEnergyConnection {
* If TRUE, the extraction will only be simulated.
* @return Amount of energy that was (or would have been, if simulated) extracted.
*/
int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate);
int extractEnergy(EnumFacing facing, int maxExtract, boolean simulate);
/**
* Returns the amount of energy currently stored.
*/
int getEnergyStored(ForgeDirection from);
int getEnergyStored(EnumFacing facing);
/**
* Returns the maximum amount of energy that can be stored.
*/
int getMaxEnergyStored(ForgeDirection from);
int getMaxEnergyStored(EnumFacing facing);
}

9
src/main/java/cofh/api/energy/IEnergyReceiver.java
View File

@@ -1,6 +1,7 @@
package cofh.api.energy;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraft.util.EnumFacing;
/**
* Implement this interface on Tile Entities which should receive energy, generally storing it in one or more internal {@link IEnergyStorage} objects.
@@ -23,16 +24,16 @@ public interface IEnergyReceiver extends IEnergyConnection {
* If TRUE, the charge will only be simulated.
* @return Amount of energy that was (or would have been, if simulated) received.
*/
int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate);
int receiveEnergy(EnumFacing facing, int maxReceive, boolean simulate);
/**
* Returns the amount of energy currently stored.
*/
int getEnergyStored(ForgeDirection from);
int getEnergyStored(EnumFacing facing);
/**
* Returns the maximum amount of energy that can be stored.
*/
int getMaxEnergyStored(ForgeDirection from);
int getMaxEnergyStored(EnumFacing facing);
}

18
src/main/java/cofh/api/energy/ItemEnergyContainer.java
View File

@@ -63,15 +63,15 @@ public class ItemEnergyContainer extends Item implements IEnergyContainerItem {
@Override
public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate) {
if (container.stackTagCompound == null) {
container.stackTagCompound = new NBTTagCompound();
if (container.getTagCompound() == null) {
container.setTagCompound(new NBTTagCompound());
}
int energy = container.stackTagCompound.getInteger("Energy");
int energy = container.getTagCompound().getInteger("Energy");
int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive));
if (!simulate) {
energy += energyReceived;
container.stackTagCompound.setInteger("Energy", energy);
container.getTagCompound().setInteger("Energy", energy);
}
return energyReceived;
}
@@ -79,15 +79,15 @@ public class ItemEnergyContainer extends Item implements IEnergyContainerItem {
@Override
public int extractEnergy(ItemStack container, int maxExtract, boolean simulate) {
if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) {
if (container.getTagCompound() == null || !container.getTagCompound().hasKey("Energy")) {
return 0;
}
int energy = container.stackTagCompound.getInteger("Energy");
int energy = container.getTagCompound().getInteger("Energy");
int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
if (!simulate) {
energy -= energyExtracted;
container.stackTagCompound.setInteger("Energy", energy);
container.getTagCompound().setInteger("Energy", energy);
}
return energyExtracted;
}
@@ -95,10 +95,10 @@ public class ItemEnergyContainer extends Item implements IEnergyContainerItem {
@Override
public int getEnergyStored(ItemStack container) {
if (container.stackTagCompound == null || !container.stackTagCompound.hasKey("Energy")) {
if (container.getTagCompound() == null || !container.getTagCompound().hasKey("Energy")) {
return 0;
}
return container.stackTagCompound.getInteger("Energy");
return container.getTagCompound().getInteger("Energy");
}
@Override

12
src/main/java/cofh/api/energy/TileEnergyHandler.java
View File

@@ -2,7 +2,7 @@ package cofh.api.energy;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraft.util.EnumFacing;
/**
* Reference implementation of {@link IEnergyHandler}. Use/extend this or implement your own.
@@ -30,34 +30,34 @@ public class TileEnergyHandler extends TileEntity implements IEnergyHandler {
/* IEnergyConnection */
@Override
public boolean canConnectEnergy(ForgeDirection from) {
public boolean canConnectEnergy(EnumFacing facing) {
return true;
}
/* IEnergyReceiver */
@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {
public int receiveEnergy(EnumFacing facing, int maxReceive, boolean simulate) {
return storage.receiveEnergy(maxReceive, simulate);
}
/* IEnergyProvider */
@Override
public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) {
public int extractEnergy(EnumFacing facing, int maxExtract, boolean simulate) {
return storage.extractEnergy(maxExtract, simulate);
}
/* IEnergyReceiver and IEnergyProvider */
@Override
public int getEnergyStored(ForgeDirection from) {
public int getEnergyStored(EnumFacing facing) {
return storage.getEnergyStored();
}
@Override
public int getMaxEnergyStored(ForgeDirection from) {
public int getMaxEnergyStored(EnumFacing facing) {
return storage.getMaxEnergyStored();
}

10
src/main/java/cofh/api/energy/package-info.java
View File

@@ -1,10 +0,0 @@
/**
* (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
* http://www.teamcofh.com
*/
@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHAPI", provides = "CoFHAPI|energy")
package cofh.api.energy;
import cofh.api.CoFHAPIProps;
import cpw.mods.fml.common.API;

9
src/main/java/cofh/api/package-info.java
View File

@@ -1,9 +0,0 @@
/**
* (C) 2014 Team CoFH / CoFH / Cult of the Full Hub
* http://www.teamcofh.com
*/
@API(apiVersion = CoFHAPIProps.VERSION, owner = "CoFHLib", provides = "CoFHAPI")
package cofh.api;
import cpw.mods.fml.common.API;

18
src/main/java/storagecraft/StorageCraft.java
View File

@@ -1,17 +1,17 @@
package storagecraft;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.Mod.Instance;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.Mod.EventHandler;
import net.minecraftforge.fml.common.Mod.Instance;
import net.minecraftforge.fml.common.SidedProxy;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.network.NetworkRegistry;
import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
import storagecraft.item.ItemStorageCell;
import storagecraft.proxy.CommonProxy;

179
src/main/java/storagecraft/block/BlockBase.java
View File

@@ -1,92 +1,87 @@
package storagecraft.block;
import net.minecraft.block.Block;
import net.minecraft.block.BlockPistonBase;
import net.minecraft.block.material.Material;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import storagecraft.StorageCraft;
import storagecraft.tile.TileBase;
import storagecraft.util.InventoryUtils;
public abstract class BlockBase extends Block
{
private String name;
public BlockBase(String name)
{
super(Material.rock);
this.name = name;
setCreativeTab(StorageCraft.TAB);
setBlockTextureName("storagecraft:" + name);
}
@Override
public String getUnlocalizedName()
{
return "block." + StorageCraft.ID + ":" + name;
}
@Override
public boolean rotateBlock(World world, int x, int y, int z, ForgeDirection axis)
{
TileEntity tile = world.getTileEntity(x, y, z);
if (tile instanceof TileBase)
{
ForgeDirection dir = ((TileBase) tile).getDirection();
int newDir = dir.ordinal() + 1;
if (newDir > ForgeDirection.VALID_DIRECTIONS.length - 1)
{
newDir = 0;
}
((TileBase) tile).setDirection(ForgeDirection.getOrientation(newDir));
world.markBlockForUpdate(x, y, z);
return true;
}
return false;
}
@Override
public int damageDropped(int meta)
{
return meta;
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entityLiving, ItemStack itemStack)
{
super.onBlockPlacedBy(world, x, y, z, entityLiving, itemStack);
TileEntity tile = world.getTileEntity(x, y, z);
if (tile instanceof TileBase)
{
((TileBase) tile).setDirection(ForgeDirection.getOrientation(BlockPistonBase.determineOrientation(world, x, y, z, entityLiving)));
}
}
@Override
public void onBlockPreDestroy(World world, int x, int y, int z, int meta)
{
TileEntity tile = world.getTileEntity(x, y, z);
if (tile instanceof TileBase && ((TileBase) tile).getDroppedInventory() != null)
{
InventoryUtils.dropInventory(world, ((TileBase) tile).getDroppedInventory(), x, y, z);
}
super.onBlockPreDestroy(world, x, y, z, meta);
}
}
package storagecraft.block;
import net.minecraft.block.Block;
import net.minecraft.block.BlockPistonBase;
import net.minecraft.block.material.Material;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.tile.TileBase;
import storagecraft.util.InventoryUtils;
public abstract class BlockBase extends Block
{
private String name;
public BlockBase(String name)
{
super(Material.rock);
this.name = name;
setCreativeTab(StorageCraft.TAB);
}
@Override
public String getUnlocalizedName()
{
return "block." + StorageCraft.ID + ":" + name;
}
@Override
public boolean rotateBlock(World world, BlockPos pos, EnumFacing axis)
{
TileEntity tile = world.getTileEntity(pos);
if (tile instanceof TileBase)
{
EnumFacing dir = ((TileBase) tile).getDirection();
int newDir = dir.ordinal() + 1;
if (newDir > EnumFacing.VALUES.length - 1)
{
newDir = 0;
}
((TileBase) tile).setDirection(EnumFacing.getFront(newDir));
world.markBlockForUpdate(pos);
return true;
}
return false;
}
@Override
public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase player, ItemStack itemStack)
{
super.onBlockPlacedBy(world, pos, state, player, itemStack);
TileEntity tile = world.getTileEntity(pos);
if (tile instanceof TileBase)
{
((TileBase) tile).setDirection(BlockPistonBase.func_180695_a(world, pos, player));
}
}
@Override
public void onBlockDestroyedByPlayer(World world, BlockPos pos, IBlockState state) // @TODO: Make this work all
{
TileEntity tile = world.getTileEntity(pos);
if (tile instanceof TileBase && ((TileBase) tile).getDroppedInventory() != null)
{
InventoryUtils.dropInventory(world, ((TileBase) tile).getDroppedInventory(), pos.getX(), pos.getY(), pos.getZ());
}
super.onBlockDestroyedByPlayer(world, pos, state);
}
}

123
src/main/java/storagecraft/block/BlockCable.java
View File

@@ -1,51 +1,72 @@
package storagecraft.block;
import java.util.List;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import storagecraft.tile.TileCable;
public class BlockCable extends BlockBase implements ITileEntityProvider
{
public BlockCable()
{
super("cable");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileCable();
}
@Override
public void getSubBlocks(Item item, CreativeTabs tab, List subItems)
{
for (int i = 0; i < 2; i++)
{
subItems.add(new ItemStack(item, 1, i));
}
}
@Override
public int getRenderType()
{
return -1;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
@Override
public boolean renderAsNormalBlock()
{
return false;
}
}
package storagecraft.block;
import java.util.List;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import storagecraft.tile.TileCable;
public class BlockCable extends BlockBase implements ITileEntityProvider
{
public static final PropertyBool SENSITIVE = PropertyBool.create("sensitive");
public BlockCable()
{
super("cable");
}
@Override
protected BlockState createBlockState()
{
return new BlockState(this, new IProperty[]
{
SENSITIVE
});
}
@Override
public IBlockState getStateFromMeta(int meta)
{
return getDefaultState().withProperty(SENSITIVE, meta);
}
@Override
public int getMetaFromState(IBlockState state)
{
return ((Boolean) state.getValue(SENSITIVE)) ? 0 : 1;
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileCable();
}
@Override
public void getSubBlocks(Item item, CreativeTabs tab, List subItems)
{
for (int i = 0; i < 2; i++)
{
subItems.add(new ItemStack(item, 1, i));
}
}
@Override
public int getRenderType()
{
return -1;
}
@Override
public boolean isOpaqueCube()
{
return false;
}
}

109
src/main/java/storagecraft/block/BlockConstructor.java
View File

@@ -1,73 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileConstructor;
public class BlockConstructor extends BlockBase implements ITileEntityProvider
{
private IIcon sideIcon;
private IIcon connectedIcon;
private IIcon disconnectedIcon;
public BlockConstructor()
{
super("constructor");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileConstructor();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.CONSTRUCTOR, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
connectedIcon = register.registerIcon("storagecraft:constructorConnected");
disconnectedIcon = register.registerIcon("storagecraft:constructorDisconnected");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileConstructor tile = (TileConstructor) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return tile.isConnected() ? connectedIcon : disconnectedIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int damage)
{
if (side == 3)
{
return disconnectedIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileConstructor;
public class BlockConstructor extends BlockMachine
{
public BlockConstructor()
{
super("constructor");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileConstructor();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.CONSTRUCTOR, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

182
src/main/java/storagecraft/block/BlockController.java
View File

@@ -1,97 +1,85 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileController;
public class BlockController extends BlockBase implements ITileEntityProvider
{
private IIcon sideIcon;
private IIcon[] icons = new IIcon[9];
public BlockController()
{
super("controller");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileController();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.CONTROLLER, world, x, y, z);
}
return true;
}
@Override
public void onBlockPreDestroy(World world, int x, int y, int z, int meta)
{
((TileController) world.getTileEntity(x, y, z)).onDestroyed();
super.onBlockPreDestroy(world, x, y, z, meta);
}
@Override
public boolean hasComparatorInputOverride()
{
return true;
}
@Override
public int getComparatorInputOverride(World world, int x, int y, int z, int side)
{
TileController tile = (TileController) world.getTileEntity(x, y, z);
return tile.getEnergyScaled(15);
}
@Override
public void registerBlockIcons(IIconRegister register)
{
for (int i = 0; i <= 8; ++i)
{
icons[i] = register.registerIcon("storagecraft:controller" + i);
}
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileController tile = (TileController) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return icons[tile.getEnergyScaled(8)];
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 3)
{
return icons[0];
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyInteger;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileController;
public class BlockController extends BlockBase implements ITileEntityProvider
{
public static final PropertyInteger ENERGY = PropertyInteger.create("energy", 0, 15);
public BlockController()
{
super("controller");
}
@Override
protected BlockState createBlockState()
{
return new BlockState(this, new IProperty[]
{
ENERGY
});
}
@Override
public IBlockState getStateFromMeta(int meta)
{
return getDefaultState().withProperty(ENERGY, meta);
}
@Override
public int getMetaFromState(IBlockState state)
{
return ((Integer) state.getValue(ENERGY));
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileController();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.CONTROLLER, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
@Override
public void onBlockDestroyedByPlayer(World world, BlockPos pos, IBlockState state) // @TODO: What about explosions?
{
((TileController) world.getTileEntity(pos)).onDestroyed();
super.onBlockDestroyedByPlayer(world, pos, state);
}
@Override
public boolean hasComparatorInputOverride()
{
return true;
}
@Override
public int getComparatorInputOverride(World world, BlockPos pos)
{
TileController tile = (TileController) world.getTileEntity(pos);
return tile.getEnergyScaled(15);
}
}

109
src/main/java/storagecraft/block/BlockDestructor.java
View File

@@ -1,73 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDestructor;
public class BlockDestructor extends BlockBase implements ITileEntityProvider
{
private IIcon sideIcon;
private IIcon connectedIcon;
private IIcon disconnectedIcon;
public BlockDestructor()
{
super("destructor");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDestructor();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DESTRUCTOR, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
connectedIcon = register.registerIcon("storagecraft:destructorConnected");
disconnectedIcon = register.registerIcon("storagecraft:destructorDisconnected");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileDestructor tile = (TileDestructor) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return tile.isConnected() ? connectedIcon : disconnectedIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int damage)
{
if (side == 3)
{
return disconnectedIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDestructor;
public class BlockDestructor extends BlockMachine
{
public BlockDestructor()
{
super("destructor");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDestructor();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DESTRUCTOR, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

130
src/main/java/storagecraft/block/BlockDetector.java
View File

@@ -1,93 +1,37 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDetector;
public class BlockDetector extends BlockBase implements ITileEntityProvider
{
private IIcon poweredIcon;
private IIcon unpoweredIcon;
private IIcon sideIcon;
public BlockDetector()
{
super("detector");
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DETECTOR, world, x, y, z);
}
return true;
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDetector();
}
@Override
public int isProvidingWeakPower(IBlockAccess world, int x, int y, int z, int side)
{
return isProvidingStrongPower(world, x, y, z, side);
}
@Override
public int isProvidingStrongPower(IBlockAccess world, int x, int y, int z, int side)
{
TileDetector detector = (TileDetector) world.getTileEntity(x, y, z);
return detector.providesPower() ? 15 : 0;
}
@Override
public boolean canProvidePower()
{
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
poweredIcon = register.registerIcon("storagecraft:detectorPowered");
unpoweredIcon = register.registerIcon("storagecraft:detectorUnpowered");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
if (side == 0 || side == 1)
{
return sideIcon;
}
TileDetector tile = (TileDetector) world.getTileEntity(x, y, z);
return tile.providesPower() ? poweredIcon : unpoweredIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 0 || side == 1)
{
return sideIcon;
}
return unpoweredIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDetector;
// @TODO: This too other textures
public class BlockDetector extends BlockMachine
{
public BlockDetector()
{
super("detector");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDetector();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DETECTOR, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

107
src/main/java/storagecraft/block/BlockDrive.java
View File

@@ -1,71 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDrive;
public class BlockDrive extends BlockBase implements ITileEntityProvider
{
private IIcon frontIcon;
private IIcon sideIcon;
public BlockDrive()
{
super("drive");
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DRIVE, world, x, y, z);
}
return true;
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDrive();
}
@Override
public void registerBlockIcons(IIconRegister register)
{
frontIcon = register.registerIcon("storagecraft:drive");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileDrive tile = (TileDrive) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return frontIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 3)
{
return frontIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileDrive;
public class BlockDrive extends BlockMachine
{
public BlockDrive()
{
super("drive");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileDrive();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.DRIVE, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

107
src/main/java/storagecraft/block/BlockExporter.java
View File

@@ -1,71 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileExporter;
public class BlockExporter extends BlockBase implements ITileEntityProvider
{
private IIcon frontIcon;
private IIcon sideIcon;
public BlockExporter()
{
super("exporter");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileExporter();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.EXPORTER, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
frontIcon = register.registerIcon("storagecraft:exporter");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileExporter tile = (TileExporter) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return frontIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 3)
{
return frontIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileExporter;
public class BlockExporter extends BlockMachine
{
public BlockExporter()
{
super("exporter");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileExporter();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.EXPORTER, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

107
src/main/java/storagecraft/block/BlockExternalStorage.java
View File

@@ -1,71 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileExternalStorage;
public class BlockExternalStorage extends BlockBase implements ITileEntityProvider
{
private IIcon frontIcon;
private IIcon sideIcon;
public BlockExternalStorage()
{
super("externalStorage");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileExternalStorage();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.EXTERNAL_STORAGE, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
frontIcon = register.registerIcon("storagecraft:externalStorage");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileExternalStorage tile = (TileExternalStorage) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return frontIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 3)
{
return frontIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileExternalStorage;
public class BlockExternalStorage extends BlockMachine
{
public BlockExternalStorage()
{
super("externalStorage");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileExternalStorage();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.EXTERNAL_STORAGE, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

122
src/main/java/storagecraft/block/BlockGrid.java
View File

@@ -1,86 +1,36 @@
package storagecraft.block;
import java.util.List;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileGrid;
public class BlockGrid extends BlockBase implements ITileEntityProvider
{
private IIcon sideIcon;
private IIcon connectedIcon;
private IIcon disconnectedIcon;
public BlockGrid()
{
super("grid");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileGrid();
}
@Override
public void getSubBlocks(Item item, CreativeTabs tab, List subItems)
{
for (int i = 0; i < 2; i++)
{
subItems.add(new ItemStack(item, 1, i));
}
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.GRID, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
connectedIcon = register.registerIcon("storagecraft:gridConnected");
disconnectedIcon = register.registerIcon("storagecraft:gridDisconnected");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileGrid tile = (TileGrid) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return tile.isConnected() ? connectedIcon : disconnectedIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int damage)
{
if (side == 3)
{
return disconnectedIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileGrid;
public class BlockGrid extends BlockMachine
{
public BlockGrid()
{
super("grid");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileGrid();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.GRID, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

107
src/main/java/storagecraft/block/BlockImporter.java
View File

@@ -1,71 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileImporter;
public class BlockImporter extends BlockBase implements ITileEntityProvider
{
private IIcon frontIcon;
private IIcon sideIcon;
public BlockImporter()
{
super("importer");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileImporter();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.IMPORTER, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
frontIcon = register.registerIcon("storagecraft:importer");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileImporter tile = (TileImporter) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return frontIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int meta)
{
if (side == 3)
{
return frontIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileImporter;
public class BlockImporter extends BlockMachine
{
public BlockImporter()
{
super("importer");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileImporter();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.IMPORTER, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

38
src/main/java/storagecraft/block/BlockMachine.java Normal file
View File

@@ -0,0 +1,38 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.block.properties.IProperty;
import net.minecraft.block.properties.PropertyBool;
import net.minecraft.block.state.BlockState;
import net.minecraft.block.state.IBlockState;
public abstract class BlockMachine extends BlockBase implements ITileEntityProvider
{
public static final PropertyBool CONNECTED = PropertyBool.create("connected");
public BlockMachine(String name)
{
super(name);
}
@Override
protected BlockState createBlockState()
{
return new BlockState(this, new IProperty[]
{
CONNECTED
});
}
@Override
public IBlockState getStateFromMeta(int meta)
{
return getDefaultState().withProperty(CONNECTED, meta);
}
@Override
public int getMetaFromState(IBlockState state)
{
return ((Boolean) state.getValue(CONNECTED)) ? 0 : 1;
}
}

42
src/main/java/storagecraft/block/BlockMachineCasing.java
View File

@@ -1,33 +1,9 @@
package storagecraft.block;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class BlockMachineCasing extends BlockBase
{
private IIcon icon;
public BlockMachineCasing()
{
super("machineCasing");
}
@Override
public void registerBlockIcons(IIconRegister register)
{
icon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
return icon;
}
@Override
public IIcon getIcon(int side, int meta)
{
return icon;
}
}
package storagecraft.block;
public class BlockMachineCasing extends BlockBase
{
public BlockMachineCasing()
{
super("machineCasing");
}
}

109
src/main/java/storagecraft/block/BlockSolderer.java
View File

@@ -1,73 +1,36 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileSolderer;
public class BlockSolderer extends BlockBase implements ITileEntityProvider
{
private IIcon sideIcon;
private IIcon connectedIcon;
private IIcon disconnectedIcon;
public BlockSolderer()
{
super("solderer");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileSolderer();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.SOLDERER, world, x, y, z);
}
return true;
}
@Override
public void registerBlockIcons(IIconRegister register)
{
connectedIcon = register.registerIcon("storagecraft:soldererConnected");
disconnectedIcon = register.registerIcon("storagecraft:soldererDisconnected");
sideIcon = register.registerIcon("storagecraft:side");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileSolderer tile = (TileSolderer) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return tile.isConnected() ? connectedIcon : disconnectedIcon;
}
return sideIcon;
}
@Override
public IIcon getIcon(int side, int damage)
{
if (side == 3)
{
return disconnectedIcon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileSolderer;
public class BlockSolderer extends BlockMachine
{
public BlockSolderer()
{
super("solderer");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileSolderer();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.SOLDERER, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

112
src/main/java/storagecraft/block/BlockWirelessTransmitter.java
View File

@@ -1,75 +1,37 @@
package storagecraft.block;
import net.minecraft.block.ITileEntityProvider;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileWirelessTransmitter;
public class BlockWirelessTransmitter extends BlockBase implements ITileEntityProvider
{
private IIcon icon;
private IIcon workingIcon;
private IIcon sideIcon;
private IIcon workingSideIcon;
public BlockWirelessTransmitter()
{
super("wirelessTransmitter");
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.WIRELESS_TRANSMITTER, world, x, y, z);
}
return true;
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileWirelessTransmitter();
}
@Override
public void registerBlockIcons(IIconRegister register)
{
icon = register.registerIcon("storagecraft:wirelessTransmitter");
workingIcon = register.registerIcon("storagecraft:wirelessTransmitterWorking");
sideIcon = register.registerIcon("storagecraft:wirelessTransmitterSide");
workingSideIcon = register.registerIcon("storagecraft:wirelessTransmitterSideWorking");
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side)
{
TileWirelessTransmitter tile = (TileWirelessTransmitter) world.getTileEntity(x, y, z);
if (side == tile.getDirection().ordinal())
{
return tile.isWorking() ? workingIcon : icon;
}
return tile.isWorking() ? workingSideIcon : sideIcon;
}
@Override
public IIcon getIcon(int side, int damage)
{
if (side == 3)
{
return icon;
}
return sideIcon;
}
}
package storagecraft.block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileWirelessTransmitter;
// @TODO: This texture behaves differently
public class BlockWirelessTransmitter extends BlockMachine
{
public BlockWirelessTransmitter()
{
super("wirelessTransmitter");
}
@Override
public TileEntity createNewTileEntity(World world, int meta)
{
return new TileWirelessTransmitter();
}
@Override
public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumFacing side, float hitX, float hitY, float hitZ)
{
if (!world.isRemote)
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.WIRELESS_TRANSMITTER, world, pos.getX(), pos.getY(), pos.getZ());
}
return true;
}
}

79
src/main/java/storagecraft/container/slot/SlotGridCraftingResult.java
View File

@@ -1,39 +1,40 @@
package storagecraft.container.slot;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.SlotCrafting;
import net.minecraft.item.ItemStack;
import storagecraft.tile.TileGrid;
public class SlotGridCraftingResult extends SlotCrafting
{
private IInventory craftingMatrix;
private TileGrid grid;
public SlotGridCraftingResult(EntityPlayer player, IInventory craftingMatrix, IInventory craftingResult, TileGrid grid, int id, int x, int y)
{
super(player, craftingMatrix, craftingResult, id, x, y);
this.craftingMatrix = craftingMatrix;
this.grid = grid;
}
@Override
public void onPickupFromSlot(EntityPlayer player, ItemStack stack)
{
ItemStack[] matrixSlots = new ItemStack[craftingMatrix.getSizeInventory()];
for (int i = 0; i < craftingMatrix.getSizeInventory(); ++i)
{
if (craftingMatrix.getStackInSlot(i) != null)
{
matrixSlots[i] = craftingMatrix.getStackInSlot(i).copy();
}
}
super.onPickupFromSlot(player, stack);
grid.onCrafted(matrixSlots);
}
}
package storagecraft.container.slot;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.inventory.SlotCrafting;
import net.minecraft.item.ItemStack;
import storagecraft.tile.TileGrid;
public class SlotGridCraftingResult extends SlotCrafting
{
private IInventory craftingMatrix;
private TileGrid grid;
public SlotGridCraftingResult(EntityPlayer player, InventoryCrafting craftingMatrix, IInventory craftingResult, TileGrid grid, int id, int x, int y)
{
super(player, craftingMatrix, craftingResult, id, x, y);
this.craftingMatrix = craftingMatrix;
this.grid = grid;
}
@Override
public void onPickupFromSlot(EntityPlayer player, ItemStack stack)
{
ItemStack[] matrixSlots = new ItemStack[craftingMatrix.getSizeInventory()];
for (int i = 0; i < craftingMatrix.getSizeInventory(); ++i)
{
if (craftingMatrix.getStackInSlot(i) != null)
{
matrixSlots[i] = craftingMatrix.getStackInSlot(i).copy();
}
}
super.onPickupFromSlot(player, stack);
grid.onCrafted(matrixSlots);
}
}

611
src/main/java/storagecraft/gui/GuiBase.java
View File

@@ -1,306 +1,305 @@
package storagecraft.gui;
import com.google.common.base.Joiner;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.inventory.Container;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StatCollector;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import storagecraft.StorageCraft;
import storagecraft.gui.sidebutton.SideButton;
public abstract class GuiBase extends GuiContainer
{
public static final int SIDE_BUTTON_WIDTH = 20;
public static final int SIDE_BUTTON_HEIGHT = 20;
private List<SideButton> sideButtons = new ArrayList<SideButton>();
private int lastButtonId = 0;
private int lastSideButtonY = 6;
public GuiBase(Container container, int w, int h)
{
super(container);
this.xSize = w;
this.ySize = h;
}
@Override
public void initGui()
{
super.initGui();
sideButtons.clear();
lastButtonId = 0;
lastSideButtonY = 6;
init(guiLeft, guiTop);
}
@Override
public void updateScreen()
{
super.updateScreen();
update(guiLeft, guiTop);
}
@Override
protected void drawGuiContainerBackgroundLayer(float renderPartialTicks, int mouseX, int mouseY)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
drawBackground(guiLeft, guiTop, mouseX, mouseY);
}
@Override
protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
mouseX -= guiLeft;
mouseY -= guiTop;
for (SideButton sideButton : sideButtons)
{
sideButton.draw(this, sideButton.getX() + 2, sideButton.getY() + 1);
if (inBounds(sideButton.getX(), sideButton.getY(), SIDE_BUTTON_WIDTH, SIDE_BUTTON_HEIGHT, mouseX, mouseY))
{
drawTooltip(mouseX, mouseY, sideButton.getTooltip(this));
}
}
drawForeground(mouseX, mouseY);
}
@Override
protected void actionPerformed(GuiButton button)
{
super.actionPerformed(button);
for (SideButton sideButton : sideButtons)
{
if (sideButton.getId() == button.id)
{
sideButton.actionPerformed();
}
}
}
public GuiButton addButton(int x, int y, int w, int h)
{
return addButton(x, y, w, h, "");
}
public GuiButton addButton(int x, int y, int w, int h, String text)
{
GuiButton button = new GuiButton(lastButtonId++, x, y, w, h, text);
buttonList.add(button);
return button;
}
public void addSideButton(SideButton button)
{
button.setX(xSize - 1);
button.setY(lastSideButtonY);
button.setId(addButton(guiLeft + button.getX(), guiTop + button.getY(), SIDE_BUTTON_WIDTH, SIDE_BUTTON_HEIGHT).id);
lastSideButtonY += SIDE_BUTTON_HEIGHT + 4;
sideButtons.add(button);
}
public boolean inBounds(int x, int y, int w, int h, int ox, int oy)
{
return ox >= x && ox <= x + w && oy >= y && oy <= y + h;
}
public void bindTexture(String file)
{
bindTexture(StorageCraft.ID, file);
}
public void bindTexture(String base, String file)
{
mc.getTextureManager().bindTexture(new ResourceLocation(base, "textures/" + file));
}
public void drawItem(int x, int y, ItemStack stack)
{
drawItem(x, y, stack, false);
}
public void drawItem(int x, int y, ItemStack stack, boolean withOverlay)
{
zLevel = 100;
itemRender.zLevel = 100;
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableGUIStandardItemLighting();
itemRender.renderItemAndEffectIntoGUI(fontRendererObj, mc.renderEngine, stack, x, y);
if (withOverlay)
{
itemRender.renderItemOverlayIntoGUI(fontRendererObj, mc.renderEngine, stack, x, y);
}
GL11.glPopAttrib();
itemRender.zLevel = 0;
zLevel = 0;
}
public void drawString(int x, int y, String message)
{
drawString(x, y, message, 4210752);
}
public void drawString(int x, int y, String message, int color)
{
fontRendererObj.drawString(message, x, y, color);
}
// https://github.com/AppliedEnergistics/Applied-Energistics-2/blob/master/src/main/java/appeng/client/gui/AEBaseGui.java
public void drawTooltip(int x, int y, String message)
{
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
String[] lines = message.split("\n");
if (lines.length > 0)
{
int var5 = 0;
int var6;
int var7;
for (var6 = 0; var6 < lines.length; ++var6)
{
var7 = this.fontRendererObj.getStringWidth(lines[var6]);
if (var7 > var5)
{
var5 = var7;
}
}
var6 = x + 12;
var7 = y - 12;
int var9 = 8;
if (lines.length > 1)
{
var9 += 2 + (lines.length - 1) * 10;
}
if (this.guiTop + var7 + var9 + 6 > this.height)
{
var7 = this.height - var9 - this.guiTop - 6;
}
zLevel = 300.0F;
itemRender.zLevel = 300.0F;
int var10 = -267386864;
drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, var10, var10);
drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, var7 + var9 + 4, var10, var10);
drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 + var9 + 3, var10, var10);
drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, var10, var10);
drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, var7 + var9 + 3, var10, var10);
int var11 = 1347420415;
int var12 = (var11 & 16711422) >> 1 | var11 & -16777216;
drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, var7 + var9 + 3 - 1, var11, var12);
drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, var7 + var9 + 3 - 1, var11, var12);
drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, var11, var11);
drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, var7 + var9 + 3, var12, var12);
for (int var13 = 0; var13 < lines.length; ++var13)
{
String var14 = lines[var13];
if (var13 == 0)
{
var14 = '\u00a7' + Integer.toHexString(15) + var14;
}
else
{
var14 = "\u00a77" + var14;
}
fontRendererObj.drawStringWithShadow(var14, var6, var7, -1);
if (var13 == 0)
{
var7 += 2;
}
var7 += 10;
}
zLevel = 0.0F;
itemRender.zLevel = 0.0F;
}
GL11.glPopAttrib();
}
public void drawTooltip(int x, int y, ItemStack stack)
{
List list = stack.getTooltip(mc.thePlayer, mc.gameSettings.advancedItemTooltips);
for (int i = 0; i < list.size(); ++i)
{
if (i == 0)
{
list.set(i, stack.getRarity().rarityColor + (String) list.get(i));
}
else
{
list.set(i, EnumChatFormatting.GRAY + (String) list.get(i));
}
}
drawTooltip(x, y, Joiner.on("\n").join(list));
}
public String t(String name, Object... format)
{
return StatCollector.translateToLocalFormatted(name, format);
}
public abstract void init(int x, int y);
public abstract void update(int x, int y);
public abstract void drawBackground(int x, int y, int mouseX, int mouseY);
public abstract void drawForeground(int mouseX, int mouseY);
}
package storagecraft.gui;
import com.google.common.base.Joiner;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.inventory.Container;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumChatFormatting;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StatCollector;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import storagecraft.StorageCraft;
import storagecraft.gui.sidebutton.SideButton;
public abstract class GuiBase extends GuiContainer
{
public static final int SIDE_BUTTON_WIDTH = 20;
public static final int SIDE_BUTTON_HEIGHT = 20;
private List<SideButton> sideButtons = new ArrayList<SideButton>();
private int lastButtonId = 0;
private int lastSideButtonY = 6;
public GuiBase(Container container, int w, int h)
{
super(container);
this.xSize = w;
this.ySize = h;
}
@Override
public void initGui()
{
super.initGui();
sideButtons.clear();
lastButtonId = 0;
lastSideButtonY = 6;
init(guiLeft, guiTop);
}
@Override
public void updateScreen()
{
super.updateScreen();
update(guiLeft, guiTop);
}
@Override
protected void drawGuiContainerBackgroundLayer(float renderPartialTicks, int mouseX, int mouseY)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
drawBackground(guiLeft, guiTop, mouseX, mouseY);
}
@Override
protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY)
{
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
mouseX -= guiLeft;
mouseY -= guiTop;
for (SideButton sideButton : sideButtons)
{
sideButton.draw(this, sideButton.getX() + 2, sideButton.getY() + 1);
if (inBounds(sideButton.getX(), sideButton.getY(), SIDE_BUTTON_WIDTH, SIDE_BUTTON_HEIGHT, mouseX, mouseY))
{
drawTooltip(mouseX, mouseY, sideButton.getTooltip(this));
}
}
drawForeground(mouseX, mouseY);
}
@Override
protected void actionPerformed(GuiButton button) throws IOException
{
super.actionPerformed(button);
for (SideButton sideButton : sideButtons)
{
if (sideButton.getId() == button.id)
{
sideButton.actionPerformed();
}
}
}
public GuiButton addButton(int x, int y, int w, int h)
{
return addButton(x, y, w, h, "");
}
public GuiButton addButton(int x, int y, int w, int h, String text)
{
GuiButton button = new GuiButton(lastButtonId++, x, y, w, h, text);
buttonList.add(button);
return button;
}
public void addSideButton(SideButton button)
{
button.setX(xSize - 1);
button.setY(lastSideButtonY);
button.setId(addButton(guiLeft + button.getX(), guiTop + button.getY(), SIDE_BUTTON_WIDTH, SIDE_BUTTON_HEIGHT).id);
lastSideButtonY += SIDE_BUTTON_HEIGHT + 4;
sideButtons.add(button);
}
public boolean inBounds(int x, int y, int w, int h, int ox, int oy)
{
return ox >= x && ox <= x + w && oy >= y && oy <= y + h;
}
public void bindTexture(String file)
{
bindTexture(StorageCraft.ID, file);
}
public void bindTexture(String base, String file)
{
mc.getTextureManager().bindTexture(new ResourceLocation(base, "textures/" + file));
}
public void drawItem(int x, int y, ItemStack stack)
{
drawItem(x, y, stack, false);
}
public void drawItem(int x, int y, ItemStack stack, boolean withOverlay)
{
zLevel = 100;
itemRender.zLevel = 100;
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glEnable(GL11.GL_LIGHTING);
GL11.glEnable(GL12.GL_RESCALE_NORMAL);
GL11.glEnable(GL11.GL_DEPTH_TEST);
RenderHelper.enableGUIStandardItemLighting();
// @TODO: itemRender.renderItemAndEffectIntoGUI(fontRendererObj, mc.renderEngine, stack, x, y);
if (withOverlay)
{
// @TODO: itemRender.renderItemOverlayIntoGUI(fontRendererObj, mc.renderEngine, stack, x, y);
}
GL11.glPopAttrib();
itemRender.zLevel = 0;
zLevel = 0;
}
public void drawString(int x, int y, String message)
{
drawString(x, y, message, 4210752);
}
public void drawString(int x, int y, String message, int color)
{
fontRendererObj.drawString(message, x, y, color);
}
// https://github.com/AppliedEnergistics/Applied-Energistics-2/blob/master/src/main/java/appeng/client/gui/AEBaseGui.java
public void drawTooltip(int x, int y, String message)
{
GL11.glPushAttrib(GL11.GL_ALL_ATTRIB_BITS);
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL11.GL_LIGHTING);
GL11.glDisable(GL11.GL_DEPTH_TEST);
String[] lines = message.split("\n");
if (lines.length > 0)
{
int var5 = 0;
int var6;
int var7;
for (var6 = 0; var6 < lines.length; ++var6)
{
var7 = this.fontRendererObj.getStringWidth(lines[var6]);
if (var7 > var5)
{
var5 = var7;
}
}
var6 = x + 12;
var7 = y - 12;
int var9 = 8;
if (lines.length > 1)
{
var9 += 2 + (lines.length - 1) * 10;
}
if (this.guiTop + var7 + var9 + 6 > this.height)
{
var7 = this.height - var9 - this.guiTop - 6;
}
zLevel = 300.0F;
itemRender.zLevel = 300.0F;
int var10 = -267386864;
drawGradientRect(var6 - 3, var7 - 4, var6 + var5 + 3, var7 - 3, var10, var10);
drawGradientRect(var6 - 3, var7 + var9 + 3, var6 + var5 + 3, var7 + var9 + 4, var10, var10);
drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 + var9 + 3, var10, var10);
drawGradientRect(var6 - 4, var7 - 3, var6 - 3, var7 + var9 + 3, var10, var10);
drawGradientRect(var6 + var5 + 3, var7 - 3, var6 + var5 + 4, var7 + var9 + 3, var10, var10);
int var11 = 1347420415;
int var12 = (var11 & 16711422) >> 1 | var11 & -16777216;
drawGradientRect(var6 - 3, var7 - 3 + 1, var6 - 3 + 1, var7 + var9 + 3 - 1, var11, var12);
drawGradientRect(var6 + var5 + 2, var7 - 3 + 1, var6 + var5 + 3, var7 + var9 + 3 - 1, var11, var12);
drawGradientRect(var6 - 3, var7 - 3, var6 + var5 + 3, var7 - 3 + 1, var11, var11);
drawGradientRect(var6 - 3, var7 + var9 + 2, var6 + var5 + 3, var7 + var9 + 3, var12, var12);
for (int var13 = 0; var13 < lines.length; ++var13)
{
String var14 = lines[var13];
if (var13 == 0)
{
var14 = '\u00a7' + Integer.toHexString(15) + var14;
}
else
{
var14 = "\u00a77" + var14;
}
// @TODO: fontRendererObj.drawStringWithShadow(var14, var6, var7, -1);
if (var13 == 0)
{
var7 += 2;
}
var7 += 10;
}
zLevel = 0.0F;
itemRender.zLevel = 0.0F;
}
GL11.glPopAttrib();
}
public void drawTooltip(int x, int y, ItemStack stack)
{
List list = stack.getTooltip(mc.thePlayer, mc.gameSettings.advancedItemTooltips);
for (int i = 0; i < list.size(); ++i)
{
if (i == 0)
{
list.set(i, stack.getRarity().rarityColor + (String) list.get(i));
}
else
{
list.set(i, EnumChatFormatting.GRAY + (String) list.get(i));
}
}
drawTooltip(x, y, Joiner.on("\n").join(list));
}
public String t(String name, Object... format)
{
return StatCollector.translateToLocalFormatted(name, format);
}
public abstract void init(int x, int y);
public abstract void update(int x, int y);
public abstract void drawBackground(int x, int y, int mouseX, int mouseY);
public abstract void drawForeground(int mouseX, int mouseY);
}

165
src/main/java/storagecraft/gui/GuiDetector.java
View File

@@ -1,82 +1,83 @@
package storagecraft.gui;
import com.google.common.primitives.Ints;
import net.minecraft.client.gui.GuiTextField;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerDetector;
import storagecraft.gui.sidebutton.SideButtonCompare;
import storagecraft.gui.sidebutton.SideButtonDetectorMode;
import storagecraft.network.MessageDetectorAmountUpdate;
import storagecraft.tile.TileDetector;
import storagecraft.util.InventoryUtils;
public class GuiDetector extends GuiBase
{
private TileDetector detector;
private GuiTextField amountField;
public GuiDetector(ContainerDetector container, TileDetector detector)
{
super(container, 176, 137);
this.detector = detector;
}
@Override
public void init(int x, int y)
{
addSideButton(new SideButtonCompare(detector, InventoryUtils.COMPARE_DAMAGE));
addSideButton(new SideButtonCompare(detector, InventoryUtils.COMPARE_NBT));
addSideButton(new SideButtonDetectorMode(detector));
amountField = new GuiTextField(fontRendererObj, x + 62 + 1, y + 23 + 1, 25, fontRendererObj.FONT_HEIGHT);
amountField.setText(String.valueOf(detector.getAmount()));
amountField.setEnableBackgroundDrawing(false);
amountField.setVisible(true);
amountField.setTextColor(16777215);
amountField.setCanLoseFocus(false);
amountField.setFocused(true);
}
@Override
public void update(int x, int y)
{
}
@Override
public void drawBackground(int x, int y, int mouseX, int mouseY)
{
bindTexture("gui/detector.png");
drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
amountField.drawTextBox();
}
@Override
public void drawForeground(int mouseX, int mouseY)
{
drawString(7, 7, t("gui.storagecraft:detector"));
drawString(7, 43, t("container.inventory"));
}
@Override
protected void keyTyped(char character, int keyCode)
{
if (!checkHotbarKeys(keyCode) && amountField.textboxKeyTyped(character, keyCode))
{
Integer result = Ints.tryParse(amountField.getText());
if (result != null)
{
StorageCraft.NETWORK.sendToServer(new MessageDetectorAmountUpdate(detector, result));
}
}
else
{
super.keyTyped(character, keyCode);
}
}
}
package storagecraft.gui;
import com.google.common.primitives.Ints;
import java.io.IOException;
import net.minecraft.client.gui.GuiTextField;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerDetector;
import storagecraft.gui.sidebutton.SideButtonCompare;
import storagecraft.gui.sidebutton.SideButtonDetectorMode;
import storagecraft.network.MessageDetectorAmountUpdate;
import storagecraft.tile.TileDetector;
import storagecraft.util.InventoryUtils;
public class GuiDetector extends GuiBase
{
private TileDetector detector;
private GuiTextField amountField;
public GuiDetector(ContainerDetector container, TileDetector detector)
{
super(container, 176, 137);
this.detector = detector;
}
@Override
public void init(int x, int y)
{
addSideButton(new SideButtonCompare(detector, InventoryUtils.COMPARE_DAMAGE));
addSideButton(new SideButtonCompare(detector, InventoryUtils.COMPARE_NBT));
addSideButton(new SideButtonDetectorMode(detector));
amountField = new GuiTextField(0, fontRendererObj, x + 62 + 1, y + 23 + 1, 25, fontRendererObj.FONT_HEIGHT); // @TODO: Is this the right id?
amountField.setText(String.valueOf(detector.getAmount()));
amountField.setEnableBackgroundDrawing(false);
amountField.setVisible(true);
amountField.setTextColor(16777215);
amountField.setCanLoseFocus(false);
amountField.setFocused(true);
}
@Override
public void update(int x, int y)
{
}
@Override
public void drawBackground(int x, int y, int mouseX, int mouseY)
{
bindTexture("gui/detector.png");
drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
amountField.drawTextBox();
}
@Override
public void drawForeground(int mouseX, int mouseY)
{
drawString(7, 7, t("gui.storagecraft:detector"));
drawString(7, 43, t("container.inventory"));
}
@Override
protected void keyTyped(char character, int keyCode) throws IOException
{
if (!checkHotbarKeys(keyCode) && amountField.textboxKeyTyped(character, keyCode))
{
Integer result = Ints.tryParse(amountField.getText());
if (result != null)
{
StorageCraft.NETWORK.sendToServer(new MessageDetectorAmountUpdate(detector, result));
}
}
else
{
super.keyTyped(character, keyCode);
}
}
}

673
src/main/java/storagecraft/gui/GuiGrid.java
View File

@@ -1,336 +1,337 @@
package storagecraft.gui;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import net.minecraft.client.audio.PositionedSoundRecord;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.inventory.Slot;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerGrid;
import storagecraft.gui.sidebutton.SideButtonGridSortingDirection;
import storagecraft.gui.sidebutton.SideButtonGridSortingType;
import storagecraft.gui.sidebutton.SideButtonRedstoneMode;
import storagecraft.network.MessageGridCraftingClear;
import storagecraft.network.MessageStoragePull;
import storagecraft.network.MessageStoragePush;
import storagecraft.storage.StorageItem;
import storagecraft.tile.TileController;
import storagecraft.tile.TileGrid;
public class GuiGrid extends GuiBase
{
public static final int SORTING_DIRECTION_ASCENDING = 0;
public static final int SORTING_DIRECTION_DESCENDING = 1;
public static final int SORTING_TYPE_COUNT = 0;
public static final int SORTING_TYPE_NAME = 1;
public static int SORTING_DIRECTION = SORTING_DIRECTION_ASCENDING;
public static int SORTING_TYPE = SORTING_TYPE_COUNT;
private ContainerGrid container;
private TileGrid grid;
private GuiTextField searchField;
private int hoveringSlotId;
private int hoveringId;
private int offset;
public GuiGrid(ContainerGrid container, TileGrid grid)
{
super(container, 176, grid.isCrafting() ? 256 : 190);
this.container = container;
this.grid = grid;
}
@Override
public void init(int x, int y)
{
addSideButton(new SideButtonRedstoneMode(grid));
addSideButton(new SideButtonGridSortingDirection());
addSideButton(new SideButtonGridSortingType());
searchField = new GuiTextField(fontRendererObj, x + 80 + 1, y + 6 + 1, 88 - 6, fontRendererObj.FONT_HEIGHT);
searchField.setEnableBackgroundDrawing(false);
searchField.setVisible(true);
searchField.setTextColor(16777215);
searchField.setCanLoseFocus(false);
searchField.setFocused(true);
}
@Override
public void update(int x, int y)
{
int wheel = Mouse.getDWheel();
wheel = Math.max(Math.min(-wheel, 1), -1);
if (canScroll(wheel))
{
offset += wheel;
}
if (offset > getMaxOffset())
{
offset = getMaxOffset();
}
}
private int getMaxOffset()
{
if (!grid.isConnected())
{
return 0;
}
int max = ((int) Math.ceil((float) getItems().size() / (float) 9)) - 4;
return max < 0 ? 0 : max;
}
private boolean canScroll(int delta)
{
if (offset + delta < 0)
{
return false;
}
return offset + delta <= getMaxOffset();
}
private boolean isHoveringOverValidSlot()
{
return grid.isConnected() && isHoveringOverSlot() && hoveringSlotId < getItems().size();
}
private boolean isHoveringOverSlot()
{
return hoveringSlotId >= 0;
}
public boolean isHoveringOverClear(int mouseX, int mouseY)
{
return inBounds(81, 105, 7, 7, mouseX, mouseY);
}
@Override
public void drawBackground(int x, int y, int mouseX, int mouseY)
{
if (grid.isCrafting())
{
bindTexture("gui/craftingGrid.png");
}
else
{
bindTexture("gui/grid.png");
}
drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
searchField.drawTextBox();
}
@Override
public void drawForeground(int mouseX, int mouseY)
{
drawString(7, 7, t("gui.storagecraft:grid"));
if (grid.isCrafting())
{
drawString(7, 94, t("container.crafting"));
}
drawString(7, grid.isCrafting() ? 163 : 96, t("container.inventory"));
int x = 8;
int y = 20;
List<StorageItem> items = getItems();
hoveringSlotId = -1;
int slot = offset * 9;
for (int i = 0; i < 9 * 4; ++i)
{
if (slot < items.size())
{
drawItem(x, y, items.get(slot).toItemStack(), true);
}
if (inBounds(x, y, 16, 16, mouseX, mouseY) || !grid.isConnected())
{
hoveringSlotId = slot;
if (slot < items.size())
{
// We need to use the ID, because if we filter, the client-side index will change
// while the serverside's index will still be the same.
hoveringId = items.get(slot).getId();
}
int color = grid.isConnected() ? -2130706433 : 0xFF5B5B5B;
zLevel = 190;
drawGradientRect(x, y, x + 16, y + 16, color, color);
zLevel = 0;
}
slot++;
x += 18;
if ((i + 1) % 9 == 0)
{
x = 8;
y += 18;
}
}
if (isHoveringOverValidSlot())
{
drawTooltip(mouseX, mouseY, items.get(hoveringSlotId).toItemStack());
}
if (grid.isCrafting() && isHoveringOverClear(mouseX, mouseY))
{
drawTooltip(mouseX, mouseY, t("misc.storagecraft:clear"));
}
}
public List<StorageItem> getItems()
{
List<StorageItem> items = new ArrayList<StorageItem>();
if (!grid.isConnected())
{
return items;
}
items.addAll(grid.getController().getItems());
if (!searchField.getText().trim().isEmpty())
{
Iterator<StorageItem> t = items.iterator();
while (t.hasNext())
{
StorageItem item = t.next();
if (!item.toItemStack().getDisplayName().toLowerCase().contains(searchField.getText().toLowerCase()))
{
t.remove();
}
}
}
switch (SORTING_TYPE)
{
case SORTING_TYPE_COUNT:
items.sort(new Comparator<StorageItem>()
{
@Override
public int compare(StorageItem o1, StorageItem o2)
{
switch (SORTING_DIRECTION)
{
case SORTING_DIRECTION_ASCENDING:
return Integer.valueOf(o2.getQuantity()).compareTo(o1.getQuantity());
case SORTING_DIRECTION_DESCENDING:
return Integer.valueOf(o1.getQuantity()).compareTo(o2.getQuantity());
default:
return 0;
}
}
});
break;
case SORTING_TYPE_NAME:
items.sort(new Comparator<StorageItem>()
{
@Override
public int compare(StorageItem o1, StorageItem o2)
{
switch (SORTING_DIRECTION)
{
case SORTING_DIRECTION_ASCENDING:
return o2.toItemStack().getDisplayName().compareTo(o1.toItemStack().getDisplayName());
case SORTING_DIRECTION_DESCENDING:
return o1.toItemStack().getDisplayName().compareTo(o2.toItemStack().getDisplayName());
default:
return 0;
}
}
});
break;
}
return items;
}
@Override
public void mouseClicked(int mouseX, int mouseY, int clickedButton)
{
super.mouseClicked(mouseX, mouseY, clickedButton);
boolean clickedClear = grid.isCrafting() && clickedButton == 0 && isHoveringOverClear(mouseX - guiLeft, mouseY - guiTop);
if (grid.isConnected())
{
TileController controller = grid.getController();
if (isHoveringOverSlot() && container.getPlayer().inventory.getItemStack() != null)
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePush(controller.xCoord, controller.yCoord, controller.zCoord, -1, clickedButton == 1));
}
else if (isHoveringOverValidSlot() && container.getPlayer().inventory.getItemStack() == null)
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePull(controller.xCoord, controller.yCoord, controller.zCoord, hoveringId, clickedButton == 1, Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)));
}
else if (clickedClear)
{
StorageCraft.NETWORK.sendToServer(new MessageGridCraftingClear(grid));
}
else
{
for (Slot slot : container.getPlayerInventorySlots())
{
if (inBounds(slot.xDisplayPosition, slot.yDisplayPosition, 16, 16, mouseX - guiLeft, mouseY - guiTop))
{
if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePush(controller.xCoord, controller.yCoord, controller.zCoord, slot.slotNumber, clickedButton == 1));
}
}
}
}
}
if (clickedClear)
{
mc.getSoundHandler().playSound(PositionedSoundRecord.func_147674_a(new ResourceLocation("gui.button.press"), 1.0F));
}
}
@Override
protected void keyTyped(char character, int keyCode)
{
if (!checkHotbarKeys(keyCode) && searchField.textboxKeyTyped(character, keyCode))
{
}
else
{
super.keyTyped(character, keyCode);
}
}
}
package storagecraft.gui;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import net.minecraft.client.audio.PositionedSoundRecord;
import net.minecraft.client.gui.GuiTextField;
import net.minecraft.inventory.Slot;
import net.minecraft.util.ResourceLocation;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerGrid;
import storagecraft.gui.sidebutton.SideButtonGridSortingDirection;
import storagecraft.gui.sidebutton.SideButtonGridSortingType;
import storagecraft.gui.sidebutton.SideButtonRedstoneMode;
import storagecraft.network.MessageGridCraftingClear;
import storagecraft.network.MessageStoragePull;
import storagecraft.network.MessageStoragePush;
import storagecraft.storage.StorageItem;
import storagecraft.tile.TileController;
import storagecraft.tile.TileGrid;
public class GuiGrid extends GuiBase
{
public static final int SORTING_DIRECTION_ASCENDING = 0;
public static final int SORTING_DIRECTION_DESCENDING = 1;
public static final int SORTING_TYPE_COUNT = 0;
public static final int SORTING_TYPE_NAME = 1;
public static int SORTING_DIRECTION = SORTING_DIRECTION_ASCENDING;
public static int SORTING_TYPE = SORTING_TYPE_COUNT;
private ContainerGrid container;
private TileGrid grid;
private GuiTextField searchField;
private int hoveringSlotId;
private int hoveringId;
private int offset;
public GuiGrid(ContainerGrid container, TileGrid grid)
{
super(container, 176, grid.isCrafting() ? 256 : 190);
this.container = container;
this.grid = grid;
}
@Override
public void init(int x, int y)
{
addSideButton(new SideButtonRedstoneMode(grid));
addSideButton(new SideButtonGridSortingDirection());
addSideButton(new SideButtonGridSortingType());
searchField = new GuiTextField(0, fontRendererObj, x + 80 + 1, y + 6 + 1, 88 - 6, fontRendererObj.FONT_HEIGHT); // @TODO: Is this the right id?
searchField.setEnableBackgroundDrawing(false);
searchField.setVisible(true);
searchField.setTextColor(16777215);
searchField.setCanLoseFocus(false);
searchField.setFocused(true);
}
@Override
public void update(int x, int y)
{
int wheel = Mouse.getDWheel();
wheel = Math.max(Math.min(-wheel, 1), -1);
if (canScroll(wheel))
{
offset += wheel;
}
if (offset > getMaxOffset())
{
offset = getMaxOffset();
}
}
private int getMaxOffset()
{
if (!grid.isConnected())
{
return 0;
}
int max = ((int) Math.ceil((float) getItems().size() / (float) 9)) - 4;
return max < 0 ? 0 : max;
}
private boolean canScroll(int delta)
{
if (offset + delta < 0)
{
return false;
}
return offset + delta <= getMaxOffset();
}
private boolean isHoveringOverValidSlot()
{
return grid.isConnected() && isHoveringOverSlot() && hoveringSlotId < getItems().size();
}
private boolean isHoveringOverSlot()
{
return hoveringSlotId >= 0;
}
public boolean isHoveringOverClear(int mouseX, int mouseY)
{
return inBounds(81, 105, 7, 7, mouseX, mouseY);
}
@Override
public void drawBackground(int x, int y, int mouseX, int mouseY)
{
if (grid.isCrafting())
{
bindTexture("gui/craftingGrid.png");
}
else
{
bindTexture("gui/grid.png");
}
drawTexturedModalRect(x, y, 0, 0, xSize, ySize);
searchField.drawTextBox();
}
@Override
public void drawForeground(int mouseX, int mouseY)
{
drawString(7, 7, t("gui.storagecraft:grid"));
if (grid.isCrafting())
{
drawString(7, 94, t("container.crafting"));
}
drawString(7, grid.isCrafting() ? 163 : 96, t("container.inventory"));
int x = 8;
int y = 20;
List<StorageItem> items = getItems();
hoveringSlotId = -1;
int slot = offset * 9;
for (int i = 0; i < 9 * 4; ++i)
{
if (slot < items.size())
{
drawItem(x, y, items.get(slot).toItemStack(), true);
}
if (inBounds(x, y, 16, 16, mouseX, mouseY) || !grid.isConnected())
{
hoveringSlotId = slot;
if (slot < items.size())
{
// We need to use the ID, because if we filter, the client-side index will change
// while the serverside's index will still be the same.
hoveringId = items.get(slot).getId();
}
int color = grid.isConnected() ? -2130706433 : 0xFF5B5B5B;
zLevel = 190;
drawGradientRect(x, y, x + 16, y + 16, color, color);
zLevel = 0;
}
slot++;
x += 18;
if ((i + 1) % 9 == 0)
{
x = 8;
y += 18;
}
}
if (isHoveringOverValidSlot())
{
drawTooltip(mouseX, mouseY, items.get(hoveringSlotId).toItemStack());
}
if (grid.isCrafting() && isHoveringOverClear(mouseX, mouseY))
{
drawTooltip(mouseX, mouseY, t("misc.storagecraft:clear"));
}
}
public List<StorageItem> getItems()
{
List<StorageItem> items = new ArrayList<StorageItem>();
if (!grid.isConnected())
{
return items;
}
items.addAll(grid.getController().getItems());
if (!searchField.getText().trim().isEmpty())
{
Iterator<StorageItem> t = items.iterator();
while (t.hasNext())
{
StorageItem item = t.next();
if (!item.toItemStack().getDisplayName().toLowerCase().contains(searchField.getText().toLowerCase()))
{
t.remove();
}
}
}
switch (SORTING_TYPE)
{
case SORTING_TYPE_COUNT:
items.sort(new Comparator<StorageItem>()
{
@Override
public int compare(StorageItem o1, StorageItem o2)
{
switch (SORTING_DIRECTION)
{
case SORTING_DIRECTION_ASCENDING:
return Integer.valueOf(o2.getQuantity()).compareTo(o1.getQuantity());
case SORTING_DIRECTION_DESCENDING:
return Integer.valueOf(o1.getQuantity()).compareTo(o2.getQuantity());
default:
return 0;
}
}
});
break;
case SORTING_TYPE_NAME:
items.sort(new Comparator<StorageItem>()
{
@Override
public int compare(StorageItem o1, StorageItem o2)
{
switch (SORTING_DIRECTION)
{
case SORTING_DIRECTION_ASCENDING:
return o2.toItemStack().getDisplayName().compareTo(o1.toItemStack().getDisplayName());
case SORTING_DIRECTION_DESCENDING:
return o1.toItemStack().getDisplayName().compareTo(o2.toItemStack().getDisplayName());
default:
return 0;
}
}
});
break;
}
return items;
}
@Override
public void mouseClicked(int mouseX, int mouseY, int clickedButton) throws IOException
{
super.mouseClicked(mouseX, mouseY, clickedButton);
boolean clickedClear = grid.isCrafting() && clickedButton == 0 && isHoveringOverClear(mouseX - guiLeft, mouseY - guiTop);
if (grid.isConnected())
{
TileController controller = grid.getController();
if (isHoveringOverSlot() && container.getPlayer().inventory.getItemStack() != null)
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePush(controller.getPos().getX(), controller.getPos().getY(), controller.getPos().getZ(), -1, clickedButton == 1));
}
else if (isHoveringOverValidSlot() && container.getPlayer().inventory.getItemStack() == null)
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePull(controller.getPos().getX(), controller.getPos().getY(), controller.getPos().getZ(), hoveringId, clickedButton == 1, Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)));
}
else if (clickedClear)
{
StorageCraft.NETWORK.sendToServer(new MessageGridCraftingClear(grid));
}
else
{
for (Slot slot : container.getPlayerInventorySlots())
{
if (inBounds(slot.xDisplayPosition, slot.yDisplayPosition, 16, 16, mouseX - guiLeft, mouseY - guiTop))
{
if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT))
{
StorageCraft.NETWORK.sendToServer(new MessageStoragePush(controller.getPos().getX(), controller.getPos().getY(), controller.getPos().getZ(), slot.slotNumber, clickedButton == 1));
}
}
}
}
}
if (clickedClear)
{
mc.getSoundHandler().playSound(PositionedSoundRecord.create(new ResourceLocation("gui.button.press"), 1.0F));
}
}
@Override
protected void keyTyped(char character, int keyCode) throws IOException
{
if (!checkHotbarKeys(keyCode) && searchField.textboxKeyTyped(character, keyCode))
{
}
else
{
super.keyTyped(character, keyCode);
}
}
}

209
src/main/java/storagecraft/gui/GuiHandler.java
View File

@@ -1,104 +1,105 @@
package storagecraft.gui;
import cpw.mods.fml.common.network.IGuiHandler;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
import storagecraft.StorageCraftGUI;
import storagecraft.container.ContainerConstructor;
import storagecraft.container.ContainerController;
import storagecraft.container.ContainerDestructor;
import storagecraft.container.ContainerDetector;
import storagecraft.container.ContainerDrive;
import storagecraft.container.ContainerExporter;
import storagecraft.container.ContainerGrid;
import storagecraft.container.ContainerImporter;
import storagecraft.container.ContainerSolderer;
import storagecraft.container.ContainerExternalStorage;
import storagecraft.container.ContainerWirelessTransmitter;
import storagecraft.tile.TileConstructor;
import storagecraft.tile.TileController;
import storagecraft.tile.TileDestructor;
import storagecraft.tile.TileDetector;
import storagecraft.tile.TileDrive;
import storagecraft.tile.TileExporter;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileImporter;
import storagecraft.tile.TileSolderer;
import storagecraft.tile.TileExternalStorage;
import storagecraft.tile.TileWirelessTransmitter;
public class GuiHandler implements IGuiHandler
{
private Container getContainer(int ID, EntityPlayer player, TileEntity tile)
{
switch (ID)
{
case StorageCraftGUI.CONTROLLER:
return new ContainerController(player);
case StorageCraftGUI.GRID:
return new ContainerGrid(player, (TileGrid) tile);
case StorageCraftGUI.DRIVE:
return new ContainerDrive(player, (TileDrive) tile);
case StorageCraftGUI.EXTERNAL_STORAGE:
return new ContainerExternalStorage(player);
case StorageCraftGUI.IMPORTER:
return new ContainerImporter(player, (TileImporter) tile);
case StorageCraftGUI.EXPORTER:
return new ContainerExporter(player, (TileExporter) tile);
case StorageCraftGUI.DETECTOR:
return new ContainerDetector(player, (TileDetector) tile);
case StorageCraftGUI.SOLDERER:
return new ContainerSolderer(player, (TileSolderer) tile);
case StorageCraftGUI.WIRELESS_TRANSMITTER:
return new ContainerWirelessTransmitter(player, (TileWirelessTransmitter) tile);
case StorageCraftGUI.DESTRUCTOR:
return new ContainerDestructor(player);
case StorageCraftGUI.CONSTRUCTOR:
return new ContainerConstructor(player, (TileConstructor) tile);
default:
return null;
}
}
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
return getContainer(ID, player, world.getTileEntity(x, y, z));
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity tile = world.getTileEntity(x, y, z);
switch (ID)
{
case StorageCraftGUI.CONTROLLER:
return new GuiController((ContainerController) getContainer(ID, player, tile), (TileController) tile);
case StorageCraftGUI.GRID:
return new GuiGrid((ContainerGrid) getContainer(ID, player, tile), (TileGrid) tile);
case StorageCraftGUI.DRIVE:
return new GuiDrive((ContainerDrive) getContainer(ID, player, tile), (TileDrive) tile);
case StorageCraftGUI.EXTERNAL_STORAGE:
return new GuiExternalStorage((ContainerExternalStorage) getContainer(ID, player, tile), (TileExternalStorage) tile);
case StorageCraftGUI.IMPORTER:
return new GuiImporter((ContainerImporter) getContainer(ID, player, tile), (TileImporter) tile);
case StorageCraftGUI.EXPORTER:
return new GuiExporter((ContainerExporter) getContainer(ID, player, tile), (TileExporter) tile);
case StorageCraftGUI.DETECTOR:
return new GuiDetector((ContainerDetector) getContainer(ID, player, tile), (TileDetector) tile);
case StorageCraftGUI.SOLDERER:
return new GuiSolderer((ContainerSolderer) getContainer(ID, player, tile), (TileSolderer) tile);
case StorageCraftGUI.WIRELESS_TRANSMITTER:
return new GuiWirelessTransmitter((ContainerWirelessTransmitter) getContainer(ID, player, tile), (TileWirelessTransmitter) tile);
case StorageCraftGUI.DESTRUCTOR:
return new GuiDestructor((ContainerDestructor) getContainer(ID, player, tile), (TileDestructor) tile);
case StorageCraftGUI.CONSTRUCTOR:
return new GuiConstructor((ContainerConstructor) getContainer(ID, player, tile), (TileConstructor) tile);
default:
return null;
}
}
}
package storagecraft.gui;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.fml.common.network.IGuiHandler;
import storagecraft.StorageCraftGUI;
import storagecraft.container.ContainerConstructor;
import storagecraft.container.ContainerController;
import storagecraft.container.ContainerDestructor;
import storagecraft.container.ContainerDetector;
import storagecraft.container.ContainerDrive;
import storagecraft.container.ContainerExporter;
import storagecraft.container.ContainerGrid;
import storagecraft.container.ContainerImporter;
import storagecraft.container.ContainerSolderer;
import storagecraft.container.ContainerExternalStorage;
import storagecraft.container.ContainerWirelessTransmitter;
import storagecraft.tile.TileConstructor;
import storagecraft.tile.TileController;
import storagecraft.tile.TileDestructor;
import storagecraft.tile.TileDetector;
import storagecraft.tile.TileDrive;
import storagecraft.tile.TileExporter;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileImporter;
import storagecraft.tile.TileSolderer;
import storagecraft.tile.TileExternalStorage;
import storagecraft.tile.TileWirelessTransmitter;
public class GuiHandler implements IGuiHandler
{
private Container getContainer(int ID, EntityPlayer player, TileEntity tile)
{
switch (ID)
{
case StorageCraftGUI.CONTROLLER:
return new ContainerController(player);
case StorageCraftGUI.GRID:
return new ContainerGrid(player, (TileGrid) tile);
case StorageCraftGUI.DRIVE:
return new ContainerDrive(player, (TileDrive) tile);
case StorageCraftGUI.EXTERNAL_STORAGE:
return new ContainerExternalStorage(player);
case StorageCraftGUI.IMPORTER:
return new ContainerImporter(player, (TileImporter) tile);
case StorageCraftGUI.EXPORTER:
return new ContainerExporter(player, (TileExporter) tile);
case StorageCraftGUI.DETECTOR:
return new ContainerDetector(player, (TileDetector) tile);
case StorageCraftGUI.SOLDERER:
return new ContainerSolderer(player, (TileSolderer) tile);
case StorageCraftGUI.WIRELESS_TRANSMITTER:
return new ContainerWirelessTransmitter(player, (TileWirelessTransmitter) tile);
case StorageCraftGUI.DESTRUCTOR:
return new ContainerDestructor(player);
case StorageCraftGUI.CONSTRUCTOR:
return new ContainerConstructor(player, (TileConstructor) tile);
default:
return null;
}
}
@Override
public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
return getContainer(ID, player, world.getTileEntity(new BlockPos(x, y, z)));
}
@Override
public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z)
{
TileEntity tile = world.getTileEntity(new BlockPos(x, y, z));
switch (ID)
{
case StorageCraftGUI.CONTROLLER:
return new GuiController((ContainerController) getContainer(ID, player, tile), (TileController) tile);
case StorageCraftGUI.GRID:
return new GuiGrid((ContainerGrid) getContainer(ID, player, tile), (TileGrid) tile);
case StorageCraftGUI.DRIVE:
return new GuiDrive((ContainerDrive) getContainer(ID, player, tile), (TileDrive) tile);
case StorageCraftGUI.EXTERNAL_STORAGE:
return new GuiExternalStorage((ContainerExternalStorage) getContainer(ID, player, tile), (TileExternalStorage) tile);
case StorageCraftGUI.IMPORTER:
return new GuiImporter((ContainerImporter) getContainer(ID, player, tile), (TileImporter) tile);
case StorageCraftGUI.EXPORTER:
return new GuiExporter((ContainerExporter) getContainer(ID, player, tile), (TileExporter) tile);
case StorageCraftGUI.DETECTOR:
return new GuiDetector((ContainerDetector) getContainer(ID, player, tile), (TileDetector) tile);
case StorageCraftGUI.SOLDERER:
return new GuiSolderer((ContainerSolderer) getContainer(ID, player, tile), (TileSolderer) tile);
case StorageCraftGUI.WIRELESS_TRANSMITTER:
return new GuiWirelessTransmitter((ContainerWirelessTransmitter) getContainer(ID, player, tile), (TileWirelessTransmitter) tile);
case StorageCraftGUI.DESTRUCTOR:
return new GuiDestructor((ContainerDestructor) getContainer(ID, player, tile), (TileDestructor) tile);
case StorageCraftGUI.CONSTRUCTOR:
return new GuiConstructor((ContainerConstructor) getContainer(ID, player, tile), (TileConstructor) tile);
default:
return null;
}
}
}

279
src/main/java/storagecraft/inventory/InventorySimple.java
View File

@@ -1,125 +1,154 @@
package storagecraft.inventory;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
public class InventorySimple implements IInventory
{
private ItemStack[] inventory;
private int size;
private String name;
public InventorySimple(String name, int size)
{
this.name = name;
this.size = size;
this.inventory = new ItemStack[size];
}
@Override
public int getSizeInventory()
{
return size;
}
@Override
public ItemStack getStackInSlot(int slotIndex)
{
return inventory[slotIndex];
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
if (stack.stackSize <= amount)
{
setInventorySlotContents(slot, null);
}
else
{
stack = stack.splitStack(amount);
if (stack.stackSize == 0)
{
setInventorySlotContents(slot, null);
}
}
}
return stack;
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
setInventorySlotContents(slot, null);
}
return stack;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
if (stack != null && stack.stackSize > getInventoryStackLimit())
{
stack.stackSize = getInventoryStackLimit();
}
inventory[slot] = stack;
}
@Override
public String getInventoryName()
{
return this.name;
}
@Override
public boolean hasCustomInventoryName()
{
return true;
}
@Override
public int getInventoryStackLimit()
{
return 64;
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return true;
}
@Override
public void openInventory()
{
}
@Override
public void closeInventory()
{
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return true;
}
@Override
public void markDirty()
{
}
}
package storagecraft.inventory;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IChatComponent;
public class InventorySimple implements IInventory
{
private ItemStack[] inventory;
private int size;
private String name;
public InventorySimple(String name, int size)
{
this.name = name;
this.size = size;
this.inventory = new ItemStack[size];
}
@Override
public int getSizeInventory()
{
return size;
}
@Override
public ItemStack getStackInSlot(int slotIndex)
{
return inventory[slotIndex];
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
if (stack.stackSize <= amount)
{
setInventorySlotContents(slot, null);
}
else
{
stack = stack.splitStack(amount);
if (stack.stackSize == 0)
{
setInventorySlotContents(slot, null);
}
}
}
return stack;
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
ItemStack stack = getStackInSlot(slot);
if (stack != null)
{
setInventorySlotContents(slot, null);
}
return stack;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
if (stack != null && stack.stackSize > getInventoryStackLimit())
{
stack.stackSize = getInventoryStackLimit();
}
inventory[slot] = stack;
}
@Override
public String getName()
{
return this.name;
}
@Override
public boolean hasCustomName()
{
return true;
}
@Override
public int getInventoryStackLimit()
{
return 64;
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return true;
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return true;
}
@Override
public void markDirty()
{
}
@Override
public void openInventory(EntityPlayer playerIn)
{
}
@Override
public void closeInventory(EntityPlayer playerIn)
{
}
@Override
public int getField(int id)
{
return 0;
}
@Override
public void setField(int id, int value)
{
}
@Override
public int getFieldCount()
{
return 0;
}
@Override
public void clear()
{
}
@Override
public IChatComponent getDisplayName()
{
return null; // @TODO: ...
}
}

70
src/main/java/storagecraft/item/ItemBase.java
View File

@@ -1,35 +1,35 @@
package storagecraft.item;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import storagecraft.StorageCraft;
public abstract class ItemBase extends Item
{
private String name;
public ItemBase(String name)
{
this.name = name;
setCreativeTab(StorageCraft.TAB);
setTextureName("storagecraft:" + name);
}
@Override
public String getUnlocalizedName()
{
return "item." + StorageCraft.ID + ":" + name;
}
@Override
public String getUnlocalizedName(ItemStack stack)
{
if (getHasSubtypes())
{
return getUnlocalizedName() + "." + stack.getItemDamage();
}
return getUnlocalizedName();
}
}
package storagecraft.item;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import storagecraft.StorageCraft;
public abstract class ItemBase extends Item
{
private String name;
public ItemBase(String name)
{
this.name = name;
setCreativeTab(StorageCraft.TAB);
// @TODO: ... setTextureName("storagecraft:" + name);
}
@Override
public String getUnlocalizedName()
{
return "item." + StorageCraft.ID + ":" + name;
}
@Override
public String getUnlocalizedName(ItemStack stack)
{
if (getHasSubtypes())
{
return getUnlocalizedName() + "." + stack.getItemDamage();
}
return getUnlocalizedName();
}
}

40
src/main/java/storagecraft/item/ItemBlockBase.java
View File

@@ -1,19 +1,21 @@
package storagecraft.item;
import net.minecraft.block.Block;
import net.minecraft.item.ItemBlockWithMetadata;
import net.minecraft.item.ItemStack;
public abstract class ItemBlockBase extends ItemBlockWithMetadata
{
public ItemBlockBase(Block block)
{
super(block, block);
}
@Override
public String getUnlocalizedName(ItemStack stack)
{
return getUnlocalizedName() + "." + stack.getItemDamage();
}
}
package storagecraft.item;
import net.minecraft.block.Block;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
public abstract class ItemBlockBase extends ItemBlock
{
public ItemBlockBase(Block block)
{
super(block);
setHasSubtypes(true);
}
@Override
public String getUnlocalizedName(ItemStack stack)
{
return getUnlocalizedName() + "." + stack.getItemDamage();
}
}

84
src/main/java/storagecraft/item/ItemCore.java
View File

@@ -1,55 +1,29 @@
package storagecraft.item;
import java.util.List;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
public class ItemCore extends ItemBase
{
public static final int TYPE_CONSTRUCTION = 0;
public static final int TYPE_DESTRUCTION = 1;
private IIcon constructionIcon;
private IIcon destructionIcon;
public ItemCore()
{
super("core");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 2; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
@Override
public void registerIcons(IIconRegister register)
{
constructionIcon = register.registerIcon("storagecraft:core0");
destructionIcon = register.registerIcon("storagecraft:core1");
}
@Override
public IIcon getIconFromDamage(int damage)
{
switch (damage)
{
case TYPE_CONSTRUCTION:
return constructionIcon;
case TYPE_DESTRUCTION:
return destructionIcon;
default:
return null;
}
}
}
package storagecraft.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
public class ItemCore extends ItemBase
{
public static final int TYPE_CONSTRUCTION = 0;
public static final int TYPE_DESTRUCTION = 1;
public ItemCore()
{
super("core");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 2; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
}

87
src/main/java/storagecraft/item/ItemProcessor.java
View File

@@ -1,53 +1,34 @@
package storagecraft.item;
import java.util.List;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
public class ItemProcessor extends ItemBase
{
public static final int TYPE_PRINTED_BASIC = 0;
public static final int TYPE_PRINTED_IMPROVED = 1;
public static final int TYPE_PRINTED_ADVANCED = 2;
public static final int TYPE_BASIC = 3;
public static final int TYPE_IMPROVED = 4;
public static final int TYPE_ADVANCED = 5;
public static final int TYPE_PRINTED_SILICON = 6;
private IIcon[] icons = new IIcon[7];
public ItemProcessor()
{
super("processor");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i <= 6; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
@Override
public void registerIcons(IIconRegister register)
{
for (int i = 0; i <= 6; ++i)
{
icons[i] = register.registerIcon("storagecraft:processor" + i);
}
}
@Override
public IIcon getIconFromDamage(int damage)
{
return icons[damage];
}
}
package storagecraft.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
public class ItemProcessor extends ItemBase
{
public static final int TYPE_PRINTED_BASIC = 0;
public static final int TYPE_PRINTED_IMPROVED = 1;
public static final int TYPE_PRINTED_ADVANCED = 2;
public static final int TYPE_BASIC = 3;
public static final int TYPE_IMPROVED = 4;
public static final int TYPE_ADVANCED = 5;
public static final int TYPE_PRINTED_SILICON = 6;
public ItemProcessor()
{
super("processor");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i <= 6; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
}

206
src/main/java/storagecraft/item/ItemStorageCell.java
View File

@@ -1,112 +1,94 @@
package storagecraft.item;
import java.util.List;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.IIcon;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import storagecraft.storage.CellStorage;
public class ItemStorageCell extends ItemBase
{
public static final int TYPE_1K = 0;
public static final int TYPE_4K = 1;
public static final int TYPE_16K = 2;
public static final int TYPE_64K = 3;
public static final int TYPE_CREATIVE = 4;
private IIcon[] icons = new IIcon[5];
public ItemStorageCell()
{
super("storageCell");
setMaxStackSize(1);
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 5; ++i)
{
list.add(initNBT(new ItemStack(item, 1, i)));
}
}
@Override
public void addInformation(ItemStack cell, EntityPlayer player, List list, boolean b)
{
if (getCapacity(cell) == -1)
{
list.add(String.format(StatCollector.translateToLocal("misc.storagecraft:storageCellStored"), getStored(cell)));
}
else
{
list.add(String.format(StatCollector.translateToLocal("misc.storagecraft:storageCellStoredWithCapacity"), getStored(cell), getCapacity(cell)));
}
}
@Override
public void onCreated(ItemStack stack, World world, EntityPlayer player)
{
super.onCreated(stack, world, player);
initNBT(stack);
}
@Override
public void registerIcons(IIconRegister register)
{
for (int i = 0; i < 5; ++i)
{
icons[i] = register.registerIcon("storagecraft:storageCell" + i);
}
}
@Override
public IIcon getIconFromDamage(int damage)
{
return icons[damage];
}
private ItemStack initNBT(ItemStack cell)
{
cell.stackTagCompound = new NBTTagCompound();
cell.stackTagCompound.setTag(CellStorage.NBT_ITEMS, new NBTTagList());
cell.stackTagCompound.setInteger(CellStorage.NBT_STORED, 0);
return cell;
}
public static int getStored(ItemStack cell)
{
return cell.stackTagCompound.getInteger(CellStorage.NBT_STORED);
}
public static int getCapacity(ItemStack cell)
{
switch (cell.getItemDamage())
{
case TYPE_1K:
return 1000;
case TYPE_4K:
return 4000;
case TYPE_16K:
return 16000;
case TYPE_64K:
return 64000;
case TYPE_CREATIVE:
return -1;
}
return 0;
}
}
package storagecraft.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import storagecraft.storage.CellStorage;
public class ItemStorageCell extends ItemBase
{
public static final int TYPE_1K = 0;
public static final int TYPE_4K = 1;
public static final int TYPE_16K = 2;
public static final int TYPE_64K = 3;
public static final int TYPE_CREATIVE = 4;
public ItemStorageCell()
{
super("storageCell");
setMaxStackSize(1);
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 5; ++i)
{
list.add(initNBT(new ItemStack(item, 1, i)));
}
}
@Override
public void addInformation(ItemStack cell, EntityPlayer player, List list, boolean b)
{
if (getCapacity(cell) == -1)
{
list.add(String.format(StatCollector.translateToLocal("misc.storagecraft:storageCellStored"), getStored(cell)));
}
else
{
list.add(String.format(StatCollector.translateToLocal("misc.storagecraft:storageCellStoredWithCapacity"), getStored(cell), getCapacity(cell)));
}
}
@Override
public void onCreated(ItemStack stack, World world, EntityPlayer player)
{
super.onCreated(stack, world, player);
initNBT(stack);
}
private ItemStack initNBT(ItemStack cell)
{
cell.setTagCompound(new NBTTagCompound());
cell.getTagCompound().setTag(CellStorage.NBT_ITEMS, new NBTTagList());
cell.getTagCompound().setInteger(CellStorage.NBT_STORED, 0);
return cell;
}
public static int getStored(ItemStack cell)
{
return cell.getTagCompound().getInteger(CellStorage.NBT_STORED);
}
public static int getCapacity(ItemStack cell)
{
switch (cell.getItemDamage())
{
case TYPE_1K:
return 1000;
case TYPE_4K:
return 4000;
case TYPE_16K:
return 16000;
case TYPE_64K:
return 64000;
case TYPE_CREATIVE:
return -1;
}
return 0;
}
}

81
src/main/java/storagecraft/item/ItemStoragePart.java
View File

@@ -1,50 +1,31 @@
package storagecraft.item;
import java.util.List;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
public class ItemStoragePart extends ItemBase
{
public static final int TYPE_1K = 0;
public static final int TYPE_4K = 1;
public static final int TYPE_16K = 2;
public static final int TYPE_64K = 3;
private IIcon[] icons = new IIcon[4];
public ItemStoragePart()
{
super("storagePart");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i <= 3; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
@Override
public void registerIcons(IIconRegister register)
{
for (int i = 0; i <= 3; ++i)
{
icons[i] = register.registerIcon("storagecraft:storagePart" + i);
}
}
@Override
public IIcon getIconFromDamage(int damage)
{
return icons[damage];
}
}
package storagecraft.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
public class ItemStoragePart extends ItemBase
{
public static final int TYPE_1K = 0;
public static final int TYPE_4K = 1;
public static final int TYPE_16K = 2;
public static final int TYPE_64K = 3;
public ItemStoragePart()
{
super("storagePart");
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i <= 3; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
}

295
src/main/java/storagecraft/item/ItemWirelessGrid.java
View File

@@ -1,159 +1,136 @@
package storagecraft.item;
import java.util.List;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.IIcon;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileWirelessTransmitter;
public class ItemWirelessGrid extends ItemBase
{
public static final String NBT_WIRELESS_TRANSMITTER_X = "WirelessTransmitterX";
public static final String NBT_WIRELESS_TRANSMITTER_Y = "WirelessTransmitterY";
public static final String NBT_WIRELESS_TRANSMITTER_Z = "WirelessTransmitterZ";
private IIcon iconConnected;
private IIcon iconDisconnected;
public ItemWirelessGrid()
{
super("wirelessGrid");
setMaxStackSize(1);
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 2; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
@Override
public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b)
{
if (isValid(stack))
{
list.add(StatCollector.translateToLocalFormatted("misc.storagecraft:wirelessGrid.tooltip", getX(stack), getY(stack), getZ(stack)));
}
}
@Override
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
{
if (!world.isRemote)
{
if (isValid(stack))
{
if (isInRange(stack, player))
{
int x = getX(stack);
int y = getY(stack);
int z = getZ(stack);
TileEntity tile = world.getTileEntity(x, y, z);
if (tile instanceof TileWirelessTransmitter)
{
TileWirelessTransmitter wirelessTransmitter = (TileWirelessTransmitter) tile;
if (wirelessTransmitter.isWorking())
{
TileGrid grid = wirelessTransmitter.getGrid(stack.getItemDamage());
if (grid == null)
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.noGrid." + stack.getItemDamage())));
}
else
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.GRID, world, grid.xCoord, grid.yCoord, grid.zCoord);
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notWorking")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notFound")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.outOfRange")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notSet." + stack.getItemDamage())));
}
}
return stack;
}
public boolean isCrafting(ItemStack stack)
{
return stack.getItemDamage() == 1;
}
public int getX(ItemStack stack)
{
return stack.stackTagCompound.getInteger(NBT_WIRELESS_TRANSMITTER_X);
}
public int getY(ItemStack stack)
{
return stack.stackTagCompound.getInteger(NBT_WIRELESS_TRANSMITTER_Y);
}
public int getZ(ItemStack stack)
{
return stack.stackTagCompound.getInteger(NBT_WIRELESS_TRANSMITTER_Z);
}
public boolean isInRange(ItemStack stack, EntityPlayer player)
{
return (int) Math.sqrt(Math.pow(getX(stack) - player.posX, 2) + Math.pow(getY(stack) - player.posY, 2) + Math.pow(getZ(stack) - player.posZ, 2)) < 64;
}
public boolean isValid(ItemStack stack)
{
return stack.stackTagCompound != null && stack.stackTagCompound.hasKey(NBT_WIRELESS_TRANSMITTER_X) && stack.stackTagCompound.hasKey(NBT_WIRELESS_TRANSMITTER_Y) && stack.stackTagCompound.hasKey(NBT_WIRELESS_TRANSMITTER_Z);
}
@Override
public void registerIcons(IIconRegister register)
{
iconConnected = register.registerIcon("storagecraft:wirelessGridConnected");
iconDisconnected = register.registerIcon("storagecraft:wirelessGridDisconnected");
}
@Override
public IIcon getIcon(ItemStack stack, int pass)
{
return getIconIndex(stack);
}
@Override
public IIcon getIconIndex(ItemStack stack)
{
return isValid(stack) ? iconConnected : iconDisconnected;
}
}
package storagecraft.item;
import java.util.List;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.ChatComponentText;
import net.minecraft.util.StatCollector;
import net.minecraft.world.World;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftGUI;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileWirelessTransmitter;
public class ItemWirelessGrid extends ItemBase
{
public static final String NBT_WIRELESS_TRANSMITTER_X = "WirelessTransmitterX";
public static final String NBT_WIRELESS_TRANSMITTER_Y = "WirelessTransmitterY";
public static final String NBT_WIRELESS_TRANSMITTER_Z = "WirelessTransmitterZ";
public ItemWirelessGrid()
{
super("wirelessGrid");
setMaxStackSize(1);
setHasSubtypes(true);
setMaxDamage(0);
}
@Override
public void getSubItems(Item item, CreativeTabs tab, List list)
{
for (int i = 0; i < 2; ++i)
{
list.add(new ItemStack(item, 1, i));
}
}
@Override
public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b)
{
if (isValid(stack))
{
list.add(StatCollector.translateToLocalFormatted("misc.storagecraft:wirelessGrid.tooltip", getX(stack), getY(stack), getZ(stack)));
}
}
@Override
public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player)
{
if (!world.isRemote)
{
if (isValid(stack))
{
if (isInRange(stack, player))
{
int x = getX(stack);
int y = getY(stack);
int z = getZ(stack);
TileEntity tile = world.getTileEntity(new BlockPos(x, y, z));
if (tile instanceof TileWirelessTransmitter)
{
TileWirelessTransmitter wirelessTransmitter = (TileWirelessTransmitter) tile;
if (wirelessTransmitter.isWorking())
{
TileGrid grid = wirelessTransmitter.getGrid(stack.getItemDamage());
if (grid == null)
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.noGrid." + stack.getItemDamage())));
}
else
{
player.openGui(StorageCraft.INSTANCE, StorageCraftGUI.GRID, world, grid.getPos().getX(), grid.getPos().getY(), grid.getPos().getZ());
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notWorking")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notFound")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.outOfRange")));
}
}
else
{
player.addChatComponentMessage(new ChatComponentText(StatCollector.translateToLocal("misc.storagecraft:wirelessGrid.notSet." + stack.getItemDamage())));
}
}
return stack;
}
public boolean isCrafting(ItemStack stack)
{
return stack.getItemDamage() == 1;
}
public int getX(ItemStack stack)
{
return stack.getTagCompound().getInteger(NBT_WIRELESS_TRANSMITTER_X);
}
public int getY(ItemStack stack)
{
return stack.getTagCompound().getInteger(NBT_WIRELESS_TRANSMITTER_Y);
}
public int getZ(ItemStack stack)
{
return stack.getTagCompound().getInteger(NBT_WIRELESS_TRANSMITTER_Z);
}
public boolean isInRange(ItemStack stack, EntityPlayer player)
{
return (int) Math.sqrt(Math.pow(getX(stack) - player.posX, 2) + Math.pow(getY(stack) - player.posY, 2) + Math.pow(getZ(stack) - player.posZ, 2)) < 64;
}
public boolean isValid(ItemStack stack)
{
return stack.hasTagCompound() && stack.getTagCompound().hasKey(NBT_WIRELESS_TRANSMITTER_X) && stack.getTagCompound().hasKey(NBT_WIRELESS_TRANSMITTER_Y) && stack.getTagCompound().hasKey(NBT_WIRELESS_TRANSMITTER_Z);
}
}

125
src/main/java/storagecraft/network/MessageCompareUpdate.java
View File

@@ -1,62 +1,63 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.ICompareSetting;
public class MessageCompareUpdate implements IMessage, IMessageHandler<MessageCompareUpdate, IMessage>
{
private int x;
private int y;
private int z;
private int compare;
public MessageCompareUpdate()
{
}
public MessageCompareUpdate(ICompareSetting setting, int compare)
{
this.x = setting.getX();
this.y = setting.getY();
this.z = setting.getZ();
this.compare = compare;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(compare);
}
@Override
public IMessage onMessage(MessageCompareUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof ICompareSetting)
{
((ICompareSetting) tile).setCompare(message.compare);
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.ICompareSetting;
public class MessageCompareUpdate implements IMessage, IMessageHandler<MessageCompareUpdate, IMessage>
{
private int x;
private int y;
private int z;
private int compare;
public MessageCompareUpdate()
{
}
public MessageCompareUpdate(ICompareSetting setting, int compare)
{
this.x = setting.getPos().getX();
this.y = setting.getPos().getY();
this.z = setting.getPos().getZ();
this.compare = compare;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(compare);
}
@Override
public IMessage onMessage(MessageCompareUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof ICompareSetting)
{
((ICompareSetting) tile).setCompare(message.compare);
}
return null;
}
}

125
src/main/java/storagecraft/network/MessageDetectorAmountUpdate.java
View File

@@ -1,62 +1,63 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileDetector;
public class MessageDetectorAmountUpdate implements IMessage, IMessageHandler<MessageDetectorAmountUpdate, IMessage>
{
private int x;
private int y;
private int z;
private int amount;
public MessageDetectorAmountUpdate()
{
}
public MessageDetectorAmountUpdate(TileDetector detector, int amount)
{
this.x = detector.xCoord;
this.y = detector.yCoord;
this.z = detector.zCoord;
this.amount = amount;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
amount = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(amount);
}
@Override
public IMessage onMessage(MessageDetectorAmountUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileDetector && message.amount >= 0)
{
((TileDetector) tile).setAmount(message.amount);
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileDetector;
public class MessageDetectorAmountUpdate implements IMessage, IMessageHandler<MessageDetectorAmountUpdate, IMessage>
{
private int x;
private int y;
private int z;
private int amount;
public MessageDetectorAmountUpdate()
{
}
public MessageDetectorAmountUpdate(TileDetector detector, int amount)
{
this.x = detector.getPos().getX();
this.y = detector.getPos().getY();
this.z = detector.getPos().getZ();
this.amount = amount;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
amount = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(amount);
}
@Override
public IMessage onMessage(MessageDetectorAmountUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileDetector && message.amount >= 0)
{
((TileDetector) tile).setAmount(message.amount);
}
return null;
}
}

143
src/main/java/storagecraft/network/MessageDetectorModeUpdate.java
View File

@@ -1,71 +1,72 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileDetector;
public class MessageDetectorModeUpdate implements IMessage, IMessageHandler<MessageDetectorModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageDetectorModeUpdate()
{
}
public MessageDetectorModeUpdate(TileDetector detector)
{
this.x = detector.xCoord;
this.y = detector.yCoord;
this.z = detector.zCoord;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageDetectorModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileDetector)
{
TileDetector detector = (TileDetector) tile;
switch (detector.getMode())
{
case TileDetector.MODE_UNDER:
detector.setMode(TileDetector.MODE_EQUAL);
break;
case TileDetector.MODE_EQUAL:
detector.setMode(TileDetector.MODE_ABOVE);
break;
case TileDetector.MODE_ABOVE:
detector.setMode(TileDetector.MODE_UNDER);
break;
}
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileDetector;
public class MessageDetectorModeUpdate implements IMessage, IMessageHandler<MessageDetectorModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageDetectorModeUpdate()
{
}
public MessageDetectorModeUpdate(TileDetector detector)
{
this.x = detector.getPos().getX();
this.y = detector.getPos().getY();
this.z = detector.getPos().getZ();
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageDetectorModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileDetector)
{
TileDetector detector = (TileDetector) tile;
switch (detector.getMode())
{
case TileDetector.MODE_UNDER:
detector.setMode(TileDetector.MODE_EQUAL);
break;
case TileDetector.MODE_EQUAL:
detector.setMode(TileDetector.MODE_ABOVE);
break;
case TileDetector.MODE_ABOVE:
detector.setMode(TileDetector.MODE_UNDER);
break;
}
}
return null;
}
}

151
src/main/java/storagecraft/network/MessageGridCraftingClear.java
View File

@@ -1,75 +1,76 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileGrid;
public class MessageGridCraftingClear implements IMessage, IMessageHandler<MessageGridCraftingClear, IMessage>
{
private int x;
private int y;
private int z;
public MessageGridCraftingClear()
{
}
public MessageGridCraftingClear(TileGrid grid)
{
this.x = grid.xCoord;
this.y = grid.yCoord;
this.z = grid.zCoord;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageGridCraftingClear message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileGrid)
{
TileGrid grid = (TileGrid) tile;
if (grid.isConnected())
{
for (int i = 0; i < grid.getCraftingMatrix().getSizeInventory(); ++i)
{
ItemStack slot = grid.getCraftingMatrix().getStackInSlot(i);
if (slot != null)
{
if (grid.getController().push(slot))
{
grid.getCraftingMatrix().setInventorySlotContents(i, null);
}
}
}
}
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileGrid;
public class MessageGridCraftingClear implements IMessage, IMessageHandler<MessageGridCraftingClear, IMessage>
{
private int x;
private int y;
private int z;
public MessageGridCraftingClear()
{
}
public MessageGridCraftingClear(TileGrid grid)
{
this.x = grid.getPos().getX();
this.y = grid.getPos().getY();
this.z = grid.getPos().getZ();
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageGridCraftingClear message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileGrid)
{
TileGrid grid = (TileGrid) tile;
if (grid.isConnected())
{
for (int i = 0; i < grid.getCraftingMatrix().getSizeInventory(); ++i)
{
ItemStack slot = grid.getCraftingMatrix().getStackInSlot(i);
if (slot != null)
{
if (grid.getController().push(slot))
{
grid.getCraftingMatrix().setInventorySlotContents(i, null);
}
}
}
}
}
return null;
}
}

155
src/main/java/storagecraft/network/MessageGridCraftingUpdate.java
View File

@@ -1,77 +1,78 @@
package storagecraft.network;
import cpw.mods.fml.common.network.ByteBufUtils;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.client.Minecraft;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileGrid;
public class MessageGridCraftingUpdate implements IMessage, IMessageHandler<MessageGridCraftingUpdate, IMessage>
{
private int x;
private int y;
private int z;
private ItemStack[] craftingMatrix = new ItemStack[9];
public MessageGridCraftingUpdate()
{
}
public MessageGridCraftingUpdate(TileGrid grid)
{
this.x = grid.xCoord;
this.y = grid.yCoord;
this.z = grid.zCoord;
for (int i = 0; i < 9; ++i)
{
craftingMatrix[i] = grid.getCraftingMatrix().getStackInSlot(i);
}
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
for (int i = 0; i < 9; ++i)
{
craftingMatrix[i] = ByteBufUtils.readItemStack(buf);
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
for (ItemStack stack : craftingMatrix)
{
ByteBufUtils.writeItemStack(buf, stack);
}
}
@Override
public IMessage onMessage(MessageGridCraftingUpdate message, MessageContext context)
{
TileEntity tile = Minecraft.getMinecraft().theWorld.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileGrid)
{
for (int i = 0; i < 9; ++i)
{
((TileGrid) tile).getCraftingMatrix().setInventorySlotContents(i, message.craftingMatrix[i]);
}
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.client.Minecraft;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileGrid;
public class MessageGridCraftingUpdate implements IMessage, IMessageHandler<MessageGridCraftingUpdate, IMessage>
{
private int x;
private int y;
private int z;
private ItemStack[] craftingMatrix = new ItemStack[9];
public MessageGridCraftingUpdate()
{
}
public MessageGridCraftingUpdate(TileGrid grid)
{
this.x = grid.getPos().getX();
this.y = grid.getPos().getY();
this.z = grid.getPos().getZ();
for (int i = 0; i < 9; ++i)
{
craftingMatrix[i] = grid.getCraftingMatrix().getStackInSlot(i);
}
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
for (int i = 0; i < 9; ++i)
{
craftingMatrix[i] = ByteBufUtils.readItemStack(buf);
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
for (ItemStack stack : craftingMatrix)
{
ByteBufUtils.writeItemStack(buf, stack);
}
}
@Override
public IMessage onMessage(MessageGridCraftingUpdate message, MessageContext context)
{
TileEntity tile = Minecraft.getMinecraft().theWorld.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileGrid)
{
for (int i = 0; i < 9; ++i)
{
((TileGrid) tile).getCraftingMatrix().setInventorySlotContents(i, message.craftingMatrix[i]);
}
}
return null;
}
}

121
src/main/java/storagecraft/network/MessageImporterModeUpdate.java
View File

@@ -1,60 +1,61 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileImporter;
public class MessageImporterModeUpdate implements IMessage, IMessageHandler<MessageImporterModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageImporterModeUpdate()
{
}
public MessageImporterModeUpdate(TileImporter importer)
{
this.x = importer.xCoord;
this.y = importer.yCoord;
this.z = importer.zCoord;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageImporterModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileImporter)
{
TileImporter importer = (TileImporter) tile;
importer.setMode(importer.getMode() == TileImporter.MODE_WHITELIST ? TileImporter.MODE_BLACKLIST : TileImporter.MODE_WHITELIST);
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileImporter;
public class MessageImporterModeUpdate implements IMessage, IMessageHandler<MessageImporterModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageImporterModeUpdate()
{
}
public MessageImporterModeUpdate(TileImporter importer)
{
this.x = importer.getPos().getX();
this.y = importer.getPos().getY();
this.z = importer.getPos().getZ();
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageImporterModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileImporter)
{
TileImporter importer = (TileImporter) tile;
importer.setMode(importer.getMode() == TileImporter.MODE_WHITELIST ? TileImporter.MODE_BLACKLIST : TileImporter.MODE_WHITELIST);
}
return null;
}
}

121
src/main/java/storagecraft/network/MessageRedstoneModeUpdate.java
View File

@@ -1,60 +1,61 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.IRedstoneModeSetting;
public class MessageRedstoneModeUpdate implements IMessage, IMessageHandler<MessageRedstoneModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageRedstoneModeUpdate()
{
}
public MessageRedstoneModeUpdate(IRedstoneModeSetting setting)
{
this.x = setting.getX();
this.y = setting.getY();
this.z = setting.getZ();
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageRedstoneModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof IRedstoneModeSetting)
{
IRedstoneModeSetting setting = (IRedstoneModeSetting) tile;
setting.setRedstoneMode(setting.getRedstoneMode().next());
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.IRedstoneModeSetting;
public class MessageRedstoneModeUpdate implements IMessage, IMessageHandler<MessageRedstoneModeUpdate, IMessage>
{
private int x;
private int y;
private int z;
public MessageRedstoneModeUpdate()
{
}
public MessageRedstoneModeUpdate(IRedstoneModeSetting setting)
{
this.x = setting.getPos().getX();
this.y = setting.getPos().getY();
this.z = setting.getPos().getZ();
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
}
@Override
public IMessage onMessage(MessageRedstoneModeUpdate message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof IRedstoneModeSetting)
{
IRedstoneModeSetting setting = (IRedstoneModeSetting) tile;
setting.setRedstoneMode(setting.getRedstoneMode().next());
}
return null;
}
}

215
src/main/java/storagecraft/network/MessageStoragePull.java
View File

@@ -1,107 +1,108 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.storage.StorageItem;
import storagecraft.tile.TileController;
public class MessageStoragePull implements IMessage, IMessageHandler<MessageStoragePull, IMessage>
{
private int x;
private int y;
private int z;
private int id;
private boolean half;
private boolean shift;
public MessageStoragePull()
{
}
public MessageStoragePull(int x, int y, int z, int id, boolean half, boolean shift)
{
this.x = x;
this.y = y;
this.z = z;
this.id = id;
this.half = half;
this.shift = shift;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
id = buf.readInt();
half = buf.readBoolean();
shift = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(id);
buf.writeBoolean(half);
buf.writeBoolean(shift);
}
@Override
public IMessage onMessage(MessageStoragePull message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileController)
{
TileController controller = (TileController) tile;
if (message.id < controller.getItems().size())
{
StorageItem item = controller.getItems().get(message.id);
int quantity = 64;
if (message.half && item.getQuantity() > 1)
{
quantity = item.getQuantity() / 2;
if (quantity > 64)
{
quantity = 64;
}
}
ItemStack took = controller.take(item.copy(quantity).toItemStack());
if (took != null)
{
if (message.shift)
{
if (!player.inventory.addItemStackToInventory(took.copy()))
{
controller.push(took);
}
}
else
{
player.inventory.setItemStack(took);
player.updateHeldItem();
}
}
}
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.storage.StorageItem;
import storagecraft.tile.TileController;
public class MessageStoragePull implements IMessage, IMessageHandler<MessageStoragePull, IMessage>
{
private int x;
private int y;
private int z;
private int id;
private boolean half;
private boolean shift;
public MessageStoragePull()
{
}
public MessageStoragePull(int x, int y, int z, int id, boolean half, boolean shift)
{
this.x = x;
this.y = y;
this.z = z;
this.id = id;
this.half = half;
this.shift = shift;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
id = buf.readInt();
half = buf.readBoolean();
shift = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(id);
buf.writeBoolean(half);
buf.writeBoolean(shift);
}
@Override
public IMessage onMessage(MessageStoragePull message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileController)
{
TileController controller = (TileController) tile;
if (message.id < controller.getItems().size())
{
StorageItem item = controller.getItems().get(message.id);
int quantity = 64;
if (message.half && item.getQuantity() > 1)
{
quantity = item.getQuantity() / 2;
if (quantity > 64)
{
quantity = 64;
}
}
ItemStack took = controller.take(item.copy(quantity).toItemStack());
if (took != null)
{
if (message.shift)
{
if (!player.inventory.addItemStackToInventory(took.copy()))
{
controller.push(took);
}
}
else
{
player.inventory.setItemStack(took);
player.updateHeldItem();
}
}
}
}
return null;
}
}

229
src/main/java/storagecraft/network/MessageStoragePush.java
View File

@@ -1,114 +1,115 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.TileController;
public class MessageStoragePush implements IMessage, IMessageHandler<MessageStoragePush, IMessage>
{
private int x;
private int y;
private int z;
private int slot;
private boolean one;
public MessageStoragePush()
{
}
public MessageStoragePush(int x, int y, int z, int slot, boolean one)
{
this.x = x;
this.y = y;
this.z = z;
this.slot = slot;
this.one = one;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
slot = buf.readInt();
one = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(slot);
buf.writeBoolean(one);
}
@Override
public IMessage onMessage(MessageStoragePush message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(message.x, message.y, message.z);
if (tile instanceof TileController)
{
TileController controller = (TileController) tile;
ItemStack stack;
if (message.slot == -1)
{
stack = player.inventory.getItemStack().copy();
if (message.one)
{
stack.stackSize = 1;
}
}
else
{
stack = player.inventory.getStackInSlot(message.slot);
}
if (stack != null)
{
boolean success = controller.push(stack);
if (success)
{
if (message.slot == -1)
{
if (message.one)
{
player.inventory.getItemStack().stackSize--;
if (player.inventory.getItemStack().stackSize == 0)
{
player.inventory.setItemStack(null);
}
}
else
{
player.inventory.setItemStack(null);
}
player.updateHeldItem();
}
else
{
player.inventory.setInventorySlotContents(message.slot, null);
}
}
}
}
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.TileController;
public class MessageStoragePush implements IMessage, IMessageHandler<MessageStoragePush, IMessage>
{
private int x;
private int y;
private int z;
private int slot;
private boolean one;
public MessageStoragePush()
{
}
public MessageStoragePush(int x, int y, int z, int slot, boolean one)
{
this.x = x;
this.y = y;
this.z = z;
this.slot = slot;
this.one = one;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
slot = buf.readInt();
one = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(x);
buf.writeInt(y);
buf.writeInt(z);
buf.writeInt(slot);
buf.writeBoolean(one);
}
@Override
public IMessage onMessage(MessageStoragePush message, MessageContext context)
{
EntityPlayerMP player = context.getServerHandler().playerEntity;
TileEntity tile = player.worldObj.getTileEntity(new BlockPos(message.x, message.y, message.z));
if (tile instanceof TileController)
{
TileController controller = (TileController) tile;
ItemStack stack;
if (message.slot == -1)
{
stack = player.inventory.getItemStack().copy();
if (message.one)
{
stack.stackSize = 1;
}
}
else
{
stack = player.inventory.getStackInSlot(message.slot);
}
if (stack != null)
{
boolean success = controller.push(stack);
if (success)
{
if (message.slot == -1)
{
if (message.one)
{
player.inventory.getItemStack().stackSize--;
if (player.inventory.getItemStack().stackSize == 0)
{
player.inventory.setItemStack(null);
}
}
else
{
player.inventory.setItemStack(null);
}
player.updateHeldItem();
}
else
{
player.inventory.setInventorySlotContents(message.slot, null);
}
}
}
}
return null;
}
}

127
src/main/java/storagecraft/network/MessageTileUpdate.java
View File

@@ -1,63 +1,64 @@
package storagecraft.network;
import cpw.mods.fml.common.network.simpleimpl.IMessage;
import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
import cpw.mods.fml.common.network.simpleimpl.MessageContext;
import io.netty.buffer.ByteBuf;
import net.minecraft.client.Minecraft;
import net.minecraft.tileentity.TileEntity;
import storagecraft.tile.INetworkTile;
public class MessageTileUpdate implements IMessage, IMessageHandler<MessageTileUpdate, IMessage>
{
private TileEntity tile;
private int x;
private int y;
private int z;
public MessageTileUpdate()
{
}
public MessageTileUpdate(TileEntity tile)
{
this.tile = tile;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
if (Minecraft.getMinecraft().theWorld != null)
{
tile = Minecraft.getMinecraft().theWorld.getTileEntity(x, y, z);
if (tile instanceof INetworkTile)
{
((INetworkTile) tile).fromBytes(buf);
}
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(tile.xCoord);
buf.writeInt(tile.yCoord);
buf.writeInt(tile.zCoord);
if (tile instanceof INetworkTile)
{
((INetworkTile) tile).toBytes(buf);
}
}
@Override
public IMessage onMessage(MessageTileUpdate message, MessageContext ctx)
{
return null;
}
}
package storagecraft.network;
import io.netty.buffer.ByteBuf;
import net.minecraft.client.Minecraft;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
import storagecraft.tile.INetworkTile;
public class MessageTileUpdate implements IMessage, IMessageHandler<MessageTileUpdate, IMessage>
{
private TileEntity tile;
private int x;
private int y;
private int z;
public MessageTileUpdate()
{
}
public MessageTileUpdate(TileEntity tile)
{
this.tile = tile;
}
@Override
public void fromBytes(ByteBuf buf)
{
x = buf.readInt();
y = buf.readInt();
z = buf.readInt();
if (Minecraft.getMinecraft().theWorld != null)
{
tile = Minecraft.getMinecraft().theWorld.getTileEntity(new BlockPos(x, y, z));
if (tile instanceof INetworkTile)
{
((INetworkTile) tile).fromBytes(buf);
}
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(tile.getPos().getX());
buf.writeInt(tile.getPos().getY());
buf.writeInt(tile.getPos().getZ());
if (tile instanceof INetworkTile)
{
((INetworkTile) tile).toBytes(buf);
}
}
@Override
public IMessage onMessage(MessageTileUpdate message, MessageContext ctx)
{
return null;
}
}

46
src/main/java/storagecraft/proxy/ClientProxy.java
View File

@@ -1,23 +1,23 @@
package storagecraft.proxy;
import cpw.mods.fml.client.registry.ClientRegistry;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import net.minecraft.item.Item;
import net.minecraftforge.client.MinecraftForgeClient;
import storagecraft.StorageCraftBlocks;
import storagecraft.render.BlockCableRenderer;
import storagecraft.render.ItemCableRenderer;
import storagecraft.tile.TileCable;
public class ClientProxy extends CommonProxy
{
@Override
public void preInit(FMLPreInitializationEvent e)
{
super.preInit(e);
ClientRegistry.bindTileEntitySpecialRenderer(TileCable.class, new BlockCableRenderer());
MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(StorageCraftBlocks.CABLE), new ItemCableRenderer());
}
}
package storagecraft.proxy;
import net.minecraft.item.Item;
import net.minecraftforge.client.MinecraftForgeClient;
import net.minecraftforge.fml.client.registry.ClientRegistry;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import storagecraft.StorageCraftBlocks;
import storagecraft.render.BlockCableRenderer;
import storagecraft.render.ItemCableRenderer;
import storagecraft.tile.TileCable;
public class ClientProxy extends CommonProxy
{
@Override
public void preInit(FMLPreInitializationEvent e)
{
super.preInit(e);
ClientRegistry.bindTileEntitySpecialRenderer(TileCable.class, new BlockCableRenderer());
MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(StorageCraftBlocks.CABLE), new ItemCableRenderer());
}
}

758
src/main/java/storagecraft/proxy/CommonProxy.java
View File

@@ -1,379 +1,379 @@
package storagecraft.proxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkRegistry;
import cpw.mods.fml.common.registry.GameRegistry;
import cpw.mods.fml.relauncher.Side;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftBlocks;
import storagecraft.StorageCraftItems;
import storagecraft.gui.GuiHandler;
import storagecraft.item.ItemBlockCable;
import storagecraft.item.ItemBlockGrid;
import storagecraft.item.ItemCore;
import storagecraft.item.ItemProcessor;
import storagecraft.item.ItemStorageCell;
import storagecraft.item.ItemStoragePart;
import storagecraft.network.MessageCompareUpdate;
import storagecraft.network.MessageDetectorAmountUpdate;
import storagecraft.network.MessageDetectorModeUpdate;
import storagecraft.network.MessageGridCraftingClear;
import storagecraft.network.MessageGridCraftingUpdate;
import storagecraft.network.MessageImporterModeUpdate;
import storagecraft.network.MessageRedstoneModeUpdate;
import storagecraft.network.MessageStoragePull;
import storagecraft.network.MessageStoragePush;
import storagecraft.network.MessageTileUpdate;
import storagecraft.tile.TileCable;
import storagecraft.tile.TileConstructor;
import storagecraft.tile.TileController;
import storagecraft.tile.TileDestructor;
import storagecraft.tile.TileDetector;
import storagecraft.tile.TileDrive;
import storagecraft.tile.TileExporter;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileImporter;
import storagecraft.tile.TileSolderer;
import storagecraft.tile.TileExternalStorage;
import storagecraft.tile.TileWirelessTransmitter;
import storagecraft.tile.solderer.SoldererRecipeCraftingGrid;
import storagecraft.tile.solderer.SoldererRecipeDrive;
import storagecraft.tile.solderer.SoldererRecipePrintedProcessor;
import storagecraft.tile.solderer.SoldererRecipeProcessor;
import storagecraft.tile.solderer.SoldererRecipeWirelessGrid;
import storagecraft.tile.solderer.SoldererRegistry;
public class CommonProxy
{
public void preInit(FMLPreInitializationEvent e)
{
StorageCraft.NETWORK.registerMessage(MessageTileUpdate.class, MessageTileUpdate.class, 0, Side.CLIENT);
StorageCraft.NETWORK.registerMessage(MessageRedstoneModeUpdate.class, MessageRedstoneModeUpdate.class, 1, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageStoragePush.class, MessageStoragePush.class, 2, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageStoragePull.class, MessageStoragePull.class, 3, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageCompareUpdate.class, MessageCompareUpdate.class, 4, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageImporterModeUpdate.class, MessageImporterModeUpdate.class, 5, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageDetectorModeUpdate.class, MessageDetectorModeUpdate.class, 6, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageDetectorAmountUpdate.class, MessageDetectorAmountUpdate.class, 7, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageGridCraftingUpdate.class, MessageGridCraftingUpdate.class, 8, Side.CLIENT);
StorageCraft.NETWORK.registerMessage(MessageGridCraftingClear.class, MessageGridCraftingClear.class, 9, Side.SERVER);
NetworkRegistry.INSTANCE.registerGuiHandler(StorageCraft.INSTANCE, new GuiHandler());
GameRegistry.registerTileEntity(TileController.class, "controller");
GameRegistry.registerTileEntity(TileCable.class, "cable");
GameRegistry.registerTileEntity(TileGrid.class, "grid");
GameRegistry.registerTileEntity(TileDrive.class, "drive");
GameRegistry.registerTileEntity(TileExternalStorage.class, "externalStorage");
GameRegistry.registerTileEntity(TileImporter.class, "importer");
GameRegistry.registerTileEntity(TileExporter.class, "exporter");
GameRegistry.registerTileEntity(TileDetector.class, "detector");
GameRegistry.registerTileEntity(TileSolderer.class, "solderer");
GameRegistry.registerTileEntity(TileWirelessTransmitter.class, "wirelessTransmitter");
GameRegistry.registerTileEntity(TileDestructor.class, "destructor");
GameRegistry.registerTileEntity(TileConstructor.class, "constructor");
GameRegistry.registerBlock(StorageCraftBlocks.CONTROLLER, "controller");
GameRegistry.registerBlock(StorageCraftBlocks.CABLE, ItemBlockCable.class, "cable");
GameRegistry.registerBlock(StorageCraftBlocks.GRID, ItemBlockGrid.class, "grid");
GameRegistry.registerBlock(StorageCraftBlocks.DRIVE, "drive");
GameRegistry.registerBlock(StorageCraftBlocks.EXTERNAL_STORAGE, "externalStorage");
GameRegistry.registerBlock(StorageCraftBlocks.IMPORTER, "importer");
GameRegistry.registerBlock(StorageCraftBlocks.EXPORTER, "exporter");
GameRegistry.registerBlock(StorageCraftBlocks.DETECTOR, "detector");
GameRegistry.registerBlock(StorageCraftBlocks.MACHINE_CASING, "machineCasing");
GameRegistry.registerBlock(StorageCraftBlocks.SOLDERER, "solderer");
GameRegistry.registerBlock(StorageCraftBlocks.WIRELESS_TRANSMITTER, "wirelessTransmitter");
GameRegistry.registerBlock(StorageCraftBlocks.DESTRUCTOR, "destructor");
GameRegistry.registerBlock(StorageCraftBlocks.CONSTRUCTOR, "constructor");
GameRegistry.registerItem(StorageCraftItems.STORAGE_CELL, "storageCell");
GameRegistry.registerItem(StorageCraftItems.WIRELESS_GRID, "wirelessGrid");
GameRegistry.registerItem(StorageCraftItems.WIRELESS_GRID_PLATE, "wirelessGridPlate");
GameRegistry.registerItem(StorageCraftItems.QUARTZ_ENRICHED_IRON, "storigiumIngot");
GameRegistry.registerItem(StorageCraftItems.CORE, "core");
GameRegistry.registerItem(StorageCraftItems.SILICON, "silicon");
GameRegistry.registerItem(StorageCraftItems.PROCESSOR, "processor");
GameRegistry.registerItem(StorageCraftItems.STORAGE_PART, "storagePart");
// Processors
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_BASIC));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_IMPROVED));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_ADVANCED));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_SILICON));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_BASIC));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_IMPROVED));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_ADVANCED));
// Silicon
GameRegistry.addSmelting(Items.quartz, new ItemStack(StorageCraftItems.SILICON), 0.5f);
// Quartz Enriched Iron
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON, 4),
"II",
"IQ",
'I', new ItemStack(Items.iron_ingot),
'Q', new ItemStack(Items.quartz)
);
// Machine Casing
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.MACHINE_CASING),
"EEE",
"E E",
"EEE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
// Construction Core
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
new ItemStack(Items.glowstone_dust)
);
// Destruction Core
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
new ItemStack(Items.quartz)
);
// Controller
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.CONTROLLER),
"EDE",
"SRS",
"ESE",
'D', new ItemStack(Items.diamond),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'R', new ItemStack(Items.redstone),
'S', new ItemStack(StorageCraftItems.SILICON)
);
// Solderer
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.SOLDERER),
"ESE",
"E E",
"ESE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'S', new ItemStack(Blocks.sticky_piston)
);
// Drive
SoldererRegistry.addRecipe(new SoldererRecipeDrive());
// Cable
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.CABLE, 6, 0),
"EEE",
"GRG",
"EEE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone)
);
// Sensitive Cable
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.CABLE, 1, 1),
new ItemStack(StorageCraftBlocks.CABLE, 1, 0),
new ItemStack(Items.redstone)
);
// Grid
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.GRID, 1, 0),
"ECE",
"PMP",
"EDE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING)
);
// Crafting Grid
SoldererRegistry.addRecipe(new SoldererRecipeCraftingGrid());
// Wireless Transmitter
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.WIRELESS_TRANSMITTER),
"EPE",
"EME",
"EAE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'A', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_ADVANCED),
'P', new ItemStack(Items.ender_pearl),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING)
);
// Wireless Grid Plate
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.WIRELESS_GRID_PLATE),
" P ",
"ERE",
"EEE",
'P', new ItemStack(Items.ender_pearl),
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
// Wireless Grid
SoldererRegistry.addRecipe(new SoldererRecipeWirelessGrid(0));
SoldererRegistry.addRecipe(new SoldererRecipeWirelessGrid(1));
// External Storage
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.EXTERNAL_STORAGE),
"CED",
"HMH",
"EPE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'H', new ItemStack(Blocks.chest),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Importer
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.IMPORTER),
new ItemStack(StorageCraftBlocks.MACHINE_CASING),
new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC)
);
// Exporter
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.EXPORTER),
new ItemStack(StorageCraftBlocks.MACHINE_CASING),
new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC)
);
// Destructor
GameRegistry.addShapedRecipe(new ItemStack(StorageCraftBlocks.DESTRUCTOR),
"EDE",
"RMR",
"EIE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'R', new ItemStack(Items.redstone),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'I', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Constructor
GameRegistry.addShapedRecipe(new ItemStack(StorageCraftBlocks.CONSTRUCTOR),
"ECE",
"RMR",
"EIE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'R', new ItemStack(Items.redstone),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'I', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Detector
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.DETECTOR),
"ECE",
"RMR",
"EPE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'R', new ItemStack(Items.redstone),
'C', new ItemStack(Items.comparator),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Storage Cell Parts
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.SILICON),
'S', new ItemStack(Blocks.glass)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_64K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_ADVANCED),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K)
);
// Storage Cells
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_1K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_4K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_16K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_64K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_64K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
}
public void init(FMLInitializationEvent e)
{
}
public void postInit(FMLPostInitializationEvent e)
{
}
}
package storagecraft.proxy;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
import net.minecraftforge.fml.common.network.NetworkRegistry;
import net.minecraftforge.fml.common.registry.GameRegistry;
import net.minecraftforge.fml.relauncher.Side;
import storagecraft.StorageCraft;
import storagecraft.StorageCraftBlocks;
import storagecraft.StorageCraftItems;
import storagecraft.gui.GuiHandler;
import storagecraft.item.ItemBlockCable;
import storagecraft.item.ItemBlockGrid;
import storagecraft.item.ItemCore;
import storagecraft.item.ItemProcessor;
import storagecraft.item.ItemStorageCell;
import storagecraft.item.ItemStoragePart;
import storagecraft.network.MessageCompareUpdate;
import storagecraft.network.MessageDetectorAmountUpdate;
import storagecraft.network.MessageDetectorModeUpdate;
import storagecraft.network.MessageGridCraftingClear;
import storagecraft.network.MessageGridCraftingUpdate;
import storagecraft.network.MessageImporterModeUpdate;
import storagecraft.network.MessageRedstoneModeUpdate;
import storagecraft.network.MessageStoragePull;
import storagecraft.network.MessageStoragePush;
import storagecraft.network.MessageTileUpdate;
import storagecraft.tile.TileCable;
import storagecraft.tile.TileConstructor;
import storagecraft.tile.TileController;
import storagecraft.tile.TileDestructor;
import storagecraft.tile.TileDetector;
import storagecraft.tile.TileDrive;
import storagecraft.tile.TileExporter;
import storagecraft.tile.TileGrid;
import storagecraft.tile.TileImporter;
import storagecraft.tile.TileSolderer;
import storagecraft.tile.TileExternalStorage;
import storagecraft.tile.TileWirelessTransmitter;
import storagecraft.tile.solderer.SoldererRecipeCraftingGrid;
import storagecraft.tile.solderer.SoldererRecipeDrive;
import storagecraft.tile.solderer.SoldererRecipePrintedProcessor;
import storagecraft.tile.solderer.SoldererRecipeProcessor;
import storagecraft.tile.solderer.SoldererRecipeWirelessGrid;
import storagecraft.tile.solderer.SoldererRegistry;
public class CommonProxy
{
public void preInit(FMLPreInitializationEvent e)
{
StorageCraft.NETWORK.registerMessage(MessageTileUpdate.class, MessageTileUpdate.class, 0, Side.CLIENT);
StorageCraft.NETWORK.registerMessage(MessageRedstoneModeUpdate.class, MessageRedstoneModeUpdate.class, 1, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageStoragePush.class, MessageStoragePush.class, 2, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageStoragePull.class, MessageStoragePull.class, 3, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageCompareUpdate.class, MessageCompareUpdate.class, 4, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageImporterModeUpdate.class, MessageImporterModeUpdate.class, 5, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageDetectorModeUpdate.class, MessageDetectorModeUpdate.class, 6, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageDetectorAmountUpdate.class, MessageDetectorAmountUpdate.class, 7, Side.SERVER);
StorageCraft.NETWORK.registerMessage(MessageGridCraftingUpdate.class, MessageGridCraftingUpdate.class, 8, Side.CLIENT);
StorageCraft.NETWORK.registerMessage(MessageGridCraftingClear.class, MessageGridCraftingClear.class, 9, Side.SERVER);
NetworkRegistry.INSTANCE.registerGuiHandler(StorageCraft.INSTANCE, new GuiHandler());
GameRegistry.registerTileEntity(TileController.class, "controller");
GameRegistry.registerTileEntity(TileCable.class, "cable");
GameRegistry.registerTileEntity(TileGrid.class, "grid");
GameRegistry.registerTileEntity(TileDrive.class, "drive");
GameRegistry.registerTileEntity(TileExternalStorage.class, "externalStorage");
GameRegistry.registerTileEntity(TileImporter.class, "importer");
GameRegistry.registerTileEntity(TileExporter.class, "exporter");
GameRegistry.registerTileEntity(TileDetector.class, "detector");
GameRegistry.registerTileEntity(TileSolderer.class, "solderer");
GameRegistry.registerTileEntity(TileWirelessTransmitter.class, "wirelessTransmitter");
GameRegistry.registerTileEntity(TileDestructor.class, "destructor");
GameRegistry.registerTileEntity(TileConstructor.class, "constructor");
GameRegistry.registerBlock(StorageCraftBlocks.CONTROLLER, "controller");
GameRegistry.registerBlock(StorageCraftBlocks.CABLE, ItemBlockCable.class, "cable");
GameRegistry.registerBlock(StorageCraftBlocks.GRID, ItemBlockGrid.class, "grid");
GameRegistry.registerBlock(StorageCraftBlocks.DRIVE, "drive");
GameRegistry.registerBlock(StorageCraftBlocks.EXTERNAL_STORAGE, "externalStorage");
GameRegistry.registerBlock(StorageCraftBlocks.IMPORTER, "importer");
GameRegistry.registerBlock(StorageCraftBlocks.EXPORTER, "exporter");
GameRegistry.registerBlock(StorageCraftBlocks.DETECTOR, "detector");
GameRegistry.registerBlock(StorageCraftBlocks.MACHINE_CASING, "machineCasing");
GameRegistry.registerBlock(StorageCraftBlocks.SOLDERER, "solderer");
GameRegistry.registerBlock(StorageCraftBlocks.WIRELESS_TRANSMITTER, "wirelessTransmitter");
GameRegistry.registerBlock(StorageCraftBlocks.DESTRUCTOR, "destructor");
GameRegistry.registerBlock(StorageCraftBlocks.CONSTRUCTOR, "constructor");
GameRegistry.registerItem(StorageCraftItems.STORAGE_CELL, "storageCell");
GameRegistry.registerItem(StorageCraftItems.WIRELESS_GRID, "wirelessGrid");
GameRegistry.registerItem(StorageCraftItems.WIRELESS_GRID_PLATE, "wirelessGridPlate");
GameRegistry.registerItem(StorageCraftItems.QUARTZ_ENRICHED_IRON, "storigiumIngot");
GameRegistry.registerItem(StorageCraftItems.CORE, "core");
GameRegistry.registerItem(StorageCraftItems.SILICON, "silicon");
GameRegistry.registerItem(StorageCraftItems.PROCESSOR, "processor");
GameRegistry.registerItem(StorageCraftItems.STORAGE_PART, "storagePart");
// Processors
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_BASIC));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_IMPROVED));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_ADVANCED));
SoldererRegistry.addRecipe(new SoldererRecipePrintedProcessor(ItemProcessor.TYPE_PRINTED_SILICON));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_BASIC));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_IMPROVED));
SoldererRegistry.addRecipe(new SoldererRecipeProcessor(ItemProcessor.TYPE_ADVANCED));
// Silicon
GameRegistry.addSmelting(Items.quartz, new ItemStack(StorageCraftItems.SILICON), 0.5f);
// Quartz Enriched Iron
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON, 4),
"II",
"IQ",
'I', new ItemStack(Items.iron_ingot),
'Q', new ItemStack(Items.quartz)
);
// Machine Casing
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.MACHINE_CASING),
"EEE",
"E E",
"EEE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
// Construction Core
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
new ItemStack(Items.glowstone_dust)
);
// Destruction Core
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
new ItemStack(Items.quartz)
);
// Controller
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.CONTROLLER),
"EDE",
"SRS",
"ESE",
'D', new ItemStack(Items.diamond),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'R', new ItemStack(Items.redstone),
'S', new ItemStack(StorageCraftItems.SILICON)
);
// Solderer
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.SOLDERER),
"ESE",
"E E",
"ESE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'S', new ItemStack(Blocks.sticky_piston)
);
// Drive
SoldererRegistry.addRecipe(new SoldererRecipeDrive());
// Cable
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.CABLE, 6, 0),
"EEE",
"GRG",
"EEE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone)
);
// Sensitive Cable
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.CABLE, 1, 1),
new ItemStack(StorageCraftBlocks.CABLE, 1, 0),
new ItemStack(Items.redstone)
);
// Grid
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.GRID, 1, 0),
"ECE",
"PMP",
"EDE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING)
);
// Crafting Grid
SoldererRegistry.addRecipe(new SoldererRecipeCraftingGrid());
// Wireless Transmitter
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.WIRELESS_TRANSMITTER),
"EPE",
"EME",
"EAE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'A', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_ADVANCED),
'P', new ItemStack(Items.ender_pearl),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING)
);
// Wireless Grid Plate
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.WIRELESS_GRID_PLATE),
" P ",
"ERE",
"EEE",
'P', new ItemStack(Items.ender_pearl),
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
// Wireless Grid
SoldererRegistry.addRecipe(new SoldererRecipeWirelessGrid(0));
SoldererRegistry.addRecipe(new SoldererRecipeWirelessGrid(1));
// External Storage
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.EXTERNAL_STORAGE),
"CED",
"HMH",
"EPE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'H', new ItemStack(Blocks.chest),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Importer
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.IMPORTER),
new ItemStack(StorageCraftBlocks.MACHINE_CASING),
new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC)
);
// Exporter
GameRegistry.addShapelessRecipe(new ItemStack(StorageCraftBlocks.EXPORTER),
new ItemStack(StorageCraftBlocks.MACHINE_CASING),
new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC)
);
// Destructor
GameRegistry.addShapedRecipe(new ItemStack(StorageCraftBlocks.DESTRUCTOR),
"EDE",
"RMR",
"EIE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'D', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_DESTRUCTION),
'R', new ItemStack(Items.redstone),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'I', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Constructor
GameRegistry.addShapedRecipe(new ItemStack(StorageCraftBlocks.CONSTRUCTOR),
"ECE",
"RMR",
"EIE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'C', new ItemStack(StorageCraftItems.CORE, 1, ItemCore.TYPE_CONSTRUCTION),
'R', new ItemStack(Items.redstone),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'I', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Detector
GameRegistry.addRecipe(new ItemStack(StorageCraftBlocks.DETECTOR),
"ECE",
"RMR",
"EPE",
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'R', new ItemStack(Items.redstone),
'C', new ItemStack(Items.comparator),
'M', new ItemStack(StorageCraftBlocks.MACHINE_CASING),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED)
);
// Storage Cell Parts
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.SILICON),
'S', new ItemStack(Blocks.glass)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_BASIC),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_IMPROVED),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_64K),
"EPE",
"SRS",
"ESE",
'R', new ItemStack(Items.redstone),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON),
'P', new ItemStack(StorageCraftItems.PROCESSOR, 1, ItemProcessor.TYPE_ADVANCED),
'S', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K)
);
// Storage Cells
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_1K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_1K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_4K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_4K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_16K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_16K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
GameRegistry.addRecipe(new ItemStack(StorageCraftItems.STORAGE_CELL, 1, ItemStorageCell.TYPE_64K),
"GRG",
"RPR",
"EEE",
'G', new ItemStack(Blocks.glass),
'R', new ItemStack(Items.redstone),
'P', new ItemStack(StorageCraftItems.STORAGE_PART, 1, ItemStoragePart.TYPE_64K),
'E', new ItemStack(StorageCraftItems.QUARTZ_ENRICHED_IRON)
);
}
public void init(FMLInitializationEvent e)
{
}
public void postInit(FMLPostInitializationEvent e)
{
}
}

46
src/main/java/storagecraft/render/BlockCableRenderer.java
View File

@@ -1,23 +1,23 @@
package storagecraft.render;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import storagecraft.render.model.CableModel;
import storagecraft.tile.TileCable;
public class BlockCableRenderer extends TileEntitySpecialRenderer
{
public static final CableModel CABLE_MODEL = new CableModel();
@Override
public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float scale)
{
GL11.glPushMatrix();
GL11.glTranslatef((float) x, (float) y, (float) z);
CABLE_MODEL.render((TileCable) tile, 0.0625F);
GL11.glPopMatrix();
}
}
package storagecraft.render;
import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer;
import net.minecraft.tileentity.TileEntity;
import org.lwjgl.opengl.GL11;
import storagecraft.render.model.CableModel;
import storagecraft.tile.TileCable;
public class BlockCableRenderer extends TileEntitySpecialRenderer
{
public static final CableModel CABLE_MODEL = new CableModel();
@Override
public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float scale, int a) // @TODO: Find out what a is
{
GL11.glPushMatrix();
GL11.glTranslatef((float) x, (float) y, (float) z);
CABLE_MODEL.render((TileCable) tile, 0.0625F);
GL11.glPopMatrix();
}
}

14
src/main/java/storagecraft/render/model/CableModel.java
View File

@@ -4,8 +4,8 @@ import net.minecraft.client.Minecraft;
import net.minecraft.client.model.ModelBase;
import net.minecraft.client.model.ModelRenderer;
import net.minecraft.item.ItemStack;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ResourceLocation;
import net.minecraftforge.common.util.ForgeDirection;
import storagecraft.tile.TileCable;
public class CableModel extends ModelBase
@@ -100,32 +100,32 @@ public class CableModel extends ModelBase
Minecraft.getMinecraft().renderEngine.bindTexture(CABLE_RESOURCE);
}
if (cable.hasConnection(ForgeDirection.UP))
if (cable.hasConnection(EnumFacing.UP))
{
up.render(x);
}
if (cable.hasConnection(ForgeDirection.DOWN))
if (cable.hasConnection(EnumFacing.DOWN))
{
down.render(x);
}
if (cable.hasConnection(ForgeDirection.NORTH))
if (cable.hasConnection(EnumFacing.NORTH))
{
north.render(x);
}
if (cable.hasConnection(ForgeDirection.EAST))
if (cable.hasConnection(EnumFacing.EAST))
{
east.render(x);
}
if (cable.hasConnection(ForgeDirection.SOUTH))
if (cable.hasConnection(EnumFacing.SOUTH))
{
south.render(x);
}
if (cable.hasConnection(ForgeDirection.WEST))
if (cable.hasConnection(EnumFacing.WEST))
{
west.render(x);
}

256
src/main/java/storagecraft/storage/CellStorage.java
View File

@@ -1,128 +1,128 @@
package storagecraft.storage;
import java.util.List;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import storagecraft.item.ItemStorageCell;
public class CellStorage implements IStorage
{
public static final String NBT_ITEMS = "Items";
public static final String NBT_STORED = "Stored";
public static final String NBT_ITEM_TYPE = "Type";
public static final String NBT_ITEM_QUANTITY = "Quantity";
public static final String NBT_ITEM_DAMAGE = "Damage";
public static final String NBT_ITEM_NBT = "NBT";
private ItemStack cell;
public CellStorage(ItemStack cell)
{
this.cell = cell;
}
@Override
public void addItems(List<StorageItem> items)
{
NBTTagList list = (NBTTagList) cell.stackTagCompound.getTag(NBT_ITEMS);
for (int i = 0; i < list.tagCount(); ++i)
{
items.add(createItemFromNBT(list.getCompoundTagAt(i)));
}
}
@Override
public void push(ItemStack stack)
{
NBTTagList list = (NBTTagList) cell.stackTagCompound.getTag(NBT_ITEMS);
cell.stackTagCompound.setInteger(NBT_STORED, ItemStorageCell.getStored(cell) + stack.stackSize);
for (int i = 0; i < list.tagCount(); ++i)
{
NBTTagCompound tag = list.getCompoundTagAt(i);
StorageItem item = createItemFromNBT(tag);
if (item.compareNoQuantity(stack))
{
tag.setInteger(NBT_ITEM_QUANTITY, item.getQuantity() + stack.stackSize);
return;
}
}
NBTTagCompound tag = new NBTTagCompound();
tag.setInteger(NBT_ITEM_TYPE, Item.getIdFromItem(stack.getItem()));
tag.setInteger(NBT_ITEM_QUANTITY, stack.stackSize);
tag.setInteger(NBT_ITEM_DAMAGE, stack.getItemDamage());
if (stack.stackTagCompound != null)
{
tag.setTag(NBT_ITEM_NBT, stack.stackTagCompound);
}
list.appendTag(tag);
}
@Override
public ItemStack take(ItemStack stack, int flags)
{
int quantity = stack.stackSize;
NBTTagList list = (NBTTagList) cell.stackTagCompound.getTag(NBT_ITEMS);
for (int i = 0; i < list.tagCount(); ++i)
{
NBTTagCompound tag = list.getCompoundTagAt(i);
StorageItem item = createItemFromNBT(tag);
if (item.compare(stack, flags))
{
if (quantity > item.getQuantity())
{
quantity = item.getQuantity();
}
tag.setInteger(NBT_ITEM_QUANTITY, item.getQuantity() - quantity);
if (item.getQuantity() - quantity == 0)
{
list.removeTag(i);
}
cell.stackTagCompound.setInteger(NBT_STORED, ItemStorageCell.getStored(cell) - quantity);
ItemStack newItem = item.toItemStack();
newItem.stackSize = quantity;
return newItem;
}
}
return null;
}
@Override
public boolean canPush(ItemStack stack)
{
if (ItemStorageCell.getCapacity(cell) == -1)
{
return true;
}
return (ItemStorageCell.getStored(cell) + stack.stackSize) <= ItemStorageCell.getCapacity(cell);
}
private StorageItem createItemFromNBT(NBTTagCompound tag)
{
return new StorageItem(Item.getItemById(tag.getInteger(NBT_ITEM_TYPE)), tag.getInteger(NBT_ITEM_QUANTITY), tag.getInteger(NBT_ITEM_DAMAGE), tag.hasKey(NBT_ITEM_NBT) ? ((NBTTagCompound) tag.getTag(NBT_ITEM_NBT)) : null);
}
}
package storagecraft.storage;
import java.util.List;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import storagecraft.item.ItemStorageCell;
public class CellStorage implements IStorage
{
public static final String NBT_ITEMS = "Items";
public static final String NBT_STORED = "Stored";
public static final String NBT_ITEM_TYPE = "Type";
public static final String NBT_ITEM_QUANTITY = "Quantity";
public static final String NBT_ITEM_DAMAGE = "Damage";
public static final String NBT_ITEM_NBT = "NBT";
private ItemStack cell;
public CellStorage(ItemStack cell)
{
this.cell = cell;
}
@Override
public void addItems(List<StorageItem> items)
{
NBTTagList list = (NBTTagList) cell.getTagCompound().getTag(NBT_ITEMS);
for (int i = 0; i < list.tagCount(); ++i)
{
items.add(createItemFromNBT(list.getCompoundTagAt(i)));
}
}
@Override
public void push(ItemStack stack)
{
NBTTagList list = (NBTTagList) cell.getTagCompound().getTag(NBT_ITEMS);
cell.getTagCompound().setInteger(NBT_STORED, ItemStorageCell.getStored(cell) + stack.stackSize);
for (int i = 0; i < list.tagCount(); ++i)
{
NBTTagCompound tag = list.getCompoundTagAt(i);
StorageItem item = createItemFromNBT(tag);
if (item.compareNoQuantity(stack))
{
tag.setInteger(NBT_ITEM_QUANTITY, item.getQuantity() + stack.stackSize);
return;
}
}
NBTTagCompound tag = new NBTTagCompound();
tag.setInteger(NBT_ITEM_TYPE, Item.getIdFromItem(stack.getItem()));
tag.setInteger(NBT_ITEM_QUANTITY, stack.stackSize);
tag.setInteger(NBT_ITEM_DAMAGE, stack.getItemDamage());
if (stack.hasTagCompound())
{
tag.setTag(NBT_ITEM_NBT, stack.getTagCompound());
}
list.appendTag(tag);
}
@Override
public ItemStack take(ItemStack stack, int flags)
{
int quantity = stack.stackSize;
NBTTagList list = (NBTTagList) cell.getTagCompound().getTag(NBT_ITEMS);
for (int i = 0; i < list.tagCount(); ++i)
{
NBTTagCompound tag = list.getCompoundTagAt(i);
StorageItem item = createItemFromNBT(tag);
if (item.compare(stack, flags))
{
if (quantity > item.getQuantity())
{
quantity = item.getQuantity();
}
tag.setInteger(NBT_ITEM_QUANTITY, item.getQuantity() - quantity);
if (item.getQuantity() - quantity == 0)
{
list.removeTag(i);
}
cell.getTagCompound().setInteger(NBT_STORED, ItemStorageCell.getStored(cell) - quantity);
ItemStack newItem = item.toItemStack();
newItem.stackSize = quantity;
return newItem;
}
}
return null;
}
@Override
public boolean canPush(ItemStack stack)
{
if (ItemStorageCell.getCapacity(cell) == -1)
{
return true;
}
return (ItemStorageCell.getStored(cell) + stack.stackSize) <= ItemStorageCell.getCapacity(cell);
}
private StorageItem createItemFromNBT(NBTTagCompound tag)
{
return new StorageItem(Item.getItemById(tag.getInteger(NBT_ITEM_TYPE)), tag.getInteger(NBT_ITEM_QUANTITY), tag.getInteger(NBT_ITEM_DAMAGE), tag.hasKey(NBT_ITEM_NBT) ? ((NBTTagCompound) tag.getTag(NBT_ITEM_NBT)) : null);
}
}

382
src/main/java/storagecraft/storage/StorageItem.java
View File

@@ -1,191 +1,191 @@
package storagecraft.storage;
import cpw.mods.fml.common.network.ByteBufUtils;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import io.netty.buffer.ByteBuf;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.util.InventoryUtils;
public class StorageItem
{
private Item type;
private int quantity;
private int damage;
private NBTTagCompound tag;
@SideOnly(Side.CLIENT)
private int id;
public StorageItem(ByteBuf buf)
{
this.id = buf.readInt();
this.type = Item.getItemById(buf.readInt());
this.quantity = buf.readInt();
this.damage = buf.readInt();
this.tag = buf.readBoolean() ? ByteBufUtils.readTag(buf) : null;
}
public StorageItem(Item type, int quantity, int damage, NBTTagCompound tag)
{
this.type = type;
this.quantity = quantity;
this.damage = damage;
this.tag = tag;
}
public StorageItem(Item type, int quantity, int damage, NBTTagCompound tag, int id)
{
this(type, quantity, damage, tag);
this.id = id;
}
public StorageItem(ItemStack stack)
{
this(stack.getItem(), stack.stackSize, stack.getItemDamage(), stack.stackTagCompound);
}
public void toBytes(ByteBuf buf, int id)
{
buf.writeInt(id);
buf.writeInt(Item.getIdFromItem(type));
buf.writeInt(quantity);
buf.writeInt(damage);
buf.writeBoolean(tag != null);
if (tag != null)
{
ByteBufUtils.writeTag(buf, tag);
}
}
public Item getType()
{
return type;
}
public int getQuantity()
{
return quantity;
}
public void setQuantity(int quantity)
{
this.quantity = quantity;
}
public int getDamage()
{
return damage;
}
public void setDamage(int damage)
{
this.damage = damage;
}
public NBTTagCompound getTag()
{
return tag;
}
public void setTag(NBTTagCompound tag)
{
this.tag = tag;
}
@SideOnly(Side.CLIENT)
public int getId()
{
return id;
}
public StorageItem copy()
{
return copy(quantity);
}
public StorageItem copy(int newQuantity)
{
return new StorageItem(type, newQuantity, damage, tag);
}
public ItemStack toItemStack()
{
ItemStack stack = new ItemStack(type, quantity, damage);
stack.stackTagCompound = tag;
return stack;
}
public boolean compare(StorageItem other, int flags)
{
if ((flags & InventoryUtils.COMPARE_DAMAGE) == InventoryUtils.COMPARE_DAMAGE)
{
if (damage != other.getDamage())
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_NBT) == InventoryUtils.COMPARE_NBT)
{
if (tag != null && !tag.equals(other.getTag()))
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_QUANTITY) == InventoryUtils.COMPARE_QUANTITY)
{
if (quantity != other.getQuantity())
{
return false;
}
}
return type == other.getType();
}
public boolean compare(ItemStack stack, int flags)
{
if ((flags & InventoryUtils.COMPARE_DAMAGE) == InventoryUtils.COMPARE_DAMAGE)
{
if (damage != stack.getItemDamage())
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_NBT) == InventoryUtils.COMPARE_NBT)
{
if (tag != null && !tag.equals(stack.stackTagCompound))
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_QUANTITY) == InventoryUtils.COMPARE_QUANTITY)
{
if (quantity != stack.stackSize)
{
return false;
}
}
return type == stack.getItem();
}
public boolean compareNoQuantity(StorageItem other)
{
return compare(other, InventoryUtils.COMPARE_NBT | InventoryUtils.COMPARE_DAMAGE);
}
public boolean compareNoQuantity(ItemStack stack)
{
return compare(stack, InventoryUtils.COMPARE_NBT | InventoryUtils.COMPARE_DAMAGE);
}
}
package storagecraft.storage;
import io.netty.buffer.ByteBuf;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.ByteBufUtils;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import storagecraft.util.InventoryUtils;
public class StorageItem
{
private Item type;
private int quantity;
private int damage;
private NBTTagCompound tag;
@SideOnly(Side.CLIENT)
private int id;
public StorageItem(ByteBuf buf)
{
this.id = buf.readInt();
this.type = Item.getItemById(buf.readInt());
this.quantity = buf.readInt();
this.damage = buf.readInt();
this.tag = buf.readBoolean() ? ByteBufUtils.readTag(buf) : null;
}
public StorageItem(Item type, int quantity, int damage, NBTTagCompound tag)
{
this.type = type;
this.quantity = quantity;
this.damage = damage;
this.tag = tag;
}
public StorageItem(Item type, int quantity, int damage, NBTTagCompound tag, int id)
{
this(type, quantity, damage, tag);
this.id = id;
}
public StorageItem(ItemStack stack)
{
this(stack.getItem(), stack.stackSize, stack.getItemDamage(), stack.getTagCompound());
}
public void toBytes(ByteBuf buf, int id)
{
buf.writeInt(id);
buf.writeInt(Item.getIdFromItem(type));
buf.writeInt(quantity);
buf.writeInt(damage);
buf.writeBoolean(tag != null);
if (tag != null)
{
ByteBufUtils.writeTag(buf, tag);
}
}
public Item getType()
{
return type;
}
public int getQuantity()
{
return quantity;
}
public void setQuantity(int quantity)
{
this.quantity = quantity;
}
public int getDamage()
{
return damage;
}
public void setDamage(int damage)
{
this.damage = damage;
}
public NBTTagCompound getTag()
{
return tag;
}
public void setTag(NBTTagCompound tag)
{
this.tag = tag;
}
@SideOnly(Side.CLIENT)
public int getId()
{
return id;
}
public StorageItem copy()
{
return copy(quantity);
}
public StorageItem copy(int newQuantity)
{
return new StorageItem(type, newQuantity, damage, tag);
}
public ItemStack toItemStack()
{
ItemStack stack = new ItemStack(type, quantity, damage);
stack.setTagCompound(tag);
return stack;
}
public boolean compare(StorageItem other, int flags)
{
if ((flags & InventoryUtils.COMPARE_DAMAGE) == InventoryUtils.COMPARE_DAMAGE)
{
if (damage != other.getDamage())
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_NBT) == InventoryUtils.COMPARE_NBT)
{
if (tag != null && !tag.equals(other.getTag()))
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_QUANTITY) == InventoryUtils.COMPARE_QUANTITY)
{
if (quantity != other.getQuantity())
{
return false;
}
}
return type == other.getType();
}
public boolean compare(ItemStack stack, int flags)
{
if ((flags & InventoryUtils.COMPARE_DAMAGE) == InventoryUtils.COMPARE_DAMAGE)
{
if (damage != stack.getItemDamage())
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_NBT) == InventoryUtils.COMPARE_NBT)
{
if (tag != null && !tag.equals(stack.getTagCompound()))
{
return false;
}
}
if ((flags & InventoryUtils.COMPARE_QUANTITY) == InventoryUtils.COMPARE_QUANTITY)
{
if (quantity != stack.stackSize)
{
return false;
}
}
return type == stack.getItem();
}
public boolean compareNoQuantity(StorageItem other)
{
return compare(other, InventoryUtils.COMPARE_NBT | InventoryUtils.COMPARE_DAMAGE);
}
public boolean compareNoQuantity(ItemStack stack)
{
return compare(stack, InventoryUtils.COMPARE_NBT | InventoryUtils.COMPARE_DAMAGE);
}
}

26
src/main/java/storagecraft/tile/ICompareSetting.java
View File

@@ -1,14 +1,12 @@
package storagecraft.tile;
public interface ICompareSetting
{
public int getCompare();
public void setCompare(int compare);
public int getX();
public int getY();
public int getZ();
}
package storagecraft.tile;
import net.minecraft.util.BlockPos;
public interface ICompareSetting
{
public int getCompare();
public void setCompare(int compare);
public BlockPos getPos();
}

29
src/main/java/storagecraft/tile/INetworkTile.java
View File

@@ -1,16 +1,13 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
public interface INetworkTile
{
public void fromBytes(ByteBuf buf);
public void toBytes(ByteBuf buf);
public int getX();
public int getY();
public int getZ();
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.util.BlockPos;
public interface INetworkTile
{
public void fromBytes(ByteBuf buf);
public void toBytes(ByteBuf buf);
public BlockPos getPos();
}

26
src/main/java/storagecraft/tile/IRedstoneModeSetting.java
View File

@@ -1,14 +1,12 @@
package storagecraft.tile;
public interface IRedstoneModeSetting
{
public RedstoneMode getRedstoneMode();
public void setRedstoneMode(RedstoneMode mode);
public int getX();
public int getY();
public int getZ();
}
package storagecraft.tile;
import net.minecraft.util.BlockPos;
public interface IRedstoneModeSetting
{
public RedstoneMode getRedstoneMode();
public void setRedstoneMode(RedstoneMode mode);
public BlockPos getPos();
}

119
src/main/java/storagecraft/tile/RedstoneMode.java
View File

@@ -1,59 +1,60 @@
package storagecraft.tile;
import net.minecraft.world.World;
public enum RedstoneMode
{
IGNORE(0),
HIGH(1),
LOW(2);
public static final String NBT = "RedstoneMode";
public final int id;
RedstoneMode(int id)
{
this.id = id;
}
public RedstoneMode next()
{
RedstoneMode next = getById(id + 1);
if (next == null)
{
return getById(0);
}
return next;
}
public boolean isEnabled(World world, int x, int y, int z)
{
switch (this)
{
case IGNORE:
return true;
case HIGH:
return world.isBlockIndirectlyGettingPowered(x, y, z);
case LOW:
return !world.isBlockIndirectlyGettingPowered(x, y, z);
}
return false;
}
public static RedstoneMode getById(int id)
{
for (RedstoneMode control : values())
{
if (control.id == id)
{
return control;
}
}
return null;
}
}
package storagecraft.tile;
import net.minecraft.util.BlockPos;
import net.minecraft.world.World;
public enum RedstoneMode
{
IGNORE(0),
HIGH(1),
LOW(2);
public static final String NBT = "RedstoneMode";
public final int id;
RedstoneMode(int id)
{
this.id = id;
}
public RedstoneMode next()
{
RedstoneMode next = getById(id + 1);
if (next == null)
{
return getById(0);
}
return next;
}
public boolean isEnabled(World world, BlockPos pos)
{
switch (this)
{
case IGNORE:
return true;
case HIGH:
return true; // @TODO: ...
case LOW:
return true;
}
return false;
}
public static RedstoneMode getById(int id)
{
for (RedstoneMode control : values())
{
if (control.id == id)
{
return control;
}
}
return null;
}
}

171
src/main/java/storagecraft/tile/TileBase.java
View File

@@ -1,86 +1,85 @@
package storagecraft.tile;
import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint;
import net.minecraft.inventory.IInventory;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import storagecraft.StorageCraft;
import storagecraft.network.MessageTileUpdate;
public abstract class TileBase extends TileEntity
{
public static final int UPDATE_RANGE = 256;
private ForgeDirection direction = ForgeDirection.UNKNOWN;
protected int ticks;
@Override
public void updateEntity()
{
super.updateEntity();
ticks++;
if (!worldObj.isRemote)
{
if (this instanceof INetworkTile)
{
TargetPoint target = new TargetPoint(worldObj.provider.dimensionId, xCoord, yCoord, zCoord, UPDATE_RANGE);
StorageCraft.NETWORK.sendToAllAround(new MessageTileUpdate(this), target);
}
}
}
public void setDirection(ForgeDirection direction)
{
this.direction = direction;
}
public ForgeDirection getDirection()
{
return direction;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
direction = ForgeDirection.getOrientation(nbt.getInteger("Direction"));
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("Direction", direction.ordinal());
}
@Override
public Packet getDescriptionPacket()
{
NBTTagCompound nbt = new NBTTagCompound();
nbt.setInteger("Direction", direction.ordinal());
return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, nbt);
}
@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet)
{
direction = ForgeDirection.getOrientation(packet.func_148857_g().getInteger("Direction"));
}
public IInventory getDroppedInventory()
{
return null;
}
}
package storagecraft.tile;
import net.minecraft.inventory.IInventory;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.server.gui.IUpdatePlayerListBox;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraftforge.fml.common.network.NetworkRegistry.TargetPoint;
import storagecraft.StorageCraft;
import storagecraft.network.MessageTileUpdate;
public abstract class TileBase extends TileEntity implements IUpdatePlayerListBox
{
public static final int UPDATE_RANGE = 256;
private EnumFacing direction;
protected int ticks;
@Override
public void update()
{
ticks++;
if (!worldObj.isRemote)
{
if (this instanceof INetworkTile)
{
TargetPoint target = new TargetPoint(worldObj.provider.getDimensionId(), pos.getX(), pos.getY(), pos.getZ(), UPDATE_RANGE);
StorageCraft.NETWORK.sendToAllAround(new MessageTileUpdate(this), target);
}
}
}
public void setDirection(EnumFacing direction)
{
this.direction = direction;
}
public EnumFacing getDirection()
{
return direction;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
direction = EnumFacing.getFront(nbt.getInteger("Direction"));
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger("Direction", direction.ordinal());
}
@Override
public Packet getDescriptionPacket()
{
NBTTagCompound nbt = new NBTTagCompound();
nbt.setInteger("Direction", direction.ordinal());
return new S35PacketUpdateTileEntity(pos, 1, nbt);
}
@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet)
{
direction = EnumFacing.getFront(packet.getNbtCompound().getInteger("Direction"));
}
public IInventory getDroppedInventory()
{
return null;
}
}

203
src/main/java/storagecraft/tile/TileCable.java
View File

@@ -1,103 +1,100 @@
package storagecraft.tile;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Vec3;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import storagecraft.block.BlockCable;
public class TileCable extends TileBase
{
public static boolean isCable(World world, int x, int y, int z, ForgeDirection dir)
{
Block block = world.getBlock(x + dir.offsetX, y + dir.offsetY, z + dir.offsetZ);
return block instanceof BlockCable;
}
public boolean hasConnection(ForgeDirection dir)
{
if (!isCable(worldObj, xCoord, yCoord, zCoord, dir))
{
TileEntity tile = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ);
return tile instanceof TileMachine || tile instanceof TileController;
}
return true;
}
public boolean isPowered()
{
return worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord);
}
public boolean isSensitiveCable()
{
return worldObj.getBlockMetadata(xCoord, yCoord, zCoord) == 1;
}
public boolean isEnabled()
{
if (isSensitiveCable())
{
return !isPowered();
}
return true;
}
public void addMachines(List<Vec3> visited, List<TileMachine> machines, TileController controller)
{
for (Vec3 visitedBlock : visited)
{
if (visitedBlock.xCoord == xCoord && visitedBlock.yCoord == yCoord && visitedBlock.zCoord == zCoord)
{
return;
}
}
visited.add(Vec3.createVectorHelper(xCoord, yCoord, zCoord));
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
int x = xCoord + dir.offsetX;
int y = yCoord + dir.offsetY;
int z = zCoord + dir.offsetZ;
boolean found = false;
for (Vec3 visitedBlock : visited)
{
if (visitedBlock.xCoord == x && visitedBlock.yCoord == y && visitedBlock.zCoord == z)
{
found = true;
}
}
if (found)
{
continue;
}
TileEntity tile = worldObj.getTileEntity(x, y, z);
if (tile instanceof TileMachine && ((TileMachine) tile).getRedstoneMode().isEnabled(worldObj, x, y, z))
{
machines.add((TileMachine) tile);
visited.add(Vec3.createVectorHelper(x, y, z));
}
else if (tile instanceof TileCable && ((TileCable) tile).isEnabled())
{
((TileCable) tile).addMachines(visited, machines, controller);
}
else if (tile instanceof TileController && (x != controller.xCoord || y != controller.yCoord || z != controller.zCoord))
{
worldObj.createExplosion(null, x, y, z, 4.5f, true);
}
}
}
}
package storagecraft.tile;
import java.util.List;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.world.World;
import storagecraft.block.BlockCable;
public class TileCable extends TileBase
{
public static boolean isCable(World world, BlockPos pos)
{
return world.getBlockState(pos).getBlock() instanceof BlockCable;
}
public boolean hasConnection(EnumFacing dir)
{
if (!isCable(worldObj, pos.offset(dir)))
{
TileEntity tile = worldObj.getTileEntity(pos.offset(dir));
return tile instanceof TileMachine || tile instanceof TileController;
}
return true;
}
public boolean isPowered()
{
// @TODO: return worldObj.isBlockIndirectlyGettingPowered(xCoord, yCoord, zCoord);
return false;
}
public boolean isSensitiveCable()
{
// @TODO: return worldObj.getBlockMetadata(xCoord, yCoord, zCoord) == 1;
return false;
}
public boolean isEnabled()
{
if (isSensitiveCable())
{
return !isPowered();
}
return true;
}
public void addMachines(List<BlockPos> visited, List<TileMachine> machines, TileController controller)
{
for (BlockPos visitedBlock : visited)
{
if (visitedBlock.equals(pos))
{
return;
}
}
visited.add(pos);
for (EnumFacing dir : EnumFacing.VALUES)
{
BlockPos newPos = pos.offset(dir);
boolean found = false;
for (BlockPos visitedBlock : visited)
{
if (visitedBlock.equals(newPos))
{
found = true;
}
}
if (found)
{
continue;
}
TileEntity tile = worldObj.getTileEntity(newPos);
if (tile instanceof TileMachine && ((TileMachine) tile).getRedstoneMode().isEnabled(worldObj, newPos))
{
machines.add((TileMachine) tile);
visited.add(newPos);
}
else if (tile instanceof TileCable && ((TileCable) tile).isEnabled())
{
((TileCable) tile).addMachines(visited, machines, controller);
}
else if (tile instanceof TileController && !controller.getPos().equals(newPos))
{
worldObj.createExplosion(null, pos.getX(), pos.getY(), pos.getZ(), 4.5f, true);
}
}
}
}

412
src/main/java/storagecraft/tile/TileConstructor.java
View File

@@ -1,191 +1,221 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileConstructor extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final String NBT_COMPARE = "Compare";
private InventorySimple inventory = new InventorySimple("constructor", 1);
private int compare = 0;
@Override
public int getEnergyUsage()
{
return 1;
}
@Override
public void updateMachine()
{
if (ticks % 10 == 0)
{
int frontX = xCoord + getDirection().offsetX;
int frontY = yCoord + getDirection().offsetY;
int frontZ = zCoord + getDirection().offsetZ;
if (worldObj.getBlock(frontX, frontY, frontZ) == Blocks.air && inventory.getStackInSlot(0) != null)
{
ItemStack took = getController().take(inventory.getStackInSlot(0).copy(), compare);
if (took != null)
{
worldObj.setBlock(frontX, frontY, frontZ, ((ItemBlock) took.getItem()).field_150939_a, took.getItemDamage(), 1 | 2);
}
}
}
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileConstructor extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final String NBT_COMPARE = "Compare";
private InventorySimple inventory = new InventorySimple("constructor", 1);
private int compare = 0;
@Override
public int getEnergyUsage()
{
return 1;
}
@Override
public void updateMachine()
{
if (ticks % 10 == 0)
{
BlockPos front = pos.offset(getDirection());
if (worldObj.isAirBlock(front) && inventory.getStackInSlot(0) != null)
{
ItemStack took = getController().take(inventory.getStackInSlot(0).copy(), compare);
if (took != null)
{
worldObj.setBlockState(front, ((ItemBlock) took.getItem()).getBlock().getDefaultState(), 1 | 2);
}
}
}
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public int[] getSlotsForFace(EnumFacing side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, EnumFacing direction)
{
return false;
}
@Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
{
return false;
}
}

776
src/main/java/storagecraft/tile/TileController.java
View File

@@ -1,397 +1,379 @@
package storagecraft.tile;
import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyReceiver;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.Vec3;
import net.minecraftforge.common.util.ForgeDirection;
import storagecraft.StorageCraftBlocks;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileController extends TileBase implements IEnergyReceiver, INetworkTile, IRedstoneModeSetting
{
private List<StorageItem> items = new ArrayList<StorageItem>();
private List<IStorage> storages = new ArrayList<IStorage>();
private RedstoneMode redstoneMode = RedstoneMode.IGNORE;
private List<TileMachine> machines = new ArrayList<TileMachine>();
private List<Vec3> visitedCables = new ArrayList<Vec3>();
private EnergyStorage energy = new EnergyStorage(32000);
private int energyUsage;
private boolean destroyed = false;
@Override
public void updateEntity()
{
super.updateEntity();
if (destroyed)
{
return;
}
if (!worldObj.isRemote)
{
int lastEnergy = energy.getEnergyStored();
if (ticks % 40 == 0)
{
if (!isActive())
{
disconnectAll();
}
else
{
visitedCables.clear();
List<TileMachine> newMachines = new ArrayList<TileMachine>();
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS)
{
TileEntity tile = worldObj.getTileEntity(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ);
if (tile instanceof TileCable)
{
TileCable cable = (TileCable) tile;
if (cable.isEnabled())
{
cable.addMachines(visitedCables, newMachines, this);
}
}
}
for (TileMachine machine : machines)
{
if (!newMachines.contains(machine))
{
machine.onDisconnected();
}
}
for (TileMachine machine : newMachines)
{
if (!machines.contains(machine))
{
machine.onConnected(this);
}
}
machines = newMachines;
storages.clear();
for (TileMachine machine : machines)
{
if (machine instanceof IStorageProvider)
{
((IStorageProvider) machine).addStorages(storages);
}
}
syncItems();
}
energyUsage = 10;
for (TileMachine machine : machines)
{
energyUsage += machine.getEnergyUsage();
}
}
energy.extractEnergy(energyUsage, false);
if (lastEnergy != energy.getEnergyStored())
{
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, StorageCraftBlocks.CONTROLLER);
}
}
}
public void onDestroyed()
{
disconnectAll();
destroyed = true;
}
private void disconnectAll()
{
for (TileMachine machine : machines)
{
machine.onDisconnected();
}
machines.clear();
}
public List<TileMachine> getMachines()
{
return machines;
}
public List<StorageItem> getItems()
{
return items;
}
private void syncItems()
{
items.clear();
for (IStorage storage : storages)
{
storage.addItems(items);
}
combineItems();
}
private void combineItems()
{
List<Integer> markedIndexes = new ArrayList<Integer>();
for (int i = 0; i < items.size(); ++i)
{
if (markedIndexes.contains(i))
{
continue;
}
StorageItem item = items.get(i);
for (int j = i + 1; j < items.size(); ++j)
{
if (markedIndexes.contains(j))
{
continue;
}
StorageItem other = items.get(j);
if (item.compareNoQuantity(other))
{
item.setQuantity(item.getQuantity() + other.getQuantity());
markedIndexes.add(j);
}
}
}
List<StorageItem> markedItems = new ArrayList<StorageItem>();
for (int i : markedIndexes)
{
markedItems.add(items.get(i));
}
items.removeAll(markedItems);
}
public boolean push(ItemStack stack)
{
IStorage foundStorage = null;
for (IStorage storage : storages)
{
if (storage.canPush(stack))
{
foundStorage = storage;
break;
}
}
if (foundStorage == null)
{
return false;
}
foundStorage.push(stack);
syncItems();
return true;
}
public ItemStack take(ItemStack stack)
{
return take(stack, InventoryUtils.COMPARE_DAMAGE | InventoryUtils.COMPARE_NBT);
}
public ItemStack take(ItemStack stack, int flags)
{
int requested = stack.stackSize;
int receiving = 0;
ItemStack newStack = null;
for (IStorage storage : storages)
{
ItemStack took = storage.take(stack, flags);
if (took != null)
{
if (newStack == null)
{
newStack = took;
}
else
{
newStack.stackSize += took.stackSize;
}
receiving += took.stackSize;
}
if (requested == receiving)
{
break;
}
}
syncItems();
return newStack;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
energy.readFromNBT(nbt);
if (nbt.hasKey(RedstoneMode.NBT))
{
redstoneMode = RedstoneMode.getById(nbt.getInteger(RedstoneMode.NBT));
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
energy.writeToNBT(nbt);
nbt.setInteger(RedstoneMode.NBT, redstoneMode.id);
}
@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
{
return energy.receiveEnergy(maxReceive, simulate);
}
@Override
public int getEnergyStored(ForgeDirection from)
{
return energy.getEnergyStored();
}
public int getEnergyScaled(int i)
{
return (int) ((float) energy.getEnergyStored() / (float) energy.getMaxEnergyStored() * (float) i);
}
@Override
public int getMaxEnergyStored(ForgeDirection from)
{
return energy.getMaxEnergyStored();
}
public int getEnergyUsage()
{
return energyUsage;
}
@Override
public boolean canConnectEnergy(ForgeDirection from)
{
return true;
}
public boolean isActive()
{
return energy.getEnergyStored() >= getEnergyUsage() && redstoneMode.isEnabled(worldObj, xCoord, yCoord, zCoord);
}
@Override
public RedstoneMode getRedstoneMode()
{
return redstoneMode;
}
@Override
public void setRedstoneMode(RedstoneMode mode)
{
this.redstoneMode = mode;
}
@Override
public int getX()
{
return xCoord;
}
@Override
public int getY()
{
return yCoord;
}
@Override
public int getZ()
{
return zCoord;
}
@Override
public void fromBytes(ByteBuf buf)
{
energy.setEnergyStored(buf.readInt());
energyUsage = buf.readInt();
redstoneMode = RedstoneMode.getById(buf.readInt());
items.clear();
int size = buf.readInt();
for (int i = 0; i < size; ++i)
{
items.add(new StorageItem(buf));
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(energy.getEnergyStored());
buf.writeInt(energyUsage);
buf.writeInt(redstoneMode.id);
buf.writeInt(items.size());
for (StorageItem item : items)
{
item.toBytes(buf, items.indexOf(item));
}
}
}
package storagecraft.tile;
import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyReceiver;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.List;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.BlockPos;
import net.minecraft.util.EnumFacing;
import storagecraft.StorageCraftBlocks;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileController extends TileBase implements IEnergyReceiver, INetworkTile, IRedstoneModeSetting
{
private List<StorageItem> items = new ArrayList<StorageItem>();
private List<IStorage> storages = new ArrayList<IStorage>();
private RedstoneMode redstoneMode = RedstoneMode.IGNORE;
private List<TileMachine> machines = new ArrayList<TileMachine>();
private List<BlockPos> visitedCables = new ArrayList<BlockPos>();
private EnergyStorage energy = new EnergyStorage(32000);
private int energyUsage;
private boolean destroyed = false;
@Override
public void update()
{
super.update();
if (destroyed)
{
return;
}
if (!worldObj.isRemote)
{
int lastEnergy = energy.getEnergyStored();
if (ticks % 40 == 0)
{
if (!isActive())
{
disconnectAll();
}
else
{
visitedCables.clear();
List<TileMachine> newMachines = new ArrayList<TileMachine>();
for (EnumFacing dir : EnumFacing.VALUES)
{
TileEntity tile = worldObj.getTileEntity(pos.offset(dir));
if (tile instanceof TileCable)
{
TileCable cable = (TileCable) tile;
if (cable.isEnabled())
{
cable.addMachines(visitedCables, newMachines, this);
}
}
}
for (TileMachine machine : machines)
{
if (!newMachines.contains(machine))
{
machine.onDisconnected();
}
}
for (TileMachine machine : newMachines)
{
if (!machines.contains(machine))
{
machine.onConnected(this);
}
}
machines = newMachines;
storages.clear();
for (TileMachine machine : machines)
{
if (machine instanceof IStorageProvider)
{
((IStorageProvider) machine).addStorages(storages);
}
}
syncItems();
}
energyUsage = 10;
for (TileMachine machine : machines)
{
energyUsage += machine.getEnergyUsage();
}
}
energy.extractEnergy(energyUsage, false);
if (lastEnergy != energy.getEnergyStored())
{
worldObj.markBlockForUpdate(pos);
worldObj.notifyNeighborsOfStateChange(pos, StorageCraftBlocks.CONTROLLER);
}
}
}
public void onDestroyed()
{
disconnectAll();
destroyed = true;
}
private void disconnectAll()
{
for (TileMachine machine : machines)
{
machine.onDisconnected();
}
machines.clear();
}
public List<TileMachine> getMachines()
{
return machines;
}
public List<StorageItem> getItems()
{
return items;
}
private void syncItems()
{
items.clear();
for (IStorage storage : storages)
{
storage.addItems(items);
}
combineItems();
}
private void combineItems()
{
List<Integer> markedIndexes = new ArrayList<Integer>();
for (int i = 0; i < items.size(); ++i)
{
if (markedIndexes.contains(i))
{
continue;
}
StorageItem item = items.get(i);
for (int j = i + 1; j < items.size(); ++j)
{
if (markedIndexes.contains(j))
{
continue;
}
StorageItem other = items.get(j);
if (item.compareNoQuantity(other))
{
item.setQuantity(item.getQuantity() + other.getQuantity());
markedIndexes.add(j);
}
}
}
List<StorageItem> markedItems = new ArrayList<StorageItem>();
for (int i : markedIndexes)
{
markedItems.add(items.get(i));
}
items.removeAll(markedItems);
}
public boolean push(ItemStack stack)
{
IStorage foundStorage = null;
for (IStorage storage : storages)
{
if (storage.canPush(stack))
{
foundStorage = storage;
break;
}
}
if (foundStorage == null)
{
return false;
}
foundStorage.push(stack);
syncItems();
return true;
}
public ItemStack take(ItemStack stack)
{
return take(stack, InventoryUtils.COMPARE_DAMAGE | InventoryUtils.COMPARE_NBT);
}
public ItemStack take(ItemStack stack, int flags)
{
int requested = stack.stackSize;
int receiving = 0;
ItemStack newStack = null;
for (IStorage storage : storages)
{
ItemStack took = storage.take(stack, flags);
if (took != null)
{
if (newStack == null)
{
newStack = took;
}
else
{
newStack.stackSize += took.stackSize;
}
receiving += took.stackSize;
}
if (requested == receiving)
{
break;
}
}
syncItems();
return newStack;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
energy.readFromNBT(nbt);
if (nbt.hasKey(RedstoneMode.NBT))
{
redstoneMode = RedstoneMode.getById(nbt.getInteger(RedstoneMode.NBT));
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
energy.writeToNBT(nbt);
nbt.setInteger(RedstoneMode.NBT, redstoneMode.id);
}
@Override
public int receiveEnergy(EnumFacing from, int maxReceive, boolean simulate)
{
return energy.receiveEnergy(maxReceive, simulate);
}
@Override
public int getEnergyStored(EnumFacing from)
{
return energy.getEnergyStored();
}
public int getEnergyScaled(int i)
{
return (int) ((float) energy.getEnergyStored() / (float) energy.getMaxEnergyStored() * (float) i);
}
@Override
public int getMaxEnergyStored(EnumFacing from)
{
return energy.getMaxEnergyStored();
}
public int getEnergyUsage()
{
return energyUsage;
}
@Override
public boolean canConnectEnergy(EnumFacing from)
{
return true;
}
public boolean isActive()
{
return energy.getEnergyStored() >= getEnergyUsage() && redstoneMode.isEnabled(worldObj, pos);
}
@Override
public RedstoneMode getRedstoneMode()
{
return redstoneMode;
}
@Override
public void setRedstoneMode(RedstoneMode mode)
{
this.redstoneMode = mode;
}
@Override
public void fromBytes(ByteBuf buf)
{
energy.setEnergyStored(buf.readInt());
energyUsage = buf.readInt();
redstoneMode = RedstoneMode.getById(buf.readInt());
items.clear();
int size = buf.readInt();
for (int i = 0; i < size; ++i)
{
items.add(new StorageItem(buf));
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeInt(energy.getEnergyStored());
buf.writeInt(energyUsage);
buf.writeInt(redstoneMode.id);
buf.writeInt(items.size());
for (StorageItem item : items)
{
item.toBytes(buf, items.indexOf(item));
}
}
}

86
src/main/java/storagecraft/tile/TileDestructor.java
View File

@@ -1,44 +1,42 @@
package storagecraft.tile;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import storagecraft.util.InventoryUtils;
public class TileDestructor extends TileMachine
{
@Override
public int getEnergyUsage()
{
return 1;
}
@Override
public void updateMachine()
{
if (ticks % 10 == 0)
{
int frontX = xCoord + getDirection().offsetX;
int frontY = yCoord + getDirection().offsetY;
int frontZ = zCoord + getDirection().offsetZ;
Block front = worldObj.getBlock(frontX, frontY, frontZ);
if (front != Blocks.air)
{
List<ItemStack> drops = front.getDrops(worldObj, frontX, frontY, frontZ, worldObj.getBlockMetadata(frontX, frontY, frontZ), 0);
worldObj.setBlockToAir(frontX, frontY, frontZ);
for (ItemStack drop : drops)
{
if (!getController().push(drop))
{
InventoryUtils.dropStack(worldObj, drop, frontX, frontY, frontZ);
}
}
}
}
}
}
package storagecraft.tile;
import java.util.List;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import net.minecraft.util.BlockPos;
import storagecraft.util.InventoryUtils;
public class TileDestructor extends TileMachine
{
@Override
public int getEnergyUsage()
{
return 1;
}
@Override
public void updateMachine()
{
if (ticks % 10 == 0)
{
BlockPos front = pos.offset(getDirection());
Block frontBlock = worldObj.getBlockState(front).getBlock();
if (!frontBlock.isAir(worldObj, front))
{
List<ItemStack> drops = frontBlock.getDrops(worldObj, front, worldObj.getBlockState(front), 0);
worldObj.setBlockToAir(front);
for (ItemStack drop : drops)
{
if (!getController().push(drop))
{
InventoryUtils.dropStack(worldObj, drop, front.getX(), front.getY(), front.getZ());
}
}
}
}
}
}

618
src/main/java/storagecraft/tile/TileDetector.java
View File

@@ -1,293 +1,325 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.StorageCraftBlocks;
import storagecraft.inventory.InventorySimple;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileDetector extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final int MODE_UNDER = 0;
public static final int MODE_EQUAL = 1;
public static final int MODE_ABOVE = 2;
public static final String NBT_COMPARE = "Compare";
public static final String NBT_MODE = "Mode";
public static final String NBT_AMOUNT = "Amount";
private InventorySimple inventory = new InventorySimple("detector", 1);
private int compare = 0;
private int mode = MODE_EQUAL;
private int amount = 0;
private boolean providesPower = false;
public TileDetector()
{
this.redstoneControlled = false;
}
@Override
public int getEnergyUsage()
{
return 4;
}
@Override
public void updateMachine()
{
if (ticks % 5 == 0)
{
ItemStack slot = inventory.getStackInSlot(0);
boolean lastProvidesPower = providesPower;
if (slot != null)
{
boolean foundAny = false;
for (StorageItem item : getController().getItems())
{
if (item.compare(slot, compare))
{
foundAny = true;
switch (mode)
{
case MODE_UNDER:
providesPower = item.getQuantity() < amount;
break;
case MODE_EQUAL:
providesPower = item.getQuantity() == amount;
break;
case MODE_ABOVE:
providesPower = item.getQuantity() > amount;
break;
}
break;
}
}
if (!foundAny)
{
if (mode == MODE_UNDER && amount != 0)
{
providesPower = true;
}
else if (mode == MODE_EQUAL && amount == 0)
{
providesPower = true;
}
else
{
providesPower = false;
}
}
}
else
{
providesPower = false;
}
if (providesPower != lastProvidesPower)
{
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, StorageCraftBlocks.DETECTOR);
}
}
}
public boolean providesPower()
{
return providesPower;
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
public int getMode()
{
return mode;
}
public void setMode(int mode)
{
this.mode = mode;
}
public int getAmount()
{
return amount;
}
public void setAmount(int amount)
{
this.amount = amount;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
if (nbt.hasKey(NBT_MODE))
{
mode = nbt.getInteger(NBT_MODE);
}
if (nbt.hasKey(NBT_AMOUNT))
{
amount = nbt.getInteger(NBT_AMOUNT);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
nbt.setInteger(NBT_MODE, mode);
nbt.setInteger(NBT_AMOUNT, amount);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
mode = buf.readInt();
amount = buf.readInt();
providesPower = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
buf.writeInt(mode);
buf.writeInt(amount);
buf.writeBoolean(providesPower);
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import storagecraft.StorageCraftBlocks;
import storagecraft.inventory.InventorySimple;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileDetector extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final int MODE_UNDER = 0;
public static final int MODE_EQUAL = 1;
public static final int MODE_ABOVE = 2;
public static final String NBT_COMPARE = "Compare";
public static final String NBT_MODE = "Mode";
public static final String NBT_AMOUNT = "Amount";
private InventorySimple inventory = new InventorySimple("detector", 1);
private int compare = 0;
private int mode = MODE_EQUAL;
private int amount = 0;
private boolean providesPower = false;
public TileDetector()
{
this.redstoneControlled = false;
}
@Override
public int getEnergyUsage()
{
return 4;
}
@Override
public void updateMachine()
{
if (ticks % 5 == 0)
{
ItemStack slot = inventory.getStackInSlot(0);
boolean lastProvidesPower = providesPower;
if (slot != null)
{
boolean foundAny = false;
for (StorageItem item : getController().getItems())
{
if (item.compare(slot, compare))
{
foundAny = true;
switch (mode)
{
case MODE_UNDER:
providesPower = item.getQuantity() < amount;
break;
case MODE_EQUAL:
providesPower = item.getQuantity() == amount;
break;
case MODE_ABOVE:
providesPower = item.getQuantity() > amount;
break;
}
break;
}
}
if (!foundAny)
{
if (mode == MODE_UNDER && amount != 0)
{
providesPower = true;
}
else if (mode == MODE_EQUAL && amount == 0)
{
providesPower = true;
}
else
{
providesPower = false;
}
}
}
else
{
providesPower = false;
}
if (providesPower != lastProvidesPower)
{
worldObj.markBlockForUpdate(pos);
worldObj.notifyBlockOfStateChange(pos, StorageCraftBlocks.DETECTOR);
}
}
}
public boolean providesPower()
{
return providesPower;
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
public int getMode()
{
return mode;
}
public void setMode(int mode)
{
this.mode = mode;
}
public int getAmount()
{
return amount;
}
public void setAmount(int amount)
{
this.amount = amount;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
if (nbt.hasKey(NBT_MODE))
{
mode = nbt.getInteger(NBT_MODE);
}
if (nbt.hasKey(NBT_AMOUNT))
{
amount = nbt.getInteger(NBT_AMOUNT);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
nbt.setInteger(NBT_MODE, mode);
nbt.setInteger(NBT_AMOUNT, amount);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
mode = buf.readInt();
amount = buf.readInt();
providesPower = buf.readBoolean();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
buf.writeInt(mode);
buf.writeInt(amount);
buf.writeBoolean(providesPower);
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public int[] getSlotsForFace(EnumFacing side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, EnumFacing direction)
{
return false;
}
@Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
{
return false;
}
}

319
src/main/java/storagecraft/tile/TileDrive.java
View File

@@ -1,144 +1,175 @@
package storagecraft.tile;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.inventory.InventorySimple;
import storagecraft.storage.CellStorage;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.util.InventoryUtils;
public class TileDrive extends TileMachine implements IInventory, IStorageProvider
{
private InventorySimple inventory = new InventorySimple("drive", 8);
@Override
public int getEnergyUsage()
{
int base = 5;
for (int i = 0; i < getSizeInventory(); ++i)
{
if (getStackInSlot(i) != null)
{
base += 2;
}
}
return base;
}
@Override
public void updateMachine()
{
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void addStorages(List<IStorage> storages)
{
for (int i = 0; i < getSizeInventory(); ++i)
{
if (getStackInSlot(i) != null)
{
storages.add(new CellStorage(getStackInSlot(i)));
}
}
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
}
package storagecraft.tile;
import java.util.List;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.IChatComponent;
import storagecraft.inventory.InventorySimple;
import storagecraft.storage.CellStorage;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.util.InventoryUtils;
public class TileDrive extends TileMachine implements IInventory, IStorageProvider
{
private InventorySimple inventory = new InventorySimple("drive", 8);
@Override
public int getEnergyUsage()
{
int base = 5;
for (int i = 0; i < getSizeInventory(); ++i)
{
if (getStackInSlot(i) != null)
{
base += 2;
}
}
return base;
}
@Override
public void updateMachine()
{
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void addStorages(List<IStorage> storages)
{
for (int i = 0; i < getSizeInventory(); ++i)
{
if (getStackInSlot(i) != null)
{
storages.add(new CellStorage(getStackInSlot(i)));
}
}
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
}

496
src/main/java/storagecraft/tile/TileExporter.java
View File

@@ -1,232 +1,264 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileExporter extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final String NBT_COMPARE = "Compare";
private InventorySimple inventory = new InventorySimple("exporter", 9);
private int compare = 0;
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
TileEntity tile = worldObj.getTileEntity(xCoord + getDirection().offsetX, yCoord + getDirection().offsetY, zCoord + getDirection().offsetZ);
if (tile instanceof IInventory)
{
IInventory connectedInventory = (IInventory) tile;
if (ticks % 5 == 0)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null)
{
ItemStack toTake = slot.copy();
toTake.stackSize = 64;
ItemStack took = getController().take(toTake, compare);
if (took != null)
{
if (connectedInventory instanceof ISidedInventory)
{
ISidedInventory sided = (ISidedInventory) connectedInventory;
boolean pushedAny = false;
for (int sidedSlot = 0; sidedSlot < connectedInventory.getSizeInventory(); ++sidedSlot)
{
if (sided.canInsertItem(sidedSlot, took, getDirection().getOpposite().ordinal()) && InventoryUtils.canPushToInventorySlot(connectedInventory, sidedSlot, took))
{
InventoryUtils.pushToInventorySlot(connectedInventory, sidedSlot, took);
pushedAny = true;
break;
}
}
if (!pushedAny)
{
getController().push(took);
}
}
else if (InventoryUtils.canPushToInventory(connectedInventory, took))
{
InventoryUtils.pushToInventory(connectedInventory, took);
}
else
{
getController().push(took);
}
}
}
}
}
}
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileExporter extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final String NBT_COMPARE = "Compare";
private InventorySimple inventory = new InventorySimple("exporter", 9);
private int compare = 0;
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
TileEntity tile = worldObj.getTileEntity(pos.offset(getDirection()));
if (tile instanceof IInventory)
{
IInventory connectedInventory = (IInventory) tile;
if (ticks % 5 == 0)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null)
{
ItemStack toTake = slot.copy();
toTake.stackSize = 64;
ItemStack took = getController().take(toTake, compare);
if (took != null)
{
if (connectedInventory instanceof ISidedInventory)
{
ISidedInventory sided = (ISidedInventory) connectedInventory;
boolean pushedAny = false;
for (int sidedSlot = 0; sidedSlot < connectedInventory.getSizeInventory(); ++sidedSlot)
{
if (sided.canInsertItem(sidedSlot, took, getDirection().getOpposite()) && InventoryUtils.canPushToInventorySlot(connectedInventory, sidedSlot, took))
{
InventoryUtils.pushToInventorySlot(connectedInventory, sidedSlot, took);
pushedAny = true;
break;
}
}
if (!pushedAny)
{
getController().push(took);
}
}
else if (InventoryUtils.canPushToInventory(connectedInventory, took))
{
InventoryUtils.pushToInventory(connectedInventory, took);
}
else
{
getController().push(took);
}
}
}
}
}
}
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public int[] getSlotsForFace(EnumFacing side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, EnumFacing direction)
{
return false;
}
@Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
{
return false;
}
}

252
src/main/java/storagecraft/tile/TileExternalStorage.java
View File

@@ -1,126 +1,126 @@
package storagecraft.tile;
import java.util.List;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileExternalStorage extends TileMachine implements IStorageProvider, IStorage
{
public IInventory getInventory()
{
TileEntity tile = worldObj.getTileEntity(xCoord + getDirection().offsetX, yCoord + getDirection().offsetY, zCoord + getDirection().offsetZ);
if (tile instanceof IInventory)
{
return (IInventory) tile;
}
return null;
}
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
}
@Override
public void addItems(List<StorageItem> items)
{
IInventory inventory = getInventory();
if (inventory != null)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
if (inventory.getStackInSlot(i) != null)
{
items.add(new StorageItem(inventory.getStackInSlot(i)));
}
}
}
}
@Override
public void push(ItemStack stack)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return;
}
InventoryUtils.pushToInventory(inventory, stack);
}
@Override
public ItemStack take(ItemStack stack, int flags)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return null;
}
int quantity = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null && InventoryUtils.compareStack(slot, stack, flags))
{
if (quantity > slot.stackSize)
{
quantity = slot.stackSize;
}
slot.stackSize -= quantity;
if (slot.stackSize == 0)
{
inventory.setInventorySlotContents(i, null);
}
ItemStack newItem = slot.copy();
newItem.stackSize = quantity;
return newItem;
}
}
return null;
}
@Override
public boolean canPush(ItemStack stack)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return false;
}
return InventoryUtils.canPushToInventory(inventory, stack);
}
@Override
public void addStorages(List<IStorage> storages)
{
storages.add(this);
}
}
package storagecraft.tile;
import java.util.List;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import storagecraft.storage.IStorage;
import storagecraft.storage.IStorageProvider;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileExternalStorage extends TileMachine implements IStorageProvider, IStorage
{
public IInventory getInventory()
{
TileEntity tile = worldObj.getTileEntity(pos.offset(getDirection()));
if (tile instanceof IInventory)
{
return (IInventory) tile;
}
return null;
}
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
}
@Override
public void addItems(List<StorageItem> items)
{
IInventory inventory = getInventory();
if (inventory != null)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
if (inventory.getStackInSlot(i) != null)
{
items.add(new StorageItem(inventory.getStackInSlot(i)));
}
}
}
}
@Override
public void push(ItemStack stack)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return;
}
InventoryUtils.pushToInventory(inventory, stack);
}
@Override
public ItemStack take(ItemStack stack, int flags)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return null;
}
int quantity = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null && InventoryUtils.compareStack(slot, stack, flags))
{
if (quantity > slot.stackSize)
{
quantity = slot.stackSize;
}
slot.stackSize -= quantity;
if (slot.stackSize == 0)
{
inventory.setInventorySlotContents(i, null);
}
ItemStack newItem = slot.copy();
newItem.stackSize = quantity;
return newItem;
}
}
return null;
}
@Override
public boolean canPush(ItemStack stack)
{
IInventory inventory = getInventory();
if (inventory == null)
{
return false;
}
return InventoryUtils.canPushToInventory(inventory, stack);
}
@Override
public void addStorages(List<IStorage> storages)
{
storages.add(this);
}
}

220
src/main/java/storagecraft/tile/TileGrid.java
View File

@@ -1,110 +1,110 @@
package storagecraft.tile;
import cpw.mods.fml.common.network.NetworkRegistry.TargetPoint;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerGridCrafting;
import storagecraft.inventory.InventorySimple;
import storagecraft.network.MessageGridCraftingUpdate;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileGrid extends TileMachine
{
private ContainerGridCrafting craftingMatrixContainer = new ContainerGridCrafting(this);
private InventoryCrafting craftingMatrix = new InventoryCrafting(craftingMatrixContainer, 3, 3);
private InventorySimple craftingResult = new InventorySimple("craftingResult", 1);
@Override
public int getEnergyUsage()
{
return 5;
}
@Override
public void updateMachine()
{
}
public int getType()
{
return worldObj.getBlockMetadata(xCoord, yCoord, zCoord);
}
public boolean isCrafting()
{
return getType() == 1;
}
public InventoryCrafting getCraftingMatrix()
{
return craftingMatrix;
}
public void onCraftingMatrixChanged()
{
craftingResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(craftingMatrix, worldObj));
}
public void onCrafted(ItemStack[] matrixSlots)
{
if (isConnected() && !worldObj.isRemote)
{
for (int i = 0; i < craftingMatrix.getSizeInventory(); ++i)
{
ItemStack slot = craftingMatrix.getStackInSlot(i);
if (slot == null && matrixSlots[i] != null)
{
for (StorageItem item : getController().getItems())
{
if (item.compareNoQuantity(matrixSlots[i].copy()))
{
craftingMatrix.setInventorySlotContents(i, getController().take(matrixSlots[i].copy()));
break;
}
}
}
}
onCraftingMatrixChanged();
// @TODO: HACK!
TargetPoint target = new TargetPoint(worldObj.provider.dimensionId, xCoord, yCoord, zCoord, UPDATE_RANGE);
StorageCraft.NETWORK.sendToAllAround(new MessageGridCraftingUpdate(this), target);
}
}
public InventorySimple getCraftingResult()
{
return craftingResult;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(craftingMatrix, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(craftingMatrix, nbt);
}
@Override
public IInventory getDroppedInventory()
{
return craftingMatrix;
}
}
package storagecraft.tile;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fml.common.network.NetworkRegistry.TargetPoint;
import storagecraft.StorageCraft;
import storagecraft.container.ContainerGridCrafting;
import storagecraft.inventory.InventorySimple;
import storagecraft.network.MessageGridCraftingUpdate;
import storagecraft.storage.StorageItem;
import storagecraft.util.InventoryUtils;
public class TileGrid extends TileMachine
{
private ContainerGridCrafting craftingMatrixContainer = new ContainerGridCrafting(this);
private InventoryCrafting craftingMatrix = new InventoryCrafting(craftingMatrixContainer, 3, 3);
private InventorySimple craftingResult = new InventorySimple("craftingResult", 1);
@Override
public int getEnergyUsage()
{
return 5;
}
@Override
public void updateMachine()
{
}
public int getType()
{
return 0; // @TODO: Make other grid work too
}
public boolean isCrafting()
{
return getType() == 1;
}
public InventoryCrafting getCraftingMatrix()
{
return craftingMatrix;
}
public void onCraftingMatrixChanged()
{
craftingResult.setInventorySlotContents(0, CraftingManager.getInstance().findMatchingRecipe(craftingMatrix, worldObj));
}
public void onCrafted(ItemStack[] matrixSlots)
{
if (isConnected() && !worldObj.isRemote)
{
for (int i = 0; i < craftingMatrix.getSizeInventory(); ++i)
{
ItemStack slot = craftingMatrix.getStackInSlot(i);
if (slot == null && matrixSlots[i] != null)
{
for (StorageItem item : getController().getItems())
{
if (item.compareNoQuantity(matrixSlots[i].copy()))
{
craftingMatrix.setInventorySlotContents(i, getController().take(matrixSlots[i].copy()));
break;
}
}
}
}
onCraftingMatrixChanged();
// @TODO: HACK!
TargetPoint target = new TargetPoint(worldObj.provider.getDimensionId(), pos.getX(), pos.getY(), pos.getZ(), UPDATE_RANGE);
StorageCraft.NETWORK.sendToAllAround(new MessageGridCraftingUpdate(this), target);
}
}
public InventorySimple getCraftingResult()
{
return craftingResult;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(craftingMatrix, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(craftingMatrix, nbt);
}
@Override
public IInventory getDroppedInventory()
{
return craftingMatrix;
}
}

598
src/main/java/storagecraft/tile/TileImporter.java
View File

@@ -1,283 +1,315 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileImporter extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final int MODE_WHITELIST = 0;
public static final int MODE_BLACKLIST = 1;
public static final String NBT_COMPARE = "Compare";
public static final String NBT_MODE = "Mode";
private InventorySimple inventory = new InventorySimple("importer", 9);
private int compare = 0;
private int mode = MODE_WHITELIST;
private int currentSlot = 0;
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
TileEntity tile = worldObj.getTileEntity(xCoord + getDirection().offsetX, yCoord + getDirection().offsetY, zCoord + getDirection().offsetZ);
if (tile instanceof IInventory)
{
IInventory connectedInventory = (IInventory) tile;
if (ticks % 5 == 0)
{
ItemStack slot = connectedInventory.getStackInSlot(currentSlot);
while ((slot = connectedInventory.getStackInSlot(currentSlot)) == null)
{
currentSlot++;
if (currentSlot > connectedInventory.getSizeInventory() - 1)
{
break;
}
}
if (slot != null && canImport(slot))
{
if (connectedInventory instanceof ISidedInventory)
{
ISidedInventory sided = (ISidedInventory) connectedInventory;
if (sided.canExtractItem(currentSlot, slot.copy(), getDirection().getOpposite().ordinal()))
{
if (getController().push(slot.copy()))
{
connectedInventory.setInventorySlotContents(currentSlot, null);
}
}
}
else if (getController().push(slot.copy()))
{
connectedInventory.setInventorySlotContents(currentSlot, null);
}
connectedInventory.markDirty();
}
currentSlot++;
if (currentSlot > connectedInventory.getSizeInventory() - 1)
{
currentSlot = 0;
}
}
}
}
public boolean canImport(ItemStack stack)
{
int slots = 0;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null)
{
slots++;
if (InventoryUtils.compareStack(stack, slot, compare))
{
if (mode == MODE_WHITELIST)
{
return true;
}
else if (mode == MODE_BLACKLIST)
{
return false;
}
}
}
}
if (mode == MODE_WHITELIST)
{
return slots == 0;
}
return true;
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
public int getMode()
{
return mode;
}
public void setMode(int mode)
{
this.mode = mode;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, int side)
{
return false;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
if (nbt.hasKey(NBT_MODE))
{
mode = nbt.getInteger(NBT_MODE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
nbt.setInteger(NBT_MODE, mode);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
mode = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
buf.writeInt(mode);
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import storagecraft.inventory.InventorySimple;
import storagecraft.util.InventoryUtils;
public class TileImporter extends TileMachine implements IInventory, ISidedInventory, ICompareSetting
{
public static final int MODE_WHITELIST = 0;
public static final int MODE_BLACKLIST = 1;
public static final String NBT_COMPARE = "Compare";
public static final String NBT_MODE = "Mode";
private InventorySimple inventory = new InventorySimple("importer", 9);
private int compare = 0;
private int mode = MODE_WHITELIST;
private int currentSlot = 0;
@Override
public int getEnergyUsage()
{
return 2;
}
@Override
public void updateMachine()
{
TileEntity tile = worldObj.getTileEntity(pos.offset(getDirection()));
if (tile instanceof IInventory)
{
IInventory connectedInventory = (IInventory) tile;
if (ticks % 5 == 0)
{
ItemStack slot = connectedInventory.getStackInSlot(currentSlot);
while ((slot = connectedInventory.getStackInSlot(currentSlot)) == null)
{
currentSlot++;
if (currentSlot > connectedInventory.getSizeInventory() - 1)
{
break;
}
}
if (slot != null && canImport(slot))
{
if (connectedInventory instanceof ISidedInventory)
{
ISidedInventory sided = (ISidedInventory) connectedInventory;
if (sided.canExtractItem(currentSlot, slot.copy(), getDirection().getOpposite()))
{
if (getController().push(slot.copy()))
{
connectedInventory.setInventorySlotContents(currentSlot, null);
}
}
}
else if (getController().push(slot.copy()))
{
connectedInventory.setInventorySlotContents(currentSlot, null);
}
connectedInventory.markDirty();
}
currentSlot++;
if (currentSlot > connectedInventory.getSizeInventory() - 1)
{
currentSlot = 0;
}
}
}
}
public boolean canImport(ItemStack stack)
{
int slots = 0;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot != null)
{
slots++;
if (InventoryUtils.compareStack(stack, slot, compare))
{
if (mode == MODE_WHITELIST)
{
return true;
}
else if (mode == MODE_BLACKLIST)
{
return false;
}
}
}
}
if (mode == MODE_WHITELIST)
{
return slots == 0;
}
return true;
}
@Override
public int getCompare()
{
return compare;
}
@Override
public void setCompare(int compare)
{
this.compare = compare;
}
public int getMode()
{
return mode;
}
public void setMode(int mode)
{
this.mode = mode;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(NBT_COMPARE))
{
compare = nbt.getInteger(NBT_COMPARE);
}
if (nbt.hasKey(NBT_MODE))
{
mode = nbt.getInteger(NBT_MODE);
}
InventoryUtils.restoreInventory(this, nbt);
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(NBT_COMPARE, compare);
nbt.setInteger(NBT_MODE, mode);
InventoryUtils.saveInventory(this, nbt);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
compare = buf.readInt();
mode = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeInt(compare);
buf.writeInt(mode);
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public int[] getSlotsForFace(EnumFacing side)
{
return new int[]
{
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, EnumFacing direction)
{
return false;
}
@Override
public boolean canExtractItem(int index, ItemStack stack, EnumFacing direction)
{
return false;
}
}

265
src/main/java/storagecraft/tile/TileMachine.java
View File

@@ -1,144 +1,121 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.nbt.NBTTagCompound;
public abstract class TileMachine extends TileBase implements INetworkTile, IRedstoneModeSetting
{
protected boolean connected = false;
protected boolean redstoneControlled = true;
private RedstoneMode redstoneMode = RedstoneMode.IGNORE;
private int xController;
private int yController;
private int zController;
public void onConnected(TileController controller)
{
connected = true;
xController = controller.xCoord;
yController = controller.yCoord;
zController = controller.zCoord;
}
public void onDisconnected()
{
connected = false;
}
@Override
public void updateEntity()
{
super.updateEntity();
if (!worldObj.isRemote && isConnected())
{
updateMachine();
}
}
public boolean isConnected()
{
return connected;
}
@Override
public RedstoneMode getRedstoneMode()
{
return redstoneMode;
}
@Override
public void setRedstoneMode(RedstoneMode mode)
{
if (redstoneControlled)
{
this.redstoneMode = mode;
}
}
@Override
public int getX()
{
return xCoord;
}
@Override
public int getY()
{
return yCoord;
}
@Override
public int getZ()
{
return zCoord;
}
public TileController getController()
{
return (TileController) worldObj.getTileEntity(xController, yController, zController);
}
@Override
public void fromBytes(ByteBuf buf)
{
boolean lastConnected = connected;
connected = buf.readBoolean();
if (connected)
{
xController = buf.readInt();
yController = buf.readInt();
zController = buf.readInt();
}
redstoneMode = RedstoneMode.getById(buf.readInt());
if (lastConnected != connected)
{
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeBoolean(connected);
if (connected)
{
buf.writeInt(xController);
buf.writeInt(yController);
buf.writeInt(zController);
}
buf.writeInt(redstoneMode.id);
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(RedstoneMode.NBT))
{
redstoneMode = RedstoneMode.getById(nbt.getInteger(RedstoneMode.NBT));
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(RedstoneMode.NBT, redstoneMode.id);
}
public abstract int getEnergyUsage();
public abstract void updateMachine();
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.BlockPos;
public abstract class TileMachine extends TileBase implements INetworkTile, IRedstoneModeSetting
{
protected boolean connected = false;
protected boolean redstoneControlled = true;
private RedstoneMode redstoneMode = RedstoneMode.IGNORE;
private BlockPos controllerPos;
public void onConnected(TileController controller)
{
connected = true;
controllerPos = controller.getPos();
}
public void onDisconnected()
{
connected = false;
}
@Override
public void update()
{
super.update();
if (!worldObj.isRemote && isConnected())
{
updateMachine();
}
}
public boolean isConnected()
{
return connected;
}
@Override
public RedstoneMode getRedstoneMode()
{
return redstoneMode;
}
@Override
public void setRedstoneMode(RedstoneMode mode)
{
if (redstoneControlled)
{
this.redstoneMode = mode;
}
}
public TileController getController()
{
return (TileController) worldObj.getTileEntity(controllerPos);
}
@Override
public void fromBytes(ByteBuf buf)
{
boolean lastConnected = connected;
connected = buf.readBoolean();
if (connected)
{
controllerPos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
}
redstoneMode = RedstoneMode.getById(buf.readInt());
if (lastConnected != connected)
{
worldObj.markBlockForUpdate(pos);
}
}
@Override
public void toBytes(ByteBuf buf)
{
buf.writeBoolean(connected);
if (connected)
{
buf.writeInt(controllerPos.getX());
buf.writeInt(controllerPos.getY());
buf.writeInt(controllerPos.getZ());
}
buf.writeInt(redstoneMode.id);
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
if (nbt.hasKey(RedstoneMode.NBT))
{
redstoneMode = RedstoneMode.getById(nbt.getInteger(RedstoneMode.NBT));
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
nbt.setInteger(RedstoneMode.NBT, redstoneMode.id);
}
public abstract int getEnergyUsage();
public abstract void updateMachine();
}

566
src/main/java/storagecraft/tile/TileSolderer.java
View File

@@ -1,268 +1,298 @@
package storagecraft.tile;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.inventory.InventorySimple;
import storagecraft.tile.solderer.ISoldererRecipe;
import storagecraft.tile.solderer.SoldererRegistry;
import storagecraft.util.InventoryUtils;
public class TileSolderer extends TileMachine implements IInventory, ISidedInventory
{
public static final String NBT_WORKING = "Working";
public static final String NBT_PROGRESS = "Progress";
private InventorySimple inventory = new InventorySimple("solderer", 4);
private ISoldererRecipe recipe;
private boolean working = false;
private int progress = 0;
@SideOnly(Side.CLIENT)
private int duration;
@Override
public int getEnergyUsage()
{
return 3;
}
@Override
public void updateMachine()
{
ISoldererRecipe newRecipe = SoldererRegistry.getRecipe(inventory);
if (newRecipe == null)
{
reset();
}
else if (newRecipe != recipe && inventory.getStackInSlot(3) == null)
{
recipe = newRecipe;
progress = 0;
working = true;
}
else if (working)
{
progress++;
if (progress == recipe.getDuration())
{
inventory.setInventorySlotContents(3, recipe.getResult());
for (int i = 0; i < 3; ++i)
{
if (recipe.getRow(i) != null)
{
inventory.decrStackSize(i, recipe.getRow(i).stackSize);
}
}
reset();
}
}
}
@Override
public void onDisconnected()
{
super.onDisconnected();
reset();
}
public void reset()
{
progress = 0;
working = false;
recipe = null;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int[] getAccessibleSlotsFromSide(int side)
{
// On all sides, but not the bottom we can reach the slots
if (side > 0)
{
return new int[]
{
0, 1, 2
};
}
// On the bottom we can only reach the output slot
return new int[]
{
3
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, int side)
{
// We can insert in all slots, but not the output slot or via the output side
return side != 0 && slot != 3;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, int side)
{
// We can only extract from the buttom in the last slot
return side == 0 && slot == 3;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
recipe = SoldererRegistry.getRecipe(inventory);
if (nbt.hasKey(NBT_WORKING))
{
working = nbt.getBoolean(NBT_WORKING);
}
if (nbt.hasKey(NBT_PROGRESS))
{
progress = nbt.getInteger(NBT_PROGRESS);
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
nbt.setBoolean(NBT_WORKING, working);
nbt.setInteger(NBT_PROGRESS, progress);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
working = buf.readBoolean();
progress = buf.readInt();
duration = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeBoolean(working);
buf.writeInt(progress);
buf.writeInt(recipe != null ? recipe.getDuration() : 0);
}
public boolean isWorking()
{
return working;
}
public int getProgress()
{
return progress;
}
@SideOnly(Side.CLIENT)
public int getProgressScaled(int i)
{
return (int) ((float) progress / (float) duration * (float) i);
}
@SideOnly(Side.CLIENT)
public int getDuration()
{
return duration;
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.IChatComponent;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import storagecraft.inventory.InventorySimple;
import storagecraft.tile.solderer.ISoldererRecipe;
import storagecraft.tile.solderer.SoldererRegistry;
import storagecraft.util.InventoryUtils;
public class TileSolderer extends TileMachine implements IInventory, ISidedInventory
{
public static final String NBT_WORKING = "Working";
public static final String NBT_PROGRESS = "Progress";
private InventorySimple inventory = new InventorySimple("solderer", 4);
private ISoldererRecipe recipe;
private boolean working = false;
private int progress = 0;
@SideOnly(Side.CLIENT)
private int duration;
@Override
public int getEnergyUsage()
{
return 3;
}
@Override
public void updateMachine()
{
ISoldererRecipe newRecipe = SoldererRegistry.getRecipe(inventory);
if (newRecipe == null)
{
reset();
}
else if (newRecipe != recipe && inventory.getStackInSlot(3) == null)
{
recipe = newRecipe;
progress = 0;
working = true;
}
else if (working)
{
progress++;
if (progress == recipe.getDuration())
{
inventory.setInventorySlotContents(3, recipe.getResult());
for (int i = 0; i < 3; ++i)
{
if (recipe.getRow(i) != null)
{
inventory.decrStackSize(i, recipe.getRow(i).stackSize);
}
}
reset();
}
}
}
@Override
public void onDisconnected()
{
super.onDisconnected();
reset();
}
public void reset()
{
progress = 0;
working = false;
recipe = null;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
recipe = SoldererRegistry.getRecipe(inventory);
if (nbt.hasKey(NBT_WORKING))
{
working = nbt.getBoolean(NBT_WORKING);
}
if (nbt.hasKey(NBT_PROGRESS))
{
progress = nbt.getInteger(NBT_PROGRESS);
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
nbt.setBoolean(NBT_WORKING, working);
nbt.setInteger(NBT_PROGRESS, progress);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
working = buf.readBoolean();
progress = buf.readInt();
duration = buf.readInt();
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeBoolean(working);
buf.writeInt(progress);
buf.writeInt(recipe != null ? recipe.getDuration() : 0);
}
public boolean isWorking()
{
return working;
}
public int getProgress()
{
return progress;
}
@SideOnly(Side.CLIENT)
public int getProgressScaled(int i)
{
return (int) ((float) progress / (float) duration * (float) i);
}
@SideOnly(Side.CLIENT)
public int getDuration()
{
return duration;
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
@Override
public int[] getSlotsForFace(EnumFacing side)
{
// On all sides, but not the bottom we can reach the slots
if (side != EnumFacing.DOWN)
{
return new int[]
{
0, 1, 2
};
}
// On the bottom we can only reach the output slot
return new int[]
{
3
};
}
@Override
public boolean canInsertItem(int slot, ItemStack stack, EnumFacing direction)
{
return slot != 3;
}
@Override
public boolean canExtractItem(int slot, ItemStack stack, EnumFacing direction)
{
return slot == 3;
}
}

513
src/main/java/storagecraft/tile/TileWirelessTransmitter.java
View File

@@ -1,240 +1,273 @@
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import storagecraft.inventory.InventorySimple;
import storagecraft.item.ItemWirelessGrid;
import storagecraft.util.InventoryUtils;
public class TileWirelessTransmitter extends TileMachine implements IInventory
{
public static final int TOTAL_PROGRESS = 10000;
public static final String NBT_WORKING = "Working";
public static final String NBT_PROGRESS = "Progress";
private InventorySimple inventory = new InventorySimple("wirelessTransmitter", 3);
private boolean working = false;
private int progress = 0;
@Override
public int getEnergyUsage()
{
return 4;
}
@Override
public void updateMachine()
{
if (working)
{
progress++;
if (progress == TOTAL_PROGRESS)
{
reset();
}
}
else if (inventory.getStackInSlot(0) != null)
{
inventory.decrStackSize(0, 1);
progress = 0;
working = true;
}
if (inventory.getStackInSlot(1) != null)
{
ItemStack slot = inventory.getStackInSlot(1);
slot.stackTagCompound = new NBTTagCompound();
slot.stackTagCompound.setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_X, xCoord);
slot.stackTagCompound.setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_Y, yCoord);
slot.stackTagCompound.setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_Z, zCoord);
inventory.setInventorySlotContents(2, slot);
inventory.setInventorySlotContents(1, null);
}
}
public void reset()
{
progress = 0;
working = false;
}
@Override
public void onDisconnected()
{
super.onDisconnected();
reset();
}
public boolean isWorking()
{
return working;
}
public int getProgress()
{
return progress;
}
public TileGrid getGrid(int type)
{
for (TileMachine machine : getController().getMachines())
{
if (worldObj.getTileEntity(machine.xCoord, machine.yCoord, machine.zCoord) != null)
{
if (machine instanceof TileGrid)
{
TileGrid grid = (TileGrid) machine;
if (grid.getType() == type)
{
return grid;
}
}
}
}
return null;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int amount)
{
return inventory.decrStackSize(slot, amount);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public String getInventoryName()
{
return inventory.getInventoryName();
}
@Override
public boolean hasCustomInventoryName()
{
return inventory.hasCustomInventoryName();
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public void openInventory()
{
inventory.openInventory();
}
@Override
public void closeInventory()
{
inventory.closeInventory();
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
if (nbt.hasKey(NBT_WORKING))
{
working = nbt.getBoolean(NBT_WORKING);
}
if (nbt.hasKey(NBT_PROGRESS))
{
progress = nbt.getInteger(NBT_PROGRESS);
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
nbt.setBoolean(NBT_WORKING, working);
nbt.setInteger(NBT_PROGRESS, progress);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
boolean lastWorking = working;
working = buf.readBoolean();
progress = buf.readInt();
if (lastWorking != working)
{
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeBoolean(working);
buf.writeInt(progress);
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
}
package storagecraft.tile;
import io.netty.buffer.ByteBuf;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.IChatComponent;
import storagecraft.inventory.InventorySimple;
import storagecraft.item.ItemWirelessGrid;
import storagecraft.util.InventoryUtils;
public class TileWirelessTransmitter extends TileMachine implements IInventory
{
public static final int TOTAL_PROGRESS = 10000;
public static final String NBT_WORKING = "Working";
public static final String NBT_PROGRESS = "Progress";
private InventorySimple inventory = new InventorySimple("wirelessTransmitter", 3);
private boolean working = false;
private int progress = 0;
@Override
public int getEnergyUsage()
{
return 4;
}
@Override
public void updateMachine()
{
if (working)
{
progress++;
if (progress == TOTAL_PROGRESS)
{
reset();
}
}
else if (inventory.getStackInSlot(0) != null)
{
inventory.decrStackSize(0, 1);
progress = 0;
working = true;
}
if (inventory.getStackInSlot(1) != null)
{
ItemStack slot = inventory.getStackInSlot(1);
slot.setTagCompound(new NBTTagCompound());
slot.getTagCompound().setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_X, pos.getX());
slot.getTagCompound().setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_Y, pos.getY());
slot.getTagCompound().setInteger(ItemWirelessGrid.NBT_WIRELESS_TRANSMITTER_Z, pos.getZ());
inventory.setInventorySlotContents(2, slot);
inventory.setInventorySlotContents(1, null);
}
}
public void reset()
{
progress = 0;
working = false;
}
@Override
public void onDisconnected()
{
super.onDisconnected();
reset();
}
public boolean isWorking()
{
return working;
}
public int getProgress()
{
return progress;
}
public TileGrid getGrid(int type)
{
for (TileMachine machine : getController().getMachines())
{
// @TODO: Is this still needed?
if (worldObj.getTileEntity(machine.getPos()) != null)
{
if (machine instanceof TileGrid)
{
TileGrid grid = (TileGrid) machine;
if (grid.getType() == type)
{
return grid;
}
}
}
}
return null;
}
@Override
public void readFromNBT(NBTTagCompound nbt)
{
super.readFromNBT(nbt);
InventoryUtils.restoreInventory(this, nbt);
if (nbt.hasKey(NBT_WORKING))
{
working = nbt.getBoolean(NBT_WORKING);
}
if (nbt.hasKey(NBT_PROGRESS))
{
progress = nbt.getInteger(NBT_PROGRESS);
}
}
@Override
public void writeToNBT(NBTTagCompound nbt)
{
super.writeToNBT(nbt);
InventoryUtils.saveInventory(this, nbt);
nbt.setBoolean(NBT_WORKING, working);
nbt.setInteger(NBT_PROGRESS, progress);
}
@Override
public void fromBytes(ByteBuf buf)
{
super.fromBytes(buf);
boolean lastWorking = working;
working = buf.readBoolean();
progress = buf.readInt();
if (lastWorking != working)
{
worldObj.markBlockForUpdate(pos);
}
}
@Override
public void toBytes(ByteBuf buf)
{
super.toBytes(buf);
buf.writeBoolean(working);
buf.writeInt(progress);
}
@Override
public IInventory getDroppedInventory()
{
return inventory;
}
@Override
public int getSizeInventory()
{
return inventory.getSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot)
{
return inventory.getStackInSlot(slot);
}
@Override
public ItemStack decrStackSize(int slot, int count)
{
return inventory.decrStackSize(slot, count);
}
@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
return inventory.getStackInSlotOnClosing(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack)
{
inventory.setInventorySlotContents(slot, stack);
}
@Override
public int getInventoryStackLimit()
{
return inventory.getInventoryStackLimit();
}
@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
return inventory.isUseableByPlayer(player);
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack stack)
{
return inventory.isItemValidForSlot(slot, stack);
}
@Override
public void openInventory(EntityPlayer player)
{
inventory.openInventory(player);
}
@Override
public void closeInventory(EntityPlayer player)
{
inventory.closeInventory(player);
}
@Override
public int getField(int id)
{
return inventory.getField(id);
}
@Override
public void setField(int id, int value)
{
inventory.setField(id, value);
}
@Override
public int getFieldCount()
{
return inventory.getFieldCount();
}
@Override
public void clear()
{
inventory.clear();
}
@Override
public String getName()
{
return inventory.getName();
}
@Override
public boolean hasCustomName()
{
return inventory.hasCustomName();
}
@Override
public IChatComponent getDisplayName()
{
return inventory.getDisplayName();
}
}

500
src/main/java/storagecraft/util/InventoryUtils.java
View File

@@ -1,250 +1,250 @@
package storagecraft.util;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.world.World;
import net.minecraftforge.common.util.Constants;
public class InventoryUtils
{
public static final String NBT_INVENTORY = "Inventory";
public static final String NBT_SLOT = "Slot";
public static final int COMPARE_DAMAGE = 1;
public static final int COMPARE_NBT = 2;
public static final int COMPARE_QUANTITY = 4;
public static void saveInventory(IInventory inventory, NBTTagCompound nbt)
{
NBTTagList tagList = new NBTTagList();
for (int i = 0; i < inventory.getSizeInventory(); i++)
{
if (inventory.getStackInSlot(i) != null)
{
NBTTagCompound compoundTag = new NBTTagCompound();
compoundTag.setInteger(NBT_SLOT, i);
inventory.getStackInSlot(i).writeToNBT(compoundTag);
tagList.appendTag(compoundTag);
}
}
nbt.setTag(NBT_INVENTORY, tagList);
}
public static void restoreInventory(IInventory inventory, NBTTagCompound nbt)
{
if (nbt.hasKey(NBT_INVENTORY))
{
NBTTagList tagList = nbt.getTagList(NBT_INVENTORY, Constants.NBT.TAG_COMPOUND);
for (int i = 0; i < tagList.tagCount(); i++)
{
int slot = tagList.getCompoundTagAt(i).getInteger(NBT_SLOT);
ItemStack stack = ItemStack.loadItemStackFromNBT(tagList.getCompoundTagAt(i));
inventory.setInventorySlotContents(slot, stack);
}
}
}
public static void dropInventory(World world, IInventory inventory, int x, int y, int z)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack stack = inventory.getStackInSlot(i);
if (stack != null)
{
dropStack(world, stack, x, y, z);
}
}
}
public static void dropStack(World world, ItemStack stack, int x, int y, int z)
{
float xo = world.rand.nextFloat() * 0.8F + 0.1F;
float yo = world.rand.nextFloat() * 0.8F + 0.1F;
float zo = world.rand.nextFloat() * 0.8F + 0.1F;
while (stack.stackSize > 0)
{
int amount = world.rand.nextInt(21) + 10;
if (amount > stack.stackSize)
{
amount = stack.stackSize;
}
stack.stackSize -= amount;
EntityItem entity = new EntityItem(world, (float) x + xo, (float) y + yo, (float) z + zo, new ItemStack(stack.getItem(), amount, stack.getItemDamage()));
entity.motionX = (float) world.rand.nextGaussian() * 0.05F;
entity.motionY = (float) world.rand.nextGaussian() * 0.05F + 0.2F;
entity.motionZ = (float) world.rand.nextGaussian() * 0.05F;
if (stack.hasTagCompound())
{
entity.getEntityItem().setTagCompound((NBTTagCompound) stack.getTagCompound().copy());
}
world.spawnEntityInWorld(entity);
}
}
public static void pushToInventorySlot(IInventory inventory, int i, ItemStack stack)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
inventory.setInventorySlotContents(i, stack);
}
else if (compareStackNoQuantity(slot, stack))
{
slot.stackSize += stack.stackSize;
}
}
public static boolean canPushToInventorySlot(IInventory inventory, int i, ItemStack stack)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
return true;
}
if (!compareStackNoQuantity(slot, stack))
{
return false;
}
return slot.stackSize + stack.stackSize < slot.getMaxStackSize();
}
public static void pushToInventory(IInventory inventory, ItemStack stack)
{
int toGo = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
inventory.setInventorySlotContents(i, stack);
return;
}
else if (compareStackNoQuantity(slot, stack))
{
int toAdd = toGo;
if (slot.stackSize + toAdd > slot.getMaxStackSize())
{
toAdd = slot.getMaxStackSize() - slot.stackSize;
}
slot.stackSize += toAdd;
toGo -= toAdd;
if (toGo == 0)
{
return;
}
}
}
}
public static boolean canPushToInventory(IInventory inventory, ItemStack stack)
{
int toGo = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
return true;
}
else if (compareStackNoQuantity(slot, stack))
{
int toAdd = toGo;
if (slot.stackSize + toAdd > slot.getMaxStackSize())
{
toAdd = slot.getMaxStackSize() - slot.stackSize;
}
toGo -= toAdd;
if (toGo == 0)
{
break;
}
}
}
return toGo == 0;
}
public static boolean compareStack(ItemStack first, ItemStack second)
{
return compareStack(first, second, COMPARE_NBT | COMPARE_DAMAGE | COMPARE_QUANTITY);
}
public static boolean compareStack(ItemStack first, ItemStack second, int flags)
{
if (first == null && second == null)
{
return true;
}
if ((first == null && second != null) || (first != null && second == null))
{
return false;
}
if ((flags & COMPARE_DAMAGE) == COMPARE_DAMAGE)
{
if (first.getItemDamage() != second.getItemDamage())
{
return false;
}
}
if ((flags & COMPARE_NBT) == COMPARE_NBT)
{
if (first.stackTagCompound != null && !first.stackTagCompound.equals(second.stackTagCompound))
{
return false;
}
}
if ((flags & COMPARE_QUANTITY) == COMPARE_QUANTITY)
{
if (first.stackSize != second.stackSize)
{
return false;
}
}
return first.getItem() == second.getItem();
}
public static boolean compareStackNoQuantity(ItemStack first, ItemStack second)
{
return compareStack(first, second, COMPARE_NBT | COMPARE_DAMAGE);
}
}
package storagecraft.util;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.world.World;
import net.minecraftforge.common.util.Constants;
public class InventoryUtils
{
public static final String NBT_INVENTORY = "Inventory";
public static final String NBT_SLOT = "Slot";
public static final int COMPARE_DAMAGE = 1;
public static final int COMPARE_NBT = 2;
public static final int COMPARE_QUANTITY = 4;
public static void saveInventory(IInventory inventory, NBTTagCompound nbt)
{
NBTTagList tagList = new NBTTagList();
for (int i = 0; i < inventory.getSizeInventory(); i++)
{
if (inventory.getStackInSlot(i) != null)
{
NBTTagCompound compoundTag = new NBTTagCompound();
compoundTag.setInteger(NBT_SLOT, i);
inventory.getStackInSlot(i).writeToNBT(compoundTag);
tagList.appendTag(compoundTag);
}
}
nbt.setTag(NBT_INVENTORY, tagList);
}
public static void restoreInventory(IInventory inventory, NBTTagCompound nbt)
{
if (nbt.hasKey(NBT_INVENTORY))
{
NBTTagList tagList = nbt.getTagList(NBT_INVENTORY, Constants.NBT.TAG_COMPOUND);
for (int i = 0; i < tagList.tagCount(); i++)
{
int slot = tagList.getCompoundTagAt(i).getInteger(NBT_SLOT);
ItemStack stack = ItemStack.loadItemStackFromNBT(tagList.getCompoundTagAt(i));
inventory.setInventorySlotContents(slot, stack);
}
}
}
public static void dropInventory(World world, IInventory inventory, int x, int y, int z)
{
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack stack = inventory.getStackInSlot(i);
if (stack != null)
{
dropStack(world, stack, x, y, z);
}
}
}
public static void dropStack(World world, ItemStack stack, int x, int y, int z) // @TODO: Take BlockPos here
{
float xo = world.rand.nextFloat() * 0.8F + 0.1F;
float yo = world.rand.nextFloat() * 0.8F + 0.1F;
float zo = world.rand.nextFloat() * 0.8F + 0.1F;
while (stack.stackSize > 0)
{
int amount = world.rand.nextInt(21) + 10;
if (amount > stack.stackSize)
{
amount = stack.stackSize;
}
stack.stackSize -= amount;
EntityItem entity = new EntityItem(world, (float) x + xo, (float) y + yo, (float) z + zo, new ItemStack(stack.getItem(), amount, stack.getItemDamage()));
entity.motionX = (float) world.rand.nextGaussian() * 0.05F;
entity.motionY = (float) world.rand.nextGaussian() * 0.05F + 0.2F;
entity.motionZ = (float) world.rand.nextGaussian() * 0.05F;
if (stack.hasTagCompound())
{
entity.getEntityItem().setTagCompound((NBTTagCompound) stack.getTagCompound().copy());
}
world.spawnEntityInWorld(entity);
}
}
public static void pushToInventorySlot(IInventory inventory, int i, ItemStack stack)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
inventory.setInventorySlotContents(i, stack);
}
else if (compareStackNoQuantity(slot, stack))
{
slot.stackSize += stack.stackSize;
}
}
public static boolean canPushToInventorySlot(IInventory inventory, int i, ItemStack stack)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
return true;
}
if (!compareStackNoQuantity(slot, stack))
{
return false;
}
return slot.stackSize + stack.stackSize < slot.getMaxStackSize();
}
public static void pushToInventory(IInventory inventory, ItemStack stack)
{
int toGo = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
inventory.setInventorySlotContents(i, stack);
return;
}
else if (compareStackNoQuantity(slot, stack))
{
int toAdd = toGo;
if (slot.stackSize + toAdd > slot.getMaxStackSize())
{
toAdd = slot.getMaxStackSize() - slot.stackSize;
}
slot.stackSize += toAdd;
toGo -= toAdd;
if (toGo == 0)
{
return;
}
}
}
}
public static boolean canPushToInventory(IInventory inventory, ItemStack stack)
{
int toGo = stack.stackSize;
for (int i = 0; i < inventory.getSizeInventory(); ++i)
{
ItemStack slot = inventory.getStackInSlot(i);
if (slot == null)
{
return true;
}
else if (compareStackNoQuantity(slot, stack))
{
int toAdd = toGo;
if (slot.stackSize + toAdd > slot.getMaxStackSize())
{
toAdd = slot.getMaxStackSize() - slot.stackSize;
}
toGo -= toAdd;
if (toGo == 0)
{
break;
}
}
}
return toGo == 0;
}
public static boolean compareStack(ItemStack first, ItemStack second)
{
return compareStack(first, second, COMPARE_NBT | COMPARE_DAMAGE | COMPARE_QUANTITY);
}
public static boolean compareStack(ItemStack first, ItemStack second, int flags)
{
if (first == null && second == null)
{
return true;
}
if ((first == null && second != null) || (first != null && second == null))
{
return false;
}
if ((flags & COMPARE_DAMAGE) == COMPARE_DAMAGE)
{
if (first.getItemDamage() != second.getItemDamage())
{
return false;
}
}
if ((flags & COMPARE_NBT) == COMPARE_NBT)
{
if (first.hasTagCompound() && !first.getTagCompound().equals(second.getTagCompound()))
{
return false;
}
}
if ((flags & COMPARE_QUANTITY) == COMPARE_QUANTITY)
{
if (first.stackSize != second.stackSize)
{
return false;
}
}
return first.getItem() == second.getItem();
}
public static boolean compareStackNoQuantity(ItemStack first, ItemStack second)
{
return compareStack(first, second, COMPARE_NBT | COMPARE_DAMAGE);
}
}