Fission fuel recipes

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

@@ -144,11 +144,17 @@ public static int assignId() {
     // Detector Covers
     public static final int UPDATE_INVERTED = assignId();
 
+    // Fission Hatches
+    public static final int LOCK_UPDATE = 17;
+
     // HPCA / Research Station
     public static final int DAMAGE_STATE = assignId();
     public static final int LOCK_OBJECT_HOLDER = assignId();
     public static final int CACHED_CWU = assignId();
 
+    // Fission Hatches
+    public static final int LOCK_UPDATE = 17;
+
     // NBT Keys
 
     // From MetaTileEntityHolder

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

@@ -0,0 +1,13 @@
+package gregtech.api.capability;
+
+import gregtech.api.capability.impl.LockableFluidTank;
+import gregtech.api.unification.material.Material;
+
+public interface ICoolantHandler extends ILockableHandler {
+
+    Material getCoolant();
+
+    void setCoolant(Material material);
+
+    LockableFluidTank getFluidTank();
+}

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

@@ -0,0 +1,13 @@
+package gregtech.api.capability;
+
+import gregtech.api.items.itemhandlers.LockableItemStackHandler;
+import gregtech.api.unification.material.Material;
+
+public interface IFuelRodHandler extends ILockableHandler {
+
+    Material getFuel();
+
+    void setFuel(Material material);
+
+    LockableItemStackHandler getStackHandler();
+}

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

@@ -0,0 +1,8 @@
+package gregtech.api.capability;
+
+public interface ILockableHandler {
+
+    void setLock(boolean isLocked);
+
+    boolean isLocked();
+}

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

@@ -0,0 +1,39 @@
+package gregtech.api.capability.impl;
+
+import gregtech.api.capability.ILockableHandler;
+import gregtech.api.metatileentity.MetaTileEntity;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidStack;
+
+public class LockableFluidTank extends NotifiableFluidTank implements ILockableHandler {
+    boolean locked;
+    Fluid lockedFluid;
+
+    public LockableFluidTank(int capacity, MetaTileEntity entityToNotify, boolean isExport) {
+        super(capacity, entityToNotify, isExport);
+    }
+
+    @Override
+    public void setLock(boolean isLocked) {
+        locked = isLocked;
+        if (isLocked) {
+            if (this.getFluid() == null)
+                lockedFluid = null;
+            else
+                lockedFluid = this.getFluid().getFluid();
+        }
+    }
+
+    @Override
+    public boolean isLocked() {
+        return locked;
+    }
+
+    @Override
+    public boolean canFillFluidType(FluidStack fluid) {
+        if (locked && fluid.getFluid() != lockedFluid) {
+            return false;
+        }
+        return super.canFillFluidType(fluid);
+    }
+}

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

@@ -0,0 +1,55 @@
+package gregtech.api.capability.impl;
+
+import gregtech.api.GTValues;
+import gregtech.api.metatileentity.multiblock.RecipeMapMultiblockController;
+import gregtech.api.recipes.logic.OverclockingLogic;
+import gregtech.api.recipes.recipeproperties.IRecipePropertyStorage;
+
+import org.jetbrains.annotations.NotNull;
+
+public class NoEnergyMultiblockRecipeLogic extends MultiblockRecipeLogic {
+
+    public NoEnergyMultiblockRecipeLogic(RecipeMapMultiblockController tileEntity) {
+        super(tileEntity);
+    }
+
+    protected long getEnergyInputPerSecond() {
+        return 2147483647L;
+    }
+
+    protected long getEnergyStored() {
+        return 0L;
+    }
+
+    protected long getEnergyCapacity() {
+        return 2147483647L;
+    }
+
+    protected boolean drawEnergy(int recipeEUt, boolean simulate) {
+        return true;
+    }
+
+    public long getMaxVoltage() {
+        return 1L;
+    }
+
+    protected int[] runOverclockingLogic(@NotNull IRecipePropertyStorage propertyStorage, int recipeEUt,
+                                         long maxVoltage, int recipeDuration, int amountOC) {
+        return OverclockingLogic.standardOverclockingLogic(1, this.getMaxVoltage(), recipeDuration, amountOC,
+                this.getOverclockingDurationDivisor(), this.getOverclockingVoltageMultiplier());
+    }
+
+    public long getMaximumOverclockVoltage() {
+        return GTValues.V[1];
+    }
+
+    public void invalidate() {
+        this.previousRecipe = null;
+        this.progressTime = 0;
+        this.maxProgressTime = 0;
+        this.recipeEUt = 0;
+        this.fluidOutputs = null;
+        this.itemOutputs = null;
+        this.setActive(false);
+    }
+}

src/main/java/gregtech/api/items/armor/IArmorLogic.java

@@ -79,4 +79,12 @@ default ModelBiped getArmorModel(EntityLivingBase entityLiving, ItemStack itemSt
     default float getHeatResistance() {
         return 1.0f;
     }
+
+    /**
+     *
+     * @return the value to multiply radiation damage by
+     */
+    default float getRadiationResistance() {
+        return 1.0f;
+    }
 }

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

@@ -0,0 +1,42 @@
+package gregtech.api.items.itemhandlers;
+
+import gregtech.api.capability.ILockableHandler;
+import gregtech.api.capability.impl.NotifiableItemStackHandler;
+import gregtech.api.metatileentity.MetaTileEntity;
+
+import net.minecraft.item.ItemStack;
+
+import org.jetbrains.annotations.NotNull;
+
+// TODO This class can be removed
+public class LockableItemStackHandler extends NotifiableItemStackHandler implements ILockableHandler {
+
+    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)
+            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) {
+            if (!this.lockedItemStack.isItemEqual(stack)) {
+                return stack;
+            }
+        }
+        return super.insertItem(slot, stack, simulate);
+    }
+}

