Difference between revisions of "Dynamic Loot Modification"

From Forge Community Wiki
(Inital Import dokuwiki)
 
(Fix the explanation)
 
(12 intermediate revisions by 6 users not shown)
Line 6: Line 6:
 
# Create a <code>global_loot_modifiers.json</code> file at <code><nowiki>/data/forge/loot_modifiers/</nowiki></code>
 
# Create a <code>global_loot_modifiers.json</code> file at <code><nowiki>/data/forge/loot_modifiers/</nowiki></code>
 
#* This will tell Forge about your modifiers and works similar to [[Tags|tags]].
 
#* This will tell Forge about your modifiers and works similar to [[Tags|tags]].
# A serialized json representing your modifier
+
# A serialized json representing your modifier at <code><nowiki>/data/<modID>/loot_modifiers/</nowiki></code>
 
#* This will contain all of the data about your modification and allows data packs to tweak your effect.
 
#* This will contain all of the data about your modification and allows data packs to tweak your effect.
 
# A class that extends <code>LootModifier</code>
 
# A class that extends <code>LootModifier</code>
#* The operational code that makes your modifier work and associated serializer.
+
#* The operational code that makes your modifier work and associated codec.
  
Finally, the serializer for your operational class is [[Registration|registered]] as any other <code>ForgeRegistryEntry</code>.
+
Finally, the codec for your operational class is [[Registration|registered]] as any other registry object.
  
== The global_loot_modifiers.json ==
+
==The global_loot_modifiers.json==
 +
All you need to add here are the file names of your loot modifiers.
 +
These are the names of the json files you have made in the loot_modifiers folder, in ResourceLocation format.
  
All you need to add here are the registry names of your loot modifiers.
 
 
<syntaxhighlight lang="json">
 
<syntaxhighlight lang="json">
 
{
 
{
Line 29: Line 30:
 
<code>replace</code> causes the cache of modifiers to be cleared fully when this asset loads (mods are loaded in an order that may be specified by a data pack). For modders you will want to use <code>false</code> while data pack makers may want to specify their overrides with <code>true</code>.
 
<code>replace</code> causes the cache of modifiers to be cleared fully when this asset loads (mods are loaded in an order that may be specified by a data pack). For modders you will want to use <code>false</code> while data pack makers may want to specify their overrides with <code>true</code>.
  
<code>entries</code> is an *ordered list* of the modifiers that will be loaded. Any modifier that is not listed will not be loaded and the ones listed are called in the order listed. This is primarily relevant to data pack makers for resolving conflicts between modifiers from separate mods.
+
<code>entries</code> is an ''ordered list'' of the modifiers that will be loaded. Any modifier that is not listed will not be loaded and the ones listed are called in the order listed. This is primarily relevant to data pack makers for resolving conflicts between modifiers from separate mods.
  
 
== The serialized json ==
 
== The serialized json ==
Line 44: Line 45:
 
     },
 
     },
 
     {
 
     {
       "condition": "block_state_property",
+
       "condition": "minecraft:block_state_property",
       "block":"minecraft:wheat"
+
       "block": "minecraft:wheat"
 
     }
 
     }
 
   ],
 
   ],
Line 55: Line 56:
  
 
In the above example, the modification only happens if the player harvests wheat when using shears (specified by the two <code>conditions</code> which are automatically <code>AND</code>ed together). The <code>seedsItem</code> and <code>numSeeds</code> values are then used to count how many seeds were generated by the vanilla loot table, and if matched, are substituted for an additional <code>replacement</code> item instead. The operation code will be shown below.
 
In the above example, the modification only happens if the player harvests wheat when using shears (specified by the two <code>conditions</code> which are automatically <code>AND</code>ed together). The <code>seedsItem</code> and <code>numSeeds</code> values are then used to count how many seeds were generated by the vanilla loot table, and if matched, are substituted for an additional <code>replacement</code> item instead. The operation code will be shown below.
<code>conditions</code> is the only object needed by the system specification, everything else is the mod maker's data.
+
 
 +
 
 +
{{Tip|<code>conditions</code> is the only object needed by the system specification, everything else is the mod maker's data.  
 +
 +
<code>seedItem</code>, <code>numSeeds</code> and <code>replacement</code> are NOT standard elements of Global Loot Modifiers. 
 +
 
 +
They are deserialized manually in the next section.}}
  
 
== The LootModifier Subclass ==
 
== The LootModifier Subclass ==
  
