596 lines
26 KiB
Java
596 lines
26 KiB
Java
|
package gregtech.api.metatileentity.implementations;
|
||
|
|
|
||
|
|
import static gregtech.api.enums.GT_Values.V;
|
||
|
|
import gregtech.api.GregTech_API;
|
||
|
|
import gregtech.api.enums.ItemList;
|
||
|
|
import gregtech.api.enums.Textures;
|
||
|
|
import gregtech.api.gui.GT_Container_BasicMachine;
|
||
|
|
import gregtech.api.gui.GT_GUIContainer_BasicMachine;
|
||
|
|
import gregtech.api.interfaces.ITexture;
|
||
|
|
import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
|
||
|
|
import gregtech.api.objects.GT_ItemStack;
|
||
|
|
import gregtech.api.objects.GT_RenderedTexture;
|
||
|
|
import gregtech.api.util.GT_OreDictUnificator;
|
||
|
|
import gregtech.api.util.GT_Recipe;
|
||
|
|
import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
|
||
|
|
import gregtech.api.util.GT_Utility;
|
||
|
|
|
||
|
|
import java.util.Arrays;
|
||
|
|
|
||
|
|
import net.minecraft.entity.player.EntityPlayer;
|
||
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
||
|
|
import net.minecraft.item.ItemStack;
|
||
|
|
import net.minecraft.nbt.NBTTagCompound;
|
||
|
|
import net.minecraft.tileentity.TileEntity;
|
||
|
|
import net.minecraftforge.common.util.ForgeDirection;
|
||
|
|
import net.minecraftforge.fluids.FluidStack;
|
||
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* NEVER INCLUDE THIS FILE IN YOUR MOD!!!
|
||
|
|
*
|
||
|
|
* This is the main construct for my Basic Machines such as the Automatic Extractor
|
||
|
|
* Extend this class to make a simple Machine
|
||
|
|
*/
|
||
|
|
public abstract class GT_MetaTileEntity_BasicMachine extends GT_MetaTileEntity_BasicTank {
|
||
|
|
public boolean mAllowInputFromOutputSide = false, mFluidTransfer = false, mItemTransfer = false, mHasBeenUpdated = false, mStuttering = false, mCharge = false, mDecharge = false;
|
||
|
|
public int mMainFacing = -1, mProgresstime = 0, mMaxProgresstime = 0, mEUt = 0, mOutputBlocked = 0;
|
||
|
|
public FluidStack mOutputFluid;
|
||
|
|
private FluidStack mFluidOut;
|
||
|
|
public String mGUIName = "", mNEIName = "";
|
||
|
|
|
||
|
|
public final ItemStack[] mOutputItems;
|
||
|
|
public final int mInputSlotCount, mAmperage;
|
||
|
|
|
||
|
|
private static final int OTHER_SLOT_COUNT = 4;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param aOverlays
|
||
|
|
* 0 = SideFacingActive
|
||
|
|
* 1 = SideFacingInactive
|
||
|
|
* 2 = FrontFacingActive
|
||
|
|
* 3 = FrontFacingInactive
|
||
|
|
* 4 = TopFacingActive
|
||
|
|
* 5 = TopFacingInactive
|
||
|
|
* 6 = BottomFacingActive
|
||
|
|
* 7 = BottomFacingInactive
|
||
|
|
* ----- Not all Array Elements have to be initialised, you can also just use 8 Parameters for the Default Pipe Texture Overlays -----
|
||
|
|
* 8 = BottomFacingPipeActive
|
||
|
|
* 9 = BottomFacingPipeInactive
|
||
|
|
* 10 = TopFacingPipeActive
|
||
|
|
* 11 = TopFacingPipeInactive
|
||
|
|
* 12 = SideFacingPipeActive
|
||
|
|
* 13 = SideFacingPipeInactive
|
||
|
|
*/
|
||
|
|
public GT_MetaTileEntity_BasicMachine(int aID, String aName, String aNameRegional, int aTier, int aAmperage, String aDescription, int aInputSlotCount, int aOutputSlotCount, String aGUIName, String aNEIName, ITexture... aOverlays) {
|
||
|
|
super(aID, aName, aNameRegional, aTier, OTHER_SLOT_COUNT+aInputSlotCount+aOutputSlotCount+1, aDescription, aOverlays);
|
||
|
|
mInputSlotCount = Math.max(0, aInputSlotCount);
|
||
|
|
mOutputItems = new ItemStack[Math.max(0, aOutputSlotCount)];
|
||
|
|
mAmperage = aAmperage;
|
||
|
|
mGUIName = aGUIName;
|
||
|
|
mNEIName = aNEIName;
|
||
|
|
}
|
||
|
|
|
||
|
|
public GT_MetaTileEntity_BasicMachine(String aName, int aTier, int aAmperage, String aDescription, ITexture[][][] aTextures, int aInputSlotCount, int aOutputSlotCount, String aGUIName, String aNEIName) {
|
||
|
|
super(aName, aTier, OTHER_SLOT_COUNT+aInputSlotCount+aOutputSlotCount+1, aDescription, aTextures);
|
||
|
|
mInputSlotCount = Math.max(0, aInputSlotCount);
|
||
|
|
mOutputItems = new ItemStack[Math.max(0, aOutputSlotCount)];
|
||
|
|
mAmperage = aAmperage;
|
||
|
|
mGUIName = aGUIName;
|
||
|
|
mNEIName = aNEIName;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public ITexture[][][] getTextureSet(ITexture[] aTextures) {
|
||
|
|
ITexture[][][] rTextures = new ITexture[14][17][];
|
||
|
|
aTextures = Arrays.copyOf(aTextures, 14);
|
||
|
|
|
||
|
|
for (int i = 0; i < aTextures.length; i++) if (aTextures[i] != null) for (byte c = -1; c < 16; c++) {
|
||
|
|
if (rTextures[ i][c+1] == null) rTextures[ i][c+1] = new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][c+1], aTextures[i]};
|
||
|
|
}
|
||
|
|
|
||
|
|
for (byte c = -1; c < 16; c++) {
|
||
|
|
if (rTextures[ 0][c+1] == null) rTextures[ 0][c+1] = getSideFacingActive(c);
|
||
|
|
if (rTextures[ 1][c+1] == null) rTextures[ 1][c+1] = getSideFacingInactive(c);
|
||
|
|
if (rTextures[ 2][c+1] == null) rTextures[ 2][c+1] = getFrontFacingActive(c);
|
||
|
|
if (rTextures[ 3][c+1] == null) rTextures[ 3][c+1] = getFrontFacingInactive(c);
|
||
|
|
if (rTextures[ 4][c+1] == null) rTextures[ 4][c+1] = getTopFacingActive(c);
|
||
|
|
if (rTextures[ 5][c+1] == null) rTextures[ 5][c+1] = getTopFacingInactive(c);
|
||
|
|
if (rTextures[ 6][c+1] == null) rTextures[ 6][c+1] = getBottomFacingActive(c);
|
||
|
|
if (rTextures[ 7][c+1] == null) rTextures[ 7][c+1] = getBottomFacingInactive(c);
|
||
|
|
if (rTextures[ 8][c+1] == null) rTextures[ 8][c+1] = getBottomFacingPipeActive(c);
|
||
|
|
if (rTextures[ 9][c+1] == null) rTextures[ 9][c+1] = getBottomFacingPipeInactive(c);
|
||
|
|
if (rTextures[10][c+1] == null) rTextures[10][c+1] = getTopFacingPipeActive(c);
|
||
|
|
if (rTextures[11][c+1] == null) rTextures[11][c+1] = getTopFacingPipeInactive(c);
|
||
|
|
if (rTextures[12][c+1] == null) rTextures[12][c+1] = getSideFacingPipeActive(c);
|
||
|
|
if (rTextures[13][c+1] == null) rTextures[13][c+1] = getSideFacingPipeInactive(c);
|
||
|
|
}
|
||
|
|
return rTextures;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
|
||
|
|
return mTextures[mMainFacing<2?aSide==aFacing?aActive?2:3:aSide==0?aActive?6:7:aSide==1?aActive?4:5:aActive?0:1:aSide==mMainFacing?aActive?2:3:(showPipeFacing()&&aSide==aFacing)?aSide==0?aActive?8:9:aSide==1?aActive?10:11:aActive?12:13:aSide==0?aActive?6:7:aSide==1?aActive?4:5:aActive?0:1][aColorIndex+1];
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override public boolean isSimpleMachine() {return false;}
|
||
|
|
@Override public boolean isOverclockerUpgradable() {return false;}
|
||
|
|
@Override public boolean isTransformerUpgradable() {return false;}
|
||
|
|
@Override public boolean isElectric() {return true;}
|
||
|
|
@Override public boolean isValidSlot(int aIndex) {return aIndex > 0 && super.isValidSlot(aIndex) && aIndex != OTHER_SLOT_COUNT+mInputSlotCount+mOutputItems.length;}
|
||
|
|
@Override public boolean isFacingValid(byte aFacing) {return mMainFacing > 1 || aFacing > 1;}
|
||
|
|
@Override public boolean isEnetInput() {return true;}
|
||
|
|
@Override public boolean isInputFacing(byte aSide) {return aSide!=mMainFacing;}
|
||
|
|
@Override public boolean isOutputFacing(byte aSide) {return false;}
|
||
|
|
@Override public boolean isTeleporterCompatible() {return false;}
|
||
|
|
@Override public boolean isLiquidInput(byte aSide) {return aSide!=mMainFacing && (mAllowInputFromOutputSide || aSide != getBaseMetaTileEntity().getFrontFacing());}
|
||
|
|
@Override public boolean isLiquidOutput(byte aSide) {return aSide!=mMainFacing;}
|
||
|
|
@Override public long getMinimumStoredEU() {return V[mTier]*16;}
|
||
|
|
@Override public long maxEUStore() {return V[mTier]*64;}
|
||
|
|
@Override public long maxEUInput() {return V[mTier];}
|
||
|
|
@Override public long maxSteamStore() {return maxEUStore();}
|
||
|
|
@Override public long maxAmperesIn() {return (mEUt * 2) / V[mTier] + 1;}
|
||
|
|
@Override public int getInputSlot() {return OTHER_SLOT_COUNT;}
|
||
|
|
@Override public int getOutputSlot() {return OTHER_SLOT_COUNT+mInputSlotCount;}
|
||
|
|
@Override public int getStackDisplaySlot() {return 2;}
|
||
|
|
@Override public int rechargerSlotStartIndex() {return 1;}
|
||
|
|
@Override public int dechargerSlotStartIndex() {return 1;}
|
||
|
|
@Override public int rechargerSlotCount() {return mCharge?1:0;}
|
||
|
|
@Override public int dechargerSlotCount() {return mDecharge?1:0;}
|
||
|
|
@Override public boolean isAccessAllowed(EntityPlayer aPlayer) {return true;}
|
||
|
|
@Override public int getProgresstime() {return mProgresstime;}
|
||
|
|
@Override public int maxProgresstime() {return mMaxProgresstime;}
|
||
|
|
@Override public int increaseProgress(int aProgress) {mProgresstime += aProgress; return mMaxProgresstime-mProgresstime;}
|
||
|
|
@Override public boolean isFluidInputAllowed(FluidStack aFluid) {return getFillableStack() != null || (getRecipeList() != null && getRecipeList().containsInput(aFluid));}
|
||
|
|
@Override public boolean isFluidChangingAllowed() {return true;}
|
||
|
|
@Override public boolean doesFillContainers() {return false;}
|
||
|
|
@Override public boolean doesEmptyContainers() {return false;}
|
||
|
|
@Override public boolean canTankBeFilled() {return true;}
|
||
|
|
@Override public boolean canTankBeEmptied() {return true;}
|
||
|
|
@Override public boolean displaysItemStack() {return true;}
|
||
|
|
@Override public boolean displaysStackSize() {return true;}
|
||
|
|
@Override public FluidStack getDisplayedFluid() {return displaysOutputFluid()?getDrainableStack():null;}
|
||
|
|
@Override public FluidStack getDrainableStack() {return mFluidOut;}
|
||
|
|
@Override public FluidStack setDrainableStack(FluidStack aFluid){mFluidOut = aFluid; return mFluidOut;}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
|
||
|
|
if (aBaseMetaTileEntity.isClientSide()) return true;
|
||
|
|
aBaseMetaTileEntity.openGUI(aPlayer);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
|
||
|
|
return new GT_Container_BasicMachine(aPlayerInventory, aBaseMetaTileEntity);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
|
||
|
|
return new GT_GUIContainer_BasicMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), mGUIName, GT_Utility.isStringValid(mNEIName) ? mNEIName : getRecipeList() != null ? getRecipeList().mUnlocalizedName : "");
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void initDefaultModes(NBTTagCompound aNBT) {
|
||
|
|
mMainFacing = -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void saveNBTData(NBTTagCompound aNBT) {
|
||
|
|
super.saveNBTData(aNBT);
|
||
|
|
aNBT.setBoolean("mFluidTransfer", mFluidTransfer);
|
||
|
|
aNBT.setBoolean("mItemTransfer", mItemTransfer);
|
||
|
|
aNBT.setBoolean("mHasBeenUpdated", mHasBeenUpdated);
|
||
|
|
aNBT.setBoolean("mAllowInputFromOutputSide", mAllowInputFromOutputSide);
|
||
|
|
aNBT.setInteger("mEUt", mEUt);
|
||
|
|
aNBT.setInteger("mMainFacing", mMainFacing);
|
||
|
|
aNBT.setInteger("mProgresstime", mProgresstime);
|
||
|
|
aNBT.setInteger("mMaxProgresstime", mMaxProgresstime);
|
||
|
|
if (mOutputFluid != null) aNBT.setTag("mOutputFluid", mOutputFluid.writeToNBT(new NBTTagCompound()));
|
||
|
|
if (mFluidOut != null) aNBT.setTag("mFluidOut", mFluidOut.writeToNBT(new NBTTagCompound()));
|
||
|
|
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) if (mOutputItems[i] != null) aNBT.setTag("mOutputItem"+i, mOutputItems[i].writeToNBT(new NBTTagCompound()));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void loadNBTData(NBTTagCompound aNBT) {
|
||
|
|
super.loadNBTData(aNBT);
|
||
|
|
mFluidTransfer = aNBT.getBoolean("mFluidTransfer");
|
||
|
|
mItemTransfer = aNBT.getBoolean("mItemTransfer");
|
||
|
|
mHasBeenUpdated = aNBT.getBoolean("mHasBeenUpdated");
|
||
|
|
mAllowInputFromOutputSide = aNBT.getBoolean("mAllowInputFromOutputSide");
|
||
|
|
mEUt = aNBT.getInteger("mEUt");
|
||
|
|
mMainFacing = aNBT.getInteger("mMainFacing");
|
||
|
|
mProgresstime = aNBT.getInteger("mProgresstime");
|
||
|
|
mMaxProgresstime = aNBT.getInteger("mMaxProgresstime");
|
||
|
|
mOutputFluid = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mOutputFluid"));
|
||
|
|
mFluidOut = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mFluidOut"));
|
||
|
|
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = GT_Utility.loadItem(aNBT, "mOutputItem"+i);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
|
||
|
|
super.onPostTick(aBaseMetaTileEntity, aTick);
|
||
|
|
|
||
|
|
if (aBaseMetaTileEntity.isServerSide()) {
|
||
|
|
mCharge = aBaseMetaTileEntity.getStoredEU() / 2 > aBaseMetaTileEntity.getEUCapacity() / 3;
|
||
|
|
mDecharge = aBaseMetaTileEntity.getStoredEU() < aBaseMetaTileEntity.getEUCapacity() / 3;
|
||
|
|
|
||
|
|
doDisplayThings();
|
||
|
|
|
||
|
|
boolean tSucceeded = false;
|
||
|
|
|
||
|
|
if (mMaxProgresstime > 0 && (mProgresstime >= 0 || aBaseMetaTileEntity.isAllowedToWork())) {
|
||
|
|
aBaseMetaTileEntity.setActive(true);
|
||
|
|
if (mProgresstime < 0 || drainEnergyForProcess(mEUt)) {
|
||
|
|
if (++mProgresstime>=mMaxProgresstime) {
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) for (int j = 0; j < mOutputItems.length; j++) if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot()+((j+i)%mOutputItems.length), mOutputItems[i])) break;
|
||
|
|
if (mOutputFluid != null) if (getDrainableStack() == null) setDrainableStack(mOutputFluid.copy()); else if (mOutputFluid.isFluidEqual(getDrainableStack())) getDrainableStack().amount += mOutputFluid.amount;
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = null;
|
||
|
|
mOutputFluid = null;
|
||
|
|
mEUt = 0;
|
||
|
|
mProgresstime = 0;
|
||
|
|
mMaxProgresstime = 0;
|
||
|
|
mStuttering = false;
|
||
|
|
tSucceeded = true;
|
||
|
|
endProcess();
|
||
|
|
}
|
||
|
|
if (mProgresstime > 5) mStuttering = false;
|
||
|
|
} else {
|
||
|
|
if (!mStuttering) {
|
||
|
|
stutterProcess();
|
||
|
|
if (canHaveInsufficientEnergy()) mProgresstime = -100;
|
||
|
|
mStuttering = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
aBaseMetaTileEntity.setActive(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
boolean tRemovedOutputFluid = false;
|
||
|
|
|
||
|
|
if (doesAutoOutputFluids() && getDrainableStack() != null && aBaseMetaTileEntity.getFrontFacing() != mMainFacing && (tSucceeded || aTick%20 == 0)) {
|
||
|
|
IFluidHandler tTank = aBaseMetaTileEntity.getITankContainerAtSide(aBaseMetaTileEntity.getFrontFacing());
|
||
|
|
if (tTank != null) {
|
||
|
|
FluidStack tDrained = drain(1000, false);
|
||
|
|
if (tDrained != null) {
|
||
|
|
int tFilledAmount = tTank.fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), tDrained, false);
|
||
|
|
if (tFilledAmount > 0) tTank.fill(ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()), drain(tFilledAmount, true), true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (getDrainableStack() == null) tRemovedOutputFluid = true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (doesAutoOutput() && !isOutputEmpty() && aBaseMetaTileEntity.getFrontFacing() != mMainFacing && (tSucceeded || mOutputBlocked%300 == 1 || aBaseMetaTileEntity.hasInventoryBeenModified() || aTick%600 == 0)) {
|
||
|
|
TileEntity tTileEntity2 = aBaseMetaTileEntity.getTileEntityAtSide(aBaseMetaTileEntity.getFrontFacing());
|
||
|
|
for (int i = 0, tCosts = 1; i < mOutputItems.length && tCosts > 0 && aBaseMetaTileEntity.isUniversalEnergyStored(128); i++) {
|
||
|
|
tCosts = GT_Utility.moveOneItemStack(aBaseMetaTileEntity, tTileEntity2, aBaseMetaTileEntity.getFrontFacing(), aBaseMetaTileEntity.getBackFacing(), null, false, (byte)64, (byte)1, (byte)64, (byte)1);
|
||
|
|
if (tCosts > 0) aBaseMetaTileEntity.decreaseStoredEnergyUnits(tCosts, true);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (mOutputBlocked != 0) if (isOutputEmpty()) mOutputBlocked = 0; else mOutputBlocked++;
|
||
|
|
|
||
|
|
if (allowToCheckRecipe()) {
|
||
|
|
if (mMaxProgresstime <= 0 && aBaseMetaTileEntity.isAllowedToWork() && (tRemovedOutputFluid || tSucceeded || aBaseMetaTileEntity.hasInventoryBeenModified() || aTick%600 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled()) && hasEnoughEnergyToCheckRecipe()) {
|
||
|
|
if (checkRecipe() == 2) {
|
||
|
|
if (mInventory[3] != null && mInventory[3].stackSize <= 0) mInventory[3] = null;
|
||
|
|
for (int i=getInputSlot() , j=i+mInputSlotCount ; i<j; i++) if (mInventory[i]!=null&&mInventory[i].stackSize<=0) mInventory[i]=null;
|
||
|
|
for (int i=0; i<mOutputItems.length; i++) {
|
||
|
|
mOutputItems[i] = GT_Utility.copy(mOutputItems[i]);
|
||
|
|
if (mOutputItems[i]!=null&&mOutputItems[i].stackSize>64) mOutputItems[i].stackSize=64;
|
||
|
|
mOutputItems[i] = GT_OreDictUnificator.get(true, mOutputItems[i]);
|
||
|
|
}
|
||
|
|
if (mFluid != null && mFluid.amount <= 0) mFluid = null;
|
||
|
|
mMaxProgresstime = Math.max(1, mMaxProgresstime);
|
||
|
|
if (GT_Utility.isDebugItem(mInventory[dechargerSlotStartIndex()])) {
|
||
|
|
mEUt = mMaxProgresstime = 1;
|
||
|
|
}
|
||
|
|
startProcess();
|
||
|
|
} else {
|
||
|
|
mMaxProgresstime = 0;
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) mOutputItems[i] = null;
|
||
|
|
mOutputFluid = null;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (!mStuttering) {
|
||
|
|
stutterProcess();
|
||
|
|
mStuttering = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void doDisplayThings() {
|
||
|
|
if (mMainFacing < 2 && getBaseMetaTileEntity().getFrontFacing() > 1) {
|
||
|
|
mMainFacing = getBaseMetaTileEntity().getFrontFacing();
|
||
|
|
}
|
||
|
|
if (mMainFacing >= 2 && !mHasBeenUpdated) {
|
||
|
|
mHasBeenUpdated = true;
|
||
|
|
getBaseMetaTileEntity().setFrontFacing(getBaseMetaTileEntity().getBackFacing());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (displaysInputFluid()) {
|
||
|
|
int tDisplayStackSlot = OTHER_SLOT_COUNT+mInputSlotCount+mOutputItems.length;
|
||
|
|
if (getFillableStack() == null) {
|
||
|
|
if (ItemList.Display_Fluid.isStackEqual(mInventory[tDisplayStackSlot], true, true)) mInventory[tDisplayStackSlot] = null;
|
||
|
|
} else {
|
||
|
|
mInventory[tDisplayStackSlot] = GT_Utility.getFluidDisplayStack(getFillableStack(), displaysStackSize());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean hasEnoughEnergyToCheckRecipe() {
|
||
|
|
return getBaseMetaTileEntity().isUniversalEnergyStored(getMinimumStoredEU() / 2);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean drainEnergyForProcess(long aEUt) {
|
||
|
|
return getBaseMetaTileEntity().decreaseStoredEnergyUnits(aEUt, false);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void calculateOverclockedNess(GT_Recipe aRecipe) {
|
||
|
|
calculateOverclockedNess(aRecipe.mEUt, aRecipe.mDuration);
|
||
|
|
}
|
||
|
|
|
||
|
|
protected void calculateOverclockedNess(int aEUt, int aDuration) {
|
||
|
|
if (aEUt <= 16) {
|
||
|
|
mEUt = aEUt * (1 << (mTier-1)) * (1 << (mTier-1));
|
||
|
|
mMaxProgresstime = aDuration / (1 << (mTier-1));
|
||
|
|
} else {
|
||
|
|
mEUt = aEUt;
|
||
|
|
mMaxProgresstime = aDuration;
|
||
|
|
while (mEUt <= V[mTier-1] * mAmperage) {
|
||
|
|
mEUt *= 4;
|
||
|
|
mMaxProgresstime /= 2;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
protected ItemStack getSpecialSlot() {
|
||
|
|
return mInventory[3];
|
||
|
|
}
|
||
|
|
|
||
|
|
protected ItemStack getOutputAt(int aIndex) {
|
||
|
|
return mInventory[getOutputSlot()+aIndex];
|
||
|
|
}
|
||
|
|
|
||
|
|
protected ItemStack[] getAllOutputs() {
|
||
|
|
ItemStack[] rOutputs = new ItemStack[mOutputItems.length];
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) rOutputs[i] = getOutputAt(i);
|
||
|
|
return rOutputs;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean canOutput(GT_Recipe aRecipe) {
|
||
|
|
return aRecipe != null && (aRecipe.mNeedsEmptyOutput ? isOutputEmpty() && getDrainableStack() == null : canOutput(aRecipe.getFluidOutput(0)) && canOutput(aRecipe.mOutputs));
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean canOutput(ItemStack... aOutputs) {
|
||
|
|
if (aOutputs == null) return true;
|
||
|
|
ItemStack[] tOutputSlots = getAllOutputs();
|
||
|
|
for (int i = 0; i < tOutputSlots.length && i < aOutputs.length; i++) if (tOutputSlots[i] != null && aOutputs[i] != null && (!GT_Utility.areStacksEqual(tOutputSlots[i], aOutputs[i], false) || tOutputSlots[i].stackSize + aOutputs[i].stackSize > tOutputSlots[i].getMaxStackSize())) {
|
||
|
|
mOutputBlocked++;
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean canOutput(FluidStack aOutput) {
|
||
|
|
return getDrainableStack() == null || aOutput == null || (getDrainableStack().isFluidEqual(aOutput) && (getDrainableStack().amount <= 0 || getDrainableStack().amount + aOutput.amount <= getCapacity()));
|
||
|
|
}
|
||
|
|
|
||
|
|
protected ItemStack getInputAt(int aIndex) {
|
||
|
|
return mInventory[getInputSlot()+aIndex];
|
||
|
|
}
|
||
|
|
|
||
|
|
protected ItemStack[] getAllInputs() {
|
||
|
|
ItemStack[] rInputs = new ItemStack[mInputSlotCount];
|
||
|
|
for (int i = 0; i < mInputSlotCount; i++) rInputs[i] = getInputAt(i);
|
||
|
|
return rInputs;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean isOutputEmpty() {
|
||
|
|
boolean rIsEmpty = true;
|
||
|
|
for (ItemStack tOutputSlotContent : getAllOutputs()) if (tOutputSlotContent != null) rIsEmpty = false;
|
||
|
|
return rIsEmpty;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean displaysInputFluid() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
protected boolean displaysOutputFluid() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onValueUpdate(byte aValue) {
|
||
|
|
mMainFacing = aValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public byte getUpdateData() {
|
||
|
|
return (byte)mMainFacing;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void doSound(byte aIndex, double aX, double aY, double aZ) {
|
||
|
|
super.doSound(aIndex, aX, aY, aZ);
|
||
|
|
if (aIndex == 8) GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(210), 100, 1.0F, aX, aY, aZ);
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean doesAutoOutput() {
|
||
|
|
return mItemTransfer;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean doesAutoOutputFluids() {
|
||
|
|
return mFluidTransfer;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean allowToCheckRecipe() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean showPipeFacing() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Called whenever the Machine successfully started a Process, useful for Sound Effects */
|
||
|
|
public void startProcess() {
|
||
|
|
//
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Called whenever the Machine successfully finished a Process, useful for Sound Effects */
|
||
|
|
public void endProcess() {
|
||
|
|
//
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Called whenever the Machine aborted a Process, useful for Sound Effects */
|
||
|
|
public void abortProcess() {
|
||
|
|
//
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Called whenever the Machine aborted a Process but still works on it, useful for Sound Effects */
|
||
|
|
public void stutterProcess() {
|
||
|
|
if (useStandardStutterSound()) sendSound((byte)8);
|
||
|
|
}
|
||
|
|
|
||
|
|
/** If this Machine can have the Insufficient Energy Line Problem */
|
||
|
|
public boolean canHaveInsufficientEnergy() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean useStandardStutterSound() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public String[] getInfoData() {
|
||
|
|
return new String[] {"Progress:", (mProgresstime/20)+" secs", (mMaxProgresstime/20)+" secs"};
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean isGivingInformation() {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
|
||
|
|
if (aSide == getBaseMetaTileEntity().getFrontFacing() || aSide == mMainFacing) {
|
||
|
|
mAllowInputFromOutputSide = !mAllowInputFromOutputSide;
|
||
|
|
GT_Utility.sendChatToPlayer(aPlayer, mAllowInputFromOutputSide?"Input from Output Side allowed":"Input from Output Side forbidden");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCoverID) {
|
||
|
|
return (aSide!=mMainFacing||GregTech_API.getCoverBehavior(aCoverID.toStack()).isGUIClickable(aSide, GT_Utility.stackToInt(aCoverID.toStack()), 0, getBaseMetaTileEntity()));
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
|
||
|
|
return aSide!=mMainFacing&&aIndex>=getOutputSlot()&&aIndex<getOutputSlot()+mOutputItems.length;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
|
||
|
|
if (aSide==mMainFacing||aIndex<getInputSlot()||aIndex>=getInputSlot()+mInputSlotCount||(!mAllowInputFromOutputSide&&aSide==aBaseMetaTileEntity.getFrontFacing())) return false;
|
||
|
|
for (int i=getInputSlot(), j=i+mInputSlotCount; i<j; i++) if (GT_Utility.areStacksEqual(GT_OreDictUnificator.get(aStack), mInventory[i])) return i==aIndex;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** @return the Recipe List which is used for this Machine, this is a useful Default Handler */
|
||
|
|
public GT_Recipe_Map getRecipeList() {
|
||
|
|
return null;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** return values for checkRecipe() */
|
||
|
|
protected static final int
|
||
|
|
DID_NOT_FIND_RECIPE = 0,
|
||
|
|
FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS = 1,
|
||
|
|
FOUND_AND_SUCCESSFULLY_USED_RECIPE = 2;
|
||
|
|
|
||
|
|
/** Contains the Recipe which has been previously used, or null if there was no previous Recipe, which could have been buffered */
|
||
|
|
protected GT_Recipe mLastRecipe = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Override this to check the Recipes yourself, super calls to this could be useful if you just want to add a special case
|
||
|
|
*
|
||
|
|
* I thought about Enum too, but Enum doesn't add support for people adding other return Systems.
|
||
|
|
*
|
||
|
|
* Funny how Eclipse marks the word Enum as not correctly spelled.
|
||
|
|
*
|
||
|
|
* @return see constants above
|
||
|
|
*/
|
||
|
|
public int checkRecipe() {
|
||
|
|
GT_Recipe_Map tMap = getRecipeList();
|
||
|
|
if (tMap == null) return DID_NOT_FIND_RECIPE;
|
||
|
|
GT_Recipe tRecipe = tMap.findRecipe(getBaseMetaTileEntity(), mLastRecipe, false, V[mTier], new FluidStack[] {getFillableStack()}, getSpecialSlot(), getAllInputs());
|
||
|
|
if (tRecipe == null) return DID_NOT_FIND_RECIPE;
|
||
|
|
if (tRecipe.mCanBeBuffered) mLastRecipe = tRecipe;
|
||
|
|
if (!canOutput(tRecipe)) {mOutputBlocked++; return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;}
|
||
|
|
if (!tRecipe.isRecipeInputEqual(true, new FluidStack[] {getFillableStack()}, getAllInputs())) return FOUND_RECIPE_BUT_DID_NOT_MEET_REQUIREMENTS;
|
||
|
|
|
||
|
|
for (int i = 0; i < mOutputItems.length; i++) if (getBaseMetaTileEntity().getRandomNumber(10000) < tRecipe.getOutputChance(i)) mOutputItems[i] = tRecipe.getOutput(i);
|
||
|
|
mOutputFluid = tRecipe.getFluidOutput(0);
|
||
|
|
calculateOverclockedNess(tRecipe);
|
||
|
|
return FOUND_AND_SUCCESSFULLY_USED_RECIPE;
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getSideFacingActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getSideFacingInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getFrontFacingActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getFrontFacingInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getTopFacingActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getTopFacingInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getBottomFacingActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getBottomFacingInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1]};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getBottomFacingPipeActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getBottomFacingPipeInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getTopFacingPipeActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getTopFacingPipeInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getSideFacingPipeActive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
|
||
|
|
public ITexture[] getSideFacingPipeInactive(byte aColor) {
|
||
|
|
return new ITexture[] {Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor+1], new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE_OUT)};
|
||
|
|
}
|
||
|
|
}
|