Spoilage

docs/content/Modpacks/Other-Topics/Machine-Modification.md

@@ -0,0 +1,10 @@
+---
+title: Machine Modification
+---
+
+# Machine Modification
+If you want to modify an existing machine's definition, you can do so using the
+`GTCEuStartupEvents.machineModification` event. It is fired right before a machine gets registered, so that
+its builder is still accessible through the `event.getBuilder()` method. For examples of methods that machine builders
+have, see [Custom Machines](Custom-Machines.md).
+For a full list of methods, see [source](https://github.com/GregTechCEu/GregTech-Modern/blob/1.20.1/src/main/java/com/gregtechceu/gtceu/api/registry/registrate/MachineBuilder.java).

docs/content/Modpacks/Other-Topics/Spoilage.md

@@ -0,0 +1,158 @@
+---
+title: Spoilage
+---
+
+**Spoilage** is a mechanic that allows items to *spoil*.<br>
+Spoilable items spoil based on the amount of ticks that passed from their creation,
+or, more specifically, from one of these events (due to Minecraft's limitations):
+
+- The item was in an `IItemHandler` that is a capability of a `BlockEntity` that had `Level#getBlockEntity` called
+- The item was crafted in a GregTech recipe
+- The item was crafted in a crafting table
+- The item was in a player's inventory for at least 1 tick
+- The item was dropped
+- `SpoilUtils.update(ItemStack, SpoilContext)` was called
+
+If you want to make an item spoil, you need to attack the `ISpoilableItem` capability to it.
+Please note that the spoilage timer still decrements even if the stack is in an unloaded chunk.
+
+### SpoilContext
+A `SpoilContext` is an object that represents the environment in which an item spoils.
+It may represent:
+
+- Nothing (all values are null, obtained by just calling the constructor without arguments)
+- A block (contains `Level` and `BlockPos`)
+- A block and an item handler (contains `Level`, `BlockPos`, `IItemHandler` and the number of the slot in that `IItemHandler`, that may be `-1`)
+- An entity, usually a player (contains `Entity` and the number of the slot in that entity's inventory, that may be `-1`)
+
+This info is used to spawn entities when the item spoils, or do something more complex.
+The `SpoilableBehavior.builder()` can accept a function as a `result`, so you can do whatever you want there :)
+
+### SpoilableBehavior
+`SpoilableBehavior` is a helper class used to make items spoilable.
+
+`SpoilableBehavior.builder()` is a convenient way to create a `SpoilableBehavior`, currently it has the following methods:
+
+- `.ticks(long)`
+    used to specify ticks until spoiled
+- `.ticks(Function<ItemStack, Long>)`
+    used to specify a ticks until spoiled value that may depend on the stack itself, for example having more items in the stack may make it spoil slower
+- `.result(ItemLike)`
+    used to specify the resulting item
+- `.result(ItemStack)`
+    used to specify the resulting stack (may be with NBT, but not count)
+- `.result(Function<ItemStack, ItemStack>)`
+    used to specify the resulting stack that may depend on the original stack
+- `.result(EntityType<? extends Mob>)`
+    used to specify the mob into which the item will spoil (it can still spoil into an item as well, but the item has to be specified first)
+- `.result(Supplier<? extends EntityType<? extends Mob>>`
+    same as `.result(EntityType<? extends Mob>)`, exists for convenience
+- `.result(SpoilResultProvider)`
+    used to specify a result function ((`ItemStack`, `SpoilContext`, `simulate`) -> `ItemStack`) for custom spoiling logic
+- `.multiplyResult(int)`
+    multiply all previously specified results (spoil into multiple items, spawn multiple mobs, etc.)
+- `.tooltip(Component)`
+    used to specify things to show in `Spoils into: ...` in the tooltip
+- `.tooltip(Function<ItemStack, Component>)`
+    same as `.tooltip(Component)`, but can depend on the stack
+
+To attach a `SpoilableBehavior` to an item, you can use the `attachTo(ItemLike)` method.
+It can be chained if you want to make multiple items spoil using the same behavior.
+
+### SpoilUtils
+`SpoilUtils` is a utility class with some static methods for updating items and blocks:
+
+- `update`
+    makes an item start spoiling with the specified `SpoilContext`
+- `updateBlock`
+    updates all items in any found `IItemHandler` capabilities of the specified block,
+    the `SpoilContext` is generated automatically
+
+!!! example
+    ```java
+    public class Example {
+
+        // Make diamonds spoil into dirt and a dragon in 100 seconds, apples into jigsaws in 35 seconds
+        public static void attachSpoilables() {
+            SpoilageBehaviour.builder()
+                    .ticks(20*100)
+                    .result(Items.DIRT)
+                    .result(EntityType.ENDER_DRAGON)
+                    .build().attachTo(Items.DIAMOND);
+            SpoilableBehaviour.builder()
+                    .ticks(20*35)
+                    .result(Items.JIGSAW)
+                    .build().attachTo(Items.APPLE);
+        }
+
+        public void getAndSetValuesAndStuff(ItemStack stack) {
+            ISpoilableItem spoilable = GTCapabilityHelper.getSpoilable(stack);
+            // If spoilable is null, it means the stack cannot spoil
+            if (spoilable != null) {
+                // Get amount of ticks until a completely fresh stack spoils
+                long totalTicks = spoilable.getSpoilTicks(stack);
+                // Get amount of ticks until this stack spoils (may be more than the previous value in some cases)
+                long ticksRemaining = spoilable.getTicksUntilSpoiled(stack);
+                // Get the stack this stack spoils into
+                ItemStack spoilResult = spoilable.spoilResult(stack);
+                // Get whether this stack should START spoiling
+                boolean shouldStartSpoiling = spoilable.shouldSpoil(stack);
+                // Get the amount of ticks until this stack spoils (may be more than spoilable.getSpoilTicks(stack))
+                spoilable.setTicksUntilSpoiled(stack, 12345);
+                // Freeze the spoiling progress of this stack
+                spoilable.freezeSpoiling(stack);
+                // Unfreeze the spoiling progress of this stack
+                spoilable.unfreezeSpoiling(stack);
+            }
+        }
+
+        public void makeStackStartSpoiling(ItemStack stack, Level level, BlockPos pos) {
+            // If for some reason the stack still hasn't started spoiling, you can start the spoiling progress using this
+            // That may happen if it is the result of a non-GT recipe and not a crafting result for example
+            SpoilUtils.update(stack, new SpoilContext(level, pos));
+        }
+
+        public void disableFrozenAndNonFrozenEquality() {
+            // If you want the player to have frozen stacks in their inventory, do this
+            // A side effect of this is that filtering by ticks remaining until spoiled will no longer work
+            SpoilUtils.FROZEN_EQUALITY = false;
+        }
+    }
+    ```
+
+!!! warning "Items may spoil in other mods' filters (even if they are phantom slots)."
+
+### Frozen stacks
+
+To freeze a stack's spoiling progress, you can use `spoilable.freezeSpoiling(stack)`, and `spoilable.unfreezeSpoiling(stack)`
+to unfreeze. A frozen stack's freshness will never be changed unless `spoilable.setTicksUntilSpoiled(stack, value)` is called.
+Currently, a stack is frozen only if it is in a phantom slot (in a GregTech filter).
+!!! warning "`ItemHandlerHelper.canItemStacksStack` behaviour is completely different for spoilables"
+
+    `ItemHandlerHelper.canItemStacksStack` returns `true` if:
+
+    - Both items are not frozen and:
+        - They are the same item
+        - They have the same NBT
+        - **Their ticks until spoiling are averaged before the equality check**
+    - One of the items is frozen and:
+        - They are the same item
+        - They have the same non-spoilage-related NBT
+        - **One of them MAY be not frozen, and they will still be equal if `ISpoilableItem.FROZEN_EQUALITY` is `true`**
+        - **Their ticks until spoiling are NOT modified in any way in this method**
+
+    !!! info "The following only applies if `ISpoilableItem.FROZEN_EQUALITY` is `true`:"
+        That means that frozen and non-frozen spoilables may stack, this is done mostly to make filtering by remaining ticks possible.
+        **Please prevent the player from having direct access to frozen stacks, as they could use them to bypass the spoiling system entirely.**
+
+### Spoilables in recipes
+
+If a GT recipe that does not have spoilable ingredients outputs a spoilable, it is outputted at full freshness.
+If a GT recipe that has spoilable ingredients outputs a spoilable, it outputs it at the freshness level equal to the average
+freshness of the ingredients. This can be overridden by setting `keepSpoilingProgress` (a parameter of the GTRecipe) to `false`.
+<br><br>
+Results of crafts in a crafting table are always outputted fully fresh.
+
+!!! note
+
+    Items will spoil in machine inputs, and there's no way to automatically remove items from inputs.

docs/content/Modpacks/Recipes/Adding-and-Removing-Recipes.md

@@ -141,7 +141,9 @@ to distinguish them from other recipes in the same machine with similar ingredie
       running or all at once at recipe start/end. Set to true with `.perTick(true)` to make the recipe builder consider
       any following input/output calls as per-tick. Remember to set the value to false with `.perTick(false)` after the
       calls you intend to be per-tick, to prevent behaviour you don't want!
-
+    - `.keepSpoilingProgress()`:
+      If set to true, spoilable outputs' freshness will depend on the recipe's inputs' freshness (default).<br>
+      If set to false, spoilable outputs of this recipe will always be crafted completely fresh.
 
 ### The Research System
 

src/generated/resources/assets/gtceu/lang/en_ud.json

@@ -1749,6 +1749,7 @@
   "config.gtceu.option.allowDrumsInputFluidsFromOutputSide": "ǝpıSʇndʇnOɯoɹℲspınןℲʇnduIsɯnɹᗡʍoןןɐ",
   "config.gtceu.option.allowedImageDomains": "suıɐɯoᗡǝbɐɯIpǝʍoןןɐ",
   "config.gtceu.option.animationTime": "ǝɯı⟘uoıʇɐɯıuɐ",
+  "config.gtceu.option.aprilFoolsMode": "ǝpoWsןooℲןıɹdɐ",
   "config.gtceu.option.arcRecyclingYield": "pןǝıʎbuıןɔʎɔǝᴚɔɹɐ",
   "config.gtceu.option.armorHud": "pnHɹoɯɹɐ",
   "config.gtceu.option.batchDuration": "uoıʇɐɹnᗡɥɔʇɐq",
@@ -3863,13 +3864,22 @@
   "gtceu.tool_action.wrench.set_facing": "buıɔɐℲ ʇǝs oʇ ɥɔuǝɹM ǝs∩8§",
   "gtceu.tooltip.computer_monitor_config": "ɐʇɐp uoıʇɐɹnbıɟuoɔ ɹǝʌoɔ ɹoʇıuoɯ ɹǝʇndɯoɔ buıɹoʇS",
   "gtceu.tooltip.computer_monitor_data": "%s :ɐʇɐp buıɹoʇS",
+  "gtceu.tooltip.creation_tick": "%d ʞɔıʇ pןɹoʍɹǝʌo uo pǝʇɐǝɹƆ",
   "gtceu.tooltip.fluid_pipe_hold_shift": "oɟuI ʇuǝɯuıɐʇuoƆ pınןℲ ʍoɥs oʇ ⟘ℲIHS pןoHㄥ§",
   "gtceu.tooltip.hold_ctrl": "oɟuı ǝɹoɯ ɹoɟ Ꞁᴚ⟘Ɔ pןoHㄥ§",
   "gtceu.tooltip.hold_shift": "oɟuı ǝɹoɯ ɹoɟ ⟘ℲIHS pןoHㄥ§",
+  "gtceu.tooltip.item_handler_data": "%s :ɐʇɐp ɹǝןpuɐH",
+  "gtceu.tooltip.item_handler_source": "%s :ǝɔɹnos ɹǝןpuɐH",
+  "gtceu.tooltip.location": ")%d '%d '%d( %s :uoıʇɐɔoꞀ",
+  "gtceu.tooltip.location_entity": "%s :ʎʇıʇuƎ",
+  "gtceu.tooltip.location_slot": "%s :ʇoןS",
   "gtceu.tooltip.player_bind": "%s :ɹǝʎɐןd oʇ punoᗺ",
   "gtceu.tooltip.potion.each": "ɹ§buıuǝddɐɥ ɟo ǝɔuɐɥɔㄥ§ %s%% ɹ§ɐ ɥʇıʍ sʞɔıʇㄥ§ %s ɹ§ɹoɟㄥ§ %s %s",
   "gtceu.tooltip.potion.header": ":sʇɔǝɟɟǝ suıɐʇuoƆ9§",
   "gtceu.tooltip.proxy_bind": "%s %s %s ʇɐ ɹǝɟɟnᗺ uɹǝʇʇɐԀ ɐ oʇ buıpuıᗺɟ§",
+  "gtceu.tooltip.spoil_time_remaining": "%s :sןıods ןıʇun ǝɯı⟘",
+  "gtceu.tooltip.spoil_time_total": "%s :ǝɯıʇ ןıods ןɐʇo⟘",
+  "gtceu.tooltip.spoils_into": "%s :oʇuı sןıodS",
   "gtceu.tooltip.status.trinary.false": "ǝsןɐℲ",
   "gtceu.tooltip.status.trinary.true": "ǝnɹ⟘",
   "gtceu.tooltip.status.trinary.unknown": "uʍouʞu∩",

src/generated/resources/assets/gtceu/lang/en_us.json

@@ -1749,6 +1749,7 @@
   "config.gtceu.option.allowDrumsInputFluidsFromOutputSide": "allowDrumsInputFluidsFromOutputSide",
   "config.gtceu.option.allowedImageDomains": "allowedImageDomains",
   "config.gtceu.option.animationTime": "animationTime",
+  "config.gtceu.option.aprilFoolsMode": "aprilFoolsMode",
   "config.gtceu.option.arcRecyclingYield": "arcRecyclingYield",
   "config.gtceu.option.armorHud": "armorHud",
   "config.gtceu.option.batchDuration": "batchDuration",
@@ -3863,13 +3864,22 @@
   "gtceu.tool_action.wrench.set_facing": "§8Use Wrench to set Facing",
   "gtceu.tooltip.computer_monitor_config": "Storing computer monitor cover configuration data",
   "gtceu.tooltip.computer_monitor_data": "Storing data: %s",
+  "gtceu.tooltip.creation_tick": "Created on overworld tick %d",
   "gtceu.tooltip.fluid_pipe_hold_shift": "§7Hold SHIFT to show Fluid Containment Info",
   "gtceu.tooltip.hold_ctrl": "§7Hold CTRL for more info",
   "gtceu.tooltip.hold_shift": "§7Hold SHIFT for more info",
+  "gtceu.tooltip.item_handler_data": "Handler data: %s",
+  "gtceu.tooltip.item_handler_source": "Handler source: %s",
+  "gtceu.tooltip.location": "Location: %s (%d, %d, %d)",
+  "gtceu.tooltip.location_entity": "Entity: %s",
+  "gtceu.tooltip.location_slot": "Slot: %s",
   "gtceu.tooltip.player_bind": "Bound to player: %s",
   "gtceu.tooltip.potion.each": "%s %s §7for§r %s §7ticks with a§r %s%% §7chance of happening§r",
   "gtceu.tooltip.potion.header": "§6Contains effects:",
   "gtceu.tooltip.proxy_bind": "§fBinding to a Pattern Buffer at %s %s %s",
+  "gtceu.tooltip.spoil_time_remaining": "Time until spoils: %s",
+  "gtceu.tooltip.spoil_time_total": "Total spoil time: %s",
+  "gtceu.tooltip.spoils_into": "Spoils into: %s",
   "gtceu.tooltip.status.trinary.false": "False",
   "gtceu.tooltip.status.trinary.true": "True",
   "gtceu.tooltip.status.trinary.unknown": "Unknown",

src/main/java/com/gregtechceu/gtceu/api/GTValues.java

@@ -1,5 +1,7 @@
 package com.gregtechceu.gtceu.api;
 
+import com.gregtechceu.gtceu.config.ConfigHolder;
+
 import net.minecraft.util.RandomSource;
 
 import java.time.LocalDate;
@@ -272,6 +274,7 @@ public static int[] tiersBetween(int minInclusive, int maxInclusive) {
             0x7EC3C4, 0x7EB07E, 0xBF74C0, 0x0B5CFE, 0x914E91, 0x488748, 0x8C0000, 0x2828F5 };
 
     // Main colour for each tier
+    @SuppressWarnings("DataFlowIssue")
     public static final int[] VCM = new int[] {
             DARK_GRAY.getColor(),
             GRAY.getColor(),
@@ -308,6 +311,7 @@ public static int[] tiersBetween(int minInclusive, int maxInclusive) {
     public static boolean HT = false;
 
     public static BooleanSupplier FOOLS = () -> {
+        if (ConfigHolder.INSTANCE != null && ConfigHolder.INSTANCE.client.aprilFoolsMode) return true;
         var now = LocalDate.now();
         return now.getMonth() == Month.APRIL && now.getDayOfMonth() == 1;
     };

src/main/java/com/gregtechceu/gtceu/api/capability/GTCapability.java

@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.capability;
 
+import com.gregtechceu.gtceu.api.item.component.ISpoilableItem;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 
 import net.minecraftforge.common.capabilities.Capability;
@@ -32,6 +33,8 @@ public class GTCapability {
             .get(new CapabilityToken<>() {});
     public static final Capability<IMonitorComponent> CAPABILITY_MONITOR_COMPONENT = CapabilityManager
             .get(new CapabilityToken<>() {});
+    public static final Capability<ISpoilableItem> CAPABILITY_SPOILABLE_ITEM = CapabilityManager
+            .get(new CapabilityToken<>() {});
 
     public static final Capability<IMedicalConditionTracker> CAPABILITY_MEDICAL_CONDITION_TRACKER = CapabilityManager
             .get(new CapabilityToken<>() {});
@@ -51,5 +54,6 @@ public static void register(RegisterCapabilitiesEvent event) {
         event.register(IMedicalConditionTracker.class);
         event.register(IHazardParticleContainer.class);
         event.register(IMonitorComponent.class);
+        event.register(ISpoilableItem.class);
     }
 }

src/main/java/com/gregtechceu/gtceu/api/capability/GTCapabilityHelper.java

@@ -1,5 +1,6 @@
 package com.gregtechceu.gtceu.api.capability;
 
+import com.gregtechceu.gtceu.api.item.component.ISpoilableItem;
 import com.gregtechceu.gtceu.api.machine.feature.multiblock.IMaintenanceMachine;
 
 import net.minecraft.core.BlockPos;
@@ -126,4 +127,9 @@ private static <T> T getBlockEntityCapability(Capability<T> capability, Level le
     public static IMedicalConditionTracker getMedicalConditionTracker(@NotNull Entity entity) {
         return entity.getCapability(GTCapability.CAPABILITY_MEDICAL_CONDITION_TRACKER, null).resolve().orElse(null);
     }
+
+    @Nullable
+    public static ISpoilableItem getSpoilable(ItemStack stack) {
+        return stack.getCapability(GTCapability.CAPABILITY_SPOILABLE_ITEM).resolve().orElse(null);
+    }
 }

src/main/java/com/gregtechceu/gtceu/api/capability/recipe/RecipeCapability.java

@@ -38,6 +38,9 @@ public abstract class RecipeCapability<T> {
     public static final Codec<Map<RecipeCapability<?>, List<Content>>> CODEC = new DispatchedMapCodec<>(
             RecipeCapability.DIRECT_CODEC,
             RecipeCapability::contentCodec);
+    public static final Codec<Map<RecipeCapability<?>, List<?>>> INGREDIENT_CODEC = new DispatchedMapCodec<>(
+            RecipeCapability.DIRECT_CODEC,
+            RecipeCapability::ingredientCodec);
     public static final Comparator<RecipeCapability<?>> COMPARATOR = Comparator.comparingInt(o -> o.sortIndex);
 
     public final String name;
@@ -59,6 +62,10 @@ public static Codec<List<Content>> contentCodec(RecipeCapability<?> capability)
         return Content.codec(capability).listOf();
     }
 
+    public static <T> Codec<List<T>> ingredientCodec(RecipeCapability<T> capability) {
+        return Content.ingredientCodec(capability).listOf();
+    }
+
     public Tag contentToNbt(Object value) {
         return this.serializer.toNbt(this.of(value));
     }

src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandler.java

@@ -53,7 +53,7 @@ public FilterHandler(ISyncManaged container) {
         this.container = container;
     }
 
-    protected abstract F loadFilter(ItemStack filterItem);
+    public abstract F loadFilter(ItemStack filterItem);
 
     protected abstract F getEmptyFilter();
 

src/main/java/com/gregtechceu/gtceu/api/cover/filter/FilterHandlers.java

@@ -11,7 +11,7 @@ static FilterHandler<ItemStack, ItemFilter> item(ISyncManaged container) {
         return new FilterHandler<>(container) {
 
             @Override
-            protected ItemFilter loadFilter(ItemStack filterItem) {
+            public ItemFilter loadFilter(ItemStack filterItem) {
                 return ItemFilter.loadFilter(filterItem);
             }
 
@@ -31,7 +31,7 @@ static FilterHandler<FluidStack, FluidFilter> fluid(ISyncManaged container) {
         return new FilterHandler<>(container) {
 
             @Override
-            protected FluidFilter loadFilter(ItemStack filterItem) {
+            public FluidFilter loadFilter(ItemStack filterItem) {
                 return FluidFilter.loadFilter(filterItem);
             }