You will also need a static child class that extends <code>GlobalLootModifierSerializer<T></code> where <code>T</code> is your LootModifier subclass in order to deserialize your json data file into operational code.
+
You will also need a <code>Codec<T></code> where <code>T</code> is your LootModifier subclass in order to deserialize your json data file into operational code. The codec must be [[Registration|registered]].
  
 
<syntaxhighlight lang="java">
 
<syntaxhighlight lang="java">
private static class WheatSeedsConverterModifier extends LootModifier {
+
/**
private final int numSeedsToConvert;
+
    * When harvesting wheat with shears, this modifier is invoked via the wheat_harvest loot_modifier json<br/>
private final Item itemToCheck;
+
    * This modifier checks how many seeds were harvested and turns X seeds into Y wheat (3:1)
private final Item itemReward;
+
    *
public WheatSeedsConverterModifier(ILootCondition[] conditionsIn, int numSeeds, Item itemCheck, Item reward) {
+
    */
super(conditionsIn);
+
// Assume there exists a <code>IForgeRegistry<Codec<T extends LootModifier>></code> LOOT_MODIFIER_REGISTRAR added by a mod
numSeedsToConvert = numSeeds;
+
private static class WheatSeedsConverterModifier extends LootModifier
itemToCheck = itemCheck;
+
{
itemReward = reward;
+
        public static final RegistryObject<Codec<WheatSeedsConverterModifier>> CODEC = LOOT_MODIFIER_REGISTRAR.register("wheat_seeds_converter", () ->
}
+
        RecordCodecBuilder.create(inst -> codecStart(inst).and(
 +
                inst.group(
 +
                        Codec.INT.fieldOf("numSeeds").forGetter(m -> m.numSeedsToConvert),
 +
                        ForgeRegistries.ITEMS.getCodec().fieldOf("seedItem").forGetter(m -> m.itemToCheck),
 +
                        ForgeRegistries.ITEMS.getCodec().fieldOf("replacement").forGetter(m -> m.itemReward)
 +
                )).apply(inst, WheatSeedsConverterModifier::new)
 +
        ));
  
@Nonnull
+
        private final int numSeedsToConvert;
@Override
+
        private final Item itemToCheck;
public List<ItemStack> doApply(List<ItemStack> generatedLoot, LootContext context) {
+
        private final Item itemReward;
//*
+
        public WheatSeedsConverterModifier(LootItemCondition[] conditionsIn, int numSeeds, Item itemCheck,
* Additional conditions can be checked, though as much as possible should be parameterized via JSON data.
+
            Item reward)
* It is better to write a new ILootCondition implementation than to do things here.
+
        {
*//
+
            super(conditionsIn);
int numSeeds = 0;
+
            numSeedsToConvert = numSeeds;
for(ItemStack stack : generatedLoot) {
+
            itemToCheck = itemCheck;
if(stack.getItem() == itemToCheck)
+
            itemReward = reward;
numSeeds+=stack.getCount();
+
        }
}
 
if(numSeeds >= numSeedsToConvert) {
 
generatedLoot.removeIf(x -> x.getItem() == itemToCheck);
 
generatedLoot.add(new ItemStack(itemReward, (numSeeds/numSeedsToConvert)));
 
numSeeds = numSeeds%numSeedsToConvert;
 
if(numSeeds > 0)
 
generatedLoot.add(new ItemStack(itemToCheck, numSeeds));
 
}
 
return generatedLoot;
 
}
 
  
private static class Serializer extends GlobalLootModifierSerializer<WheatSeedsConverterModifier> {
+
        @NotNull
 +
        @Override
 +
        public ObjectArrayList<ItemStack> doApply(ObjectArrayList<ItemStack> generatedLoot, LootContext context) {
 +
            //
 +
            // Additional conditions can be checked, though as much as possible should be parameterized via JSON data.
 +
            // It is better to write a new ILootCondition implementation than to do things here.
 +
            //
 +
            int numSeeds = 0;
 +
            generatedLoot.stream().filter(stack -> stack.getItem() == itemToCheck)
 +
                  .forEach(stack -> numSeeds+=stack.getCount())
 +
            if(numSeeds >= numSeedsToConvert) {
 +
                generatedLoot.removeIf(x -> x.getItem() == itemToCheck);
 +
                generatedLoot.add(new ItemStack(itemReward, (numSeeds/numSeedsToConvert)));
 +
                numSeeds = numSeeds%numSeedsToConvert;
 +
                if(numSeeds > 0)
 +
                    generatedLoot.add(new ItemStack(itemToCheck, numSeeds));
 +
            }
 +
            return generatedLoot;
 +
        }
  
@Override
+
        @Override
public WheatSeedsConverterModifier read(ResourceLocation name, JsonObject object, ILootCondition[] conditionsIn) {
+
        public Codec<? extends IGlobalLootModifier> codec() {
int numSeeds = JSONUtils.getInt(object, "numSeeds");
+
            return CODEC.get();
Item seed = ForgeRegistries.ITEMS.getValue(new ResourceLocation((JSONUtils.getString(object, "seedItem"))));
+
        }
Item wheat = ForgeRegistries.ITEMS.getValue(new ResourceLocation(JSONUtils.getString(object, "replacement")));
+
    }
return new WheatSeedsConverterModifier(conditionsIn, numSeeds, seed, wheat);
 
}
 
}
 
}
 
 
</syntaxhighlight>
 