src/main/java/gregtech/api/items/materialitem/MetaPrefixItem.java

@@ -87,8 +87,8 @@ private static void registerSpecialOreDict(ItemStack item, Material material, Or
 
         if (material == Materials.Plutonium239) {
             OreDictUnifier.registerOre(item, prefix.name() + material.toCamelCaseString() + "239");
-        } else if (material == Materials.Uranium238) {
-            OreDictUnifier.registerOre(item, prefix.name() + material.toCamelCaseString() + "238");
+        } else if (material == Materials.Uranium) {
+            OreDictUnifier.registerOre(item, prefix.name() + material.toCamelCaseString());
         } else if (material == Materials.Saltpeter) {
             OreDictUnifier.registerOre(item, prefix.name() + material.toCamelCaseString());
         }
@@ -157,23 +157,49 @@ public void onUpdate(@NotNull ItemStack itemStack, @NotNull World worldIn, @NotN
         super.onUpdate(itemStack, worldIn, entityIn, itemSlot, isSelected);
         if (metaItems.containsKey((short) itemStack.getItemDamage()) && entityIn instanceof EntityLivingBase entity) {
             if (entityIn.ticksExisted % 20 == 0) {
-                if (prefix.heatDamageFunction == null) return;
-
-                Material material = getMaterial(itemStack);
-                if (material == null || !material.hasProperty(PropertyKey.BLAST)) return;
 
-                float heatDamage = prefix.heatDamageFunction.apply(material.getBlastTemperature());
-                ItemStack armor = entity.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
-                if (!armor.isEmpty() && armor.getItem() instanceof ArmorMetaItem<?>) {
-                    ArmorMetaItem<?>.ArmorMetaValueItem metaValueItem = ((ArmorMetaItem<?>) armor.getItem())
-                            .getItem(armor);
-                    if (metaValueItem != null) heatDamage *= metaValueItem.getArmorLogic().getHeatResistance();
+                //Handle heat damage
+                if (prefix.heatDamageFunction != null) {
+                    Material material = getMaterial(itemStack);
+                    if (material != null) {
+                        float heatDamage = 0.f;
+                        if (material.hasProperty(PropertyKey.BLAST)) {
+                            heatDamage = prefix.heatDamageFunction.apply(material.getBlastTemperature());
+                        } else if (material.hasProperty(PropertyKey.FISSION_FUEL)) {
+                            heatDamage = prefix.heatDamageFunction.apply(0);
+                        }
+                        ItemStack armor = entity.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
+                        if (!armor.isEmpty() && armor.getItem() instanceof ArmorMetaItem<?>) {
+                            ArmorMetaItem<?>.ArmorMetaValueItem metaValueItem = ((ArmorMetaItem<?>) armor.getItem())
+                                    .getItem(armor);
+                            if (metaValueItem != null) heatDamage *= metaValueItem.getArmorLogic().getHeatResistance();
+                        }
+                        if (heatDamage > 0.0) {
+                            entity.attackEntityFrom(DamageSources.getHeatDamage().setDamageBypassesArmor(), heatDamage);
+                        } else if (heatDamage < 0.0) {
+                            entity.attackEntityFrom(DamageSources.getFrostDamage().setDamageBypassesArmor(),
+                                    -heatDamage);
+                        }
+                    }
                 }
 
-                if (heatDamage > 0.0) {
-                    entity.attackEntityFrom(DamageSources.getHeatDamage().setDamageBypassesArmor(), heatDamage);
-                } else if (heatDamage < 0.0) {
-                    entity.attackEntityFrom(DamageSources.getFrostDamage().setDamageBypassesArmor(), -heatDamage);
+                //Handle radiation damage
+                if (prefix.radiationDamageFunction != null) {
+                    Material material = getMaterial(itemStack);
+                    if (material != null) {
+                        float radiationDamage = prefix.radiationDamageFunction.apply(material.getNeutrons());
+                        ItemStack armor = entity.getItemStackFromSlot(EntityEquipmentSlot.CHEST);
+                        if (!armor.isEmpty() && armor.getItem() instanceof ArmorMetaItem<?>) {
+                            ArmorMetaItem<?>.ArmorMetaValueItem metaValueItem = ((ArmorMetaItem<?>) armor.getItem())
+                                    .getItem(armor);
+                            if (metaValueItem != null) {
+                                radiationDamage *= metaValueItem.getArmorLogic().getRadiationResistance();
+                            }
+                        }
+                        if (radiationDamage > 0.0) {
+                            entity.attackEntityFrom(DamageSources.getRadioactiveDamage().setDamageBypassesArmor(), radiationDamage);
+                        }
+                    }
                 }
             }
         }

src/main/java/gregtech/api/metatileentity/multiblock/IControlRodPort.java

@@ -0,0 +1,5 @@
+package gregtech.api.metatileentity.multiblock;
+
+public interface IControlRodPort {
+    byte getInsertionAmount();
+}

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

@@ -0,0 +1,15 @@
+package gregtech.api.metatileentity.multiblock;
+
+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);
+
+    boolean isValid();
+
+    void setValid(boolean valid);
+}

src/main/java/gregtech/api/metatileentity/multiblock/MultiblockAbility.java

@@ -76,6 +76,14 @@ public class MultiblockAbility<T> {
             "hpca_component");
     public static final MultiblockAbility<IObjectHolder> OBJECT_HOLDER = new MultiblockAbility<>("object_holder");
 
+    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<IControlRodPort> CONTROL_ROD_PORT = new MultiblockAbility<>(
+            "control_rod_port");
+
     public static void registerMultiblockAbility(MultiblockAbility<?> ability, MetaTileEntity part) {
         if (!REGISTRY.containsKey(ability)) {
             REGISTRY.put(ability, new ArrayList<>());