Add the Cleanroom

src/main/java/gregtech/api/block/machines/BlockMachine.java

@@ -4,6 +4,7 @@
 import codechicken.lib.raytracer.IndexedCuboid6;
 import codechicken.lib.raytracer.RayTracer;
 import codechicken.lib.vec.Cuboid6;
+import gregtech.api.GTValues;
 import gregtech.api.GregTechAPI;
 import gregtech.api.block.BlockCustomParticle;
 import gregtech.api.block.UnlistedIntegerProperty;
@@ -55,6 +56,7 @@
 import net.minecraftforge.common.property.ExtendedBlockState;
 import net.minecraftforge.common.property.IExtendedBlockState;
 import net.minecraftforge.common.property.IUnlistedProperty;
+import net.minecraftforge.fml.common.Loader;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 import org.apache.commons.lang3.tuple.Pair;
@@ -251,6 +253,11 @@ public void onBlockPlacedBy(World worldIn, @Nonnull BlockPos pos, @Nonnull IBloc
             } else {
                 metaTileEntity.setFrontFacing(placer.getHorizontalFacing().getOpposite());
             }
+            if (Loader.isModLoaded(GTValues.MODID_APPENG)) {
+                if (metaTileEntity.getProxy() != null) {
+                    metaTileEntity.getProxy().setOwner((EntityPlayer) placer);
+                }
+            }
         }
     }
 

src/main/java/gregtech/api/capability/GregtechDataCodes.java