</syntaxhighlight>
  
 
The critical portion is the <code>doApply</code> method.
 
The critical portion is the <code>doApply</code> method.
  
This method is only called if the <code>conditions</code> specified return <code>true</code> and the modder is now able to make the modifications they desire. In this case we can see that the number of <code>itemToCheck</code> meets or exceeds the <code>numSeedsToConvert</code> before modifying the list by adding an <code>itemReward</code> and removing any excess <code>itemToCheck</code> stacks, matching the previously mentioned effects: When a wheat block is harvested with shears, if enough seeds are generated as loot, they are converted to additional wheat instead.
+
This method is only called if the <code>conditions</code> specified return <code>true</code> and the modder is now able to make the modifications they desire. In this case we can see that the number of <code>itemToCheck</code> meets or exceeds the <code>numSeedsToConvert</code> before modifying the list by adding an <code>itemReward</code> and removing any excess <code>itemToCheck</code> stacks, matching the previously mentioned effects: ''When a wheat block is harvested with shears, if enough seeds are generated as loot, they are converted to additional wheat instead''.
  
Also take note of the <code>read</code> method in the serializer. The conditions are already deserialized for you and if you have no other data, simply <code>return new MyModifier(conditionsIn)</code>. However, the full <code>JsonObject</code> is available if needed.
+
The codec can also be used for [[datageneration|data generation]] with a <code>GlobalLootModifierProvider</code>.
  
