diff --git a/.github/workflows/build_artifacts.yml b/.github/workflows/build_artifacts.yml index ee8577c..6c1c10e 100644 --- a/.github/workflows/build_artifacts.yml +++ b/.github/workflows/build_artifacts.yml @@ -14,13 +14,13 @@ jobs: - uses: actions/checkout@v4 - name: Set up JDK 21 - uses: actions/setup-java@v4 + uses: actions/setup-java@v5 with: java-version: '21' distribution: 'temurin' - name: Setup Gradle - uses: gradle/actions/setup-gradle@v4 + uses: gradle/actions/setup-gradle@v5 with: cache-read-only: false @@ -30,20 +30,23 @@ jobs: - name: Generate resources with Gradle run: ./gradlew runDatagenClient env: - CUSTOM_VERSION: ${{ env.short_commit_hash }} + PRESERVE_PRERELEASE_VERSION: true DISABLE_PROPERTIES_UPDATE: true + VERSION_SUFFIX: ${{ env.short_commit_hash }} - name: Build with Gradle run: ./gradlew build env: - CUSTOM_VERSION: ${{ env.short_commit_hash }} + PRESERVE_PRERELEASE_VERSION: true DISABLE_PROPERTIES_UPDATE: true + VERSION_SUFFIX: ${{ env.short_commit_hash }} - name: Publish to Maven run: ./gradlew publishMavenPublicationToOffsetMonkey538Repository env: - CUSTOM_VERSION: ${{ env.short_commit_hash }} + PRESERVE_PRERELEASE_VERSION: true DISABLE_PROPERTIES_UPDATE: true + VERSION_SUFFIX: ${{ env.short_commit_hash }} MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }} MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }} diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml index c1f31e6..c9d030d 100644 --- a/.github/workflows/publish.yml +++ b/.github/workflows/publish.yml @@ -16,13 +16,13 @@ jobs: - uses: actions/checkout@v4 - name: Set up JDK 21 - uses: actions/setup-java@v4 + uses: actions/setup-java@v5 with: java-version: '21' distribution: 'temurin' - name: Setup Gradle - uses: gradle/actions/setup-gradle@v4 + uses: gradle/actions/setup-gradle@v5 with: cache-read-only: false @@ -32,29 +32,35 @@ jobs: - name: Generate resources with Gradle run: ./gradlew runDatagenClient env: + IS_RELEASE: true DISABLE_PROPERTIES_UPDATE: true - name: Build with Gradle run: ./gradlew build env: + IS_RELEASE: true DISABLE_PROPERTIES_UPDATE: true - name: Upload to Modrinth run: ./gradlew modrinth env: + IS_RELEASE: true + DISABLE_PROPERTIES_UPDATE: true MODRINTH_TOKEN: ${{ secrets.MODRINTH_TOKEN }} VERSION_NAME: ${{ github.event.release.name }} VERSION_IS_PRERELEASE: ${{ github.event.release.prerelease }} VERSION_CHANGELOG: ${{ github.event.release.body }} - - name: Upload to GitHub - uses: softprops/action-gh-release@v2 - with: - files: build/libs/*.jar - - name: Publish to Maven run: ./gradlew publishMavenPublicationToOffsetMonkey538Repository env: + IS_RELEASE: true + DISABLE_PROPERTIES_UPDATE: true MAVEN_USERNAME: ${{ secrets.MAVEN_USERNAME }} MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }} + + - name: Upload to GitHub + uses: softprops/action-gh-release@v2 + with: + files: build/libs/*.jar diff --git a/build.gradle b/build.gradle index bba62c3..2a84be7 100644 --- a/build.gradle +++ b/build.gradle @@ -1,5 +1,7 @@ import dex.plugins.outlet.v2.util.ReleaseType +import java.nio.file.Files + plugins { id 'fabric-loom' version '1.11-SNAPSHOT' id 'io.github.dexman545.outlet' version '1.6.1' @@ -7,31 +9,39 @@ plugins { id 'maven-publish' } -sourceCompatibility = JavaVersion.VERSION_17 -targetCompatibility = JavaVersion.VERSION_17 - -archivesBaseName = "loot-table-modifier" -group = "top.offsetmonkey538.loottablemodifier" +ext { + versionPrefix = rootProject.mod_version + if (!Boolean.parseBoolean(System.getenv("IS_RELEASE"))) { + String preReleaseVersion = System.currentTimeMillis() + if (Boolean.parseBoolean(System.getenv("PRESERVE_PRERELEASE_VERSION"))) { + var preReleaseVersionFile = file("preReleaseVersion.txt").toPath() + if (Files.exists(preReleaseVersionFile)) preReleaseVersion = Files.readString(preReleaseVersionFile) + Files.writeString(preReleaseVersionFile, preReleaseVersion) + } -version = project.mod_version + var separator = "-" + if (versionPrefix.contains("-")) separator = "." + versionPrefix = "${versionPrefix}${separator}${preReleaseVersion}" + } + final String versionSuffix = System.getenv("VERSION_SUFFIX") + if (versionSuffix != null && !versionSuffix.isEmpty()) { + versionPrefix = "${versionPrefix}+${versionSuffix}" + } -if ("true".equalsIgnoreCase(System.getenv("IS_DEBUG"))) { - version = "${version}-${System.currentTimeMillis()}" + System.out.println("Version Prefix: " + versionPrefix) } -final String customVersion = System.getenv("CUSTOM_VERSION") -if (customVersion != null && !customVersion.isEmpty()) { - version = "${version}-${customVersion}" +allprojects { + group = "top.offsetmonkey538.loottablemodifier" + base.archivesName = "mesh-lib" // todo: move to subprojects and give em different suffixes + version = "${rootProject.versionPrefix}+${project.property("minecraft_version")}" // todo: again, move to subprojects } -version = "${project.version}+${project.minecraft_version}" -println "Version: ${version}" - outlet { maintainPropertiesFile = System.getenv("DISABLE_PROPERTIES_UPDATE") == null mcVersionRange = project.supported_minecraft_versions - allowedReleaseTypes = Set.of(ReleaseType.RELEASE) + allowedReleaseTypes = [ReleaseType.RELEASE] propertiesData = [ 'fapi_version': outlet.fapiVersion(project.minecraft_version), 'yarn_version': outlet.yarnVersion(project.minecraft_version), @@ -168,8 +178,8 @@ tasks.named("javadoc", Javadoc) { } jar { - from("LICENSE") { - rename { "${it}_${project.archivesBaseName}" } + from("${rootProject.projectDir}/LICENSE") { + rename { "${it}" } } } @@ -178,6 +188,7 @@ modrinth { token = System.getenv("MODRINTH_TOKEN") projectId = "loot-table-modifier" gameVersions = outlet.mcVersions() + loaders = ["fabric"] // Version stuff def customVersionName = System.getenv("VERSION_NAME") @@ -185,19 +196,18 @@ modrinth { versionNumber = "${project.version}" - def isPreRelease = System.getenv("VERSION_IS_PRERELEASE") - versionType = "true".equalsIgnoreCase(isPreRelease) ? "beta" : "release" + versionType = Boolean.parseBoolean(System.getenv("VERSION_IS_PRERELEASE")) ? "beta" : "release" - if (project.mod_version.contains("beta")) versionType = "beta" - else if (project.mod_version.contains("alpha")) versionType = "alpha" + if (rootProject.mod_version.contains("beta")) versionType = "beta" + if (rootProject.mod_version.contains("alpha")) versionType = "alpha" // Files uploadFile = remapJar.archiveFile - //additionalFiles = [sourcesJar.archiveFile, javadocJar.archiveFile] additionalFiles = [sourcesJar.archiveFile] + // Project info syncBodyFrom = rootProject.file("README.md").text def changelogEnv = System.getenv("VERSION_CHANGELOG") if (changelogEnv != null) changelog = changelogEnv @@ -227,7 +237,7 @@ publishing { } publications { maven(MavenPublication) { - artifactId = "loot-table-modifier" + artifactId = base.archivesName.get() from(components["java"]) } diff --git a/gradle.properties b/gradle.properties index 9e35644..67f3c54 100644 --- a/gradle.properties +++ b/gradle.properties @@ -8,14 +8,14 @@ minecraft_version = 1.21.8 # These should be automatically updated, unless the environment # variable "DISABLE_PROPERTIES_UPDATE" is set. -fapi_version = 0.129.0+1.21.8 +fapi_version = 0.136.0+1.21.8 yarn_version = 1.21.8+build.1 -loader_version = 0.16.14 +loader_version = 0.18.0 # Dependencies ## DevAuth, check at https://github.com/DJtheRedstoner/DevAuth devauth_version = 1.2.1 # Mod Properties -mod_version = 2.0.0-alpha.1 +mod_version = 2.0.0-alpha.2 supported_minecraft_versions = >=1.21.5 <=1.21.8 diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar index 1b33c55..f8e1ee3 100644 Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 78cb6e1..49ab6fc 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,7 +1,7 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionSha256Sum=bd71102213493060956ec229d946beee57158dbd89d0e62b91bca0fa2c5f3531 -distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip +distributionSha256Sum=df67a32e86e3276d011735facb1535f64d0d88df84fa87521e90becc2d735444 +distributionUrl=https\://services.gradle.org/distributions/gradle-9.2.0-bin.zip networkTimeout=10000 validateDistributionUrl=true zipStoreBase=GRADLE_USER_HOME diff --git a/gradlew b/gradlew index 23d15a9..adff685 100755 --- a/gradlew +++ b/gradlew @@ -1,7 +1,7 @@ #!/bin/sh # -# Copyright © 2015-2021 the original authors. +# Copyright © 2015 the original authors. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. @@ -114,7 +114,6 @@ case "$( uname )" in #( NONSTOP* ) nonstop=true ;; esac -CLASSPATH="\\\"\\\"" # Determine the Java command to use to start the JVM. @@ -172,7 +171,6 @@ fi # For Cygwin or MSYS, switch paths to Windows format before running java if "$cygwin" || "$msys" ; then APP_HOME=$( cygpath --path --mixed "$APP_HOME" ) - CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" ) JAVACMD=$( cygpath --unix "$JAVACMD" ) @@ -212,7 +210,6 @@ DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' set -- \ "-Dorg.gradle.appname=$APP_BASE_NAME" \ - -classpath "$CLASSPATH" \ -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \ "$@" diff --git a/gradlew.bat b/gradlew.bat index db3a6ac..c4bdd3a 100644 --- a/gradlew.bat +++ b/gradlew.bat @@ -70,11 +70,10 @@ goto fail :execute @rem Setup the command line -set CLASSPATH= @rem Execute Gradle -"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* :end @rem End local scope for the variables with windows NT shell diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/LootTableModifier.java b/src/main/java/top/offsetmonkey538/loottablemodifier/LootTableModifier.java index e0c461a..0d4da6b 100644 --- a/src/main/java/top/offsetmonkey538/loottablemodifier/LootTableModifier.java +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/LootTableModifier.java @@ -29,7 +29,6 @@ import net.minecraft.util.JsonHelper; import org.apache.commons.io.file.PathUtils; import org.jetbrains.annotations.NotNull; -import org.jetbrains.annotations.Nullable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import top.offsetmonkey538.loottablemodifier.api.resource.action.LootModifierActionTypes; @@ -94,19 +93,18 @@ public static void runModification(ResourceManager resourceManager, Registry poolsCopy = new LinkedList<>(table.pools); - int poolsSize = Math.max(1, poolsCopy.size()); + final LootPool[] poolsCopy = table.pools.toArray(LootPool[]::new); + int poolsSize = Math.max(1, poolsCopy.length); // Run loop at least once for (int i = 0; i < poolsSize; i++) { - final @Nullable LootPool pool = poolsCopy.isEmpty() ? null : poolsCopy.get(i); + final LootPool pool = poolsCopy.length == 0 ? null : poolsCopy[i]; poolModified = false; - final List entriesCopy = pool == null ? List.of() : new LinkedList<>(pool.entries); - int entriesSize = Math.max(1, entriesCopy.size()); + final LootPoolEntry[] entriesCopy = pool == null ? new LootPoolEntry[]{} : pool.entries.toArray(LootPoolEntry[]::new); + int entriesSize = Math.max(1, entriesCopy.length); // Run loop at least once for (int j = 0; j < entriesSize; j++) { - final @Nullable LootPoolEntry entry = entriesCopy.isEmpty() ? null : entriesCopy.get(j); + final LootPoolEntry entry = entriesCopy.length == 0 ? null : entriesCopy[j]; for (Map.Entry modifierEntry : modifiers.entrySet()) { - // Everything is so fast anyway that there's probably no point in doing what the to-do here said final LootModifierContext context = new LootModifierContext(table, tableId, pool, entry, tableModified, poolModified); final LootModifier modifier = modifierEntry.getValue(); @@ -229,7 +227,7 @@ public static Identifier id(String path) { } /* - In 1.21.4, the 'Registry' class extends 'RegistryWrapper' and inherits the 'streamEntries' method from *it*. + In 1.21.4, the 'Registry' class extends 'RegistryWrapper' and inherits the 'streamEntries' method from it. In 1.20.5, the 'Registry' class *doesn't* extend the 'RegistryWrapper' and implements its own 'streamEntries' method. Compiling on both versions works, because the names of the methods are the same, but they compile to different intermediary names, thus a jar compiled for 1.20.5 doesn't work on 1.21.4 and vice versa. Solution: Turn the 'Registry' into a 'RegistryWrapper' as its 'streamEntries' retains the same intermediary on both versions. diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/LootModifierActionTypes.java b/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/LootModifierActionTypes.java index 5d263f3..dd00b16 100644 --- a/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/LootModifierActionTypes.java +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/LootModifierActionTypes.java @@ -5,6 +5,7 @@ import net.minecraft.util.Identifier; import org.jetbrains.annotations.ApiStatus; import org.jetbrains.annotations.NotNull; +import top.offsetmonkey538.loottablemodifier.api.resource.action.condition.ConditionAddAction; import top.offsetmonkey538.loottablemodifier.api.resource.action.entry.EntryAddAction; import top.offsetmonkey538.loottablemodifier.api.resource.action.entry.EntryRemoveAction; import top.offsetmonkey538.loottablemodifier.api.resource.action.pool.PoolAddAction; @@ -45,6 +46,11 @@ private LootModifierActionTypes() { */ public static final LootModifierActionType ENTRY_ITEM_SET = register(id("entry_item_set"), EntryItemSetAction.CODEC); + /** + * Type of {@link ConditionAddAction} + */ + public static final LootModifierActionType CONDITION_ADD = register(id("condition_add"), ConditionAddAction.CODEC); + private static LootModifierActionType register(final @NotNull Identifier id, final @NotNull MapCodec codec) { return Registry.register(LootModifierActionType.REGISTRY, id, new LootModifierActionType(codec)); } diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/condition/ConditionAddAction.java b/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/condition/ConditionAddAction.java new file mode 100644 index 0000000..9fd8cec --- /dev/null +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/api/resource/action/condition/ConditionAddAction.java @@ -0,0 +1,134 @@ +package top.offsetmonkey538.loottablemodifier.api.resource.action.condition; + +import com.google.common.collect.ImmutableList; +import com.mojang.serialization.Codec; +import com.mojang.serialization.MapCodec; +import com.mojang.serialization.codecs.RecordCodecBuilder; +import net.minecraft.loot.LootPool; +import net.minecraft.loot.condition.LootCondition; +import net.minecraft.loot.entry.LootPoolEntry; +import org.jetbrains.annotations.Contract; +import org.jetbrains.annotations.NotNull; +import top.offsetmonkey538.loottablemodifier.api.resource.action.LootModifierAction; +import top.offsetmonkey538.loottablemodifier.api.resource.action.LootModifierActionType; +import top.offsetmonkey538.loottablemodifier.api.resource.action.LootModifierActionTypes; +import top.offsetmonkey538.loottablemodifier.api.resource.util.LootModifierContext; +import top.offsetmonkey538.loottablemodifier.duck.LootElementWithConditions; + +import java.util.List; + +/** + * Adds the provided conditions to matched pools/ + * + * @param conditions the conditions to add + * @param includePools whether the conditions should be added to matched pools + * @param includeEntries whether the conditions should be added to matched pools + */ +public record ConditionAddAction(List conditions, boolean includePools, boolean includeEntries) implements LootModifierAction { + public static final MapCodec CODEC = RecordCodecBuilder.mapCodec(instance -> instance.group( + LootCondition.CODEC.listOf().fieldOf("conditions").forGetter(ConditionAddAction::conditions), + Codec.BOOL.optionalFieldOf("includePools", true).forGetter(ConditionAddAction::includePools), + Codec.BOOL.optionalFieldOf("includeEntries", true).forGetter(ConditionAddAction::includeEntries) + ).apply(instance, ConditionAddAction::new)); + + @Override + public LootModifierActionType getType() { + return LootModifierActionTypes.CONDITION_ADD; + } + + @Override + public int apply(@NotNull LootModifierContext context) { + final LootPool pool = context.pool(); + if (pool == null) return MODIFIED_NONE; + + int returnValue = MODIFIED_NONE; + + if (includePools && !context.poolAlreadyModified()) { + final List newConditions = ImmutableList.builder() + .addAll(pool.conditions) + .addAll(conditions) + .build(); + + ((LootElementWithConditions) pool).loot_table_modifier$setConditions(newConditions); + returnValue |= MODIFIED_POOL; + } + + + if (!includeEntries) return returnValue; + + final LootPoolEntry entry = context.entry(); + if (entry == null) return returnValue | MODIFIED_NONE; + + final List newConditions = ImmutableList.builder() + .addAll(entry.conditions) + .addAll(conditions) + .build(); + + ((LootElementWithConditions) entry).loot_table_modifier$setConditions(newConditions); + + return MODIFIED_ENTRY; + } + + /** + * Creates a builder for {@link ConditionAddAction} + * + * @return a new {@link ConditionAddAction.Builder} + */ + @Contract("->new") + public static ConditionAddAction.Builder builder() { + return new ConditionAddAction.Builder(); + } + + /** + * Builder for {@link ConditionAddAction} + */ + public static class Builder implements LootModifierAction.Builder { + private Builder() { + + } + + private final ImmutableList.Builder conditions = ImmutableList.builder(); + private boolean includePools = true, includeEntries = true; + + /** + * Adds a condition + * + * @param conditionBuilder The condition to add + * @return this + */ + @Contract("_->this") + public ConditionAddAction.Builder condition(LootCondition.Builder conditionBuilder) { + this.conditions.add(conditionBuilder.build()); + return this; + } + + /** + * The conditions will only be applied to matched pools + * + * @return this + */ + @Contract("->this") + public ConditionAddAction.Builder onlyPools() { + includePools = true; + includeEntries = false; + return this; + } + + /** + * The conditions will only be applied to matched entries + * + * @return this + */ + @Contract("->this") + public ConditionAddAction.Builder onlyEntries() { + includeEntries = true; + includePools = false; + return this; + } + + @Override + public ConditionAddAction build() { + return new ConditionAddAction(conditions.build(), includePools, includeEntries); + } + } +} diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/datagen/LootTableModifierDatagen.java b/src/main/java/top/offsetmonkey538/loottablemodifier/datagen/LootTableModifierDatagen.java index 3bc41dc..426b7e8 100644 --- a/src/main/java/top/offsetmonkey538/loottablemodifier/datagen/LootTableModifierDatagen.java +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/datagen/LootTableModifierDatagen.java @@ -9,6 +9,7 @@ import net.minecraft.item.Items; import net.minecraft.loot.LootPool; import net.minecraft.loot.LootTable; +import net.minecraft.loot.condition.KilledByPlayerLootCondition; import net.minecraft.loot.context.LootContextTypes; import net.minecraft.loot.entry.ItemEntry; import net.minecraft.loot.function.SetCountLootFunction; @@ -19,6 +20,7 @@ import net.minecraft.registry.RegistryWrapper; import top.offsetmonkey538.loottablemodifier.api.datagen.LootModifierProvider; import top.offsetmonkey538.loottablemodifier.api.resource.LootModifier; +import top.offsetmonkey538.loottablemodifier.api.resource.action.condition.ConditionAddAction; import top.offsetmonkey538.loottablemodifier.api.resource.action.entry.EntryAddAction; import top.offsetmonkey538.loottablemodifier.api.resource.action.entry.EntryRemoveAction; import top.offsetmonkey538.loottablemodifier.api.resource.predicate.table.TablePredicate; @@ -176,6 +178,22 @@ protected void generate(RegistryWrapper.WrapperLookup lookup) { EntryRemoveAction.builder() ) ); + addModifier( + id("squid_ink_sac_only_from_player"), + LootModifier.builder() + .conditionally( + TablePredicate.builder() + .name(EntityType.SQUID) + .and(EntryItemPredicate.builder(Items.INK_SAC)) + ) + .action( + ConditionAddAction.builder() + .onlyPools() + .condition( + KilledByPlayerLootCondition.builder() + ) + ) + ); } } diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/duck/LootElementWithConditions.java b/src/main/java/top/offsetmonkey538/loottablemodifier/duck/LootElementWithConditions.java new file mode 100644 index 0000000..147ae35 --- /dev/null +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/duck/LootElementWithConditions.java @@ -0,0 +1,9 @@ +package top.offsetmonkey538.loottablemodifier.duck; + +import net.minecraft.loot.condition.LootCondition; + +import java.util.List; + +public interface LootElementWithConditions { + void loot_table_modifier$setConditions(List conditions); +} \ No newline at end of file diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolEntryMixin.java b/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolEntryMixin.java new file mode 100644 index 0000000..1e2ae23 --- /dev/null +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolEntryMixin.java @@ -0,0 +1,32 @@ +package top.offsetmonkey538.loottablemodifier.mixin; + +import net.minecraft.loot.condition.LootCondition; +import net.minecraft.loot.context.LootContext; +import net.minecraft.loot.entry.LootPoolEntry; +import net.minecraft.util.Util; +import org.spongepowered.asm.mixin.*; +import top.offsetmonkey538.loottablemodifier.duck.LootElementWithConditions; + +import java.util.List; +import java.util.function.Predicate; + +@Mixin(LootPoolEntry.class) +public class LootPoolEntryMixin implements LootElementWithConditions { + + @Shadow + @Final + @Mutable + public List conditions; + + @Shadow + @Final + @Mutable + private Predicate conditionPredicate; + + @Override + @Unique + public void loot_table_modifier$setConditions(List conditions) { + this.conditions = conditions; + this.conditionPredicate = Util.allOf(conditions); + } +} diff --git a/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolMixin.java b/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolMixin.java new file mode 100644 index 0000000..3efe51a --- /dev/null +++ b/src/main/java/top/offsetmonkey538/loottablemodifier/mixin/LootPoolMixin.java @@ -0,0 +1,32 @@ +package top.offsetmonkey538.loottablemodifier.mixin; + +import net.minecraft.loot.LootPool; +import net.minecraft.loot.condition.LootCondition; +import net.minecraft.loot.context.LootContext; +import net.minecraft.util.Util; +import org.spongepowered.asm.mixin.*; +import top.offsetmonkey538.loottablemodifier.duck.LootElementWithConditions; + +import java.util.List; +import java.util.function.Predicate; + +@Mixin(LootPool.class) +public class LootPoolMixin implements LootElementWithConditions { + + @Shadow + @Final + @Mutable + public List conditions; + + @Shadow + @Final + @Mutable + private Predicate predicate; + + @Override + @Unique + public void loot_table_modifier$setConditions(List conditions) { + this.conditions = conditions; + this.predicate = Util.allOf(conditions); + } +} diff --git a/src/main/resources/loot-table-modifier.accesswidener b/src/main/resources/loot-table-modifier.accesswidener index 9bcda25..a3ac5f3 100644 --- a/src/main/resources/loot-table-modifier.accesswidener +++ b/src/main/resources/loot-table-modifier.accesswidener @@ -1,5 +1,7 @@ accessWidener v1 named +# TODO: get rid of these and use mixin insteadddd + accessible field net/minecraft/loot/LootTable pools Ljava/util/List; accessible field net/minecraft/loot/LootTable functions Ljava/util/List; diff --git a/src/main/resources/loot-table-modifier.mixins.json b/src/main/resources/loot-table-modifier.mixins.json index 2352da9..48bc9db 100644 --- a/src/main/resources/loot-table-modifier.mixins.json +++ b/src/main/resources/loot-table-modifier.mixins.json @@ -1,14 +1,16 @@ { - "required": true, - "package": "top.offsetmonkey538.loottablemodifier.mixin", - "compatibilityLevel": "JAVA_17", - "mixins": [ - "ItemEntryAccessor", - "LootPoolAccessor", - "LootTableAccessor", - "ReloadableRegistriesMixin" - ], - "injectors": { - "defaultRequire": 1 + "required": true, + "package": "top.offsetmonkey538.loottablemodifier.mixin", + "compatibilityLevel": "JAVA_17", + "mixins": [ + "ItemEntryAccessor", + "LootPoolAccessor", + "LootPoolEntryMixin", + "LootPoolMixin", + "LootTableAccessor", + "ReloadableRegistriesMixin" + ], + "injectors": { + "defaultRequire": 1 } }