Forge Community Wiki - User contributions [en-gb]

SimpleChannel

2023-08-28T21:21:11Z

Ferri Arnus: /* Registering Packets */

SimpleChannel is the name given to the packet system that revolves around the <code><nowiki>SimpleChannel</nowiki></code> class. Using this system is by far the easiest way to send custom data between clients and the server.

== Getting Started ==

First you need to create your <code><nowiki>SimpleChannel</nowiki></code> object. We recommend that you do this in a separate class, possibly something like <code><nowiki>ModidPacketHandler</nowiki></code>. Create your <code><nowiki>SimpleChannel</nowiki></code> as a static field in this class, like so:

<syntaxhighlight lang="java">
private static final String PROTOCOL_VERSION = "1";
public static final SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
new ResourceLocation("mymodid", "main"),
() -> PROTOCOL_VERSION,
PROTOCOL_VERSION::equals,
PROTOCOL_VERSION::equals
);
</syntaxhighlight>

The first argument is a name for the channel. The second argument is a <code><nowiki>Supplier<String></nowiki></code> returning the current network protocol version. The third and fourth arguments respectively are <code><nowiki>Predicate<String></nowiki></code> checking whether an incoming connection protocol version is network-compatible with the client or server, respectively.
Here, we simply compare with the <code><nowiki>PROTOCOL_VERSION</nowiki></code> field directly, meaning that the client and server <code><nowiki>PROTOCOL_VERSION</nowiki></code>s must always match or FML will deny login.

== Protocol Versions ==
If your mod does not require the other side to have a specific network channel, or to be a Forge instance at all, you should take care that you properly define your version compatibility checkers (the <code><nowiki>Predicate<String></nowiki></code> parameters) to handle additional "meta-versions" (defined in <code><nowiki>NetworkRegistry</nowiki></code>) that can be received by the version checker. These are:
* <code><nowiki>ABSENT</nowiki></code> - if this channel is missing on the other endpoint. Note that in this case, the endpoint is still a Forge endpoint, and may have other mods.
* <code><nowiki>ACCEPTVANILLA</nowiki></code> - if the endpoint is a vanilla (or non-Forge) endpoint.

Returning <code><nowiki>false</nowiki></code> for both means that this channel must be present on the other endpoint. If you just copy the code above, this is what it does. Note that these values are also used during the list ping compatibility check, which is responsible for showing the green check / red cross in the multiplayer server select screen.

== Registering Packets ==

Next, we must declare the types of messages that we would like to send and receive. This is done using the <code><nowiki>INSTANCE.registerMessage</nowiki></code> method, which takes 5 parameters.

* The first parameter is the discriminator for the packet. This is a per-channel unique ID for the packet. We recommend you use a local variable to hold the ID, and then call registerMessage using <code><nowiki>id++</nowiki></code>. This will guarantee 100% unique IDs.
* The second parameter is the actual packet class <code><nowiki>MSG</nowiki></code>.
* The third parameter is a <code><nowiki>BiConsumer<MSG, FriendlyByteBuf></nowiki></code> responsible for encoding the message into the provided <code><nowiki>FriendlyByteBuf</nowiki></code>
* The fourth parameter is a <code><nowiki>Function<FriendlyByteBuf, MSG></nowiki></code> responsible for decoding the message from the provided <code><nowiki>FriendlyByteBuf</nowiki></code>
* The final parameter is a <code><nowiki>BiConsumer<MSG, Supplier<NetworkEvent.Context>></nowiki></code> responsible for handling the message itself

The last three parameters can be method references to either static or instance methods in Java. Remember that an instance method <code><nowiki>MSG.encode(FriendlyByteBuf)</nowiki></code> still satisfies <code><nowiki>BiConsumer<MSG, FriendlyByteBuf></nowiki></code>, the <code><nowiki>MSG</nowiki></code> simply becomes the implicit first argument.