Additional [https://github.com/MinecraftForge/MinecraftForge/blob/1.15.x/src/test/java/net/minecraftforge/debug/gameplay/loot/GlobalLootModifiersTest.java examples] can be found on the Forge Git repository, including silk touch and smelting effects.
+
Additional [https://github.com/MinecraftForge/MinecraftForge/blob/1.19.x/src/test/java/net/minecraftforge/debug/gameplay/loot/GlobalLootModifiersTest.java examples] can be found on the Forge Git repository, including silk touch and smelting effects.

Latest revision as of 18:30, 20 September 2022

Global Loot Modifiers are a data-driven method of handling modification of harvested drops without the need to overwrite dozens to hundreds of vanilla loot tables or to handle effects that would require interactions with another mod's loot tables without knowing what mods may be loaded. Global Loot Modifiers are also stacking, rather than last-load-wins as modifications to loot tables would be.

Registering a Global Loot Modifier

You will need 3 things:

  1. Create a global_loot_modifiers.json file at /data/forge/loot_modifiers/
    • This will tell Forge about your modifiers and works similar to tags.
  2. A serialized json representing your modifier at /data/<modID>/loot_modifiers/
    • This will contain all of the data about your modification and allows data packs to tweak your effect.
  3. A class that extends LootModifier
    • The operational code that makes your modifier work and associated codec.

Finally, the codec for your operational class is registered as any other registry object.

The global_loot_modifiers.json

All you need to add here are the file names of your loot modifiers. These are the names of the json files you have made in the loot_modifiers folder, in ResourceLocation format.

{
  "replace": false,
  "entries": [
    "global_loot_test:silk_touch_bamboo",
    "global_loot_test:smelting",
    "global_loot_test:wheat_harvest"
  ]
}

replace causes the cache of modifiers to be cleared fully when this asset loads (mods are loaded in an order that may be specified by a data pack). For modders you will want to use false while data pack makers may want to specify their overrides with true.

entries is an ordered list of the modifiers that will be loaded. Any modifier that is not listed will not be loaded and the ones listed are called in the order listed. This is primarily relevant to data pack makers for resolving conflicts between modifiers from separate mods.

The serialized json

This file contains all of the potential variables related to your modifier, including the conditions that must be met prior to modifying any loot as well as any other parameters your modifier might have. Avoid hard-coded values where ever possible so that data pack makers can adjust balance if they wish to.

{
  "conditions": [
    {
      "condition": "minecraft:match_tool",
      "predicate": {
        "item": "minecraft:shears"
      }
    },
    {
      "condition": "minecraft:block_state_property",
      "block": "minecraft:wheat"
    }
  ],
  "seedItem": "minecraft:wheat_seeds",
  "numSeeds": 3,
  "replacement": "minecraft:wheat"
}

In the above example, the modification only happens if the player harvests wheat when using shears (specified by the two conditions which are automatically ANDed together). The seedsItem and numSeeds values are then used to count how many seeds were generated by the vanilla loot table, and if matched, are substituted for an additional replacement item instead. The operation code will be shown below.


conditions is the only object needed by the system specification, everything else is the mod maker's data.

seedItem, numSeeds and replacement are NOT standard elements of Global Loot Modifiers.

They are deserialized manually in the next section.

The LootModifier Subclass

You will also need a Codec<T> where T is your LootModifier subclass in order to deserialize your json data file into operational code. The codec must be registered.

/**
     * When harvesting wheat with shears, this modifier is invoked via the wheat_harvest loot_modifier json<br/>
     * This modifier checks how many seeds were harvested and turns X seeds into Y wheat (3:1)
     *
     */
// Assume there exists a <code>IForgeRegistry<Codec<T extends LootModifier>></code> LOOT_MODIFIER_REGISTRAR added by a mod
private static class WheatSeedsConverterModifier extends LootModifier
{
        public static final RegistryObject<Codec<WheatSeedsConverterModifier>> CODEC = LOOT_MODIFIER_REGISTRAR.register("wheat_seeds_converter", () -> 
        RecordCodecBuilder.create(inst -> codecStart(inst).and(
                inst.group(
                        Codec.INT.fieldOf("numSeeds").forGetter(m -> m.numSeedsToConvert),
                        ForgeRegistries.ITEMS.getCodec().fieldOf("seedItem").forGetter(m -> m.itemToCheck),
                        ForgeRegistries.ITEMS.getCodec().fieldOf("replacement").forGetter(m -> m.itemReward)
                )).apply(inst, WheatSeedsConverterModifier::new)
        ));

        private final int numSeedsToConvert;
        private final Item itemToCheck;
        private final Item itemReward;
        public WheatSeedsConverterModifier(LootItemCondition[] conditionsIn, int numSeeds, Item itemCheck, 
             Item reward)
        {
            super(conditionsIn);
            numSeedsToConvert = numSeeds;
            itemToCheck = itemCheck;
            itemReward = reward;
        }

        @NotNull
        @Override
        public ObjectArrayList<ItemStack> doApply(ObjectArrayList<ItemStack> generatedLoot, LootContext context) {
            //
            // Additional conditions can be checked, though as much as possible should be parameterized via JSON data.
            // It is better to write a new ILootCondition implementation than to do things here.
            //
            int numSeeds = 0;
            generatedLoot.stream().filter(stack -> stack.getItem() == itemToCheck)
                   .forEach(stack -> numSeeds+=stack.getCount())
            if(numSeeds >= numSeedsToConvert) {
                generatedLoot.removeIf(x -> x.getItem() == itemToCheck);
                generatedLoot.add(new ItemStack(itemReward, (numSeeds/numSeedsToConvert)));
                numSeeds = numSeeds%numSeedsToConvert;
                if(numSeeds > 0)
                    generatedLoot.add(new ItemStack(itemToCheck, numSeeds));
            }
            return generatedLoot;
        }

        @Override
        public Codec<? extends IGlobalLootModifier> codec() {
            return CODEC.get();
        }
    }

The critical portion is the doApply method.

This method is only called if the conditions specified return true and the modder is now able to make the modifications they desire. In this case we can see that the number of itemToCheck meets or exceeds the numSeedsToConvert before modifying the list by adding an itemReward and removing any excess itemToCheck stacks, matching the previously mentioned effects: When a wheat block is harvested with shears, if enough seeds are generated as loot, they are converted to additional wheat instead.

The codec can also be used for data generation with a GlobalLootModifierProvider.

Additional examples can be found on the Forge Git repository, including silk touch and smelting effects.