tilera/Mekanism-tilera-Edition
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Work on Quantum Entangloporters. I get the feeling this is gonna be a big project

Browse source
This commit is contained in:
aidancbrady 2016-03-04 11:06:05 -05:00
parent cfb0986a48
commit ad15e359ac
13 changed files with 562 additions and 220 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/main/java/mekanism/client/ClientProxy.java
View file

@ -148,7 +148,7 @@ import mekanism.common.tile.TileEntityEliteFactory;
import mekanism.common.tile.TileEntityEnergizedSmelter;
import mekanism.common.tile.TileEntityEnergyCube;
import mekanism.common.tile.TileEntityEnrichmentChamber;
import mekanism.common.tile.TileEntityEntangledBlock;
import mekanism.common.tile.TileEntityQuantumEntangloporter;
import mekanism.common.tile.TileEntityFactory;
import mekanism.common.tile.TileEntityFluidTank;
import mekanism.common.tile.TileEntityFluidicPlenisher;
@ -510,7 +510,7 @@ public class ClientProxy extends CommonProxy
case 45:
return new GuiLaserTractorBeam(player.inventory, (TileEntityLaserTractorBeam)tileEntity);
case 46:
return new GuiEntangledBlock(player.inventory, (TileEntityEntangledBlock)tileEntity);
return new GuiEntangledBlock(player.inventory, (TileEntityQuantumEntangloporter)tileEntity);
case 47:
return new GuiSolarNeutronActivator(player.inventory, (TileEntitySolarNeutronActivator)tileEntity);
case 48:

6
src/main/java/mekanism/client/gui/GuiEntangledBlock.java
View file