<syntaxhighlight lang="java">
class MessagePacket {
public void encoder(FriendlyByteBuf buffer) {
// Write to buffer
}

public static MessagePacket decoder(FriendlyByteBuf buffer) {
// Create packet from buffer data
}

public void messageConsumer(Supplier<NetworkEvent.Context> ctx) {
// Handle message
}
}

// Original direct registration syntax
INSTANCE.registerMessage(id, MessagePacket.class,
MessagePacket::encoder,
MessagePacket::decoder,
MessagePacket::messageConsumer);
// Consumer here must use enqueueWork and setPacketHandled

// New builder-based definition
INSTANCE.messageBuilder(MessagePacket.class, id)
.encoder(MessagePacket::encoder)
.decoder(MessagePacket::decoder)
.consumerMainThread(MessagePacket::messageConsumer)
.add();
// You can use consumerMainThread or consumerNetworkThread.
// If you use consumerMainThread, the builder will take care of the enqueueWork and setPacketHandled.
// With consumerNetworkThread, you can return a value instead of calling setPacketHandled.
</syntaxhighlight>

== Handling Packets ==

There are a couple things to highlight in a packet handler. A packet handler has both the message object and the network context available to it. The context allows access to the player that sent the packet (if on the server), and a way to enqueue threadsafe work.

<syntaxhighlight lang="java">
public static void handle(MyMessage msg, Supplier<NetworkEvent.Context> ctx) {
ctx.get().enqueueWork(() -> {
// Work that needs to be threadsafe (most work)
ServerPlayer sender = ctx.get().getSender(); // the client that sent this packet
// do stuff
});
ctx.get().setPacketHandled(true);
}
</syntaxhighlight>

Packets sent from the server to the client should be handled in another class and wrapped via <code>DistExecutor#unsafeRunWhenOn</code>.

<syntaxhighlight lang="java">
// In Packet class
public static void handle(MyClientMessage msg, Supplier<NetworkEvent.Context> ctx) {
ctx.get().enqueueWork(() ->
// Make sure it's only executed on the physical client
DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientPacketHandlerClass.handlePacket(msg, ctx))
);
ctx.get().setPacketHandled(true);
}

// In ClientPacketHandlerClass
public static void handlePacket(MyClientMessage msg, Supplier<NetworkEvent.Context> ctx) {
// Do stuff
}
</syntaxhighlight>

Note the presence of <code><nowiki>#setPacketHandled</nowiki></code>, which used to tell the network system that the packet has successfully completed handling.

=== Common Packet Handling Pitfalls ===