@@ -67,6 +67,7 @@ public class GregtechDataCodes {
     public static final int IS_ROTOR_LOOPING = 200;
     public static final int FRONT_FACE_FREE = 201;
     public static final int UPDATE_ROTOR_COLOR = 201;
+    public static final int UPDATE_STRUCTURE_SIZE = 202;
     public static final int STRUCTURE_FORMED = 400;
     public static final int IS_TAPED = 550;
     public static final int STORE_MAINTENANCE = 551;

src/main/java/gregtech/api/capability/impl/AbstractRecipeLogic.java

@@ -7,10 +7,11 @@
 import gregtech.api.capability.IWorkable;
 import gregtech.api.metatileentity.MTETrait;
 import gregtech.api.metatileentity.MetaTileEntity;
-import gregtech.api.metatileentity.multiblock.ParallelLogicType;
+import gregtech.api.metatileentity.multiblock.*;
 import gregtech.api.recipes.Recipe;
 import gregtech.api.recipes.RecipeMap;
 import gregtech.api.recipes.logic.IParallelableRecipeLogic;
+import gregtech.api.recipes.recipeproperties.CleanroomProperty;
 import gregtech.api.recipes.recipeproperties.RecipePropertyStorage;
 import gregtech.api.util.GTTransferUtils;
 import gregtech.api.util.GTUtility;
@@ -244,7 +245,20 @@ protected void updateRecipeProgress() {
      * @return {@code true} if the recipe can progress, else false
      */
     protected boolean canProgressRecipe() {
-        return true;
+        if (previousRecipe == null)
+            return true;
+
+        CleanroomType requiredType = null;
+        if (previousRecipe.hasProperty(CleanroomProperty.getInstance())) {
+            requiredType = previousRecipe.getProperty(CleanroomProperty.getInstance(), null);
+        }
+
+        if (requiredType == null) return true;
+
+        ICleanroomProvider cleanroomProvider = ((ICleanroomReceiver) getMetaTileEntity()).getCleanroom();
+        if (cleanroomProvider == null) return false;
+
+        return cleanroomProvider.isClean() && cleanroomProvider.getTypes().contains(requiredType);
     }
 
     /**
@@ -294,8 +308,20 @@ protected boolean checkPreviousRecipe() {
      * @param recipe the recipe to check
      * @return true if the recipe is allowed to be used, else false
      */
-    protected boolean checkRecipe(Recipe recipe) {
-        return true;
+    protected boolean checkRecipe(@Nonnull Recipe recipe) {
+        CleanroomType requiredType = null;
+        if (recipe.hasProperty(CleanroomProperty.getInstance())) {
+            requiredType = recipe.getProperty(CleanroomProperty.getInstance(), null);
+        }
+
+        if (requiredType == null) return true;
+
+        if (getMetaTileEntity() instanceof MultiblockWithDisplayBase && ConfigHolder.machines.cleanMultiblocks) return true;
+
+        ICleanroomProvider cleanroomProvider = ((ICleanroomReceiver) getMetaTileEntity()).getCleanroom();
+        if (cleanroomProvider == null) return false;
+
+        return cleanroomProvider.isClean() && cleanroomProvider.getTypes().contains(requiredType);
     }
 
     /**

src/main/java/gregtech/api/capability/impl/CleanroomLogic.java

@@ -0,0 +1,240 @@
+package gregtech.api.capability.impl;
+
+import gregtech.api.capability.GregtechDataCodes;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.metatileentity.multiblock.ICleanroomProvider;
+import gregtech.api.metatileentity.multiblock.IMaintenance;
+import gregtech.common.ConfigHolder;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.world.World;
+
+import javax.annotation.Nonnull;
+
+public class CleanroomLogic {
+
+    public static final int BASE_CLEAN_AMOUNT = 5;
+
+    private int maxProgress = 0;
+    private int progressTime = 0;
+
+    private final int minEnergyTier;
+
+    private final MetaTileEntity metaTileEntity;
+    private final boolean hasMaintenance;
+
+    private boolean isActive;
+    private boolean isWorkingEnabled = true;
+    private boolean wasActiveAndNeedsUpdate;
+
+    private boolean hasNotEnoughEnergy;
+
+    public CleanroomLogic(MetaTileEntity metaTileEntity, int minEnergyTier) {
+        this.metaTileEntity = metaTileEntity;
+        this.minEnergyTier = minEnergyTier;
+        this.hasMaintenance = ConfigHolder.machines.enableMaintenance && ((IMaintenance) metaTileEntity).hasMaintenanceMechanics();
+    }
+
+    /**
+     * Performs the actual cleaning
+     * Call this method every tick in update
+     */
+    public void updateLogic() {
+        // cleanrooms which cannot work do nothing
+        if (!this.isWorkingEnabled) return;
+
+        // all maintenance problems not fixed means the machine does not run
+        if (hasMaintenance && ((IMaintenance) metaTileEntity).getNumMaintenanceProblems() > 5) return;
+
+        // drain the energy
+        if (consumeEnergy(true)) {
+            consumeEnergy(false);
+        } else {
+            if (progressTime >= 2) {
+                if (ConfigHolder.machines.recipeProgressLowEnergy) this.progressTime = 1;
+                else this.progressTime = Math.max(1, progressTime - 2);
+            }
+            hasNotEnoughEnergy = true;
+
+            // the cleanroom does not have enough energy, so it looses cleanliness
+            if (metaTileEntity.getOffsetTimer() % maxProgress == 0) {
+                adjustCleanAmount(true);
+            }
+            return;
+        }
+
+        if (!this.isActive) setActive(true);
+
+        // increase progress
+        progressTime++;
+        if (progressTime % getMaxProgress() != 0) return;
+        progressTime = 0;
+
+        adjustCleanAmount(false);
+    }
+
+    protected void adjustCleanAmount(boolean shouldRemove) {
+        int amountToClean = BASE_CLEAN_AMOUNT * (getTierDifference() + 1);
+        if (shouldRemove) amountToClean *= -1;
+
+        // each maintenance problem lowers gain by 1
+        if (hasMaintenance) amountToClean -= ((IMaintenance) metaTileEntity).getNumMaintenanceProblems();
+        ((ICleanroomProvider) metaTileEntity).adjustCleanAmount(amountToClean);
+    }
+
+    protected boolean consumeEnergy(boolean simulate) {
+        return ((ICleanroomProvider) metaTileEntity).drainEnergy(simulate);
+    }
+
+    public void invalidate() {
+        this.progressTime = 0;
+        this.maxProgress = 0;
+        setActive(false);
+    }
+
+    /**
+     * @return true if the cleanroom is active
+     */
+    public boolean isActive() {
+        return this.isActive && isWorkingEnabled();
+    }
+
+    /**
+     * @param active the new state of the cleanroom's activity: true to change to active, else false
+     */
+    public void setActive(boolean active) {
+        if (this.isActive != active) {
+            this.isActive = active;
+            this.metaTileEntity.markDirty();
+            World world = this.metaTileEntity.getWorld();
+            if (world != null && !world.isRemote) {
+                this.metaTileEntity.writeCustomData(GregtechDataCodes.WORKABLE_ACTIVE, buf -> buf.writeBoolean(active));
+            }
+        }
+    }
+
+    /**
+     * @param workingEnabled the new state of the cleanroom's ability to work: true to change to enabled, else false
+     */
+    public void setWorkingEnabled(boolean workingEnabled) {
+        this.isWorkingEnabled = workingEnabled;
+        this.metaTileEntity.markDirty();
+        World world = this.metaTileEntity.getWorld();
+        if (world != null && !world.isRemote) {
+            this.metaTileEntity.writeCustomData(GregtechDataCodes.WORKING_ENABLED, buf -> buf.writeBoolean(workingEnabled));
+        }
+    }
+
+    /**
+     * @return whether working is enabled for the logic
+     */
+    public boolean isWorkingEnabled() {
+        return isWorkingEnabled;
+    }
+
+    /**
+     * @return whether the cleanroom is currently working
+     */
+    public boolean isWorking() {
+        return isActive && !hasNotEnoughEnergy && isWorkingEnabled;
+    }
+
+    /**
+     * @return the current progress towards completing one cycle of the cleanroom
+     */
+    public int getProgressTime() {
+        return this.progressTime;
+    }
+
+    public void setMaxProgress(int maxProgress) {
+        this.maxProgress = maxProgress;
+    }
+
+    public int getMaxProgress() {
+        return this.maxProgress;
+    }
+
+    public int getProgressPercent() {
+        return (int) ((1.0F * getProgressTime() / getMaxProgress()) * 100);
+    }
+
+    protected int getTierDifference() {
+        return ((ICleanroomProvider) metaTileEntity).getEnergyTier() - minEnergyTier;
+    }
+
+    /**
+     * writes all needed values to NBT
+     * This MUST be called and returned in the MetaTileEntity's {@link MetaTileEntity#writeToNBT(NBTTagCompound)} method
+     */
+    public NBTTagCompound writeToNBT(@Nonnull NBTTagCompound data) {
+        data.setBoolean("isActive", this.isActive);
+        data.setBoolean("isWorkingEnabled", this.isWorkingEnabled);
+        data.setBoolean("wasActiveAndNeedsUpdate", this.wasActiveAndNeedsUpdate);
+        data.setInteger("progressTime", progressTime);
+        data.setInteger("maxProgress", maxProgress);
+        return data;
+    }
+
+    /**
+     * reads all needed values from NBT
+     * This MUST be called and returned in the MetaTileEntity's {@link MetaTileEntity#readFromNBT(NBTTagCompound)} method
+     */
+    public void readFromNBT(@Nonnull NBTTagCompound data) {
+        this.isActive = data.getBoolean("isActive");
+        this.isWorkingEnabled = data.getBoolean("isWorkingEnabled");
+        this.wasActiveAndNeedsUpdate = data.getBoolean("wasActiveAndNeedsUpdate");
+        this.progressTime = data.getInteger("progressTime");
+        this.maxProgress = data.getInteger("maxProgress");
+    }
+
+    /**
+     * writes all needed values to InitialSyncData
+     * This MUST be called and returned in the MetaTileEntity's {@link MetaTileEntity#writeInitialSyncData(PacketBuffer)} method
+     */
+    public void writeInitialSyncData(@Nonnull PacketBuffer buf) {
+        buf.writeBoolean(this.isActive);
+        buf.writeBoolean(this.isWorkingEnabled);
+        buf.writeBoolean(this.wasActiveAndNeedsUpdate);
+        buf.writeInt(this.progressTime);
+        buf.writeInt(this.maxProgress);
+    }
+
+    /**
+     * reads all needed values from InitialSyncData
+     * This MUST be called and returned in the MetaTileEntity's {@link MetaTileEntity#receiveInitialSyncData(PacketBuffer)} method
+     */
+    public void receiveInitialSyncData(@Nonnull PacketBuffer buf) {
+        setActive(buf.readBoolean());
+        setWorkingEnabled(buf.readBoolean());
+        setWasActiveAndNeedsUpdate(buf.readBoolean());
+        this.progressTime = buf.readInt();
+        this.maxProgress = buf.readInt();
+    }
+
+    /**
+     * reads all needed values from CustomData
+     * This MUST be called and returned in the MetaTileEntity's {@link MetaTileEntity#receiveCustomData(int, PacketBuffer)} method
+     */
+    public void receiveCustomData(int dataId, PacketBuffer buf) {
+        if (dataId == GregtechDataCodes.IS_WORKING) {
+            setActive(buf.readBoolean());
+            metaTileEntity.scheduleRenderUpdate();
+        }
+    }
+
+    /**
+     * @return whether the cleanroom was active and needs an update
+     */
+    public boolean wasActiveAndNeedsUpdate() {
+        return this.wasActiveAndNeedsUpdate;
+    }
+
+    /**
+     * set whether the cleanroom was active and needs an update
+     *
+     * @param wasActiveAndNeedsUpdate the state to set
+     */
+    public void setWasActiveAndNeedsUpdate(boolean wasActiveAndNeedsUpdate) {
+        this.wasActiveAndNeedsUpdate = wasActiveAndNeedsUpdate;
+    }
+}

src/main/java/gregtech/api/capability/impl/MultiblockRecipeLogic.java

@@ -11,6 +11,7 @@
 import net.minecraft.util.Tuple;
 import net.minecraftforge.items.IItemHandlerModifiable;
 
+import javax.annotation.Nonnull;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
@@ -42,7 +43,7 @@ public void updateWorkable() {
 
     @Override
     protected boolean canProgressRecipe() {
-        return !((IMultiblockController) metaTileEntity).isStructureObstructed();
+        return super.canProgressRecipe() && !((IMultiblockController) metaTileEntity).isStructureObstructed();
     }
 
     /**
@@ -295,7 +296,7 @@ protected Tuple<Integer, Double> getMaintenanceValues() {
     }
 
     @Override
-    protected boolean checkRecipe(Recipe recipe) {
+    protected boolean checkRecipe(@Nonnull Recipe recipe) {
         RecipeMapMultiblockController controller = (RecipeMapMultiblockController) metaTileEntity;
         if (controller.checkRecipe(recipe, false)) {
             controller.checkRecipe(recipe, true);

src/main/java/gregtech/api/capability/impl/RecipeLogicEnergy.java

@@ -45,5 +45,4 @@ protected long getMaxVoltage() {
         return Math.max(energyContainer.get().getInputVoltage(),
                 energyContainer.get().getOutputVoltage());
     }
-
 }

src/main/java/gregtech/api/capability/impl/RecipeLogicSteam.java

@@ -180,7 +180,7 @@ public void update() {
     }
 
     @Override
-    protected boolean checkRecipe(Recipe recipe) {
+    protected boolean checkRecipe(@Nonnull Recipe recipe) {
         return super.checkRecipe(recipe) && !this.needsVenting;
     }