Merging in old CEu nuclear fission PR

dependencies.gradle

@@ -67,6 +67,7 @@ dependencies {
     implementation rfg.deobf("curse.maven:athenaeum-284350:4633750")
     implementation rfg.deobf("curse.maven:dropt-284973:5405050")
 
+    compileOnly rfg.deobf("curse.maven:opencomputers-223008:5274236")
     compileOnly rfg.deobf("curse.maven:yungs-better-mineshafts-forge-389665:3247154")
 
     api("CraftTweaker2:CraftTweaker2-MC1120-Main:1.12-4.1.20.700")

src/main/java/supersymmetry/api/capability/ICoolantHandler.java

@@ -0,0 +1,24 @@
+package supersymmetry.api.capability;
+
+
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.fluids.Fluid;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import supersymmetry.api.capability.impl.LockableFluidTank;
+import supersymmetry.api.nuclear.fission.ICoolantStats;
+
+public interface ICoolantHandler extends ILockableHandler<Fluid> {
+
+    @Nullable
+    ICoolantStats getCoolant();
+
+    void setCoolant(@Nullable ICoolantStats prop);
+
+    @NotNull
+    LockableFluidTank getFluidTank();
+
+    @NotNull
+    EnumFacing getFrontFacing();
+}

src/main/java/supersymmetry/api/capability/IFuelRodHandler.java

@@ -0,0 +1,28 @@
+package supersymmetry.api.capability;
+
+
+import net.minecraft.item.ItemStack;
+import supersymmetry.api.items.itemhandlers.LockableItemStackHandler;
+import supersymmetry.api.nuclear.fission.IFissionFuelStats;
+import supersymmetry.api.nuclear.fission.components.FuelRod;
+
+public interface IFuelRodHandler extends ILockableHandler<ItemStack> {
+
+    IFissionFuelStats getFuel();
+
+    void setFuel(IFissionFuelStats prop);
+
+    IFissionFuelStats getPartialFuel();
+
+    /**
+     * Set the fuel type that's currently being processed by this specific handler.
+     * 
+     * @param prop The new fuel type.
+     * @return true if the partial fuel changed.
+     */
+    boolean setPartialFuel(IFissionFuelStats prop);
+
+    void setInternalFuelRod(FuelRod rod);
+
+    LockableItemStackHandler getStackHandler();
+}

src/main/java/supersymmetry/api/capability/ILockableHandler.java

@@ -0,0 +1,13 @@
+package supersymmetry.api.capability;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface ILockableHandler<T> {
+
+    void setLock(boolean isLocked);
+
+    boolean isLocked();
+
+    @Nullable
+    T getLockedObject();
+}

src/main/java/supersymmetry/api/capability/impl/LockableFluidTank.java

@@ -0,0 +1,81 @@
+package supersymmetry.api.capability.impl;
+
+import gregtech.api.capability.impl.NotifiableFluidTank;
+import gregtech.api.metatileentity.MetaTileEntity;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidRegistry;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTank;
+import supersymmetry.api.capability.ILockableHandler;
+
+public class LockableFluidTank extends NotifiableFluidTank implements ILockableHandler<Fluid> {
+
+    private boolean locked;
+    private Fluid lockedFluid;
+
+    public LockableFluidTank(int capacity, MetaTileEntity entityToNotify, boolean isExport) {
+        super(capacity, entityToNotify, isExport);
+    }
+
+    @Override
+    public Fluid getLockedObject() {
+        return lockedFluid;
+    }
+
+    @Override
+    public void setLock(boolean isLocked) {
+        locked = isLocked;
+    }
+
+    @Override
+    public int fill(FluidStack resource, boolean doFill) {
+        int filled = super.fill(resource, doFill);
+        if (doFill && this.fluid != null && this.fluid.amount != 0) {
+            this.lockedFluid = this.fluid.getFluid();
+        }
+        return filled;
+    }
+
+    @Override
+    public void setFluid(FluidStack fluid) {
+        super.setFluid(fluid);
+        if (this.fluid != null && this.fluid.amount != 0) {
+            this.lockedFluid = this.fluid.getFluid();
+        }
+    }
+
+    @Override
+    public boolean isLocked() {
+        return locked;
+    }
+
+    @Override
+    public boolean canFillFluidType(FluidStack fluid) {
+        if (locked && fluid.getFluid() != lockedFluid) {
+            return false;
+        }
+        return super.canFillFluidType(fluid);
+    }
+
+    @Override
+    public FluidTank readFromNBT(NBTTagCompound nbt) {
+        super.readFromNBT(nbt);
+        if (nbt.hasKey("LockedFluid")) {
+            this.lockedFluid = FluidRegistry.getFluid(nbt.getString("LockedFluid"));
+        } else if (this.fluid != null && this.fluid.amount != 0) {
+            this.lockedFluid = this.fluid.getFluid();
+        }
+        return this;
+    }
+
+    @Override
+    public NBTTagCompound writeToNBT(NBTTagCompound nbt) {
+        super.writeToNBT(nbt);
+        if (lockedFluid != null) {
+            nbt.setString("LockedFluid", lockedFluid.getName());
+        }
+        return nbt;
+    }
+}

src/main/java/supersymmetry/api/cover/ICustomEnergyCover.java

@@ -0,0 +1,18 @@
+package supersymmetry.api.cover;
+
+/**
+ * Simple interface specifying that an attached energy detector(advanced or not) cover reads custom EU values from the
+ * MTE
+ */
+public interface ICustomEnergyCover {
+
+    /**
+     * @return The total EU capacity
+     */
+    long getCoverCapacity();
+
+    /**
+     * @return The stored EU capacity
+     */
+    long getCoverStored();
+}

src/main/java/supersymmetry/api/gui/SusyGuiTextures.java

@@ -28,4 +28,13 @@ public class SusyGuiTextures {
     public static final TextureArea BUTTON_INT_CIRCUIT_PLUS_PRIMITIVE = TextureArea.fullImage("textures/gui/widget/button_circuit_plus_primitive.png");
     public static final TextureArea BUTTON_INT_CIRCUIT_MINUS_PRIMITIVE = TextureArea.fullImage("textures/gui/widget/button_circuit_minus_primitive.png");
     public static final TextureArea FLUID_SLOT_PRIMITIVE = TextureArea.fullImage("textures/gui/base/fluid_slot_primitive.png");
+
+    // Nuclear GuiTextures
+    public static final TextureArea BUTTON_CONTROL_ROD_HELPER = TextureArea.fullImage("textures/gui/widget/button_control_rod_helper.png");
+    public static final TextureArea DARK_SLIDER_BACKGROUND = TextureArea.fullImage("textures/gui/widget/dark_slider_background.png");
+    public static final TextureArea DARK_SLIDER_BACKGROUND_VERTICAL = TextureArea.fullImage("textures/gui/widget/dark_slider_background_vertical.png");
+    public static final TextureArea DARK_SLIDER_ICON = TextureArea.fullImage("textures/gui/widget/dark_slider.png");
+    public static final TextureArea PROGRESS_BAR_FISSION_HEAT = TextureArea.fullImage("textures/gui/progress_bar/progress_bar_fission_heat.png");
+    public static final TextureArea PROGRESS_BAR_FISSION_PRESSURE = TextureArea.fullImage("textures/gui/progress_bar/progress_bar_fission_pressure.png");
+    public static final TextureArea PROGRESS_BAR_FISSION_ENERGY = TextureArea.fullImage("textures/gui/progress_bar/progress_bar_fission_energy.png");
 }

src/main/java/supersymmetry/api/gui/widgets/UpdatedSliderWidget.java

@@ -0,0 +1,42 @@
+package supersymmetry.api.gui.widgets;
+
+import gregtech.api.gui.IRenderContext;
+import gregtech.api.gui.widgets.SliderWidget;
+import gregtech.api.util.Position;
+import gregtech.api.util.Size;
+import gregtech.api.util.function.FloatConsumer;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import supersymmetry.api.util.function.FloatSupplier;
+import supersymmetry.mixins.gregtech.SliderWidgetAccessor;
+
+public class UpdatedSliderWidget extends SliderWidget {
+
+    private FloatSupplier detector;
+    private final SliderWidgetAccessor self;
+
+    public UpdatedSliderWidget(String name, int xPosition, int yPosition, int width, int height, float min, float max,
+                               float currentValue, FloatConsumer responder, FloatSupplier detector) {
+        super(name, xPosition, yPosition, width, height, min, max, currentValue, responder);
+        this.detector = detector;
+        this.self = (SliderWidgetAccessor) this;
+    }
+
+    @Override
+    public void drawInBackground(int mouseX, int mouseY, float partialTicks, IRenderContext context) {
+        Position pos = getPosition();
+        Size size = getSize();
+        if (self.getBackgroundArea() != null) {
+            self.getBackgroundArea().draw(pos.x, pos.y, size.width, size.height);
+        }
+        self.setSliderPosition((detector.get() - self.getMin()) / (self.getMax() - self.getMin()));
+        self.setDisplayString2(getDisplayString());
+
+        self.getSliderIcon().draw(pos.x + (int) (self.getSliderPosition() * (float) (size.width - 8)), pos.y, self.getSliderWidth(),
+                size.height);
+        FontRenderer fontRenderer = Minecraft.getMinecraft().fontRenderer;
+        fontRenderer.drawString(self.getDisplayString2(),
+                pos.x + size.width / 2 - fontRenderer.getStringWidth(self.getDisplayString2()) / 2,
+                pos.y + size.height / 2 - fontRenderer.FONT_HEIGHT / 2, self.getTextColor());
+    }
+}

src/main/java/supersymmetry/api/items/itemhandlers/LockableItemStackHandler.java

@@ -0,0 +1,45 @@
+package supersymmetry.api.items.itemhandlers;
+
+import gregtech.api.capability.impl.NotifiableItemStackHandler;
+import gregtech.api.metatileentity.MetaTileEntity;
+
+import net.minecraft.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+import supersymmetry.api.capability.ILockableHandler;
+
+public class LockableItemStackHandler extends NotifiableItemStackHandler implements ILockableHandler<ItemStack> {
+
+    protected boolean locked;
+    protected ItemStack lockedItemStack;
+
+    public LockableItemStackHandler(MetaTileEntity entityToNotify, boolean isExport) {
+        super(entityToNotify, 1, entityToNotify, isExport);
+    }
+
+    @Override
+    public void setLock(boolean isLocked) {
+        this.locked = isLocked;
+        if (isLocked && !this.getStackInSlot(0).isEmpty()) {
+            lockedItemStack = this.getStackInSlot(0).copy();
+        }
+    }
+
+    public boolean isLocked() {
+        return this.locked;
+    }
+
+    @NotNull
+    @Override
+    public ItemStack insertItem(int slot, @NotNull ItemStack stack, boolean simulate) {
+        if (this.locked && !this.lockedItemStack.isItemEqual(stack)) {
+            return stack;
+        }
+        return super.insertItem(slot, stack, simulate);
+    }
+
+    @Override
+    public ItemStack getLockedObject() {
+        return lockedItemStack;
+    }
+}

src/main/java/supersymmetry/api/metatileentity/multiblock/IFissionReactorHatch.java

@@ -0,0 +1,17 @@
+package supersymmetry.api.metatileentity.multiblock;
+
+import net.minecraft.util.math.BlockPos;
+
+import org.jetbrains.annotations.Nullable;
+
+public interface IFissionReactorHatch {
+
+    /**
+     * @param depth The depth of the reactor that needs checking
+     * @return If the channel directly below the hatch is valid or not
+     */
+    boolean checkValidity(int depth);
+
+    @Nullable
+    BlockPos getPos();
+}

src/main/java/supersymmetry/api/metatileentity/multiblock/SuSyMultiblockAbilities.java

@@ -2,8 +2,19 @@
 
 import gregtech.api.metatileentity.multiblock.MultiblockAbility;
 import net.minecraftforge.items.IItemHandlerModifiable;
+import supersymmetry.api.capability.ICoolantHandler;
+import supersymmetry.api.capability.IFuelRodHandler;
+import supersymmetry.common.metatileentities.multi.multiblockpart.MetaTileEntityControlRodPort;
 
+@SuppressWarnings("InstantiationOfUtilityClass")
 public class SuSyMultiblockAbilities {
+
     public static final MultiblockAbility<IItemHandlerModifiable> PRIMITIVE_IMPORT_ITEMS = new MultiblockAbility<>("primitive_import_items");
     public static final MultiblockAbility<IItemHandlerModifiable> PRIMITIVE_EXPORT_ITEMS = new MultiblockAbility<>("primitive_export_items");
+
+    public static final MultiblockAbility<IFuelRodHandler> IMPORT_FUEL_ROD = new MultiblockAbility<>("import_fuel_rod");
+    public static final MultiblockAbility<IItemHandlerModifiable> EXPORT_FUEL_ROD = new MultiblockAbility<>("export_fuel_rod");
+    public static final MultiblockAbility<ICoolantHandler> IMPORT_COOLANT = new MultiblockAbility<>("import_coolant");
+    public static final MultiblockAbility<ICoolantHandler> EXPORT_COOLANT = new MultiblockAbility<>("export_coolant");
+    public static final MultiblockAbility<MetaTileEntityControlRodPort> CONTROL_ROD_PORT = new MultiblockAbility<>("control_rod_port");
 }

src/main/java/supersymmetry/api/nuclear/fission/CoolantRegistry.java

@@ -0,0 +1,36 @@
+package supersymmetry.api.nuclear.fission;
+
+import net.minecraftforge.fluids.Fluid;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Map;
+
+public class CoolantRegistry {
+
+    private static final Map<Fluid, ICoolantStats> COOLANTS = new Object2ObjectOpenHashMap<>();
+    private static final Map<ICoolantStats, Fluid> COOLANTS_INVERSE = new Object2ObjectOpenHashMap<>();
+
+    public static void registerCoolant(@NotNull Fluid fluid, @NotNull ICoolantStats coolant) {
+        COOLANTS.put(fluid, coolant);
+        COOLANTS_INVERSE.put(coolant, fluid);
+    }
+
+    @Nullable
+    public static ICoolantStats getCoolant(Fluid fluid) {
+        return COOLANTS.get(fluid);
+    }
+
+    @NotNull
+    public static Collection<Fluid> getAllCoolants() {
+        return COOLANTS.keySet();
+    }
+
+    @Nullable
+    public static Fluid originalFluid(ICoolantStats stats) {
+        return COOLANTS_INVERSE.get(stats);
+    }
+}