{{Colored box|title=Know that packets are by default handled on the network thread.|content=
That means that your handler can ''not'' interact with most game objects directly.
Forge provides a convenient way to make your code execute on the main thread through the supplied <code><nowiki>NetworkEvent$Context</nowiki></code>.
Simply call <code><nowiki>NetworkEvent$Context#enqueueWork(Runnable)</nowiki></code>, which will call the given <code><nowiki>Runnable</nowiki></code> on the main thread at the next opportunity.}}

{{Colored box|title=Be defensive when handling packets on the server.|content=
A client could attempt to exploit the packet handling by sending unexpected data.
<br>
A common problem is vulnerability to <code>arbitrary chunk generation</code>. This typically happens when the server is trusting a block position sent by a client to access blocks and block entities. When accessing blocks and block entities in unloaded areas of the level, the server will either generate or load this area from disk, then promply write it to disk. This can be exploited to cause <code>catastrophic damage</code> to a server's performance and storage space without leaving a trace.
<br>
To avoid this problem, a general rule of thumb is to only access blocks and block entities if <code><nowiki>Level#hasChunkAt</nowiki></code> is true.}}

{{Colored box|title=Register encoders on the physical client, as well as the physical server.|content=
If you only register an encoder for a clientbound packet on the physical server, your mod will likely crash or present unintended behaviour in single-player worlds. ''Forge will happily send packets that have no encoder defined, '''without a warning or error message!''''' They will be encoded as a 256-long byte buffer filled only with null bytes, by default.
<br>}}

== Sending Packets ==

=== Sending to the Server ===

There is but one way to send a packet to the server. This is because there is only ever *one* server the client can be connected to at once. To do so, we must again use that <code><nowiki>SimpleChannel</nowiki></code> that was defined earlier. Simply call <code><nowiki>INSTANCE.sendToServer(new MyMessage())</nowiki></code>. The message will be sent to the handler for its type, if one exists.

=== Sending to Clients ===

Packets can be sent directly to a client using the <code><nowiki>SimpleChannel</nowiki></code>: <code><nowiki>HANDLER.sendTo(MSG, serverPlayer.connection.getConnection(), NetworkDirection.PLAY_TO_CLIENT)</nowiki></code>. However, this can be quite inconvenient. Forge has some convenience functions that can be used:

<syntaxhighlight lang="java">
// Sending to one player
INSTANCE.send(PacketDistributor.PLAYER.with(serverPlayer), new MyMessage());

// Send to all players tracking this level chunk
INSTANCE.send(PacketDistributor.TRACKING_CHUNK.with(levelChunk), new MyMessage());

// Sending to all connected players
INSTANCE.send(PacketDistributor.ALL.noArg(), new MyMessage());
</syntaxhighlight>

There are additional <code><nowiki>PacketDistributor</nowiki></code> types available, check the documentation on the <code><nowiki>PacketDistributor</nowiki></code> class for more details.

Networking with Entities

2022-02-21T21:49:38Z

Ferri Arnus: /* IEntityAdditionalSpawnData */

In addition to regular network messages, there are various other systems provided to handle synchronizing entity data.

== Spawn Data ==

In general, the spawning of modded entities is handled seperately, by Forge.

{{Colored box|title=Info|content=This means that simply extending a vanilla entity class may not inherit all its behaviour here. You may need to implement certain vanilla behaviours yourself.}}

You can add extra data to the spawn packet Forge sends by implementing the following interface.

===IEntityAdditionalSpawnData===
If your entity has data that is needed on the client, but doesn't change over time, then it can be added to the entity spawn packet using this interface. <code><nowiki>writeSpawnData()</nowiki></code> and <code><nowiki>readSpawnData()</nowiki></code> control how the data should be en/decoded to/from the network buffer. Also override <code><nowiki>getAddEntityPacket()</nowiki></code> to return <code><nowiki>NetworkHooks.getEntitySpawningPacket(...)</nowiki></code> for the data to be send.

== Dynamic Data ==

=== Data Parameters ===

This is the main vanilla system for synchronizing entity data from the server to the client. As such, a number of vanilla examples are available to refer to.

Firstly you need a <code><nowiki>EntityDataAccessor<T></nowiki></code> for the data you wish to keep synchronized. This should be stored as a static final field in your entity class, obtained by calling <code><nowiki>SynchedEntityData.defineId()</nowiki></code> and passing the entity class and a serializer for that type of data. The available serializer implementations can be found as static constants within the <code><nowiki>EntityDataSerializers</nowiki></code> class.

{{Colored box|title=Alert|content=You should '''only''' create data parameters for your own entities, ''within that entity's class''. Adding parameters to entities you do not control can cause the IDs used to send that data over the network to become desynchronized, causing difficult to debug crashes.}}

Then, override <code><nowiki>Entity#defineSynchedData()</nowiki></code> and call <code><nowiki>this.entityData.define(...)</nowiki></code> for each of your data parameters, passing the parameter and an initial value to use. Remember to always call <code><nowiki>super.defineSynchedData()</nowiki></code> first!

You can then get and set these values via your entity's <code><nowiki>entityData</nowiki></code> instance. Changes made will be synchronized to the client automatically.

Datageneration/Loot Tables

2021-07-16T14:45:10Z

Ferri Arnus: /* The LootPool Builder */

Datageneration/Loot Tables

2021-07-16T14:39:14Z

Ferri Arnus: /* The LootPool Builder */

Datageneration/Loot Tables

2021-07-16T14:34:50Z

Ferri Arnus: /* The LootPool Builder */

Datageneration/Loot Tables

2021-07-16T14:21:22Z

Ferri Arnus: /* The LootPool Builder */

Datageneration/Loot Tables

2021-07-16T14:20:15Z

Ferri Arnus: /* Preperation */

Datageneration/Loot Tables

2021-07-16T14:18:51Z

Ferri Arnus: /* Preperation */

Datageneration/Loot Tables

2021-07-16T14:17:18Z

Ferri Arnus: /* The LootPool Builder */

Datageneration/Loot Tables

2021-07-16T13:52:22Z

Ferri Arnus: /* The actual Class for Lootables */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strictly needed.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class which is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.

=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. An example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents when placed.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:52:05Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strictly needed.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class which is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. An example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents when placed.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:51:32Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strictly needed.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class which is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. An example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:50:52Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strictly needed.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class which is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:49:54Z

Ferri Arnus: /* Preperation */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strictly needed.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class which is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:47:59Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see [https://minecraft.fandom.com/wiki/Loot_table LootTables] for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: [https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials Full list of his tutorials] and [https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen Lootprovider and other datagen classes]
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:41:37Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions and/or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials and https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:41:02Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a <code>LootTable.Builder</code>. This builder can be made by using the <code>LootPool.lootPool()</code> method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return <code>LootTable.lootTable().withPool(builder)</code>. A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials and https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:38:37Z

Ferri Arnus: /* The actual Class for Lootables */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a LootTable.Builder. This builder can be made by using the LootPool.lootPool() method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return LootTable.lootTable().withPool(builder). A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder).setParamSet(LootParameterSets.BLOCK);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials and https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:35:01Z

Ferri Arnus: /* The actual Class for Lootables */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class for blocks. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().setParamSet(LootParameterSets.BLOCK).build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a LootTable.Builder. This builder can be made by using the LootPool.lootPool() method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return LootTable.lootTable().withPool(builder). A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials and https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:33:59Z

Ferri Arnus: /* The LootPool Builder */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().setParamSet(LootParameterSets.BLOCK).build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable (this is an explanation for a block loottable). If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a LootTable.Builder. This builder can be made by using the LootPool.lootPool() method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return LootTable.lootTable().withPool(builder). A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder);
}
</syntaxhighlight>
Thanks and creddits to McJty with his amazing tutorials: https://wiki.mcjty.eu/modding/index.php?title=YouTube-Tutorials and https://github.com/McJty/YouTubeModding14/tree/1.16/src/main/java/com/mcjty/mytutorial/datagen
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:28:02Z

Ferri Arnus: /* Preperation */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().setParamSet(LootParameterSets.BLOCK).build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable. If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a LootTable.Builder. This builder can be made by using the LootPool.lootPool() method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return LootTable.lootTable().withPool(builder). A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder);
}
</syntaxhighlight>
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T09:22:11Z

Ferri Arnus: /* The actual Class for Lootables */

{{Under construction}}
Loot Tables are not so polished like the other Providers. You need need to do some work to get them to a good state.

== Preperation ==
First you would need a new Class that extend the <code>LootTableProvider</code>. In this class you would override the <code>act</code> and optionally <code>getName</code> Method.
In the <code>getName</code> you just return the Name shown in the Logs.
Also you should create a abstract Method which you would override in subclasses but this is not strickly needded.
Also you need a Gson constant. You would create it like this <code> private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create(); </code>
You should also save the <code>DataGenerator</code> for later use since you can't access from the <code>LootTableProvider</code>.
Also you would need two Maps, one with the the Class witch is used to get the Lootable Resource Location in this example the Block and one the Loot Table Builder.
The second Map consist of a <code>ResourceLocation</code> and the actual <code>LootTable</code>. Look at the Code for more info.

<syntaxhighlight lang="java">
private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
public static Map<ResourceLocation, LootTable> tables = new HashMap<>();
protected final DataGenerator generator;
</syntaxhighlight>

Also you would need a Function to save the Tables
<syntaxhighlight lang="java">
private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.toJson(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);
}
});
}
</syntaxhighlight>