@ -6,7 +6,7 @@ import mekanism.api.Coord4D;
import mekanism.common.Mekanism;
import mekanism.common.inventory.container.ContainerNull;
import mekanism.common.network.PacketTileEntity.TileEntityMessage;
import mekanism.common.tile.TileEntityEntangledBlock;
import mekanism.common.tile.TileEntityQuantumEntangloporter;
import mekanism.common.util.LangUtils;
import mekanism.common.util.MekanismUtils;
import mekanism.common.util.MekanismUtils.ResourceType;
@ -22,13 +22,13 @@ import cpw.mods.fml.relauncher.SideOnly;
@SideOnly(Side.CLIENT)
public class GuiEntangledBlock extends GuiMekanism
{
public TileEntityEntangledBlock tileEntity;
public TileEntityQuantumEntangloporter tileEntity;
public GuiTextField frequencyField;
public boolean isCreative;
public GuiEntangledBlock(InventoryPlayer inventory, TileEntityEntangledBlock tentity)
public GuiEntangledBlock(InventoryPlayer inventory, TileEntityQuantumEntangloporter tentity)
{
super(tentity, new ContainerNull(inventory.player, tentity));
tileEntity = tentity;

5
src/main/java/mekanism/client/gui/GuiQuantumEntangloporter.java Normal file
View file

@ -0,0 +1,5 @@
package mekanism.client.gui;
public class GuiQuantumEntangloporter {
}

9
src/main/java/mekanism/common/Mekanism.java
View file

@ -44,6 +44,7 @@ import mekanism.common.base.IModule;
import mekanism.common.block.BlockMachine.MachineType;
import mekanism.common.chunkloading.ChunkManager;
import mekanism.common.content.boiler.SynchronizedBoilerData;
import mekanism.common.content.entangloporter.InventoryFrequency;
import mekanism.common.content.matrix.SynchronizedMatrixData;
import mekanism.common.content.tank.SynchronizedTankData;
import mekanism.common.content.transporter.PathfinderCache;
@ -75,8 +76,8 @@ import mekanism.common.tile.TileEntityAdvancedBoundingBlock;
import mekanism.common.tile.TileEntityBoundingBlock;
import mekanism.common.tile.TileEntityCardboardBox;
import mekanism.common.tile.TileEntityElectricBlock;
import mekanism.common.tile.TileEntityEntangledBlock;
import mekanism.common.tile.TileEntityPressureDisperser;
import mekanism.common.tile.TileEntityQuantumEntangloporter;
import mekanism.common.tile.TileEntitySuperheatingElement;
import mekanism.common.tile.TileEntityThermalEvaporationBlock;
import mekanism.common.tile.TileEntityThermalEvaporationValve;
@ -177,6 +178,9 @@ public class Mekanism
public static FrequencyManager publicTeleporters = new FrequencyManager(Frequency.class);
public static Map<String, FrequencyManager> privateTeleporters = new HashMap<String, FrequencyManager>();
public static FrequencyManager publicEntangloporters = new FrequencyManager(InventoryFrequency.class);
public static Map<String, FrequencyManager> privateEntangloporters = new HashMap<String, FrequencyManager>();
/** Mekanism creative tab */
public static CreativeTabMekanism tabMekanism = new CreativeTabMekanism();
@ -1111,7 +1115,7 @@ public class Mekanism
GameRegistry.registerTileEntity(TileEntityCardboardBox.class, "CardboardBox");
GameRegistry.registerTileEntity(TileEntityThermalEvaporationValve.class, "SalinationValve"); //TODO rename
GameRegistry.registerTileEntity(TileEntityThermalEvaporationBlock.class, "SalinationTank"); //TODO rename
GameRegistry.registerTileEntity(TileEntityEntangledBlock.class, "EntangledBlock");
GameRegistry.registerTileEntity(TileEntityQuantumEntangloporter.class, "EntangledBlock");
GameRegistry.registerTileEntity(TileEntityPressureDisperser.class, "PressureDisperser");
GameRegistry.registerTileEntity(TileEntitySuperheatingElement.class, "SuperheatingElement");
@ -1154,6 +1158,7 @@ public class Mekanism
activeVibrators.clear();
worldTickHandler.resetRegenChunks();
privateTeleporters.clear();
privateEntangloporters.clear();
//Reset consistent managers
MultiblockManager.reset();

35
src/main/java/mekanism/common/block/BlockMachine.java
View file

@ -63,7 +63,6 @@ import mekanism.common.tile.TileEntityElectrolyticSeparator;
import mekanism.common.tile.TileEntityEliteFactory;
import mekanism.common.tile.TileEntityEnergizedSmelter;
import mekanism.common.tile.TileEntityEnrichmentChamber;
import mekanism.common.tile.TileEntityEntangledBlock;
import mekanism.common.tile.TileEntityFactory;
import mekanism.common.tile.TileEntityFluidTank;
import mekanism.common.tile.TileEntityFluidicPlenisher;
@ -77,6 +76,7 @@ import mekanism.common.tile.TileEntityOsmiumCompressor;
import mekanism.common.tile.TileEntityPRC;
import mekanism.common.tile.TileEntityPrecisionSawmill;
import mekanism.common.tile.TileEntityPurificationChamber;
import mekanism.common.tile.TileEntityQuantumEntangloporter;
import mekanism.common.tile.TileEntityResistiveHeater;
import mekanism.common.tile.TileEntityRotaryCondensentrator;
import mekanism.common.tile.TileEntitySeismicVibrator;
@ -149,7 +149,7 @@ import cpw.mods.fml.relauncher.SideOnly;
* 1:13: Laser
* 1:14: Laser Amplifier
* 1:15: Laser Tractor Beam
* 2:0: Entangled Block
* 2:0: Quantum Entangloporter
* 2:1: Solar Neutron Activator
* 2:2: Ambient Accumulator
* 2:3: Oredictionificator
@ -312,6 +312,11 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo
TileEntityTeleporter teleporter = (TileEntityTeleporter)tileEntity;
teleporter.owner = entityliving.getCommandSenderName();
}
else if(tileEntity instanceof TileEntityQuantumEntangloporter)
{
TileEntityQuantumEntangloporter entangloporter = (TileEntityQuantumEntangloporter)tileEntity;
entangloporter.owner = entityliving.getCommandSenderName();
}
tileEntity.setFacing((short)change);
tileEntity.redstone = world.isBlockIndirectlyGettingPowered(x, y, z);
@ -666,6 +671,26 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo
entityplayer.addChatMessage(new ChatComponentText(EnumColor.DARK_BLUE + "[Mekanism] " + EnumColor.GREY + LangUtils.localize("gui.teleporter.noAccess")));
}
return true;
}
case QUANTUM_ENTANGLOPORTER:
if(!entityplayer.isSneaking())
{
TileEntityQuantumEntangloporter teleporter = (TileEntityQuantumEntangloporter)tileEntity;
if(teleporter.owner == null)
{
teleporter.owner = entityplayer.getCommandSenderName();
}
if(teleporter.owner.equals(entityplayer.getCommandSenderName()) || MekanismUtils.isOp((EntityPlayerMP)entityplayer))
{
entityplayer.openGui(Mekanism.instance, type.guiId, world, x, y, z);
}
else {
entityplayer.addChatMessage(new ChatComponentText(EnumColor.DARK_BLUE + "[Mekanism] " + EnumColor.GREY + LangUtils.localize("gui.entangloporter.noAccess")));
}
return true;
}
default:
@ -1144,7 +1169,7 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo
LASER(MachineBlock.MACHINE_BLOCK_2, 13, "Laser", -1, TileEntityLaser.class, true, true, false),
LASER_AMPLIFIER(MachineBlock.MACHINE_BLOCK_2, 14, "LaserAmplifier", 44, TileEntityLaserAmplifier.class, false, true, false),
LASER_TRACTOR_BEAM(MachineBlock.MACHINE_BLOCK_2, 15, "LaserTractorBeam", 45, TileEntityLaserTractorBeam.class, false, true, false),
ENTANGLED_BLOCK(MachineBlock.MACHINE_BLOCK_3, 0, "EntangledBlock", 46, TileEntityEntangledBlock.class, true, false, false),
QUANTUM_ENTANGLOPORTER(MachineBlock.MACHINE_BLOCK_3, 0, "QuantumEntangloporter", 46, TileEntityQuantumEntangloporter.class, true, false, false),
SOLAR_NEUTRON_ACTIVATOR(MachineBlock.MACHINE_BLOCK_3, 1, "SolarNeutronActivator", 47, TileEntitySolarNeutronActivator.class, false, true, false),
AMBIENT_ACCUMULATOR(MachineBlock.MACHINE_BLOCK_3, 2, "AmbientAccumulator", 48, TileEntityAmbientAccumulator.class, true, false, false),
OREDICTIONIFICATOR(MachineBlock.MACHINE_BLOCK_3, 3, "Oredictionificator", 52, TileEntityOredictionificator.class, false, false, false),
@ -1199,7 +1224,7 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo
for(MachineType type : MachineType.values())
{
if(type != ENTANGLED_BLOCK && type != AMBIENT_ACCUMULATOR)
if(type != QUANTUM_ENTANGLOPORTER && type != AMBIENT_ACCUMULATOR)
{
ret.add(type);
}
@ -1311,7 +1336,7 @@ public class BlockMachine extends BlockContainer implements ISpecialBounds, IBlo
return 0;
case LASER_TRACTOR_BEAM:
return 0;
case ENTANGLED_BLOCK:
case QUANTUM_ENTANGLOPORTER:
return 0;
case SOLAR_NEUTRON_ACTIVATOR:
return 0;

178
src/main/java/mekanism/common/content/entangloporter/InventoryFrequency.java Normal file
View file

@ -0,0 +1,178 @@
package mekanism.common.content.entangloporter;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import mekanism.api.gas.GasStack;
import mekanism.api.gas.GasTank;
import mekanism.api.transmitters.TransmissionType;
import mekanism.common.frequency.Frequency;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.fluids.FluidRegistry;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
public class InventoryFrequency extends Frequency
{
public static final double MAX_ENERGY = 1000000;
public double storedEnergy;
public FluidTank storedFluid = new FluidTank(1000);
public GasTank storedGas = new GasTank(1000);
public ItemStack storedItem;
public double temperature;
public Map<TransmissionType, TransferType> transmissions = new HashMap<TransmissionType, TransferType>();
public InventoryFrequency(String n, String o)
{
super(n, o);
}
public InventoryFrequency(NBTTagCompound nbtTags)
{
super(nbtTags);
}
public InventoryFrequency(ByteBuf dataStream)
{
super(dataStream);
}
@Override
public void write(NBTTagCompound nbtTags)
{
super.write(nbtTags);
nbtTags.setDouble("storedEnergy", storedEnergy);
if(storedFluid != null)
{
nbtTags.setTag("storedFluid", storedFluid.writeToNBT(new NBTTagCompound()));
}
if(storedGas != null)
{
nbtTags.setTag("storedGas", storedGas.write(new NBTTagCompound()));
}
if(storedItem != null)
{
nbtTags.setTag("storedItem", storedItem.writeToNBT(new NBTTagCompound()));
}
nbtTags.setDouble("temperature", temperature);
for(TransmissionType type : TransmissionType.values())
{
nbtTags.setInteger("transmission" + type.ordinal(), transmissions.get(type).ordinal());
}
}
@Override
protected void read(NBTTagCompound nbtTags)
{
super.read(nbtTags);
storedEnergy = nbtTags.getDouble("storedEnergy");
if(nbtTags.hasKey("storedFluid"))
{
storedFluid.readFromNBT(nbtTags.getCompoundTag("storedFluid"));
}
if(nbtTags.hasKey("storedGas"))
{
storedGas.read(nbtTags.getCompoundTag("storedGas"));
}
if(nbtTags.hasKey("storedItem"))
{
storedItem.readFromNBT(nbtTags.getCompoundTag("storedItem"));
}
temperature = nbtTags.getDouble("temperature");
for(TransmissionType type : TransmissionType.values())
{
transmissions.put(type, TransferType.values()[nbtTags.getInteger("transmission" + type.ordinal())]);
}
}
@Override
public void write(ArrayList data)
{
super.write(data);
data.add(storedEnergy);
if(storedFluid.getFluid() != null)
{
data.add(true);
data.add(storedFluid.getFluid().getFluidID());
data.add(storedFluid.getFluidAmount());
}
else {
data.add(false);
}
if(storedGas.getGas() != null)
{
data.add(true);
data.add(storedGas.getGasType().getID());
data.add(storedGas.getStored());
}
else {
data.add(false);
}
data.add(temperature);
for(TransmissionType type : TransmissionType.values())
{
data.add(transmissions.get(type).ordinal());
}
}
@Override
protected void read(ByteBuf dataStream)
{
super.read(dataStream);
storedEnergy = dataStream.readDouble();
if(dataStream.readBoolean())
{
storedFluid.setFluid(new FluidStack(FluidRegistry.getFluid(dataStream.readInt()), dataStream.readInt()));
}
else {
storedFluid.setFluid(null);
}
if(dataStream.readBoolean())
{
storedGas.setGas(new GasStack(dataStream.readInt(), dataStream.readInt()));
}
else {
storedGas.setGas(null);
}
temperature = dataStream.readDouble();
for(TransmissionType type : TransmissionType.values())
{
transmissions.put(type, TransferType.values()[dataStream.readInt()]);
}
}
public static enum TransferType
{
RECEIVE,
SEND,
BOTH;
}
}

2
src/main/java/mekanism/common/content/teleportation/SharedInventory.java → src/main/java/mekanism/common/content/entangloporter/SharedInventory.java
View file

@ -1,4 +1,4 @@
package mekanism.common.content.teleportation;
package mekanism.common.content.entangloporter;
import mekanism.api.energy.IStrictEnergyStorage;
import mekanism.api.gas.Gas;

2
src/main/java/mekanism/common/content/teleportation/SharedInventoryManager.java → src/main/java/mekanism/common/content/entangloporter/SharedInventoryManager.java
View file

@ -1,4 +1,4 @@
package mekanism.common.content.teleportation;
package mekanism.common.content.entangloporter;
import java.util.Arrays;
import java.util.HashMap;

2
src/main/java/mekanism/common/frequency/FrequencyManager.java
View file

@ -282,7 +282,7 @@ public class FrequencyManager
try {
for(int i = 0; i < size; i++)
{
Frequency freq = frequencyClass.newInstance();
Frequency freq = frequencyClass.getConstructor(new Class[] {ByteBuf.class}).newInstance(dataStream);
freq.read(dataStream);
ret.add(freq);
}

12
src/main/java/mekanism/common/tile/TileEntityElectricBlock.java
View file

@ -213,14 +213,14 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
{
if(getConsumingSides().contains(from))
{
double toAdd = (int)Math.min(getMaxEnergy()-getEnergy(), maxReceive* general.FROM_TE);
double toAdd = (int)Math.min(getMaxEnergy()-getEnergy(), maxReceive*general.FROM_TE);
if(!simulate)
{
setEnergy(getEnergy() + toAdd);
}
return (int)Math.round(toAdd* general.TO_TE);
return (int)Math.round(toAdd*general.TO_TE);
}
return 0;
@ -232,14 +232,14 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
{
if(getOutputtingSides().contains(from))
{
double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), maxExtract* general.FROM_TE));
double toSend = Math.min(getEnergy(), Math.min(getMaxOutput(), maxExtract*general.FROM_TE));
if(!simulate)
{
setEnergy(getEnergy() - toSend);
}
return (int)Math.round(toSend* general.TO_TE);
return (int)Math.round(toSend*general.TO_TE);
}
return 0;
@ -256,14 +256,14 @@ public abstract class TileEntityElectricBlock extends TileEntityContainerBlock i
@Method(modid = "CoFHCore")
public int getEnergyStored(ForgeDirection from)
{
return (int)Math.round(getEnergy()* general.TO_TE);
return (int)Math.round(getEnergy()*general.TO_TE);
}
@Override
@Method(modid = "CoFHCore")
public int getMaxEnergyStored(ForgeDirection from)
{
return (int)Math.round(getMaxEnergy()* general.TO_TE);
return (int)Math.round(getMaxEnergy()*general.TO_TE);
}
@Override

198
src/main/java/mekanism/common/tile/TileEntityEntangledBlock.java
View file

@ -1,198 +0,0 @@
package mekanism.common.tile;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.EnumSet;
import mekanism.api.gas.Gas;
import mekanism.api.gas.GasStack;
import mekanism.api.gas.IGasHandler;
import mekanism.api.gas.ITubeConnection;
import mekanism.common.PacketHandler;
import mekanism.common.content.teleportation.SharedInventory;
import mekanism.common.content.teleportation.SharedInventoryManager;
import mekanism.common.util.CableUtils;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
public class TileEntityEntangledBlock extends TileEntityElectricBlock implements IFluidHandler, IGasHandler, ITubeConnection
{
public SharedInventory sharedInventory;
public static final EnumSet<ForgeDirection> nothing = EnumSet.noneOf(ForgeDirection.class);
public TileEntityEntangledBlock()
{
super("Entangled", 0);
inventory = new ItemStack[0];
}
@Override
public void onUpdate()
{
super.onUpdate();
CableUtils.emit(this);
}
public void setInventory(String frequency)
{
sharedInventory = SharedInventoryManager.getInventory(frequency);
markDirty();
}
@Override
public void handlePacketData(ByteBuf dataStream)
{
if(!worldObj.isRemote)
{
switch(dataStream.readInt())
{
case 0:
setInventory(PacketHandler.readString(dataStream));
return;
}
}
super.handlePacketData(dataStream);
setEnergy(dataStream.readDouble());
}
@Override
public ArrayList getNetworkedData(ArrayList data)
{
super.getNetworkedData(data);
data.add(getEnergy());
return data;
}
@Override
public EnumSet<ForgeDirection> getOutputtingSides()
{
return sharedInventory == null ? nothing : EnumSet.of(ForgeDirection.UP);
}
@Override
public EnumSet<ForgeDirection> getConsumingSides()
{
return sharedInventory == null ? nothing : EnumSet.complementOf(EnumSet.of(ForgeDirection.UNKNOWN, ForgeDirection.UP));
}
@Override
public double getMaxOutput()
{
return sharedInventory == null ? 0 : 1000;
}
@Override
public double getEnergy()
{
return sharedInventory == null ? 0 : sharedInventory.getEnergy();
}
@Override
public void setEnergy(double energy)
{
if(sharedInventory != null)
{
sharedInventory.setEnergy(energy);
}
}
@Override
public double getMaxEnergy()
{
return sharedInventory == null ? 0 : sharedInventory.getMaxEnergy();
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
return sharedInventory == null ? 0 : sharedInventory.fill(from, resource, doFill);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
if(sharedInventory == null)
{
return null;
}
return sharedInventory.drain(from, resource, doDrain);
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
if(sharedInventory == null)
{
return null;
}
return sharedInventory.drain(from, maxDrain, doDrain);
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
return sharedInventory == null ? false : sharedInventory.canFill(from, fluid);
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
return sharedInventory == null ? false : sharedInventory.canDrain(from, fluid);
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return sharedInventory == null ? new FluidTankInfo[0] : sharedInventory.getTankInfo(from);
}
@Override
public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer)
{
return sharedInventory == null ? 0 : sharedInventory.receiveGas(side, stack, doTransfer);
}
@Override
public int receiveGas(ForgeDirection side, GasStack stack)
{
return receiveGas(side, stack, true);
}
@Override
public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer)
{
return sharedInventory == null ? null : sharedInventory.drawGas(side, amount, doTransfer);
}
@Override
public GasStack drawGas(ForgeDirection side, int amount)
{
return drawGas(side, amount, true);
}
@Override
public boolean canReceiveGas(ForgeDirection side, Gas type)
{
return sharedInventory == null ? false : sharedInventory.canReceiveGas(side, type);
}
@Override
public boolean canDrawGas(ForgeDirection side, Gas type)
{
return sharedInventory == null ? false : sharedInventory.canDrawGas(side, type);
}
@Override
public boolean canTubeConnect(ForgeDirection side)
{
return sharedInventory == null ? false : true;
}
}

