From b851def47ba05ae471176dcc0313c21612a0c222 Mon Sep 17 00:00:00 2001 From: brian Date: Sat, 8 Jun 2024 19:55:12 -0500 Subject: [PATCH 01/35] version --- .gitignore | 1 + gradle.properties | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.gitignore b/.gitignore index 9d67b094..ff99070a 100644 --- a/.gitignore +++ b/.gitignore @@ -20,4 +20,5 @@ build # other eclipse run +libs libs \ No newline at end of file diff --git a/gradle.properties b/gradle.properties index 143f345c..2b5521b2 100644 --- a/gradle.properties +++ b/gradle.properties @@ -7,7 +7,7 @@ modGroup = com.fulltrix.gcyl # Version of your mod. # This field can be left empty if you want your mod's version to be determined by the latest git tag instead. -modVersion = 0.0.5 +modVersion = 0.0.6 # Whether to use the old jar naming structure (modid-mcversion-version) instead of the new version (modid-version) includeMCVersionJar = false From 4a0113a95dc4be3bd2847ac3bb0112643fd3ed98 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 07:11:21 -0500 Subject: [PATCH 02/35] ender item link --- .../java/com/fulltrix/gcyl/CommonProxy.java | 7 + .../api/util/ItemContainerSwitchShim.java | 58 +++ .../api/util/VirtualContainerRegistry.java | 342 +++++++++++++++ .../fulltrix/gcyl/client/ClientHandler.java | 3 + .../gcyl/covers/CoverEnderItemLink.java | 401 ++++++++++++++++++ .../gcyl/covers/GCYLCoverBehaviors.java | 1 + .../com/fulltrix/gcyl/item/GCYLCoreItem.java | 2 + .../com/fulltrix/gcyl/item/GCYLCoreItems.java | 2 +- .../resources/assets/gcyl/lang/en_us.lang | 3 + .../item/metaitems/cover.ender.item_link.json | 6 + .../blocks/cover/overlay_ender_item_link.png | Bin 0 -> 1407 bytes .../cover/overlay_ender_item_link.png.mcmeta | 5 + .../overlay_ender_item_link_emissive.png | Bin 0 -> 1188 bytes ...verlay_ender_item_link_emissive.png.mcmeta | 5 + .../items/metaitems/cover.ender.item_link.png | Bin 0 -> 582 bytes 15 files changed, 834 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/fulltrix/gcyl/api/util/ItemContainerSwitchShim.java create mode 100644 src/main/java/com/fulltrix/gcyl/api/util/VirtualContainerRegistry.java create mode 100644 src/main/java/com/fulltrix/gcyl/covers/CoverEnderItemLink.java create mode 100644 src/main/resources/assets/gregtech/models/item/metaitems/cover.ender.item_link.json create mode 100644 src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link.png create mode 100644 src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link.png.mcmeta create mode 100644 src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link_emissive.png create mode 100644 src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link_emissive.png.mcmeta create mode 100644 src/main/resources/assets/gregtech/textures/items/metaitems/cover.ender.item_link.png diff --git a/src/main/java/com/fulltrix/gcyl/CommonProxy.java b/src/main/java/com/fulltrix/gcyl/CommonProxy.java index c9d5b1a0..e988c537 100644 --- a/src/main/java/com/fulltrix/gcyl/CommonProxy.java +++ b/src/main/java/com/fulltrix/gcyl/CommonProxy.java @@ -1,5 +1,6 @@ package com.fulltrix.gcyl; +import com.fulltrix.gcyl.api.util.VirtualContainerRegistry; import com.fulltrix.gcyl.item.GCYLCoreItems; import com.fulltrix.gcyl.materials.GCYLMaterialOverride; import com.fulltrix.gcyl.materials.GCYLMaterials; @@ -29,6 +30,7 @@ import net.minecraftforge.common.config.Config; import net.minecraftforge.common.config.ConfigManager; import net.minecraftforge.event.RegistryEvent; +import net.minecraftforge.event.world.WorldEvent; import net.minecraftforge.fml.client.event.ConfigChangedEvent; import net.minecraftforge.fml.common.Mod; import net.minecraftforge.fml.common.eventhandler.EventPriority; @@ -157,6 +159,11 @@ public static void registerRecipes(RegistryEvent.Register event) { //RecipeHandler.registerLargeMachineRecipes(); } + @SubscribeEvent + public static void onWorldLoadEvent(WorldEvent.Load event) { + VirtualContainerRegistry.initializeStorage(event.getWorld()); + } + @SubscribeEvent diff --git a/src/main/java/com/fulltrix/gcyl/api/util/ItemContainerSwitchShim.java b/src/main/java/com/fulltrix/gcyl/api/util/ItemContainerSwitchShim.java new file mode 100644 index 00000000..af243812 --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/api/util/ItemContainerSwitchShim.java @@ -0,0 +1,58 @@ +package com.fulltrix.gcyl.api.util; + +import com.cleanroommc.modularui.widgets.slot.ModularSlot; +import net.minecraft.item.ItemStack; +import net.minecraftforge.items.IItemHandlerModifiable; +import org.jetbrains.annotations.NotNull; + +import javax.annotation.Nonnull; + +public class ItemContainerSwitchShim implements IItemHandlerModifiable { + + IItemHandlerModifiable container; + public ItemContainerSwitchShim(IItemHandlerModifiable container) { + changeInventory(container); + } + + public void changeInventory(IItemHandlerModifiable container) { + this.container = container; + } + + @Override + public int getSlots() { + return this.container.getSlots(); + } + + @Nonnull + @Override + public ItemStack getStackInSlot(int slot) { + return this.container.getStackInSlot(slot); + } + + @Nonnull + @Override + public ItemStack insertItem(int slot, @Nonnull ItemStack itemStack, boolean simulate) { + return this.container.insertItem(slot, itemStack, simulate); + } + + @Nonnull + @Override + public ItemStack extractItem(int slot, int amount, boolean simulate) { + return this.container.extractItem(slot, amount, simulate); + } + + @Override + public int getSlotLimit(int slot) { + return this.container.getSlotLimit(slot); + } + + @Override + public boolean isItemValid(int slot, @NotNull ItemStack stack) { + return IItemHandlerModifiable.super.isItemValid(slot, stack); + } + + @Override + public void setStackInSlot(int i, @Nonnull ItemStack itemStack) { + this.container.setStackInSlot(i, itemStack); + } +} diff --git a/src/main/java/com/fulltrix/gcyl/api/util/VirtualContainerRegistry.java b/src/main/java/com/fulltrix/gcyl/api/util/VirtualContainerRegistry.java new file mode 100644 index 00000000..af5f7e92 --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/api/util/VirtualContainerRegistry.java @@ -0,0 +1,342 @@ +package com.fulltrix.gcyl.api.util; + +import gregtech.api.GTValues; +import gregtech.api.util.GTLog; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.util.NonNullList; +import net.minecraft.world.World; +import net.minecraft.world.storage.MapStorage; +import net.minecraft.world.storage.WorldSavedData; +import net.minecraftforge.common.util.Constants; +import net.minecraftforge.common.util.INBTSerializable; +import net.minecraftforge.items.IItemHandler; +import net.minecraftforge.items.IItemHandlerModifiable; +import net.minecraftforge.items.ItemHandlerHelper; + +import javax.annotation.Nonnull; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; + +public class VirtualContainerRegistry extends WorldSavedData { + private static final int DEFAULT_SIZE = 9; // 9 slots + private static final String DATA_ID = GTValues.MODID + ".vcontainer_data"; + + protected static Map> containerMap = new HashMap<>(); + + public VirtualContainerRegistry(){ + super(DATA_ID); + } + // for some reason, MapStorage throws an error if this constructor is not present + @SuppressWarnings("unused") + public VirtualContainerRegistry(String name){ + super(name); + } + + /** + * Retrieves a container from the registry + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + * @return The container object + */ + public static VirtualContainer getContainer(String key, UUID uuid) { + return containerMap.get(uuid).get(key); + } + + /** + * @return the internal Map of containers. + * Do not use to modify the map! + */ + public static Map> getContainerMap() { + return containerMap; + } + + /** + * Retrieves a container from the registry, creating it if it does not exist + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + * @param size The initial size of the container + * @return The container object + */ + public static VirtualContainer getContainerCreate(String key, UUID uuid, int size) { + if (!containerMap.containsKey(uuid) || !containerMap.get(uuid).containsKey(key)) { + addContainer(key, uuid, size); + } + return getContainer(key, uuid); + } + + /** + * Retrieves a container from the registry, creating it with {@link #DEFAULT_SIZE the default size} if it does not exist + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + * @return The container object + */ + public static VirtualContainer getContainerCreate(String key, UUID uuid) { + return getContainerCreate(key, uuid, DEFAULT_SIZE); + } + + /** + * Adds a container to the registry + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + * @param size The initial size of the container + */ + public static void addContainer(String key, UUID uuid, int size) { + if (containerMap.containsKey(uuid) && containerMap.get(uuid).containsKey(key)) { + GTLog.logger.warn("Overwriting virtual container " + key + "/" + (uuid == null ? "null" :uuid.toString()) + ", this might cause item loss!"); + } else if (!containerMap.containsKey(uuid)) { + containerMap.put(uuid, new HashMap<>()); + } + containerMap.get(uuid).put(key, new VirtualContainer(size)); + } + + /** + * Adds a container to the registry with {@link #DEFAULT_SIZE the default size} + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + */ + public static void addContainer(String key, UUID uuid) { + addContainer(key, uuid, DEFAULT_SIZE); + } + + /** + * Removes a container from the registry. Use with caution! + * @param key The name of the container + * @param uuid The uuid of the player the container is private to, or null if the container is public + * @param removeContainer Whether to remove the container if it has items in it + */ + public static void delContainer(String key, UUID uuid, boolean removeContainer) { + if (containerMap.containsKey(uuid) && containerMap.get(uuid).containsKey(key)) { + boolean isEmpty = true; + IItemHandler container = containerMap.get(uuid).get(key); + + for (int i = 0; i < container.getSlots(); i++) { + if (!container.getStackInSlot(i).isEmpty()) { + isEmpty = false; + break; + } + } + + if (removeContainer || isEmpty) { + containerMap.get(uuid).remove(key); + if (containerMap.get(uuid).size() == 0) { + containerMap.remove(uuid); + } + } + } else { + GTLog.logger.warn("Attempted to delete container " + key + "/" + (uuid == null ? "null" :uuid.toString()) + ", which does not exist!"); + } + } + + /** + * To be called on server stopped event + */ + public static void clearMaps() { + containerMap.clear(); + } + + @Override + public void readFromNBT(NBTTagCompound nbt) { + if (nbt.hasKey("Public")) { + NBTTagCompound publicContainers = nbt.getCompoundTag("Public"); + for (String key : publicContainers.getKeySet()) { + NBTTagCompound containerCompound = publicContainers.getCompoundTag(key); + VirtualContainerRegistry.getContainerCreate(key, null).deserializeNBT(containerCompound); + } + } + if (nbt.hasKey("Private")) { + NBTTagCompound privateContainerUUIDs = nbt.getCompoundTag("Private"); + for (String uuidStr : privateContainerUUIDs.getKeySet()) { + UUID uuid = UUID.fromString(uuidStr); + NBTTagCompound privateContainers = privateContainerUUIDs.getCompoundTag(uuidStr); + for (String key : privateContainers.getKeySet()) { + NBTTagCompound containerCompound = privateContainers.getCompoundTag(key); + VirtualContainerRegistry.getContainerCreate(key, uuid).deserializeNBT(containerCompound); + } + } + } + } + + @Nonnull + @Override + public NBTTagCompound writeToNBT(NBTTagCompound compound) { + compound.setTag("Private", new NBTTagCompound()); + containerMap.forEach( (uuid, map) -> { + NBTTagCompound mapCompound = new NBTTagCompound(); + map.forEach( (key, container) -> { + NBTTagCompound containerCompound = container.serializeNBT(); + mapCompound.setTag(key, containerCompound); + }); + if (mapCompound.getSize() > 0) { + if (uuid == null) { + compound.setTag("Public", mapCompound); + } else { + compound.getCompoundTag("Private").setTag(uuid.toString(), mapCompound); + } + } + }); + return compound; + } + + @Override + public boolean isDirty() { + // can't think of a good way to mark dirty other than always + return true; + } + + /** + * To be called on world load event + */ + public static void initializeStorage(World world) { + MapStorage storage = world.getMapStorage(); + VirtualContainerRegistry instance = (VirtualContainerRegistry) storage.getOrLoadData(VirtualContainerRegistry.class, DATA_ID); + + if (instance == null) { + instance = new VirtualContainerRegistry(); + storage.setData(DATA_ID, instance); + } + } + + protected static class VirtualContainer implements IItemHandlerModifiable, IItemHandler, INBTSerializable { + private NonNullList stacks; + public VirtualContainer(int size){ + this.setSize(size); + } + + public void setSize(int size) + { + stacks = NonNullList.withSize(size, ItemStack.EMPTY); + } + + @Override + public void setStackInSlot(int slot, @Nonnull ItemStack stack) { + validateSlotIndex(slot); + this.stacks.set(slot, stack); + } + + @Override + public int getSlots() + { + return stacks.size(); + } + + @Override + @Nonnull + public ItemStack getStackInSlot(int slot) { + validateSlotIndex(slot); + return this.stacks.get(slot); + } + + @Override + @Nonnull + public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { + if (stack.isEmpty()) + return ItemStack.EMPTY; + + validateSlotIndex(slot); + + ItemStack existing = this.stacks.get(slot); + + int limit = getStackLimit(slot, stack); + + if (!existing.isEmpty()) { + if (!ItemHandlerHelper.canItemStacksStack(stack, existing)) + return stack; + + limit -= existing.getCount(); + } + + if (limit <= 0) + return stack; + + boolean reachedLimit = stack.getCount() > limit; + + if (!simulate) { + if (existing.isEmpty()) { + this.stacks.set(slot, reachedLimit ? ItemHandlerHelper.copyStackWithSize(stack, limit) : stack); + } else { + existing.grow(reachedLimit ? limit : stack.getCount()); + } + } + + return reachedLimit ? ItemHandlerHelper.copyStackWithSize(stack, stack.getCount()- limit) : ItemStack.EMPTY; + } + + @Override + @Nonnull + public ItemStack extractItem(int slot, int amount, boolean simulate) { + if (amount == 0) + return ItemStack.EMPTY; + + validateSlotIndex(slot); + + ItemStack existing = this.stacks.get(slot); + + if (existing.isEmpty()) + return ItemStack.EMPTY; + + int toExtract = Math.min(amount, existing.getMaxStackSize()); + + if (existing.getCount() <= toExtract) { + if (!simulate) { + this.stacks.set(slot, ItemStack.EMPTY); + } + return existing; + } else { + if (!simulate) { + this.stacks.set(slot, ItemHandlerHelper.copyStackWithSize(existing, existing.getCount() - toExtract)); + } + + return ItemHandlerHelper.copyStackWithSize(existing, toExtract); + } + } + + @Override + public int getSlotLimit(int slot) + { + return 64; + } + + protected int getStackLimit(int slot, @Nonnull ItemStack stack) { + return Math.min(getSlotLimit(slot), stack.getMaxStackSize()); + } + + @Override + public NBTTagCompound serializeNBT() { + NBTTagList nbtTagList = new NBTTagList(); + for (int i = 0; i < stacks.size(); i++) { + if (!stacks.get(i).isEmpty()) { + NBTTagCompound itemTag = new NBTTagCompound(); + itemTag.setInteger("Slot", i); + stacks.get(i).writeToNBT(itemTag); + nbtTagList.appendTag(itemTag); + } + } + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setTag("Items", nbtTagList); + nbt.setInteger("Size", stacks.size()); + return nbt; + } + + @Override + public void deserializeNBT(NBTTagCompound nbt) { + setSize(nbt.hasKey("Size", Constants.NBT.TAG_INT) ? nbt.getInteger("Size") : stacks.size()); + NBTTagList tagList = nbt.getTagList("Items", Constants.NBT.TAG_COMPOUND); + for (int i = 0; i < tagList.tagCount(); i++) { + NBTTagCompound itemTags = tagList.getCompoundTagAt(i); + int slot = itemTags.getInteger("Slot"); + + if (slot >= 0 && slot < stacks.size()) { + stacks.set(slot, new ItemStack(itemTags)); + } + } + } + + protected void validateSlotIndex(int slot) { + if (slot < 0 || slot >= stacks.size()) + throw new RuntimeException("Slot " + slot + " not in valid range - [0," + stacks.size() + ")"); + } + } +} diff --git a/src/main/java/com/fulltrix/gcyl/client/ClientHandler.java b/src/main/java/com/fulltrix/gcyl/client/ClientHandler.java index de0e6fe8..bacb5541 100644 --- a/src/main/java/com/fulltrix/gcyl/client/ClientHandler.java +++ b/src/main/java/com/fulltrix/gcyl/client/ClientHandler.java @@ -31,10 +31,12 @@ public class ClientHandler { public static SimpleOverlayRenderer HASTELLOY_K243_CASING; public static SimpleOverlayRenderer MAINTENANCE_OVERLAY_STERILE_CLEANING; public static SimpleOverlayRenderer CLADDED_REACTOR_CASING; + public static SimpleOverlayRenderer ENDER_ITEM_LINK; public static OrientedOverlayRenderer NAQADAH_OVERLAY; public static OrientedOverlayRenderer ROCKET_OVERLAY; + private ClientHandler() { } @@ -56,6 +58,7 @@ public static void preInit() { MAINTENANCE_OVERLAY_STERILE_CLEANING = new SimpleOverlayRenderer("overlay/machine/overlay_maintenance_sterile_cleaning"); + ENDER_ITEM_LINK = new SimpleOverlayRenderer("cover/overlay_ender_item_link"); //MetaCasing1 STABALLOY_CASING = new SimpleOverlayRenderer("casings/metal_casings/staballoy"); QUANTUM_CASING = new SimpleOverlayRenderer("casings/metal_casings/quantum"); diff --git a/src/main/java/com/fulltrix/gcyl/covers/CoverEnderItemLink.java b/src/main/java/com/fulltrix/gcyl/covers/CoverEnderItemLink.java new file mode 100644 index 00000000..f31edd57 --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/covers/CoverEnderItemLink.java @@ -0,0 +1,401 @@ +package com.fulltrix.gcyl.covers; + +import codechicken.lib.raytracer.CuboidRayTraceResult; +import codechicken.lib.render.CCRenderState; +import codechicken.lib.render.pipeline.IVertexOperation; +import codechicken.lib.vec.Cuboid6; +import codechicken.lib.vec.Matrix4; +import com.cleanroommc.modularui.api.drawable.IKey; +import com.cleanroommc.modularui.api.widget.IWidget; +import com.cleanroommc.modularui.drawable.DynamicDrawable; +import com.cleanroommc.modularui.drawable.Rectangle; +import com.cleanroommc.modularui.factory.SidedPosGuiData; +import com.cleanroommc.modularui.screen.ModularPanel; +import com.cleanroommc.modularui.utils.Color; +import com.cleanroommc.modularui.value.sync.*; +import com.cleanroommc.modularui.widgets.FluidSlot; +import com.cleanroommc.modularui.widgets.ItemSlot; +import com.cleanroommc.modularui.widgets.ToggleButton; +import com.cleanroommc.modularui.widgets.layout.Column; +import com.cleanroommc.modularui.widgets.layout.Grid; +import com.cleanroommc.modularui.widgets.layout.Row; +import com.cleanroommc.modularui.widgets.textfield.TextFieldWidget; +import com.fulltrix.gcyl.CommonProxy; +import com.fulltrix.gcyl.api.util.ItemContainerSwitchShim; +import com.fulltrix.gcyl.api.util.VirtualContainerRegistry; +import com.fulltrix.gcyl.client.ClientHandler; +import gregtech.api.capability.GregtechTileCapabilities; +import gregtech.api.capability.IControllable; +import gregtech.api.cover.CoverBase; +import gregtech.api.cover.CoverDefinition; +import gregtech.api.cover.CoverWithUI; +import gregtech.api.cover.CoverableView; +import gregtech.api.gui.GuiTextures; +import gregtech.api.gui.ModularUI; +import gregtech.api.gui.widgets.*; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.mui.GTGuiTextures; +import gregtech.api.mui.GTGuis; +import gregtech.api.util.GTTransferUtils; +import gregtech.client.renderer.texture.Textures; +import gregtech.common.covers.CoverConveyor; +import gregtech.common.covers.CoverPump; +import gregtech.common.covers.filter.ItemFilterContainer; +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.PacketBuffer; +import net.minecraft.util.*; +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.items.CapabilityItemHandler; +import net.minecraftforge.items.IItemHandler; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import java.util.regex.Pattern; + +//TODO: get itemslots to sync properly so that itemslots can be used with mui +//TODO: implement integration with terminal? +public class CoverEnderItemLink extends CoverBase implements CoverWithUI, ITickable, IControllable { + public static final int TRANSFER_RATE = 1000; + + private static final Pattern COLOR_INPUT_PATTERN = Pattern.compile("[0-9a-fA-F]*"); + + protected CoverConveyor.ConveyorMode conveyorMode = CoverConveyor.ConveyorMode.IMPORT; + + private int color = 0xFFFFFFFF; + private UUID playerUUID = null; + private boolean isPrivate = false; + private boolean workingEnabled = true; + private boolean ioEnabled = false; + private String tempColorStr; + private boolean isColorTemp; + protected int itemsLeftToTransferLastSecond; + + private final ItemContainerSwitchShim linkedShim; + + protected final ItemFilterContainer itemFilter; + + + protected CoverEnderItemLink(@NotNull CoverDefinition definition, @NotNull CoverableView coverableView, + @NotNull EnumFacing attachedSide) { + super(definition, coverableView, attachedSide); + this.linkedShim = new ItemContainerSwitchShim(VirtualContainerRegistry.getContainerCreate(makeChestName(), null)); + itemFilter = new ItemFilterContainer(this); + } + + private String makeChestName() { + return "EILink#" + Integer.toHexString(this.color).toUpperCase(); + } + + private UUID getChestUUID() { return isPrivate ? playerUUID : null;} + + public ItemFilterContainer getItemFilterContainer() {return this.itemFilter;} + + public boolean isIOEnabled() {return this.ioEnabled;} + + @Override + public boolean canAttach(@NotNull CoverableView coverable, @NotNull EnumFacing side) { + return coverable.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, side); + } + + //TODO: change to item link texture + @Override + public void renderCover(@NotNull CCRenderState renderState, @NotNull Matrix4 translation, + IVertexOperation[] pipeline, @NotNull Cuboid6 plateBox, @NotNull BlockRenderLayer layer) { + ClientHandler.ENDER_ITEM_LINK.renderSided(getAttachedSide(), plateBox, renderState, pipeline, translation); + } + + @Override + public @NotNull EnumActionResult onScrewdriverClick(@NotNull EntityPlayer playerIn, @NotNull EnumHand hand, + @NotNull CuboidRayTraceResult hitResult) { + if (!getWorld().isRemote) { + openUI((EntityPlayerMP) playerIn); + } + return EnumActionResult.SUCCESS; + } + + @Override + public void onAttachment(@NotNull CoverableView coverableView, @NotNull EnumFacing side, + @Nullable EntityPlayer player, @NotNull ItemStack itemStack) { + super.onAttachment(coverableView, side, player, itemStack); + if (player != null) { + this.playerUUID = player.getUniqueID(); + } + } + + @Override + public void onRemoval() { + NonNullList drops = NonNullList.create(); + MetaTileEntity.clearInventory(drops, itemFilter); + for (ItemStack itemStack : drops) { + Block.spawnAsEntity(this.getWorld(), this.getPos(), itemStack); + } + } + + @Override + public void update() { + long timer = this.getOffsetTimer(); + IItemHandler targetInventory = getCoverableView().getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, getAttachedSide()); + if (workingEnabled && ioEnabled && itemsLeftToTransferLastSecond > 0 && timer % 5 == 0) { + int totalTransferred = doTransferItemsAny(targetInventory, linkedShim, itemsLeftToTransferLastSecond); + this.itemsLeftToTransferLastSecond -= totalTransferred; + } + + if (timer % 20 == 0){ + this.itemsLeftToTransferLastSecond = TRANSFER_RATE; + } + } + + protected int doTransferItemsAny(IItemHandler otherHandler, IItemHandler enderHandler, int maxTransferAmount) { + if (conveyorMode == CoverConveyor.ConveyorMode.IMPORT) { + return moveInventoryItems(otherHandler, enderHandler, maxTransferAmount); + } else if (conveyorMode == CoverConveyor.ConveyorMode.EXPORT) { + return moveInventoryItems(enderHandler, otherHandler, maxTransferAmount); + } + return 0; + } + + + protected int moveInventoryItems(IItemHandler sourceInventory, IItemHandler targetInventory, int maxTransferAmount) { + int itemsLeftToTransfer = maxTransferAmount; + for (int srcIndex = 0; srcIndex < sourceInventory.getSlots(); srcIndex++) { + ItemStack sourceStack = sourceInventory.extractItem(srcIndex, itemsLeftToTransfer, true); + if (sourceStack.isEmpty()) { + continue; + } + if (!itemFilter.test(sourceStack)) { + continue; + } + ItemStack remainder = GTTransferUtils.insertItem(targetInventory, sourceStack, true); + int amountToInsert = sourceStack.getCount() - remainder.getCount(); + + if (amountToInsert > 0) { + sourceStack = sourceInventory.extractItem(srcIndex, amountToInsert, false); + if (!sourceStack.isEmpty()) { + GTTransferUtils.insertItem(targetInventory, sourceStack, false); + itemsLeftToTransfer -= sourceStack.getCount(); + + if (itemsLeftToTransfer == 0) { + break; + } + } + } + } + return maxTransferAmount - itemsLeftToTransfer; + } + + public void setConveyorMode(CoverConveyor.ConveyorMode mode) { + conveyorMode = mode; + this.markDirty(); + } + + public CoverConveyor.ConveyorMode getConveyorMode() { + return conveyorMode; + } + + @Override + public void writeInitialSyncData(PacketBuffer packetBuffer) { + packetBuffer.writeInt(this.color); + packetBuffer.writeString(this.playerUUID == null ? "null" : this.playerUUID.toString()); + } + + @Override + public void readInitialSyncData(PacketBuffer packetBuffer) { + this.color = packetBuffer.readInt(); + String uuidStr = packetBuffer.readString(36); + this.playerUUID = uuidStr.equals("null") ? null : UUID.fromString(uuidStr); + } + + @Override + public void writeToNBT(NBTTagCompound tagCompound) { + super.writeToNBT(tagCompound); + tagCompound.setInteger("ConveyorMode", conveyorMode.ordinal()); + tagCompound.setTag("Filter", itemFilter.serializeNBT()); + tagCompound.setBoolean("WorkingAllowed", workingEnabled); + tagCompound.setBoolean("IOAllowed", ioEnabled); + tagCompound.setBoolean("Private", isPrivate); + tagCompound.setString("PlacedUUID", playerUUID.toString()); + tagCompound.setInteger("Frequency", color); + } + + @Override + public void readFromNBT(NBTTagCompound tagCompound) { + super.readFromNBT(tagCompound); + this.conveyorMode = CoverConveyor.ConveyorMode.values()[tagCompound.getInteger("ConveyorMode")]; + this.itemFilter.deserializeNBT(tagCompound.getCompoundTag("Filter")); + this.workingEnabled = tagCompound.getBoolean("WorkingAllowed"); + this.ioEnabled = tagCompound.getBoolean("IOAllowed"); + this.isPrivate = tagCompound.getBoolean("Private"); + this.playerUUID = UUID.fromString(tagCompound.getString("PlacedUUID")); + this.color = tagCompound.getInteger("Frequency"); + updateChestLink(); + } + + protected void updateChestLink() { + this.linkedShim.changeInventory(VirtualContainerRegistry.getContainerCreate(makeChestName(), getChestUUID())); + this.markDirty(); + } + + public T getCapability(Capability capability, T defaultValue) { + if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) { + return CapabilityItemHandler.ITEM_HANDLER_CAPABILITY.cast((IItemHandler) linkedShim); + } + if (capability == GregtechTileCapabilities.CAPABILITY_CONTROLLABLE) { + return GregtechTileCapabilities.CAPABILITY_CONTROLLABLE.cast(this); + } + return defaultValue; + } + + private boolean isPrivate() { + return isPrivate; + } + + private void setPrivate(boolean isPrivate) { + this.isPrivate = isPrivate; + updateChestLink(); + } + + private void setIoEnabled(boolean ioEnabled) { + this.ioEnabled = ioEnabled; + } + + @Override + public boolean isWorkingEnabled() { + return workingEnabled; + } + + @Override + public void setWorkingEnabled(boolean isActivationAllowed) { + this.workingEnabled = isActivationAllowed; + } + + @Override + public void openUI(EntityPlayerMP player) { + CoverWithUI.super.openUI(player); + isColorTemp = false; + } + + @Override + public boolean usesMui2() { + return true; + } + @Override + public ModularPanel buildUI(SidedPosGuiData guiData, GuiSyncManager guiSyncManager) { + var panel = GTGuis.createPanel(this, 176, 208); + + getItemFilterContainer().setMaxTransferSize(1); + + return panel.child(CoverWithUI.createTitleRow(getPickItem())) + .bindPlayerInventory() + .child(createWidgets(panel, guiSyncManager)); + + } + + protected Column createWidgets(ModularPanel panel, GuiSyncManager syncManager) { + var isPrivate = new BooleanSyncValue(this::isPrivate, this::setPrivate); + isPrivate.updateCacheFromSource(true); + + var color = new StringSyncValue(this::getColorStr, this::updateColor); + color.updateCacheFromSource(true); + + var conveyorMode = new EnumSyncValue<>(CoverConveyor.ConveyorMode.class, this::getConveyorMode, this::setConveyorMode); + syncManager.syncValue("conveyor_mode", conveyorMode); + conveyorMode.updateCacheFromSource(true); + + var ioEnabled = new BooleanSyncValue(this::isIOEnabled, this::setIoEnabled); + + syncManager.registerSlotGroup("item_inv", this.linkedShim.getSlots()); + + int rowSize = this.linkedShim.getSlots(); + List itemSlots = new ArrayList<>(); + for (int i = 0; i < rowSize; i++) { + itemSlots.add(new ItemSlot().slot(SyncHandlers.itemSlot(this.linkedShim, i).slotGroup("item_inv"))); + itemSlots.get(i).setEnabled(false); //disable faulty itemslots + } + + List> widgets = new ArrayList<>(); + widgets.add(new ArrayList<>()); + widgets.get(0).addAll(itemSlots); + + + return new Column().coverChildrenHeight().top(24) + .margin(7, 0).widthRel(1f) + .child(new Row().marginBottom(2) + .coverChildrenHeight() + .child(new ToggleButton() + .tooltip(tooltip -> tooltip.setAutoUpdate(true)) + .background(GTGuiTextures.PRIVATE_MODE_BUTTON[0]) + .hoverBackground(GTGuiTextures.PRIVATE_MODE_BUTTON[0]) + .selectedBackground(GTGuiTextures.PRIVATE_MODE_BUTTON[1]) + .selectedHoverBackground(GTGuiTextures.PRIVATE_MODE_BUTTON[1]) + .tooltipBuilder(tooltip -> tooltip.addLine(IKey.lang(this.isPrivate ? + "cover.ender_fluid_link.private.tooltip.enabled" : + "cover.ender_fluid_link.private.tooltip.disabled"))) + .marginRight(2) + .value(isPrivate)) + .child(new DynamicDrawable(() -> new Rectangle() + .setColor(this.color) + .asIcon().size(16)) + .asWidget() + .background(GTGuiTextures.SLOT) + .size(18).marginRight(2)) + .child(new TextFieldWidget().height(18) + .value(color) + .setValidator(s -> { + if (s.length() != 8) { + return color.getStringValue(); + } + return s; + }) + .setPattern(COLOR_INPUT_PATTERN) + .widthRel(0.5f).marginRight(2))) + .child(new Row().marginBottom(2) + .coverChildrenHeight() + .child(new Grid() + .height(18) + .minElementMargin(0, 0) + .minColWidth(18).minRowHeight(18) + .matrix(widgets))) + .child(new Row().marginBottom(2) + .coverChildrenHeight() + .child(new ToggleButton() + .value(ioEnabled) + .overlay(IKey.dynamic(() -> IKey.lang(this.ioEnabled ? + "behaviour.soft_hammer.enabled" : + "behaviour.soft_hammer.disabled").get()) + .color(Color.WHITE.darker(1))) + .widthRel(0.6f) + .left(0))) + .child(getItemFilterContainer().initUI(panel, syncManager)) + .child(new EnumRowBuilder<>(CoverConveyor.ConveyorMode.class) + .value(conveyorMode) + .overlay(GTGuiTextures.CONVEYOR_MODE_OVERLAY) + .lang("cover.pump.mode") + .build()); + } + + public String getColorStr() { + return isColorTemp ? tempColorStr : Integer.toHexString(this.color).toUpperCase(); + } + + public void updateColor(String str) { + if (str.length() == 8) { + isColorTemp = false; + long tmp = Long.parseLong(str, 16); + if (tmp > 0x7FFFFFFF) { + tmp -= 0x100000000L; + } + this.color = (int) tmp; + updateChestLink(); + } else { + tempColorStr = str; + isColorTemp = true; + } + } +} diff --git a/src/main/java/com/fulltrix/gcyl/covers/GCYLCoverBehaviors.java b/src/main/java/com/fulltrix/gcyl/covers/GCYLCoverBehaviors.java index 3db5cca0..a35258b2 100644 --- a/src/main/java/com/fulltrix/gcyl/covers/GCYLCoverBehaviors.java +++ b/src/main/java/com/fulltrix/gcyl/covers/GCYLCoverBehaviors.java @@ -23,5 +23,6 @@ public static void init() { registerBehavior(gcylId("infinite_water_zpm"), GCYLCoreItems.ZPM_INFINITE_WATER_SOURCE, (def,view, side) -> new GCYLCoverInfiniteWater(def, view, side, ZPM)); registerBehavior(gcylId("infinite_water_uv"), GCYLCoreItems.UV_INFINITE_WATER_SOURCE, (def,view, side) -> new GCYLCoverInfiniteWater(def, view, side, UV)); + registerBehavior(gcylId("ender_item_link"), GCYLCoreItems.COVER_ENDER_ITEM_LINK, CoverEnderItemLink::new); } } diff --git a/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItem.java b/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItem.java index d64daf66..37b66428 100644 --- a/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItem.java +++ b/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItem.java @@ -372,6 +372,8 @@ public void registerSubItems() { TOOL_DATA_DEEP_MINER = addItem(616, "tool.data.deep_miner").addComponents(new MinerDataItemBehavior(false)); + COVER_ENDER_ITEM_LINK = addItem(620, "cover.ender.item_link"); + PYROLYTIC_CARBON = addItem(16, "pyrolytic_carbon"); MICA_SHEET = addItem(26, "mica_sheet"); MICA_INSULATOR_SHEET = addItem(27, "mica_insulator_sheet"); diff --git a/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItems.java b/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItems.java index 45b9d746..3d549d9c 100644 --- a/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItems.java +++ b/src/main/java/com/fulltrix/gcyl/item/GCYLCoreItems.java @@ -431,7 +431,7 @@ public class GCYLCoreItems { public static MetaItem.MetaValueItem TOOL_DATA_DEEP_MINER; public static MetaItem.MetaValueItem TOOL_DATA_DEEP_MINER_MODULE; public static MetaItem.MetaValueItem TOOL_DATA_DEEP_MINER_COMPLEX; - + public static MetaItem.MetaValueItem COVER_ENDER_ITEM_LINK; public static void init() { GCYLCoreItem item = new GCYLCoreItem(); diff --git a/src/main/resources/assets/gcyl/lang/en_us.lang b/src/main/resources/assets/gcyl/lang/en_us.lang index 091b1271..0fc9cc99 100644 --- a/src/main/resources/assets/gcyl/lang/en_us.lang +++ b/src/main/resources/assets/gcyl/lang/en_us.lang @@ -4785,3 +4785,6 @@ tile.gcyl_reactor_casing.cladded_reactor_casing.name=Radiation Safe Casing gcyl.machine.greenhouse_mv.name=Greenhouse (GH) gcyl.machine.greenhouse_uv.name=Industrial Greenhouse (IGH) +metaitem.cover.ender.item_link.name=Ender Item Link Cover +metaitem.cover.ender.item_link.tooltip=Transports §rItems§7 with a §rWireless §dEnder§r Connection§7 as §rCover§7. +cover.conveyor.mode=Conveyor Mode diff --git a/src/main/resources/assets/gregtech/models/item/metaitems/cover.ender.item_link.json b/src/main/resources/assets/gregtech/models/item/metaitems/cover.ender.item_link.json new file mode 100644 index 00000000..2e602397 --- /dev/null +++ b/src/main/resources/assets/gregtech/models/item/metaitems/cover.ender.item_link.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "gregtech:items/metaitems/cover.ender.item_link" + } +} \ No newline at end of file diff --git a/src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link.png b/src/main/resources/assets/gregtech/textures/blocks/cover/overlay_ender_item_link.png new file mode 100644 index 0000000000000000000000000000000000000000..bf0d35587ceb404f1008f9f839b7a420d050d742 GIT binary patch literal 1407 zcmV-_1%UdAP)Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!vFvd!vV){sAK>D1r$j{K~!i%?U~Dq z990y?zk2thx;x!Hof(r%+R023!Mp^SB)HIEkhs=`Zd`~PaiI&rjS%z?kZgT{2wAvM z+_+G|peQ6Dgs2P|O~y=;o|*3HcURZ@UQe}69#gZp!t~1epsB9vd(VB;Ilnrm8i^o{ zkN0%`<+EJo9I_-qQRqn5WQjwemI^rD`uvB7`l#dMJw=^ASer%Y+L%A`98}dnud|NS zaDdlJm&UE`D;nS-DKr`nL-@lkmM?#S>({>@+aUD&GFq%OR2hL1*)Wg3x<463vr z5)CDjfmc8IX`6*4`oAmY6g$F$3!O5>k1T~fA4bZ=qfeiPsVR7I<>I*2eQgs9G%D95 z*fIjU3%gxIcd3Ea?T$DPvPPA@5m>w-m}jA}ejUBdzBmt5RY$g5g-l%F6h)zHAq-q` z9_05Hv1j2Z)NBz-x&XtRf}~mEJkV4JbI12#s(Kt68Idv}WGzg1kZ5v>ImLhFLCnB= zFFngYT$v7#HdUKCGV;Pm*}@FoDgKN%KfCl$pKW4+Bfal2>I}HUHoSfVzSGCyBWJ{U z5YkkcZzJe$f;j_JrVm2XHE|wfD{~0LfM8?0#qj~95@NBl*a1iAHmmFf;Z-uHFJi6*9)Q|w5+@Kt9K9hD$C#2yvggNPx(UP(kjRA_>`Gs1MSb>%}XvxHOU-obHvMhDvjlQBQv{Or(p$0X2FQcQ+Cxcv?G%sfGBk%n70 zR$vrh+n^OiyoXGNs4S*->f-bQ&#R-tHaZ)l09_U&2iwyNW}8ct%_XwsvqT%eqGUml zMbit)opqeWHO{>D7JBqL_wV1qN+X6wMMcF?z}OGkSKn1-VF@`Z@Pm+NuUsZ{ZEk(~ z(RBU5(yk!Ul*tg4j2PbQleYt71(xYz!|wtbolj7COn>_~M!V)T8U>Ey(dcxsygFJ~ z$Sg*dnNeVzLUXyztTRv4dxXp;_~AUlji;}`byC*OuQ1;|kK1S?>JrP9MnOfz(ZJXb zj$eAepcXob&?v0{Xtb8t{Pv4O7 zAuN_wUc&WUqrluy7S@omMCAzxfl`Widvkh$FC{XIvAh7=Z;-2kUhm=bQ`n1o2;0G% zStOWU#I+oPyfg|bDvk!mesJc4Pl{w*DxLXWHr_`$v9dfR`rmzhC_Bb1xb0PEGVC)N ztRrQP<#?9m81H2kB#-ym-@Hc|?<0hT8U@BUZ#}t78SjBAal9I>`7YfvuTEcq zJtJ`3XV6;F?5uKZZEyG~A}x8gl3HPt2^mNPvaCaNIc7+)#oh`N0lFa=>7) zf!8@f5O$1HFt1RW3kcW6QW8~W6ypJTJ~0Z+Tb?wbzHpM%Yfwae5Ee-Da^Jk+z{YDH zquG6#G@Gz~?|X!88wC{=M+0L&Sbh6Fm4r=^?Pj<^$jOTrxqRt_{_@(J)2$D5ZAqvo zCm(H4BqP$@oI7`)7;k3YFG!zkyopLj2e6t1oal9frHi(ij;hRg9J-Y zEoiNV$owQ*qaGkos$`OG8XJPKBh9WYV9g0^Kg0{?P(i9iv1eW+Ra6`ajF0DqtJn2` zqmh1{G#Qak2H3)8|A!mXohQa&NRk|o_8yW?hM*K~*fv&R3{x;OkIZB8(H?TVkIWNn z%ls+ADDeCS6dAIJQ8LH2ZM;r*dO2)RKQIdV8^2Jd5i%Qt)(BMt-<(F{6r?i&+eWxPP7qS- zoFH7An_gfyJZ&`{g4Pn@;%UNDD=c3ye=@E3ANULQY|>%lp??(s0000Px#1ZP1_K>z@;j|==^1poj532;bRa{vGi!2kdb!2!6DYwZ940ozGLK~y+Tos+>! zR8bVhfA`HiXH08SA_A?^jZrHXQefITEFx&vqOC<+GqJ>lm;_oeX+i7oZzyotP#YIR zpt+FrX$F~N>deBII-PUhx0Uih|Z zFRI1))@CcBDiQf};j6XP!29u&q5F48hToQ4m>wa4!Eqd1$t<_jh&eFyUEGp0gL@#^ zx(=srJPcXjgw`S{2`Txtcaq$4BiWuuoa*jnqL5*HHbX+fCI6{ZOhBV3*=_4&YUUkv z*IHTs@`0L`E^5wRVf0gjh}haih-V;$)n2@ue8A*fiMc1w@Yh%Hi)-xuUX$P9aDm)% z1Lu1BnG*8+VV@f(pK0c6QOs2xPWwFxTD0M#XQc&66s@2)YdjJ+k21B_Pad4UB)@I3v#Dxw5!C} z)e^p!$6x)(_{}meZk6qjMUxjo Date: Sun, 9 Jun 2024 09:58:32 -0500 Subject: [PATCH 03/35] ender item link recipe --- .../gcyl/recipes/categories/MiscRecipes.java | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java index d24c4db4..b2bcc212 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java @@ -1,13 +1,18 @@ package com.fulltrix.gcyl.recipes.categories; +import static com.fulltrix.gcyl.item.GCYLCoreItems.COVER_ENDER_ITEM_LINK; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Americium241; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.ADVANCED_MIXER_RECIPES; import static gregicality.multiblocks.api.unification.GCYMMaterials.Stellite100; +import static gregtech.api.GTValues.*; +import static gregtech.api.recipes.RecipeMaps.ASSEMBLER_RECIPES; import static gregtech.api.recipes.RecipeMaps.MIXER_RECIPES; import static gregtech.api.unification.material.Materials.*; import static gregtech.api.unification.material.Materials.Bismuth; -import static gregtech.api.unification.ore.OrePrefix.dust; +import static gregtech.api.unification.ore.OrePrefix.*; +import static gregtech.common.items.MetaItems.*; +import static gregtech.common.items.MetaItems.COVER_ENDER_FLUID_LINK; public class MiscRecipes { public static void init() { @@ -34,6 +39,17 @@ public static void init() { .circuitMeta(9) .buildAndRegister(); + //Ender Item Link + ASSEMBLER_RECIPES.recipeBuilder() + .input(plate, EnderPearl, 9) + .input(plateDouble, StainlessSteel) + .input(SENSOR_HV) + .input(EMITTER_HV) + .input(ELECTRIC_PISTON_HV) + .fluidInputs(Polyethylene.getFluid(L * 2)) + .output(COVER_ENDER_ITEM_LINK) + .EUt(VA[HV]).duration(320) + .buildAndRegister(); } } From c9771f99726f4238bae885466adb4e2323511569 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 16:21:24 -0500 Subject: [PATCH 04/35] remove cpu from integrated logic circuit with smds --- .../gcyl/recipes/categories/circuits/CircuitRecipes.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index 58c7ef35..526f2dbc 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -20,6 +20,7 @@ public class CircuitRecipes { //TODO: higher tier soldering alloys //TODO: research and/or move circuits to circuit assembly line + //TODO: remove tin as a soldering alloy public static void init() { @@ -80,7 +81,6 @@ private static void electronicCircuits() { .inputs(SMD_RESISTOR_REFINED.getStackForm(4)) .inputs(SMD_CAPACITOR_REFINED.getStackForm(4)) .inputs(GOOD_CIRCUIT_BOARD.getStackForm()) - .inputs(CENTRAL_PROCESSING_UNIT.getStackForm()) .input(wireFine, Copper, 4) .outputs(INTEGRATED_CIRCUIT_LV.getStackForm()) .buildAndRegister(); From 85da6f2f57bab1ff9e20e0232d5315f3354355b1 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 16:27:02 -0500 Subject: [PATCH 05/35] Change Advanced integrated Circuit recipe to require LV superconductor instead of annealed copper wire --- .../gcyl/recipes/categories/circuits/CircuitRecipes.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index 526f2dbc..af2b5e6a 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -21,6 +21,7 @@ public class CircuitRecipes { //TODO: higher tier soldering alloys //TODO: research and/or move circuits to circuit assembly line //TODO: remove tin as a soldering alloy + //TODO: make smd ore prefixes to condense recipes public static void init() { @@ -109,7 +110,7 @@ private static void electronicCircuits() { .inputs(RESISTOR.getStackForm(4)) .inputs(INTEGRATED_LOGIC_CIRCUIT.getStackForm(2)) .input(plate, Aluminium, 2) - .input(wireGtSingle, AnnealedCopper, 4) + .input(wireGtSingle, LVSuperconductor, 4) .outputs(INTEGRATED_CIRCUIT_HV.getStackForm()) .buildAndRegister(); @@ -119,7 +120,7 @@ private static void electronicCircuits() { .inputs(SMD_RESISTOR_REFINED.getStackForm(2)) .inputs(INTEGRATED_LOGIC_CIRCUIT.getStackForm(2)) .input(plate, Aluminium, 2) - .input(wireGtSingle, AnnealedCopper, 4) + .input(wireGtSingle, LVSuperconductor, 4) .outputs(INTEGRATED_CIRCUIT_HV.getStackForm()) .buildAndRegister(); } From 64ec86f4e753fbc5472dc5645ae62715fb0786e0 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 16:49:00 -0500 Subject: [PATCH 06/35] Require micro smds to need a Cleanroom and change recipes EU/t to MV --- .../recipes/categories/RecipeOverride.java | 25 ++++++ .../circuits/CircuitComponentRecipes.java | 81 ++++++++++++++++++- 2 files changed, 105 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 6a04526c..6708129b 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -268,6 +268,31 @@ private static void recipeRemoval() { //raw crystal chip parts removeRecipesByInputs(FORGE_HAMMER_RECIPES, RAW_CRYSTAL_CHIP.getStackForm()); + //MICRO SMDS + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,Carbon), OreDictUnifier.get(wireFine, Electrum, 4)}, new FluidStack[]{Polyethylene.getFluid(L * 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,Carbon), OreDictUnifier.get(wireFine, Tantalum, 4)}, new FluidStack[]{Polyethylene.getFluid(L * 2)}); + + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,GalliumArsenide), OreDictUnifier.get(wireFine, Platinum, 8)}, new FluidStack[]{Polyethylene.getFluid(L * 2)}); + + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,Gallium), OreDictUnifier.get(wireFine, AnnealedCopper, 8)}, new FluidStack[]{Polyethylene.getFluid(L)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,Gallium), OreDictUnifier.get(wireFine, Tantalum, 8)}, new FluidStack[]{Polyethylene.getFluid(L)}); + + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,SiliconeRubber), OreDictUnifier.get(foil, Aluminium)}, new FluidStack[]{Polyethylene.getFluid(L / 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,PolyvinylChloride,2), OreDictUnifier.get(foil, Aluminium)}, new FluidStack[]{Polyethylene.getFluid(L / 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,SiliconeRubber), OreDictUnifier.get(foil, Tantalum)}, new FluidStack[]{Polyethylene.getFluid(L / 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,PolyvinylChloride,2), OreDictUnifier.get(foil, Tantalum)}, new FluidStack[]{Polyethylene.getFluid(L / 2)}); + + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(ring,NickelZincFerrite), OreDictUnifier.get(wireFine, Cupronickel, 4)}, new FluidStack[]{Polyethylene.getFluid(L)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,NickelZincFerrite), OreDictUnifier.get(wireFine, Tantalum, 4)}, new FluidStack[]{Polyethylene.getFluid(L)}); + + //ADVANCED SMDS + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,Graphene), OreDictUnifier.get(wireFine, Platinum, 4)}, new FluidStack[]{Polybenzimidazole.getFluid(L * 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,IndiumGalliumPhosphide), OreDictUnifier.get(wireFine, NiobiumTitanium, 16)}, new FluidStack[]{Polybenzimidazole.getFluid(L * 2)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,VanadiumGallium), OreDictUnifier.get(wireFine, HSSG, 8)}, new FluidStack[]{Polybenzimidazole.getFluid(L)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,Polybenzimidazole), OreDictUnifier.get(foil, HSSS)}, new FluidStack[]{Polybenzimidazole.getFluid(L * 2)}); + + + } public static void chemistryOverride() { diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java index ba0e5006..0b66fd3b 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java @@ -6,7 +6,7 @@ import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.item.GCYLCoreItems.*; import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Plutonium; -import static gregtech.api.GTValues.L; +import static gregtech.api.GTValues.*; import static gregtech.api.recipes.GTRecipeHandler.removeRecipesByInputs; import static gregtech.api.recipes.RecipeMaps.*; import static gregtech.api.unification.material.Materials.*; @@ -19,6 +19,7 @@ public static void init() { // TODO //primitiveSMD(); refinedSMD(); + microSMD(); nanoSMD(); quantumSMD(); CrystalComponents.init(); @@ -66,6 +67,84 @@ private static void refinedSMD() { .buildAndRegister(); } + private static void microSMD() { + // SMD Resistor + ASSEMBLER_RECIPES.recipeBuilder() + .input(dust, Carbon) + .input(wireFine, Electrum, 4) + .fluidInputs(Polyethylene.getFluid(L * 2)) + .output(SMD_RESISTOR, 16) + .cleanroom(CleanroomType.CLEANROOM) + .duration(160).EUt(VA[MV]).buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder() + .input(dust, Carbon) + .input(wireFine, Tantalum, 4) + .fluidInputs(Polyethylene.getFluid(L * 2)) + .output(SMD_RESISTOR, 32) + .cleanroom(CleanroomType.CLEANROOM) + .duration(160).EUt(VA[MV]).buildAndRegister(); + + // SMD Diode + ASSEMBLER_RECIPES.recipeBuilder() + .input(dust, GalliumArsenide) + .input(wireFine, Platinum, 8) + .fluidInputs(Polyethylene.getFluid(L * 2)) + .output(SMD_DIODE, 32) + .cleanroom(CleanroomType.CLEANROOM) + .duration(200).EUt(VA[MV]).buildAndRegister(); + + // SMD Transistor + ASSEMBLER_RECIPES.recipeBuilder() + .input(plate, Gallium) + .input(wireFine, AnnealedCopper, 8) + .fluidInputs(Polyethylene.getFluid(L)) + .output(SMD_TRANSISTOR, 16) + .cleanroom(CleanroomType.CLEANROOM) + .duration(160).EUt(VA[MV]).buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder() + .input(plate, Gallium) + .input(wireFine, Tantalum, 8) + .fluidInputs(Polyethylene.getFluid(L)) + .output(SMD_TRANSISTOR, 32) + .cleanroom(CleanroomType.CLEANROOM) + .duration(160).EUt(VA[MV]).buildAndRegister(); + + // SMD Capacitor + ASSEMBLER_RECIPES.recipeBuilder() + .input(foil, SiliconeRubber) + .input(foil, Aluminium) + .fluidInputs(Polyethylene.getFluid(L / 2)) + .output(SMD_CAPACITOR, 8) + .cleanroom(CleanroomType.CLEANROOM) + .duration(80).EUt(VA[MV]).buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder() + .input(foil, PolyvinylChloride, 2) + .input(foil, Aluminium) + .fluidInputs(Polyethylene.getFluid(L / 2)) + .output(SMD_CAPACITOR, 12) + .cleanroom(CleanroomType.CLEANROOM) + .duration(80).EUt(VA[MV]).buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder() + .input(foil, SiliconeRubber) + .input(foil, Tantalum) + .fluidInputs(Polyethylene.getFluid(L / 2)) + .output(SMD_CAPACITOR, 16) + .cleanroom(CleanroomType.CLEANROOM) + .duration(120).EUt(VA[MV]).buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder() + .input(foil, PolyvinylChloride, 2) + .input(foil, Tantalum) + .fluidInputs(Polyethylene.getFluid(L / 2)) + .output(SMD_CAPACITOR, 24) + .cleanroom(CleanroomType.CLEANROOM) + .duration(120).EUt(VA[MV]).buildAndRegister(); + } + private static void nanoSMD() { // Transistor From d957cc2b8ba294e162e46367f2568c0f359ae541 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:21:42 -0500 Subject: [PATCH 07/35] Add a recipe for Deep Ore Miner (HV) --- .../machines/MultiblockCraftingRecipes.java | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java index 70e8d687..663bd2b1 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java @@ -4,6 +4,7 @@ import com.fulltrix.gcyl.machines.GCYLTileEntities; import gregtech.api.GTValues; import gregtech.api.recipes.ModHandler; +import gregtech.api.unification.OreDictUnifier; import gregtech.api.unification.material.MarkerMaterials; import gregtech.api.unification.stack.UnificationEntry; import gregtech.common.blocks.BlockBoilerCasing; @@ -373,6 +374,16 @@ private static void otherMultiblockInit() { .EUt(VA[GTValues.UV])) .buildAndRegister(); + //DEEP MINER + ModHandler.addShapedRecipe("gcyl_deep_miner", DEEP_MINER.getStackForm(), + "SCS", "AHB", "SGS", + 'S', SENSOR_HV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.IV), + 'A', ELECTRIC_PISTON_HV, + 'B', ELECTRIC_PUMP_HV, + 'G', new UnificationEntry(gear, StainlessSteel), + 'H', HULL[GTValues.HV].getStackForm()); + /* From 7a0dbc474788518d21a626fa708a04f18914b068 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:21:49 -0500 Subject: [PATCH 08/35] Remove Chemical Bath Recipes that produce Tungstic Acid --- .../com/fulltrix/gcyl/recipes/categories/RecipeOverride.java | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 6708129b..1a352914 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -291,7 +291,9 @@ private static void recipeRemoval() { removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,VanadiumGallium), OreDictUnifier.get(wireFine, HSSG, 8)}, new FluidStack[]{Polybenzimidazole.getFluid(L)}); removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(foil,Polybenzimidazole), OreDictUnifier.get(foil, HSSS)}, new FluidStack[]{Polybenzimidazole.getFluid(L * 2)}); - + //Tungstic Acid + removeRecipesByInputs(CHEMICAL_BATH_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Scheelite,6)}, new FluidStack[]{HydrochloricAcid.getFluid(2000)}); + removeRecipesByInputs(CHEMICAL_BATH_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Tungstate,7)}, new FluidStack[]{HydrochloricAcid.getFluid(2000)}); } From a1eebd796e00c48d185c34c0931b90b8c268438b Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:25:58 -0500 Subject: [PATCH 09/35] Add scanner research to Quantum Mainframe --- .../gcyl/recipes/categories/circuits/CircuitRecipes.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index af2b5e6a..70b74328 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -1,6 +1,7 @@ package com.fulltrix.gcyl.recipes.categories.circuits; +import gregtech.api.GTValues; import gregtech.api.metatileentity.multiblock.CleanroomType; import gregtech.api.recipes.ModHandler; import gregtech.api.unification.stack.UnificationEntry; @@ -402,6 +403,9 @@ private static void quantumCircuits() { .input(wireGtSingle, IVSuperconductor, 16) .outputs(QUANTUM_MAINFRAME_ZPM.getStackForm()) .cleanroom(CleanroomType.CLEANROOM) + .scannerResearch(b -> b + .researchStack(QUANTUM_COMPUTER_LUV.getStackForm()) + .EUt(GTValues.VA[GTValues.IV])) .buildAndRegister(); } From a961b789e01d56f4f8ff29504d2c1946ac5b3296 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:26:52 -0500 Subject: [PATCH 10/35] Add scanner research to Crystal Supercomputer --- .../gcyl/recipes/categories/circuits/CircuitRecipes.java | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index 70b74328..ec075076 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -458,6 +458,9 @@ private static void crystalCircuits() { .input(wireGtSingle, LuVSuperconductor, 16) .outputs(CRYSTAL_COMPUTER_ZPM.getStackForm()) .cleanroom(CleanroomType.CLEANROOM) + .scannerResearch(b -> b + .researchStack(CRYSTAL_ASSEMBLY_LUV.getStackForm()) + .EUt(GTValues.VA[GTValues.LuV])) .buildAndRegister(); // Crystal Mainframe From 6e023f93c7ee658b8678f26b1e957cce20e84d4d Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:27:44 -0500 Subject: [PATCH 11/35] Remove trinium from Research Station recipe --- .../com/fulltrix/gcyl/recipes/categories/RecipeOverride.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 1a352914..25ff662e 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -755,7 +755,7 @@ public static void gregtechOverride() { .input(FIELD_GENERATOR_LuV, 2) .input(ELECTRIC_MOTOR_ZPM, 2) .input(wireGtDouble, ZPMSuperconductor, 32) - .input(foil, Trinium, 32) + .input(foil, Rutherfordium, 32) .input(OPTICAL_PIPES[0], 16) .fluidInputs(SolderingAlloy.getFluid(L * 8)) .fluidInputs(VanadiumGallium.getFluid(L * 8)) From 4556ea60090922130859ed884c41e290babebab9 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:29:35 -0500 Subject: [PATCH 12/35] Add research station research to Crystal Mainframe --- .../gcyl/recipes/categories/circuits/CircuitRecipes.java | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index ec075076..23bf6523 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -475,6 +475,10 @@ private static void crystalCircuits() { .input(frameGt, HSSE, 4) .input(wireGtSingle, LuVSuperconductor, 32) .outputs(CRYSTAL_MAINFRAME_UV.getStackForm()) + .stationResearch(b -> b + .researchStack(CRYSTAL_COMPUTER_ZPM.getStackForm()) + .CWUt(16) + .EUt(GTValues.VA[GTValues.LuV])) .cleanroom(CleanroomType.CLEANROOM) .buildAndRegister(); } From 4330343d35e9a0bc3130d77c267de998876a58fe Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:37:56 -0500 Subject: [PATCH 13/35] Add research station research to Wetware Assembly Add research station research to Wetware Supercomputer Add research station research to Wetware Mainframe --- .../recipes/categories/circuits/CircuitRecipes.java | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index 23bf6523..5c5a6fb0 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -521,6 +521,10 @@ private static void wetwareCircuits() { .fluidInputs(SterileGrowthMedium.getFluid(2000)) .outputs(WETWARE_PROCESSOR_ASSEMBLY_ZPM.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(WETWARE_PROCESSOR_LUV.getStackForm()) + .CWUt(16) + .EUt(GTValues.VA[GTValues.ZPM])) .buildAndRegister(); // Wetware Supercomputer @@ -538,6 +542,10 @@ private static void wetwareCircuits() { .fluidInputs(SterileGrowthMedium.getFluid(2000)) .outputs(WETWARE_SUPER_COMPUTER_UV.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(WETWARE_PROCESSOR_ASSEMBLY_ZPM.getStackForm()) + .CWUt(32) + .EUt(GTValues.VA[GTValues.ZPM])) .buildAndRegister(); // Wetware Mainframe @@ -558,6 +566,10 @@ private static void wetwareCircuits() { .fluidInputs(UUMatter.getFluid(100)) .outputs(WETWARE_MAINFRAME_UHV.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(WETWARE_SUPER_COMPUTER_UV.getStackForm()) + .CWUt(64) + .EUt(GTValues.VA[GTValues.ZPM])) .buildAndRegister(); } From a687d53a44621a29805dbb29a792743e479c03aa Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 17:44:04 -0500 Subject: [PATCH 14/35] Remove Indium concentrate recipe --- .../com/fulltrix/gcyl/recipes/categories/RecipeOverride.java | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 25ff662e..fa0e9cf3 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -295,6 +295,8 @@ private static void recipeRemoval() { removeRecipesByInputs(CHEMICAL_BATH_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Scheelite,6)}, new FluidStack[]{HydrochloricAcid.getFluid(2000)}); removeRecipesByInputs(CHEMICAL_BATH_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Tungstate,7)}, new FluidStack[]{HydrochloricAcid.getFluid(2000)}); + //indium concentrate + removeRecipesByInputs(MIXER_RECIPES, new ItemStack[]{OreDictUnifier.get(crushedPurified, Sphalerite), OreDictUnifier.get(crushedPurified, Galena)}, new FluidStack[]{SulfuricAcid.getFluid(4000)}); } public static void chemistryOverride() { From eae140176527733ccfa16741a889585390c53161 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 18:02:56 -0500 Subject: [PATCH 15/35] Add research station research to all Bioware Circuits above Processor --- .../circuits/CircuitComponentRecipes.java | 1 + .../categories/circuits/CircuitRecipes.java | 16 ++++++++++++++-- 2 files changed, 15 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java index 0b66fd3b..29b59c6e 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitComponentRecipes.java @@ -1,6 +1,7 @@ package com.fulltrix.gcyl.recipes.categories.circuits; import com.fulltrix.gcyl.recipes.categories.circuits.components.*; +import gregtech.api.GTValues; import gregtech.api.metatileentity.multiblock.CleanroomType; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java index 5c5a6fb0..8a379fc4 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/circuits/CircuitRecipes.java @@ -523,7 +523,7 @@ private static void wetwareCircuits() { .cleanroom(CleanroomType.STERILE_CLEANROOM) .stationResearch(b -> b .researchStack(WETWARE_PROCESSOR_LUV.getStackForm()) - .CWUt(16) + .CWUt(32) .EUt(GTValues.VA[GTValues.ZPM])) .buildAndRegister(); @@ -544,7 +544,7 @@ private static void wetwareCircuits() { .cleanroom(CleanroomType.STERILE_CLEANROOM) .stationResearch(b -> b .researchStack(WETWARE_PROCESSOR_ASSEMBLY_ZPM.getStackForm()) - .CWUt(32) + .CWUt(48) .EUt(GTValues.VA[GTValues.ZPM])) .buildAndRegister(); @@ -606,6 +606,10 @@ private static void biowareCircuits() { .fluidInputs(NaquadahEnriched.getFluid(L * 9)) .outputs(BIOWARE_ASSEMBLY.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(BIOWARE_PROCESSOR.getStackForm()) + .CWUt(64) + .EUt(GTValues.VA[GTValues.UV])) .buildAndRegister(); // Bioware Computer @@ -627,6 +631,10 @@ private static void biowareCircuits() { .fluidInputs(NaquadahEnriched.getFluid(L * 9)) .outputs(BIOWARE_COMPUTER.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(BIOWARE_ASSEMBLY.getStackForm()) + .CWUt(96) + .EUt(GTValues.VA[GTValues.UV])) .buildAndRegister(); // Bioware Mainframe @@ -650,6 +658,10 @@ private static void biowareCircuits() { .fluidInputs(Naquadria.getFluid(L * 9)) .outputs(BIOWARE_MAINFRAME.getStackForm()) .cleanroom(CleanroomType.STERILE_CLEANROOM) + .stationResearch(b -> b + .researchStack(BIOWARE_COMPUTER.getStackForm()) + .CWUt(128) + .EUt(GTValues.VA[GTValues.UV])) .buildAndRegister(); } From 0254692465854e5528efcc1a0d1dbf7927879be8 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 18:10:17 -0500 Subject: [PATCH 16/35] remove indium from indium concentrate --- .../gcyl/recipes/categories/RecipeOverride.java | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index fa0e9cf3..2eab0213 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -297,6 +297,16 @@ private static void recipeRemoval() { //indium concentrate removeRecipesByInputs(MIXER_RECIPES, new ItemStack[]{OreDictUnifier.get(crushedPurified, Sphalerite), OreDictUnifier.get(crushedPurified, Galena)}, new FluidStack[]{SulfuricAcid.getFluid(4000)}); + + //indium from concentrate + removeRecipesByInputs(CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 4), getIntegratedCircuit(1)}, new FluidStack[]{IndiumConcentrate.getFluid(1000)}); + removeRecipesByInputs(LARGE_CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 4), getIntegratedCircuit(1)}, new FluidStack[]{IndiumConcentrate.getFluid(1000)}); + removeRecipesByInputs(CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 16), getIntegratedCircuit(4)}, new FluidStack[]{IndiumConcentrate.getFluid(4000)}); + removeRecipesByInputs(LARGE_CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 16), getIntegratedCircuit(4)}, new FluidStack[]{IndiumConcentrate.getFluid(4000)}); + + //fusion casings + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{HULL[GTValues.LuV].getStackForm(), FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL), NEUTRON_REFLECTOR.getStackForm(), ELECTRIC_PUMP_LuV.getStackForm(), OreDictUnifier.get(plate, TungstenSteel)}, new FluidStack[]{Polybenzimidazole.getFluid(144)}); + } public static void chemistryOverride() { From 91c4172fd37af326428dc3a72e21ff50341cbe07 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 18:44:13 -0500 Subject: [PATCH 17/35] Fix Superconducting Coil recipe --- .../recipes/categories/RecipeOverride.java | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 2eab0213..05d2c676 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -1,6 +1,7 @@ package com.fulltrix.gcyl.recipes.categories; import gregtech.api.GTValues; +import gregtech.api.fluids.store.FluidStorageKeys; import gregtech.api.items.armor.ArmorMetaItem; import gregtech.api.metatileentity.multiblock.CleanroomType; import gregtech.api.recipes.ModHandler; @@ -9,7 +10,9 @@ import gregtech.api.unification.OreDictUnifier; import gregtech.api.unification.material.MarkerMaterials; import gregtech.api.unification.stack.UnificationEntry; +import gregtech.common.ConfigHolder; import gregtech.common.blocks.BlockComputerCasing; +import gregtech.common.blocks.BlockFusionCasing; import gregtech.common.blocks.MetaBlocks; import gregtech.common.items.MetaItems; import gregtech.common.metatileentities.MetaTileEntities; @@ -304,6 +307,13 @@ private static void recipeRemoval() { removeRecipesByInputs(CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 16), getIntegratedCircuit(4)}, new FluidStack[]{IndiumConcentrate.getFluid(4000)}); removeRecipesByInputs(LARGE_CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Aluminium, 16), getIntegratedCircuit(4)}, new FluidStack[]{IndiumConcentrate.getFluid(4000)}); + //superconductor coil block + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, IndiumTinBariumTitaniumCuprate, 32), OreDictUnifier.get(foil, NiobiumTitanium, 32)}, new FluidStack[]{Trinium.getFluid(3456)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, UraniumRhodiumDinaquadide, 16), OreDictUnifier.get(foil, NiobiumTitanium, 16)}, new FluidStack[]{Trinium.getFluid(2304)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, EnrichedNaquadahTriniumEuropiumDuranide, 8), OreDictUnifier.get(foil, NiobiumTitanium, 8)}, new FluidStack[]{Trinium.getFluid(1152)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, RutheniumTriniumAmericiumNeutronate, 4), OreDictUnifier.get(foil, NiobiumTitanium, 4)}, new FluidStack[]{Trinium.getFluid(576)}); + + //fusion casings removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{HULL[GTValues.LuV].getStackForm(), FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL), NEUTRON_REFLECTOR.getStackForm(), ELECTRIC_PUMP_LuV.getStackForm(), OreDictUnifier.get(plate, TungstenSteel)}, new FluidStack[]{Polybenzimidazole.getFluid(144)}); @@ -1055,5 +1065,64 @@ public static void gregtechOverride() { ModHandler.addShapedRecipe(true, "electric_motor_iv", ELECTRIC_MOTOR_IV.getStackForm(), "CWR", "WMW", "RWC", 'C', new UnificationEntry(cableGtDouble, Tungsten), 'W', new UnificationEntry(wireGtQuadruple, BrightSteel), 'R', new UnificationEntry(stick, TungstenSteel), 'M', new UnificationEntry(stick, NeodymiumMagnetic)); + + //Superconductor Coil Block + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.LuV]).duration(100) + .input(wireGtSingle, LuVSuperconductor, 16) + .input(plate, Osmiridium, 16) + .fluidInputs(Helium.getFluid(FluidStorageKeys.LIQUID, 8000)) + .cleanroom(CleanroomType.CLEANROOM) + .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.ZPM]).duration(100) + .input(wireGtSingle, ZPMSuperconductor, 8) + .input(plate, Rutherfordium, 8) + .fluidInputs(Argon.getFluid(FluidStorageKeys.LIQUID, 4000)) + .cleanroom(CleanroomType.CLEANROOM) + .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UV]).duration(100) + .input(wireGtSingle, UVSuperconductor, 4) + .input(plate, Dubnium, 4) + .fluidInputs(Krypton.getFluid(FluidStorageKeys.LIQUID, 2000)) + .cleanroom(CleanroomType.CLEANROOM) + .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UHV]).duration(100) + .input(wireGtSingle, UHVSuperconductor, 2) + .input(plate, Tennessine, 2) + .fluidInputs(Radon.getFluid(FluidStorageKeys.LIQUID, 1000)) + .cleanroom(CleanroomType.CLEANROOM) + .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UEV]).duration(100) + .input(wireGtSingle, UEVSuperconductor, 1) + .input(plate, Bohrium, 1) + .fluidInputs(Xenon.getFluid(FluidStorageKeys.LIQUID, 500)) + .cleanroom(CleanroomType.CLEANROOM) + .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .buildAndRegister(); + + //Fusion casings + ASSEMBLY_LINE_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.LuV]).duration(100) + .inputs(HULL[GTValues.LuV].getStackForm()) + .inputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) + .inputs(NEUTRON_REFLECTOR.getStackForm()) + .inputs(FIELD_GENERATOR_LuV.getStackForm()) + .inputs(VOLTAGE_COIL_LuV.getStackForm(2)) + .input(plate, Osmiridium, 6) + .fluidInputs(Polybenzimidazole.getFluid(L * 4)) + .outputs(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING, ConfigHolder.recipes.casingsPerCraft)) + .buildAndRegister(); + + + + + + } } From 3e9546a8d88d76f78630329e24d09b8772156852 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 19:25:07 -0500 Subject: [PATCH 18/35] Change Fusion Casing MK2 to use Rutherfordium Plates and ZPM field generator Change Fusion Casing MK3 to use Tritanium Plates and UV field generator Change Fusion Casing Recipes to be in the Assline --- .../recipes/categories/RecipeOverride.java | 54 ++++++++++++++----- 1 file changed, 42 insertions(+), 12 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 05d2c676..64667fce 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -13,6 +13,7 @@ import gregtech.common.ConfigHolder; import gregtech.common.blocks.BlockComputerCasing; import gregtech.common.blocks.BlockFusionCasing; +import gregtech.common.blocks.BlockMachineCasing; import gregtech.common.blocks.MetaBlocks; import gregtech.common.items.MetaItems; import gregtech.common.metatileentities.MetaTileEntities; @@ -41,6 +42,7 @@ import static gregtech.common.items.MetaItems.GRAVITATION_ENGINE; import static gregtech.common.metatileentities.MetaTileEntities.*; import static gregtech.integration.crafttweaker.recipe.CTRecipeUtils.removeAll; +import static gregtech.loaders.recipe.CraftingComponent.CASING; public class RecipeOverride { public static void init() { @@ -313,9 +315,10 @@ private static void recipeRemoval() { removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, EnrichedNaquadahTriniumEuropiumDuranide, 8), OreDictUnifier.get(foil, NiobiumTitanium, 8)}, new FluidStack[]{Trinium.getFluid(1152)}); removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{OreDictUnifier.get(wireGtDouble, RutheniumTriniumAmericiumNeutronate, 4), OreDictUnifier.get(foil, NiobiumTitanium, 4)}, new FluidStack[]{Trinium.getFluid(576)}); - //fusion casings - removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{HULL[GTValues.LuV].getStackForm(), FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL), NEUTRON_REFLECTOR.getStackForm(), ELECTRIC_PUMP_LuV.getStackForm(), OreDictUnifier.get(plate, TungstenSteel)}, new FluidStack[]{Polybenzimidazole.getFluid(144)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{MetaBlocks.MACHINE_CASING.getItemVariant(BlockMachineCasing.MachineCasingType.LuV), FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL), NEUTRON_REFLECTOR.getStackForm(), ELECTRIC_PUMP_LuV.getStackForm(), OreDictUnifier.get(plate, TungstenSteel, 6)}, new FluidStack[]{Polybenzimidazole.getFluid(144)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{MetaBlocks.MACHINE_CASING.getItemVariant(BlockMachineCasing.MachineCasingType.ZPM), FUSION_CASING.getItemVariant(FUSION_COIL), VOLTAGE_COIL_ZPM.getStackForm(2), FIELD_GENERATOR_LuV.getStackForm(), OreDictUnifier.get(plate, Europium, 6)}, new FluidStack[]{Polybenzimidazole.getFluid(288)}); + removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{MetaBlocks.MACHINE_CASING.getItemVariant(BlockMachineCasing.MachineCasingType.UV), FUSION_CASING.getItemVariant(FUSION_COIL), VOLTAGE_COIL_UV.getStackForm(2), FIELD_GENERATOR_ZPM.getStackForm(), OreDictUnifier.get(plate, Americium, 6)}, new FluidStack[]{Polybenzimidazole.getFluid(576)}); } @@ -1066,11 +1069,11 @@ public static void gregtechOverride() { 'C', new UnificationEntry(cableGtDouble, Tungsten), 'W', new UnificationEntry(wireGtQuadruple, BrightSteel), 'R', new UnificationEntry(stick, TungstenSteel), 'M', new UnificationEntry(stick, NeodymiumMagnetic)); - //Superconductor Coil Block + //Superconductor Coil Block //TODO change these to use liquid version of gas instead ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.LuV]).duration(100) .input(wireGtSingle, LuVSuperconductor, 16) .input(plate, Osmiridium, 16) - .fluidInputs(Helium.getFluid(FluidStorageKeys.LIQUID, 8000)) + .fluidInputs(Helium.getFluid( 8000)) .cleanroom(CleanroomType.CLEANROOM) .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .buildAndRegister(); @@ -1078,7 +1081,7 @@ public static void gregtechOverride() { ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.ZPM]).duration(100) .input(wireGtSingle, ZPMSuperconductor, 8) .input(plate, Rutherfordium, 8) - .fluidInputs(Argon.getFluid(FluidStorageKeys.LIQUID, 4000)) + .fluidInputs(Argon.getFluid(4000)) .cleanroom(CleanroomType.CLEANROOM) .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .buildAndRegister(); @@ -1086,7 +1089,7 @@ public static void gregtechOverride() { ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UV]).duration(100) .input(wireGtSingle, UVSuperconductor, 4) .input(plate, Dubnium, 4) - .fluidInputs(Krypton.getFluid(FluidStorageKeys.LIQUID, 2000)) + .fluidInputs(Krypton.getFluid(2000)) .cleanroom(CleanroomType.CLEANROOM) .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .buildAndRegister(); @@ -1094,7 +1097,7 @@ public static void gregtechOverride() { ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UHV]).duration(100) .input(wireGtSingle, UHVSuperconductor, 2) .input(plate, Tennessine, 2) - .fluidInputs(Radon.getFluid(FluidStorageKeys.LIQUID, 1000)) + .fluidInputs(Radon.getFluid(1000)) .cleanroom(CleanroomType.CLEANROOM) .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .buildAndRegister(); @@ -1102,25 +1105,52 @@ public static void gregtechOverride() { ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UEV]).duration(100) .input(wireGtSingle, UEVSuperconductor, 1) .input(plate, Bohrium, 1) - .fluidInputs(Xenon.getFluid(FluidStorageKeys.LIQUID, 500)) + .fluidInputs(Xenon.getFluid( 500)) .cleanroom(CleanroomType.CLEANROOM) .outputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .buildAndRegister(); - //Fusion casings + //Fusion casings //TODO: MIGHT BE TOO EXPENSIVE, change output count to ConfigHolder.recipes.casingsPerCraft ASSEMBLY_LINE_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.LuV]).duration(100) .inputs(HULL[GTValues.LuV].getStackForm()) .inputs(FUSION_CASING.getItemVariant(SUPERCONDUCTOR_COIL)) .inputs(NEUTRON_REFLECTOR.getStackForm()) .inputs(FIELD_GENERATOR_LuV.getStackForm()) .inputs(VOLTAGE_COIL_LuV.getStackForm(2)) - .input(plate, Osmiridium, 6) + .input(plate, Osmiridium, 2) .fluidInputs(Polybenzimidazole.getFluid(L * 4)) - .outputs(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING, ConfigHolder.recipes.casingsPerCraft)) + .fluidInputs(Indalloy140.getFluid(L * 2)) + .outputs(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING, 1)) + .cleanroom(CleanroomType.CLEANROOM) .buildAndRegister(); + ASSEMBLY_LINE_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.ZPM]).duration(100) + .inputs(HULL[GTValues.ZPM].getStackForm()) + .inputs(FUSION_CASING.getItemVariant(FUSION_COIL)) + .inputs(FIELD_GENERATOR_ZPM.getStackForm()) + .inputs(VOLTAGE_COIL_ZPM.getStackForm(2)) + .input(plate, Rutherfordium, 2) + .fluidInputs(Polybenzimidazole.getFluid(L * 8)) + .fluidInputs(Indalloy140.getFluid(L * 4)) + .outputs(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING_MK2, 1)) + .cleanroom(CleanroomType.CLEANROOM) + .buildAndRegister(); - + ASSEMBLY_LINE_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.UV]).duration(100) + .inputs(HULL[GTValues.UV].getStackForm()) + .inputs(FUSION_CASING.getItemVariant(FUSION_COIL)) + .inputs(FIELD_GENERATOR_UV.getStackForm(2)) + .inputs(VOLTAGE_COIL_UV.getStackForm(2)) + .input(plate, Tritanium, 2) + .fluidInputs(Polybenzimidazole.getFluid(L * 16)) + .fluidInputs(Indalloy140.getFluid(L * 8)) + .outputs(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING_MK3, 1)) + .cleanroom(CleanroomType.CLEANROOM) + .stationResearch(b->b + .researchStack(FUSION_CASING.getItemVariant(BlockFusionCasing.CasingType.FUSION_CASING_MK2)) + .EUt(GTValues.VA[GTValues.UV]) + .CWUt(32)) + .buildAndRegister(); From 9f85782a01b9f7f4e814b57446f7b03b06843223 Mon Sep 17 00:00:00 2001 From: brian Date: Sun, 9 Jun 2024 19:32:02 -0500 Subject: [PATCH 19/35] recipe eu/t fixes for luv-uv field gens --- .../gcyl/recipes/categories/ComponentRecipes.java | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/ComponentRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/ComponentRecipes.java index 619fa82e..5bbe18ea 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/ComponentRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/ComponentRecipes.java @@ -430,7 +430,7 @@ private static void fieldGenInit() { .scannerResearch(b -> b .researchStack(FIELD_GENERATOR_IV.getStackForm()) .duration(2400)) - .duration(600).EUt(VA[GTValues.ZPM]).buildAndRegister(); + .duration(600).EUt(VA[GTValues.LuV]).buildAndRegister(); /* original zpm field gen @@ -457,8 +457,9 @@ private static void fieldGenInit() { .output(FIELD_GENERATOR_ZPM) .stationResearch(b -> b .researchStack(FIELD_GENERATOR_LuV.getStackForm()) - .CWUt(4)) - .duration(600).EUt(VA[GTValues.UV]).buildAndRegister(); + .CWUt(4) + .EUt(VA[GTValues.ZPM])) + .duration(600).EUt(VA[GTValues.ZPM]).buildAndRegister(); /* original uv field gen ASSEMBLY_LINE_RECIPES.recipeBuilder().duration(600).EUt(491520) @@ -487,7 +488,7 @@ private static void fieldGenInit() { .stationResearch(b -> b .researchStack(FIELD_GENERATOR_ZPM.getStackForm()) .CWUt(48) - .EUt(VA[GTValues.UHV])) + .EUt(VA[GTValues.UV])) .duration(600).EUt(491520).buildAndRegister(); From a5ed6756ce80f98b198e88b232ac256045caf02f Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 03:55:07 -0500 Subject: [PATCH 20/35] mat fix --- .../java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index 61d965fb..b6cfb482 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -89,7 +89,7 @@ public static void materialChanges() { //PLATE ADDITIONS List platemats = new ArrayList<>(); - Collections.addAll(platemats, Vanadium); + Collections.addAll(platemats, Vanadium, Tennessine); for (Material mat : platemats) { mat.addFlags(GENERATE_PLATE); } From f07c6983a593d3106139ba4d1054dc988b27825a Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 07:26:25 -0500 Subject: [PATCH 21/35] Add Mega Cleanroom --- .../gcyl/machines/GCYLTileEntities.java | 3 + .../advance/MetaTileEntityMegaCleanroom.java | 397 ++++++++++++++++++ .../machines/MultiblockCraftingRecipes.java | 15 + .../resources/assets/gcyl/lang/en_us.lang | 6 + 4 files changed, 421 insertions(+) create mode 100644 src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java diff --git a/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java b/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java index 49d1d851..48cb1b4e 100644 --- a/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java +++ b/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java @@ -51,6 +51,7 @@ public class GCYLTileEntities { public static MetaTileEntityDeepMiner DEEP_MINER; public static MetaTileEntityDecayChamber DECAY_CHAMBER; public static MetaTileEntityGreenhouse[] GREEN_HOUSE = new MetaTileEntityGreenhouse[2]; + public static MetaTileEntityMegaCleanroom MEGA_CLEANROOM; public static MetaTileEntitySterileCleaningMaintenanceHatch STERILE_CLEANING_MAINTENANCE_HATCH; @@ -115,6 +116,8 @@ public static void init() { GREEN_HOUSE[0] = registerMetaTileEntity(++id, new MetaTileEntityGreenhouse(gcylId("greenhouse_mv"), 2)); GREEN_HOUSE[1] = registerMetaTileEntity(++id, new MetaTileEntityGreenhouse(gcylId("greenhouse_uv"), 8)); + + MEGA_CLEANROOM = registerMetaTileEntity(++id, new MetaTileEntityMegaCleanroom(gcylId("mega_cleanroom"))); //TODO: configurable efficiency for naq reactors, efficiency implementation in general /* diff --git a/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java new file mode 100644 index 00000000..af649c46 --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java @@ -0,0 +1,397 @@ +package com.fulltrix.gcyl.machines.multi.advance; + +import appeng.core.AEConfig; +import appeng.core.features.AEFeature; +import gregtech.api.GTValues; +import gregtech.api.capability.GregtechDataCodes; +import gregtech.api.capability.impl.CleanroomLogic; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.interfaces.IGregTechTileEntity; +import gregtech.api.metatileentity.multiblock.CleanroomType; +import gregtech.api.metatileentity.multiblock.MultiblockAbility; +import gregtech.api.pattern.*; +import gregtech.api.util.Mods; +import gregtech.client.utils.TooltipHelper; +import gregtech.common.ConfigHolder; +import gregtech.common.blocks.BlockCleanroomCasing; +import gregtech.common.blocks.BlockGlassCasing; +import gregtech.common.blocks.MetaBlocks; +import gregtech.common.metatileentities.MetaTileEntities; +import gregtech.common.metatileentities.multi.electric.MetaTileEntityCleanroom; +import net.minecraft.block.BlockDoor; +import net.minecraft.client.resources.I18n; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.PacketBuffer; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import net.minecraftforge.event.world.WorldEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +public class MetaTileEntityMegaCleanroom extends MetaTileEntityCleanroom { + public static final int MIN_RADIUS = 10; + public static final int MIN_DEPTH = 9; + private int lDist = 0; + private int rDist = 0; + private int bDist = 0; + private int fDist = 0; + private int hDist = 0; + private final CleanroomLogic cleanroomLogic; + private CleanroomType cleanroomType = null; + + private boolean initialForm = true; + public MetaTileEntityMegaCleanroom(ResourceLocation metaTileEntityId) { + super(metaTileEntityId); + this.cleanroomLogic = new CleanroomLogic(this, GTValues.LV); + } + + @Override + public MetaTileEntity createMetaTileEntity(IGregTechTileEntity tileEntity) { + return new MetaTileEntityMegaCleanroom(metaTileEntityId); + } + + @Override + public boolean updateStructureDimensions() { + World world = getWorld(); + EnumFacing front = getFrontFacing(); + EnumFacing back = front.getOpposite(); + EnumFacing left = front.rotateYCCW(); + EnumFacing right = left.getOpposite(); + + BlockPos.MutableBlockPos lPos = new BlockPos.MutableBlockPos(getPos()); + BlockPos.MutableBlockPos rPos = new BlockPos.MutableBlockPos(getPos()); + BlockPos.MutableBlockPos fPos = new BlockPos.MutableBlockPos(getPos()); + BlockPos.MutableBlockPos bPos = new BlockPos.MutableBlockPos(getPos()); + BlockPos.MutableBlockPos hPos = new BlockPos.MutableBlockPos(getPos()); + + // find the distances from the controller to the plascrete blocks on one horizontal axis and the Y axis + // repeatable aisles take care of the second horizontal axis + int lDist = 0; + int rDist = 0; + int bDist = 0; + int fDist = 0; + int hDist = 0; + + // find the left, right, back, and front distances for the structure pattern + // maximum size is 15x15x15 including walls, so check 7 block radius around the controller for blocks + for (int i = 1; i < 51; i++) { + if (lDist == 0 && isBlockEdge(world, lPos, left)) lDist = i; + if (rDist == 0 && isBlockEdge(world, rPos, right)) rDist = i; + if (bDist == 0 && isBlockEdge(world, bPos, back)) bDist = i; + if (fDist == 0 && isBlockEdge(world, fPos, front)) fDist = i; + if (lDist != 0 && rDist != 0 && bDist != 0 && fDist != 0) break; + } + + // height is diameter instead of radius, so it needs to be done separately + for (int i = 1; i < 101; i++) { + if (isBlockFloor(world, hPos, EnumFacing.DOWN)) hDist = i; + if (hDist != 0) break; + } + + if (lDist < MIN_RADIUS || rDist < MIN_RADIUS || bDist < MIN_RADIUS || fDist < MIN_RADIUS || hDist < MIN_DEPTH) { + invalidateStructure(); + return false; + } + + this.lDist = lDist; + this.rDist = rDist; + this.bDist = bDist; + this.fDist = fDist; + this.hDist = hDist; + + writeCustomData(GregtechDataCodes.UPDATE_STRUCTURE_SIZE, buf -> { + buf.writeInt(this.lDist); + buf.writeInt(this.rDist); + buf.writeInt(this.bDist); + buf.writeInt(this.fDist); + buf.writeInt(this.hDist); + }); + return true; + } + + /* + @Override + public void update() { + if (getOffsetTimer() % 100 == 0) { + super.update(); + } + } + */ + @SubscribeEvent + public void checkStructurePatternSave(WorldEvent.Save event) { + this.initialForm = true; + super.checkStructurePattern(); + } + + @Override + public void checkStructurePattern() { + if((initialForm) || !isStructureFormed()) { + this.initialForm = false; + super.checkStructurePattern(); + } + } + + @Override + protected void formStructure(PatternMatchContext context) { + super.formStructure(context); + initializeAbilities(); + Object type = context.get("FilterType"); + if (type instanceof BlockCleanroomCasing.CasingType) { + BlockCleanroomCasing.CasingType casingType = (BlockCleanroomCasing.CasingType) type; + + if (casingType.equals(BlockCleanroomCasing.CasingType.FILTER_CASING)) { + this.cleanroomType = CleanroomType.CLEANROOM; + } else if (casingType.equals(BlockCleanroomCasing.CasingType.FILTER_CASING_STERILE)) { + this.cleanroomType = CleanroomType.STERILE_CLEANROOM; + } + } + // max progress is based on the dimensions of the structure: (x^3)-(x^2) + // taller cleanrooms take longer than wider ones + // minimum of 100 is a 5x5x5 cleanroom: 125-25=100 ticks + this.cleanroomLogic.setMaxProgress(Math.max(100, + ((lDist + rDist + 1) * (bDist + fDist + 1) * hDist) - ((lDist + rDist + 1) * (bDist + fDist + 1)))); + } + + @Override + public boolean checkCleanroomType(@NotNull CleanroomType type) { + return type == this.cleanroomType; + } + + @NotNull + @Override + protected BlockPattern createStructurePattern() { + // return the default structure, even if there is no valid size found + // this means auto-build will still work, and prevents terminal crashes. + if (getWorld() != null) updateStructureDimensions(); + + // these can sometimes get set to 0 when loading the game, breaking JEI + if (lDist < MIN_RADIUS) lDist = MIN_RADIUS; + if (rDist < MIN_RADIUS) rDist = MIN_RADIUS; + if (bDist < MIN_RADIUS) bDist = MIN_RADIUS; + if (fDist < MIN_RADIUS) fDist = MIN_RADIUS; + if (hDist < MIN_DEPTH) hDist = MIN_DEPTH; + + if (this.frontFacing == EnumFacing.EAST || this.frontFacing == EnumFacing.WEST) { + int tmp = lDist; + lDist = rDist; + rDist = tmp; + } + + // build each row of the structure + StringBuilder borderBuilder = new StringBuilder(); // BBBBB + StringBuilder wallBuilder = new StringBuilder(); // BXXXB + StringBuilder insideBuilder = new StringBuilder(); // X X + StringBuilder roofBuilder = new StringBuilder(); // BFFFB + StringBuilder controllerBuilder = new StringBuilder(); // BFSFB + StringBuilder centerBuilder = new StringBuilder(); // BXKXB + + // everything to the left of the controller + for (int i = 0; i < lDist; i++) { + borderBuilder.append("B"); + if (i == 0) { + wallBuilder.append("B"); + insideBuilder.append("X"); + roofBuilder.append("B"); + controllerBuilder.append("B"); + centerBuilder.append("B"); + } else { + insideBuilder.append(" "); + wallBuilder.append("X"); + roofBuilder.append("F"); + controllerBuilder.append("F"); + centerBuilder.append("X"); + } + } + + // everything in-line with the controller + borderBuilder.append("B"); + wallBuilder.append("X"); + insideBuilder.append(" "); + roofBuilder.append("F"); + controllerBuilder.append("S"); + centerBuilder.append("K"); + + // everything to the right of the controller + for (int i = 0; i < rDist; i++) { + borderBuilder.append("B"); + if (i == rDist - 1) { + wallBuilder.append("B"); + insideBuilder.append("X"); + roofBuilder.append("B"); + controllerBuilder.append("B"); + centerBuilder.append("B"); + } else { + insideBuilder.append(" "); + wallBuilder.append("X"); + roofBuilder.append("F"); + controllerBuilder.append("F"); + centerBuilder.append("X"); + } + } + + // build each slice of the structure + String[] wall = new String[hDist + 1]; // "BBBBB", "BXXXB", "BXXXB", "BXXXB", "BBBBB" + Arrays.fill(wall, wallBuilder.toString()); + wall[0] = borderBuilder.toString(); + wall[wall.length - 1] = borderBuilder.toString(); + + String[] slice = new String[hDist + 1]; // "BXXXB", "X X", "X X", "X X", "BFFFB" + Arrays.fill(slice, insideBuilder.toString()); + slice[0] = wallBuilder.toString(); + slice[slice.length - 1] = roofBuilder.toString(); + + String[] center = Arrays.copyOf(slice, slice.length); // "BXKXB", "X X", "X X", "X X", "BFSFB" + if (this.frontFacing == EnumFacing.NORTH || this.frontFacing == EnumFacing.SOUTH) { + center[0] = centerBuilder.reverse().toString(); + center[center.length - 1] = controllerBuilder.reverse().toString(); + } else { + center[0] = centerBuilder.toString(); + center[center.length - 1] = controllerBuilder.toString(); + } + + TraceabilityPredicate wallPredicate = states(getCasingState(), getGlassState()); + TraceabilityPredicate basePredicate = autoAbilities().or(abilities(MultiblockAbility.INPUT_ENERGY) + .setMinGlobalLimited(1).setMaxGlobalLimited(3)); + + // layer the slices one behind the next + return FactoryBlockPattern.start() + .aisle(wall) + .aisle(slice).setRepeatable(bDist - 1) + .aisle(center) + .aisle(slice).setRepeatable(fDist - 1) + .aisle(wall) + .where('S', selfPredicate()) + .where('B', states(getCasingState()).or(basePredicate)) + .where('X', wallPredicate.or(basePredicate) + .or(doorPredicate().setMaxGlobalLimited(8)) + .or(abilities(MultiblockAbility.PASSTHROUGH_HATCH).setMaxGlobalLimited(30))) + .where('K', wallPredicate) // the block beneath the controller must only be a casing for structure + // dimension checks + .where('F', filterPredicate()) + .where(' ', innerPredicate()) + .build(); + } + + @Override + public List getMatchingShapes() { + ArrayList shapeInfo = new ArrayList<>(); + MultiblockShapeInfo.Builder builder = MultiblockShapeInfo.builder() + .aisle("XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXIHLXXXXXXXXX", "XXXXXXXXXXDXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFSFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXXXXXXXXXXXXX", "X X", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "G G", "X X", "XFFFFFFFFFFFFFFFFFFFX") + .aisle("XXXXXXXXXMXEXXXXXXXXX", "XXXXXXXXXXOXXXXXXXXXX", "XXXXXXXXXXRXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXX") + .where('X', MetaBlocks.CLEANROOM_CASING.getState(BlockCleanroomCasing.CasingType.PLASCRETE)) + .where('G', MetaBlocks.TRANSPARENT_CASING.getState(BlockGlassCasing.CasingType.CLEANROOM_GLASS)) + .where('S', MetaTileEntities.CLEANROOM, EnumFacing.SOUTH) + .where(' ', Blocks.AIR.getDefaultState()) + .where('E', MetaTileEntities.ENERGY_INPUT_HATCH[GTValues.ZPM], EnumFacing.SOUTH) + .where('I', MetaTileEntities.PASSTHROUGH_HATCH_ITEM, EnumFacing.NORTH) + .where('L', MetaTileEntities.PASSTHROUGH_HATCH_FLUID, EnumFacing.NORTH) + .where('H', MetaTileEntities.HULL[GTValues.HV], EnumFacing.NORTH) + .where('D', MetaTileEntities.DIODES[GTValues.HV], EnumFacing.NORTH) + .where('M', + () -> ConfigHolder.machines.enableMaintenance ? MetaTileEntities.MAINTENANCE_HATCH : + MetaBlocks.CLEANROOM_CASING.getState(BlockCleanroomCasing.CasingType.PLASCRETE), + EnumFacing.SOUTH) + .where('O', + Blocks.IRON_DOOR.getDefaultState().withProperty(BlockDoor.FACING, EnumFacing.NORTH) + .withProperty(BlockDoor.HALF, BlockDoor.EnumDoorHalf.LOWER)) + .where('R', Blocks.IRON_DOOR.getDefaultState().withProperty(BlockDoor.FACING, EnumFacing.NORTH) + .withProperty(BlockDoor.HALF, BlockDoor.EnumDoorHalf.UPPER)); + + Arrays.stream(BlockCleanroomCasing.CasingType.values()) + .filter(casingType -> !casingType.equals(BlockCleanroomCasing.CasingType.PLASCRETE)) + .forEach(casingType -> shapeInfo + .add(builder.where('F', MetaBlocks.CLEANROOM_CASING.getState(casingType)).build())); + return shapeInfo; + } + + @Override + public void addInformation(ItemStack stack, @Nullable World player, List tooltip, boolean advanced) { + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.1")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.2")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.3")); + tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.1")); + tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.2")); + + if (TooltipHelper.isCtrlDown()) { + tooltip.add(""); + tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.3")); + tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.4")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.5")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.6")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.7")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.8")); + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.9")); + if (Mods.AppliedEnergistics2.isModLoaded()) { + tooltip.add(I18n.format(AEConfig.instance().isFeatureEnabled(AEFeature.CHANNELS) ? + "gregtech.machine.cleanroom.tooltip.ae2.channels" : + "gregtech.machine.cleanroom.tooltip.ae2.no_channels")); + } + tooltip.add(""); + } else { + tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.hold_ctrl")); + } + } + + + /* + @Override + public NBTTagCompound writeToNBT(@NotNull NBTTagCompound data) { + super.writeToNBT(data); + data.setBoolean("initialForm", this.initialForm); + return this.cleanroomLogic.writeToNBT(data); + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + this.initialForm = data.hasKey("initialForm") ? data.getBoolean("initialForm") : this.initialForm; + this.cleanroomLogic.readFromNBT(data); + } + + @Override + public void writeInitialSyncData(PacketBuffer buf) { + super.writeInitialSyncData(buf); + buf.writeBoolean(this.initialForm); + this.cleanroomLogic.writeInitialSyncData(buf); + } + + @Override + public void receiveInitialSyncData(PacketBuffer buf) { + super.receiveInitialSyncData(buf); + this.initialForm = buf.readBoolean(); + this.cleanroomLogic.receiveInitialSyncData(buf); + } + + */ + + + +} diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java index 663bd2b1..c658b4c5 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/MultiblockCraftingRecipes.java @@ -384,6 +384,21 @@ private static void otherMultiblockInit() { 'G', new UnificationEntry(gear, StainlessSteel), 'H', HULL[GTValues.HV].getStackForm()); + //MEGA CLEANROOM + ASSEMBLY_LINE_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.ZPM]).duration(400) + .inputs(CLEANROOM.getStackForm(4)) + .input(HULL[GTValues.ZPM]) + .input(rotor, HSSE, 8) + .inputs(ELECTRIC_MOTOR_ZPM.getStackForm(8)) + .input(circuit, MarkerMaterials.Tier.ZPM, 4) + .fluidInputs(Indalloy140.getFluid(L * 8)) + .outputs(MEGA_CLEANROOM.getStackForm()) + .scannerResearch(b->b + .researchStack(CLEANROOM.getStackForm()) + .EUt(GTValues.VA[GTValues.ZPM])) + .buildAndRegister(); + + /* diff --git a/src/main/resources/assets/gcyl/lang/en_us.lang b/src/main/resources/assets/gcyl/lang/en_us.lang index 0fc9cc99..c58fd016 100644 --- a/src/main/resources/assets/gcyl/lang/en_us.lang +++ b/src/main/resources/assets/gcyl/lang/en_us.lang @@ -4788,3 +4788,9 @@ gcyl.machine.greenhouse_uv.name=Industrial Greenhouse (IGH) metaitem.cover.ender.item_link.name=Ender Item Link Cover metaitem.cover.ender.item_link.tooltip=Transports §rItems§7 with a §rWireless §dEnder§r Connection§7 as §rCover§7. cover.conveyor.mode=Conveyor Mode + +gcyl.machine.mega_cleanroom.name=Mega Cleanroom (MC) +gcyl.machine.cleanroom.tooltip.1=§bSize: §f21x21x10 to 101x101x101 +gcyl.machine.cleanroom.tooltip.2=§cMay cause performance issues! Read additional structure info. +gcyl.machine.cleanroom.tooltip.3=§cTo increase performance, the multiblock only checks its structure pattern on forming and when saving the world. +gcyl.machine.cleanroom.tooltip.4=§c§lDO NOT TRY TO CHEAT THIS! §r§7Doing so will cause the multiblock to constantly check its structure upon loading into the world, causing major TPS lag until fixed. \ No newline at end of file From 4e8a62597c600b4fbddeeba29d73c0d36ad6e53d Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 07:33:17 -0500 Subject: [PATCH 22/35] Dimension based rock breaker recipes for netherrack and endstone --- .../gcyl/recipes/categories/MiscRecipes.java | 23 +++++++++++++++++-- 1 file changed, 21 insertions(+), 2 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java index b2bcc212..b04258ce 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java @@ -1,13 +1,15 @@ package com.fulltrix.gcyl.recipes.categories; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; + import static com.fulltrix.gcyl.item.GCYLCoreItems.COVER_ENDER_ITEM_LINK; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Americium241; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.ADVANCED_MIXER_RECIPES; import static gregicality.multiblocks.api.unification.GCYMMaterials.Stellite100; import static gregtech.api.GTValues.*; -import static gregtech.api.recipes.RecipeMaps.ASSEMBLER_RECIPES; -import static gregtech.api.recipes.RecipeMaps.MIXER_RECIPES; +import static gregtech.api.recipes.RecipeMaps.*; import static gregtech.api.unification.material.Materials.*; import static gregtech.api.unification.material.Materials.Bismuth; import static gregtech.api.unification.ore.OrePrefix.*; @@ -50,6 +52,23 @@ public static void init() { .output(COVER_ENDER_ITEM_LINK) .EUt(VA[HV]).duration(320) .buildAndRegister(); + + //Rock breaker recipes for netherrack and endstone + ROCK_BREAKER_RECIPES.recipeBuilder() + .notConsumable(new ItemStack(Blocks.NETHERRACK)) + .duration(16) + .EUt(240) + .dimension(-1) + .outputs(new ItemStack(Blocks.NETHERRACK)) + .buildAndRegister(); + + ROCK_BREAKER_RECIPES.recipeBuilder() + .notConsumable(new ItemStack(Blocks.END_STONE)) + .duration(16) + .EUt(960) + .dimension(1) + .outputs(new ItemStack(Blocks.END_STONE)) + .buildAndRegister(); } } From 693611aa30e204085f570320e0e425ed8d7be9ee Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 08:51:39 -0500 Subject: [PATCH 23/35] Change recipes for Voltage Control Units Add Eglin Steel Dust Recipe Add Inconel 625 material and recipes Add Babbitt alloy --- .../gcyl/materials/GCYLMaterialOverride.java | 11 +- .../gcyl/materials/GCYLMaterials.java | 23 +++- .../recipes/categories/CasingRecipes.java | 119 +++++++++++------- .../gcyl/recipes/categories/MiscRecipes.java | 40 ++++++ 4 files changed, 146 insertions(+), 47 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index b6cfb482..f39e7dbe 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -58,7 +58,7 @@ public static void materialChanges() { //EXT2 METAL ADDITIONS List e2mmats = new ArrayList<>(); - Collections.addAll(e2mmats, MaragingSteel250, AbyssalAlloy, HG1223); + Collections.addAll(e2mmats, MaragingSteel250, AbyssalAlloy, HG1223, BabbittAlloy, Inconel625); for (Material mat : e2mmats) { for (MaterialFlag flag : EXT2_METAL) { mat.addFlags(flag); @@ -377,6 +377,13 @@ public static void tempMaterialModifications() { mat.addFlags(GENERATE_FINE_WIRE); } + //add gears + List gearmats = new ArrayList<>(); + Collections.addAll(gearmats, RhodiumPlatedPalladium, EglinSteel, Magnalium, Inconel625, QCDMatter, AbyssalAlloy, BabbittAlloy, Nitinol60, HG1223); + for (Material mat : gearmats) { + mat.addFlags(GENERATE_GEAR); + } + //Small Specific cases HSSG.addFlags(GENERATE_RING); Osmium.addFlags(GENERATE_RING); @@ -386,7 +393,6 @@ public static void tempMaterialModifications() { Trinium.addFlags(GENERATE_FRAME); Naquadria.addFlags(GENERATE_DENSE); Lead.addFlags(GENERATE_DENSE); - RhodiumPlatedPalladium.addFlags(GENERATE_GEAR); NaquadahAlloy.addFlags(DISABLE_DECOMPOSITION); NaquadahAlloy.addFlags(NO_ALLOY_BLAST_RECIPES); Glowstone.addFlags(DISABLE_DECOMPOSITION); @@ -403,6 +409,7 @@ public static void tempMaterialModifications() { //Cable Duranium.setProperty(PropertyKey.WIRE, new WireProperties((int) GTValues.V[UV], 1, 16)); + Titanium.setProperty(PropertyKey.WIRE, new WireProperties((int) GTValues.V[GTValues.EV], 4,2)); diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java index 50a9771c..6cf6b80c 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java @@ -1124,6 +1124,8 @@ public class GCYLMaterials { public static Material ChaosAlloy; public static Material BrightSteel; public static Material Gallite; + public static Material BabbittAlloy; + public static Material Inconel625; //COILS public static Material Pikyonium; @@ -1208,7 +1210,7 @@ public static void register() { .flags(DISABLE_REPLICATION).build(); EglinSteel = new Material.Builder(++id, gcylId("eglin_steel")) - .ingot(6) + .ingot(6).liquid() .color(0x8B4513) .iconSet(METALLIC) .flags(EXT2_METAL, GENERATE_FRAME) @@ -9825,6 +9827,25 @@ public static void register2() { .components(Copper,1,Gallium,1,Sulfur,2) .build(); + BabbittAlloy = new Material.Builder(++id, gcylId("babbitt_alloy")) + .ingot(4).liquid() + .color(0xA19CA4) + .iconSet(METALLIC) + .flags(DISABLE_REPLICATION) + .components(Tin, 5, Lead,36, Antimony,8,Arsenic,1) + .blast(737) + .build(); + + Inconel625 = new Material.Builder(++id, gcylId("inconel_a")) + .ingot(6).liquid() + .color(0x80C880) + .iconSet(METALLIC) + .flags(DISABLE_REPLICATION) + .components(Nickel,3,Chrome,7,Molybdenum,10,Invar,10,Nichrome,13) + .blast(2425) + .build(); + + /* = new Material.Builder(++id, gcylId("material")) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/CasingRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/CasingRecipes.java index d5c1b439..4fef3ee6 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/CasingRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/CasingRecipes.java @@ -2,8 +2,12 @@ import com.fulltrix.gcyl.item.GCYLMetaBlocks; import com.fulltrix.gcyl.item.GCYLMultiblockCasing2; +import gregicality.multiblocks.common.metatileentities.GCYMMetaTileEntities; +import gregtech.api.GTValues; +import gregtech.api.unification.material.MarkerMaterials; import gregtech.api.unification.stack.MaterialStack; import gregtech.common.blocks.MetaBlocks; +import gregtech.common.metatileentities.MetaTileEntities; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.item.GCYLCoreItems.*; @@ -11,9 +15,11 @@ import static com.fulltrix.gcyl.item.GCYLMultiblockCasing2.CasingType.*; import static com.fulltrix.gcyl.item.GCYLReactorCasing.CasingType.*; import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.ReactorSteel; +import static gregicality.multiblocks.api.unification.GCYMMaterials.*; import static gregtech.api.GTValues.L; import static gregtech.api.recipes.GTRecipeHandler.removeRecipesByInputs; import static gregtech.api.recipes.ModHandler.removeRecipeByName; +import static gregtech.api.recipes.ModHandler.removeTieredRecipeByName; import static gregtech.api.recipes.RecipeMaps.ASSEMBLER_RECIPES; import static gregtech.api.recipes.RecipeMaps.FORMING_PRESS_RECIPES; import static gregtech.api.unification.material.MarkerMaterials.Tier.*; @@ -22,6 +28,7 @@ import static gregtech.common.blocks.BlockWireCoil.CoilType.*; import static gregtech.common.items.MetaItems.*; import static gregtech.common.items.MetaItems.EMITTER_UV; +import static gregtech.common.metatileentities.MetaTileEntities.HULL; public class CasingRecipes { @@ -35,141 +42,165 @@ public static void init() { private static void tieredCasings() { - //TODO: voltage controls from GCYM + removeTieredRecipeByName("gcym:gcym.machine.tiered_hatch.", GTValues.ULV, GTValues.UV); - /* // Integral Frameworks ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(7) - .input(circuit, Primitive, 2) + .input(circuit, ULV, 2) .input(gear, Potin, 2) .input(plate, Potin, 2) .input(cableGtOctal, Tin) - .inputs(MetaTileEntities.HULL[ULV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.ULV].getStackForm()) .fluidInputs(Steel.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_ULV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[0].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30) - .input(circuit, Basic, 2) + .input(circuit, LV, 2) .input(gear, Magnalium, 2) .input(plate, Magnalium, 2) .input(cableGtOctal, Cobalt) - .inputs(MetaTileEntities.HULL[LV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.LV].getStackForm()) .fluidInputs(Silicon.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_LV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[1].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(120) - .input(circuit, Good, 2) + .input(circuit, MV, 2) .input(gear, EglinSteel, 2) .input(plate, EglinSteel, 2) .input(cableGtOctal, AnnealedCopper) - .inputs(MetaTileEntities.HULL[MV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.MV].getStackForm()) .fluidInputs(BabbittAlloy.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_MV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[2].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(480) - .input(circuit, Advanced, 2) + .input(circuit, HV, 2) .input(gear, Inconel625, 2) .input(plate, Inconel625, 2) .input(cableGtOctal, Gold) - .inputs(MetaTileEntities.HULL[HV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.HV].getStackForm()) .fluidInputs(Inconel625.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_HV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[3].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(1920) - .input(circuit, Extreme, 2) + .input(circuit, EV, 2) .input(gear, TungstenCarbide, 4) .input(plate, TungstenCarbide, 4) .input(cableGtOctal, Titanium) - .inputs(MetaTileEntities.HULL[EV].getStackForm()) - .fluidInputs(Stellite.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_EV)) + .inputs(MetaTileEntities.HULL[GTValues.EV].getStackForm()) + .fluidInputs(Stellite100.getFluid(L * 2)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[4].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(7680) - .input(circuit, Elite, 2) + .input(circuit, IV, 2) .input(gear, Nitinol60, 4) .input(plate, Nitinol60, 4) .input(cableGtOctal, Nichrome) - .inputs(MetaTileEntities.HULL[IV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.IV].getStackForm()) .fluidInputs(Thorium.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_IV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[5].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720) - .input(circuit, Master, 2) + .input(circuit, LuV, 2) .input(gear, IncoloyMA956, 4) .input(plate, IncoloyMA956, 4) .input(cableGtOctal, Platinum) - .inputs(MetaTileEntities.HULL[LuV].getStackForm()) - .fluidInputs(Uranium238Isotope.getMaterial().getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_LUV)) + .inputs(MetaTileEntities.HULL[GTValues.LuV].getStackForm()) + .fluidInputs(Uranium238.getFluid(L * 2)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[6].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 4) - .input(circuit, Ultimate, 2) + .input(circuit, ZPM, 2) .input(gear, BabbittAlloy, 4) .input(plate, BabbittAlloy, 4) .input(cableGtOctal, NiobiumTitanium) - .inputs(MetaTileEntities.HULL[GAValues.ZPM].getStackForm()) - .fluidInputs(Plutonium244Isotope.getMaterial().getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_ZPM)) + .inputs(MetaTileEntities.HULL[GTValues.ZPM].getStackForm()) + .fluidInputs(Plutonium244.getFluid(L * 2)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[7].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 16) - .input(circuit, Superconductor, 2) + .input(circuit, UV, 2) .input(gear, HG1223, 4) .input(plate, HG1223, 4) .input(cableGtOctal, YttriumBariumCuprate) - .inputs(MetaTileEntities.HULL[UV].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.UV].getStackForm()) .fluidInputs(NaquadahEnriched.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING.getItemVariant(TIERED_HULL_UV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[8].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 64) - .input(circuit, Infinite, 2) + .input(circuit, UHV, 2) .input(gear, AbyssalAlloy, 8) .input(plate, AbyssalAlloy, 8) .input(cableGtOctal, TungstenTitaniumCarbide) - .inputs(GATileEntities.GA_HULLS[0].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.UHV].getStackForm()) .fluidInputs(Naquadria.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING2.getItemVariant(TIERED_HULL_UHV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[9].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 256) - .input(circuit, GAMaterials.UEV, 2) + .input(circuit, UEV, 2) .input(gear, TitanSteel, 8) .input(plate, TitanSteel, 8) .input(cableGtOctal, Pikyonium) - .inputs(GATileEntities.GA_HULLS[1].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.UEV].getStackForm()) .fluidInputs(Naquadria.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING2.getItemVariant(TIERED_HULL_UEV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[10].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 1024) - .input(circuit, GAMaterials.UIV, 2) + .input(circuit, UIV, 2) .input(gear, BlackTitanium, 8) .input(plate, BlackTitanium, 8) .input(cableGtOctal, Cinobite) - .inputs(GATileEntities.GA_HULLS[2].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.UIV].getStackForm()) .fluidInputs(Naquadria.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING2.getItemVariant(TIERED_HULL_UIV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[11].getStackForm()) .buildAndRegister(); ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 4096) - .input(circuit, GAMaterials.UMV, 2) + .input(circuit, UXV, 2) .input(gear, Vibranium, 8) .input(plate, Vibranium, 8) .input(cableGtOctal, NaquadriaticTaranium) - .inputs(GATileEntities.GA_HULLS[3].getStackForm()) + .inputs(MetaTileEntities.HULL[GTValues.UXV].getStackForm()) .fluidInputs(Naquadria.getFluid(L * 2)) - .outputs(TJFMetaBlocks.MUTLIBLOCK_CASING2.getItemVariant(TIERED_HULL_UMV)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[12].getStackForm()) + .buildAndRegister(); + + ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 8192) + .input(circuit, OpV, 2) + .input(gear, QCDMatter, 8) + .input(plate, QCDMatter, 8) + .input(cableGtOctal, NaquadriaticTaranium) + .inputs(MetaTileEntities.HULL[GTValues.OpV].getStackForm()) + .fluidInputs(EnrichedNaquadahAlloy.getFluid(L * 2)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[13].getStackForm()) + .buildAndRegister(); + + //TODO: finish MAX tiered hatch + /* + ASSEMBLER_RECIPES.recipeBuilder().duration(100).EUt(30720 * 16384) + .input(circuit, MAX, 4) + .input(gear, Neutronium, 8) + .input(plate, Neutronium, 8) + .input(cableGtOctal, ChaosAlloy) + .inputs(MetaTileEntities.HULL[GTValues.MAX].getStackForm()) + .fluidInputs(RefinedChaos.getFluid(L * 2)) + .outputs(GCYMMetaTileEntities.TIERED_HATCH[13].getStackForm()) .buildAndRegister(); + */ + + /* // Battery Tower Cells ASSEMBLER_RECIPES.recipeBuilder().EUt(240).duration(1200) .input(plateDouble, Lead, 4) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java index b04258ce..32ffd8e3 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java @@ -1,5 +1,6 @@ package com.fulltrix.gcyl.recipes.categories; +import gregtech.api.GTValues; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; @@ -41,6 +42,45 @@ public static void init() { .circuitMeta(9) .buildAndRegister(); + //Inconel 625 dust + MIXER_RECIPES.recipeBuilder().duration(860).EUt(480) + .input(dust, Nickel, 3) + .input(dust, Chrome, 7) + .input(dust, Molybdenum, 10) + .input(dust, Invar, 10) + .input(dust, Nichrome, 13) + .circuitMeta(5) + .output(dust, Inconel625, 43) + .buildAndRegister(); + + //eglin steel dust and base dust + MIXER_RECIPES.recipeBuilder().duration(20 * 10).EUt(120) + .input(dust, Iron, 4) + .input(dust, Kanthal) + .input(dust, Invar, 5) + .circuitMeta(3) + .output(dust, EglinSteelBase, 10) + .buildAndRegister(); + + MIXER_RECIPES.recipeBuilder().duration(13 * 20).EUt(120) + .input(dust, EglinSteelBase, 10) + .input(dust, Sulfur) + .input(dust, Silicon) + .input(dust, Carbon) + .output(dust, EglinSteel, 13) + .circuitMeta(5) + .buildAndRegister(); + + //Babbitt alloy + MIXER_RECIPES.recipeBuilder().duration(50 * 20).EUt(GTValues.VA[ZPM]) + .input(dust, Tin, 5) + .input(dust, Lead, 36) + .input(dust, Antimony) + .input(dust, Arsenic) + .circuitMeta(4) + .output(dust, BabbittAlloy, 50) + .buildAndRegister(); + //Ender Item Link ASSEMBLER_RECIPES.recipeBuilder() .input(plate, EnderPearl, 9) From ab2b35c3d9b3b7170e7c2e645bf20bc10dc667fc Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 10:27:01 -0500 Subject: [PATCH 24/35] Force enable high tier solars, replace LV Solar panel recipe, add recipes for others Add arcfurance recipes --- .../java/com/fulltrix/gcyl/CommonProxy.java | 3 + .../advance/MetaTileEntityMegaCleanroom.java | 1 + .../gcyl/materials/GCYLMaterialOverride.java | 6 ++ .../fulltrix/gcyl/recipes/RecipeHandler.java | 2 +- .../gcyl/recipes/categories/MiscRecipes.java | 90 ++++++++++++++++++- .../recipes/categories/RecipeOverride.java | 2 + .../recipes/chain/ArcFurnaceOxidation.java | 41 +++++++++ 7 files changed, 143 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/fulltrix/gcyl/recipes/chain/ArcFurnaceOxidation.java diff --git a/src/main/java/com/fulltrix/gcyl/CommonProxy.java b/src/main/java/com/fulltrix/gcyl/CommonProxy.java index e988c537..dbbe2916 100644 --- a/src/main/java/com/fulltrix/gcyl/CommonProxy.java +++ b/src/main/java/com/fulltrix/gcyl/CommonProxy.java @@ -21,6 +21,7 @@ import gregtech.api.recipes.recipeproperties.FusionEUToStartProperty; import gregtech.api.unification.material.event.MaterialEvent; import gregtech.api.unification.material.event.MaterialRegistryEvent; +import gregtech.common.ConfigHolder; import net.minecraft.block.Block; import net.minecraft.item.Item; import net.minecraft.item.ItemBlock; @@ -62,6 +63,8 @@ public static void forceHighTierConfig(HighTierEvent event) { //Force enable high tier content, regardless of config option event.enableHighTier(); + ConfigHolder.machines.enableHighTierSolars = true; + //Force enable tiered casings from GCYM GCYMConfigHolder.globalMultiblocks.enableTieredCasings = true; //Force enable low quality gems diff --git a/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java index af649c46..c605a613 100644 --- a/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java +++ b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java @@ -37,6 +37,7 @@ import java.util.Arrays; import java.util.List; +//TODO: Decrease tps lag when they try to cheat it public class MetaTileEntityMegaCleanroom extends MetaTileEntityCleanroom { public static final int MIN_RADIUS = 10; public static final int MIN_DEPTH = 9; diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index f39e7dbe..1f557d7b 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -411,6 +411,12 @@ public static void tempMaterialModifications() { Duranium.setProperty(PropertyKey.WIRE, new WireProperties((int) GTValues.V[UV], 1, 16)); Titanium.setProperty(PropertyKey.WIRE, new WireProperties((int) GTValues.V[GTValues.EV], 4,2)); + WireProperties wireProp; + + wireProp = YttriumBariumCuprate.getProperty(PropertyKey.WIRE); + wireProp.setVoltage((int) GTValues.V[GTValues.LuV]); + wireProp.setAmperage(4); + wireProp.setLossPerBlock(4); } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java b/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java index 34520d18..22bcfb7c 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java @@ -75,11 +75,11 @@ public static void initChains() { NaquadahChain.init(); TriniumChain.init(); Dyes.init(); + ArcFurnaceOxidation.init(); /* UraniumChain.init(); DigitalInterfaces.init(); - ArcFurnaceOxidation.init(); */ } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java index 32ffd8e3..0ae7ba9a 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java @@ -1,10 +1,14 @@ package com.fulltrix.gcyl.recipes.categories; import gregtech.api.GTValues; +import gregtech.api.recipes.ModHandler; +import gregtech.api.unification.material.MarkerMaterials; +import gregtech.api.unification.stack.UnificationEntry; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; -import static com.fulltrix.gcyl.item.GCYLCoreItems.COVER_ENDER_ITEM_LINK; +import static com.fulltrix.gcyl.item.GCYLCoreItems.*; +import static com.fulltrix.gcyl.machines.GCYLTileEntities.DEEP_MINER; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Americium241; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.ADVANCED_MIXER_RECIPES; @@ -16,9 +20,13 @@ import static gregtech.api.unification.ore.OrePrefix.*; import static gregtech.common.items.MetaItems.*; import static gregtech.common.items.MetaItems.COVER_ENDER_FLUID_LINK; +import static gregtech.common.metatileentities.MetaTileEntities.HULL; +import static gregtech.loaders.recipe.MetaTileEntityLoader.registerMachineRecipe; public class MiscRecipes { public static void init() { + initSolars(); + // Quantum Dust ADVANCED_MIXER_RECIPES.recipeBuilder().duration(10500).EUt(30) .input(dust, Stellite100, 15) @@ -111,4 +119,84 @@ public static void init() { .buildAndRegister(); } + public static void initSolars() { + + //TODO: add additional recipes to these + //TODO: add max solar panel + + ModHandler.addShapedRecipe("gcyl_solar_panel_lv", COVER_SOLAR_PANEL_LV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_EV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.EV), + 'W', new UnificationEntry(cableGtSingle, Aluminium), + 'B', BATTERY_LV_CADMIUM, + 'G', new UnificationEntry(gemExquisite, Diamond), + 'H', HULL[GTValues.EV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_mv", COVER_SOLAR_PANEL_MV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_IV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.IV), + 'W', new UnificationEntry(cableGtSingle, Tungsten), + 'B', BATTERY_MV_CADMIUM, + 'G', new UnificationEntry(gemExquisite, Ruby), + 'H', HULL[GTValues.IV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_hv", COVER_SOLAR_PANEL_HV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_LuV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.LuV), + 'W', new UnificationEntry(cableGtSingle, YttriumBariumCuprate), + 'B', BATTERY_HV_CADMIUM, + 'G', new UnificationEntry(gemExquisite, Ruby), + 'H', HULL[GTValues.LuV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_ev", COVER_SOLAR_PANEL_EV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_ZPM, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.ZPM), + 'W', new UnificationEntry(cableGtSingle, Naquadah), + 'B', BATTERY_NIMH, + 'G', new UnificationEntry(gemExquisite, Emerald), + 'H', HULL[GTValues.ZPM].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_iv", COVER_SOLAR_PANEL_IV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_UV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.UV), + 'W', new UnificationEntry(cableGtSingle, Duranium), + 'B', BATTERY_SMALL_LITHIUM_ION, + 'G', new UnificationEntry(gemExquisite, BlueTopaz), + 'H', HULL[GTValues.UV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_luv", COVER_SOLAR_PANEL_LUV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_UHV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.UHV), + 'W', new UnificationEntry(cableGtSingle, AbyssalAlloy), + 'B', BATTERY_MEDIUM_LITHIUM_ION, + 'G', new UnificationEntry(gemExquisite, RhodiumSalt), + 'H', HULL[GTValues.UHV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_zpm", COVER_SOLAR_PANEL_ZPM.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_UEV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.UEV), + 'W', new UnificationEntry(cableGtSingle, TitanSteel), + 'B', BATTERY_LARGE_LITHIUM_ION, + 'G', new UnificationEntry(gemExquisite, CubicZirconia), + 'H', HULL[GTValues.UEV].getStackForm()); + + ModHandler.addShapedRecipe("gcyl_solar_panel_uv", COVER_SOLAR_PANEL_UV.getStackForm(), + "SGS", "CHC", "WBW", + 'S', SENSOR_UIV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.UIV), + 'W', new UnificationEntry(cableGtSingle, BlackTitanium), + 'B', BATTERY_SMALL_LIS, + 'G', new UnificationEntry(gemExquisite, LeadZirconateTitanate), + 'H', HULL[GTValues.UIV].getStackForm()); + + + } + } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 64667fce..df7fe42a 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -320,6 +320,8 @@ private static void recipeRemoval() { removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{MetaBlocks.MACHINE_CASING.getItemVariant(BlockMachineCasing.MachineCasingType.ZPM), FUSION_CASING.getItemVariant(FUSION_COIL), VOLTAGE_COIL_ZPM.getStackForm(2), FIELD_GENERATOR_LuV.getStackForm(), OreDictUnifier.get(plate, Europium, 6)}, new FluidStack[]{Polybenzimidazole.getFluid(288)}); removeRecipesByInputs(ASSEMBLER_RECIPES, new ItemStack[]{MetaBlocks.MACHINE_CASING.getItemVariant(BlockMachineCasing.MachineCasingType.UV), FUSION_CASING.getItemVariant(FUSION_COIL), VOLTAGE_COIL_UV.getStackForm(2), FIELD_GENERATOR_ZPM.getStackForm(), OreDictUnifier.get(plate, Americium, 6)}, new FluidStack[]{Polybenzimidazole.getFluid(576)}); + //lv solar + removeRecipeByName("gregtech:solar_panel_lv"); } public static void chemistryOverride() { diff --git a/src/main/java/com/fulltrix/gcyl/recipes/chain/ArcFurnaceOxidation.java b/src/main/java/com/fulltrix/gcyl/recipes/chain/ArcFurnaceOxidation.java new file mode 100644 index 00000000..9da842de --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/recipes/chain/ArcFurnaceOxidation.java @@ -0,0 +1,41 @@ +package com.fulltrix.gcyl.recipes.chain; + +import gregtech.api.unification.OreDictUnifier; + +import static com.fulltrix.gcyl.materials.GCYLMaterials.WellMixedYBCOxides; +import static gregtech.api.recipes.RecipeMaps.ARC_FURNACE_RECIPES; +import static gregtech.api.unification.material.Materials.*; +import static gregtech.api.unification.ore.OrePrefix.*; +import static gregtech.api.unification.ore.OrePrefix.dust; + +public class ArcFurnaceOxidation { + public static void init() { + // 2Sb + 3O = Sb2O3 + ARC_FURNACE_RECIPES.recipeBuilder().EUt(30).duration(60) + .input(dust, Antimony, 2) + .fluidInputs(Oxygen.getFluid(3000)) + .outputs(OreDictUnifier.get(dust, AntimonyTrioxide, 5)) + .buildAndRegister(); + + // NiZnFe4 + 8O = NiZnFe4O8 + ARC_FURNACE_RECIPES.recipeBuilder().EUt(120).duration(600) + .input(dust, FerriteMixture, 6) + .fluidInputs(Oxygen.getFluid(8000)) + .outputs(OreDictUnifier.get(ingot, NickelZincFerrite, 14)) + .buildAndRegister(); + + + // YBa2Cu3O6 + O -> YBa2Cu3O7 + ARC_FURNACE_RECIPES.recipeBuilder().duration(2509).EUt(7680) + .input(dust, WellMixedYBCOxides,12) + .fluidInputs(Oxygen.getFluid(1000)) + .output(ingotHot, YttriumBariumCuprate, 13) + .buildAndRegister(); + + ARC_FURNACE_RECIPES.recipeBuilder().EUt(30).duration(100) + .input(dust, Cobalt) + .fluidInputs(Oxygen.getFluid(1000)) + .output(dust, CobaltOxide, 2) + .buildAndRegister(); + } +} From 7a4151a6c0115a4bfc6e278db572ff8c70b126c2 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 10:30:31 -0500 Subject: [PATCH 25/35] Fix YBCO --- .../java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java | 1 + .../com/fulltrix/gcyl/recipes/categories/RecipeOverride.java | 3 +++ 2 files changed, 4 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index 1f557d7b..e6448745 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -395,6 +395,7 @@ public static void tempMaterialModifications() { Lead.addFlags(GENERATE_DENSE); NaquadahAlloy.addFlags(DISABLE_DECOMPOSITION); NaquadahAlloy.addFlags(NO_ALLOY_BLAST_RECIPES); + YttriumBariumCuprate.addFlags(NO_ALLOY_BLAST_RECIPES); Glowstone.addFlags(DISABLE_DECOMPOSITION); Pyrochlore.addFlags(DISABLE_DECOMPOSITION); diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index df7fe42a..c6e658b8 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -322,6 +322,9 @@ private static void recipeRemoval() { //lv solar removeRecipeByName("gregtech:solar_panel_lv"); + + //yttrium barium cuprate dust + removeRecipesByInputs(MIXER_RECIPES, new ItemStack[]{getIntegratedCircuit(2), OreDictUnifier.get(dust, Yttrium), OreDictUnifier.get(dust, Barium, 2), OreDictUnifier.get(dust, Copper,3)}, new FluidStack[]{Oxygen.getFluid(7000)}); } public static void chemistryOverride() { From e696e5c0005ea136cde7b0fe189f1ff8ca8005c9 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 10:36:53 -0500 Subject: [PATCH 26/35] Recipe conflict --- .../com/fulltrix/gcyl/recipes/categories/RecipeOverride.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index c6e658b8..9b7a33b1 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -325,6 +325,11 @@ private static void recipeRemoval() { //yttrium barium cuprate dust removeRecipesByInputs(MIXER_RECIPES, new ItemStack[]{getIntegratedCircuit(2), OreDictUnifier.get(dust, Yttrium), OreDictUnifier.get(dust, Barium, 2), OreDictUnifier.get(dust, Copper,3)}, new FluidStack[]{Oxygen.getFluid(7000)}); + + //cobalt in arc furnace + removeRecipesByInputs(ARC_FURNACE_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Cobalt)}, new FluidStack[]{Oxygen.getFluid(59)}); + //antimony in arc furnace + removeRecipesByInputs(ARC_FURNACE_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Antimony)}, new FluidStack[]{Oxygen.getFluid(121)}); } public static void chemistryOverride() { From a824c355803d0bb5069aa57f9e5db0bde87782b0 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 10:45:33 -0500 Subject: [PATCH 27/35] mega cleanroom tooltip --- .../machines/multi/advance/MetaTileEntityMegaCleanroom.java | 1 + src/main/resources/assets/gcyl/lang/en_us.lang | 3 ++- 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java index c605a613..9fcb857b 100644 --- a/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java +++ b/src/main/java/com/fulltrix/gcyl/machines/multi/advance/MetaTileEntityMegaCleanroom.java @@ -345,6 +345,7 @@ public void addInformation(ItemStack stack, @Nullable World player, List tooltip.add(""); tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.3")); tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.4")); + tooltip.add(I18n.format("gcyl.machine.cleanroom.tooltip.5")); tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.5")); tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.6")); tooltip.add(I18n.format("gregtech.machine.cleanroom.tooltip.7")); diff --git a/src/main/resources/assets/gcyl/lang/en_us.lang b/src/main/resources/assets/gcyl/lang/en_us.lang index c58fd016..7025bd06 100644 --- a/src/main/resources/assets/gcyl/lang/en_us.lang +++ b/src/main/resources/assets/gcyl/lang/en_us.lang @@ -4793,4 +4793,5 @@ gcyl.machine.mega_cleanroom.name=Mega Cleanroom (MC) gcyl.machine.cleanroom.tooltip.1=§bSize: §f21x21x10 to 101x101x101 gcyl.machine.cleanroom.tooltip.2=§cMay cause performance issues! Read additional structure info. gcyl.machine.cleanroom.tooltip.3=§cTo increase performance, the multiblock only checks its structure pattern on forming and when saving the world. -gcyl.machine.cleanroom.tooltip.4=§c§lDO NOT TRY TO CHEAT THIS! §r§7Doing so will cause the multiblock to constantly check its structure upon loading into the world, causing major TPS lag until fixed. \ No newline at end of file +gcyl.machine.cleanroom.tooltip.4=§c§lDO NOT TRY TO CHEAT THIS! §r§cDoing so will cause the multiblock to constantly check its structure upon loading into the world, causing major TPS lag until fixed. +gcyl.machine.cleanroom.tooltip.5=§c§lMake sure the structure is valid if you make changes to the multiblock! \ No newline at end of file From 66e9d471f7f63b06cc423d5f88560857876d6e4b Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 12:30:08 -0500 Subject: [PATCH 28/35] Properly remove trinium and tritanium coils --- src/main/java/com/fulltrix/gcyl/GCYLCore.java | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/GCYLCore.java b/src/main/java/com/fulltrix/gcyl/GCYLCore.java index 90cf3999..3e9df6fd 100644 --- a/src/main/java/com/fulltrix/gcyl/GCYLCore.java +++ b/src/main/java/com/fulltrix/gcyl/GCYLCore.java @@ -7,6 +7,8 @@ import gregtech.GTInternalTags; import gregtech.api.GregTechAPI; import gregtech.api.cover.CoverDefinition; +import gregtech.common.blocks.BlockWireCoil; +import gregtech.common.blocks.MetaBlocks; import net.minecraftforge.common.MinecraftForge; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fml.common.Mod; @@ -42,6 +44,11 @@ public void preInit(FMLPreInitializationEvent event) { for (GCYLHeatingCoil.CoilType type : GCYLHeatingCoil.CoilType.values()) { HEATING_COILS.put(HEATING_COIL.getState(type), type); } + + HEATING_COILS.remove(MetaBlocks.WIRE_COIL.getState(BlockWireCoil.CoilType.TRINIUM),BlockWireCoil.CoilType.TRINIUM); + HEATING_COILS.remove(MetaBlocks.WIRE_COIL.getState(BlockWireCoil.CoilType.TRITANIUM),BlockWireCoil.CoilType.TRITANIUM); + + } @EventHandler From 22f5d4c5c5603e3d3d324f97b087d8681d50ac7e Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 14:00:22 -0500 Subject: [PATCH 29/35] Implement temporary ways to get some nuclear materials before a permanent solution is added (Fission). (Polonium: Quantum SMD Diode, Americium & Plutonium: Quantum SMD Transistor) --- .../gcyl/materials/GCYLMaterialOverride.java | 2 +- .../gcyl/materials/GCYLNuclearMaterials.java | 18 +++++ .../fulltrix/gcyl/recipes/GCYLRecipeMaps.java | 2 +- .../recipes/categories/DeepMinerRecipes.java | 48 +++++++++---- .../gcyl/recipes/categories/MiscRecipes.java | 69 ++++++++++++++++++- .../gcyl/recipes/chain/NuclearChain.java | 4 +- .../resources/assets/gcyl/lang/en_us.lang | 6 +- 7 files changed, 130 insertions(+), 19 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index e6448745..f8c04eac 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -180,7 +180,7 @@ public static void materialChanges() { Collections.addAll(omats, Lignite, Witherite, Barytocalcite, PlatinumMetallicPowder, IridiumMetalResidue, PreciousMetal, RarestMetalMixture, PalladiumMetallicPowder, Celestine, Caliche, Fluorite, Rhodocrosite, Columbite, Niter, Zircon, Bowieite, Zinc, Enargite, Andradite, Dolomite, Wollastonite, Kaolinite, Tenorite, Tennantite, Cuprite, Tellurium, Zirkelite, - Arsenopyrite, Draconium, Iridium, Osmium, Rutile, Gallite, NetherStar); + Arsenopyrite, Draconium, Iridium, Osmium, Rutile, Gallite, NetherStar, Plutonium, Uranium238); for (Material mat : omats) { addOre(mat, 1, 1,false); } diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLNuclearMaterials.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLNuclearMaterials.java index be33c272..e517b616 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLNuclearMaterials.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLNuclearMaterials.java @@ -35,6 +35,9 @@ public class GCYLNuclearMaterials { public static Material Fermium259; public static Material Mendelevium261; + //TODO: REMOVE AFTER IMPLEMENTING NUCLEAR + public static Material Bismuth210; + //HEXAFLUORIDES, OXIDES, NITRITES, HEXACHLORIDES public static Map GenericRadioactives = new Object2ObjectOpenHashMap<>(); @@ -154,6 +157,9 @@ public static void registerNuclear() { registerDecayMats(); + //TODO: FINISH NUCLEAR AND REMOVE + temporaryNuclearMaterials(); + /* HighEnrichedNeptuniumDioxide = new Material.Builder(++id, gcylId("high_enriched_neptunium_dioxide")) .dust(3) @@ -237,5 +243,17 @@ else if (s.equals("nitrite")) { private static void registerDecayMats() { + } + + private static void temporaryNuclearMaterials() { + + Bismuth210 = new Material.Builder(++id, gcylId("bismuth_210")) + .dust() + .color(Bismuth.getMaterialRGB()) + .iconSet(Bismuth.getMaterialIconSet()) + .build() + .setFormula("Bi-210", true); + + } } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java b/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java index 6e24faa1..908e1134 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java @@ -45,7 +45,7 @@ private GCYLRecipeMaps() { //public static final RecipeMap NUCLEAR_BREEDER_RECIPES = new RecipeMap<>("nuclear_breeder", 4, 4, 0, 0, new NuclearReactorBuilder().EUt(1920),false); //NUCLEAR_MARK - public static final RecipeMap DECAY_CHAMBERS_RECIPES = new RecipeMap<>("decay_chamber", 2, 1, 1, 1, new SimpleRecipeBuilder().EUt(30), false) + public static final RecipeMap DECAY_CHAMBERS_RECIPES = new RecipeMap<>("decay_chamber", 2, 4, 1, 1, new SimpleRecipeBuilder().EUt(30), false) .setProgressBar(GuiTextures.PROGRESS_BAR_HAMMER, ProgressWidget.MoveType.VERTICAL); //NUCLEAR_MARK public static final RecipeMap ADV_FUSION_RECIPES = new RecipeMap<>("adv_fusion", 0, 0, 3, 3, new AdvFusionRecipeBuilder(), false) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/DeepMinerRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/DeepMinerRecipes.java index d6359813..89974795 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/DeepMinerRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/DeepMinerRecipes.java @@ -1,6 +1,7 @@ package com.fulltrix.gcyl.recipes.categories; import com.fulltrix.gcyl.recipes.recipeproperties.GCYLScanProperty; +import gregtech.api.GTValues; import gregtech.api.metatileentity.multiblock.CleanroomType; import gregtech.api.recipes.RecipeBuilder; import gregtech.api.recipes.RecipeMaps; @@ -24,6 +25,7 @@ import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.item.GCYLCoreItems.TOOL_DATA_DEEP_MINER; +import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Plutonium; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.DEEP_MINER_RECIPES; import static gregtech.api.recipes.RecipeMaps.*; import static gregtech.api.unification.material.Materials.*; @@ -66,6 +68,8 @@ public static void init() { createResearchRecipe( "deep_exotics", OreDictUnifier.get(block, Enderium), null, TOOL_DATA_DEEP_MINER.getStackForm(), true, 300, 1920, 0); + createResearchRecipe("deep_radioactive", OreDictUnifier.get(block, Plutonium244), null, TOOL_DATA_DEEP_MINER.getStackForm(), true, 300, 7860, 0); + DEEP_MINER_RECIPES.recipeBuilder() .notConsumable(minerScanMap.get("deep_diamond")) @@ -73,7 +77,7 @@ public static void init() { .input(SENSOR_HV) .input(ELECTRIC_PISTON_HV) - .fluidInputs(DrillingFluid.getFluid(32000)) + .fluidInputs(DrillingFluid.getFluid(64000)) .output(ore, Coal, 64) .output(ore, Diamond, 16) .chancedOutput(ore, Coal, 64,100,2000) @@ -93,7 +97,7 @@ public static void init() { .input(SENSOR_HV) .input(ELECTRIC_PISTON_HV) - .fluidInputs(DrillingFluid.getFluid(32000)) + .fluidInputs(DrillingFluid.getFluid(64000)) .output(ore, Pyrochlore, 64) .output(ore, Columbite, 64) .chancedOutput(ore, Pyrochlore, 64,100,2000) @@ -112,7 +116,7 @@ public static void init() { .input(SENSOR_HV) .input(ELECTRIC_PISTON_HV) - .fluidInputs(DrillingFluid.getFluid(32000)) + .fluidInputs(DrillingFluid.getFluid(64000)) .output(ore, Bauxite, 64) .output(ore, Aluminium, 32) .output(ore, Gallite, 32) @@ -134,7 +138,7 @@ public static void init() { .input(SENSOR_HV) .input(ELECTRIC_PISTON_HV) - .fluidInputs(DrillingFluid.getFluid(32000)) + .fluidInputs(DrillingFluid.getFluid(64000)) .output(ore, Bauxite, 64) .output(ore, Rutile, 32) .chancedOutput(ore, Bauxite, 64,100,2000) @@ -153,7 +157,7 @@ public static void init() { .input(SENSOR_EV) .input(ELECTRIC_PISTON_EV) - .fluidInputs(DrillingFluid.getFluid(64000)) + .fluidInputs(DrillingFluid.getFluid(128000)) .output(ore, PlatinumMetallicPowder, 64) .output(ore, PalladiumMetallicPowder, 64) .chancedOutput(ore, PlatinumMetallicPowder, 64,100,2000) @@ -172,7 +176,7 @@ public static void init() { .input(SENSOR_EV) .input(ELECTRIC_PISTON_EV) - .fluidInputs(DrillingFluid.getFluid(64000)) + .fluidInputs(DrillingFluid.getFluid(128000)) .output(ore, NetherStar, 16) .chancedOutput(ore, NetherStar, 16,100,2000) .chancedOutput(ore, NetherStar, 16,100,500) @@ -189,7 +193,7 @@ public static void init() { .input(SENSOR_IV) .input(ELECTRIC_PUMP_IV) - .fluidInputs(DrillingFluid.getFluid(128000)) + .fluidInputs(DrillingFluid.getFluid(256000)) .fluidInputs(NitricAcid.getFluid(16000)) .fluidOutputs(Chlorine.getFluid(64000)) .chancedFluidOutput(Chlorine.getFluid(64000), 100, 2000) @@ -206,7 +210,7 @@ public static void init() { .input(SENSOR_IV) .input(ELECTRIC_PUMP_IV) - .fluidInputs(DrillingFluid.getFluid(128000)) + .fluidInputs(DrillingFluid.getFluid(256000)) .fluidInputs(NitricAcid.getFluid(16000)) .fluidOutputs(Fluorine.getFluid(64000)) .chancedFluidOutput(Fluorine.getFluid(64000), 100, 2000) @@ -223,7 +227,7 @@ public static void init() { .input(SENSOR_IV) .input(ELECTRIC_PISTON_IV) - .fluidInputs(DrillingFluid.getFluid(128000)) + .fluidInputs(DrillingFluid.getFluid(256000)) .fluidInputs(NitricAcid.getFluid(16000)) .output(ore, Salt, 32) .chancedOutput(ore, Salt, 32, 100, 2000) @@ -249,7 +253,7 @@ public static void init() { .input(SENSOR_IV) .input(ELECTRIC_PISTON_IV) - .fluidInputs(DrillingFluid.getFluid(128000)) + .fluidInputs(DrillingFluid.getFluid(256000)) .fluidInputs(NitricAcid.getFluid(16000)) .output(ore, Salt, 32) .chancedOutput(ore, Salt, 32, 100, 2000) @@ -271,11 +275,11 @@ public static void init() { DEEP_MINER_RECIPES.recipeBuilder() .notConsumable(minerScanMap.get("deep_exotics")) - .circuitMeta(1) + .circuitMeta(0) .input(SENSOR_IV) .input(ELECTRIC_PISTON_IV) - .fluidInputs(DrillingFluid.getFluid(128000)) + .fluidInputs(DrillingFluid.getFluid(256000)) .fluidInputs(NitricAcid.getFluid(32000)) .output(ore, NaquadricCompound, 64) .chancedOutput(ore, NaquadricCompound, 64, 100, 2000) @@ -292,6 +296,26 @@ public static void init() { .dimension(0) .buildAndRegister(); + DEEP_MINER_RECIPES.recipeBuilder() + .notConsumable(minerScanMap.get("deep_radioactive")) + .circuitMeta(0) + .input(SENSOR_LuV) + .input(ELECTRIC_PISTON_LUV) + + .fluidInputs(DrillingFluid.getFluid(512000)) + .fluidInputs(NitricAcid.getFluid(64000)) + .output(ore, Uranium238, 64) + .chancedOutput(ore, Uranium238, 64, 100, 2000) + .chancedOutput(ore, Uranium238, 64, 100, 500) + .output(ore, Plutonium, 32) + .chancedOutput(ore, Plutonium, 32, 100, 2000) + .chancedOutput(ore, Plutonium, 32, 100, 500) + .duration(4000) + .EUt(GTValues.VA[GTValues.LuV]) + .temperature(7200) + .dimension(0) + .buildAndRegister(); + } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java index 0ae7ba9a..c95d1e48 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/MiscRecipes.java @@ -2,6 +2,7 @@ import gregtech.api.GTValues; import gregtech.api.recipes.ModHandler; +import gregtech.api.recipes.chance.output.ChancedOutputLogic; import gregtech.api.unification.material.MarkerMaterials; import gregtech.api.unification.stack.UnificationEntry; import net.minecraft.init.Blocks; @@ -10,8 +11,9 @@ import static com.fulltrix.gcyl.item.GCYLCoreItems.*; import static com.fulltrix.gcyl.machines.GCYLTileEntities.DEEP_MINER; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; -import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.Americium241; +import static com.fulltrix.gcyl.materials.GCYLNuclearMaterials.*; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.ADVANCED_MIXER_RECIPES; +import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.DECAY_CHAMBERS_RECIPES; import static gregicality.multiblocks.api.unification.GCYMMaterials.Stellite100; import static gregtech.api.GTValues.*; import static gregtech.api.recipes.RecipeMaps.*; @@ -22,11 +24,16 @@ import static gregtech.common.items.MetaItems.COVER_ENDER_FLUID_LINK; import static gregtech.common.metatileentities.MetaTileEntities.HULL; import static gregtech.loaders.recipe.MetaTileEntityLoader.registerMachineRecipe; +import static kono.ceu.materialreplication.api.unification.materials.MRMaterials.NeutralMatter; public class MiscRecipes { public static void init() { initSolars(); + + //TODO: FINISH NUCLEAR AND REMOVE + temporaryNuclearRecipes(); + // Quantum Dust ADVANCED_MIXER_RECIPES.recipeBuilder().duration(10500).EUt(30) .input(dust, Stellite100, 15) @@ -199,4 +206,64 @@ public static void initSolars() { } + public static void temporaryNuclearRecipes() { + + + //alpha decay + + //beta decay + DECAY_CHAMBERS_RECIPES.recipeBuilder().EUt(7680).duration(300) + .input(dust, Bismuth210, 1) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Polonium, 5000, 0) + .chancedOutput(dust, Bismuth, 10000, 0) + .buildAndRegister(); + + DECAY_CHAMBERS_RECIPES.recipeBuilder().EUt(7680).duration(300) + .input(dust, Uranium238, 1) + .fluidInputs(NeutralMatter.getFluid(200)) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Plutonium, 2000, 0) + .chancedOutput(dust, Uranium, 10000, 0) + .buildAndRegister(); + + + DECAY_CHAMBERS_RECIPES.recipeBuilder().EUt(GTValues.VA[GTValues.IV]).duration(600) + .input(dust, Plutonium241) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Americium, 2000, 0) + .chancedOutput(dust, Plutonium, 10000, 0) + .buildAndRegister(); + + //isotopes + DECAY_CHAMBERS_RECIPES.recipeBuilder().EUt(7680).duration(300) + .input(dust, Bismuth, 1) + .fluidInputs(NeutralMatter.getFluid(100)) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Bismuth210, 2500, 0) + .chancedOutput(dust, Bismuth, 10000, 0) + .buildAndRegister(); + + CENTRIFUGE_RECIPES.recipeBuilder().EUt(320).duration(1600) + .input(dust, Uranium) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Uranium235, 100,0) + .chancedOutput(dust,Uranium238, 10000,0) + .buildAndRegister(); + + CENTRIFUGE_RECIPES.recipeBuilder().EUt(320).duration(1600) + .input(dust, Plutonium) + .chancedOutputLogic(ChancedOutputLogic.XOR) + .chancedOutput(dust, Plutonium244, 2500,0) + .chancedOutput(dust,Plutonium241, 5000,0) + .chancedOutput(dust,Plutonium239, 10000,0) + .buildAndRegister(); + + CENTRIFUGE_RECIPES.recipeBuilder().EUt(320).duration(1600) + .input(dust, Plutonium241) + .chancedOutput(dust, Plutonium244, 2000, 300) + .chancedOutput(dustTiny, Uranium238, 3000, 450) + .buildAndRegister(); + } + } diff --git a/src/main/java/com/fulltrix/gcyl/recipes/chain/NuclearChain.java b/src/main/java/com/fulltrix/gcyl/recipes/chain/NuclearChain.java index 327a26ca..48dcc93b 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/chain/NuclearChain.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/chain/NuclearChain.java @@ -10,6 +10,7 @@ import static gregtech.api.unification.material.Materials.*; import static gregtech.api.unification.ore.OrePrefix.dust; import static gregtech.api.unification.ore.OrePrefix.ingot; +import static kono.ceu.materialreplication.api.unification.materials.MRMaterials.NeutralMatter; public class NuclearChain { public static void init() { @@ -342,9 +343,6 @@ private static void gasCentrifugeInit() { private static void decayChamberInit() { - //alpha decay - - } } diff --git a/src/main/resources/assets/gcyl/lang/en_us.lang b/src/main/resources/assets/gcyl/lang/en_us.lang index 7025bd06..bc421da4 100644 --- a/src/main/resources/assets/gcyl/lang/en_us.lang +++ b/src/main/resources/assets/gcyl/lang/en_us.lang @@ -4758,6 +4758,8 @@ gcyl.research.deep_exotics=§6Deep Exotics Data gcyl.research.deep_exotics.tooltip=§aScan an Enderium Block for this Data gcyl.research.deep_salts=§6Deep Salts Data gcyl.research.deep_salts.tooltip=§aScan a Salt Block with Hydrofluoric Acid for this Data +gcyl.research.deep_radioactive=§6Deep Radioactive Data +gcyl.research.deep_radioactive.tooltip=§aScan a Plutonium 244 Block for this Data gcyl.machine.deep_miner.name=Deep Miner (DM) gcyl.machine.deep_miner.config.0=Fluid type set to Lava @@ -4794,4 +4796,6 @@ gcyl.machine.cleanroom.tooltip.1=§bSize: §f21x21x10 to 101x101x101 gcyl.machine.cleanroom.tooltip.2=§cMay cause performance issues! Read additional structure info. gcyl.machine.cleanroom.tooltip.3=§cTo increase performance, the multiblock only checks its structure pattern on forming and when saving the world. gcyl.machine.cleanroom.tooltip.4=§c§lDO NOT TRY TO CHEAT THIS! §r§cDoing so will cause the multiblock to constantly check its structure upon loading into the world, causing major TPS lag until fixed. -gcyl.machine.cleanroom.tooltip.5=§c§lMake sure the structure is valid if you make changes to the multiblock! \ No newline at end of file +gcyl.machine.cleanroom.tooltip.5=§c§lMake sure the structure is valid if you make changes to the multiblock! + +gcyl.material.bismuth_210=Bismuth 210 \ No newline at end of file From 64438530a49cd6c2a74c969a94f16f965d109706 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 15:00:52 -0500 Subject: [PATCH 30/35] Implement dyes chain so that some missing materials are covered --- .../gcyl/materials/GCYLMaterialOverride.java | 4 +- .../gcyl/materials/GCYLMaterials.java | 458 ++++++++++++++++++ .../com/fulltrix/gcyl/recipes/chain/Dyes.java | 241 ++++----- 3 files changed, 586 insertions(+), 117 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java index f8c04eac..304c910b 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterialOverride.java @@ -89,7 +89,7 @@ public static void materialChanges() { //PLATE ADDITIONS List platemats = new ArrayList<>(); - Collections.addAll(platemats, Vanadium, Tennessine); + Collections.addAll(platemats, Vanadium, Tennessine, Rutile); for (Material mat : platemats) { mat.addFlags(GENERATE_PLATE); } @@ -180,7 +180,7 @@ public static void materialChanges() { Collections.addAll(omats, Lignite, Witherite, Barytocalcite, PlatinumMetallicPowder, IridiumMetalResidue, PreciousMetal, RarestMetalMixture, PalladiumMetallicPowder, Celestine, Caliche, Fluorite, Rhodocrosite, Columbite, Niter, Zircon, Bowieite, Zinc, Enargite, Andradite, Dolomite, Wollastonite, Kaolinite, Tenorite, Tennantite, Cuprite, Tellurium, Zirkelite, - Arsenopyrite, Draconium, Iridium, Osmium, Rutile, Gallite, NetherStar, Plutonium, Uranium238); + Arsenopyrite, Draconium, Iridium, Osmium, Rutile, Gallite, NetherStar, Plutonium, Uranium238, FluoroApatite); for (Material mat : omats) { addOre(mat, 1, 1,false); } diff --git a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java index 6cf6b80c..b3d41e1f 100644 --- a/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java +++ b/src/main/java/com/fulltrix/gcyl/materials/GCYLMaterials.java @@ -1126,6 +1126,58 @@ public class GCYLMaterials { public static Material Gallite; public static Material BabbittAlloy; public static Material Inconel625; + public static Material ApatiteAcidicLeach; + public static Material PhosphorousArsenicSolution; + public static Material ApatiteSolidResidue; + public static Material FluoroApatite; + public static Material FluoroapatiteAcidicLeach; + public static Material FluoroapatiteSolidResidue; + public static Material SodiumArsenate; + public static Material FinelyPowderedRutile; + public static Material RawSienna; + public static Material BurnedSienna; + public static Material MercuryNitrate; + public static Material MercuryChloride; + public static Material MercuryIodide; + public static Material BismuthVanadateSolution; + public static Material BismuthVanadate; + public static Material CopperArsenite; + public static Material ScheelesGreen; + public static Material CobaltZincOxide; + public static Material CobaltAluminate; + public static Material PotassiumFerrocyanide; + public static Material PrussianBlue; + public static Material TitaniumYellow; + public static Material ManganeseIIIOxide; + public static Material AmmoniumManganesePhosphate; + public static Material HanPurple; + public static Material ChromeYellow; + public static Material ChromeOrange; + public static Material Nitrotoluene; + public static Material DiaminostilbenedisulfonicAcid; + public static Material Nigrosin; + public static Material SodiumSulfanilate; + public static Material Naphthylamine; + public static Material DirectBrown; + public static Material DianilineterephthalicAcid; + public static Material Quinacridone; + public static Material Acetoacetanilide; + public static Material DiarylideYellow; + public static Material Quinizarin; + public static Material Toluidine; + public static Material AlizarineCyanineGreen; + public static Material Anthraquinone; + public static Material Aminoanthraquinone; + public static Material IndanthroneBlue; + public static Material Mauveine; + public static Material Isopropylsuccinate; + public static Material Benzonitrile; + public static Material Diketopyrrolopyrrole; + public static Material Indigo; + public static Material Tetrabromoindigo; + public static Material CyanIndigoDye; + public static Material Erythrosine; + //COILS public static Material Pikyonium; @@ -9845,7 +9897,413 @@ public static void register2() { .blast(2425) .build(); + ApatiteAcidicLeach = new Material.Builder(++id, gcylId("apatite_acidic_leach")) + .liquid() + .color(PhosphoricAcid.getMaterialRGB()) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("H10P3O12Cl??",true); + + PhosphorousArsenicSolution = new Material.Builder(++id, gcylId("phosphorous_arsenic_solution")) + .liquid() + .color(PhosphoricAcid.getMaterialRGB()) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("AsCd(HPO4)10",true); + + ApatiteSolidResidue = new Material.Builder(++id, gcylId("apatite_solid_residue")) + .dust() + .color(0x3cb290) + .flags(DISABLE_REPLICATION) + .iconSet(FINE) + .build() + .setFormula("Ca6PO4SiO3",true); + + FluoroApatite = new Material.Builder(++id, gcylId("fluoroapatite")) + .dust(2) + .color(Apatite.getMaterialRGB()) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .components(Calcium,5,Phosphate,3,Fluorine,1) + .build(); + + FluoroapatiteAcidicLeach = new Material.Builder(++id, gcylId("fluoroapatite_acidic_leach")) + .liquid(new FluidBuilder().attribute(ACID)) + .color(PhosphoricAcid.getMaterialRGB()) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("H10P3O12F??",true); + + FluoroapatiteSolidResidue = new Material.Builder(++id, gcylId("fluoroapatite_solid_residue")) + .dust() + .color(0x3cb290) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("Ca6PO4SiO3F",true); + + SodiumArsenate = new Material.Builder(++id, gcylId("sodium_arsenate")) + .dust() + .color(0xbffabf) + .flags(DISABLE_REPLICATION) + .iconSet(METALLIC) + .build() + .setFormula("Na3AsO4",true); + + FinelyPowderedRutile = new Material.Builder(++id, gcylId("finely_powdered_rutile")) + .dust() + .color(0xffffff) + .flags(DISABLE_REPLICATION) + .iconSet(FINE) + .build() + .setFormula("TiO2",true); + + RawSienna = new Material.Builder(++id, gcylId("raw_siena")) + .dust() + .color(0x663300) + .flags(DISABLE_REPLICATION) + .iconSet(ROUGH) + .build() + .setFormula("SiO2(MnO2)(FeO2)",true); + + BurnedSienna = new Material.Builder(++id, gcylId("burned_siena")) + .dust() + .color(0xff0000) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("SiO2(MnO2)(FeO2)",true); + + MercuryNitrate = new Material.Builder(++id, gcylId("mercury_nitrate")) + .liquid() + .color(0xd6b8ad) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("Hg(NO3)2",true); + + MercuryChloride = new Material.Builder(++id, gcylId("mercury_chloride")) + .dust() + .color(0xd6b8ad) + .flags(DISABLE_REPLICATION) + .iconSet(ROUGH) + .build() + .setFormula("HgCl2",true); + + MercuryIodide = new Material.Builder(++id, gcylId("mercury_iodide")) + .liquid() + .color(0xff0000) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("HgI2",true); + + BismuthVanadateSolution = new Material.Builder(++id, gcylId("bismuth_vanadate_solution")) + .liquid() + .color(0xffff00) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("(H2O)BiVO4",true); + + BismuthVanadate = new Material.Builder(++id, gcylId("bismuth_vanadate")) + .dust() + .color(0xffff00) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("BiVO4",true); + + CopperArsenite = new Material.Builder(++id, gcylId("copper_arsenite")) + .dust() + .color(0x66ff66) + .flags(DISABLE_REPLICATION) + .iconSet(ROUGH) + .build() + .setFormula("Cu3(AsO4)2",true); + + ScheelesGreen = new Material.Builder(++id, gcylId("scheeles_green")) + .dust() + .color(0x00ff00) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("AsCuHO3",true); + + CobaltZincOxide = new Material.Builder(++id, gcylId("cobalt_zinc_oxide")) + .dust() + .color(0x00ffff) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("CoZn4O5",true); + + CobaltAluminate = new Material.Builder(++id, gcylId("cobalt_aluminate")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(FINE) + .build() + .setFormula("Al2Co2O5",true); + + PotassiumFerrocyanide = new Material.Builder(++id, gcylId("potassium_ferrocyanide")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(ROUGH) + .build() + .setFormula("K4Fe(CN)6(H2O)3",true); + + PrussianBlue = new Material.Builder(++id, gcylId("prussian_blue")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("Fe4(Fe(CN)6)3",true); + + TitaniumYellow = new Material.Builder(++id, gcylId("titanium_yellow")) + .dust() + .color(0xffff00) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("NiO(Sb2O3)(TiO2)20",true); + + ManganeseIIIOxide = new Material.Builder(++id, gcylId("manganese_iii_oxide")) + .dust() + .color(Pyrolusite.getMaterialRGB()) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("Mn2O3",true); + + AmmoniumManganesePhosphate = new Material.Builder(++id, gcylId("ammonium_manganese_phosphate")) + .dust() + .color(0x660066) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("NH4MnPO4",true); + + HanPurple = new Material.Builder(++id, gcylId("hans_purple")) + .dust() + .color(0x660066) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("BaCuSi2O6",true); + + ChromeYellow = new Material.Builder(++id, gcylId("chrome_yellow")) + .dust() + .color(0xffff00) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("PbCrO4",true); + + ChromeOrange = new Material.Builder(++id, gcylId("chrome_orange")) + .dust() + .color(0xff6600) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("Pb2CrO5",true); + + Nitrotoluene = new Material.Builder(++id, gcylId("nitrotoluene")) + .liquid() + .color(0xfcca00) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C7H7NO2",true); + + DiaminostilbenedisulfonicAcid = new Material.Builder(++id, gcylId("diaminostilbenedisulfonic_acid")) + .dust() + .color(0xffffff) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C14H14N2O6S2",true); + + Nigrosin = new Material.Builder(++id, gcylId("nigrosin")) + .dust() + .color(0x000000) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C36H26N5ClNa2S2O6",true); + + SodiumSulfanilate = new Material.Builder(++id, gcylId("sodium_sulfanilate")) + .dust() + .color(0xe49879) + .flags(DISABLE_REPLICATION) + .iconSet(SHINY) + .build() + .setFormula("C6H6NNaO3S",true); + + Naphthylamine = new Material.Builder(++id, gcylId("naphthylamine")) + .liquid() + .color(0xe3e81c) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C10H9N",true); + + DirectBrown = new Material.Builder(++id, gcylId("direct_brown")) + .dust() + .color(0x663300) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C26H19N6NaO3S",true); + + DianilineterephthalicAcid = new Material.Builder(++id, gcylId("dianilineterephthalic_acid")) + .dust() + .color(0xff0000) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C20H16N2O4",true); + + Quinacridone = new Material.Builder(++id, gcylId("quinacridone")) + .dust() + .color(0xff0000) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C20H12N2O2",true); + + Acetoacetanilide = new Material.Builder(++id, gcylId("acetoacetanilide")) + .liquid() + .color(0xffffc2) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C10H11NO2",true); + + DiarylideYellow = new Material.Builder(++id, gcylId("diarylide_yellow")) + .liquid() + .color(0xffff00) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C32H26Cl2N6O4",true); + + Quinizarin = new Material.Builder(++id, gcylId("quinizarin")) + .liquid() + .color(0x3c5a2c0) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C14H8O4",true); + + Toluidine = new Material.Builder(++id, gcylId("toluidine")) + .liquid() + .color((Toluene.getMaterialRGB()+ Aniline.getMaterialRGB())/2) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C7H9N",true); + + AlizarineCyanineGreen = new Material.Builder(++id, gcylId("alizarine_cyanine_green")) + .dust() + .color(0x00ff00) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C28H20N2Na2O8S2",true); + + Anthraquinone = new Material.Builder(++id, gcylId("anthraquinone")) + .dust() + .color(0xfff782) + .flags(DISABLE_REPLICATION) + .iconSet(ROUGH) + .build() + .setFormula("C14H8O2",true); + + Aminoanthraquinone = new Material.Builder(++id, gcylId("aminoanthraquinone")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C14H9NO2",true); + + IndanthroneBlue = new Material.Builder(++id, gcylId("indanthrone_blue")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C28H14N2O2",true); + + Mauveine = new Material.Builder(++id, gcylId("mauveine")) + .dust() + .color(0x660066) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C26H23N4",true); + + Isopropylsuccinate = new Material.Builder(++id, gcylId("isopropylsuccinate")) + .liquid() + .color(0xb26680) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C7H12O4",true); + + Benzonitrile = new Material.Builder(++id, gcylId("benzonitrile")) + .liquid() + .color(0x2c2c9c) + .flags(DISABLE_REPLICATION) + .iconSet(FLUID) + .build() + .setFormula("C7H5N",true); + + Diketopyrrolopyrrole = new Material.Builder(++id, gcylId("diketopyrrolopyrrole")) + .dust() + .color(0xff6600) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C18H12N2O2",true); + + Indigo = new Material.Builder(++id, gcylId("indigo")) + .dust() + .color(0x0000ff) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C16H10N2O2",true); + Tetrabromoindigo = new Material.Builder(++id, gcylId("tetrabromoindigo")) + .dust() + .color(0x00ff00) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C16H6Br2N2O2",true); + + CyanIndigoDye = new Material.Builder(++id, gcylId("cyan_indigo_dye")) + .dust() + .color(0x009999) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("(C16H10N2O2)2Br2",true); + + Erythrosine = new Material.Builder(++id, gcylId("erythrosine")) + .dust() + .color(0xff00ff) + .flags(DISABLE_REPLICATION) + .iconSet(DULL) + .build() + .setFormula("C20H6I4Na2O5",true); /* = new Material.Builder(++id, gcylId("material")) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/chain/Dyes.java b/src/main/java/com/fulltrix/gcyl/recipes/chain/Dyes.java index 4d43f1e0..bf143257 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/chain/Dyes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/chain/Dyes.java @@ -1,13 +1,23 @@ package com.fulltrix.gcyl.recipes.chain; +import gregtech.api.recipes.ModHandler; +import gregtech.api.unification.OreDictUnifier; +import gregtech.api.unification.material.MarkerMaterial; +import gregtech.api.unification.material.MarkerMaterials; +import gregtech.api.unification.ore.OrePrefix; +import net.minecraft.item.ItemStack; + import static com.fulltrix.gcyl.materials.GCYLMaterials.*; -import static gregtech.api.recipes.RecipeMaps.CHEMICAL_RECIPES; +import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.CHEMICAL_DEHYDRATOR_RECIPES; +import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.CHEMICAL_PLANT_RECIPES; +import static gregtech.api.recipes.RecipeMaps.*; import static gregtech.api.unification.material.Materials.*; -import static gregtech.api.unification.ore.OrePrefix.dust; +import static gregtech.api.unification.ore.OrePrefix.*; +import static gregtech.common.items.MetaItems.SHAPE_MOLD_PLATE; public class Dyes { public static void init() { - /* + // Ca5(PO4)3Cl + H2SO4 -> 5 CaS(H2O)2O4 + [3 H3PO4 + HCl + ? + ?] CHEMICAL_BATH_RECIPES.recipeBuilder().duration(260).EUt(500) .input(dust, Apatite, 9) @@ -23,17 +33,17 @@ public static void init() { .input(dust, SiliconDioxide, 3) .fluidInputs(HydrochloricAcid.getFluid(1000)) .fluidOutputs(PhosphorousArsenicSolution.getFluid(3000)) - .outputs(ApatiteSolidResidue.getItemStack(11)) + .output(dust,ApatiteSolidResidue,11) .fluidOutputs(CarbonDioxide.getFluid(1000)) .buildAndRegister(); // [Na2SiCl6 + 0.25 Fe2O3] + 1.5 HCl -> SiCl4 + 2 NaCl + 0.5 FeCl3 + 0.75 H2O CENTRIFUGE_RECIPES.recipeBuilder().duration(320).EUt(500) .fluidInputs(HydrochloricAcid.getFluid(1500)) - .inputs(ApatiteSolidResidue.getItemStack(11)) - .outputs(SiliconChloride.getItemStack(5)) + .input(dust,ApatiteSolidResidue,11) + .output(dust,SiliconChloride,5) .output(dust, Salt, 2) - .fluidOutputs(IronChloride.getFluid(500)) + .fluidOutputs(Iron3Chloride.getFluid(500)) .fluidOutputs(Water.getFluid(750)) .buildAndRegister(); @@ -52,17 +62,17 @@ public static void init() { .input(dust, SiliconDioxide, 3) .fluidInputs(HydrochloricAcid.getFluid(1000)) .fluidOutputs(PhosphorousArsenicSolution.getFluid(3000)) - .outputs(FluoroapatiteSolidResidue.getItemStack(11)) + .output(dust,FluoroapatiteSolidResidue,11) .fluidOutputs(CarbonDioxide.getFluid(1000)) .buildAndRegister(); // [Na2SiF6 + 0.25 Fe2O3] + 3.5 HCl -> H2SiF6 + 2 NaCl + 0.5 FeCl3 + 0.75 H2O CENTRIFUGE_RECIPES.recipeBuilder().duration(320).EUt(500) .fluidInputs(HydrochloricAcid.getFluid(3500)) - .inputs(FluoroapatiteSolidResidue.getItemStack(11)) + .input(dust,FluoroapatiteSolidResidue,11) .fluidOutputs(FluorosilicicAcid.getFluid(1000)) .output(dust, Salt, 2) - .fluidOutputs(IronChloride.getFluid(500)) + .fluidOutputs(Iron3Chloride.getFluid(500)) .fluidOutputs(Water.getFluid(750)) .buildAndRegister(); @@ -71,25 +81,25 @@ public static void init() { .fluidInputs(PhosphorousArsenicSolution.getFluid(12000)) .input(dust, SodiumSulfide,6) .input(dust, SodiumHydroxide, 6) - .outputs(SodiumArsenate.getItemStack(16)) - .outputs(CadmiumSulfide.getItemStack(4)) + .output(dust,SodiumArsenate,16) + .output(dust,CadmiumSulfide,4) .fluidOutputs(PhosphoricAcid.getFluid(12000)) .buildAndRegister(); // 2Na3AsO4 + 5 H2SO4 + 4 NaI -> As2O3 + 5 Na2SO4(H2O) + 4 I LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(280).EUt(1100) - .inputs(SodiumArsenate.getItemStack(16)) + .input(dust,SodiumArsenate,16) .fluidInputs(SulfuricAcid.getFluid(5000)) - .inputs(SodiumIodide.getItemStack(8)) - .outputs(OreDictUnifier.get(dust, ArsenicTrioxide, 5)) + .input(dust,SodiumIodide,8) + .output(dust,ArsenicTrioxide, 5) .fluidOutputs(SodiumSulfateSolution.getFluid(5000)) .output(dust, Iodine, 4) .buildAndRegister(); // Na2O -> 2Na + O ELECTROLYZER_RECIPES.recipeBuilder().duration(240).EUt(30) - .inputs(SodiumOxide.getItemStack(3)) - .outputs(OreDictUnifier.get(dust, Sodium, 2)) + .input(dust,SodiumOxide,3) + .output(dust,Sodium, 2) .fluidOutputs(Oxygen.getFluid(1000)) .buildAndRegister(); @@ -97,29 +107,29 @@ public static void init() { ALLOY_SMELTER_RECIPES.recipeBuilder().duration(240).EUt(300) .input(dust, Cadmium) .input(dust, Sulfur) - .outputs(CadmiumSulfide.getItemStack(2)) + .output(dust,CadmiumSulfide,2) .buildAndRegister(); // CdS -> Cd + S ELECTROLYZER_RECIPES.recipeBuilder().duration(320).EUt(500) - .inputs(CadmiumSulfide.getItemStack(2)) - .outputs(OreDictUnifier.get(dust, Sulfur)) - .outputs(OreDictUnifier.get(dust, Cadmium)) + .input(dust,CadmiumSulfide,2) + .output(dust, Sulfur) + .output(dust, Cadmium) .buildAndRegister(); MACERATOR_RECIPES.recipeBuilder().duration(190).EUt(120) .input(dust, Rutile) - .outputs(FinelyPowderedRutile.getItemStack()) + .output(dust,FinelyPowderedRutile,1) .buildAndRegister(); ALLOY_SMELTER_RECIPES.recipeBuilder().duration(310).EUt(30) - .inputs(FinelyPowderedRutile.getItemStack()) + .input(dust,FinelyPowderedRutile,1) .notConsumable(SHAPE_MOLD_PLATE) .output(plate, Rutile) .buildAndRegister(); CHEMICAL_RECIPES.recipeBuilder().duration(450).EUt(480) - .inputs(FinelyPowderedRutile.getItemStack(3)) + .input(dust,FinelyPowderedRutile,3) .input(dust, Carbon) .fluidInputs(Chlorine.getFluid(4000)) .fluidOutputs(CarbonDioxide.getFluid(1000)) @@ -130,24 +140,24 @@ public static void init() { .input(dust, BrownLimonite,2) .input(dustTiny, SiliconDioxide) .input(dustTiny, Pyrolusite) - .outputs(RawSienna.getItemStack(2)) + .output(dust,RawSienna,2) .buildAndRegister(); MIXER_RECIPES.recipeBuilder().duration(320).EUt(32) .input(dust, YellowLimonite,2) .input(dustTiny, SiliconDioxide) .input(dustTiny, Pyrolusite) - .outputs(RawSienna.getItemStack(2)) + .output(dust,RawSienna,2) .buildAndRegister(); MIXER_RECIPES.recipeBuilder().duration(320).EUt(32) .input(dust, BandedIron,2) .input(dustTiny, SiliconDioxide) .input(dustTiny, Pyrolusite) - .outputs(RawSienna.getItemStack(2)) + .output(dust,RawSienna,2) .buildAndRegister(); - ModHandler.addSmeltingRecipe(RawSienna.getItemStack(), BurnedSienna.getItemStack()); + ModHandler.addSmeltingRecipe(OreDictUnifier.get(dust, RawSienna), OreDictUnifier.get(dust, BurnedSienna)); // Hg + 4 HNO3 -> 2 H2O + Hg(NO3)2 + 2 NO2 CHEMICAL_RECIPES.recipeBuilder().duration(210).EUt(500) @@ -162,22 +172,22 @@ public static void init() { CHEMICAL_RECIPES.recipeBuilder().duration(190).EUt(500) .fluidInputs(MercuryNitrate.getFluid(1000)) .fluidInputs(HydrochloricAcid.getFluid(2000)) - .outputs(MercuryChloride.getItemStack(3)) + .output(dust,MercuryChloride,3) .fluidOutputs(NitricAcid.getFluid(2000)) .buildAndRegister(); // HgCl2 + 2I + 2K -> HgI2 + 2KCl BLAST_RECIPES.recipeBuilder().duration(240).EUt(720).blastFurnaceTemp(700) - .inputs(MercuryChloride.getItemStack(3)) + .input(dust,MercuryChloride,3) .input(dust, Iodine, 2) .input(dust, Potassium, 2) - .outputs(MercuryIodide.getItemStack(3)) - .outputs(OreDictUnifier.get(dust, RockSalt, 4)) + .output(dust,MercuryIodide,3) + .output(dust,RockSalt, 4) .buildAndRegister(); // NH4VO3 + [Bi(NO3)3 + H2O] + 2 NH3 + H2O -> 3 NH4NO3 + BiVO4(H2O) CHEMICAL_RECIPES.recipeBuilder().duration(220).EUt(640) - .inputs(AmmoniumVanadate.getItemStack(9)) + .input(dust,AmmoniumVanadate,9) .fluidInputs(BismuthNitrateSoluton.getFluid(1000)) .fluidInputs(Ammonia.getFluid(2000)) .fluidInputs(Water.getFluid(1000)) @@ -188,7 +198,7 @@ public static void init() { // BiVO4(H2O) -> BiVO4 (H2O lost because it is a dehydration step) CHEMICAL_DEHYDRATOR_RECIPES.recipeBuilder().duration(190).EUt(600) .fluidInputs(BismuthVanadateSolution.getFluid(1000)) - .outputs(BismuthVanadate.getItemStack(6)) + .output(dust,BismuthVanadate,6) .buildAndRegister(); // As2O3 + 2 [CuSO4 + H2O] + 2 [NaOH + H2O] + Na2CO3 -> 2 CuAsHO3 + 2 [Na2SO4 + H2O] + CO2 (2 H2O voided) @@ -197,25 +207,25 @@ public static void init() { .fluidInputs(SodiumHydroxideSolution.getFluid(2000)) .input(dust, ArsenicTrioxide, 5) .input(dust, SodaAsh, 6) - .outputs(CopperArsenite.getItemStack(12)) + .output(dust,CopperArsenite,12) .fluidOutputs(CarbonDioxide.getFluid(1000)) .fluidOutputs(SodiumSulfateSolution.getFluid(2000)) .buildAndRegister(); - ModHandler.addSmeltingRecipe(CopperArsenite.getItemStack(), ScheelesGreen.getItemStack()); + ModHandler.addSmeltingRecipe(OreDictUnifier.get(dust, CopperArsenite), OreDictUnifier.get(dust,ScheelesGreen)); // 4ZnO + CoO -> Zn4CoO5 BLAST_RECIPES.recipeBuilder().duration(240).EUt(125).blastFurnaceTemp(500) .input(dust, Zincite,8) .input(dust, CobaltOxide, 2) - .outputs(CobaltZincOxide.getItemStack(10)) + .output(dust,CobaltZincOxide,10) .buildAndRegister(); // 2CoO + Al2O3 -> Al2Co2O5 BLAST_RECIPES.recipeBuilder().duration(240).EUt(125).blastFurnaceTemp(500) .input(dust, CobaltOxide, 4) - .inputs(Alumina.getItemStack(5)) - .outputs(CobaltAluminate.getItemStack(9)) + .input(dust,Alumina,5) + .output(dust,CobaltAluminate,9) .buildAndRegister(); // 6HCN + FeCl2 + 4 KOH -> K4Fe(CN)6 + 4H2O + 2 HCl @@ -223,16 +233,16 @@ public static void init() { .fluidInputs(Iron2Chloride.getFluid(1000)) .fluidInputs(HydrogenCyanide.getFluid(6000)) .fluidInputs(PotassiumHydroxide.getFluid(4000)) - .outputs(PotassiumFerrocyanide.getItemStack(17)) + .output(dust,PotassiumFerrocyanide,17) .fluidOutputs(HydrochloricAcid.getFluid(2000)) .fluidOutputs(Water.getFluid(4000)) .buildAndRegister(); // 3 K4Fe(CN)6 + 4 FeCl3 -> Fe7(CN)18 + 12 KCl CHEMICAL_BATH_RECIPES.recipeBuilder().duration(300).EUt(720) - .inputs(PotassiumFerrocyanide.getItemStack(51)) - .fluidInputs(IronChloride.getFluid(4000)) - .outputs(PrussianBlue.getItemStack(43)) + .input(dust,PotassiumFerrocyanide,51) + .fluidInputs(Iron3Chloride.getFluid(4000)) + .output(dust,PrussianBlue,43) .output(dust, RockSalt, 24) .buildAndRegister(); @@ -241,7 +251,7 @@ public static void init() { .input(dust, Rutile, 60) .input(dust, AntimonyTrioxide, 5) .input(dust, Garnierite, 2) - .outputs(TitaniumYellow.getItemStack(67)) + .output(dust,TitaniumYellow,67) .buildAndRegister(); // 2 MnO2 + Zn + H2SO4 -> ZnSO4 + Mn2O3 + H2O @@ -250,25 +260,25 @@ public static void init() { .input(dust, Zinc) .fluidInputs(SulfuricAcid.getFluid(1000)) .output(dust, ZincSulfate, 6) - .outputs(ManganeseIIIOxide.getItemStack(5)) + .output(dust,ManganeseIIIOxide,5) .fluidOutputs(Steam.getFluid(1000)) .buildAndRegister(); // Mn2O3 + 2NH3 + 4H3PO4 -> 2 NH4MnP2O7 + 5H2O CHEMICAL_RECIPES.recipeBuilder().duration(240).EUt(500) - .inputs(ManganeseIIIOxide.getItemStack(5)) + .input(dust,ManganeseIIIOxide,5) .fluidInputs(Ammonia.getFluid(2000)) .fluidInputs(PhosphoricAcid.getFluid(4000)) - .outputs(AmmoniumManganesePhosphate.getItemStack(30)) + .output(dust,AmmoniumManganesePhosphate,30) .fluidOutputs(Water.getFluid(5000)) .buildAndRegister(); // Cu2CH2O5 + 2BaCO3 + 4SiO2 -> 2BaCuSi2O6 + 3CO2 + H2O(lost) BLAST_RECIPES.recipeBuilder().duration(270).EUt(500).blastFurnaceTemp(1000) .input(dust, Malachite, 10) - .inputs(BariumCarbonate.getItemStack(10)) + .input(dust,BariumCarbonate,10) .input(dust, SiliconDioxide,12) - .outputs(HanPurple.getItemStack(20)) + .output(dust,HanPurple,20) .fluidOutputs(CarbonDioxide.getFluid(3000)) .buildAndRegister(); @@ -277,17 +287,17 @@ public static void init() { .input(dust, LeadNitrate, 18) .input(dust, PotassiumDichromate, 11) .fluidInputs(Water.getFluid(1000)) - .outputs(ChromeYellow.getItemStack(12)) + .output(dust,ChromeYellow,12) .fluidOutputs(NitricAcid.getFluid(2000)) .output(dust, Saltpeter, 10) .buildAndRegister(); // 2PbCrO4 + 2 NaOH -> Pb2CrO5 + [Na2CrO4 + H2O] CHEMICAL_RECIPES.recipeBuilder().duration(320).EUt(500) - .inputs(ChromeYellow.getItemStack(12)) + .input(dust,ChromeYellow,12) .input(dust, SodiumHydroxide, 6) .fluidOutputs(SodiumChromateSolution.getFluid(1000)) - .outputs(ChromeOrange.getItemStack(8)) + .output(dust,ChromeOrange,8) .buildAndRegister(); // C7H8 + [H2SO4 + HNO3] -> C7H7(NO2) + (H2SO4)2(H2O) @@ -302,23 +312,23 @@ public static void init() { //2C7H7(NO2) + 2H2SO4 + 2NaClO + 12 H -> C14H14N2O6S2 + 2NaCl + 8 H2O LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(340).EUt(1240) .notConsumable(dust, Zinc) - .inputs(SodiumHypochlorite.getItemStack(3)) + .input(dust,SodiumHypochlorite,3) .fluidInputs(Nitrotoluene.getFluid(1000)) .fluidInputs(SulfuricAcid.getFluid(2000)) - .outputs(DiaminostilbenedisulfonicAcid.getItemStack(19)) + .output(dust,DiaminostilbenedisulfonicAcid,19) .output(dust, Salt, 2) .fluidOutputs(Water.getFluid(4000)) .buildAndRegister(); // 4 C6H7N + 2 C6H5NO2 + HCl + 2 H2SO4 + 2 NaOH -> C36H26N5ClNa2S2O6 + 8 H2O + NH3 LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(200).EUt(1400) - .fluidInputs(NitroBenzene.getFluid(1000)) + .fluidInputs(Nitrobenzene.getFluid(1000)) .fluidInputs(Aniline.getFluid(2000)) .fluidInputs(HydrochloricAcid.getFluid(500)) .fluidInputs(SulfuricAcid.getFluid(1000)) .input(dust, SodiumHydroxide, 3) .notConsumable(dust, Copper) - .outputs(Nigrosin.getItemStack(39)) + .output(dust,Nigrosin,39) .fluidOutputs(Water.getFluid(4000)) .fluidOutputs(Ammonia.getFluid(500)) .buildAndRegister(); @@ -326,10 +336,11 @@ public static void init() { // NaOH + H2SO4 + C6H5NH2 -> 2 H2O + C6H6NNaO3S CHEMICAL_RECIPES.recipeBuilder().duration(240).EUt(1800) .input(dust, SodiumHydroxide, 3) + .circuitMeta(1) .fluidInputs(SulfuricAcid.getFluid(1000)) .fluidInputs(Aniline.getFluid(1000)) .fluidOutputs(Water.getFluid(2000)) - .outputs(SodiumSulfanilate.getItemStack(18)) + .output(dust,SodiumSulfanilate,18) .buildAndRegister(); //C10H8 + HNO3 + H2SO4 + 6 H -> C10H9N + H2SO4 + 3 H2O @@ -344,32 +355,32 @@ public static void init() { // C6H6NNaO3S + C10H9N + HCl + NaNO2 -> NaCl + C16H12N3NaO3S + 2 H2O LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(270).EUt(1800) - .inputs(SodiumSulfanilate.getItemStack(18)) + .input(dust,SodiumSulfanilate,18) .fluidInputs(Naphthylamine.getFluid(1000)) .fluidInputs(HydrochloricAcid.getFluid(1000)) - .inputs(SodiumNitrite.getItemStack(4)) - .outputs(OreDictUnifier.get(dust, Salt, 2)) + .input(dust,SodiumNitrite,4) + .output(dust, Salt, 2) .fluidOutputs(Water.getFluid(2000)) - .outputs(DirectBrown.getItemStack(36)) + .output(dust,DirectBrown,36) .buildAndRegister(); // 4 NaOH + 2 H2SO4 + 2 C4H6O4 + 2 C6H5NH2 + O -> 7 H2O + C20H16N2O4 + 2 [Na2SO4 + H2O] LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(260).EUt(1600) .input(dust, SodiumHydroxide, 12) .fluidInputs(SulfuricAcid.getFluid(2000)) - .inputs(SuccinicAcid.getItemStack(28)) + .input(dust,SuccinicAcid,28) .fluidInputs(Aniline.getFluid(2000)) .fluidInputs(Oxygen.getFluid(1000)) - .notConsumable(Ethanol) + .notConsumable(Ethanol.getFluid(1)) .fluidOutputs(Water.getFluid(7000)) .fluidOutputs(SodiumSulfateSolution.getFluid(2000)) - .outputs(DianilineterephthalicAcid.getItemStack(42)) + .output(dust,DianilineterephthalicAcid,42) .buildAndRegister(); // C20H16N2O4 -> C20H12N2O2 (2H2O lost) CHEMICAL_DEHYDRATOR_RECIPES.recipeBuilder().duration(220).EUt(1200) - .inputs(DianilineterephthalicAcid.getItemStack(7)) - .outputs(Quinacridone.getItemStack(6)) + .input(dust,DianilineterephthalicAcid,7) + .output(dust,Quinacridone,6) .buildAndRegister(); // 2 C2H2O + C6H5NH2 -> C10H11NO2 @@ -384,13 +395,12 @@ public static void init() { .fluidInputs(Acetoacetanilide.getFluid(1000)) .fluidInputs(Dichlorobenzidine.getFluid(500)) .fluidInputs(HydrochloricAcid.getFluid(1000)) - .inputs(SodiumNitrite.getItemStack(4)) - .outputs(OreDictUnifier.get(dust, Salt, 2)) - .outputs(DiarylideYellow.getItemStack(35)) + .input(dust,SodiumNitrite,4) + .output(dust,Salt, 2) + .output(dust,DiarylideYellow,35) .fluidOutputs(Water.getFluid(2000)) .buildAndRegister(); - */ // C7H8 + SO3 + NaCl -> C7H7SO3Na + HCl CHEMICAL_RECIPES.recipeBuilder().duration(220).EUt(950) @@ -401,7 +411,7 @@ public static void init() { .fluidOutputs(HydrochloricAcid.getFluid(1000)) .buildAndRegister(); - /* + // C6H4(OH)2 + C8H4O3 -> C14H8O4 + H2O CHEMICAL_RECIPES.recipeBuilder().duration(240).EUt(1400) @@ -419,8 +429,8 @@ public static void init() { .fluidInputs(SulfuricAcid.getFluid(2000)) .input(dust, SodiumHydroxide, 6) .notConsumable(BoricAcid.getFluid(1)) - .notConsumable(TinChloride.getItemStack()) - .outputs(AlizarineCyanineGreen.getItemStack(31)) + .notConsumable(dust,TinChloride,1) + .output(dust,AlizarineCyanineGreen,31) .fluidOutputs(Water.getFluid(6000)) .buildAndRegister(); @@ -428,9 +438,9 @@ public static void init() { CHEMICAL_RECIPES.recipeBuilder().duration(270).EUt(1800) .input(dust, PhthalicAnhydride, 15) .fluidInputs(Benzene.getFluid(1000)) - .outputs(Anthraquinone.getItemStack(24)) + .output(dust,Anthraquinone,24) .fluidOutputs(Water.getFluid(1000)) - .notConsumable(AluminiumChloride.getItemStack()) + .notConsumable(dust,AluminiumChloride,1) .buildAndRegister(); //C14H10 + K2Cr2O7 + H2SO4 -> C14H8O2 + Cr2O3 + K2SO4 + 2 H2O @@ -438,9 +448,9 @@ public static void init() { .fluidInputs(SulfuricAcid.getFluid(1000)) .fluidInputs(Anthracene.getFluid(1000)) .input(dust, PotassiumDichromate, 11) - .outputs(ChromiumIIIOxide.getItemStack(5)) - .outputs(Anthraquinone.getItemStack(24)) - .outputs(PotassiumSulfate.getItemStack(7)) + .output(dust,ChromiumIIIOxide,5) + .output(dust,Anthraquinone,24) + .output(dust,PotassiumSulfate,7) .fluidOutputs(Water.getFluid(2000)) .buildAndRegister(); @@ -452,18 +462,19 @@ public static void init() { .fluidInputs(SulfurTrioxide.getFluid(1000)) .fluidInputs(HydrogenPeroxide.getFluid(1000)) .fluidInputs(Ammonia.getFluid(1000)) - .inputs(Anthraquinone.getItemStack(24)) - .outputs(Aminoanthraquinone.getItemStack(26)) + .input(dust,Anthraquinone,24) + .circuitMeta(1) + .output(dust,Aminoanthraquinone,26) .fluidOutputs(DilutedSulfuricAcid.getFluid(3000)) .buildAndRegister(); //2 C14H9NO2 + 2 NaClO -> 2 NaCl + 2 H2O + C28H14N2O4 BLAST_RECIPES.recipeBuilder().duration(240).EUt(1400).blastFurnaceTemp(700) - .inputs(Aminoanthraquinone.getItemStack(52)) + .input(dust,Aminoanthraquinone,52) .notConsumable(PotassiumHydroxide.getFluid(1)) - .inputs(SodiumHypochlorite.getItemStack(6)) + .input(dust,SodiumHypochlorite,6) .output(dust, Salt, 4) - .outputs(IndanthroneBlue.getItemStack(48)) + .output(dust,IndanthroneBlue,48) .fluidOutputs(Water.getFluid(2000)) .buildAndRegister(); @@ -480,14 +491,14 @@ public static void init() { //C6H7N + 3 C7H9N + 2 KMnO4 + 7 HCl -> C27H25N4Cl + 2 KCl + 8 H2O + 2 MnCl2 LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(140).EUt(1340) - .inputs(PotassiumPermanganate.getItemStack(6)) + .input(dust,PotassiumPermanganate,6) .fluidInputs(Aniline.getFluid(500)) .fluidInputs(Toluidine.getFluid(1500)) .fluidInputs(HydrochloricAcid.getFluid(3500)) .fluidOutputs(Water.getFluid(4000)) .output(dust, RockSalt, 2) - .outputs(CopperChloride.getItemStack(3)) - .outputs(Mauveine.getItemStack(28)) + .output(dust,CopperChloride,3) + .output(dust,Mauveine,28) .buildAndRegister(); //3 C6H7N + 9 C7H9N + 5 K2Cr2O7 + 3 HCl -> 3 C27H25N4Cl + 10 KOH + 10 H2O + 5 Cr2O3 @@ -499,13 +510,13 @@ public static void init() { .fluidInputs(HydrochloricAcid.getFluid(600)) .fluidOutputs(Water.getFluid(2000)) .fluidOutputs(PotassiumHydroxide.getFluid(2000)) - .outputs(ChromiumIIIOxide.getItemStack(5)) - .outputs(Mauveine.getItemStack(34)) + .output(dust,ChromiumIIIOxide,5) + .output(dust,Mauveine,34) .buildAndRegister(); //C4H10 + 7 O -> C4H2O3 + 4 H2O CHEMICAL_RECIPES.recipeBuilder().duration(520).EUt(1340) - .notConsumable(BismuthVanadate.getItemStack()) + .notConsumable(dust,BismuthVanadate,1) .fluidInputs(Butane.getFluid(1000)) .fluidInputs(Oxygen.getFluid(7000)) .fluidOutputs(Water.getFluid(4000)) @@ -518,12 +529,12 @@ public static void init() { .fluidInputs(Hydrogen.getFluid(1000)) .fluidInputs(Water.getFluid(1000)) .notConsumable(dust, RhodiumPlatedPalladium) - .outputs(SuccinicAcid.getItemStack(14)) + .output(dust,SuccinicAcid,14) .buildAndRegister(); // C4H6O4 + 2 C3H8O -> C10H18O4 + 2 H2O CHEMICAL_RECIPES.recipeBuilder().duration(260).EUt(1400) - .inputs(SuccinicAcid.getItemStack(14)) + .input(dust,SuccinicAcid,14) .fluidInputs(IsopropylAlcohol.getFluid(2000)) .fluidOutputs(Isopropylsuccinate.getFluid(1000)) .fluidOutputs(Water.getFluid(2000)) @@ -542,10 +553,10 @@ public static void init() { CHEMICAL_RECIPES.recipeBuilder().duration(250).EUt(1700) .fluidInputs(Isopropylsuccinate.getFluid(1000)) .fluidInputs(Benzonitrile.getFluid(1000)) - .notConsumable(SodiumEthoxide.getItemStack()) + .notConsumable(dust,SodiumEthoxide,1) .notConsumable(IsopropylAlcohol.getFluid(10)) .fluidOutputs(IsopropylAlcohol.getFluid(1000)) - .outputs(Diketopyrrolopyrrole.getItemStack(32)) + .output(dust,Diketopyrrolopyrrole,32) .buildAndRegister(); //2 CH2O + 2 HCN + 2 C6H7N + 2O -> C16H10N2O2 + 2 H2O + 2 NH3 @@ -555,56 +566,57 @@ public static void init() { .fluidInputs(Aniline.getFluid(1000)) .fluidInputs(Oxygen.getFluid(1000)) .notConsumable(PotassiumHydroxide.getFluid(10)) - .notConsumable(SodiumAzanide.getItemStack()) + .notConsumable(dust,SodiumAzanide,1) .notConsumable(dust, SodiumHydroxide) - .outputs(Indigo.getItemStack(15)) + .output(dust,Indigo,15) .fluidOutputs(Water.getFluid(1000)) .fluidOutputs(Ammonia.getFluid(1000)) .buildAndRegister(); //C16H10N2O2 + 4 Br -> C16H6Br4N2O2 + 4 H CHEMICAL_RECIPES.recipeBuilder().duration(240).EUt(850) - .inputs(Indigo.getItemStack(30)) + .input(dust,Indigo,30) .fluidInputs(Bromine.getFluid(4000)) - .outputs(Tetrabromoindigo.getItemStack(30)) + .output(dust,Tetrabromoindigo,30) .fluidOutputs(Hydrogen.getFluid(4000)) .buildAndRegister(); MIXER_RECIPES.recipeBuilder().duration(270).EUt(250) - .inputs(Indigo.getItemStack()) - .inputs(Tetrabromoindigo.getItemStack()) - .outputs(CyanIndigoDye.getItemStack(2)) + .input(dust,Indigo,1) + .input(dust,Tetrabromoindigo,1) + .output(dust,CyanIndigoDye,2) .buildAndRegister(); //C8H4O3 + 2 C6H6O2 -> C20H12O5 + 2H2O CHEMICAL_RECIPES.recipeBuilder().duration(240).EUt(1150) .input(dust, PhthalicAnhydride, 15) .fluidInputs(Resorcinol.getFluid(2000)) - .outputs(Fluorescein.getItemStack(37)) + .output(dust,Fluorescein,37) .fluidOutputs(Water.getFluid(2000)) - .notConsumable(ZincChloride.getItemStack()) + .notConsumable(dust,ZincChloride) .buildAndRegister(); //C20H12O5 + 4 I + 2 NaOH -> C20H6I4Na2O5 + 4 H + 2 H2O LARGE_CHEMICAL_RECIPES.recipeBuilder().duration(150).EUt(750) .input(dust, Iodine, 4) .input(dust, SodiumHydroxide, 6) - .inputs(Fluorescein.getItemStack(37)) - .outputs(Erythrosine.getItemStack(37)) + .input(dust,Fluorescein,37) + .output(dust,Erythrosine,37) .fluidOutputs(Hydrogen.getFluid(4000)) .fluidOutputs(Water.getFluid(2000)) .buildAndRegister(); - ItemStack[][] color_dyes = {{OreDictUnifier.get(dust,Barite),FinelyPowderedRutile.getItemStack(),OreDictUnifier.get(dust,LeadNitrate), DiaminostilbenedisulfonicAcid.getItemStack()}, - {OreDictUnifier.get(dust,Carbon),OreDictUnifier.get(dust,Pyrolusite),Nigrosin.getItemStack()}, - {RawSienna.getItemStack(),DirectBrown.getItemStack()}, - {BurnedSienna.getItemStack(),MercuryIodide.getItemStack(),OreDictUnifier.get(dust,Cinnabar),Quinacridone.getItemStack()}, - {CadmiumSulfide.getItemStack(),BismuthVanadate.getItemStack(),TitaniumYellow.getItemStack(),ChromeYellow.getItemStack(),DiarylideYellow.getItemStack()}, - {OreDictUnifier.get(dust,Malachite),ScheelesGreen.getItemStack(),CobaltZincOxide.getItemStack(),AlizarineCyanineGreen.getItemStack()}, - {CobaltAluminate.getItemStack(),PrussianBlue.getItemStack(),IndanthroneBlue.getItemStack(),Indigo.getItemStack()}, - {AmmoniumManganesePhosphate.getItemStack(),HanPurple.getItemStack(),Mauveine.getItemStack()}, - {ChromeOrange.getItemStack(),Diketopyrrolopyrrole.getItemStack()}, - {CyanIndigoDye.getItemStack()},{Erythrosine.getItemStack()}}; + + ItemStack[][] color_dyes = {{OreDictUnifier.get(dust,Barite),OreDictUnifier.get(dust,FinelyPowderedRutile),OreDictUnifier.get(dust,LeadNitrate),OreDictUnifier.get(dust,DiaminostilbenedisulfonicAcid)}, + {OreDictUnifier.get(dust,Carbon),OreDictUnifier.get(dust,Pyrolusite),OreDictUnifier.get(dust,Nigrosin)}, + {OreDictUnifier.get(dust,RawSienna),OreDictUnifier.get(dust,DirectBrown)}, + {OreDictUnifier.get(dust,BurnedSienna),OreDictUnifier.get(dust,MercuryIodide),OreDictUnifier.get(dust,Cinnabar),OreDictUnifier.get(dust,Quinacridone)}, + {OreDictUnifier.get(dust,CadmiumSulfide),OreDictUnifier.get(dust,BismuthVanadate),OreDictUnifier.get(dust,TitaniumYellow),OreDictUnifier.get(dust,ChromeYellow),OreDictUnifier.get(dust,DiarylideYellow)}, + {OreDictUnifier.get(dust,Malachite),OreDictUnifier.get(dust,ScheelesGreen),OreDictUnifier.get(dust,CobaltZincOxide),OreDictUnifier.get(dust,AlizarineCyanineGreen)}, + {OreDictUnifier.get(dust,CobaltAluminate),OreDictUnifier.get(dust,PrussianBlue),OreDictUnifier.get(dust,IndanthroneBlue),OreDictUnifier.get(dust,Indigo)}, + {OreDictUnifier.get(dust,AmmoniumManganesePhosphate),OreDictUnifier.get(dust,HanPurple),OreDictUnifier.get(dust,Mauveine)}, + {OreDictUnifier.get(dust,ChromeOrange),OreDictUnifier.get(dust,Diketopyrrolopyrrole)}, + {OreDictUnifier.get(dust,CyanIndigoDye)},{OreDictUnifier.get(dust,Erythrosine)}}; MarkerMaterial[] colors = {MarkerMaterials.Color.White,MarkerMaterials.Color.Black,MarkerMaterials.Color.Brown,MarkerMaterials.Color.Red,MarkerMaterials.Color.Yellow, MarkerMaterials.Color.Green,MarkerMaterials.Color.Blue,MarkerMaterials.Color.Purple,MarkerMaterials.Color.Orange,MarkerMaterials.Color.Cyan,MarkerMaterials.Color.Pink}; @@ -613,7 +625,6 @@ public static void init() { OreDictUnifier.registerOre(color, OrePrefix.dye, colors[i]); } } - */ } } From f5af03756c948119b13896f5906a50209c4a0238 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 15:28:00 -0500 Subject: [PATCH 31/35] Remove GTCEu recipes related to naquadah --- .../item/behaviors/MinerDataItemBehavior.java | 6 ------ .../com/fulltrix/gcyl/jei/JEIGCYLPlugin.java | 13 ++++++++++++ .../fulltrix/gcyl/recipes/RecipeHandler.java | 3 ++- .../{machines => }/GreenhouseRecipes.java | 2 +- .../recipes/categories/RecipeOverride.java | 20 +++++++++++++++++++ 5 files changed, 36 insertions(+), 8 deletions(-) rename src/main/java/com/fulltrix/gcyl/recipes/categories/{machines => }/GreenhouseRecipes.java (97%) diff --git a/src/main/java/com/fulltrix/gcyl/item/behaviors/MinerDataItemBehavior.java b/src/main/java/com/fulltrix/gcyl/item/behaviors/MinerDataItemBehavior.java index 6e43542a..8c110d0f 100644 --- a/src/main/java/com/fulltrix/gcyl/item/behaviors/MinerDataItemBehavior.java +++ b/src/main/java/com/fulltrix/gcyl/item/behaviors/MinerDataItemBehavior.java @@ -1,18 +1,12 @@ package com.fulltrix.gcyl.item.behaviors; -import com.fulltrix.gcyl.recipes.GCYLRecipeMaps; import com.fulltrix.gcyl.recipes.categories.DeepMinerRecipes; import gregtech.api.items.metaitem.stats.IDataItem; import gregtech.api.items.metaitem.stats.IItemBehaviour; -import gregtech.api.recipes.Recipe; -import gregtech.api.recipes.RecipeMap; -import gregtech.api.recipes.machines.IResearchRecipeMap; -import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet; import net.minecraft.client.resources.I18n; import net.minecraft.item.ItemStack; import org.jetbrains.annotations.NotNull; -import java.util.Collection; import java.util.List; public class MinerDataItemBehavior implements IItemBehaviour, IDataItem { diff --git a/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java b/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java index 06465750..734aecfb 100644 --- a/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java +++ b/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java @@ -57,6 +57,19 @@ public void onRuntimeAvailable(IJeiRuntime jeiRuntime) { itemBlacklist.addIngredientToBlacklist(ADVANCED_SMD_TRANSISTOR.getStackForm()); itemBlacklist.addIngredientToBlacklist(SMD_INDUCTOR.getStackForm()); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dust, NaquadriaSulfate)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustSmall, NaquadriaSulfate)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustTiny, NaquadriaSulfate)); + + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dust, EnrichedNaquadahSulfate)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustSmall, EnrichedNaquadahSulfate)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustTiny, EnrichedNaquadahSulfate)); + + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dust, TriniumSulfide)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustSmall, TriniumSulfide)); + itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustTiny, TriniumSulfide)); + + //The list has to be in this order for some godforsaken reason TODO: make it work on manganese phosphide all the way. hide fluids //hide old superconductors diff --git a/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java b/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java index 22bcfb7c..ea7ed0ed 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/RecipeHandler.java @@ -2,7 +2,8 @@ import com.fulltrix.gcyl.recipes.categories.*; import com.fulltrix.gcyl.recipes.categories.circuits.CircuitRecipes; -import com.fulltrix.gcyl.recipes.categories.machines.GreenhouseRecipes; +import com.fulltrix.gcyl.recipes.categories.DeepMinerRecipes; +import com.fulltrix.gcyl.recipes.categories.GreenhouseRecipes; import com.fulltrix.gcyl.recipes.categories.machines.MachineCraftingRecipes; import com.fulltrix.gcyl.recipes.chain.*; diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/GreenhouseRecipes.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/GreenhouseRecipes.java similarity index 97% rename from src/main/java/com/fulltrix/gcyl/recipes/categories/machines/GreenhouseRecipes.java rename to src/main/java/com/fulltrix/gcyl/recipes/categories/GreenhouseRecipes.java index afbd544d..b944aabe 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/machines/GreenhouseRecipes.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/GreenhouseRecipes.java @@ -1,4 +1,4 @@ -package com.fulltrix.gcyl.recipes.categories.machines; +package com.fulltrix.gcyl.recipes.categories; import com.cleanroommc.groovyscript.api.IIngredient; import gregtech.common.blocks.MetaBlocks; diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 9b7a33b1..79ebe2c2 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -330,6 +330,26 @@ private static void recipeRemoval() { removeRecipesByInputs(ARC_FURNACE_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Cobalt)}, new FluidStack[]{Oxygen.getFluid(59)}); //antimony in arc furnace removeRecipesByInputs(ARC_FURNACE_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Antimony)}, new FluidStack[]{Oxygen.getFluid(121)}); + + //naquadah + removeRecipesByInputs(BLAST_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,NaquadriaSulfate, 6)}, new FluidStack[]{Hydrogen.getFluid(2000)}); + removeRecipesByInputs(BLAST_RECIPES, new ItemStack[]{OreDictUnifier.get(dust,EnrichedNaquadahSulfate, 6)}, new FluidStack[]{Hydrogen.getFluid(2000)}); + removeRecipesByInputs(BLAST_RECIPES, OreDictUnifier.get(dust, TriniumSulfide, 2), OreDictUnifier.get(dust, Zinc)); + removeRecipesByInputs(CENTRIFUGE_RECIPES, AcidicNaquadriaSolution.getFluid(3000)); + removeRecipesByInputs(MIXER_RECIPES, SulfuricAcid.getFluid(2000), NaquadriaSolution.getFluid(1000)); + removeRecipesByInputs(MIXER_RECIPES, SulfuricAcid.getFluid(2000), EnrichedNaquadahSolution.getFluid(1000)); + removeRecipesByInputs(LARGE_CHEMICAL_RECIPES, new ItemStack[]{OreDictUnifier.get(dust, Naquadah,6)}, new FluidStack[]{FluoroantimonicAcid.getFluid(1000)}); + removeRecipesByInputs(CENTRIFUGE_RECIPES, ImpureNaquadriaSolution.getFluid(2000)); + removeRecipesByInputs(CENTRIFUGE_RECIPES, ImpureEnrichedNaquadahSolution.getFluid(2000)); + removeRecipesByInputs(DISTILLATION_RECIPES, NaquadriaWaste.getFluid(2000)); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(1)}, new FluidStack[]{NaquadriaWaste.getFluid(200)}); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(2)}, new FluidStack[]{NaquadriaWaste.getFluid(200)}); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(3)}, new FluidStack[]{NaquadriaWaste.getFluid(400)}); + removeRecipesByInputs(DISTILLATION_RECIPES, EnrichedNaquadahWaste.getFluid(2000)); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(1)}, new FluidStack[]{EnrichedNaquadahWaste.getFluid(200)}); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(2)}, new FluidStack[]{EnrichedNaquadahWaste.getFluid(200)}); + removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(3)}, new FluidStack[]{EnrichedNaquadahWaste.getFluid(400)}); + } public static void chemistryOverride() { From 761310397d725c2057cd25c6b19c662be4e84745 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 15:49:54 -0500 Subject: [PATCH 32/35] Add some unification data to correct issues --- .../gcyl/recipes/helper/GCYLComponents.java | 94 +++++++++++++++++++ 1 file changed, 94 insertions(+) diff --git a/src/main/java/com/fulltrix/gcyl/recipes/helper/GCYLComponents.java b/src/main/java/com/fulltrix/gcyl/recipes/helper/GCYLComponents.java index cb1ae415..08d35c0d 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/helper/GCYLComponents.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/helper/GCYLComponents.java @@ -1,6 +1,10 @@ package com.fulltrix.gcyl.recipes.helper; +import gregtech.api.GTValues; +import gregtech.api.unification.material.Materials; +import gregtech.api.unification.ore.OrePrefix; import gregtech.api.unification.stack.UnificationEntry; +import gregtech.loaders.recipe.CraftingComponent; import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static gregtech.api.unification.material.Materials.*; @@ -70,6 +74,96 @@ public static void initializeComponents() { }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + CraftingComponent.CABLE = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtSingle, Materials.RedAlloy) }, + { 1, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Tin) }, + { 2, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Copper) }, + { 3, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Gold) }, + { 4, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Aluminium) }, + { 5, new UnificationEntry(OrePrefix.cableGtSingle, Platinum) }, + { 6, new UnificationEntry(OrePrefix.cableGtSingle, Materials.NiobiumTitanium) }, + { 7, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Naquadah) }, + { 8, new UnificationEntry(OrePrefix.cableGtSingle, Materials.NaquadahAlloy) }, + { 9, new UnificationEntry(OrePrefix.cableGtSingle, TungstenTitaniumCarbide) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + + CraftingComponent.CABLE_QUAD = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.RedAlloy) }, + { 1, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Tin) }, + { 2, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Copper) }, + { 3, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Gold) }, + { 4, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Aluminium) }, + { 5, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Platinum) }, + { 6, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.NiobiumTitanium) }, + { 7, new UnificationEntry(OrePrefix.cableGtQuadruple, Naquadah) }, + { 8, new UnificationEntry(OrePrefix.cableGtQuadruple, NaquadahAlloy) }, + { 9, new UnificationEntry(OrePrefix.cableGtQuadruple, TungstenTitaniumCarbide) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + + CraftingComponent.CABLE_OCT = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtOctal, Materials.RedAlloy) }, + { 1, new UnificationEntry(OrePrefix.cableGtOctal, Materials.Tin) }, + { 2, new UnificationEntry(OrePrefix.cableGtOctal, Materials.Copper) }, + { 3, new UnificationEntry(OrePrefix.cableGtOctal, Materials.Gold) }, + { 4, new UnificationEntry(OrePrefix.cableGtOctal, Materials.Aluminium) }, + { 5, new UnificationEntry(OrePrefix.cableGtOctal, Materials.Platinum) }, + { 6, new UnificationEntry(OrePrefix.cableGtOctal, Materials.NiobiumTitanium) }, + { 7, new UnificationEntry(OrePrefix.cableGtOctal, Naquadah) }, + { 8, new UnificationEntry(OrePrefix.cableGtOctal, NaquadahAlloy) }, + { 9, new UnificationEntry(OrePrefix.cableGtOctal, TungstenTitaniumCarbide) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + + CraftingComponent.CABLE_HEX = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtHex, Materials.RedAlloy) }, + { 1, new UnificationEntry(OrePrefix.cableGtHex, Materials.Tin) }, + { 2, new UnificationEntry(OrePrefix.cableGtHex, Materials.Copper) }, + { 3, new UnificationEntry(OrePrefix.cableGtHex, Materials.Gold) }, + { 4, new UnificationEntry(OrePrefix.cableGtHex, Materials.Aluminium) }, + { 5, new UnificationEntry(OrePrefix.cableGtHex, Materials.Platinum) }, + { 6, new UnificationEntry(OrePrefix.cableGtHex, Materials.NiobiumTitanium) }, + { 7, new UnificationEntry(OrePrefix.cableGtHex, Naquadah) }, + { 8, new UnificationEntry(OrePrefix.cableGtHex, NaquadahAlloy) }, + { 9, new UnificationEntry(OrePrefix.cableGtHex, TungstenTitaniumCarbide) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + + CraftingComponent.CABLE_TIER_UP = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Tin) }, + { 1, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Copper) }, + { 2, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Gold) }, + { 3, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Aluminium) }, + { 4, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Platinum) }, + { 5, new UnificationEntry(OrePrefix.cableGtSingle, Materials.NiobiumTitanium) }, + { 6, new UnificationEntry(OrePrefix.cableGtSingle, Naquadah) }, + { 7, new UnificationEntry(OrePrefix.cableGtSingle, NaquadahAlloy) }, + { 8, new UnificationEntry(OrePrefix.cableGtSingle, TungstenTitaniumCarbide) }, + { GTValues.FALLBACK, new UnificationEntry(OrePrefix.cableGtSingle, Materials.Europium) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + + CraftingComponent.CABLE_QUAD_TIER_UP = new Component(Stream.of(new Object[][] { + + { 0, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Tin) }, + { 1, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Copper) }, + { 2, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Gold) }, + { 3, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Aluminium) }, + { 4, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Platinum) }, + { 5, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.NiobiumTitanium) }, + { 6, new UnificationEntry(OrePrefix.cableGtQuadruple, Naquadah) }, + { 7, new UnificationEntry(OrePrefix.cableGtQuadruple, NaquadahAlloy) }, + { 8, new UnificationEntry(OrePrefix.cableGtQuadruple, TungstenTitaniumCarbide) }, + { GTValues.FALLBACK, new UnificationEntry(OrePrefix.cableGtQuadruple, Materials.Europium) }, + + }).collect(Collectors.toMap(data -> (Integer) data[0], data -> data[1]))); + } } From 993cf7229b574bdad17d28a8389d34bf09164cb2 Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 16:25:53 -0500 Subject: [PATCH 33/35] Disable IV+ circuit assemblers Change Large Circuit Assembler recipe --- .../com/fulltrix/gcyl/jei/JEIGCYLPlugin.java | 6 ++++ .../recipes/categories/RecipeOverride.java | 36 ++++++++++++++++--- 2 files changed, 38 insertions(+), 4 deletions(-) diff --git a/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java b/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java index 734aecfb..d51206ba 100644 --- a/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java +++ b/src/main/java/com/fulltrix/gcyl/jei/JEIGCYLPlugin.java @@ -17,6 +17,7 @@ import static gregtech.api.unification.material.Materials.*; import static gregtech.common.blocks.BlockWireCoil.CoilType.*; import static gregtech.common.items.MetaItems.*; +import static gregtech.common.metatileentities.MetaTileEntities.CIRCUIT_ASSEMBLER; @JEIPlugin @@ -69,6 +70,11 @@ public void onRuntimeAvailable(IJeiRuntime jeiRuntime) { itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustSmall, TriniumSulfide)); itemBlacklist.addIngredientToBlacklist(OreDictUnifier.get(OrePrefix.dustTiny, TriniumSulfide)); + for (int i = 5; i < 14; i++) { + itemBlacklist.addIngredientToBlacklist(CIRCUIT_ASSEMBLER[i].getStackForm()); + } + + //The list has to be in this order for some godforsaken reason TODO: make it work on manganese phosphide all the way. hide fluids diff --git a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java index 79ebe2c2..d327d0bc 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/categories/RecipeOverride.java @@ -1,5 +1,8 @@ package com.fulltrix.gcyl.recipes.categories; +import gregicality.multiblocks.common.block.GCYMMetaBlocks; +import gregicality.multiblocks.common.block.blocks.BlockLargeMultiblockCasing; +import gregicality.multiblocks.common.metatileentities.GCYMMetaTileEntities; import gregtech.api.GTValues; import gregtech.api.fluids.store.FluidStorageKeys; import gregtech.api.items.armor.ArmorMetaItem; @@ -11,10 +14,7 @@ import gregtech.api.unification.material.MarkerMaterials; import gregtech.api.unification.stack.UnificationEntry; import gregtech.common.ConfigHolder; -import gregtech.common.blocks.BlockComputerCasing; -import gregtech.common.blocks.BlockFusionCasing; -import gregtech.common.blocks.BlockMachineCasing; -import gregtech.common.blocks.MetaBlocks; +import gregtech.common.blocks.*; import gregtech.common.items.MetaItems; import gregtech.common.metatileentities.MetaTileEntities; import net.minecraft.init.Items; @@ -24,9 +24,11 @@ import static com.fulltrix.gcyl.materials.GCYLMaterials.*; import static com.fulltrix.gcyl.item.GCYLCoreItems.*; import static gregicality.multiblocks.api.recipes.GCYMRecipeMaps.ALLOY_BLAST_RECIPES; +import static gregicality.multiblocks.api.unification.GCYMMaterials.Stellite100; import static gregtech.api.GTValues.*; import static gregtech.api.recipes.GTRecipeHandler.removeRecipesByInputs; import static gregtech.api.recipes.ModHandler.removeRecipeByName; +import static gregtech.api.recipes.ModHandler.removeTieredRecipeByName; import static gregtech.api.recipes.RecipeMaps.*; import static gregtech.api.recipes.ingredients.IntCircuitIngredient.getIntegratedCircuit; import static gregtech.api.unification.material.MarkerMaterials.Color.*; @@ -350,6 +352,15 @@ private static void recipeRemoval() { removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(2)}, new FluidStack[]{EnrichedNaquadahWaste.getFluid(200)}); removeRecipesByInputs(DISTILLERY_RECIPES, new ItemStack[]{getIntegratedCircuit(3)}, new FluidStack[]{EnrichedNaquadahWaste.getFluid(400)}); + //circuit assemblers + removeTieredRecipeByName("gregtech:gregtech.machine.circuit_assembler.",IV,OpV); + + //gcym circuit assembler + removeRecipeByName("gcym:large_circuit_assembler"); + + //large scale assembler casing + removeRecipeByName("gcym:casing_large_assembler"); + removeRecipesByInputs(ASSEMBLER_RECIPES,getIntegratedCircuit(6) ,OreDictUnifier.get(plate, Stellite100,6), OreDictUnifier.get(frameGt, Tungsten)); } public static void chemistryOverride() { @@ -1182,6 +1193,23 @@ public static void gregtechOverride() { .CWUt(32)) .buildAndRegister(); + //large circuit assembler + ModHandler.addShapedRecipe("gcyl_circuit_assembler", GCYMMetaTileEntities.LARGE_CIRCUIT_ASSEMBLER.getStackForm(), + "ARA", "CHC", "ARA", + 'A', MULTIBLOCK_CASING.getItemVariant(BlockMultiblockCasing.MultiblockCasingType.ASSEMBLY_CONTROL), + 'R', ROBOT_ARM_LuV, + 'C', new UnificationEntry(circuit, MarkerMaterials.Tier.LuV), + 'H', HULL[6].getStackForm()); + + //large scale assembler casing + ASSEMBLER_RECIPES.recipeBuilder().EUt(GTValues.VA[IV]).duration(200) + .circuitMeta(6) + .input(plate, Stellite100, 24) + .input(frameGt, Tungsten, 4) + .inputs(MULTIBLOCK_CASING.getItemVariant(BlockMultiblockCasing.MultiblockCasingType.ASSEMBLY_CONTROL)) + .fluidInputs(HastelloyN.getFluid(L * 16)) + .outputs(GCYMMetaBlocks.LARGE_MULTIBLOCK_CASING.getItemVariant(BlockLargeMultiblockCasing.CasingType.ASSEMBLING_CASING, 4 * ConfigHolder.recipes.casingsPerCraft)) + .buildAndRegister(); } From 3a253c6f6137689fa59598a41386e1254429cedc Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 17:05:08 -0500 Subject: [PATCH 34/35] Set a sound for the Decay Chamber recipe map Add additional computation components Add additional cooling components --- .../gcyl/machines/GCYLTileEntities.java | 29 +++---- .../MetaTileEntityHPCAComputationPlus.java | 86 +++++++++++++++++++ .../MetaTileEntityHPCACoolingPlus.java | 77 +++++++++++++++++ .../fulltrix/gcyl/recipes/GCYLRecipeMaps.java | 5 +- 4 files changed, 180 insertions(+), 17 deletions(-) create mode 100644 src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCAComputationPlus.java create mode 100644 src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCACoolingPlus.java diff --git a/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java b/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java index 48cb1b4e..5fbe4e37 100644 --- a/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java +++ b/src/main/java/com/fulltrix/gcyl/machines/GCYLTileEntities.java @@ -10,6 +10,8 @@ import com.fulltrix.gcyl.machines.multi.advance.*; import com.fulltrix.gcyl.machines.multi.miner.MetaTileEntityDeepMiner; import com.fulltrix.gcyl.machines.multi.miner.MetaTileEntityVoidMiner; +import com.fulltrix.gcyl.machines.multi.multiblockpart.MetaTileEntityHPCAComputationPlus; +import com.fulltrix.gcyl.machines.multi.multiblockpart.MetaTileEntityHPCACoolingPlus; import com.fulltrix.gcyl.machines.multi.multiblockpart.MetaTileEntitySterileCleaningMaintenanceHatch; import com.fulltrix.gcyl.machines.multi.simple.MetaTileEntityChemicalPlant; import com.fulltrix.gcyl.machines.multi.simple.MetaTileEntityDecayChamber; @@ -23,11 +25,15 @@ import gregtech.client.renderer.texture.Textures; import gregtech.common.metatileentities.MetaTileEntities; import gregtech.common.metatileentities.multi.multiblockpart.MetaTileEntityEnergyHatch; +import gregtech.common.metatileentities.multi.multiblockpart.hpca.MetaTileEntityHPCAComputation; import net.minecraft.util.ResourceLocation; import static com.fulltrix.gcyl.GCYLUtility.gcylId; import static com.fulltrix.gcyl.recipes.GCYLRecipeMaps.DEEP_MINER_RECIPES; +import static com.google.common.base.Ascii.toLowerCase; +import static com.ibm.icu.impl.locale.AsciiUtil.toLower; import static gregtech.api.util.GTUtility.gregtechId; +import static gregtech.api.util.GTUtility.toLowerCaseUnderscore; import static gregtech.common.metatileentities.MetaTileEntities.registerMetaTileEntity; public class GCYLTileEntities { @@ -55,6 +61,8 @@ public class GCYLTileEntities { public static MetaTileEntitySterileCleaningMaintenanceHatch STERILE_CLEANING_MAINTENANCE_HATCH; + public static MetaTileEntityHPCACoolingPlus[] HPCA_COOLING_PLUS = new MetaTileEntityHPCACoolingPlus[7]; + public static MetaTileEntityHPCAComputationPlus[] HPCA_COMPUTATION_PLUS = new MetaTileEntityHPCAComputationPlus[7]; public static SimpleGeneratorMetaTileEntity[] NAQUADAH_REACTOR = new SimpleGeneratorMetaTileEntity[8]; public static SimpleGeneratorMetaTileEntity[] ROCKET_GENERATOR = new SimpleGeneratorMetaTileEntity[8]; @@ -118,6 +126,12 @@ public static void init() { GREEN_HOUSE[1] = registerMetaTileEntity(++id, new MetaTileEntityGreenhouse(gcylId("greenhouse_uv"), 8)); MEGA_CLEANROOM = registerMetaTileEntity(++id, new MetaTileEntityMegaCleanroom(gcylId("mega_cleanroom"))); + + for(int i = 0; i < 7; i++) { + HPCA_COOLING_PLUS[i] = registerMetaTileEntity(++id, new MetaTileEntityHPCACoolingPlus(gcylId("hpca.cooling_component." + toLowerCase(GTValues.VN[i+8])), i+8)); + HPCA_COMPUTATION_PLUS[i] = registerMetaTileEntity(++id, new MetaTileEntityHPCAComputationPlus(gcylId("hpca.computation_component." + toLowerCase(GTValues.VN[i+8])), i+8)); + + } //TODO: configurable efficiency for naq reactors, efficiency implementation in general /* @@ -145,21 +159,6 @@ public static void init() { ROCKET_GENERATOR[5] = registerMetaTileEntity(++id, new SimpleGeneratorMetaTileEntity(gcylId("rocket_generator.mk3"), GCYLRecipeMaps.ROCKET_FUEL_RECIPES, ClientHandler.ROCKET_OVERLAY, 6, GTUtility.genericGeneratorTankSizeFunction)); //} - //TODO: figure this out - /* - for(int i = 10; i<13 ; i++) { - String voltageName = GTValues.VN[i].toLowerCase(); - ENERGY_INPUT_HATCH_4A[i-10] = registerMetaTileEntity(++id, - new MetaTileEntityEnergyHatch(tjfId("energy_hatch.input_4a"+voltageName),i,4,false)); - ENERGY_OUTPUT_HATCH_4A[i-10] = registerMetaTileEntity(++id, - new MetaTileEntityEnergyHatch(tjfId("energy_hatch.input_4a"+voltageName),i,4,true)); - ENERGY_INPUT_HATCH_16A[i-10] = registerMetaTileEntity(++id, - new MetaTileEntityEnergyHatch(tjfId("energy_hatch.input_16a"+voltageName),i,16,false)); - ENERGY_OUTPUT_HATCH_16A[i-10] = registerMetaTileEntity(++id, - new MetaTileEntityEnergyHatch(tjfId("energy_hatch.input_16a"+voltageName),i,16,true)); - } - - */ MetaTileEntities.registerSimpleMetaTileEntity(DEHYDRATOR, ++id, "dehydrator", GCYLRecipeMaps.CHEMICAL_DEHYDRATOR_RECIPES, Textures.SIFTER_OVERLAY, true, GCYLUtility::gcylId, GTUtility.hvCappedTankSizeFunction); } diff --git a/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCAComputationPlus.java b/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCAComputationPlus.java new file mode 100644 index 00000000..d8ac391c --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCAComputationPlus.java @@ -0,0 +1,86 @@ +package com.fulltrix.gcyl.machines.multi.multiblockpart; + +import gregtech.api.GTValues; +import gregtech.api.capability.IHPCAComputationProvider; +import gregtech.api.gui.GuiTextures; +import gregtech.api.gui.resources.TextureArea; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.interfaces.IGregTechTileEntity; +import gregtech.client.renderer.texture.Textures; +import gregtech.client.renderer.texture.cube.SimpleOverlayRenderer; +import gregtech.common.metatileentities.multi.multiblockpart.hpca.MetaTileEntityHPCAComponent; +import net.minecraft.util.ResourceLocation; + +//TODO: Make better textures +public class MetaTileEntityHPCAComputationPlus extends MetaTileEntityHPCAComponent implements IHPCAComputationProvider { + + private final int tier; + private final boolean advanced = true; + + public MetaTileEntityHPCAComputationPlus(ResourceLocation metaTileEntityId, int tier) { + super(metaTileEntityId); + this.tier = tier; + } + + @Override + public MetaTileEntity createMetaTileEntity(IGregTechTileEntity tileEntity) { + return new MetaTileEntityHPCAComputationPlus(metaTileEntityId, tier); + } + + @Override + public boolean isAdvanced() { + return true; + } + + public int getTier() { + return tier; + } + + @Override + public SimpleOverlayRenderer getFrontOverlay() { + if (isDamaged()) return advanced ? Textures.HPCA_ADVANCED_DAMAGED_OVERLAY : Textures.HPCA_DAMAGED_OVERLAY; + return advanced ? Textures.HPCA_ADVANCED_COMPUTATION_OVERLAY : Textures.HPCA_COMPUTATION_OVERLAY; + } + + @Override + public SimpleOverlayRenderer getFrontActiveOverlay() { + if (isDamaged()) return advanced ? Textures.HPCA_ADVANCED_DAMAGED_ACTIVE_OVERLAY : Textures.HPCA_DAMAGED_ACTIVE_OVERLAY; + return advanced ? Textures.HPCA_ADVANCED_COMPUTATION_ACTIVE_OVERLAY : Textures.HPCA_COMPUTATION_ACTIVE_OVERLAY; + } + + @Override + public int getUpkeepEUt() { + return GTValues.VA[tier - 2]; + } + + @Override + public int getMaxEUt() { + return GTValues.VA[tier]; + } + + @Override + public int getCWUPerTick() { + if (isDamaged()) return 0; + return (int) Math.pow(2, tier - 3); + } + + @Override + public int getCoolingPerTick() { + return (int) Math.pow(2, tier - 5); + } + + @Override + public boolean canBeDamaged() { + return true; + } + + @Override + public TextureArea getComponentIcon() { + if (isDamaged()) { + return advanced ? GuiTextures.HPCA_ICON_DAMAGED_ADVANCED_COMPUTATION_COMPONENT : + GuiTextures.HPCA_ICON_DAMAGED_COMPUTATION_COMPONENT; + } + return advanced ? GuiTextures.HPCA_ICON_ADVANCED_COMPUTATION_COMPONENT : + GuiTextures.HPCA_ICON_COMPUTATION_COMPONENT; + } +} \ No newline at end of file diff --git a/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCACoolingPlus.java b/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCACoolingPlus.java new file mode 100644 index 00000000..626bfc90 --- /dev/null +++ b/src/main/java/com/fulltrix/gcyl/machines/multi/multiblockpart/MetaTileEntityHPCACoolingPlus.java @@ -0,0 +1,77 @@ +package com.fulltrix.gcyl.machines.multi.multiblockpart; + +import gregtech.api.GTValues; +import gregtech.api.capability.IHPCACoolantProvider; +import gregtech.api.gui.GuiTextures; +import gregtech.api.gui.resources.TextureArea; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.interfaces.IGregTechTileEntity; +import gregtech.client.renderer.texture.Textures; +import gregtech.client.renderer.texture.cube.SimpleOverlayRenderer; +import gregtech.common.metatileentities.multi.multiblockpart.hpca.MetaTileEntityHPCAComponent; +import net.minecraft.util.ResourceLocation; + +public class MetaTileEntityHPCACoolingPlus extends MetaTileEntityHPCAComponent implements IHPCACoolantProvider { + + private final int tier; + private final boolean advanced = true; + + public MetaTileEntityHPCACoolingPlus(ResourceLocation metaTileEntityId, int tier) { + super(metaTileEntityId); + this.tier = tier; + } + + @Override + public MetaTileEntity createMetaTileEntity(IGregTechTileEntity tileEntity) { + return new MetaTileEntityHPCACoolingPlus(metaTileEntityId, tier); + } + + @Override + public boolean isAdvanced() { + return true; + } + + public int getTier() { + return tier; + } + + @Override + public SimpleOverlayRenderer getFrontOverlay() { + return advanced ? Textures.HPCA_ACTIVE_COOLER_OVERLAY : Textures.HPCA_HEAT_SINK_OVERLAY; + } + + @Override + public SimpleOverlayRenderer getFrontActiveOverlay() { + return advanced ? Textures.HPCA_ACTIVE_COOLER_ACTIVE_OVERLAY : getFrontOverlay(); + } + + @Override + public int getUpkeepEUt() { + return GTValues.VA[tier - 2]; + } + + @Override + public boolean canBeDamaged() { + return false; + } + + @Override + public TextureArea getComponentIcon() { + return GuiTextures.HPCA_ICON_ACTIVE_COOLER_COMPONENT; + } + + @Override + public int getCoolingAmount() { + return (int) Math.pow(2, tier - 6); + } + + @Override + public boolean isActiveCooler() { + return advanced; + } + + @Override + public int getMaxCoolantPerTick() { + return (int) Math.pow(2, tier - 4); + } +} diff --git a/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java b/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java index 908e1134..9d78d6d3 100644 --- a/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java +++ b/src/main/java/com/fulltrix/gcyl/recipes/GCYLRecipeMaps.java @@ -45,8 +45,9 @@ private GCYLRecipeMaps() { //public static final RecipeMap NUCLEAR_BREEDER_RECIPES = new RecipeMap<>("nuclear_breeder", 4, 4, 0, 0, new NuclearReactorBuilder().EUt(1920),false); //NUCLEAR_MARK - public static final RecipeMap DECAY_CHAMBERS_RECIPES = new RecipeMap<>("decay_chamber", 2, 4, 1, 1, new SimpleRecipeBuilder().EUt(30), false) - .setProgressBar(GuiTextures.PROGRESS_BAR_HAMMER, ProgressWidget.MoveType.VERTICAL); //NUCLEAR_MARK + public static final RecipeMap DECAY_CHAMBERS_RECIPES = new RecipeMap<>("decay_chamber", 2, 4, 1, 1, new SimpleRecipeBuilder(), false) + .setProgressBar(GuiTextures.PROGRESS_BAR_HAMMER, ProgressWidget.MoveType.VERTICAL) + .setSound(GTSoundEvents.ARC); //NUCLEAR_MARK public static final RecipeMap ADV_FUSION_RECIPES = new RecipeMap<>("adv_fusion", 0, 0, 3, 3, new AdvFusionRecipeBuilder(), false) .setSound(GTSoundEvents.ARC); From ffad47154a12d3b55c8a533121837a19857d682e Mon Sep 17 00:00:00 2001 From: brian Date: Mon, 10 Jun 2024 17:08:21 -0500 Subject: [PATCH 35/35] readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index ee4720e5..e3a76cbd 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,6 @@ # GCYL: CEu -## Currently in alpha. A survival play through is impossible and not supported. Find breaks in progression, overlapping recipes, missing recipes, useless recipes, etc. and submit problems and suggestions with GitHub issues. +## Currently in alpha. LV-UV should be playable. Breaking changes may come without support for your world. Find breaks in progression, overlapping recipes, missing recipes, useless recipes, etc. and submit problems and suggestions with GitHub issues. ### Accelerated playtesting is reasonable now. Gregicality Legacy Port to CEu (specifically with reference to the Technological Journey fork)