For the writeTables method you would need to convert the First Map to the second map, for this we need to iterate over the first map.
<syntaxhighlight lang="java">
lootTables.forEach(blockBuilderMap -> {
for (Map.Entry<Block, LootTable.Builder> entry : blockBuilderMap.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().build());
}
});
</syntaxhighlight>

in the act Method you would then first call the Method where you create the tables or just create them in there (if you do you can ignore the next section), then you would convert the Tables and at last you would save the loottables.

== The actual Class for Lootables ==
Here's an example Lootprovider class. The class is abstract and will be extended by the actual lootprovider class. This is however, optional. The class could also be used directly.
<syntaxhighlight lang="java">
public abstract class BaseLootTableProvider extends LootTableProvider {

private static final Gson GSON = new GsonBuilder().setPrettyPrinting().disableHtmlEscaping().create();
private static final Logger LOGGER = LogManager.getLogger();

protected final Map<Block, LootTable.Builder> lootTables = new HashMap<>();
private final DataGenerator generator;

public BaseLootTableProvider(DataGenerator dataGeneratorIn) {
super(dataGeneratorIn);
this.generator = dataGeneratorIn;
}

protected abstract void addTables();

@Override
public void run(DirectoryCache cache) {
addTables();

Map<ResourceLocation, LootTable> tables = new HashMap<>();
for (Map.Entry<Block, LootTable.Builder> entry : lootTables.entrySet()) {
tables.put(entry.getKey().getLootTable(), entry.getValue().setParamSet(LootParameterSets.BLOCK).build());
}
writeTables(cache, tables);
}

private void writeTables(DirectoryCache cache, Map<ResourceLocation, LootTable> tables) {
Path outputFolder = this.generator.getOutputFolder();
tables.forEach((key, lootTable) -> {
Path path = outputFolder.resolve("data/" + key.getNamespace() + "/loot_tables/" + key.getPath() + ".json");
try {
IDataProvider.save(GSON, cache, LootTableManager.serialize(lootTable), path);
} catch (IOException e) {
LOGGER.error("Couldn't write loot table {}", path, (Object) e);

}
});
}

@Override
public String getName() {
return "Example LootTables";
}
}
</syntaxhighlight>
=== Another class (Optional) ===
Create a new class that extends from the Class you created in the Section above and override the abstract function in there you can begin to create your Lootables.
<syntaxhighlight lang="java">
public class LootTables extends BaseLootTableProvider{

@Override
protected void addTables() {
lootTables.put(BLOCK, LootTable.Builder);
}
}
</syntaxhighlight>
=== The LootPool Builder ===
This is where you actually make a loottable. If you have multiple blocks with similar loottables, making a general method could be a good idea. The Method should return a LootTable.Builder. This builder can be made by using the LootPool.lootPool() method, but you still need to add attributes. You need a name for the pool, the amount you get and also "what" you get. The "what" can modified using functions or conditions (see https://minecraft.fandom.com/wiki/Loot_table for possible vanilla funtions and conditions). After having made the builder, you return LootTable.lootTable().withPool(builder). A example of a "shulkerbox-like" block, copying its name, inventory and "energy" data to the block and restoring its contents.
<syntaxhighlight lang="java">
protected LootTable.Builder createTable(String name, Block block) {
LootPool.Builder builder = LootPool.lootPool()
.name(name)
.setRolls(ConstantRange.exactly(1))
.add(ItemLootEntry.lootTableItem(block)
.apply(CopyName.copyName(CopyName.Source.BLOCK_ENTITY))
.apply(CopyNbt.copyData(CopyNbt.Source.BLOCK_ENTITY)
.copy("inv", "BlockEntityTag.inv", CopyNbt.Action.REPLACE)
.copy("energy", "BlockEntityTag.energy", CopyNbt.Action.REPLACE))
.apply(SetContents.setContents()
.withEntry(DynamicLootEntry.dynamicEntry(new ResourceLocation("minecraft", "contents"))))
);
return LootTable.lootTable().withPool(builder);
}
</syntaxhighlight>
[[Category:Data Generation]]

Datageneration/Loot Tables

2021-07-16T08:54:07Z

Ferri Arnus: /* The actual Class for Lootables */

Datageneration/Loot Tables

2021-07-15T19:15:19Z

Ferri Arnus: /* Preperation */

Tinted Textures

2021-06-29T22:23:12Z

Ferri Arnus: /* IBlockColor / IItemColor */

Many blocks and items in vanilla change their texture color depending on where they are, such as grass. Models support specifying “tint indices” on faces, which are integers that can then be handled by <code>IBlockColor</code>s and <code>IItemColor</code>s. See the wiki for information on how tint indices are defined in vanilla models.

=== IBlockColor / IItemColor ===
Both of these are single-method interfaces. <code>IBlockColor</code> takes an <code>IBlockState</code>, an (<code>nullable</code>) <code>IBlockDisplayReader</code>, and a (<code>nullable</code>) <code>BlockPos</code>. <code>IItemColor</code> takes an <code>ItemStack</code>. Both of them take a parameter <code>tintIndex</code>, which is the tint index of the face being colored. Both of them return an <code>int</code>, a color multiplier. This int is treated as four unsigned bytes, alpha, red, green, and blue, in that order, from most significant byte to least. For each pixel in the tinted face, the value of each color channel is <code><nowiki>(int)((float)base * multiplier / 255)</nowiki></code>, where <code>base</code> is the original value for the channel, and <code>multiplier</code> is the associated byte from the color multiplier. Note that blocks do not use the alpha channel. For example, the grass texture, untinted, looks white and gray. The <code>IBlockColor</code> and <code>IItemColor</code> for grass return color multipliers with low red and blue components, but high alpha and green components, (at least in warm biomes) so when the multiplication is performed, the green is brought out and the red/blue diminished.

If an item inherits from the <code><nowiki>builtin/generated</nowiki></code> model, each layer (“layer0”, “layer1”, etc.) has a tint index corresponding to its layer index. For blocks, the “particle” layer is index 0.

=== Creating Color Handlers ===
<code>IBlockColor</code>s need to be registered to the <code>BlockColors</code> instance of the game. <code>BlockColors</code> can be acquired through <code>ColorHandlerEvent$Block</code>, and an <code>IBlockColor</code> can be registered by <code><nowiki>BlockColors#register</nowiki></code>. Note that this does not cause the <code>BlockItem</code> for the given block to be colored. <code>BlockItem</code> are items and need to colored with an <code>IItemColor</code>.
<syntaxhighlight lang="java">
public void registerBlockColors(ColorHandlerEvent.Block event){
event.getBlockColors().register(myIBlockColor, coloredBlock1, coloredBlock2, ...);
}
</syntaxhighlight>
<code>IItemColor</code>s need to be registered to the <code>ItemColors</code> instance of the game. <code>ItemColors</code> can be acquired through <code><nowiki>ColorHandlerEvent$Item()</nowiki></code>, and an <code>IItemColor</code> can be registered by <code><nowiki>ItemColors#register</nowiki></code>. This method is overloaded to also take <code>Block</code>s, which simply registers the color handler for the item <code><nowiki>Block#asItem</nowiki></code> (i.e. the block’s <code>BlockItem</code>).
<syntaxhighlight lang="java">
public void registerItemColors(ColorHandlerEvent.Item event){
event.getItemColors().register(myIItemColor, coloredItem1, coloredItem2, ...);
}
</syntaxhighlight>
This registration must be done client-side, in the initialization phase.