324
src/main/java/mekanism/common/tile/TileEntityQuantumEntangloporter.java Normal file
View file

@ -0,0 +1,324 @@
package mekanism.common.tile;
import io.netty.buffer.ByteBuf;
import java.util.ArrayList;
import java.util.EnumSet;
import mekanism.api.Coord4D;
import mekanism.api.gas.Gas;
import mekanism.api.gas.GasStack;
import mekanism.api.gas.IGasHandler;
import mekanism.common.Mekanism;
import mekanism.common.PacketHandler;
import mekanism.common.content.entangloporter.InventoryFrequency;
import mekanism.common.frequency.Frequency;
import mekanism.common.frequency.FrequencyManager;
import mekanism.common.frequency.IFrequencyHandler;
import mekanism.common.util.CableUtils;
import mekanism.common.util.MekanismUtils;
import mekanism.common.util.PipeUtils;
import net.minecraft.item.ItemStack;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;
public class TileEntityQuantumEntangloporter extends TileEntityElectricBlock implements IFluidHandler, IFrequencyHandler, IGasHandler
{
public String owner;
public InventoryFrequency frequency;
public static final EnumSet<ForgeDirection> nothing = EnumSet.noneOf(ForgeDirection.class);
public TileEntityQuantumEntangloporter()
{
super("QuantumEntangloporter", 0);
inventory = new ItemStack[0];
}
@Override
public void onUpdate()
{
super.onUpdate();
CableUtils.emit(this);
}
@Override
public Frequency getFrequency()
{
return frequency;
}
public FrequencyManager getManager(Frequency freq)
{
if(owner == null || freq == null)
{
return null;
}
if(freq.isPublic())
{
return Mekanism.publicEntangloporters;
}
else {
if(!Mekanism.privateEntangloporters.containsKey(owner))
{
FrequencyManager manager = new FrequencyManager(InventoryFrequency.class, owner);
Mekanism.privateEntangloporters.put(owner, manager);
manager.createOrLoad(worldObj);
}
return Mekanism.privateEntangloporters.get(owner);
}
}
public void setFrequency(String name, boolean publicFreq)
{
if(name.equals(frequency))
{
return;
}
FrequencyManager manager = getManager(new Frequency(name, null).setPublic(publicFreq));
manager.deactivate(Coord4D.get(this));
for(Frequency freq : manager.getFrequencies())
{
if(freq.name.equals(name))
{
frequency = (InventoryFrequency)freq;
frequency.activeCoords.add(Coord4D.get(this));
return;
}
}
Frequency freq = new Frequency(name, owner).setPublic(publicFreq);
freq.activeCoords.add(Coord4D.get(this));
manager.addFrequency(freq);
frequency = (InventoryFrequency)freq;
MekanismUtils.saveChunk(this);
markDirty();
}
@Override
public void handlePacketData(ByteBuf dataStream)
{
if(!worldObj.isRemote)
{
int type = dataStream.readInt();
if(type == 0)
{
String name = PacketHandler.readString(dataStream);
boolean isPublic = dataStream.readBoolean();
setFrequency(name, isPublic);
}
else if(type == 1)
{
String freq = PacketHandler.readString(dataStream);
boolean isPublic = dataStream.readBoolean();
FrequencyManager manager = getManager(new Frequency(freq, null).setPublic(isPublic));
if(manager != null)
{
manager.remove(freq, owner);
}
}
return;
}
super.handlePacketData(dataStream);
setEnergy(dataStream.readDouble());
}
@Override
public ArrayList getNetworkedData(ArrayList data)
{
super.getNetworkedData(data);
data.add(getEnergy());
return data;
}
@Override
public EnumSet<ForgeDirection> getOutputtingSides()
{
return frequency == null ? nothing : EnumSet.of(ForgeDirection.UP);
}
@Override
public EnumSet<ForgeDirection> getConsumingSides()
{
return frequency == null ? nothing : EnumSet.complementOf(EnumSet.of(ForgeDirection.UNKNOWN, ForgeDirection.UP));
}
@Override
public double getMaxOutput()
{
return frequency == null ? 0 : InventoryFrequency.MAX_ENERGY;
}
@Override
public double getEnergy()
{
return frequency == null ? 0 : frequency.storedEnergy;
}
@Override
public void setEnergy(double energy)
{
if(frequency != null)
{
frequency.storedEnergy = Math.min(InventoryFrequency.MAX_ENERGY, energy);
}
}
@Override
public double getMaxEnergy()
{
return frequency == null ? 0 : frequency.MAX_ENERGY;
}
@Override
public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
{
return frequency == null ? 0 : frequency.storedFluid.fill(resource, doFill);
}
@Override
public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
{
if(frequency != null && resource.isFluidEqual(frequency.storedFluid.getFluid()))
{
return frequency.storedFluid.drain(resource.amount, doDrain);
}
return null;
}
@Override
public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
{
if(frequency != null)
{
return frequency.storedFluid.drain(maxDrain, doDrain);
}
return null;
}
@Override
public boolean canFill(ForgeDirection from, Fluid fluid)
{
if(frequency != null)
{
return frequency.storedFluid.getFluid() == null || fluid == frequency.storedFluid.getFluid().getFluid();
}
return false;
}
@Override
public boolean canDrain(ForgeDirection from, Fluid fluid)
{
if(frequency != null)
{
return frequency.storedFluid.getFluid() == null || fluid == frequency.storedFluid.getFluid().getFluid();
}
return false;
}
@Override
public FluidTankInfo[] getTankInfo(ForgeDirection from)
{
return frequency == null ? PipeUtils.EMPTY : new FluidTankInfo[] {frequency.storedFluid.getInfo()};
}
@Override
public int receiveGas(ForgeDirection side, GasStack stack, boolean doTransfer)
{
return frequency == null ? 0 : frequency.storedGas.receive(stack, doTransfer);
}
@Override
public int receiveGas(ForgeDirection side, GasStack stack)
{
return receiveGas(side, stack, true);
}
@Override
public GasStack drawGas(ForgeDirection side, int amount, boolean doTransfer)
{
return frequency == null ? null : frequency.storedGas.draw(amount, doTransfer);
}
@Override
public GasStack drawGas(ForgeDirection side, int amount)
{
return drawGas(side, amount, true);
}
@Override
public boolean canReceiveGas(ForgeDirection side, Gas type)
{
if(frequency != null)
{
return frequency.storedGas.getGasType() == null || type == frequency.storedGas.getGasType();
}
return false;
}
@Override
public boolean canDrawGas(ForgeDirection side, Gas type)
{
if(frequency != null)
{
return frequency.storedGas.getGasType() == null || type == frequency.storedGas.getGasType();
}
return false;
}
@Override
public boolean handleInventory()
{
return false;
}
@Override
public int getSizeInventory()
{
return 1;
}
@Override
public ItemStack getStackInSlot(int slotID)
{
return frequency != null && slotID == 0 ? frequency.storedItem : null;
}
@Override
public void setInventorySlotContents(int slotID, ItemStack itemstack)
{
if(frequency != null && slotID == 0)
{
frequency.storedItem = itemstack;
if(itemstack != null && itemstack.stackSize > getInventoryStackLimit())
{
itemstack.stackSize = getInventoryStackLimit();
}
}
}
}

5
src/main/resources/assets/mekanism/lang/en_US.lang
View file

@ -147,6 +147,7 @@ tile.MachineBlock2.LaserAmplifier.name=Laser Amplifier
tile.MachineBlock2.LaserTractorBeam.name=Laser Tractor Beam
//Machine Block 3 (third ID iteration)
tile.MachineBlock3.QuantumEntangloporter.name=Quantum Entangloporter
tile.MachineBlock3.SolarNeutronActivator.name=Solar Neutron Activator
tile.MachineBlock3.Oredictionificator.name=Oredictionificator
tile.MachineBlock3.ResistiveHeater.name=Resistive Heater
@ -627,9 +628,11 @@ gui.teleporter.noFrame=No frame
gui.teleporter.noLink=No link
gui.teleporter.exceeds=Links > 2
gui.teleporter.needsEnergy=Needs energy
gui.teleporter.noAccess=You don't have access to this teleporter.
gui.teleporter.noAccess=You don't have access to this Teleporter.
gui.teleporter.noFreq=No frequency
gui.entangloporter.noAccess=You don't have access to this Entangloporter.
gui.digitalMinerConfig=Digital Miner Config
gui.digitalMiner.autoPull=Auto-pull