GT5-Unofficial/main/java/gregtech/api/metatileentity/implementations/GT_MetaTileEntity_BasicMachine.java
2015-07-25 18:34:52 +02:00

602 lines
No EOL
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[] {
mNEIName,
"Progress:", (mProgresstime/20)+" secs",
(mMaxProgresstime/20)+" secs",
"Stored Energy:",
getBaseMetaTileEntity().getStoredEU()+"EU",
getBaseMetaTileEntity().getEUCapacity()+"EU"};
}
@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)};
}
}