diff --git a/src/main/java/com/gtnewhorizons/postea/Postea.java b/src/main/java/com/gtnewhorizons/postea/Postea.java
index cf55f7a..11da543 100644
--- a/src/main/java/com/gtnewhorizons/postea/Postea.java
+++ b/src/main/java/com/gtnewhorizons/postea/Postea.java
@@ -1,5 +1,9 @@
package com.gtnewhorizons.postea;
+import net.minecraftforge.event.world.ChunkEvent;
+
+import com.gtnewhorizons.postea.utility.ChunkFixerUtility;
+import com.gtnewhorizons.postea.utility.IDRegistry;
import com.gtnewhorizons.postea.utility.MissingMappingHandler;
import com.gtnewhorizons.postea.utility.SimpleTransformationRegistry;
import com.gtnewhorizons.postea.utility.TransformerRegistry;
@@ -9,7 +13,6 @@ import cpw.mods.fml.common.event.FMLLoadCompleteEvent;
import cpw.mods.fml.common.event.FMLMissingMappingsEvent;
import cpw.mods.fml.common.event.FMLModIdMappingEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import cpw.mods.fml.common.event.FMLServerStoppingEvent;
@Mod(
modid = Postea.MODID,
@@ -26,10 +29,16 @@ public class Postea {
@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event) {}
+ @Mod.EventHandler
+ public void chunkLoaded(ChunkEvent.Load event) {
+ ChunkFixerUtility.onChunkLoaded(event.getChunk());
+ }
+
@Mod.EventHandler
public void onIdMappingsChanged(FMLModIdMappingEvent event) {
SimpleTransformationRegistry.onIdMappingsChanged();
TransformerRegistry.onIdMappingsChanged();
+ IDRegistry.onMappingUpdated();
}
@Mod.EventHandler
@@ -40,12 +49,6 @@ public class Postea {
@Mod.EventHandler
public void onLoadCompleted(FMLLoadCompleteEvent event) {
SimpleTransformationRegistry.onLoadCompleted();
- MissingMappingHandler.onLoadCompleted();
- }
-
- @Mod.EventHandler
- public void onServerStopping(FMLServerStoppingEvent event) {
- TransformerRegistry.onServerStopping();
}
}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/BlockAccessCompat.java b/src/main/java/com/gtnewhorizons/postea/api/BlockAccessCompat.java
new file mode 100644
index 0000000..fd724ec
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/BlockAccessCompat.java
@@ -0,0 +1,95 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+import com.gtnewhorizons.postea.compat.Compat;
+import com.gtnewhorizons.postea.compat.SubChunkAccess;
+
+/**
+ * Public API for accessing information related to a block located at the location of a tile entity inside a
+ * tile entity transformer registered via
+ * {@link TileEntityReplacementManager#tileEntityTransformer(String, TriFunction)}
+ */
+@SuppressWarnings("unused")
+public abstract class BlockAccessCompat {
+
+ /**
+ * Fetches the id of the block that is (or used to be) at the position of the TE stored in the given tag.
+ *
+ * @apiNote This method is intended for use withing TileEntityTransformers declared via
+ * {@link TileEntityReplacementManager#tileEntityTransformer(String, TriFunction)}
+ *
+ * @param tag The tag for the tile entity
+ * @param chunk The chunk containing the tile entity
+ * @return The id of the block that exists (or used to exist) at that location.
+ */
+ @SuppressWarnings("unused")
+ public static int getBlockIDAtTE(NBTTagCompound tag, Chunk chunk) {
+ // fetch the block accessor
+ ExtendedBlockStorage[] ebsArray = chunk.getBlockStorageArray();
+ // abort if y is oob
+ int y = tag.getInteger("y");
+ if (y >> 4 >= ebsArray.length) return 0;
+ SubChunkAccess access = Compat.getSubChunkAccess(ebsArray[y >> 4]);
+
+ // identify the block
+ int x = tag.getInteger("x") & 0xf;
+ y &= 0xf;
+ int z = tag.getInteger("z") & 0xf;
+ return access.getBlockId(x, y, z);
+ }
+
+ /**
+ * Fetches the meta of the block that is (or used to be) at the position of the TE stored in the given tag.
+ *
+ * @apiNote This method is intended for use withing TileEntityTransformers declared via
+ * {@link TileEntityReplacementManager#tileEntityTransformer(String, TriFunction)}
+ *
+ * @param tag The tag for the tile entity
+ * @param chunk The chunk containing the tile entity
+ * @return The id of the block that exists (or used to exist) at that location.
+ */
+ @SuppressWarnings("unused")
+ public static int getBlockMetaAtTE(NBTTagCompound tag, Chunk chunk) {
+ // fetch the block accessor
+ ExtendedBlockStorage[] ebsArray = chunk.getBlockStorageArray();
+ // abort if y is oob
+ int y = tag.getInteger("y");
+ if (y >> 4 >= ebsArray.length) return 0;
+ SubChunkAccess access = Compat.getSubChunkAccess(ebsArray[y >> 4]);
+
+ // identify the block
+ int x = tag.getInteger("x") & 0xf;
+ y &= 0xf;
+ int z = tag.getInteger("z") & 0xf;
+ return access.getMeta(x, y, z);
+ }
+
+ /**
+ * Fetches the id and meta of the block that is (or used to be) at the position of the TE stored in the given tag.
+ *
+ * @apiNote This method is intended for use withing TileEntityTransformers declared via
+ * {@link TileEntityReplacementManager#tileEntityTransformer(String, TriFunction)}
+ *
+ * @param tag The tag for the tile entity
+ * @param chunk The chunk containing the tile entity
+ * @return An array with th eid of the block that exists (or used to exist) at that location.
+ */
+ @SuppressWarnings("unused")
+ public static int[] getBlockIDAndMetaAtTE(NBTTagCompound tag, Chunk chunk) {
+ // fetch the block accessor
+ ExtendedBlockStorage[] ebsArray = chunk.getBlockStorageArray();
+ // abort if y is oob
+ int y = tag.getInteger("y");
+ if (y >> 4 >= ebsArray.length) return new int[] { 0, 0 };
+ SubChunkAccess access = Compat.getSubChunkAccess(ebsArray[y >> 4]);
+
+ // identify the block
+ int x = tag.getInteger("x") & 0xf;
+ y &= 0xf;
+ int z = tag.getInteger("z") & 0xf;
+ return new int[] { access.getBlockId(x, y, z), access.getMeta(x, y, z) };
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/BlockReplacementManager.java b/src/main/java/com/gtnewhorizons/postea/api/BlockReplacementManager.java
index 46f9a95..03de4ca 100644
--- a/src/main/java/com/gtnewhorizons/postea/api/BlockReplacementManager.java
+++ b/src/main/java/com/gtnewhorizons/postea/api/BlockReplacementManager.java
@@ -1,6 +1,7 @@
package com.gtnewhorizons.postea.api;
import java.util.function.BiFunction;
+import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
@@ -10,11 +11,19 @@ import net.minecraft.world.World;
import net.minecraftforge.oredict.OreDictionary;
import com.gtnewhorizons.postea.utility.BlockConversionInfo;
+import com.gtnewhorizons.postea.utility.IDRegistry;
import com.gtnewhorizons.postea.utility.MissingMappingHandler;
import com.gtnewhorizons.postea.utility.SimpleTransformationRegistry;
import com.gtnewhorizons.postea.utility.TransformerRegistry;
-public class BlockReplacementManager {
+/**
+ * Public API used to register block transformers via postea's handler system.
+ *
+ * Block transformers are executed after Tile Entity transformers, when chunks being loading into the world.
+ */
+public abstract class BlockReplacementManager {
+
+ // region custom transformer registration
/**
* Adds a custom transformer for a given id.
@@ -27,11 +36,11 @@ public class BlockReplacementManager {
*
* If you need to perform a simple transformations consider using the following methods instead:
*
resolver) {
+ if (originalId == null) throw new NullPointerException("originalId cannot be null");
+ if (resolver == null) throw new NullPointerException("resolver cannot be null");
+ IDRegistry.registerBlockIDResolver(originalId, resolver);
+ }
+
+ // endregion id resolving
+
+ // region missing mapping replacements
+
/**
* Adds a mapping to remap stacks and block instances of a specific removed block to the given block whilst, whilst
- * maintaining its meta value.
+ * maintaining its meta value.
*
* IMPORTANT: This only works if the world does not have an existing id set for the target block. If you need
* to transform a missing block into something that was previously given an id (e.g.: Transforming a removed block
- * into dirt), use {@link #addBlockReplacement(String, Block)} with both meta parameters set to
+ * into dirt), use {@link #addSimpleReplacement(String, Block)} with both meta parameters set to
* OreDictionary.WILDCARD_VALUE.
*
* @param originalId The id of the block to remap.
@@ -97,7 +272,7 @@ public class BlockReplacementManager {
public static void replaceMissingBlockWithNewBlock(String originalId, Block block) {
if (originalId == null) throw new IllegalArgumentException("original id is null");
if (block == null) throw new IllegalArgumentException("block is null");
- MissingMappingHandler.addSimpleReplacement(originalId, block);
+ MissingMappingHandler.addBlockMapping(originalId, block);
}
/**
@@ -110,6 +285,10 @@ public class BlockReplacementManager {
MissingMappingHandler.addIgnore(originalId);
}
+ // endregion missing mapping replacements
+
+ // region simple replacements
+
// block -> block
/**
@@ -124,8 +303,8 @@ public class BlockReplacementManager {
* @param block The block to remap to.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, @Nonnull Block block) {
- addBlockReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, OreDictionary.WILDCARD_VALUE, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Block block) {
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, OreDictionary.WILDCARD_VALUE, false);
}
/**
@@ -141,8 +320,8 @@ public class BlockReplacementManager {
* @param skipStackRemap Set to true to skip auto-adding an item stack remapper.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, @Nonnull Block block, boolean skipStackRemap) {
- addBlockReplacement(
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Block block, boolean skipStackRemap) {
+ addSimpleReplacement(
originalId,
OreDictionary.WILDCARD_VALUE,
block,
@@ -161,8 +340,8 @@ public class BlockReplacementManager {
* @param block The block to remap to.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block) {
- addBlockReplacement(originalId, originalMeta, block, OreDictionary.WILDCARD_VALUE, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block) {
+ addSimpleReplacement(originalId, originalMeta, block, OreDictionary.WILDCARD_VALUE, false);
}
/**
@@ -175,9 +354,9 @@ public class BlockReplacementManager {
* @param skipStackRemap Set to true to skip auto-adding an item stack remapper.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block,
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block,
boolean skipStackRemap) {
- addBlockReplacement(originalId, originalMeta, block, OreDictionary.WILDCARD_VALUE, skipStackRemap);
+ addSimpleReplacement(originalId, originalMeta, block, OreDictionary.WILDCARD_VALUE, skipStackRemap);
}
// block -> block+meta
@@ -191,8 +370,8 @@ public class BlockReplacementManager {
* @param newMeta The meta of the block to remap to. OreDictionary.WILDCARD_VALUE maintains the existing value.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, @Nonnull Block block, int newMeta) {
- addBlockReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, newMeta, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Block block, int newMeta) {
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, newMeta, false);
}
/**
@@ -206,9 +385,9 @@ public class BlockReplacementManager {
* @param skipStackRemap Set to true to skip auto-adding an item stack remapper.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, @Nonnull Block block, int newMeta,
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Block block, int newMeta,
boolean skipStackRemap) {
- addBlockReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, newMeta, skipStackRemap);
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, block, newMeta, skipStackRemap);
}
// block+meta -> block+meta
@@ -223,9 +402,9 @@ public class BlockReplacementManager {
* @param newMeta The meta of the block to remap to. OreDictionary.WILDCARD_VALUE maintains the existing value.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block,
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Block block,
int newMeta) {
- addBlockReplacement(originalId, originalMeta, block, newMeta, false);
+ addSimpleReplacement(originalId, originalMeta, block, newMeta, false);
}
/**
@@ -240,10 +419,13 @@ public class BlockReplacementManager {
* @param skipStackRemap Set to true to skip auto-adding an item stack remapper.
*/
@SuppressWarnings("unused")
- public static void addBlockReplacement(String originalId, int originalMeta, Block block, int newMeta,
+ public static void addSimpleReplacement(String originalId, int originalMeta, Block block, int newMeta,
boolean skipStackRemap) {
if (originalId == null) throw new IllegalArgumentException("original id is null");
if (block == null) throw new IllegalArgumentException("block is null");
SimpleTransformationRegistry.addSimpleTransformer(originalId, originalMeta, block, newMeta, skipStackRemap);
}
+
+ // endregion simple replacements
+
}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/IComplexBlockTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/IComplexBlockTransformer.java
new file mode 100644
index 0000000..5ed00d7
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/IComplexBlockTransformer.java
@@ -0,0 +1,16 @@
+package com.gtnewhorizons.postea.api;
+
+import com.gtnewhorizons.postea.utility.BlockConversionInfo;
+
+@FunctionalInterface
+public interface IComplexBlockTransformer {
+
+ /**
+ * A custom transformer for blocks.
+ *
+ * @param info The information about the block.
+ * @return True if the block was replaced and no other block transformation handler should be executed for the
+ * associated original id;
+ */
+ boolean transformBlock(BlockConversionInfo info);
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/IComplexStackTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/IComplexStackTransformer.java
new file mode 100644
index 0000000..f050a9a
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/IComplexStackTransformer.java
@@ -0,0 +1,16 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+@FunctionalInterface
+public interface IComplexStackTransformer {
+
+ /**
+ * A custom transformer for items.
+ *
+ * @param originalId The namespaced id of the stack being passed to this transformer.
+ * @param tag The raw nbt data of the stack being transformed.
+ * @return A non-null value to prevent any future handlers from executing or if the stack was replaced.
+ */
+ boolean transformStack(String originalId, NBTTagCompound tag);
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/IDExtenderCompat.java b/src/main/java/com/gtnewhorizons/postea/api/IDExtenderCompat.java
index 41f756b..c34336f 100644
--- a/src/main/java/com/gtnewhorizons/postea/api/IDExtenderCompat.java
+++ b/src/main/java/com/gtnewhorizons/postea/api/IDExtenderCompat.java
@@ -5,8 +5,13 @@ import static net.minecraftforge.common.util.Constants.NBT.TAG_SHORT;
import net.minecraft.nbt.NBTTagCompound;
+/**
+ * Public API used to query and update stack item IDs inside Postea transformers.
+ */
+@SuppressWarnings("unused")
public class IDExtenderCompat {
+ @SuppressWarnings("unused")
public static int getItemStackID(NBTTagCompound tag) {
if (tag.hasKey("idExt", TAG_INT)) return tag.getInteger("idExt");
else if (tag.hasKey("id", TAG_INT)) return tag.getInteger("id");
@@ -14,6 +19,7 @@ public class IDExtenderCompat {
else return 0;
}
+ @SuppressWarnings("unused")
public static void setItemStackID(NBTTagCompound tag, int id) {
if (id < 32000) {
tag.setShort("id", (short) id);
diff --git a/src/main/java/com/gtnewhorizons/postea/api/ISimpleBlockTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/ISimpleBlockTransformer.java
new file mode 100644
index 0000000..c553f9f
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/ISimpleBlockTransformer.java
@@ -0,0 +1,10 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.block.Block;
+
+public interface ISimpleBlockTransformer {
+
+ Block getTargetBlock();
+
+ int getTargetBlockMeta();
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/ISimpleItemTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/ISimpleItemTransformer.java
new file mode 100644
index 0000000..ae73d5d
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/ISimpleItemTransformer.java
@@ -0,0 +1,10 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.item.Item;
+
+public interface ISimpleItemTransformer {
+
+ Item getTargetItem();
+
+ int getTargetItemMeta();
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/ISimpleStackTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/ISimpleStackTransformer.java
new file mode 100644
index 0000000..27e7ee8
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/ISimpleStackTransformer.java
@@ -0,0 +1,8 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.item.ItemStack;
+
+public interface ISimpleStackTransformer {
+
+ ItemStack getTargetStack();
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/ItemStackReplacementManager.java b/src/main/java/com/gtnewhorizons/postea/api/ItemStackReplacementManager.java
index cc1f3c1..4095e1e 100644
--- a/src/main/java/com/gtnewhorizons/postea/api/ItemStackReplacementManager.java
+++ b/src/main/java/com/gtnewhorizons/postea/api/ItemStackReplacementManager.java
@@ -1,6 +1,7 @@
package com.gtnewhorizons.postea.api;
import java.util.function.BiFunction;
+import java.util.function.Consumer;
import java.util.function.Function;
import javax.annotation.Nonnull;
@@ -11,13 +12,21 @@ import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.oredict.OreDictionary;
+import com.gtnewhorizons.postea.utility.IDRegistry;
import com.gtnewhorizons.postea.utility.MissingMappingHandler;
import com.gtnewhorizons.postea.utility.SimpleTransformationRegistry;
import com.gtnewhorizons.postea.utility.TransformerRegistry;
-public class ItemStackReplacementManager {
+/**
+ * Public API used to register item stack transformers via postea's handler system.
+ *
+ * Item stack transformers are applied when something tries to convert any NBT that has an "id" field into an item
+ * stack.
+ */
+@SuppressWarnings("unused")
+public abstract class ItemStackReplacementManager {
- // Public API for converting ItemStacks.
+ // region custom transformer registration
/**
* Adds a custom transformer for a given id.
@@ -30,10 +39,11 @@ public class ItemStackReplacementManager {
*
* If you need to perform a simple transformations consider using the following methods instead:
*
- * - item -> item (with same meta): {@link #addItemReplacement(String, Item)}
- * - item -> item with specific meta: {@link #addItemReplacement(String, Item, int)}
- * - item with meta -> item (with same meta): {@link #addItemReplacement(String, int, Item)}
- * - item with meta -> item with specific meta: {@link #addItemReplacement(String, int, Item, int)}
+ * - item -> item (with same meta): {@link #addSimpleReplacement(String, Item)}
+ * - item -> item with specific meta: {@link #addSimpleReplacement(String, Item, int)}
+ * - item with meta -> item (with same meta): {@link #addSimpleReplacement(String, int, Item)}
+ * - item with meta -> item with specific meta:
+ * {@link #addSimpleReplacement(String, int, Item, int)}
*
*
* @implNote For performance reasons, Postea assumes that the tag that was passed to the handler hasn't been
@@ -61,10 +71,11 @@ public class ItemStackReplacementManager {
*
* If you need to perform a simple transformations consider using the following methods instead:
*
- * - item -> item (with same meta): {@link #addItemReplacement(String, Item)}
- * - item -> item with specific meta: {@link #addItemReplacement(String, Item, int)}
- * - item with meta -> item (with same meta): {@link #addItemReplacement(String, int, Item)}
- * - item with meta -> item with specific meta: {@link #addItemReplacement(String, int, Item, int)}
+ * - item -> item (with same meta): {@link #addSimpleReplacement(String, Item)}
+ * - item -> item with specific meta: {@link #addSimpleReplacement(String, Item, int)}
+ * - item with meta -> item (with same meta): {@link #addSimpleReplacement(String, int, Item)}
+ * - item with meta -> item with specific meta:
+ * {@link #addSimpleReplacement(String, int, Item, int)}
*
*
* @implNote For performance reasons, Postea assumes that the tag that was passed to the handler hasn't been
@@ -83,12 +94,47 @@ public class ItemStackReplacementManager {
TransformerRegistry.addStackTransformer(originalId, transformer);
}
+ // endregion custom transformer registration
+
+ // region id resolving
+
/**
- * Adds a mapping to remap stacks of a specific removed item to the given item.
- *
+ * Registers a callback function that will be provided the numeric ID of the given namespaced ID when a world is
+ * first loaded. Since forge doesn't discard stacks associated with missing IDs when loading a world for
+ * performance reasons, instead opting to null the result of the nbt data read, you can store that value into a
+ * static field, and use it to compare against an id provided to you during the execution of a transformation
+ * handler.
+ *
+ * This function is mostly intended to speed up larger transformer handlers since resolving the string id of a
+ * removed id inside a transformer will be slower than simply matching for it. Regular item transformers are
+ * already provided the string ID of the item they are transforming so, there is no reason not to do a switch case
+ * on those. This also overcomes the need to create dummy blocks and items in order to identify
+ * items inside a custom stack transformer.
+ *
+ * For compatibility reasons, it's better not to register dummies to take the place of dummy items. If one mod was
+ * to only convert blocks with a specific meta while another handled the rest, the other mod would either need
+ * additional work to detect your own dummy blocks or even worst, fail to identify the original blocks as it's not
+ * aware of your dummy blocks.
+ *
+ * @param originalId The namespaced ID of a block you wish to identify in one of your transformers.
+ * @param resolver The callback executed to provide the numeric ID of the given namespaced ID.
+ */
+ @SuppressWarnings("unused")
+ public static void registerIDResolver(String originalId, Consumer resolver) {
+ if (originalId == null) throw new NullPointerException("originalId cannot be null");
+ if (resolver == null) throw new NullPointerException("resolver cannot be null");
+ IDRegistry.registerItemIDResolver(originalId, resolver);
+ }
+
+ // endregion id resolving
+
+ // region missing mapping replacements
+ /**
+ * Adds a mapping to remap stacks of a specific removed item to the given item.
+ *
* IMPORTANT: This only works if the world does not have an existing id set for the target item. If you need
* to transform a missing item into something that was previously given an id (e.g.: Transforming a removed item
- * into a stick), use {@link #addItemReplacement(String, int, Item, int)} with both meta values set to
+ * into a stick), use {@link #addSimpleReplacement(String, int, Item, int)} with both meta values set to
* OreDictionary.WILDCARD_VALUE.
*
* @param originalId The id of the item to remap.
@@ -98,7 +144,7 @@ public class ItemStackReplacementManager {
public static void replaceMissingItemWithNewItem(String originalId, Item item) {
if (originalId == null) throw new IllegalArgumentException("original id is null");
if (item == null) throw new IllegalArgumentException("item is null");
- MissingMappingHandler.addSimpleReplacement(originalId, item);
+ MissingMappingHandler.addItemMapping(originalId, item);
}
/**
@@ -111,6 +157,10 @@ public class ItemStackReplacementManager {
MissingMappingHandler.addIgnore(originalId);
}
+ // endregion missing mapping replacements
+
+ // region simple replacements
+
// item -> item
/**
@@ -128,8 +178,8 @@ public class ItemStackReplacementManager {
* @param item The item to remap to.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull Item item) {
- addItemReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, OreDictionary.WILDCARD_VALUE, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Item item) {
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, OreDictionary.WILDCARD_VALUE, false);
}
/**
@@ -147,8 +197,8 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a block remapper if the item happens to be an ItemBlock.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull Item item, boolean skipBlockRemap) {
- addItemReplacement(
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Item item, boolean skipBlockRemap) {
+ addSimpleReplacement(
originalId,
OreDictionary.WILDCARD_VALUE,
item,
@@ -170,8 +220,8 @@ public class ItemStackReplacementManager {
* @param newMeta The meta of the item to remap to. OreDictionary.WILDCARD_VALUE maintains the existing value.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull Item item, int newMeta) {
- addItemReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, newMeta, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Item item, int newMeta) {
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, newMeta, false);
}
/**
@@ -187,9 +237,9 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a block remapper if the item happens to be an ItemBlock.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull Item item, int newMeta,
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull Item item, int newMeta,
boolean skipBlockRemap) {
- addItemReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, newMeta, skipBlockRemap);
+ addSimpleReplacement(originalId, OreDictionary.WILDCARD_VALUE, item, newMeta, skipBlockRemap);
}
// item -> stack
@@ -207,8 +257,8 @@ public class ItemStackReplacementManager {
* @param stack The item to remap to.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull ItemStack stack) {
- addItemReplacement(
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull ItemStack stack) {
+ addSimpleReplacement(
originalId,
OreDictionary.WILDCARD_VALUE,
stack.getItem(),
@@ -229,9 +279,9 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a block remapper if the item happens to be an ItemBlock.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, @Nonnull ItemStack stack,
+ public static void addSimpleReplacement(@Nonnull String originalId, @Nonnull ItemStack stack,
boolean skipBlockRemap) {
- addItemReplacement(
+ addSimpleReplacement(
originalId,
OreDictionary.WILDCARD_VALUE,
stack.getItem(),
@@ -253,8 +303,8 @@ public class ItemStackReplacementManager {
* @param item The item to remap to.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item) {
- addItemReplacement(originalId, originalMeta, item, OreDictionary.WILDCARD_VALUE, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item) {
+ addSimpleReplacement(originalId, originalMeta, item, OreDictionary.WILDCARD_VALUE, false);
}
/**
@@ -270,9 +320,9 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a item remapper if the .
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item,
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item,
boolean skipBlockRemap) {
- addItemReplacement(originalId, originalMeta, item, OreDictionary.WILDCARD_VALUE, skipBlockRemap);
+ addSimpleReplacement(originalId, originalMeta, item, OreDictionary.WILDCARD_VALUE, skipBlockRemap);
}
// item+meta -> stack
@@ -291,8 +341,8 @@ public class ItemStackReplacementManager {
* @param stack A stack of the item to replace to.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, int originalMeta, @Nonnull ItemStack stack) {
- addItemReplacement(originalId, originalMeta, stack, false);
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull ItemStack stack) {
+ addSimpleReplacement(originalId, originalMeta, stack, false);
}
/**
@@ -310,9 +360,9 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a block remapper if the item happens to be an ItemBlock.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, int originalMeta, @Nonnull ItemStack stack,
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull ItemStack stack,
boolean skipBlockRemap) {
- addItemReplacement(originalId, originalMeta, stack.getItem(), Items.feather.getDamage(stack), skipBlockRemap);
+ addSimpleReplacement(originalId, originalMeta, stack.getItem(), Items.feather.getDamage(stack), skipBlockRemap);
}
// item+meta -> item+meta
@@ -330,9 +380,9 @@ public class ItemStackReplacementManager {
* @param newMeta The meta of the item to remap to. OreDictionary.WILDCARD_VALUE maintains the existing value.
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item,
+ public static void addSimpleReplacement(@Nonnull String originalId, int originalMeta, @Nonnull Item item,
int newMeta) {
- addItemReplacement(originalId, originalMeta, item, newMeta, false);
+ addSimpleReplacement(originalId, originalMeta, item, newMeta, false);
}
/**
@@ -350,10 +400,12 @@ public class ItemStackReplacementManager {
* @param skipBlockRemap Set to true to skip auto-adding a item remapper if the .
*/
@SuppressWarnings("unused")
- public static void addItemReplacement(String originalId, int originalMeta, Item item, int newMeta,
+ public static void addSimpleReplacement(String originalId, int originalMeta, Item item, int newMeta,
boolean skipBlockRemap) {
if (originalId == null) throw new IllegalArgumentException("original id is null");
if (item == null) throw new IllegalArgumentException("item is null");
SimpleTransformationRegistry.addSimpleTransformer(originalId, originalMeta, item, newMeta, skipBlockRemap);
}
+
+ // endregion simple replacements
}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/PosteaBlockStackTransformer.java b/src/main/java/com/gtnewhorizons/postea/api/PosteaBlockStackTransformer.java
new file mode 100644
index 0000000..788c262
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/api/PosteaBlockStackTransformer.java
@@ -0,0 +1,79 @@
+package com.gtnewhorizons.postea.api;
+
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.oredict.OreDictionary;
+
+import com.gtnewhorizons.postea.utility.BlockConversionInfo;
+
+public abstract class PosteaBlockStackTransformer {
+
+ public String originalId;
+ public int originalMeta;
+
+ public PosteaBlockStackTransformer(String originalId) {
+ this(originalId, OreDictionary.WILDCARD_VALUE);
+ }
+
+ public PosteaBlockStackTransformer(String originalId, int originalMeta) {
+ this.originalId = originalId;
+ this.originalMeta = originalMeta;
+ }
+
+ public void register() {
+ if (this instanceof IComplexStackTransformer cst) {
+ if (this.originalMeta == OreDictionary.WILDCARD_VALUE) {
+ ItemStackReplacementManager.addTransformationHandler(
+ this.originalId,
+ (originalId, tag) -> complexStackTransformerCheckMeta(originalId, tag, cst));
+ } else {
+ ItemStackReplacementManager.addTransformationHandler(this.originalId, cst::transformStack);
+ }
+ }
+ if (this instanceof IComplexBlockTransformer cbt) {
+ if (this.originalMeta == OreDictionary.WILDCARD_VALUE) {
+ BlockReplacementManager
+ .addTransformationHandler(this.originalId, (info) -> complexBlockTransformerCheckMeta(info, cbt));
+ } else {
+ BlockReplacementManager.addTransformationHandler(this.originalId, cbt::transformBlock);
+ }
+ }
+ if (this instanceof ISimpleBlockTransformer sbt) {
+ BlockReplacementManager.addSimpleReplacement(
+ this.originalId,
+ this.originalMeta,
+ sbt.getTargetBlock(),
+ sbt.getTargetBlockMeta(),
+ true);
+ }
+ if (this instanceof ISimpleItemTransformer sit) {
+ ItemStackReplacementManager.addSimpleReplacement(
+ this.originalId,
+ this.originalMeta,
+ sit.getTargetItem(),
+ sit.getTargetItemMeta(),
+ true);
+ }
+ if (this instanceof ISimpleStackTransformer sst) {
+ ItemStack stack = sst.getTargetStack();
+ ItemStackReplacementManager.addSimpleReplacement(
+ this.originalId,
+ this.originalMeta,
+ stack.getItem(),
+ Items.feather.getDamage(stack),
+ true);
+ }
+ }
+
+ private boolean complexStackTransformerCheckMeta(String originalId, NBTTagCompound tag,
+ IComplexStackTransformer st) {
+ if (tag.getShort("Damage") != originalMeta) return false;
+ return st.transformStack(originalId, tag);
+ }
+
+ private boolean complexBlockTransformerCheckMeta(BlockConversionInfo info, IComplexBlockTransformer bt) {
+ if (info.metadata != originalMeta) return false;
+ return bt.transformBlock(info);
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/TileEntityReplacementManager.java b/src/main/java/com/gtnewhorizons/postea/api/TileEntityReplacementManager.java
index 845596c..bcad3ec 100644
--- a/src/main/java/com/gtnewhorizons/postea/api/TileEntityReplacementManager.java
+++ b/src/main/java/com/gtnewhorizons/postea/api/TileEntityReplacementManager.java
@@ -1,20 +1,23 @@
package com.gtnewhorizons.postea.api;
-import java.util.Collection;
import java.util.function.BiFunction;
+import java.util.function.Consumer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
-import com.google.common.collect.LinkedListMultimap;
import com.gtnewhorizons.postea.utility.BlockInfo;
+import com.gtnewhorizons.postea.utility.PosteaUtilities;
+import com.gtnewhorizons.postea.utility.TransformerRegistry;
+/**
+ * Public API used to register tile entity transformers via postea's handler system.
+ *
+ * Tile entity transformers are executed before any block transformers, when chunks being loading into the world.
+ */
@SuppressWarnings("unused")
-public class TileEntityReplacementManager {
-
- private static final LinkedListMultimap> tileEntityToNormalBlockTransformer = LinkedListMultimap
- .create();
+public abstract class TileEntityReplacementManager {
/**
* @deprecated Superseded by {@link #tileEntityTransformer(String, TriFunction)}.
@@ -22,26 +25,57 @@ public class TileEntityReplacementManager {
@Deprecated
public static void tileEntityTransformer(String tileEntityId,
BiFunction transformerFunction) {
- tileEntityToNormalBlockTransformer
- .put(tileEntityId, (tag, world, chunk) -> transformerFunction.apply(tag, world));
+ if (transformerFunction == null) throw new NullPointerException("transformer is null");
+ tileEntityTransformer(tileEntityId, (tag, world, chunk) -> transformerFunction.apply(tag, world));
}
/**
* Register a callback function to transform a tile entity before it's loaded.
- * Callback returns a {@link BlockInfo} which the tile entity will be transformed into.
- * Note that the callback will be called before the world is fully loaded, and world.getBlock will throw an error.
- * Use chunk.getBlock(x & 15, y, z & 15) instead.
+ * Callback returns a {@link BlockInfo} which the tile entity will be transformed into.
+ * If you return a null value instead of a block info, Postea will assume that you don't want to replace the block
+ * and/or tile entity and look for any other compatible handlers that may be able to do a replacement.
+ *
+ * Note that the callback will be called before the world is fully loaded, and {@code world.getBlock} will throw an
+ * error. If you need to identify a block, consider using
+ * {@link BlockReplacementManager#registerIDResolver(String, Consumer)}
+ * and {@link BlockAccessCompat#getBlockIDAtTE(NBTTagCompound, Chunk)} instead. If you need to identify the meta
+ * value, consider using {@code Chunk.getBlockMetadata(x & 15, y, z & 15)} or the other functions inside of
+ * {@link BlockReplacementManager}.
+ *
+ * {@code BlockReplacementManager.registerIDResolver} registers a simple callback that will be executed just after
+ * the game resolves all numeric ID conflicts when loading a save. The provided value is the numeric ID of the
+ * block linked provided string ID or -1 if the block has never been registered while the currently
+ * loading world.
+ *
+ * {@code BlockAccessCompat.getBlockIDAtTE} lets you fetch the ID of the block where the current tile entity is
+ * located. Since forge doesn't actually replace the id of missing blocks for performance reasons, opting to treat
+ * them like air instead; You can use the value given to the resolver you registered using
+ * {@code BlockReplacementManager.registerIDResolver} to identify the block directly.
+ *
+ * Using these 2 methods skips the need to register dummy blocks or items to identify blocks when migrating things,
+ * which will improve the overall performance and compatibility of your migrations.
*
* @param tileEntityId ID of the tile entity to be transformed
* @param transformerFunction Callback function to transforms the tile entity
*/
public static void tileEntityTransformer(String tileEntityId,
TriFunction transformerFunction) {
- tileEntityToNormalBlockTransformer.put(tileEntityId, transformerFunction);
+ if (transformerFunction == null) throw new NullPointerException("transformer is null");
+ if (tileEntityId == null) throw new NullPointerException("transformer is null");
+ TransformerRegistry.addTileEntityTransformer(tileEntityId, transformerFunction);
}
- public static Collection> getTileEntityToNormalBlockTransformerFunction(
- String tileEntityId) {
- return tileEntityToNormalBlockTransformer.get(tileEntityId);
+ /**
+ * Creates a bare-bones tile entity tag for the provided ID that clones all the positional information of the
+ * provided tile entity NBT Tag. The passed NBT tag is never modified.
+ *
+ * @param tag The tag of the tile entity at the current position.
+ * @param newId The ID of the new tile entity.
+ * @return A bare-bones tile entity tag for the provided id at ths same position as the passed tile entity tag.
+ */
+ public static NBTTagCompound createTETagAtSamePosition(String newId, NBTTagCompound tag) {
+ if (tag == null) throw new NullPointerException("tag was null");
+ if (newId == null) throw new NullPointerException("tag was null");
+ return PosteaUtilities.cleanseNBT(newId, tag);
}
}
diff --git a/src/main/java/com/gtnewhorizons/postea/api/TriFunction.java b/src/main/java/com/gtnewhorizons/postea/api/TriFunction.java
index eaf05f7..3658ab4 100644
--- a/src/main/java/com/gtnewhorizons/postea/api/TriFunction.java
+++ b/src/main/java/com/gtnewhorizons/postea/api/TriFunction.java
@@ -1,5 +1,13 @@
package com.gtnewhorizons.postea.api;
+/**
+ * A simple function interface for functions with 3 parameters that must return a value.
+ *
+ * @param The first parameter type.
+ * @param The second parameter type.
+ * @param The third parameter type.
+ * @param The return type.
+ */
@FunctionalInterface
public interface TriFunction {
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/PosteaLoadingPlugin.java b/src/main/java/com/gtnewhorizons/postea/mixins/PosteaLoadingPlugin.java
index 590e2f6..03c4428 100644
--- a/src/main/java/com/gtnewhorizons/postea/mixins/PosteaLoadingPlugin.java
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/PosteaLoadingPlugin.java
@@ -46,6 +46,7 @@ public final class PosteaLoadingPlugin implements IEarlyMixinLoader, IFMLLoading
mixins.add("MixinItemStack");
mixins.add("MixinChunk");
mixins.add("MixinAnvilChunkLoader");
+ mixins.add("MixinNBTTagList");
return mixins;
}
}
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/PosteaPreInitLoadingPlugin.java b/src/main/java/com/gtnewhorizons/postea/mixins/PosteaPreInitLoadingPlugin.java
new file mode 100644
index 0000000..0def35a
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/PosteaPreInitLoadingPlugin.java
@@ -0,0 +1,49 @@
+package com.gtnewhorizons.postea.mixins;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+import org.spongepowered.asm.lib.tree.ClassNode;
+import org.spongepowered.asm.mixin.extensibility.IMixinConfigPlugin;
+import org.spongepowered.asm.mixin.extensibility.IMixinInfo;
+
+public final class PosteaPreInitLoadingPlugin implements IMixinConfigPlugin {
+
+ @Override
+ public void onLoad(String mixinPackage) {
+
+ }
+
+ @Override
+ public String getRefMapperConfig() {
+ return null;
+ }
+
+ @Override
+ public boolean shouldApplyMixin(String targetClassName, String mixinClassName) {
+ return true;
+ }
+
+ @Override
+ public void acceptTargets(Set myTargets, Set otherTargets) {
+
+ }
+
+ @Override
+ public List getMixins() {
+ List mixins = new ArrayList<>();
+ mixins.add("MixinGameData");
+ return mixins;
+ }
+
+ @Override
+ public void preApply(String s, ClassNode classNode, String s1, IMixinInfo iMixinInfo) {
+
+ }
+
+ @Override
+ public void postApply(String s, ClassNode classNode, String s1, IMixinInfo iMixinInfo) {
+
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinAnvilChunkLoader.java b/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinAnvilChunkLoader.java
index 927356d..cb342dd 100644
--- a/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinAnvilChunkLoader.java
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinAnvilChunkLoader.java
@@ -4,7 +4,6 @@ import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.storage.AnvilChunkLoader;
-import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.injection.At;
@@ -12,7 +11,6 @@ import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
-import com.gtnewhorizons.postea.mixins.interfaces.IChunkMixin;
import com.gtnewhorizons.postea.utility.ChunkFixerUtility;
import com.llamalad7.mixinextras.sugar.Local;
@@ -23,53 +21,17 @@ public abstract class MixinAnvilChunkLoader {
@Inject(method = "readChunkFromNBT", at = @At("RETURN"), require = 1)
private void postea$chunkHook(CallbackInfoReturnable cir, @Local Chunk chunk,
@Local(argsOnly = true) World world, @Local(ordinal = 0, argsOnly = true) NBTTagCompound tag) {
- IChunkMixin chunkMixin = (IChunkMixin) chunk;
- chunkMixin.Postea$setPosteaCode(-1);
- if (tag.hasKey("POSTEA")) {
- chunkMixin.Postea$setPosteaCode(tag.getLong("POSTEA"));
- }
- // This checks if the chunk has been run with the current POSTEA_UPDATE_CODE and skips it if so.
- if (chunkMixin.Postea$getPosteaCode() == ChunkFixerUtility.POSTEA_UPDATE_CODE) return;
- for (ExtendedBlockStorage ebs : chunk.getBlockStorageArray()) {
- if (ebs == null) {
- continue;
- }
- ChunkFixerUtility.transformNormalBlocks(chunk, ebs, world);
- }
- }
-
- @Inject(
- method = "loadEntities",
- at = @At(
- value = "INVOKE",
- target = "Lnet/minecraft/nbt/NBTTagCompound;getTagList(Ljava/lang/String;I)Lnet/minecraft/nbt/NBTTagList;",
- ordinal = 1),
- require = 1)
- private void postea$transformTileEntities(CallbackInfo ci, @Local(ordinal = 0) NBTTagCompound tag,
- @Local World world, @Local Chunk chunk) {
- IChunkMixin chunkMixin = (IChunkMixin) chunk;
- // This checks if the chunk has been run with the current POSTEA_UPDATE_CODE and skips it if so.
- if (chunkMixin.Postea$getPosteaCode() == ChunkFixerUtility.POSTEA_UPDATE_CODE) return;
-
- ChunkFixerUtility.transformTileEntities(tag, chunk, world);
+ ChunkFixerUtility.onChunkRead(chunk, world, tag);
}
@Inject(method = "loadChunk", at = @At("RETURN"))
private void postea$updatePosteaChunkCode(World world, int i, int j, CallbackInfoReturnable cir) {
- Chunk chunk = cir.getReturnValue();
- if (chunk instanceof IChunkMixin iChunkMixin) {
- if (iChunkMixin.Postea$getPosteaCode() != ChunkFixerUtility.POSTEA_UPDATE_CODE) {
- iChunkMixin.Postea$setPosteaCode(ChunkFixerUtility.POSTEA_UPDATE_CODE);
- chunk.setChunkModified();
- }
- }
+ ChunkFixerUtility.onChunkLoaded(cir.getReturnValue());
}
@Inject(method = "writeChunkToNBT", at = @At("HEAD"))
private void postea$writePosteaChunkCode(Chunk chunk, World world, NBTTagCompound nbtTagCompound, CallbackInfo ci) {
- if (chunk instanceof IChunkMixin iChunkMixin) {
- nbtTagCompound.setLong("POSTEA", iChunkMixin.Postea$getPosteaCode());
- }
+ ChunkFixerUtility.onChunkWrite(chunk, nbtTagCompound);
}
}
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinNBTTagList.java b/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinNBTTagList.java
new file mode 100644
index 0000000..f870033
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/early/MixinNBTTagList.java
@@ -0,0 +1,28 @@
+package com.gtnewhorizons.postea.mixins.early;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+
+import com.gtnewhorizons.postea.mixins.interfaces.IMixinNBTTagList;
+
+@Mixin(NBTTagList.class)
+public class MixinNBTTagList implements IMixinNBTTagList {
+
+ @Shadow
+ @Final
+ private List tagList = new ArrayList();
+
+ @Override
+ @Unique
+ public void Postea$replaceCompoundTagAt(int index, NBTTagCompound tag) {
+ tagList.set(index, tag);
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/interfaces/IMixinNBTTagList.java b/src/main/java/com/gtnewhorizons/postea/mixins/interfaces/IMixinNBTTagList.java
new file mode 100644
index 0000000..47e7f5a
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/interfaces/IMixinNBTTagList.java
@@ -0,0 +1,8 @@
+package com.gtnewhorizons.postea.mixins.interfaces;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public interface IMixinNBTTagList {
+
+ void Postea$replaceCompoundTagAt(int index, NBTTagCompound tag);
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/mixins/preinit/MixinGameData.java b/src/main/java/com/gtnewhorizons/postea/mixins/preinit/MixinGameData.java
new file mode 100644
index 0000000..94820ec
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/mixins/preinit/MixinGameData.java
@@ -0,0 +1,30 @@
+package com.gtnewhorizons.postea.mixins.preinit;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import com.gtnewhorizons.postea.utility.IDRegistry;
+
+import cpw.mods.fml.common.registry.GameData;
+
+@Mixin(value = GameData.class, remap = false)
+public abstract class MixinGameData {
+
+ @Inject(
+ method = "injectWorldIDMap(Ljava/util/Map;Ljava/util/Set;Ljava/util/Map;Ljava/util/Map;Ljava/util/Set;Ljava/util/Set;ZZ)Ljava/util/List;",
+ at = @At("HEAD"),
+ require = 1)
+ @SuppressWarnings("unused")
+ private static void Postea$injectWorldIDMap(Map dataList, Set blockedIds,
+ Map blockAliases, Map itemAliases, Set blockSubstitutions,
+ Set itemSubstitutions, boolean injectFrozenData, boolean isLocalWorld,
+ CallbackInfoReturnable> cir) {
+ IDRegistry.registerWorldSpecificIDs(dataList);
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/BlockConversionInfo.java b/src/main/java/com/gtnewhorizons/postea/utility/BlockConversionInfo.java
index 2b27808..b9d6c91 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/BlockConversionInfo.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/BlockConversionInfo.java
@@ -4,12 +4,35 @@ import net.minecraft.world.World;
public final class BlockConversionInfo {
+ /**
+ * The namespaced ID of the block being converted.
+ */
public final String blockName;
+ /**
+ * The numeric ID of the block currently being replaced, or of the block you want it replaced with.
+ */
public int blockID;
+ /**
+ * The meta value of the block currently being replaced, or value you want it replaced with.
+ */
public int metadata;
+ /**
+ * The x coordinate of the block being replaced.
+ */
public final int x;
+ /**
+ * The y coordinate of the block being replaced.
+ */
public final int y;
+ /**
+ * The z coordinate of the block being replaced.
+ */
public final int z;
+
+ /**
+ * The world containing the block being replaced. It won't be loaded fully when a block transformer is executed, so
+ * any call to something like world.getBlock() will throw an error.
+ */
public final World world;
public BlockConversionInfo(String blockName, int blockID, int metadata, int x, int y, int z, World world) {
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/BlockInfo.java b/src/main/java/com/gtnewhorizons/postea/utility/BlockInfo.java
index 484f7f6..d2eebba 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/BlockInfo.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/BlockInfo.java
@@ -11,12 +11,29 @@ public final class BlockInfo {
public final int metadata;
public final Function tileTransformer;
+ /**
+ * Used to notify postea that you wish to update a tile entity, and the block situated at that same location.
+ *
+ * @param block The block that should replace the block currently stored at the tile entity's location.
+ * @param metadata The meta value of the block being placed where the tile entity used to exist.
+ * @param tileTransformer A transformer function for the NBT data of the tile entity. (you can just edit the one
+ * passed to the transformer instead, it's executed right after you return this block info,
+ * just make sure to provide a pass though function otherwise we won't know you want to keep
+ * the tile entity alive.)
+ */
public BlockInfo(Block block, int metadata, Function tileTransformer) {
this.block = block;
this.metadata = metadata;
this.tileTransformer = tileTransformer;
}
+ /**
+ * Used to replace a tile entity with a block that does not need any tile entity data. Any existing data will be
+ * erased when returning a block info created with this constructor.
+ *
+ * @param block The block that should replace the block currently stored at the tile entity's location.
+ * @param metadata The meta value of the block being placed where the tile entity used to exist.
+ */
public BlockInfo(Block block, int metadata) {
this.block = block;
this.metadata = metadata;
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/ChunkFixerUtility.java b/src/main/java/com/gtnewhorizons/postea/utility/ChunkFixerUtility.java
index 55dd554..caa6132 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/ChunkFixerUtility.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/ChunkFixerUtility.java
@@ -1,6 +1,5 @@
package com.gtnewhorizons.postea.utility;
-import static com.gtnewhorizons.postea.utility.PosteaUtilities.getModListHash;
import static com.gtnewhorizons.postea.utility.TransformerRegistry.getBlockReplacement;
import java.util.ArrayList;
@@ -13,21 +12,72 @@ import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
-import com.gtnewhorizons.postea.api.TileEntityReplacementManager;
import com.gtnewhorizons.postea.api.TriFunction;
import com.gtnewhorizons.postea.compat.Compat;
import com.gtnewhorizons.postea.compat.SubChunkAccess;
-
-import akka.japi.Pair;
+import com.gtnewhorizons.postea.mixins.interfaces.IChunkMixin;
+import com.gtnewhorizons.postea.mixins.interfaces.IMixinNBTTagList;
public class ChunkFixerUtility {
// This will not change between runs, unless a mod is updated or added.
- public static final int POSTEA_UPDATE_CODE = getModListHash();
+ public static final int POSTEA_UPDATE_CODE = PosteaUtilities.getModListHash();
+
+ public static boolean hasChunkBeenUpdated(long chunkHash) {
+ // We are in a dev env.
+ if (POSTEA_UPDATE_CODE == -1) return false;
+ return chunkHash == POSTEA_UPDATE_CODE;
+ }
private static final int AIR_ID = 0;
- public static void transformNormalBlocks(Chunk chunk, ExtendedBlockStorage ebs, World world) {
+ public static void onChunkRead(Chunk chunk, World world, NBTTagCompound tag) {
+ IChunkMixin chunkMixin = (IChunkMixin) chunk;
+ chunkMixin.Postea$setPosteaCode(-1);
+ if (tag.hasKey("POSTEA", 4)) {
+ chunkMixin.Postea$setPosteaCode(tag.getLong("POSTEA"));
+ }
+ // This checks if the chunk has been run with the current POSTEA_UPDATE_CODE and skips it if so.
+ if (hasChunkBeenUpdated(chunkMixin.Postea$getPosteaCode())) return;
+ List conversionInfoList = adjustTileEntities(tag.getTagList("TileEntities", 10), world, chunk);
+
+ for (ExtendedBlockStorage ebs : chunk.getBlockStorageArray()) {
+ if (ebs == null) continue;
+ int sectionY = ebs.getYLocation();
+
+ List filteredList = conversionInfoList.stream()
+ .filter(info -> info.y >= sectionY && info.y < (sectionY + 16))
+ .collect(Collectors.toList());
+
+ for (ConversionInfo info : filteredList) {
+ int localX = info.x & 15;
+ int localY = info.y & 15;
+ int localZ = info.z & 15;
+ ebs.func_150818_a(localX, localY, localZ, info.blockInfo.block);
+ ebs.setExtBlockMetadata(localX, localY, localZ, info.blockInfo.metadata);
+ }
+
+ transformNormalBlocksInSubChunk(chunk, ebs, world);
+ }
+ chunkMixin.Postea$setPosteaCode(ChunkFixerUtility.POSTEA_UPDATE_CODE);
+ }
+
+ public static void onChunkLoaded(Chunk chunk) {
+ if (chunk instanceof IChunkMixin iChunkMixin) {
+ if (!hasChunkBeenUpdated(iChunkMixin.Postea$getPosteaCode())) {
+ iChunkMixin.Postea$setPosteaCode(ChunkFixerUtility.POSTEA_UPDATE_CODE);
+ chunk.setChunkModified();
+ }
+ }
+ }
+
+ public static void onChunkWrite(Chunk chunk, NBTTagCompound tag) {
+ if (chunk instanceof IChunkMixin iChunkMixin) {
+ tag.setLong("POSTEA", iChunkMixin.Postea$getPosteaCode());
+ }
+ }
+
+ public static void transformNormalBlocksInSubChunk(Chunk chunk, ExtendedBlockStorage ebs, World world) {
int chunkXPos = chunk.xPosition * 16;
int chunkZPos = chunk.zPosition * 16;
@@ -62,54 +112,15 @@ public class ChunkFixerUtility {
}
}
- public static void transformTileEntities(NBTTagCompound levelCompoundTag, Chunk chunk, World world) {
-
- Pair, NBTTagList> output = adjustTileEntities(
- levelCompoundTag.getTagList("TileEntities", 10),
- world,
- chunk);
- List conversionInfoList = output.first();
- NBTTagList tileEntities = output.second();
-
- if (tileEntities.tagCount() > 0) {
- levelCompoundTag.setTag("TileEntities", tileEntities);
- }
-
- for (ExtendedBlockStorage ebs : chunk.getBlockStorageArray()) {
- if (ebs == null) continue;
- processSection(ebs, conversionInfoList);
- }
- }
-
- private static void processSection(ExtendedBlockStorage ebs, List conversionInfoList) {
- int sectionY = ebs.getYLocation();
-
- List filteredList = conversionInfoList.stream()
- .filter(info -> info.y >= sectionY && info.y < (sectionY + 16))
- .collect(Collectors.toList());
-
- for (ConversionInfo info : filteredList) {
- int localX = info.x & 15;
- int localY = info.y & 15;
- int localZ = info.z & 15;
- ebs.func_150818_a(localX, localY, localZ, info.blockInfo.block);
- ebs.setExtBlockMetadata(localX, localY, localZ, info.blockInfo.metadata);
- }
- }
-
- private static Pair, NBTTagList> adjustTileEntities(NBTTagList tileEntities, World world,
- Chunk chunk) {
+ private static List adjustTileEntities(NBTTagList tileEntities, World world, Chunk chunk) {
List conversionInfo = new ArrayList<>();
- NBTTagList tileEntitiesCopy = new NBTTagList();
-
for (int i = 0; i < tileEntities.tagCount(); i++) {
NBTTagCompound tileEntity = tileEntities.getCompoundTagAt(i);
String tileEntityId = tileEntity.getString("id");
// Check if we have a transformer registered for this tile entity ID
- boolean found = false;
- for (TriFunction transformationFunction : TileEntityReplacementManager
+ for (TriFunction transformationFunction : TransformerRegistry
.getTileEntityToNormalBlockTransformerFunction(tileEntityId)) {
int x = tileEntity.getInteger("x");
@@ -119,21 +130,18 @@ public class ChunkFixerUtility {
BlockInfo blockInfo = transformationFunction.apply(tileEntity, world, chunk);
if (blockInfo == null) continue;
- if (blockInfo.tileTransformer != null) {
- tileEntitiesCopy.appendTag(blockInfo.tileTransformer.apply(tileEntity));
- } // Otherwise they are removed, therefore not appended.
+ if (blockInfo.tileTransformer == null) {
+ tileEntities.removeTag(i--);
+ } else {
+ ((IMixinNBTTagList) tileEntities)
+ .Postea$replaceCompoundTagAt(i, blockInfo.tileTransformer.apply(tileEntity));
+ }
conversionInfo.add(new ConversionInfo(x, y, z, blockInfo));
- found = true;
- break;
- }
- if (!found) {
- // Do nothing.
- tileEntitiesCopy.appendTag(tileEntity);
}
}
- return new Pair<>(conversionInfo, tileEntitiesCopy);
+ return conversionInfo;
}
private static class ConversionInfo {
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/IDRegistry.java b/src/main/java/com/gtnewhorizons/postea/utility/IDRegistry.java
new file mode 100644
index 0000000..666cfa0
--- /dev/null
+++ b/src/main/java/com/gtnewhorizons/postea/utility/IDRegistry.java
@@ -0,0 +1,133 @@
+package com.gtnewhorizons.postea.utility;
+
+import java.util.Map;
+import java.util.function.Consumer;
+
+import com.google.common.collect.LinkedHashMultimap;
+
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderState;
+import cpw.mods.fml.common.registry.GameData;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+
+/**
+ * A simple utility to resolve the IDs of any namepsaced ID that has ever been registered to an active world's id list.
+ */
+public abstract class IDRegistry {
+
+ // Part of a bi-map for lookups between block namespaced ids and numeric ids
+ private static final Object2IntOpenHashMap BLOCK_NAME_TO_ID = new Object2IntOpenHashMap<>();
+
+ // Part of a bi-map for lookups between item namespaced ids and numeric ids
+ private static final Object2IntOpenHashMap ITEM_NAME_TO_ID = new Object2IntOpenHashMap<>();
+
+ private static final LinkedHashMultimap> BLOCK_ID_RESOLVERS = LinkedHashMultimap.create();
+ private static final LinkedHashMultimap> ITEM_ID_RESOLVERS = LinkedHashMultimap.create();
+
+ /**
+ * Triggers all the callbacks registered by other mods that wish to identify a block that may no longer exist.
+ * These callbacks effectively remove the need for dummies, and should help improve performance at runtime.
+ */
+ public static void onMappingUpdated() {
+ // this event is fired on server startup and shutdown. On shutdown, we just need to clear the mappings to save
+ // some space memory we can just ignore adding stuff safely.
+ if (!Loader.instance()
+ .isInState(LoaderState.SERVER_ABOUT_TO_START)) return;
+ // we should be fine to execute those in parallel I think?
+ BLOCK_ID_RESOLVERS.asMap()
+ .entrySet()
+ .parallelStream()
+ .forEach(kv -> {
+ int id = getItemId(kv.getKey());
+ for (Consumer resolver : kv.getValue()) {
+ resolver.accept(id);
+ }
+ });
+ ITEM_ID_RESOLVERS.asMap()
+ .entrySet()
+ .parallelStream()
+ .forEach(kv -> {
+ int id = getItemId(kv.getKey());
+ for (Consumer resolver : kv.getValue()) {
+ resolver.accept(id);
+ }
+ });
+ }
+
+ /**
+ * Called by {@link com.gtnewhorizons.postea.mixins.preinit.MixinGameData}, this function is used to register all
+ * the previously registered namespaced to numeric id mappings that have ever been seen into a world.
+ *
+ * This function executes before the game starts remapping it's own internal IDs, so we can be sure that any
+ * existing will remain while the world is loaded.
+ */
+ public static void registerWorldSpecificIDs(Map map) {
+ BLOCK_NAME_TO_ID.clear();
+ ITEM_NAME_TO_ID.clear();
+ for (Map.Entry kv : map.entrySet()) {
+ String name = kv.getKey()
+ .substring(1);
+ int id = kv.getValue();
+ if (kv.getKey()
+ .charAt(0) == '\u0001') {
+ BLOCK_NAME_TO_ID.put(name, id);
+ } else {
+ ITEM_NAME_TO_ID.put(name, id);
+ }
+ }
+ }
+
+ /**
+ * Fetches the block numeric ID associated with the namespaced ID.
+ *
+ * @param name the namespaced id of the block.
+ * @return The ID of the block, or -1 if the namespaced ID has never been registered while the current world was
+ * loaded.
+ */
+ public static int getBlockId(String name) {
+ int id = BLOCK_NAME_TO_ID.getOrDefault(name, -1);
+ if (id < 0) {
+ id = GameData.getBlockRegistry()
+ .getId(name);
+ if (id >= 0) BLOCK_NAME_TO_ID.put(name, id);
+ }
+ return id;
+ }
+
+ /**
+ * Fetches the item numeric ID associated with the namespaced ID.
+ *
+ * @param name the namespaced id of the block.
+ * @return The ID of the block, or -1 if the namespaced ID has never been registered while the current world was
+ * loaded.
+ */
+ public static int getItemId(String name) {
+ int id = ITEM_NAME_TO_ID.getOrDefault(name, -1);
+ if (id < 0) {
+ id = GameData.getItemRegistry()
+ .getId(name);
+ if (id >= 0) ITEM_NAME_TO_ID.put(name, id);
+ }
+ return id;
+ }
+
+ /**
+ * Registers a callback used by mods to identify the numeric ID of a namespaced ID when a world is loaded.
+ *
+ * @param name The namespaced ID to resolve.
+ * @param resolver The callback to call just after forge adjusts the ID mappings to prevent collisions.
+ */
+ public static void registerBlockIDResolver(String name, Consumer resolver) {
+ BLOCK_ID_RESOLVERS.put(name, resolver);
+ }
+
+ /**
+ * Registers a callback used by mods to identify the numeric ID of a namespaced ID when a world is loaded.
+ *
+ * @param name The namespaced ID to resolve.
+ * @param resolver The callback to call just after forge adjusts the ID mappings to prevent collisions.
+ */
+ public static void registerItemIDResolver(String name, Consumer resolver) {
+ ITEM_ID_RESOLVERS.put(name, resolver);
+ }
+}
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/MissingMappingHandler.java b/src/main/java/com/gtnewhorizons/postea/utility/MissingMappingHandler.java
index 156d507..27aded2 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/MissingMappingHandler.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/MissingMappingHandler.java
@@ -1,116 +1,40 @@
package com.gtnewhorizons.postea.utility;
-import java.util.HashMap;
-import java.util.HashSet;
import java.util.Map;
import java.util.Set;
-import javax.annotation.Nullable;
-
import net.minecraft.block.Block;
-import net.minecraft.block.material.Material;
import net.minecraft.item.Item;
-import net.minecraft.item.ItemBlock;
-
-import com.gtnewhorizons.postea.Postea;
-import com.gtnewhorizons.postea.compat.Compat;
import cpw.mods.fml.common.event.FMLMissingMappingsEvent;
import cpw.mods.fml.common.registry.GameRegistry;
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
+/**
+ * A simple utility used to allow mods to register simple missing mapping migrations without having to set up a whole
+ * system themselves.
+ */
public abstract class MissingMappingHandler {
- enum MappingType {
- /** Tells the mapping logic to register an Item. */
- Item,
- /** Tells the mapping logic to register a Block (and ItemBlock). */
- Block
- }
-
- static class DummyMapping {
-
- /** The type of thing that should be registered for this dummy */
- public MappingType type;
- /** The id under which the dummy should be registered */
- public String registerAs;
- /** The full id of the dummy, including mod prefix */
- public String id;
-
- public DummyMapping(MappingType type, String registerAs, String id) {
- this.type = type;
- this.registerAs = registerAs;
- this.id = id;
- }
- }
-
- // because we're using reflection to quickly identify our stuff at runtime.
- public static class DummyBlock extends Block {
-
- public DummyBlock() {
- super(Material.ground);
- }
- }
-
- public static class DummyItem extends Item {
- }
-
- public static class DummyItemBlock extends ItemBlock {
-
- public DummyItemBlock(Block p_i45328_1_) {
- super(p_i45328_1_);
- }
- }
-
- private static final Set MISSING_IDS_TO_IGNORE = new HashSet<>();
- private static final HashMap MISSING_ITEM_MAPPINGS = new HashMap<>();
- private static final HashMap MISSING_BLOCK_MAPPINGS = new HashMap<>();
- private static final HashMap DUMMY_TARGET_TYPES = new HashMap<>();
- private static final HashMap DUMMY_ID_TO_ORIGINAL_ID_LOOKUP = new HashMap<>();
- private static final HashMap ORIGINAL_ID_TO_DUMMY_ID_LOOKUP = new HashMap<>();
-
- private static final IntOpenHashSet DUMMY_IDS = new IntOpenHashSet();
-
- private static final String DUMMY_ID_PREFIX_START = Postea.MODID + ":";
- private static final String DUMMY_ID_PREFIX_END = "d.";
- private static final String DUMMY_ID_PREFIX = DUMMY_ID_PREFIX_START + DUMMY_ID_PREFIX_END;
-
- public static void onLoadCompleted() {
- for (Map.Entry kv : DUMMY_TARGET_TYPES.entrySet()) {
- DummyMapping mapping = kv.getValue();
- String originalId = kv.getKey();
- // split the original id into parts to query for the original's existance.
- String[] splitId = splitItemId(originalId);
- if (splitId == null) continue;
- // ensure nothing else is registered under that id.
- if (GameRegistry.findBlock(splitId[0], splitId[1]) != null) continue;
- if (GameRegistry.findItem(splitId[0], splitId[1]) != null) continue;
- // remap if not found
- if (mapping.type == MappingType.Block) {
- // check if the block was since registered.
- Block dummy = new DummyBlock();
- GameRegistry.registerBlock(dummy, DummyItemBlock.class, mapping.registerAs);
- // register both for when we're remapping from ourselves to ourselves because something wasn't loaded
- // and transformed.
- MISSING_BLOCK_MAPPINGS.put(originalId, dummy);
- Compat.hideItemFromNEI(Item.getItemFromBlock(dummy));
- } else {
- Item dummy = new DummyItem();
- GameRegistry.registerItem(dummy, mapping.registerAs);
- MISSING_ITEM_MAPPINGS.put(originalId, dummy);
- Compat.hideItemFromNEI(dummy);
- }
- DUMMY_ID_TO_ORIGINAL_ID_LOOKUP.put(mapping.id, originalId);
- ORIGINAL_ID_TO_DUMMY_ID_LOOKUP.put(originalId, mapping.id);
- }
- // no longer needed free what ever used to be in there
- DUMMY_TARGET_TYPES.clear();
- }
+ /**
+ * A set of String IDs that can safely be ignored.
+ */
+ private static final Set MISSING_IDS_TO_IGNORE = new ObjectOpenHashSet<>();
+ /**
+ * A set of string IDs and items they should map to.
+ */
+ private static final Map MISSING_ITEM_MAPPINGS = new Object2ObjectOpenHashMap<>();
+ /**
+ * A set of string IDs and items they should map to.
+ */
+ private static final Map MISSING_BLOCK_MAPPINGS = new Object2ObjectOpenHashMap<>();
+ // region FML Life Cycle handlers
public static void onMissingMapping(FMLMissingMappingsEvent event) {
for (FMLMissingMappingsEvent.MissingMapping mapping : event.getAll()) {
// ignore things that can be ignored safely, and our own dummy items for when a handler is removed.
- if (MISSING_IDS_TO_IGNORE.contains(mapping.name) || mapping.name.startsWith(DUMMY_ID_PREFIX)) {
+ if (MISSING_IDS_TO_IGNORE.contains(mapping.name)) {
mapping.ignore();
continue;
}
@@ -135,70 +59,35 @@ public abstract class MissingMappingHandler {
}
}
}
+ // endregion FML Life Cycle handlers
- private static void onMappingAdded(String originalId, MappingType mappingType) {
- // split name into parts
- String[] splitId = splitItemId(originalId);
- if (splitId == null) return;
- // else register a fake item
- final String registerAs = DUMMY_ID_PREFIX_END + splitId[0] + "." + splitId[1];
- final String dummyFullId = DUMMY_ID_PREFIX_START + registerAs;
- if (mappingType == MappingType.Item) {
- DUMMY_TARGET_TYPES.putIfAbsent(originalId, new DummyMapping(mappingType, registerAs, dummyFullId));
- } else {
- DummyMapping existing = DUMMY_TARGET_TYPES.getOrDefault(originalId, null);
- if (existing != null) {
- existing.type = mappingType;
- } else {
- DUMMY_TARGET_TYPES.put(originalId, new DummyMapping(mappingType, registerAs, dummyFullId));
- }
- }
- }
-
- public static void addSimpleReplacement(String originalId, Item item) {
+ /**
+ * Adds a direct mapping for a missing item mapping.
+ *
+ * @param originalId The namespaced id of the missing item.
+ * @param item The item it should be replaced with.
+ */
+ public static void addItemMapping(String originalId, Item item) {
MISSING_ITEM_MAPPINGS.put(originalId, item);
}
- public static void addSimpleReplacement(String originalId, Block block) {
+ /**
+ * Adds a direct mapping for a missing block mapping.
+ *
+ * @param originalId The namespaced id of the missing block.
+ * @param block The block it should be replaced with.
+ */
+ public static void addBlockMapping(String originalId, Block block) {
MISSING_BLOCK_MAPPINGS.put(originalId, block);
}
+ /**
+ * Adds a notice that FML should silence any warning when loading a world telling the player that an ID
+ * is now missing.
+ *
+ * @param originalId The namespace ID to ignore.
+ */
public static void addIgnore(String originalId) {
MISSING_IDS_TO_IGNORE.add(originalId);
}
-
- public static void createDummyBlockIfNeeded(String originalId) {
- DummyMapping existing = DUMMY_TARGET_TYPES.get(originalId);
- // item mappings should be over-written
- if (existing != null && existing.type == MappingType.Block) return;
- onMappingAdded(originalId, MappingType.Block);
- }
-
- public static void createDummyItemIfNeeded(String originalId) {
- DummyMapping existing = DUMMY_TARGET_TYPES.get(originalId);
- if (existing != null) return;
- onMappingAdded(originalId, MappingType.Item);
- }
-
- public static String getOriginalIDIfIDIsDummyID(String originalId) {
- return DUMMY_ID_TO_ORIGINAL_ID_LOOKUP.getOrDefault(originalId, originalId);
- }
-
- public static String getDummyIdIfMissing(String originalId) {
- return ORIGINAL_ID_TO_DUMMY_ID_LOOKUP.getOrDefault(originalId, originalId);
- }
-
- private static @Nullable String[] splitItemId(String itemId) {
- int pos = itemId.indexOf(':');
- if (pos < 1) return null;
- return new String[] { itemId.substring(0, pos), itemId.substring(pos + 1) };
- }
-
- public static boolean isDummyItem(Item item) {
- return item instanceof DummyItem || item instanceof DummyItemBlock;
- }
-
- public static boolean isDummyBlock(Block block) {
- return block instanceof DummyBlock;
- }
}
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/PosteaUtilities.java b/src/main/java/com/gtnewhorizons/postea/utility/PosteaUtilities.java
index 967ff16..3ef532f 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/PosteaUtilities.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/PosteaUtilities.java
@@ -3,6 +3,7 @@ package com.gtnewhorizons.postea.utility;
import java.util.ArrayList;
import java.util.Collections;
+import net.minecraft.launchwrapper.Launch;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
@@ -30,6 +31,9 @@ public abstract class PosteaUtilities {
}
public static int getModListHash() {
+ // when in a dev env allow mutations to happen every time a chunk is loaded for testing purposes.
+ final Object deobfEnv = Launch.blackboard != null ? Launch.blackboard.get("fml.deobfuscatedEnvironment") : null;
+ if (deobfEnv != null && (boolean) deobfEnv) return -1;
// We iterate over every mod, get its version and put it into a giant list.
// This is done so we can see if our mods have actually changed, if so, we
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationMap.java b/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationMap.java
index ffcfebe..5f53f8e 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationMap.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationMap.java
@@ -10,55 +10,97 @@ import net.minecraftforge.oredict.OreDictionary;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
-public class SimpleTransformationMap {
+/**
+ * A simple mapping registry for quick access to simple transformations.
+ *
+ * It's essentially a 2 layer map.
+ * The first layer contains the namespaced ID of the thing that needs to be replaced.
+ * The second layer contains mappings for each meta/damage value of the namespaced ID.
+ *
+ * When registering something to the second/meta layer, Using {@link OreDictionary#WILDCARD_VALUE}
+ * will register a fallback for all meta/damage value of the namespaced ID.
+ *
+ * Here is an example of the typical structure of this map
+ *
+ *
+ * {@code
+ * ┌─ mod:name_one ─┬─ 1 -> {Stone, 0} : Transforms all mod:name_one with meta 1 into stone with meta 0
+ * │ └─ wildcard -> {Plank, Wildcard} : Transforms all other mod:name_one to planks of the same meta.
+ * │
+ * ├─ mod:name_two ─── 2 -> {Clay, 0} : transforms all mod:name_two with meta 2 to clay with meta 0
+ * │
+ * └─ mod:name_three ─┬─ 0 -> {Air, 0} : transforms all mod:name_three with meta 0 to air with meta 0
+ * ├─ 1 -> {Sand, 1} : transforms all mod:name_three with meta 1 to sand with meta 1
+ * └─ 5 -> {SandStone, Wildcard} : transforms all mod:name_three to sandstone with the same meta.
+ * }
+ *
+ *
+ * @param Either {@link net.minecraft.block.Block} or {@link net.minecraft.item.Item}
+ */
+class SimpleTransformationMap {
- private final Map> registry = new Object2ObjectOpenHashMap<>();
+ public static class Value {
+
+ /**
+ * The target block or item for the simple transformation
+ */
+ public final T target;
+ /**
+ * The target meta/damage value for the transformation.
+ * If the value is {@link OreDictionary#WILDCARD_VALUE}, It maintains the old meta/damage value.
+ */
+ public final short targetMeta;
+ /**
+ * The numeric id of the target block, updated during the FMLMappingUpdate event
+ */
+ public int targetRuntimeId;
+
+ public Value(T target, short targetMeta) {
+ this.target = target;
+ this.targetMeta = targetMeta;
+ this.targetRuntimeId = -1;
+ }
+ }
+
+ private final Map>> registry = new Object2ObjectOpenHashMap<>();
/**
* Puts a mapping in this registry.
*
- * @param originalId The original id of the item/block to replace.
- * @param originalMeta The metadata of the item/block to replace. OreDictionary.WILDCARD_VALUE can be used as a
- * wildcard.
+ * @param originalId The namespaced ID of the item or block to replace.
+ * @param originalMeta The meta or damage value of the item or block to replace.
+ * {@link OreDictionary#WILDCARD_VALUE} can be used as a wildcard/fallback value.
+ * When querying, the value will be replaced, which will
+ * be used when ever no other specific meta match is found.
*/
- public void put(String originalId, int originalMeta, T data) {
+ public void put(String originalId, int originalMeta, T target, short targetMeta) {
if (originalMeta == -1) originalMeta = OreDictionary.WILDCARD_VALUE;
this.registry.computeIfAbsent(originalId, k -> new Int2ObjectOpenHashMap<>())
- .put(originalMeta, data);
+ .put(originalMeta, new Value<>(target, targetMeta));
}
/**
- * Gets the mapping from the registry.
+ * Used to query sub-maps at runtime since we capture the relevant sub-map into the transformation handler that is
+ * registered for simple transformations. This allows us to not re-query the first layer of this map while
+ * performing simple transformations, which should hopefully increase performance.
*
- * @param id The id of the item/block to replace.
- * @param meta The meta of the item/block to replace.
- * @return The new id and meta for the item/block if found.
+ * @param subMap The sub-map to query.
+ * @param meta The meta/damage value of the block/item being transformed.
+ * @return The mapping if found, else null.
+ * @param The type of the sub-map,
*/
- public @Nullable T get(String id, int meta) {
- Map metaMap = this.registry.get(id);
- if (metaMap == null) return null;
- T mapping = metaMap.get(meta);
+ public static @Nullable Value getFromSubMap(Map> subMap, int meta) {
+ Value mapping = subMap.get(meta);
if (mapping != null) return mapping;
- return metaMap.get(OreDictionary.WILDCARD_VALUE);
- }
-
- public static @Nullable T getFromSubmap(Map metaMap, int meta) {
- T mapping = metaMap.get(meta);
- if (mapping != null) return mapping;
- return metaMap.get(OreDictionary.WILDCARD_VALUE);
+ return subMap.get(OreDictionary.WILDCARD_VALUE);
}
/**
- * @return the set of all registered item ids.
+ * Used to update runtime IDs during the MappingUpdate event.
+ *
+ * @return The set of all registered item ids
*/
- public Set keySet() {
- return this.registry.keySet();
- }
-
- /**
- * @return the set of all registered item ids.
- */
- public Set>> entrySet() {
+ public Set>>> entrySet() {
return this.registry.entrySet();
}
}
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationRegistry.java b/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationRegistry.java
index 9b4dc11..815546c 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationRegistry.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/SimpleTransformationRegistry.java
@@ -1,6 +1,8 @@
package com.gtnewhorizons.postea.utility;
import java.util.Map;
+import java.util.function.BiFunction;
+import java.util.function.Function;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
@@ -8,12 +10,8 @@ import net.minecraft.item.ItemBlock;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.oredict.OreDictionary;
-import org.apache.commons.lang3.tuple.Pair;
-
import com.gtnewhorizons.postea.api.IDExtenderCompat;
-import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
-
/**
* A registry for simple item and block transformations. A common use case is mod removal, replacements or deprecations.
* When replacing one mod with another in GTNH, we have to migrate most if not all the mod's items and this often means
@@ -30,49 +28,47 @@ public class SimpleTransformationRegistry {
/**
* Stores simple block transformations (eg: if old id is # with meta # then turn into item with id # with meta #.)
*/
- public static final SimpleTransformationMap> SIMPLE_BLOCK_TRANSFORMATION_MAP = new SimpleTransformationMap<>();
- public static final Object2IntOpenHashMap RUNTIME_BLOCK_ID_LOOKUP = new Object2IntOpenHashMap<>();
+ private static final SimpleTransformationMap SIMPLE_BLOCK_TRANSFORMATION_MAP = new SimpleTransformationMap<>();
/**
* Stores simple item transformations (eg: if old id is # with meta # then turn into item with id # with meta #.)
*/
- public static final SimpleTransformationMap> SIMPLE_ITEM_TRANSFORMATION_MAP = new SimpleTransformationMap<>();
- public static final Object2IntOpenHashMap- RUNTIME_ITEM_ID_LOOKUP = new Object2IntOpenHashMap<>();
+ private static final SimpleTransformationMap
- SIMPLE_ITEM_TRANSFORMATION_MAP = new SimpleTransformationMap<>();
// region FML Life Cycle handlers
/**
* Registers 1 handler per targeted ID to minimize the number of handlers. The meta-map is captured to reduce
- * the execution time of the handlers.
+ * the execution time of the handlers. This is done at the load completed to hopefully always register these
+ * handlers last, allowing all other user made transformers to execute first.
*/
public static void onLoadCompleted() {
// add handlers for simple block remaps
- for (Map.Entry>> kv : SIMPLE_BLOCK_TRANSFORMATION_MAP.entrySet()) {
- Map> subMap = kv.getValue();
- TransformerRegistry.addBlockTransformer(kv.getKey(), info -> simpleBlockTransformer(info, subMap));
+ for (Map.Entry>> kv : SIMPLE_BLOCK_TRANSFORMATION_MAP
+ .entrySet()) {
+ TransformerRegistry.addBlockTransformer(kv.getKey(), new SimpleBlockTransformationHandler(kv.getValue()));
}
// add handlers for simple item remaps
- for (Map.Entry>> kv : SIMPLE_ITEM_TRANSFORMATION_MAP.entrySet()) {
- Map> subMap = kv.getValue();
- TransformerRegistry
- .addStackTransformer(kv.getKey(), (originalId, tag) -> simpleItemStackTransformer(tag, subMap));
+ for (Map.Entry>> kv : SIMPLE_ITEM_TRANSFORMATION_MAP
+ .entrySet()) {
+ TransformerRegistry.addStackTransformer(kv.getKey(), new SimpleItemTransformationHandler(kv.getValue()));
}
}
/**
- * Pre-caches updated block and item IDs for any simple transformation to speed-up the handlers.
+ * Pre-caches updated block and item numeric IDs for any simple transformation to speed up the handlers.
*/
public static void onIdMappingsChanged() {
- RUNTIME_ITEM_ID_LOOKUP.clear();
- RUNTIME_BLOCK_ID_LOOKUP.clear();
- for (Map.Entry>> kv : SIMPLE_BLOCK_TRANSFORMATION_MAP.entrySet()) {
- for (Pair mapping : kv.getValue()
+ for (Map.Entry>> kv : SIMPLE_BLOCK_TRANSFORMATION_MAP
+ .entrySet()) {
+ for (SimpleTransformationMap.Value mapping : kv.getValue()
.values()) {
- RUNTIME_BLOCK_ID_LOOKUP.computeIfAbsent(mapping.getKey(), Block::getIdFromBlock);
+ mapping.targetRuntimeId = Block.getIdFromBlock(mapping.target);
}
}
- for (Map.Entry>> kv : SIMPLE_ITEM_TRANSFORMATION_MAP.entrySet()) {
- for (Pair
- mapping : kv.getValue()
+ for (Map.Entry>> kv : SIMPLE_ITEM_TRANSFORMATION_MAP
+ .entrySet()) {
+ for (SimpleTransformationMap.Value
- mapping : kv.getValue()
.values()) {
- RUNTIME_ITEM_ID_LOOKUP.computeIfAbsent(mapping.getKey(), Item::getIdFromItem);
+ mapping.targetRuntimeId = Item.getIdFromItem(mapping.target);
}
}
}
@@ -104,11 +100,11 @@ public class SimpleTransformationRegistry {
public static void addSimpleTransformer(String originalId, int originalMeta, Block newBlock, int newMeta,
boolean skipStackRemap) {
if (newMeta == -1) newMeta = OreDictionary.WILDCARD_VALUE;
- SIMPLE_BLOCK_TRANSFORMATION_MAP.put(originalId, originalMeta, Pair.of(newBlock, (short) newMeta));
+ SIMPLE_BLOCK_TRANSFORMATION_MAP.put(originalId, originalMeta, newBlock, (short) newMeta);
if (!skipStackRemap) {
Item item = Item.getItemFromBlock(newBlock);
if (item != null) {
- SIMPLE_ITEM_TRANSFORMATION_MAP.put(originalId, originalMeta, Pair.of(item, (short) newMeta));
+ SIMPLE_ITEM_TRANSFORMATION_MAP.put(originalId, originalMeta, item, (short) newMeta);
}
}
}
@@ -118,14 +114,25 @@ public class SimpleTransformationRegistry {
*
* @implNote This implementation has constant-time runtime.
*/
- private static boolean simpleBlockTransformer(BlockConversionInfo info, Map> metaMap) {
- Pair mapping = SimpleTransformationMap.getFromSubmap(metaMap, info.metadata);
- if (mapping == null) return false;
- info.blockID = RUNTIME_BLOCK_ID_LOOKUP.computeIfAbsent(mapping.getKey(), Block::getIdFromBlock);
- if (mapping.getValue() != OreDictionary.WILDCARD_VALUE) {
- info.metadata = mapping.getValue();
+ private static class SimpleBlockTransformationHandler implements Function {
+
+ private final Map> metaMap;
+
+ SimpleBlockTransformationHandler(Map> metaMap) {
+ this.metaMap = metaMap;
+ }
+
+ @Override
+ public Boolean apply(BlockConversionInfo info) {
+ SimpleTransformationMap.Value mapping = SimpleTransformationMap
+ .getFromSubMap(metaMap, info.metadata);
+ if (mapping == null || mapping.targetRuntimeId <= -1) return false;
+ info.blockID = mapping.targetRuntimeId;
+ if (mapping.targetMeta != OreDictionary.WILDCARD_VALUE) {
+ info.metadata = mapping.targetMeta;
+ }
+ return true;
}
- return true;
}
// endregion block transformations
@@ -159,9 +166,9 @@ public class SimpleTransformationRegistry {
boolean skipBlockRemap) {
if (newMeta == -1) newMeta = OreDictionary.WILDCARD_VALUE;
if (!skipBlockRemap && newItem instanceof ItemBlock ib) {
- SIMPLE_BLOCK_TRANSFORMATION_MAP.put(originalId, originalMeta, Pair.of(ib.field_150939_a, (short) newMeta));
+ SIMPLE_BLOCK_TRANSFORMATION_MAP.put(originalId, originalMeta, ib.field_150939_a, (short) newMeta);
}
- SIMPLE_ITEM_TRANSFORMATION_MAP.put(originalId, originalMeta, Pair.of(newItem, (short) newMeta));
+ SIMPLE_ITEM_TRANSFORMATION_MAP.put(originalId, originalMeta, newItem, (short) newMeta);
}
/**
@@ -169,16 +176,25 @@ public class SimpleTransformationRegistry {
*
* @implNote This implementation has constant-time runtime.
*/
- private static boolean simpleItemStackTransformer(NBTTagCompound tag, Map> metaMap) {
- short meta = tag.getShort("Damage");
- Pair
- mapping = SimpleTransformationMap.getFromSubmap(metaMap, meta);
- if (mapping == null) return false;
- IDExtenderCompat
- .setItemStackID(tag, RUNTIME_ITEM_ID_LOOKUP.computeIfAbsent(mapping.getKey(), Item::getIdFromItem));
- if (mapping.getValue() != OreDictionary.WILDCARD_VALUE) {
- tag.setShort("Damage", mapping.getValue());
+ private static class SimpleItemTransformationHandler implements BiFunction {
+
+ private final Map> metaMap;
+
+ SimpleItemTransformationHandler(Map> metaMap) {
+ this.metaMap = metaMap;
+ }
+
+ @Override
+ public Boolean apply(String originalId, NBTTagCompound tag) {
+ short meta = tag.getShort("Damage");
+ SimpleTransformationMap.Value
- mapping = SimpleTransformationMap.getFromSubMap(metaMap, meta);
+ if (mapping == null || mapping.targetRuntimeId <= -1) return false;
+ IDExtenderCompat.setItemStackID(tag, mapping.targetRuntimeId);
+ if (mapping.targetMeta != OreDictionary.WILDCARD_VALUE) {
+ tag.setShort("Damage", mapping.targetMeta);
+ }
+ return true;
}
- return true;
}
// endregion item transformations
}
diff --git a/src/main/java/com/gtnewhorizons/postea/utility/TransformerRegistry.java b/src/main/java/com/gtnewhorizons/postea/utility/TransformerRegistry.java
index 891cbdd..7b8c4be 100644
--- a/src/main/java/com/gtnewhorizons/postea/utility/TransformerRegistry.java
+++ b/src/main/java/com/gtnewhorizons/postea/utility/TransformerRegistry.java
@@ -1,23 +1,26 @@
package com.gtnewhorizons.postea.utility;
+import java.util.Collection;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
+import javax.annotation.Nonnull;
import javax.annotation.Nullable;
-import net.minecraft.block.Block;
-import net.minecraft.item.Item;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
import org.apache.commons.lang3.tuple.Pair;
import com.google.common.collect.LinkedListMultimap;
import com.gtnewhorizons.postea.api.IDExtenderCompat;
+import com.gtnewhorizons.postea.api.TriFunction;
+import cpw.mods.fml.common.Loader;
+import cpw.mods.fml.common.LoaderState;
import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
/**
* A registry for all transformer functions
@@ -28,7 +31,8 @@ public class TransformerRegistry {
.create();
public static final LinkedListMultimap> BLOCK_REPLACEMENT_MAP = LinkedListMultimap
.create();
-
+ private static final LinkedListMultimap> TILE_ENTITY_REPLACEMENT_MAP = LinkedListMultimap
+ .create();
/**
* Map of itemID -> originalName+transformationHandler.
* Pivoting on the id is faster than pivoting on the strings so this should help with perf a bit.
@@ -41,11 +45,40 @@ public class TransformerRegistry {
* Generated during the mapping update event whilst entering/loading a world.
*/
private static final Int2ObjectOpenHashMap>>> RUNTIME_BLOCK_REPLACEMENT_MAP = new Int2ObjectOpenHashMap<>();
+
+ // region FML Life Cycle handlers
/**
- * List of ids used by dummy items and blocks generated by Postea.
- * Generated during the mapping update event whilst entering/loading a world.
+ * When FML loads a world, it remaps certain IDs if the IDs it registered during the load period do not match the
+ * IDs that were previously registered when the world was last loaded.
+ *
+ * We use this opportunity to fetch the "world specific" IDs of all the blocks and items that have a
+ * transformation registered to them so we can pivot using the numeric IDs when we're doing replacements.
+ *
+ * This is because pivoting on the numeric ids is significantly faster than pivoting on string or object hashes.
*/
- public static final IntOpenHashSet DUMMY_IDS = new IntOpenHashSet();
+ public static void onIdMappingsChanged() {
+ RUNTIME_BLOCK_REPLACEMENT_MAP.clear();
+ RUNTIME_ITEM_REPLACEMENT_MAP.clear();
+ // this event is fired on server startup and shutdown. On shutdown, we just need to clear the mappings to save
+ // some space memory we can just ignore adding stuff safely.
+ if (!Loader.instance()
+ .isInState(LoaderState.SERVER_ABOUT_TO_START)) return;
+ // create a lookup for source block ids.
+ for (String key : BLOCK_REPLACEMENT_MAP.keys()) {
+ int id = IDRegistry.getBlockId(key);
+ if (id >= 0) {
+ RUNTIME_BLOCK_REPLACEMENT_MAP.put(id, Pair.of(key, BLOCK_REPLACEMENT_MAP.get(key)));
+ }
+ }
+ // create a lookup for source block ids.
+ for (String key : ITEM_REPLACEMENT_MAP.keys()) {
+ int id = IDRegistry.getItemId(key);
+ if (id >= 0) {
+ RUNTIME_ITEM_REPLACEMENT_MAP.put(id, Pair.of(key, ITEM_REPLACEMENT_MAP.get(key)));
+ }
+ }
+ }
+ // endregion FML Life Cycle handlers
/**
* Registers a block transformation handler function for the given id.
@@ -60,8 +93,8 @@ public class TransformerRegistry {
* @param originalId The namespaced id of the block to transform.
* @param transformer The transformation handler that will execute a transformation on the block.
*/
- public static void addBlockTransformer(String originalId, Function transformer) {
- MissingMappingHandler.createDummyBlockIfNeeded(originalId);
+ public static void addBlockTransformer(@Nonnull String originalId,
+ @Nonnull Function transformer) {
BLOCK_REPLACEMENT_MAP.put(originalId, transformer);
}
@@ -78,50 +111,30 @@ public class TransformerRegistry {
* @param originalId The namespaced id of the block to transform.
* @param transformer The transformation handler that will execute a transformation on the block.
*/
- public static void addStackTransformer(String originalId, BiFunction transformer) {
- MissingMappingHandler.createDummyItemIfNeeded(originalId);
+ public static void addStackTransformer(@Nonnull String originalId,
+ @Nonnull BiFunction transformer) {
ITEM_REPLACEMENT_MAP.put(originalId, transformer);
}
- // region FML Life Cycle handlers
- public static void onIdMappingsChanged() {
- DUMMY_IDS.clear();
- RUNTIME_BLOCK_REPLACEMENT_MAP.clear();
- RUNTIME_ITEM_REPLACEMENT_MAP.clear();
- // create a lookup for source block ids.
- for (String key : BLOCK_REPLACEMENT_MAP.keys()) {
- String name = MissingMappingHandler.getDummyIdIfMissing(key);
- if (Block.blockRegistry.getObject(name) instanceof Block block) {
- int id = Block.getIdFromBlock(block);
- RUNTIME_BLOCK_REPLACEMENT_MAP.put(id, Pair.of(key, BLOCK_REPLACEMENT_MAP.get(key)));
- // not using .equals() on purpose, I'm looking for instance, not content equality
- if (key != name) DUMMY_IDS.add(id);
- }
- }
- // create a lookup for source block ids.
- for (String key : ITEM_REPLACEMENT_MAP.keys()) {
- String name = MissingMappingHandler.getDummyIdIfMissing(key);
- if (Item.itemRegistry.getObject(name) instanceof Item item) {
- int id = Item.getIdFromItem(item);
- RUNTIME_ITEM_REPLACEMENT_MAP.put(id, Pair.of(key, ITEM_REPLACEMENT_MAP.get(key)));
- // not using .equals() on purpose, I'm looking for instance, not content equality
- if (key != name) DUMMY_IDS.add(id);
- }
- }
+ /**
+ * Registers an item transformation handler function for the given id.
+ *
+ * @implNote It doesn't matter if the id doesn't belong to an existing item, a dummy item will be created when
+ * Postea detects that the id isn't associated to an item during the FMLLoadCompleted event. Dependent
+ * mods don't need to worry about this as transformation handlers are given the original id associated
+ * with the nbt they are provided when the handler is executed. When Postea runs a transformation on a
+ * dummy item and no handler returns true, Postea will automatically invalidate the stack by removing
+ * its id and idExt fields.
+ *
+ * @param originalId The namespaced id of the block to transform.
+ * @param transformer The transformation handler that will execute a transformation on the block.
+ */
+ public static void addTileEntityTransformer(@Nonnull String originalId,
+ @Nonnull TriFunction transformer) {
+ TILE_ENTITY_REPLACEMENT_MAP.put(originalId, transformer);
}
- public static void onServerStopping() {
- RUNTIME_BLOCK_REPLACEMENT_MAP.clear();
- RUNTIME_ITEM_REPLACEMENT_MAP.clear();
- DUMMY_IDS.clear();
- }
- // endregion FML Life Cycle handlers
-
// region transformation handlers
- public static boolean isDummyId(int id) {
- return TransformerRegistry.DUMMY_IDS.contains(id);
- }
-
public static @Nullable BlockConversionInfo getBlockReplacement(int blockId, byte metadata, World world, int x,
int y, int z) {
Pair>> data = RUNTIME_BLOCK_REPLACEMENT_MAP.get(blockId);
@@ -137,19 +150,9 @@ public class TransformerRegistry {
world);
for (Function transformer : data.getValue()) {
if (transformer.apply(blockConversionInfo)) {
- // Not sure if we want to keep this around since this would affect perf a bit, good for debugging
- // though.
- // if (DUMMY_IDS.contains(result.blockID)) FMLLog.warning("returned a success on a non-transformed
- // block!");
return blockConversionInfo;
}
}
- // if we're transforming a dummy block from a missing mapping and it wasn't handled, delete the block.
- if (TransformerRegistry.isDummyId(blockId)) {
- blockConversionInfo.blockID = 0;
- blockConversionInfo.metadata = 0;
- return blockConversionInfo;
- }
return null;
}
@@ -160,24 +163,20 @@ public class TransformerRegistry {
int id = IDExtenderCompat.getItemStackID(tag);
Pair>> data = RUNTIME_ITEM_REPLACEMENT_MAP.get(id);
// abort early if handler not found
- if (data == null || data.getValue()
- .isEmpty()) return;
-
- // apply handlers
- for (BiFunction transformer : data.getValue()) {
- if (transformer.apply(data.getKey(), tag)) {
- // Not sure if we want to keep this around since this would affect perf a bit, good for debugging
- // though.
- // if (DUMMY_IDS.contains(IDExtenderCompat.getItemStackID(tag))) FMLLog.warning("returned a success on a
- // non-transformed block!");
- return;
+ if (data != null && !data.getValue()
+ .isEmpty()) {
+ // apply handlers
+ for (BiFunction transformer : data.getValue()) {
+ if (transformer.apply(data.getKey(), tag)) {
+ return;
+ }
}
}
- // if no handler overwrote anything on this stack, and it's a dummy, delete the stack.
- if (TransformerRegistry.isDummyId(id)) {
- tag.removeTag("id");
- tag.removeTag("idExt");
- }
+ }
+
+ public static Collection> getTileEntityToNormalBlockTransformerFunction(
+ String tileEntityId) {
+ return TILE_ENTITY_REPLACEMENT_MAP.get(tileEntityId);
}
// endregion transformation handlers
}
diff --git a/src/main/resources/mixins.postea.early.json b/src/main/resources/mixins.postea.early.json
index f6b26a8..55ec0ee 100644
--- a/src/main/resources/mixins.postea.early.json
+++ b/src/main/resources/mixins.postea.early.json
@@ -8,7 +8,8 @@
"mixins": [
"MixinAnvilChunkLoader",
"MixinChunk",
- "MixinItemStack"
+ "MixinItemStack",
+ "MixinNBTTagList"
],
"client": [],
"server": []
diff --git a/src/main/resources/mixins.postea.json b/src/main/resources/mixins.postea.json
index 3b643c4..f3e0bf0 100644
--- a/src/main/resources/mixins.postea.json
+++ b/src/main/resources/mixins.postea.json
@@ -1,8 +1,10 @@
{
"required": true,
"minVersion": "0.8.5-GTNH",
+ "package": "com.gtnewhorizons.postea.mixins.preinit",
+ "plugin": "com.gtnewhorizons.postea.mixins.PosteaPreInitLoadingPlugin",
"refmap": "mixins.postea.refmap.json",
- "target": "@env(DEFAULT)",
+ "target": "@env(PREINIT)",
"compatibilityLevel": "JAVA_8",
"mixins": [],
"client": [],