capability, IItemHandler instance, Direction side, Tag base) {
+ if (!(instance instanceof IItemHandlerModifiable)) {
+ throw new RuntimeException("IItemHandler instance does not implement IItemHandlerModifiable");
+ }
+
+ IItemHandlerModifiable itemHandlerModifiable = (IItemHandlerModifiable) instance;
+ ListTag tagList = (ListTag) base;
+
+ for (int i = 0; i < tagList.size(); i++) {
+ CompoundTag itemTags = tagList.getCompound(i);
+ int j = itemTags.getInt("Slot");
+
+ if (j >= 0 && j < instance.getSlots()) {
+ itemHandlerModifiable.setStackInSlot(j, ItemStack.fromTag(itemTags));
+ }
+ }
+ }
+ }, ItemStackHandler::new);
+ }
+}
diff --git a/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandler.java b/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandler.java
new file mode 100644
index 00000000..23851bb9
--- /dev/null
+++ b/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandler.java
@@ -0,0 +1,112 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.items;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.inventory.Inventory;
+import net.minecraft.item.ItemStack;
+
+public interface IItemHandler {
+ /**
+ * Returns the number of slots available.
+ *
+ * @return The number of slots available
+ */
+ int getSlots();
+
+ /**
+ * Returns the ItemStack in a given slot.
+ *
+ * The result's stack size may be greater than the itemstack's max size.
+ *
+ *
If the result is empty, then the slot is empty.
+ *
+ *
IMPORTANT: This ItemStack MUST NOT be modified. This method is not for
+ * altering an inventory's contents. Any implementers who are able to detect
+ * modification through this method should throw an exception.
+ *
+ *
SERIOUSLY: DO NOT MODIFY THE RETURNED ITEMSTACK
+ *
+ * @param slot Slot to query
+ * @return ItemStack in given slot. Empty Itemstack if the slot is empty.
+ */
+ @Nonnull
+ ItemStack getStackInSlot(int slot);
+
+ /**
+ *
Inserts an ItemStack into the given slot and return the remainder.
+ * The ItemStack should not be modified in this function!
+ *
+ * Note: This behaviour is subtly different from net.minecraftforge.fluids.capability.IFluidHandler#fill(net.minecraftforge.fluids.FluidStack, boolean)
+ *
+ * @param slot Slot to insert into.
+ * @param stack ItemStack to insert. This must not be modified by the item handler.
+ * @param simulate If true, the insertion is only simulated
+ * @return The remaining ItemStack that was not inserted (if the entire stack is accepted, then return an empty ItemStack).
+ * May be the same as the input ItemStack if unchanged, otherwise a new ItemStack.
+ * The returned ItemStack can be safely modified after.
+ */
+ @Nonnull
+ ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate);
+
+ /**
+ * Extracts an ItemStack from the given slot.
+ * The returned value must be empty if nothing is extracted,
+ * otherwise its stack size must be less than or equal to {@code amount} and {@link ItemStack#getMaxCount()} ()}.
+ *
+ *
+ * @param slot Slot to extract from.
+ * @param amount Amount to extract (may be greater than the current stack's max limit)
+ * @param simulate If true, the extraction is only simulated
+ * @return ItemStack extracted from the slot, must be empty if nothing can be extracted.
+ * The returned ItemStack can be safely modified after, so item handlers should return a new or copied stack.
+ */
+ @Nonnull
+ ItemStack extractItem(int slot, int amount, boolean simulate);
+
+ /**
+ * Retrieves the maximum stack size allowed to exist in the given slot.
+ *
+ * @param slot Slot to query.
+ * @return The maximum stack size allowed in the slot.
+ */
+ int getSlotLimit(int slot);
+
+ /**
+ * This function re-implements the vanilla function {@link Inventory#isValidInvStack(int, ItemStack)}.
+ * It should be used instead of simulated insertions in cases where the contents and state of the inventory are
+ * irrelevant, mainly for the purpose of automation and logic (for instance, testing if a minecart can wait
+ * to deposit its items into a full inventory, or if the items in the minecart can never be placed into the
+ * inventory and should move on).
+ *
+ *
+ * - isItemValid is false when insertion of the item is never valid.
+ * - When isItemValid is true, no assumptions can be made and insertion must be simulated case-by-case.
+ * - The actual items in the inventory, its fullness, or any other state are not considered by isItemValid.
+ *
+ *
+ * @param slot Slot to query for validity
+ * @param stack Stack to test with for validity
+ * @return true if the slot can insert the ItemStack, not considering the current state of the inventory.
+ * false if the slot can never insert the ItemStack in any situation.
+ */
+ boolean isItemValid(int slot, @Nonnull ItemStack stack);
+}
diff --git a/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandlerModifiable.java b/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandlerModifiable.java
new file mode 100644
index 00000000..e24731cc
--- /dev/null
+++ b/patchwork-items/src/main/java/net/minecraftforge/items/IItemHandlerModifiable.java
@@ -0,0 +1,39 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.items;
+
+import javax.annotation.Nonnull;
+
+import net.minecraft.item.ItemStack;
+
+public interface IItemHandlerModifiable extends IItemHandler {
+ /**
+ * Overrides the stack in the given slot. This method is used by the
+ * standard Forge helper methods and classes. It is not intended for
+ * general use by other mods, and the handler may throw an error if it
+ * is called unexpectedly.
+ *
+ * @param slot Slot to modify
+ * @param stack ItemStack to set slot to (may be empty).
+ * @throws RuntimeException if the handler is called in a way that the handler
+ * was not expecting.
+ */
+ void setStackInSlot(int slot, @Nonnull ItemStack stack);
+}
diff --git a/patchwork-items/src/main/java/net/minecraftforge/items/ItemHandlerHelper.java b/patchwork-items/src/main/java/net/minecraftforge/items/ItemHandlerHelper.java
new file mode 100644
index 00000000..9fc6ed38
--- /dev/null
+++ b/patchwork-items/src/main/java/net/minecraftforge/items/ItemHandlerHelper.java
@@ -0,0 +1,219 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.items;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.MathHelper;
+
+import net.patchworkmc.impl.capability.CapabilityProviderHolder;
+
+public class ItemHandlerHelper {
+ private static boolean patchwork$areItemStackCapsCompatible(ItemStack a, ItemStack b) {
+ return ((CapabilityProviderHolder) (Object) a).areCapsCompatible(((CapabilityProviderHolder) (Object) b).getCapabilityProvider());
+ }
+
+ @Nonnull
+ public static ItemStack insertItem(IItemHandler dest, @Nonnull ItemStack stack, boolean simulate) {
+ if (dest == null || stack.isEmpty()) {
+ return stack;
+ }
+
+ for (int i = 0; i < dest.getSlots(); i++) {
+ stack = dest.insertItem(i, stack, simulate);
+
+ if (stack.isEmpty()) {
+ return ItemStack.EMPTY;
+ }
+ }
+
+ return stack;
+ }
+
+ public static boolean canItemStacksStack(@Nonnull ItemStack a, @Nonnull ItemStack b) {
+ if (a.isEmpty() || !a.isItemEqualIgnoreDamage(b) || a.hasTag() != b.hasTag()) {
+ return false;
+ }
+
+ return (!a.hasTag() || a.getTag().equals(b.getTag())) && patchwork$areItemStackCapsCompatible(a, b);
+ }
+
+ /**
+ * A relaxed version of canItemStacksStack that stacks itemstacks with different metadata if they don't have subtypes.
+ * This usually only applies when players pick up items.
+ */
+ public static boolean canItemStacksStackRelaxed(@Nonnull ItemStack a, @Nonnull ItemStack b) {
+ if (a.isEmpty() || b.isEmpty() || a.getItem() != b.getItem()) {
+ return false;
+ }
+
+ if (!a.isStackable()) {
+ return false;
+ }
+
+ if (a.hasTag() != b.hasTag()) {
+ return false;
+ }
+
+ return (!a.hasTag() || a.getTag().equals(b.getTag())) && patchwork$areItemStackCapsCompatible(a, b);
+ }
+
+ @Nonnull
+ public static ItemStack copyStackWithSize(@Nonnull ItemStack itemStack, int size) {
+ if (size == 0) {
+ return ItemStack.EMPTY;
+ }
+
+ ItemStack copy = itemStack.copy();
+ copy.setCount(size);
+ return copy;
+ }
+
+ /**
+ * Inserts the ItemStack into the inventory, filling up already present stacks first.
+ * This is equivalent to the behaviour of a player picking up an item.
+ * Note: This function stacks items without subtypes with different metadata together.
+ */
+ @Nonnull
+ public static ItemStack insertItemStacked(IItemHandler inventory, @Nonnull ItemStack stack, boolean simulate) {
+ if (inventory == null || stack.isEmpty()) {
+ return stack;
+ }
+
+ // not stackable -> just insert into a new slot
+ if (!stack.isStackable()) {
+ return insertItem(inventory, stack, simulate);
+ }
+
+ int sizeInventory = inventory.getSlots();
+
+ // go through the inventory and try to fill up already existing items
+ for (int i = 0; i < sizeInventory; i++) {
+ ItemStack slot = inventory.getStackInSlot(i);
+
+ if (canItemStacksStackRelaxed(slot, stack)) {
+ stack = inventory.insertItem(i, stack, simulate);
+
+ if (stack.isEmpty()) {
+ break;
+ }
+ }
+ }
+
+ // insert remainder into empty slots
+ if (!stack.isEmpty()) {
+ // find empty slot
+ for (int i = 0; i < sizeInventory; i++) {
+ if (inventory.getStackInSlot(i).isEmpty()) {
+ stack = inventory.insertItem(i, stack, simulate);
+
+ if (stack.isEmpty()) {
+ break;
+ }
+ }
+ }
+ }
+
+ return stack;
+ }
+
+ /**
+ * giveItemToPlayer without preferred slot
+ */
+
+ /* TODO: PlayerMainInvWrapper
+ public static void giveItemToPlayer(PlayerEntity player, @Nonnull ItemStack stack) {
+ giveItemToPlayer(player, stack, -1);
+ }*/
+
+ /**
+ * Inserts the given itemstack into the players inventory.
+ * If the inventory can't hold it, the item will be dropped in the world at the players position.
+ *
+ * @param player The player to give the item to
+ * @param stack The itemstack to insert
+ */
+
+ /* TODO: PlayerMainInvWrapper
+ public static void giveItemToPlayer(PlayerEntity player, @Nonnull ItemStack stack, int preferredSlot) {
+ if (stack.isEmpty()) return;
+
+ IItemHandler inventory = new PlayerMainInvWrapper(player.inventory);
+ World world = player.world;
+
+ // try adding it into the inventory
+ ItemStack remainder = stack;
+
+ // insert into preferred slot first
+ if (preferredSlot >= 0 && preferredSlot < inventory.getSlots()) {
+ remainder = inventory.insertItem(preferredSlot, stack, false);
+ }
+
+ // then into the inventory in general
+ if (!remainder.isEmpty()) {
+ remainder = insertItemStacked(inventory, remainder, false);
+ }
+
+ // play sound if something got picked up
+ if (remainder.isEmpty() || remainder.getCount() != stack.getCount()) {
+ world.playSound(null, player.x, player.y + 0.5, player.z,
+ SoundEvents.ENTITY_ITEM_PICKUP, SoundCategory.PLAYERS, 0.2F, ((world.random.nextFloat() - world.random.nextFloat()) * 0.7F + 1.0F) * 2.0F);
+ }
+
+ // drop remaining itemstack into the world
+ if (!remainder.isEmpty() && !world.isClient) {
+ ItemEntity entityitem = new ItemEntity(world, player.x, player.y + 0.5, player.z, remainder);
+ entityitem.setPickupDelay(40);
+ entityitem.setVelocity(entityitem.getVelocity().multiply(0, 1, 0));
+
+ world.spawnEntity(entityitem);
+ }
+ }*/
+
+ /**
+ * This method uses the standard vanilla algorithm to calculate a comparator output for how "full" the inventory is.
+ * This method is an adaptation of Container#calculateComparatorOutput(Inventory).
+ *
+ * @param inv The inventory handler to test.
+ * @return A redstone value in the range [0,15] representing how "full" this inventory is.
+ */
+ public static int calcRedstoneFromInventory(@Nullable IItemHandler inv) {
+ if (inv == null) {
+ return 0;
+ } else {
+ int itemsFound = 0;
+ float proportion = 0.0F;
+
+ for (int j = 0; j < inv.getSlots(); ++j) {
+ ItemStack itemstack = inv.getStackInSlot(j);
+
+ if (!itemstack.isEmpty()) {
+ proportion += (float) itemstack.getCount() / (float) Math.min(inv.getSlotLimit(j), itemstack.getMaxCount());
+ ++itemsFound;
+ }
+ }
+
+ proportion = proportion / (float) inv.getSlots();
+ return MathHelper.floor(proportion * 14.0F) + (itemsFound > 0 ? 1 : 0);
+ }
+ }
+}
diff --git a/patchwork-items/src/main/java/net/minecraftforge/items/ItemStackHandler.java b/patchwork-items/src/main/java/net/minecraftforge/items/ItemStackHandler.java
new file mode 100644
index 00000000..064ec704
--- /dev/null
+++ b/patchwork-items/src/main/java/net/minecraftforge/items/ItemStackHandler.java
@@ -0,0 +1,210 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.items;
+
+import javax.annotation.Nonnull;
+
+import net.minecraftforge.common.util.INBTSerializable;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.util.DefaultedList;
+
+import net.fabricmc.fabric.api.util.NbtType;
+
+public class ItemStackHandler implements IItemHandler, IItemHandlerModifiable, INBTSerializable {
+ protected DefaultedList stacks;
+
+ public ItemStackHandler() {
+ this(1);
+ }
+
+ public ItemStackHandler(int size) {
+ stacks = DefaultedList.ofSize(size, ItemStack.EMPTY);
+ }
+
+ public ItemStackHandler(DefaultedList stacks) {
+ this.stacks = stacks;
+ }
+
+ public void setSize(int size) {
+ stacks = DefaultedList.ofSize(size, ItemStack.EMPTY);
+ }
+
+ @Override
+ public void setStackInSlot(int slot, @Nonnull ItemStack stack) {
+ validateSlotIndex(slot);
+ this.stacks.set(slot, stack);
+ onContentsChanged(slot);
+ }
+
+ @Override
+ public int getSlots() {
+ return stacks.size();
+ }
+
+ @Override
+ @Nonnull
+ public ItemStack getStackInSlot(int slot) {
+ validateSlotIndex(slot);
+ return this.stacks.get(slot);
+ }
+
+ @Override
+ @Nonnull
+ public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) {
+ if (stack.isEmpty()) {
+ return ItemStack.EMPTY;
+ }
+
+ if (!isItemValid(slot, stack)) {
+ return stack;
+ }
+
+ validateSlotIndex(slot);
+
+ ItemStack existing = this.stacks.get(slot);
+
+ int limit = getStackLimit(slot, stack);
+
+ if (!existing.isEmpty()) {
+ if (!ItemHandlerHelper.canItemStacksStack(stack, existing)) {
+ return stack;
+ }
+
+ limit -= existing.getCount();
+ }
+
+ if (limit <= 0) {
+ return stack;
+ }
+
+ boolean reachedLimit = stack.getCount() > limit;
+
+ if (!simulate) {
+ if (existing.isEmpty()) {
+ this.stacks.set(slot, reachedLimit ? ItemHandlerHelper.copyStackWithSize(stack, limit) : stack);
+ } else {
+ existing.increment(reachedLimit ? limit : stack.getCount());
+ }
+
+ onContentsChanged(slot);
+ }
+
+ return reachedLimit ? ItemHandlerHelper.copyStackWithSize(stack, stack.getCount() - limit) : ItemStack.EMPTY;
+ }
+
+ @Override
+ @Nonnull
+ public ItemStack extractItem(int slot, int amount, boolean simulate) {
+ if (amount == 0) {
+ return ItemStack.EMPTY;
+ }
+
+ validateSlotIndex(slot);
+
+ ItemStack existing = this.stacks.get(slot);
+
+ if (existing.isEmpty()) {
+ return ItemStack.EMPTY;
+ }
+
+ int toExtract = Math.min(amount, existing.getMaxCount());
+
+ if (existing.getCount() <= toExtract) {
+ if (!simulate) {
+ this.stacks.set(slot, ItemStack.EMPTY);
+ onContentsChanged(slot);
+ }
+
+ return existing;
+ } else {
+ if (!simulate) {
+ this.stacks.set(slot, ItemHandlerHelper.copyStackWithSize(existing, existing.getCount() - toExtract));
+ onContentsChanged(slot);
+ }
+
+ return ItemHandlerHelper.copyStackWithSize(existing, toExtract);
+ }
+ }
+
+ @Override
+ public int getSlotLimit(int slot) {
+ return 64;
+ }
+
+ protected int getStackLimit(int slot, @Nonnull ItemStack stack) {
+ return Math.min(getSlotLimit(slot), stack.getMaxCount());
+ }
+
+ @Override
+ public boolean isItemValid(int slot, @Nonnull ItemStack stack) {
+ return true;
+ }
+
+ @Override
+ public CompoundTag serializeNBT() {
+ ListTag nbtTagList = new ListTag();
+
+ for (int i = 0; i < stacks.size(); i++) {
+ if (!stacks.get(i).isEmpty()) {
+ CompoundTag itemTag = new CompoundTag();
+ itemTag.putInt("Slot", i);
+ stacks.get(i).toTag(itemTag);
+ nbtTagList.add(itemTag);
+ }
+ }
+
+ CompoundTag nbt = new CompoundTag();
+ nbt.put("Items", nbtTagList);
+ nbt.putInt("Size", stacks.size());
+ return nbt;
+ }
+
+ @Override
+ public void deserializeNBT(CompoundTag nbt) {
+ setSize(nbt.contains("Size", NbtType.INT) ? nbt.getInt("Size") : stacks.size());
+ ListTag tagList = nbt.getList("Items", NbtType.COMPOUND);
+
+ for (int i = 0; i < tagList.size(); i++) {
+ CompoundTag itemTags = tagList.getCompound(i);
+ int slot = itemTags.getInt("Slot");
+
+ if (slot >= 0 && slot < stacks.size()) {
+ stacks.set(slot, ItemStack.fromTag(itemTags));
+ }
+ }
+
+ onLoad();
+ }
+
+ protected void validateSlotIndex(int slot) {
+ if (slot < 0 || slot >= stacks.size()) {
+ throw new RuntimeException("Slot " + slot + " not in valid range - [0," + stacks.size() + ")");
+ }
+ }
+
+ protected void onLoad() {
+ }
+
+ protected void onContentsChanged(int slot) {
+ }
+}
diff --git a/patchwork-items/src/main/java/net/patchworkmc/impl/items/ItemHandlerInventoryWrapper.java b/patchwork-items/src/main/java/net/patchworkmc/impl/items/ItemHandlerInventoryWrapper.java
new file mode 100644
index 00000000..219899e3
--- /dev/null
+++ b/patchwork-items/src/main/java/net/patchworkmc/impl/items/ItemHandlerInventoryWrapper.java
@@ -0,0 +1,92 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.items;
+
+import net.minecraftforge.items.IItemHandlerModifiable;
+
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.inventory.Inventory;
+import net.minecraft.item.ItemStack;
+
+public class ItemHandlerInventoryWrapper implements Inventory {
+ private IItemHandlerModifiable itemHandler;
+
+ public ItemHandlerInventoryWrapper(IItemHandlerModifiable itemHandler) {
+ this.itemHandler = itemHandler;
+ }
+
+ @Override
+ public int getInvSize() {
+ return itemHandler.getSlots();
+ }
+
+ @Override
+ public boolean isInvEmpty() {
+ for (int i = 0; i < itemHandler.getSlots(); i++) {
+ if (!itemHandler.getStackInSlot(i).isEmpty()) {
+ return false;
+ }
+ }
+
+ return true;
+ }
+
+ @Override
+ public ItemStack getInvStack(int slot) {
+ return itemHandler.getStackInSlot(slot);
+ }
+
+ @Override
+ public ItemStack takeInvStack(int slot, int amount) {
+ return itemHandler.extractItem(slot, amount, false);
+ }
+
+ @Override
+ public ItemStack removeInvStack(int slot) {
+ ItemStack copy = itemHandler.getStackInSlot(slot).copy();
+ itemHandler.setStackInSlot(slot, ItemStack.EMPTY);
+ return copy;
+ }
+
+ @Override
+ public void setInvStack(int slot, ItemStack stack) {
+ itemHandler.setStackInSlot(slot, stack);
+ }
+
+ @Override
+ public void markDirty() {
+ }
+
+ @Override
+ public boolean canPlayerUseInv(PlayerEntity player) {
+ return false;
+ }
+
+ @Override
+ public void clear() {
+ for (int i = 0; i < itemHandler.getSlots(); i++) {
+ itemHandler.setStackInSlot(i, ItemStack.EMPTY);
+ }
+ }
+
+ public IItemHandlerModifiable getItemHandler() {
+ return this.itemHandler;
+ }
+}
diff --git a/patchwork-items/src/main/java/net/patchworkmc/impl/items/PatchworkItems.java b/patchwork-items/src/main/java/net/patchworkmc/impl/items/PatchworkItems.java
new file mode 100644
index 00000000..fba684d7
--- /dev/null
+++ b/patchwork-items/src/main/java/net/patchworkmc/impl/items/PatchworkItems.java
@@ -0,0 +1,38 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.items;
+
+import net.minecraftforge.items.CapabilityItemHandler;
+
+import net.minecraft.util.math.Direction;
+
+import net.fabricmc.api.ModInitializer;
+
+public class PatchworkItems implements ModInitializer {
+ /**
+ * Shared ThreadLocal for {@link net.patchworkmc.mixin.items.MixinDropperBlock} and {@link net.patchworkmc.mixin.items.MixinHopperBlockEntity}.
+ */
+ public static final ThreadLocal currentSide = new ThreadLocal<>();
+
+ @Override
+ public void onInitialize() {
+ CapabilityItemHandler.register();
+ }
+}
diff --git a/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinDropperBlock.java b/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinDropperBlock.java
new file mode 100644
index 00000000..b4bd9c1f
--- /dev/null
+++ b/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinDropperBlock.java
@@ -0,0 +1,39 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.items;
+
+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.CallbackInfo;
+
+import net.minecraft.block.DropperBlock;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+
+import net.patchworkmc.impl.items.PatchworkItems;
+
+@Mixin(DropperBlock.class)
+public class MixinDropperBlock {
+ @Inject(method = "dispense", at = @At(value = "INVOKE", target = "Lnet/minecraft/block/entity/HopperBlockEntity;getInventoryAt(Lnet/minecraft/world/World;Lnet/minecraft/util/math/BlockPos;)Lnet/minecraft/inventory/Inventory;"))
+ private void onDispenseGetInventory(World world, BlockPos pos, CallbackInfo ci) {
+ PatchworkItems.currentSide.set(world.getBlockState(pos).get(DropperBlock.FACING));
+ }
+}
diff --git a/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinHopperBlockEntity.java b/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinHopperBlockEntity.java
new file mode 100644
index 00000000..bc8ffb7d
--- /dev/null
+++ b/patchwork-items/src/main/java/net/patchworkmc/mixin/items/MixinHopperBlockEntity.java
@@ -0,0 +1,93 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.items;
+
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.IItemHandlerModifiable;
+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 net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.HopperBlock;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.block.entity.Hopper;
+import net.minecraft.block.entity.HopperBlockEntity;
+import net.minecraft.inventory.Inventory;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+import net.patchworkmc.impl.items.PatchworkItems;
+import net.patchworkmc.impl.items.ItemHandlerInventoryWrapper;
+
+@Mixin(HopperBlockEntity.class)
+public class MixinHopperBlockEntity {
+ @Inject(method = "getInputInventory", at = @At("HEAD"))
+ private static void onGetInputInventory(Hopper hopper, CallbackInfoReturnable cir) {
+ PatchworkItems.currentSide.set(Direction.UP);
+ }
+
+ @Inject(method = "getOutputInventory", at = @At("HEAD"))
+ private void onGetOutputInventory(CallbackInfoReturnable cir) {
+ PatchworkItems.currentSide.set(((BlockEntity) (Object) this).getCachedState().get(HopperBlock.FACING));
+ }
+
+ @Inject(method = "getInventoryAt(Lnet/minecraft/world/World;DDD)Lnet/minecraft/inventory/Inventory;", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/World;getEntities(Lnet/minecraft/entity/Entity;Lnet/minecraft/util/math/Box;Ljava/util/function/Predicate;)Ljava/util/List;"), cancellable = true)
+ private static void onGetInventoryAt(World world, double x, double y, double z, CallbackInfoReturnable cir) {
+ BlockPos blockPos = new BlockPos(x, y, z);
+ BlockState blockState = world.getBlockState(blockPos);
+ Block block = blockState.getBlock();
+
+ if (block.hasBlockEntity()) {
+ BlockEntity blockEntity = world.getBlockEntity(blockPos);
+
+ if (blockEntity != null) {
+ Direction direction = PatchworkItems.currentSide.get();
+
+ if (direction != null) {
+ LazyOptional capability = ((ICapabilityProvider) blockEntity).getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, direction.getOpposite());
+ PatchworkItems.currentSide.remove();
+ capability.ifPresent(result -> {
+ if (result instanceof IItemHandlerModifiable) {
+ cir.setReturnValue(new ItemHandlerInventoryWrapper((IItemHandlerModifiable) result));
+ }
+ });
+ }
+ }
+ }
+ }
+
+ @Inject(method = "transfer(Lnet/minecraft/inventory/Inventory;Lnet/minecraft/inventory/Inventory;Lnet/minecraft/item/ItemStack;ILnet/minecraft/util/math/Direction;)Lnet/minecraft/item/ItemStack;", at = @At("HEAD"), cancellable = true)
+ private static void onTransfer(Inventory from, Inventory to, ItemStack stack, int slot, Direction direction, CallbackInfoReturnable cir) {
+ IItemHandlerModifiable itemHandler;
+
+ if (to instanceof ItemHandlerInventoryWrapper) {
+ itemHandler = ((ItemHandlerInventoryWrapper) to).getItemHandler();
+ cir.setReturnValue(itemHandler.insertItem(slot, stack, false));
+ }
+ }
+}
diff --git a/patchwork-items/src/main/resources/assets/patchwork-items/icon.png b/patchwork-items/src/main/resources/assets/patchwork-items/icon.png
new file mode 100644
index 00000000..de75d2fb
Binary files /dev/null and b/patchwork-items/src/main/resources/assets/patchwork-items/icon.png differ
diff --git a/patchwork-items/src/main/resources/fabric.mod.json b/patchwork-items/src/main/resources/fabric.mod.json
new file mode 100644
index 00000000..93ef2083
--- /dev/null
+++ b/patchwork-items/src/main/resources/fabric.mod.json
@@ -0,0 +1,26 @@
+{
+ "schemaVersion": 1,
+ "id": "patchwork-items",
+ "version": "${version}",
+ "name": "Patchwork Items",
+ "description": "A reimplementation of the Minecraft Forge item handling APIs.",
+ "authors": [
+ "coderbot"
+ ],
+ "license": "LGPL-2.1-only",
+ "icon": "assets/patchwork-items/icon.png",
+ "environment": "*",
+ "depends": {
+ "patchwork-api-base": "*"
+ },
+ "mixins": [
+ "patchwork-items.mixins.json"
+ ],
+ "entrypoints": {
+ "main": ["net.patchworkmc.impl.items.PatchworkItems"]
+ },
+ "custom": {
+ "modmenu:api": true,
+ "modmenu:parent": "patchwork"
+ }
+}
diff --git a/patchwork-items/src/main/resources/patchwork-items.mixins.json b/patchwork-items/src/main/resources/patchwork-items.mixins.json
new file mode 100644
index 00000000..edf8c6d6
--- /dev/null
+++ b/patchwork-items/src/main/resources/patchwork-items.mixins.json
@@ -0,0 +1,12 @@
+{
+ "required": true,
+ "package": "net.patchworkmc.mixin.items",
+ "compatibilityLevel": "JAVA_8",
+ "mixins": [
+ "MixinDropperBlock",
+ "MixinHopperBlockEntity"
+ ],
+ "injectors": {
+ "defaultRequire": 1
+ }
+}
diff --git a/patchwork-key-bindings/build.gradle b/patchwork-key-bindings/build.gradle
new file mode 100644
index 00000000..33c56484
--- /dev/null
+++ b/patchwork-key-bindings/build.gradle
@@ -0,0 +1,6 @@
+archivesBaseName = "patchwork-key-bindings"
+version = getSubprojectVersion(project, "0.2.0")
+
+dependencies {
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+}
diff --git a/patchwork-key-bindings/src/main/java/net/minecraftforge/client/extensions/IForgeKeybinding.java b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/extensions/IForgeKeybinding.java
new file mode 100644
index 00000000..ee2384ac
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/extensions/IForgeKeybinding.java
@@ -0,0 +1,69 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.extensions;
+
+import javax.annotation.Nonnull;
+
+import net.minecraftforge.client.settings.IKeyConflictContext;
+import net.minecraftforge.client.settings.KeyModifier;
+
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+
+public interface IForgeKeybinding {
+ default KeyBinding getKeyBinding() {
+ return (KeyBinding) this;
+ }
+
+ @Nonnull
+ InputUtil.KeyCode getKey();
+
+ /**
+ * Checks that the key conflict context and modifier are active, and that the keyCode matches this binding.
+ */
+ default boolean isActiveAndMatches(InputUtil.KeyCode keyCode) {
+ return keyCode.getKeyCode() != 0 && keyCode.equals(getKey()) && getKeyConflictContext().isActive() && getKeyModifier().isActive(getKeyConflictContext());
+ }
+
+ default void setToDefault() {
+ setKeyModifierAndCode(getKeyModifierDefault(), getKeyBinding().getDefaultKeyCode());
+ }
+
+ IKeyConflictContext getKeyConflictContext();
+
+ void setKeyConflictContext(IKeyConflictContext keyConflictContext);
+
+ KeyModifier getKeyModifierDefault();
+
+ KeyModifier getKeyModifier();
+
+ void setKeyModifierAndCode(KeyModifier keyModifier, InputUtil.KeyCode keyCode);
+
+ /**
+ * Returns true when one of the bindings' key codes conflicts with the other's modifier.
+ */
+ default boolean hasKeyCodeModifierConflict(KeyBinding other) {
+ if (getKeyConflictContext().conflicts(((IForgeKeybinding) other).getKeyConflictContext()) || ((IForgeKeybinding) other).getKeyConflictContext().conflicts(getKeyConflictContext())) {
+ return getKeyModifier().matches(((IForgeKeybinding) other).getKey()) || ((IForgeKeybinding) other).getKeyModifier().matches(getKey());
+ }
+
+ return false;
+ }
+}
diff --git a/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/IKeyConflictContext.java b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/IKeyConflictContext.java
new file mode 100644
index 00000000..78515753
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/IKeyConflictContext.java
@@ -0,0 +1,37 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.settings;
+
+/**
+ * Defines the context that a {@link KeyBinding} is used.
+ * Key conflicts occur when a {@link KeyBinding} has the same {@link IKeyConflictContext} and has conflicting modifiers and keyCodes.
+ */
+public interface IKeyConflictContext {
+ /**
+ * @return true if conditions are met to activate {@link KeyBinding}s with this context
+ */
+ boolean isActive();
+
+ /**
+ * @return true if the other context can have {@link KeyBinding} conflicts with this one.
+ * This will be called on both contexts to check for conflicts.
+ */
+ boolean conflicts(IKeyConflictContext other);
+}
diff --git a/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyConflictContext.java b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyConflictContext.java
new file mode 100644
index 00000000..b0ae3034
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyConflictContext.java
@@ -0,0 +1,70 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.settings;
+
+import net.minecraft.client.MinecraftClient;
+
+public enum KeyConflictContext implements IKeyConflictContext {
+ /**
+ * Universal key bindings are used in every context and will conflict with any other context.
+ * Key Bindings are universal by default.
+ */
+ UNIVERSAL {
+ @Override
+ public boolean isActive() {
+ return true;
+ }
+
+ @Override
+ public boolean conflicts(IKeyConflictContext other) {
+ return true;
+ }
+ },
+
+ /**
+ * Gui key bindings are only used when a {@link GuiScreen} is open.
+ */
+ GUI {
+ @Override
+ public boolean isActive() {
+ return MinecraftClient.getInstance().currentScreen != null;
+ }
+
+ @Override
+ public boolean conflicts(IKeyConflictContext other) {
+ return this == other;
+ }
+ },
+
+ /**
+ * In-game key bindings are only used when a {@link GuiScreen} is not open.
+ */
+ IN_GAME {
+ @Override
+ public boolean isActive() {
+ return !GUI.isActive();
+ }
+
+ @Override
+ public boolean conflicts(IKeyConflictContext other) {
+ return this == other;
+ }
+ }
+}
diff --git a/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyModifier.java b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyModifier.java
new file mode 100644
index 00000000..22cb1165
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/minecraftforge/client/settings/KeyModifier.java
@@ -0,0 +1,150 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.settings;
+
+import java.util.function.Supplier;
+
+import javax.annotation.Nullable;
+
+import org.lwjgl.glfw.GLFW;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.gui.screen.Screen;
+import net.minecraft.client.resource.language.I18n;
+import net.minecraft.client.util.InputUtil;
+
+public enum KeyModifier {
+ CONTROL {
+ @Override
+ public boolean matches(InputUtil.KeyCode key) {
+ int keyCode = key.getKeyCode();
+
+ if (MinecraftClient.IS_SYSTEM_MAC) {
+ return keyCode == GLFW.GLFW_KEY_LEFT_ALT || keyCode == GLFW.GLFW_KEY_RIGHT_ALT;
+ } else {
+ return keyCode == GLFW.GLFW_KEY_LEFT_CONTROL || keyCode == GLFW.GLFW_KEY_RIGHT_CONTROL;
+ }
+ }
+
+ @Override
+ public boolean isActive(@Nullable IKeyConflictContext conflictContext) {
+ return Screen.hasControlDown();
+ }
+
+ @Override
+ public String getLocalizedComboName(InputUtil.KeyCode key, Supplier defaultLogic) {
+ String keyName = defaultLogic.get();
+ String localizationFormatKey = MinecraftClient.IS_SYSTEM_MAC ? "forge.controlsgui.control.mac" : "forge.controlsgui.control";
+ return I18n.translate(localizationFormatKey, keyName);
+ }
+ },
+ SHIFT {
+ @Override
+ public boolean matches(InputUtil.KeyCode key) {
+ return key.getKeyCode() == GLFW.GLFW_KEY_LEFT_SHIFT || key.getKeyCode() == GLFW.GLFW_KEY_RIGHT_SHIFT;
+ }
+
+ @Override
+ public boolean isActive(@Nullable IKeyConflictContext conflictContext) {
+ return Screen.hasShiftDown();
+ }
+
+ @Override
+ public String getLocalizedComboName(InputUtil.KeyCode key, Supplier defaultLogic) {
+ return I18n.translate("forge.controlsgui.shift", defaultLogic.get());
+ }
+ },
+ ALT {
+ @Override
+ public boolean matches(InputUtil.KeyCode key) {
+ return key.getKeyCode() == GLFW.GLFW_KEY_LEFT_ALT || key.getKeyCode() == GLFW.GLFW_KEY_RIGHT_ALT;
+ }
+
+ @Override
+ public boolean isActive(@Nullable IKeyConflictContext conflictContext) {
+ return Screen.hasAltDown();
+ }
+
+ @Override
+ public String getLocalizedComboName(InputUtil.KeyCode keyCode, Supplier defaultLogic) {
+ return I18n.translate("forge.controlsgui.alt", defaultLogic.get());
+ }
+ },
+ NONE {
+ @Override
+ public boolean matches(InputUtil.KeyCode key) {
+ return false;
+ }
+
+ @Override
+ public boolean isActive(@Nullable IKeyConflictContext conflictContext) {
+ if (conflictContext != null && !conflictContext.conflicts(KeyConflictContext.IN_GAME)) {
+ for (KeyModifier keyModifier : MODIFIER_VALUES) {
+ if (keyModifier.isActive(conflictContext)) {
+ return false;
+ }
+ }
+ }
+
+ return true;
+ }
+
+ @Override
+ public String getLocalizedComboName(InputUtil.KeyCode key, Supplier defaultLogic) {
+ return defaultLogic.get();
+ }
+ };
+
+ public static final KeyModifier[] MODIFIER_VALUES = {SHIFT, CONTROL, ALT};
+
+ public static KeyModifier getActiveModifier() {
+ for (KeyModifier keyModifier : MODIFIER_VALUES) {
+ if (keyModifier.isActive(null)) {
+ return keyModifier;
+ }
+ }
+
+ return NONE;
+ }
+
+ public static boolean isKeyCodeModifier(InputUtil.KeyCode key) {
+ for (KeyModifier keyModifier : MODIFIER_VALUES) {
+ if (keyModifier.matches(key)) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ public static KeyModifier valueFromString(String stringValue) {
+ try {
+ return valueOf(stringValue);
+ } catch (NullPointerException | IllegalArgumentException ignored) {
+ return NONE;
+ }
+ }
+
+ public abstract boolean matches(InputUtil.KeyCode key);
+
+ public abstract boolean isActive(@Nullable IKeyConflictContext conflictContext);
+
+ public abstract String getLocalizedComboName(InputUtil.KeyCode key, Supplier defaultLogic);
+}
diff --git a/patchwork-key-bindings/src/main/java/net/patchworkmc/api/keybindings/PatchworkKeyBinding.java b/patchwork-key-bindings/src/main/java/net/patchworkmc/api/keybindings/PatchworkKeyBinding.java
new file mode 100644
index 00000000..664b217b
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/patchworkmc/api/keybindings/PatchworkKeyBinding.java
@@ -0,0 +1,63 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.api.keybindings;
+
+import net.minecraftforge.client.extensions.IForgeKeybinding;
+import net.minecraftforge.client.settings.IKeyConflictContext;
+import net.minecraftforge.client.settings.KeyModifier;
+
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+
+import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
+
+import net.patchworkmc.impl.keybindings.ForgeKeyBindingConstruct;
+
+public class PatchworkKeyBinding extends KeyBinding {
+ public PatchworkKeyBinding(String id, int keyCode, String category) {
+ super(id, keyCode, category);
+ KeyBindingHelper.registerKeyBinding(this);
+ }
+
+ public PatchworkKeyBinding(String id, InputUtil.Type type, int code, String category) {
+ super(id, type, code, category);
+ KeyBindingHelper.registerKeyBinding(this);
+ }
+
+ public PatchworkKeyBinding(String id, IKeyConflictContext keyConflictContext, final InputUtil.Type inputType, final int keyCode, String category) {
+ this(id, keyConflictContext, inputType.createFromCode(keyCode), category);
+ }
+
+ public PatchworkKeyBinding(String id, IKeyConflictContext keyConflictContext, InputUtil.KeyCode keyCode, String category) {
+ this(id, keyConflictContext, KeyModifier.NONE, keyCode, category);
+ }
+
+ public PatchworkKeyBinding(String id, IKeyConflictContext keyConflictContext, KeyModifier keyModifier, final InputUtil.Type inputType, final int keyCode, String category) {
+ this(id, keyConflictContext, keyModifier, inputType.createFromCode(keyCode), category);
+ }
+
+ public PatchworkKeyBinding(String id, IKeyConflictContext keyConflictContext, KeyModifier keyModifier, InputUtil.KeyCode keyCode, String category) {
+ super(id, keyCode.getCategory(), keyCode.getKeyCode(), category);
+ ((IForgeKeybinding) this).setKeyConflictContext(keyConflictContext);
+ ((IForgeKeybinding) this).setKeyModifierAndCode(keyModifier, keyCode);
+ ((ForgeKeyBindingConstruct) this).patchwork$constructForgeKeyBindingOptions(keyConflictContext, keyModifier.matches(keyCode) ? KeyModifier.NONE : keyModifier);
+ KeyBindingHelper.registerKeyBinding(this);
+ }
+}
diff --git a/patchwork-key-bindings/src/main/java/net/patchworkmc/impl/keybindings/ForgeKeyBindingConstruct.java b/patchwork-key-bindings/src/main/java/net/patchworkmc/impl/keybindings/ForgeKeyBindingConstruct.java
new file mode 100644
index 00000000..29217348
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/patchworkmc/impl/keybindings/ForgeKeyBindingConstruct.java
@@ -0,0 +1,27 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.keybindings;
+
+import net.minecraftforge.client.settings.IKeyConflictContext;
+import net.minecraftforge.client.settings.KeyModifier;
+
+public interface ForgeKeyBindingConstruct {
+ void patchwork$constructForgeKeyBindingOptions(IKeyConflictContext keyConflictContext, KeyModifier keyModifier);
+}
diff --git a/patchwork-key-bindings/src/main/java/net/patchworkmc/mixin/keybindings/MixinKeyBinding.java b/patchwork-key-bindings/src/main/java/net/patchworkmc/mixin/keybindings/MixinKeyBinding.java
new file mode 100644
index 00000000..ad2bcff2
--- /dev/null
+++ b/patchwork-key-bindings/src/main/java/net/patchworkmc/mixin/keybindings/MixinKeyBinding.java
@@ -0,0 +1,103 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.keybindings;
+
+import net.minecraftforge.client.extensions.IForgeKeybinding;
+import net.minecraftforge.client.settings.IKeyConflictContext;
+import net.minecraftforge.client.settings.KeyConflictContext;
+import net.minecraftforge.client.settings.KeyModifier;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import net.minecraft.client.options.KeyBinding;
+import net.minecraft.client.util.InputUtil;
+
+import net.patchworkmc.impl.keybindings.ForgeKeyBindingConstruct;
+
+@Mixin(KeyBinding.class)
+public abstract class MixinKeyBinding implements Comparable, IForgeKeybinding, ForgeKeyBindingConstruct {
+ @Shadow
+ private InputUtil.KeyCode keyCode;
+
+ // These exist in forge to allow modifiers and conflicting keys to work, this is not implemented
+ // but these remain to avoid stubbing the methods
+ @Unique
+ private KeyModifier keyModifierDefault = KeyModifier.NONE;
+ @Unique
+ private KeyModifier keyModifier = KeyModifier.NONE;
+ @Unique
+ private IKeyConflictContext keyConflictContext = KeyConflictContext.UNIVERSAL;
+
+ @Inject(method = "isPressed()Z", at = @At("HEAD"))
+ public void isPressed(CallbackInfoReturnable info) {
+ if (!getKeyConflictContext().isActive()) {
+ info.setReturnValue(false);
+ info.cancel();
+ }
+ }
+
+ @Override
+ public InputUtil.KeyCode getKey() {
+ return this.keyCode;
+ }
+
+ @Override
+ public IKeyConflictContext getKeyConflictContext() {
+ return keyConflictContext;
+ }
+
+ @Override
+ public void setKeyConflictContext(IKeyConflictContext keyConflictContext) {
+ this.keyConflictContext = keyConflictContext;
+ }
+
+ @Override
+ public KeyModifier getKeyModifierDefault() {
+ return keyModifierDefault;
+ }
+
+ @Override
+ public KeyModifier getKeyModifier() {
+ return keyModifier;
+ }
+
+ @Override
+ public void setKeyModifierAndCode(KeyModifier keyModifier, InputUtil.KeyCode keyCode) {
+ this.keyCode = keyCode;
+
+ if (keyModifier.matches(keyCode)) {
+ keyModifier = KeyModifier.NONE;
+ }
+
+ this.keyModifier = keyModifier;
+ KeyBinding.updateKeysByCode();
+ }
+
+ @Override
+ public void patchwork$constructForgeKeyBindingOptions(IKeyConflictContext keyConflictContext, KeyModifier keyModifier) {
+ this.keyModifier = keyModifier;
+ this.keyModifierDefault = keyModifier;
+ this.keyConflictContext = keyConflictContext;
+ }
+}
diff --git a/patchwork-key-bindings/src/main/resources/assets/patchwork-key-bindings/icon.png b/patchwork-key-bindings/src/main/resources/assets/patchwork-key-bindings/icon.png
new file mode 100644
index 00000000..de75d2fb
Binary files /dev/null and b/patchwork-key-bindings/src/main/resources/assets/patchwork-key-bindings/icon.png differ
diff --git a/patchwork-key-bindings/src/main/resources/fabric.mod.json b/patchwork-key-bindings/src/main/resources/fabric.mod.json
new file mode 100644
index 00000000..bed15e69
--- /dev/null
+++ b/patchwork-key-bindings/src/main/resources/fabric.mod.json
@@ -0,0 +1,26 @@
+{
+ "schemaVersion": 1,
+ "id": "patchwork-key-bindings",
+ "name": "Patchwork Keybindings",
+ "version": "${version}",
+ "license": "LGPL-2.1-only",
+ "icon": "assets/patchwork-key-bindings/icon.png",
+ "contact": {
+ "issues": "https://github.com/PatchworkMC/patchwork-api/issues",
+ "sources": "https://github.com/PatchworkMC/patchwork-api"
+ },
+ "authors": [
+ "PatchworkMC"
+ ],
+ "depends": {
+ "patchwork-api-base": "*"
+ },
+ "mixins": [
+ "patchwork-key-bindings.mixins.json"
+ ],
+ "description": "Implementation of the Forge Keybinding system.",
+ "custom": {
+ "modmenu:api": true,
+ "modmenu:parent": "patchwork"
+ }
+}
diff --git a/patchwork-key-bindings/src/main/resources/patchwork-key-bindings.mixins.json b/patchwork-key-bindings/src/main/resources/patchwork-key-bindings.mixins.json
new file mode 100644
index 00000000..98f3d6ad
--- /dev/null
+++ b/patchwork-key-bindings/src/main/resources/patchwork-key-bindings.mixins.json
@@ -0,0 +1,11 @@
+{
+ "required": true,
+ "package": "net.patchworkmc.mixin.keybindings",
+ "compatibilityLevel": "JAVA_8",
+ "client": [
+ "MixinKeyBinding"
+ ],
+ "injectors": {
+ "defaultRequire": 1
+ }
+}
diff --git a/patchwork-level-generators/build.gradle b/patchwork-level-generators/build.gradle
index 597ee7b6..1f95fe0f 100644
--- a/patchwork-level-generators/build.gradle
+++ b/patchwork-level-generators/build.gradle
@@ -1,11 +1,12 @@
archivesBaseName = "patchwork-level-generators"
-version = getSubprojectVersion(project, "0.2.0")
+version = getSubprojectVersion(project, "0.3.0")
dependencies {
- compile project(path: ':patchwork-fml', configuration: 'dev')
- compile project(path: ':patchwork-events-world', configuration: 'dev')
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+ implementation project(path: ':patchwork-fml', configuration: 'dev')
+ implementation project(path: ':patchwork-events-world', configuration: 'dev')
}
-minecraft {
+loom {
accessWidener "src/main/resources/patchwork-level-generators.accesswidener"
}
diff --git a/patchwork-level-generators/src/main/resources/fabric.mod.json b/patchwork-level-generators/src/main/resources/fabric.mod.json
index 01fc6bd6..018ec87d 100644
--- a/patchwork-level-generators/src/main/resources/fabric.mod.json
+++ b/patchwork-level-generators/src/main/resources/fabric.mod.json
@@ -13,7 +13,7 @@
"PatchworkMC"
],
"depends": {
- "fabricloader": ">=0.8.4"
+ "patchwork-api-base": "*"
},
"description": "Implementation of the Forge World Type API.",
"mixins": [
diff --git a/patchwork-loot/build.gradle b/patchwork-loot/build.gradle
index 9029bd24..7b270e2c 100644
--- a/patchwork-loot/build.gradle
+++ b/patchwork-loot/build.gradle
@@ -1,2 +1,7 @@
archivesBaseName = "patchwork-loot"
-version = getSubprojectVersion(project, "0.2.0")
+version = getSubprojectVersion(project, "0.3.0")
+
+dependencies {
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+}
+
diff --git a/patchwork-loot/src/main/java/net/minecraftforge/event/LootTableLoadEvent.java b/patchwork-loot/src/main/java/net/minecraftforge/event/LootTableLoadEvent.java
new file mode 100644
index 00000000..93ecb6b8
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/minecraftforge/event/LootTableLoadEvent.java
@@ -0,0 +1,67 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.event;
+
+import net.minecraftforge.eventbus.api.Event;
+
+import net.minecraft.loot.LootManager;
+import net.minecraft.loot.LootTable;
+import net.minecraft.util.Identifier;
+
+/**
+ * Event fired when a LootTable json is loaded from json.
+ * This event is fired whenever resources are loaded, or when the server starts.
+ * This event will NOT be fired for LootTables loaded from the world folder, these are
+ * considered configurations files and should not be modified by mods.
+ *
+ * Canceling the event will make it load a empty loot table.
+ */
+public class LootTableLoadEvent extends Event {
+ private final Identifier name;
+ private LootTable table;
+ private LootManager lootTableManager;
+
+ public LootTableLoadEvent(Identifier name, LootTable table, LootManager lootTableManager) {
+ this.name = name;
+ this.table = table;
+ this.lootTableManager = lootTableManager;
+ }
+
+ public Identifier getName() {
+ return this.name;
+ }
+
+ public LootTable getTable() {
+ return this.table;
+ }
+
+ public void setTable(LootTable table) {
+ this.table = table;
+ }
+
+ public LootManager getLootTableManager() {
+ return this.lootTableManager;
+ }
+
+ @Override
+ public boolean isCancelable() {
+ return true;
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootPool.java b/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootPool.java
new file mode 100644
index 00000000..7aef5158
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootPool.java
@@ -0,0 +1,42 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.api.loot;
+
+import net.minecraft.loot.LootPool;
+import net.minecraft.loot.LootTableRange;
+import net.minecraft.loot.UniformLootTableRange;
+
+/**
+ * Interface for adding Forge methods added to LootPool and its inner classes.
+ */
+public interface ForgeLootPool {
+ // TODO: doesn't include methods having to do with freezing yet
+
+ String getName();
+ LootTableRange getRolls();
+ LootTableRange getBonusRolls();
+ void setRolls(UniformLootTableRange v);
+ void setBonusRolls(UniformLootTableRange v);
+
+ public interface Builder {
+ LootPool.Builder name(String name);
+ LootPool.Builder bonusRolls(float min, float max);
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootTable.java b/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootTable.java
new file mode 100644
index 00000000..86650bac
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/api/loot/ForgeLootTable.java
@@ -0,0 +1,33 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.api.loot;
+
+import net.minecraft.loot.LootPool;
+
+/**
+ * Interface for adding Forge methods added to LootTable.
+ */
+public interface ForgeLootTable {
+ // TODO: doesn't include methods having to do with freezing yet
+
+ LootPool getPool(String name);
+ LootPool removePool(String name);
+ void addPool(LootPool pool);
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/impl/event/loot/LootEvents.java b/patchwork-loot/src/main/java/net/patchworkmc/impl/event/loot/LootEvents.java
new file mode 100644
index 00000000..c732f201
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/impl/event/loot/LootEvents.java
@@ -0,0 +1,39 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.event.loot;
+
+import net.minecraftforge.event.LootTableLoadEvent;
+import net.minecraftforge.common.MinecraftForge;
+
+import net.minecraft.loot.LootManager;
+import net.minecraft.loot.LootTable;
+import net.minecraft.util.Identifier;
+
+public class LootEvents {
+ public static LootTable loadLootTable(Identifier name, LootTable table, LootManager manager) {
+ LootTableLoadEvent event = new LootTableLoadEvent(name, table, manager);
+
+ if (MinecraftForge.EVENT_BUS.post(event)) {
+ return LootTable.EMPTY;
+ }
+
+ return event.getTable();
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/LootHooks.java b/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/LootHooks.java
new file mode 100644
index 00000000..88a5d840
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/LootHooks.java
@@ -0,0 +1,149 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.loot;
+
+import java.util.Deque;
+import java.util.HashSet;
+
+import javax.annotation.Nullable;
+
+import com.google.common.collect.Queues;
+import com.google.common.collect.Sets;
+import com.google.gson.Gson;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+
+import net.minecraft.loot.LootManager;
+import net.minecraft.loot.LootTable;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.JsonHelper;
+
+import net.patchworkmc.impl.event.loot.LootEvents;
+
+// NOTE: this class is more or less a direct copy of parts of Forge's ForgeHooks.
+public class LootHooks {
+ // Made public for Patchwork's own use
+ public static ThreadLocal> lootContext = new ThreadLocal>();
+
+ public static LootTable loadLootTable(Gson gson, Identifier name, JsonElement data, boolean custom, LootManager lootTableManager) {
+ Deque que = lootContext.get();
+
+ if (que == null) {
+ que = Queues.newArrayDeque();
+ lootContext.set(que);
+ }
+
+ LootTable ret = null;
+
+ try {
+ que.push(new LootTableContext(name, custom));
+ ret = gson.fromJson(data, LootTable.class);
+ que.pop();
+ } catch (JsonParseException e) {
+ que.pop();
+ throw e;
+ }
+
+ if (!custom) {
+ ret = LootEvents.loadLootTable(name, ret, lootTableManager);
+ }
+
+ // if (ret != null) {
+ // ret.freeze();
+ // }
+
+ return ret;
+ }
+
+ private static LootTableContext getLootTableContext() {
+ LootTableContext ctx = lootContext.get().peek();
+
+ if (ctx == null) {
+ throw new JsonParseException("Invalid call stack, could not grab json context!"); // Should I throw this? Do we care about custom deserializers outside the manager?
+ }
+
+ return ctx;
+ }
+
+ public static String readPoolName(JsonObject json) {
+ LootTableContext ctx = LootHooks.getLootTableContext();
+ ctx.resetPoolCtx();
+
+ if (json.has("name")) {
+ return JsonHelper.getString(json, "name");
+ }
+
+ if (ctx.custom) {
+ return "custom#" + json.hashCode(); //We don't care about custom ones modders shouldn't be editing them!
+ }
+
+ ctx.poolCount++;
+
+ if (!ctx.vanilla) {
+ throw new JsonParseException("Loot Table \"" + ctx.name.toString() + "\" Missing `name` entry for pool #" + (ctx.poolCount - 1));
+ }
+
+ return ctx.poolCount == 1 ? "main" : "pool" + (ctx.poolCount - 1);
+ }
+
+ // Made public for Patchwork's own use
+ public static class LootTableContext {
+ public final Identifier name;
+ public final boolean custom;
+ private final boolean vanilla;
+ public int poolCount = 0;
+ public int entryCount = 0;
+ private HashSet entryNames = Sets.newHashSet();
+
+ protected LootTableContext(Identifier name, boolean custom) {
+ this.name = name;
+ this.custom = custom;
+ this.vanilla = "minecraft".equals(this.name.getNamespace());
+ }
+
+ private void resetPoolCtx() {
+ this.entryCount = 0;
+ this.entryNames.clear();
+ }
+
+ public String validateEntryName(@Nullable String name) {
+ if (name != null && !this.entryNames.contains(name)) {
+ this.entryNames.add(name);
+ return name;
+ }
+
+ if (!this.vanilla) {
+ throw new JsonParseException("Loot Table \"" + this.name.toString() + "\" Duplicate entry name \"" + name + "\" for pool #" + (this.poolCount - 1) + " entry #" + (this.entryCount - 1));
+ }
+
+ int x = 0;
+
+ while (this.entryNames.contains(name + "#" + x)) {
+ x++;
+ }
+
+ name = name + "#" + x;
+ this.entryNames.add(name);
+
+ return name;
+ }
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/PatchworkLootPool.java b/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/PatchworkLootPool.java
new file mode 100644
index 00000000..68770139
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/impl/loot/PatchworkLootPool.java
@@ -0,0 +1,28 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.loot;
+
+/**
+ * Forge does this through patching the constructor, we just add methods with
+ * mixins instead.
+ */
+public interface PatchworkLootPool {
+ void patchwork$setName(String name);
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinJsonDataLoader.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinJsonDataLoader.java
new file mode 100644
index 00000000..85b3b420
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinJsonDataLoader.java
@@ -0,0 +1,44 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import java.util.Map;
+
+import com.google.gson.JsonObject;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+import net.minecraft.resource.JsonDataLoader;
+import net.minecraft.resource.SinglePreparationResourceReloadListener;
+import net.minecraft.util.Identifier;
+
+// TODO: Is there a better place to put this?
+@Mixin(JsonDataLoader.class)
+public abstract class MixinJsonDataLoader extends SinglePreparationResourceReloadListener> {
+ @Shadow
+ @Final
+ String dataType;
+
+ // This does not get its own interface -- any mixins on subclasses wishing to use it should probably extend this mixin.
+ protected Identifier getPreparedPath(Identifier id) {
+ return new Identifier(id.getNamespace(), dataType + "/" + id.getPath() + ".json");
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootManager.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootManager.java
new file mode 100644
index 00000000..4ae6cb97
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootManager.java
@@ -0,0 +1,81 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import java.util.Map;
+import java.util.function.BiConsumer;
+
+import com.google.common.collect.ImmutableMap;
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import org.apache.logging.log4j.Logger;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Overwrite;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+
+import net.minecraft.loot.LootManager;
+import net.minecraft.loot.LootTable;
+import net.minecraft.resource.Resource;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+
+import net.patchworkmc.impl.loot.LootHooks;
+
+@Mixin(LootManager.class)
+public abstract class MixinLootManager extends MixinJsonDataLoader {
+ @Shadow
+ @Final
+ private static Gson GSON;
+
+ @Shadow
+ @Final
+ private static Logger LOGGER;
+
+ @Redirect(method = "apply", at = @At(value = "INVOKE", target = "java/util/Map.forEach (Ljava/util/function/BiConsumer;)V", ordinal = 0))
+ private void cancel_forEach(Map map, BiConsumer consumer) {
+ // ignore this call, we're gonna reintroduce it but with capturing locals
+ }
+
+ @Inject(method = "apply", at = @At(value = "INVOKE", target = "java/util/Map.forEach (Ljava/util/function/BiConsumer;)V", ordinal = 0), locals = LocalCapture.CAPTURE_FAILHARD)
+ private void reintroduce_forEach(Map map, ResourceManager resourceManager, Profiler profiler, CallbackInfo info, ImmutableMap.Builder builder) {
+ map.forEach((id, jsonObject) -> {
+ try {
+ LootManager lootManager = (LootManager) (Object) this;
+ Resource res = resourceManager.getResource(this.getPreparedPath(id));
+ LootTable lootTable = LootHooks.loadLootTable(GSON, id, jsonObject, res == null || !res.getResourcePackName().equals("Default"), lootManager);
+ builder.put(id, lootTable);
+ } catch (Exception ex) {
+ LOGGER.error("Couldn't parse loot table {}", id, ex);
+ }
+ });
+ }
+
+ @Overwrite
+ private static void method_20711(ImmutableMap.Builder builder, Identifier id, JsonObject obj) {
+ // We are effectively overwriting this lambda with our own, so let's make that explicit by actually overwriting it.
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPool.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPool.java
new file mode 100644
index 00000000..b538bfbf
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPool.java
@@ -0,0 +1,82 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+
+import net.minecraft.loot.LootPool;
+import net.minecraft.loot.LootTableRange;
+import net.minecraft.loot.UniformLootTableRange;
+
+import net.patchworkmc.api.loot.ForgeLootPool;
+import net.patchworkmc.impl.loot.PatchworkLootPool;
+
+@Mixin(LootPool.class)
+public class MixinLootPool implements PatchworkLootPool, ForgeLootPool {
+ // Forge has this as final, but I don't have a good way to initialize it if it is final.
+ @Unique
+ private String name;
+
+ @Shadow
+ private UniformLootTableRange bonusRollsRange;
+
+ @Shadow
+ private LootTableRange rollsRange;
+
+ // implementation detail
+ // TODO: if we could have an inner class that was also a mixin, we could set this as protected?
+ @Override
+ public void patchwork$setName(String name) {
+ this.name = name;
+ }
+
+ // Forge methods that should be added directly to the type
+
+ // TODO: freezing stuff
+
+ @Override
+ public String getName() {
+ return this.name;
+ }
+
+ @Override
+ public LootTableRange getRolls() {
+ return rollsRange;
+ }
+
+ @Override
+ public LootTableRange getBonusRolls() {
+ return this.bonusRollsRange;
+ }
+
+ @Override
+ public void setRolls(UniformLootTableRange v) {
+ // checkFrozen();
+ this.rollsRange = v;
+ }
+
+ @Override
+ public void setBonusRolls(UniformLootTableRange v) {
+ // checkFrozen();
+ this.bonusRollsRange = v;
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolBuilder.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolBuilder.java
new file mode 100644
index 00000000..d2d2d8fc
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolBuilder.java
@@ -0,0 +1,60 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import net.minecraft.loot.LootPool;
+import net.minecraft.loot.UniformLootTableRange;
+
+import net.patchworkmc.api.loot.ForgeLootPool;
+import net.patchworkmc.impl.loot.PatchworkLootPool;
+
+@Mixin(LootPool.Builder.class)
+public abstract class MixinLootPoolBuilder implements ForgeLootPool.Builder {
+ @Unique
+ private String name;
+
+ @Shadow
+ private UniformLootTableRange bonusRollsRange;
+
+ @Inject(method = "build", at = @At("RETURN"), cancellable = true)
+ private void addNameToConstructor(CallbackInfoReturnable cir) {
+ LootPool ret = cir.getReturnValue();
+ ((PatchworkLootPool) ret).patchwork$setName(name);
+ }
+
+ @Override
+ public LootPool.Builder name(String name) {
+ this.name = name;
+ return (LootPool.Builder) (Object) this;
+ }
+
+ @Override
+ public LootPool.Builder bonusRolls(float min, float max) {
+ this.bonusRollsRange = new UniformLootTableRange(min, max);
+ return (LootPool.Builder) (Object) this;
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolSerializer.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolSerializer.java
new file mode 100644
index 00000000..5f57ca15
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootPoolSerializer.java
@@ -0,0 +1,64 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import java.lang.reflect.Type;
+
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonElement;
+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.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonSerializationContext;
+
+import net.minecraft.loot.LootPool;
+
+import net.patchworkmc.api.loot.ForgeLootPool;
+import net.patchworkmc.impl.loot.LootHooks;
+import net.patchworkmc.impl.loot.PatchworkLootPool;
+
+@Mixin(LootPool.Serializer.class)
+public class MixinLootPoolSerializer {
+ @Inject(method = "deserialize", at = @At("RETURN"), cancellable = true, locals = LocalCapture.CAPTURE_FAILHARD)
+ private void addNameToConstructor(JsonElement elem, Type ty, JsonDeserializationContext ctx, CallbackInfoReturnable cir, JsonObject obj) {
+ LootPool ret = cir.getReturnValue();
+ ((PatchworkLootPool) ret).patchwork$setName(LootHooks.readPoolName(obj));
+
+ // is this necessary?
+ cir.setReturnValue(ret);
+ }
+
+ @Redirect(method = "serialize", at = @At(value = "NEW", args = "class=com/google/gson/JsonObject"))
+ private static JsonObject serializeName(LootPool pool, Type type, JsonSerializationContext ctx) {
+ JsonObject ret = new JsonObject();
+
+ String name = ((ForgeLootPool) pool).getName();
+
+ if (name != null && !name.startsWith("custom#")) {
+ ret.add("name", ctx.serialize(name));
+ }
+
+ return ret;
+ }
+}
diff --git a/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootTable.java b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootTable.java
new file mode 100644
index 00000000..346b04c3
--- /dev/null
+++ b/patchwork-loot/src/main/java/net/patchworkmc/mixin/loot/MixinLootTable.java
@@ -0,0 +1,75 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.loot;
+
+import java.util.Arrays;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+
+import net.minecraft.loot.LootPool;
+import net.minecraft.loot.LootTable;
+
+import net.fabricmc.fabric.api.loot.v1.FabricLootSupplier;
+
+import net.patchworkmc.api.loot.ForgeLootTable;
+import net.patchworkmc.api.loot.ForgeLootPool;
+
+@Mixin(LootTable.class)
+public class MixinLootTable implements ForgeLootTable {
+ @Shadow
+ LootPool[] pools;
+
+ // Forge added methods
+
+ // TODO: freezing stuff
+
+ @Override
+ public LootPool getPool(String name) {
+ return ((FabricLootSupplier) this).getPools().stream().filter(e -> name.equals(((ForgeLootPool) e).getName())).findFirst().orElse(null);
+ }
+
+ @Override
+ public LootPool removePool(String name) {
+ // checkFrozen();
+ for (int idx = 0; idx < pools.length; ++idx) {
+ LootPool pool = pools[idx];
+
+ if (name.equals(((ForgeLootPool) pool).getName())) {
+ // https://stackoverflow.com/a/644764
+ System.arraycopy(pools, idx + 1, pools, idx, pools.length - 1 - idx);
+ return pool;
+ }
+ }
+
+ return null;
+ }
+
+ @Override
+ public void addPool(LootPool pool) {
+ // checkFrozen();
+ if (((FabricLootSupplier) this).getPools().stream().anyMatch(e -> e == pool || ((ForgeLootPool) e).getName().equals(((ForgeLootPool) pool).getName()))) {
+ throw new RuntimeException("Attempted to add a duplicate pool to loot table: " + ((ForgeLootPool) pool).getName());
+ }
+
+ pools = Arrays.copyOf(pools, pools.length + 1);
+ pools[pools.length - 1] = pool;
+ }
+}
diff --git a/patchwork-loot/src/main/resources/assets/patchwork-loot/icon.png b/patchwork-loot/src/main/resources/assets/patchwork-loot/icon.png
new file mode 100644
index 00000000..de75d2fb
Binary files /dev/null and b/patchwork-loot/src/main/resources/assets/patchwork-loot/icon.png differ
diff --git a/patchwork-loot/src/main/resources/fabric.mod.json b/patchwork-loot/src/main/resources/fabric.mod.json
index 46a3e957..215c4733 100644
--- a/patchwork-loot/src/main/resources/fabric.mod.json
+++ b/patchwork-loot/src/main/resources/fabric.mod.json
@@ -13,7 +13,7 @@
"PatchworkMC"
],
"depends": {
- "fabricloader": ">=0.8.4"
+ "patchwork-api-base": "*"
},
"mixins": [
"patchwork-loot.mixins.json"
diff --git a/patchwork-loot/src/main/resources/patchwork-loot.mixins.json b/patchwork-loot/src/main/resources/patchwork-loot.mixins.json
index 137951b0..4cedf63b 100644
--- a/patchwork-loot/src/main/resources/patchwork-loot.mixins.json
+++ b/patchwork-loot/src/main/resources/patchwork-loot.mixins.json
@@ -5,7 +5,13 @@
"mixins": [
"MixinAdvancementRewards",
"MixinFishingBobberEntity",
- "MixinLootContextTypes"
+ "MixinJsonDataLoader",
+ "MixinLootContextTypes",
+ "MixinLootManager",
+ "MixinLootPool",
+ "MixinLootPoolBuilder",
+ "MixinLootPoolSerializer",
+ "MixinLootTable"
],
"injectors": {
"defaultRequire": 1
diff --git a/patchwork-model-loader/build.gradle b/patchwork-model-loader/build.gradle
new file mode 100644
index 00000000..77fa2553
--- /dev/null
+++ b/patchwork-model-loader/build.gradle
@@ -0,0 +1,7 @@
+archivesBaseName = "patchwork-model-loader"
+version = getSubprojectVersion(project, "0.2.1")
+
+dependencies {
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+ implementation project(path: ':patchwork-fml', configuration: 'dev')
+}
diff --git a/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelBakeEvent.java b/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelBakeEvent.java
new file mode 100644
index 00000000..18ac9787
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelBakeEvent.java
@@ -0,0 +1,59 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.event;
+
+import java.util.Map;
+
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.eventbus.api.Event;
+
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BakedModelManager;
+import net.minecraft.util.Identifier;
+
+/**
+ * Fired when the BakedModelManager is notified of the resource manager reloading.
+ * Called after model registry is setup, but before it's passed to
+ * BlockModelShapes.
+ */
+public class ModelBakeEvent extends Event {
+ private final BakedModelManager modelManager;
+ private final Map modelRegistry;
+ private final ModelLoader modelLoader;
+
+ public ModelBakeEvent(BakedModelManager modelManager, Map modelRegistry,
+ ModelLoader modelLoader) {
+ this.modelManager = modelManager;
+ this.modelRegistry = modelRegistry;
+ this.modelLoader = modelLoader;
+ }
+
+ public BakedModelManager getModelManager() {
+ return modelManager;
+ }
+
+ public Map getModelRegistry() {
+ return modelRegistry;
+ }
+
+ public ModelLoader getModelLoader() {
+ return modelLoader;
+ }
+}
diff --git a/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelRegistryEvent.java b/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelRegistryEvent.java
new file mode 100644
index 00000000..d31900d6
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/minecraftforge/client/event/ModelRegistryEvent.java
@@ -0,0 +1,29 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.event;
+
+import net.minecraftforge.eventbus.api.Event;
+
+/**
+ * Fired when the {@link net.minecraftforge.client.model.ModelLoader} is ready
+ * to receive registrations.
+ */
+public class ModelRegistryEvent extends Event {
+}
diff --git a/patchwork-model-loader/src/main/java/net/minecraftforge/client/model/ModelLoader.java b/patchwork-model-loader/src/main/java/net/minecraftforge/client/model/ModelLoader.java
new file mode 100644
index 00000000..54dcafca
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/minecraftforge/client/model/ModelLoader.java
@@ -0,0 +1,109 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.model;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import javax.annotation.Nullable;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.MarkerManager;
+
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.texture.SpriteAtlasTexture;
+import net.minecraft.client.util.ModelIdentifier;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+
+import net.patchworkmc.impl.modelloader.SpecialModelProvider;
+
+public class ModelLoader extends net.minecraft.client.render.model.ModelLoader implements SpecialModelProvider {
+ private static final Marker MODELLOADING = MarkerManager.getMarker("MODELLOADING");
+ private static Set specialModels = new HashSet<>();
+ private static final Logger LOGGER = LogManager.getLogger();
+ private final Map loadingExceptions = new HashMap<>();
+ private boolean isLoading = false;
+ private static ModelLoader instance;
+
+ @Nullable
+ public static ModelLoader instance() {
+ return instance;
+ }
+
+ public boolean isLoading() {
+ return isLoading;
+ }
+
+ public ModelLoader(ResourceManager resourceManager, SpriteAtlasTexture spriteAtlas, BlockColors blockColors,
+ Profiler profiler) {
+ super(resourceManager, spriteAtlas, blockColors, profiler);
+ }
+
+ /**
+ * Indicate to vanilla that it should load and bake the given model, even if no
+ * blocks or items use it. This is useful if e.g. you have baked models only for
+ * entity renderers. Call during
+ * {@link net.minecraftforge.client.event.ModelRegistryEvent}
+ *
+ * @param rl The model, either {@link ModelResourceLocation} to point to a
+ * blockstate variant, or plain {@link ResourceLocation} to point
+ * directly to a json in the models folder.
+ */
+ public static void addSpecialModel(Identifier rl) {
+ specialModels.add(rl);
+ }
+
+ @Override
+ public Set getSpecialModels() {
+ return specialModels;
+ }
+
+ /**
+ * Internal, do not use.
+ */
+ public void onPostBakeEvent(Map modelRegistry) {
+ BakedModel missingModel = modelRegistry.get(MISSING);
+
+ for (Map.Entry entry : loadingExceptions.entrySet()) {
+ // ignoring pure Identifier arguments, all things we care about pass
+ // ModelIdentifier
+ if (entry.getKey() instanceof ModelIdentifier) {
+ LOGGER.debug(MODELLOADING, "Model {} failed to load: {}", entry.getKey().toString(),
+ entry.getValue().getLocalizedMessage());
+ final ModelIdentifier location = (ModelIdentifier) entry.getKey();
+ final BakedModel model = modelRegistry.get(location);
+
+ if (model == null) {
+ modelRegistry.put(location, missingModel);
+ }
+ }
+ }
+
+ loadingExceptions.clear();
+ isLoading = false;
+ }
+}
diff --git a/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/ModelEventDispatcher.java b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/ModelEventDispatcher.java
new file mode 100644
index 00000000..1afc38d1
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/ModelEventDispatcher.java
@@ -0,0 +1,37 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.modelloader;
+
+import java.util.Map;
+
+import net.minecraftforge.client.event.ModelBakeEvent;
+import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.fml.ModLoader;
+
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BakedModelManager;
+import net.minecraft.util.Identifier;
+
+public class ModelEventDispatcher {
+ public static void onModelBake(BakedModelManager modelManager, Map modelRegistry, ModelLoader modelLoader) {
+ ModLoader.get().postEvent(new ModelBakeEvent(modelManager, modelRegistry, modelLoader));
+ modelLoader.onPostBakeEvent(modelRegistry);
+ }
+}
diff --git a/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/Signatures.java b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/Signatures.java
new file mode 100644
index 00000000..735b2b3a
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/Signatures.java
@@ -0,0 +1,34 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.modelloader;
+
+public class Signatures {
+ public static final String Profiler_swap = "net/minecraft/util/profiler/Profiler.swap(Ljava/lang/String;)V";
+
+ public static final String ModelLoader_new = "("
+ + "Lnet/minecraft/resource/ResourceManager;"
+ + "Lnet/minecraft/client/texture/SpriteAtlasTexture;"
+ + "Lnet/minecraft/client/color/block/BlockColors;"
+ + "Lnet/minecraft/util/profiler/Profiler;"
+ + ")"
+ + "Lnet/minecraft/client/render/model/ModelLoader;";
+
+ public static final String ModelLoader_addModel = "net/minecraft/client/render/model/ModelLoader.addModel(Lnet/minecraft/client/util/ModelIdentifier;)V";
+}
diff --git a/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/SpecialModelProvider.java b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/SpecialModelProvider.java
new file mode 100644
index 00000000..e39b5a46
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/patchworkmc/impl/modelloader/SpecialModelProvider.java
@@ -0,0 +1,30 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.modelloader;
+
+import java.util.Set;
+
+import net.minecraft.util.Identifier;
+
+public interface SpecialModelProvider {
+ default Set getSpecialModels() {
+ return java.util.Collections.emptySet();
+ }
+}
diff --git a/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinBakedModelManager.java b/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinBakedModelManager.java
new file mode 100644
index 00000000..e2169543
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinBakedModelManager.java
@@ -0,0 +1,59 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.modelloader;
+
+import java.util.Map;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.At.Shift;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import net.minecraft.client.color.block.BlockColors;
+import net.minecraft.client.render.model.BakedModel;
+import net.minecraft.client.render.model.BakedModelManager;
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.client.texture.SpriteAtlasTexture;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+
+import net.patchworkmc.impl.modelloader.ModelEventDispatcher;
+import net.patchworkmc.impl.modelloader.Signatures;
+
+@Mixin(BakedModelManager.class)
+public abstract class MixinBakedModelManager {
+ @Shadow
+ private Map models;
+
+ @Redirect(method = "prepare", at = @At(value = "NEW", target = Signatures.ModelLoader_new, ordinal = 0))
+ private ModelLoader patchwork_prepare_new_ModelLoader(ResourceManager resourceManager, SpriteAtlasTexture spriteAtlas, BlockColors blockColors, Profiler profiler) {
+ return new net.minecraftforge.client.model.ModelLoader(resourceManager, spriteAtlas, blockColors, profiler);
+ }
+
+ @Inject(method = "apply", at = @At(shift = Shift.BEFORE, value = "INVOKE", target = Signatures.Profiler_swap, ordinal = 0))
+ protected void patchwork_apply_swap(ModelLoader modelLoader, ResourceManager resourceManager, Profiler profiler, CallbackInfo ci) {
+ BakedModelManager me = (BakedModelManager) (Object) this;
+ ModelEventDispatcher.onModelBake(me, models, (net.minecraftforge.client.model.ModelLoader) modelLoader);
+ }
+}
diff --git a/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinModelLoader.java b/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinModelLoader.java
new file mode 100644
index 00000000..fc082222
--- /dev/null
+++ b/patchwork-model-loader/src/main/java/net/patchworkmc/mixin/modelloader/MixinModelLoader.java
@@ -0,0 +1,89 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.modelloader;
+
+import java.util.Map;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+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 org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.Slice;
+
+import net.minecraft.client.render.model.ModelLoader;
+import net.minecraft.client.render.model.UnbakedModel;
+import net.minecraft.client.util.ModelIdentifier;
+import net.minecraft.util.Identifier;
+
+import net.patchworkmc.impl.modelloader.Signatures;
+import net.patchworkmc.impl.modelloader.SpecialModelProvider;
+
+@Mixin(ModelLoader.class)
+public abstract class MixinModelLoader implements SpecialModelProvider {
+ @Unique
+ private static final ModelIdentifier TRIDENT_INV = new ModelIdentifier("minecraft:trident_in_hand#inventory");
+ @Unique
+ private static final Logger LOGGER = LogManager.getLogger(ModelLoader.class);
+
+ @Shadow
+ @Final
+ private Map modelsToBake;
+
+ @Shadow
+ @Final
+ private Map unbakedModels;
+
+ @Unique
+ private void patchwork$loadSpecialModel() {
+ for (Identifier id : getSpecialModels()) {
+ ModelLoader me = (ModelLoader) (Object) this;
+ UnbakedModel iunbakedmodel = me.getOrLoadModel(id);
+ this.unbakedModels.put(id, iunbakedmodel);
+ this.modelsToBake.put(id, iunbakedmodel);
+ }
+ }
+
+ @Shadow
+ private void addModel(ModelIdentifier modelId) { }
+
+ /**
+ * Due to the limitations of mixin, when targeting a constructor, we cannot use injection points other than "TAIL".
+ * There are multiple occurrences of addModel in the constructor, Forge inserts the patch after adding model for the trident.
+ * Here we just do another check to ensure that the injection point is correct.
+ * @param me
+ * @param modelId
+ */
+ @Redirect(slice = @Slice(from = @At(value = "INVOKE_STRING", target = Signatures.Profiler_swap, args = "ldc=special")),
+ method = "", at = @At(value = "INVOKE", target = Signatures.ModelLoader_addModel, ordinal = 0))
+ private void patchwork_addModel_return(ModelLoader me, ModelIdentifier modelId) {
+ addModel(modelId);
+
+ if (modelId.equals(TRIDENT_INV)) {
+ LOGGER.debug("Patchwork is loading special models for Forge mods");
+ patchwork$loadSpecialModel();
+ } else {
+ LOGGER.warn("Patchwork was unable to load special models for Forge mods");
+ }
+ }
+}
diff --git a/patchwork-model-loader/src/main/resources/assets/patchwork-model-loader/icon.png b/patchwork-model-loader/src/main/resources/assets/patchwork-model-loader/icon.png
new file mode 100644
index 00000000..de75d2fb
Binary files /dev/null and b/patchwork-model-loader/src/main/resources/assets/patchwork-model-loader/icon.png differ
diff --git a/patchwork-model-loader/src/main/resources/fabric.mod.json b/patchwork-model-loader/src/main/resources/fabric.mod.json
new file mode 100644
index 00000000..87194392
--- /dev/null
+++ b/patchwork-model-loader/src/main/resources/fabric.mod.json
@@ -0,0 +1,27 @@
+{
+ "schemaVersion": 1,
+ "id": "patchwork-model-loader",
+ "name": "Patchwork Model Loader",
+ "version": "${version}",
+ "license": "LGPL-2.1-only",
+ "icon": "assets/patchwork-model-loader/icon.png",
+ "contact": {
+ "issues": "https://github.com/PatchworkMC/patchwork-api/issues",
+ "sources": "https://github.com/PatchworkMC/patchwork-api"
+ },
+ "authors": [
+ "PatchworkMC"
+ ],
+ "depends": {
+ "patchwork-api-base": "*",
+ "patchwork-fml": "*"
+ },
+ "mixins": [
+ "patchwork-model-loader.mixins.json"
+ ],
+ "description": "Implementation of the Forge Model Loader.",
+ "custom": {
+ "modmenu:api": true,
+ "modmenu:parent": "patchwork"
+ }
+}
diff --git a/patchwork-model-loader/src/main/resources/patchwork-model-loader.mixins.json b/patchwork-model-loader/src/main/resources/patchwork-model-loader.mixins.json
new file mode 100644
index 00000000..9bd996d7
--- /dev/null
+++ b/patchwork-model-loader/src/main/resources/patchwork-model-loader.mixins.json
@@ -0,0 +1,12 @@
+{
+ "required": true,
+ "package": "net.patchworkmc.mixin.modelloader",
+ "compatibilityLevel": "JAVA_8",
+ "client": [
+ "MixinBakedModelManager",
+ "MixinModelLoader"
+ ],
+ "injectors": {
+ "defaultRequire": 1
+ }
+}
diff --git a/patchwork-networking-messages/build.gradle b/patchwork-networking-messages/build.gradle
index 9fad475e..e1019e69 100644
--- a/patchwork-networking-messages/build.gradle
+++ b/patchwork-networking-messages/build.gradle
@@ -1,7 +1,7 @@
archivesBaseName = "patchwork-networking-messages"
-version = getSubprojectVersion(project, "0.2.0")
+version = getSubprojectVersion(project, "0.3.1")
dependencies {
- compile project(path: ':patchwork-fml', configuration: 'dev')
- compile project(path: ':patchwork-networking', configuration: 'dev')
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+ implementation project(path: ':patchwork-networking', configuration: 'dev')
}
diff --git a/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessages.java b/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessages.java
index d1b0ae9a..1db5de7a 100644
--- a/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessages.java
+++ b/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessages.java
@@ -37,36 +37,20 @@
import net.minecraft.util.PacketByteBuf;
import net.fabricmc.api.ModInitializer;
-import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
import net.fabricmc.fabric.api.network.ServerSidePacketRegistry;
public class PatchworkPlayNetworkingMessages implements ModInitializer, MessageFactory {
- private static final Logger LOGGER = LogManager.getLogger("patchwork-networking");
- private static final Identifier IDENTIFIER = new Identifier("fml", "play");
- private static final NetworkChannelVersion VERSION = new NetworkChannelVersion("FML2", version -> true, version -> true);
- private static final short SPAWN_ENTITY = 0;
- private static final short OPEN_CONTAINER = 1;
+ public static final Logger LOGGER = LogManager.getLogger("patchwork-networking");
+ public static final Identifier IDENTIFIER = new Identifier("fml", "play");
+ public static final NetworkChannelVersion VERSION = new NetworkChannelVersion("FML2", version -> true, version -> true);
+ public static final short SPAWN_ENTITY = 0;
+ public static final short OPEN_CONTAINER = 1;
@Override
public void onInitialize() {
PatchworkNetworking.getVersionManager().createChannel(IDENTIFIER, VERSION);
PatchworkNetworking.setFactory(this);
- // TODO: Move to client initializer
- ClientSidePacketRegistry.INSTANCE.register(IDENTIFIER, (context, buf) -> {
- int id = buf.readUnsignedByte();
-
- if (id == SPAWN_ENTITY) {
- FMLPlayMessages.SpawnEntity spawn = FMLPlayMessages.SpawnEntity.decode(buf);
- FMLPlayMessages.SpawnEntity.handle(spawn, context);
- } else if (id == OPEN_CONTAINER) {
- FMLPlayMessages.OpenContainer open = FMLPlayMessages.OpenContainer.decode(buf);
- FMLPlayMessages.OpenContainer.handle(open, context);
- } else {
- LOGGER.warn("Received an unknown fml:play message with an id of {} and a payload of {} bytes", id, buf.readableBytes());
- }
- });
-
ServerSidePacketRegistry.INSTANCE.register(IDENTIFIER, (context, buf) -> {
LOGGER.warn("Received an fml:play on the server, this should not happen! Kicking the offending client.");
diff --git a/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessagesClient.java b/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessagesClient.java
new file mode 100644
index 00000000..1c5a5825
--- /dev/null
+++ b/patchwork-networking-messages/src/main/java/net/patchworkmc/impl/networking/PatchworkPlayNetworkingMessagesClient.java
@@ -0,0 +1,45 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.networking;
+
+import net.minecraftforge.fml.network.FMLPlayMessages;
+
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.network.ClientSidePacketRegistry;
+
+public class PatchworkPlayNetworkingMessagesClient implements ClientModInitializer {
+ @Override
+ public void onInitializeClient() {
+ // TODO: Move to client initializer
+ ClientSidePacketRegistry.INSTANCE.register(PatchworkPlayNetworkingMessages.IDENTIFIER, (context, buf) -> {
+ int id = buf.readUnsignedByte();
+
+ if (id == PatchworkPlayNetworkingMessages.SPAWN_ENTITY) {
+ FMLPlayMessages.SpawnEntity spawn = FMLPlayMessages.SpawnEntity.decode(buf);
+ FMLPlayMessages.SpawnEntity.handle(spawn, context);
+ } else if (id == PatchworkPlayNetworkingMessages.OPEN_CONTAINER) {
+ FMLPlayMessages.OpenContainer open = FMLPlayMessages.OpenContainer.decode(buf);
+ FMLPlayMessages.OpenContainer.handle(open, context);
+ } else {
+ PatchworkPlayNetworkingMessages.LOGGER.warn("Received an unknown fml:play message with an id of {} and a payload of {} bytes", id, buf.readableBytes());
+ }
+ });
+ }
+}
diff --git a/patchwork-networking-messages/src/main/java/net/patchworkmc/mixin/networking/MixinServerPlayerEntity.java b/patchwork-networking-messages/src/main/java/net/patchworkmc/mixin/networking/MixinServerPlayerEntity.java
index 55c8ec24..f43fcc2d 100644
--- a/patchwork-networking-messages/src/main/java/net/patchworkmc/mixin/networking/MixinServerPlayerEntity.java
+++ b/patchwork-networking-messages/src/main/java/net/patchworkmc/mixin/networking/MixinServerPlayerEntity.java
@@ -20,29 +20,23 @@
package net.patchworkmc.mixin.networking;
import org.spongepowered.asm.mixin.Mixin;
-import org.spongepowered.asm.mixin.gen.Accessor;
-import org.spongepowered.asm.mixin.gen.Invoker;
+import org.spongepowered.asm.mixin.Shadow;
import net.minecraft.server.network.ServerPlayerEntity;
import net.patchworkmc.impl.networking.ContainerSyncAccess;
@Mixin(ServerPlayerEntity.class)
-public class MixinServerPlayerEntity implements ContainerSyncAccess {
- @Accessor
- private int getContainerSyncId() {
- throw new AssertionError("Mixin not applied");
- }
-
- @Invoker
- private void invokeIncrementContainerSyncId() {
- throw new AssertionError("Mixin not applied");
- }
+public abstract class MixinServerPlayerEntity implements ContainerSyncAccess {
+ @Shadow
+ private int containerSyncId;
+ @Shadow
+ protected abstract void incrementContainerSyncId();
@Override
public int patchwork$getNewContainerSyncId() {
- invokeIncrementContainerSyncId();
+ incrementContainerSyncId();
- return getContainerSyncId();
+ return containerSyncId;
}
}
diff --git a/patchwork-networking-messages/src/main/resources/assets/patchwork-networking-messages/icon.png b/patchwork-networking-messages/src/main/resources/assets/patchwork-networking-messages/icon.png
new file mode 100644
index 00000000..de75d2fb
Binary files /dev/null and b/patchwork-networking-messages/src/main/resources/assets/patchwork-networking-messages/icon.png differ
diff --git a/patchwork-networking-messages/src/main/resources/fabric.mod.json b/patchwork-networking-messages/src/main/resources/fabric.mod.json
index 6552e4b2..45f3390f 100644
--- a/patchwork-networking-messages/src/main/resources/fabric.mod.json
+++ b/patchwork-networking-messages/src/main/resources/fabric.mod.json
@@ -13,14 +13,15 @@
"PatchworkMC"
],
"depends": {
- "fabricloader": ">=0.8.4",
- "fabric-networking-v0": "*",
- "patchwork-fml": "*",
+ "patchwork-api-base": "*",
"patchwork-networking": "*"
},
"entrypoints": {
"main": [
"net.patchworkmc.impl.networking.PatchworkPlayNetworkingMessages"
+ ],
+ "client": [
+ "net.patchworkmc.impl.networking.PatchworkPlayNetworkingMessagesClient"
]
},
"mixins": [
diff --git a/patchwork-networking-messages/src/main/resources/patchwork-networking-messages.mixins.json b/patchwork-networking-messages/src/main/resources/patchwork-networking-messages.mixins.json
index 0cd067e8..37fda991 100644
--- a/patchwork-networking-messages/src/main/resources/patchwork-networking-messages.mixins.json
+++ b/patchwork-networking-messages/src/main/resources/patchwork-networking-messages.mixins.json
@@ -4,7 +4,8 @@
"compatibilityLevel": "JAVA_8",
"mixins": [
"MixinEntityType",
- "MixinEntityTypeBuilder"
+ "MixinEntityTypeBuilder",
+ "MixinServerPlayerEntity"
],
"injectors": {
"defaultRequire": 1
diff --git a/patchwork-networking/build.gradle b/patchwork-networking/build.gradle
index fa90b140..8598ae7f 100644
--- a/patchwork-networking/build.gradle
+++ b/patchwork-networking/build.gradle
@@ -1,6 +1,7 @@
archivesBaseName = "patchwork-networking"
-version = getSubprojectVersion(project, "0.2.0")
+version = getSubprojectVersion(project, "0.4.0")
dependencies {
- compile project(path: ':patchwork-fml', configuration: 'dev')
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+ implementation project(path: ':patchwork-fml', configuration: 'dev')
}
diff --git a/patchwork-networking/src/main/java/net/minecraftforge/client/event/ClientPlayerNetworkEvent.java b/patchwork-networking/src/main/java/net/minecraftforge/client/event/ClientPlayerNetworkEvent.java
new file mode 100644
index 00000000..a6c90336
--- /dev/null
+++ b/patchwork-networking/src/main/java/net/minecraftforge/client/event/ClientPlayerNetworkEvent.java
@@ -0,0 +1,104 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.client.event;
+
+import net.minecraftforge.eventbus.api.Event;
+
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.network.ClientConnection;
+
+/**
+ * Client-side events fired on changes to player connectivity.
+ */
+public class ClientPlayerNetworkEvent extends Event {
+ private final ClientPlayerInteractionManager playerInteractionManager;
+ private final ClientPlayerEntity player;
+ private final ClientConnection clientConnection;
+
+ ClientPlayerNetworkEvent(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity player, final ClientConnection clientConnection) {
+ this.playerInteractionManager = interactionManager;
+ this.player = player;
+ this.clientConnection = clientConnection;
+ }
+
+ /**
+ * @return The ClientPlayerInteractionManager instance for the client side.
+ */
+ public ClientPlayerInteractionManager getController() {
+ return this.playerInteractionManager;
+ }
+
+ /**
+ * @return The player instance, if present (otherwise, returns null).
+ */
+ public ClientPlayerEntity getPlayer() {
+ return this.player;
+ }
+
+ /**
+ * @return The network connection, if present (otherwise, returns null).
+ */
+ public ClientConnection getNetworkManager() {
+ return this.clientConnection;
+ }
+
+ /**
+ * Fired when the player logs out.
+ *
+ * Note: This might also be fired when a new integrated server is being created.
+ */
+ public static class LoggedInEvent extends ClientPlayerNetworkEvent {
+ public LoggedInEvent(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity player, final ClientConnection clientConnection) {
+ super(interactionManager, player, clientConnection);
+ }
+ }
+
+ /**
+ * Fired when the player logs out.
+ *
+ * Note: This might also fire when a new integrated server is being created.
+ */
+ public static class LoggedOutEvent extends ClientPlayerNetworkEvent {
+ public LoggedOutEvent(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity player, final ClientConnection clientConnection) {
+ super(interactionManager, player, clientConnection);
+ }
+ }
+
+ /**
+ * Fired when the player object respawns, such as dimension changes.
+ */
+ public static class RespawnEvent extends ClientPlayerNetworkEvent {
+ private final ClientPlayerEntity oldPlayer;
+
+ public RespawnEvent(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity oldPlayer, final ClientPlayerEntity newPlayer, final ClientConnection clientConnection) {
+ super(interactionManager, newPlayer, clientConnection);
+ this.oldPlayer = oldPlayer;
+ }
+
+ public ClientPlayerEntity getOldPlayer() {
+ return this.oldPlayer;
+ }
+
+ public ClientPlayerEntity getNewPlayer() {
+ return super.getPlayer();
+ }
+ }
+}
diff --git a/patchwork-networking/src/main/java/net/patchworkmc/impl/networking/ClientNetworkingEvents.java b/patchwork-networking/src/main/java/net/patchworkmc/impl/networking/ClientNetworkingEvents.java
new file mode 100644
index 00000000..2545045a
--- /dev/null
+++ b/patchwork-networking/src/main/java/net/patchworkmc/impl/networking/ClientNetworkingEvents.java
@@ -0,0 +1,41 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.impl.networking;
+
+import net.minecraftforge.client.event.ClientPlayerNetworkEvent;
+import net.minecraftforge.common.MinecraftForge;
+
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.network.ClientConnection;
+
+public class ClientNetworkingEvents {
+ public static void firePlayerLogin(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity player, final ClientConnection clientConnection) {
+ MinecraftForge.EVENT_BUS.post(new ClientPlayerNetworkEvent.LoggedInEvent(interactionManager, player, clientConnection));
+ }
+
+ public static void firePlayerLogout(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity player) {
+ MinecraftForge.EVENT_BUS.post(new ClientPlayerNetworkEvent.LoggedOutEvent(interactionManager, player, player != null ? player.networkHandler != null ? player.networkHandler.getConnection() : null : null));
+ }
+
+ public static void firePlayerRespawn(final ClientPlayerInteractionManager interactionManager, final ClientPlayerEntity oldPlayer, final ClientPlayerEntity newPlayer, final ClientConnection clientConnection) {
+ MinecraftForge.EVENT_BUS.post(new ClientPlayerNetworkEvent.RespawnEvent(interactionManager, oldPlayer, newPlayer, clientConnection));
+ }
+}
diff --git a/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/client/MixinMinecraftClient.java b/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/client/MixinMinecraftClient.java
new file mode 100644
index 00000000..0a541d38
--- /dev/null
+++ b/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/client/MixinMinecraftClient.java
@@ -0,0 +1,47 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.patchworkmc.mixin.networking.client;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.network.ClientPlayerInteractionManager;
+
+import net.patchworkmc.impl.networking.ClientNetworkingEvents;
+
+@Mixin(MinecraftClient.class)
+public class MixinMinecraftClient {
+ @Shadow
+ public ClientPlayerInteractionManager interactionManager;
+
+ @Shadow
+ public ClientPlayerEntity player;
+
+ @Inject(method = "disconnect(Lnet/minecraft/client/gui/screen/Screen;)V",
+ at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/GameRenderer;reset()V", shift = At.Shift.AFTER))
+ public void patchwork$hookDisconnect(CallbackInfo ci) {
+ ClientNetworkingEvents.firePlayerLogout(this.interactionManager, this.player);
+ }
+}
diff --git a/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/handler/MixinClientPlayNetworkHandler.java b/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/handler/MixinClientPlayNetworkHandler.java
index 812e17a5..4fcd7104 100644
--- a/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/handler/MixinClientPlayNetworkHandler.java
+++ b/patchwork-networking/src/main/java/net/patchworkmc/mixin/networking/handler/MixinClientPlayNetworkHandler.java
@@ -26,13 +26,23 @@
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.LocalCapture;
+import net.minecraft.client.MinecraftClient;
import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.client.network.ClientPlayerEntity;
import net.minecraft.network.ClientConnection;
import net.minecraft.network.packet.s2c.play.CustomPayloadS2CPacket;
+import net.minecraft.network.packet.s2c.play.PlayerRespawnS2CPacket;
+import net.minecraft.world.dimension.DimensionType;
+
+import net.patchworkmc.impl.networking.ClientNetworkingEvents;
@Mixin(ClientPlayNetworkHandler.class)
public abstract class MixinClientPlayNetworkHandler {
+ @Shadow
+ private MinecraftClient client;
+
@Shadow
public abstract ClientConnection getConnection();
@@ -42,4 +52,16 @@ public abstract class MixinClientPlayNetworkHandler {
callback.cancel();
}
}
+
+ @Inject(method = "onGameJoin", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/packet/s2c/play/GameJoinS2CPacket;getEntityId()I"))
+ public void patchwork$hookGameJoin(CallbackInfo ci) {
+ ClientNetworkingEvents.firePlayerLogin(this.client.interactionManager, this.client.player, this.client.getNetworkHandler().getConnection());
+ }
+
+ @Inject(method = "onPlayerRespawn",
+ at = @At(value = "INVOKE", target = "Lnet/minecraft/client/world/ClientWorld;addPlayer(ILnet/minecraft/client/network/AbstractClientPlayerEntity;)V"),
+ locals = LocalCapture.CAPTURE_FAILHARD)
+ public void patchwork$hookPlayerRespawn(PlayerRespawnS2CPacket packet, CallbackInfo ci, DimensionType dimensionType, ClientPlayerEntity clientPlayerEntity, int i, String string, ClientPlayerEntity clientPlayerEntity2) {
+ ClientNetworkingEvents.firePlayerRespawn(this.client.interactionManager, clientPlayerEntity, clientPlayerEntity2, clientPlayerEntity2.networkHandler.getConnection());
+ }
}
diff --git a/patchwork-networking/src/main/resources/fabric.mod.json b/patchwork-networking/src/main/resources/fabric.mod.json
index d27421ae..f5a3fbdc 100644
--- a/patchwork-networking/src/main/resources/fabric.mod.json
+++ b/patchwork-networking/src/main/resources/fabric.mod.json
@@ -13,12 +13,12 @@
"PatchworkMC"
],
"depends": {
- "fabricloader": ">=0.8.4",
- "fabric-networking-v0": "*",
+ "patchwork-api-base": "*",
"patchwork-fml": "*"
},
"mixins": [
"patchwork-networking.accessor.mixins.json",
+ "patchwork-networking.client.mixins.json",
"patchwork-networking.handler.mixins.json",
"patchwork-networking.packet.mixins.json"
],
diff --git a/patchwork-networking/src/main/resources/patchwork-networking.client.mixins.json b/patchwork-networking/src/main/resources/patchwork-networking.client.mixins.json
new file mode 100644
index 00000000..3eb9d42c
--- /dev/null
+++ b/patchwork-networking/src/main/resources/patchwork-networking.client.mixins.json
@@ -0,0 +1,11 @@
+{
+ "required": true,
+ "package": "net.patchworkmc.mixin.networking.client",
+ "compatibilityLevel": "JAVA_8",
+ "client": [
+ "MixinMinecraftClient"
+ ],
+ "injectors": {
+ "defaultRequire": 1
+ }
+}
diff --git a/patchwork-recipes/build.gradle b/patchwork-recipes/build.gradle
index f13ee8e0..ad6c0ed0 100644
--- a/patchwork-recipes/build.gradle
+++ b/patchwork-recipes/build.gradle
@@ -1,2 +1,6 @@
archivesBaseName = "patchwork-recipes"
-version = getSubprojectVersion(project, "0.2.0")
+version = getSubprojectVersion(project, "0.3.0")
+
+dependencies {
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+}
diff --git a/patchwork-recipes/src/main/resources/fabric.mod.json b/patchwork-recipes/src/main/resources/fabric.mod.json
index 329f85ac..176a8769 100644
--- a/patchwork-recipes/src/main/resources/fabric.mod.json
+++ b/patchwork-recipes/src/main/resources/fabric.mod.json
@@ -11,7 +11,7 @@
"icon": "assets/patchwork-recipes/icon.png",
"environment": "*",
"depends": {
- "fabricloader": ">=0.8.4",
+ "patchwork-api-base": "*",
"fabric": "*"
},
"mixins": [
diff --git a/patchwork-registries/build.gradle b/patchwork-registries/build.gradle
index 2d6ea957..9f39bae5 100644
--- a/patchwork-registries/build.gradle
+++ b/patchwork-registries/build.gradle
@@ -1,6 +1,11 @@
archivesBaseName = "patchwork-registries"
-version = getSubprojectVersion(project, "0.3.0")
+version = getSubprojectVersion(project, "0.4.0")
dependencies {
- compile project(path: ':patchwork-fml', configuration: 'dev')
+ implementation project(path: ':patchwork-api-base', configuration: 'dev')
+ implementation project(path: ':patchwork-fml', configuration: 'dev')
+}
+
+loom {
+ accessWidener "src/main/resources/patchwork-registries.accesswidener"
}
diff --git a/patchwork-registries/src/main/java/net/minecraftforge/fml/RegistryObject.java b/patchwork-registries/src/main/java/net/minecraftforge/fml/RegistryObject.java
new file mode 100644
index 00000000..9024333b
--- /dev/null
+++ b/patchwork-registries/src/main/java/net/minecraftforge/fml/RegistryObject.java
@@ -0,0 +1,296 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.fml;
+
+import java.util.Objects;
+import java.util.Optional;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.stream.Stream;
+
+import javax.annotation.Nullable;
+
+import net.minecraftforge.registries.IForgeRegistry;
+import net.minecraftforge.registries.IForgeRegistryEntry;
+import net.minecraftforge.registries.RegistryManager;
+
+import net.minecraft.util.Identifier;
+
+import net.patchworkmc.api.registries.ObjectHolderRegistry;
+
+public final class RegistryObject> implements Supplier {
+ private static RegistryObject EMPTY = new RegistryObject<>();
+ private final Identifier name;
+ @Nullable
+ private T value;
+
+ private RegistryObject() {
+ this.name = null;
+ }
+
+ private > RegistryObject(Identifier name, Supplier> registryType) {
+ this(name, RegistryManager.ACTIVE.getRegistry(registryType.get()));
+ }
+
+ @SuppressWarnings("unchecked")
+ private > RegistryObject(Identifier name, IForgeRegistry registry) {
+ if (registry == null) {
+ throw new IllegalArgumentException("Invalid registry argument, must not be null");
+ }
+
+ this.name = name;
+ ObjectHolderRegistry.INSTANCE.register(registry.getRegistrySuperType(), name.getNamespace(), name.getPath(), value -> {
+ this.value = (T) value;
+ });
+ }
+
+ @Deprecated
+ public static , U extends T> RegistryObject of(final String name, Supplier> registryType) {
+ return of(new Identifier(name), registryType);
+ }
+
+ public static , U extends T> RegistryObject of(final Identifier name, Supplier> registryType) {
+ return new RegistryObject<>(name, registryType);
+ }
+
+ @Deprecated
+ public static , U extends T> RegistryObject of(final String name, IForgeRegistry registry) {
+ return of(new Identifier(name), registry);
+ }
+
+ public static , U extends T> RegistryObject of(final Identifier name, IForgeRegistry registry) {
+ return new RegistryObject<>(name, registry);
+ }
+
+ private static > RegistryObject empty() {
+ @SuppressWarnings("unchecked")
+ RegistryObject t = (RegistryObject) EMPTY;
+ return t;
+ }
+
+ /**
+ * Directly retrieves the wrapped Registry Object. This value will automatically be updated when the backing registry is updated.
+ */
+ @Nullable
+ @Override
+ public T get() {
+ return this.value;
+ }
+
+ public void updateReference(IForgeRegistry registry) {
+ this.value = registry.getValue(getId());
+ }
+
+ public Identifier getId() {
+ return this.name;
+ }
+
+ /**
+ * @deprecated Prefer {@link #getId()}
+ */
+ @Deprecated
+ public String getName() {
+ return getId().toString();
+ }
+
+ public Stream stream() {
+ return isPresent() ? Stream.of(get()) : Stream.of();
+ }
+
+ /**
+ * Return {@code true} if there is a mod object present, otherwise {@code false}.
+ *
+ * @return {@code true} if there is a mod object present, otherwise {@code false}
+ */
+ public boolean isPresent() {
+ return get() != null;
+ }
+
+ /**
+ * If a mod object is present, invoke the specified consumer with the object,
+ * otherwise do nothing.
+ *
+ * @param consumer block to be executed if a mod object is present
+ * @throws NullPointerException if mod object is present and {@code consumer} is
+ * null
+ */
+ public void ifPresent(Consumer consumer) {
+ if (get() != null) {
+ consumer.accept(get());
+ }
+ }
+
+ /**
+ * If a mod object is present, and the mod object matches the given predicate,
+ * return an {@code RegistryObject} describing the value, otherwise return an
+ * empty {@code RegistryObject}.
+ *
+ * @param predicate a predicate to apply to the mod object, if present
+ * @return an {@code RegistryObject} describing the value of this {@code RegistryObject}
+ * if a mod object is present and the mod object matches the given predicate,
+ * otherwise an empty {@code RegistryObject}
+ * @throws NullPointerException if the predicate is null
+ */
+ public RegistryObject filter(Predicate predicate) {
+ Objects.requireNonNull(predicate);
+
+ if (!isPresent()) {
+ return this;
+ } else {
+ return predicate.test(get()) ? this : empty();
+ }
+ }
+
+ /**
+ * If a mod object is present, apply the provided mapping function to it,
+ * and if the result is non-null, return an {@code Optional} describing the
+ * result. Otherwise return an empty {@code Optional}.
+ *
+ * @param The type of the result of the mapping function
+ * @param mapper a mapping function to apply to the mod object, if present
+ * @return an {@code Optional} describing the result of applying a mapping
+ * function to the mod object of this {@code RegistryObject}, if a mod object is present,
+ * otherwise an empty {@code Optional}
+ * @throws NullPointerException if the mapping function is null
+ * @apiNote This method supports post-processing on optional values, without
+ * the need to explicitly check for a return status.
+ */
+ public Optional map(Function mapper) {
+ Objects.requireNonNull(mapper);
+
+ if (!isPresent()) {
+ return Optional.empty();
+ } else {
+ return Optional.ofNullable(mapper.apply(get()));
+ }
+ }
+
+ /**
+ * If a value is present, apply the provided {@code Optional}-bearing
+ * mapping function to it, return that result, otherwise return an empty
+ * {@code Optional}. This method is similar to {@link #map(Function)},
+ * but the provided mapper is one whose result is already an {@code Optional},
+ * and if invoked, {@code flatMap} does not wrap it with an additional
+ * {@code Optional}.
+ *
+ * @param The type parameter to the {@code Optional} returned by
+ * @param mapper a mapping function to apply to the mod object, if present
+ * the mapping function
+ * @return the result of applying an {@code Optional}-bearing mapping
+ * function to the value of this {@code Optional}, if a value is present,
+ * otherwise an empty {@code Optional}
+ * @throws NullPointerException if the mapping function is null or returns
+ * a null result
+ */
+ public Optional flatMap(Function> mapper) {
+ Objects.requireNonNull(mapper);
+
+ if (!isPresent()) {
+ return Optional.empty();
+ } else {
+ return Objects.requireNonNull(mapper.apply(get()));
+ }
+ }
+
+ /**
+ * If a mod object is present, lazily apply the provided mapping function to it,
+ * returning a supplier for the transformed result. If this object is empty, or the
+ * mapping function returns {@code null}, the supplier will return {@code null}.
+ *
+ * @param The type of the result of the mapping function
+ * @param mapper A mapping function to apply to the mod object, if present
+ * @return A {@code Supplier} lazily providing the result of applying a mapping
+ * function to the mod object of this {@code RegistryObject}, if a mod object is present,
+ * otherwise a supplier returning {@code null}
+ * @throws NullPointerException if the mapping function is {@code null}
+ * @apiNote This method supports post-processing on optional values, without
+ * the need to explicitly check for a return status.
+ */
+ public Supplier lazyMap(Function mapper) {
+ Objects.requireNonNull(mapper);
+ return () -> isPresent() ? mapper.apply(get()) : null;
+ }
+
+ /**
+ * Return the mod object if present, otherwise return {@code other}.
+ *
+ * @param other the mod object to be returned if there is no mod object present, may
+ * be null
+ * @return the mod object, if present, otherwise {@code other}
+ */
+ public T orElse(T other) {
+ return isPresent() ? get() : other;
+ }
+
+ /**
+ * Return the mod object if present, otherwise invoke {@code other} and return
+ * the result of that invocation.
+ *
+ * @param other a {@code Supplier} whose result is returned if no mod object
+ * is present
+ * @return the mod object if present otherwise the result of {@code other.get()}
+ * @throws NullPointerException if mod object is not present and {@code other} is
+ * null
+ */
+ public T orElseGet(Supplier other) {
+ return isPresent() ? get() : other.get();
+ }
+
+ /**
+ * Return the contained mod object, if present, otherwise throw an exception
+ * to be created by the provided supplier.
+ *
+ * @param Type of the exception to be thrown
+ * @param exceptionSupplier The supplier which will return the exception to
+ * be thrown
+ * @return the present mod object
+ * @throws X if there is no mod object present
+ * @throws NullPointerException if no mod object is present and
+ * {@code exceptionSupplier} is null
+ * @apiNote A method reference to the exception constructor with an empty
+ * argument list can be used as the supplier. For example,
+ * {@code IllegalStateException::new}
+ */
+ public T orElseThrow(Supplier exceptionSupplier) throws X {
+ if (get() != null) {
+ return get();
+ } else {
+ throw exceptionSupplier.get();
+ }
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+
+ if (obj instanceof RegistryObject) {
+ return Objects.equals(((RegistryObject) obj).name, name);
+ }
+
+ return false;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(name);
+ }
+}
diff --git a/patchwork-registries/src/main/java/net/minecraftforge/fml/client/registry/ClientRegistry.java b/patchwork-registries/src/main/java/net/minecraftforge/fml/client/registry/ClientRegistry.java
index 41054f51..0fda3e3c 100644
--- a/patchwork-registries/src/main/java/net/minecraftforge/fml/client/registry/ClientRegistry.java
+++ b/patchwork-registries/src/main/java/net/minecraftforge/fml/client/registry/ClientRegistry.java
@@ -24,7 +24,6 @@
import net.minecraft.block.entity.BlockEntity;
import net.minecraft.client.options.KeyBinding;
-import net.minecraft.client.render.block.entity.BlockEntityRenderDispatcher;
import net.minecraft.client.render.block.entity.BlockEntityRenderer;
import net.minecraft.entity.Entity;
import net.minecraft.util.Identifier;
@@ -44,7 +43,7 @@ public class ClientRegistry {
*/
public static synchronized void bindTileEntitySpecialRenderer(Class tileEntityClass, BlockEntityRenderer specialRenderer) {
BlockEntityRendererRegistry.INSTANCE.register(tileEntityClass, specialRenderer);
- specialRenderer.setRenderManager(BlockEntityRenderDispatcher.INSTANCE);
+ // Done by Fabric API: specialRenderer.setRenderManager(BlockEntityRenderDispatcher.INSTANCE);
}
/**
diff --git a/patchwork-registries/src/main/java/net/minecraftforge/registries/DeferredRegister.java b/patchwork-registries/src/main/java/net/minecraftforge/registries/DeferredRegister.java
new file mode 100644
index 00000000..73a9eda0
--- /dev/null
+++ b/patchwork-registries/src/main/java/net/minecraftforge/registries/DeferredRegister.java
@@ -0,0 +1,104 @@
+/*
+ * Minecraft Forge, Patchwork Project
+ * Copyright (c) 2016-2020, 2019-2020
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation version 2.1
+ * of the License.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+package net.minecraftforge.registries;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Supplier;
+
+import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+
+import net.minecraft.util.Identifier;
+
+/**
+ * Utility class to help with managing registry entries.
+ * Maintains a list of all suppliers for entries and registers them during the proper Register event.
+ * Suppliers should return NEW instances every time.
+ *
+ * @param The base registry type, must be a concrete base class, do not use subclasses or wild cards.
+ */
+public class DeferredRegister> {
+ private final IForgeRegistry type;
+ private final String modid;
+ private final Map, Supplier> entries = new LinkedHashMap<>();
+ private final Set> entriesView = Collections.unmodifiableSet(entries.keySet());
+
+ public DeferredRegister(IForgeRegistry reg, String modid) {
+ this.type = reg;
+ this.modid = modid;
+ }
+
+ /**
+ * Adds a new supplier to the list of entries to be registered, and returns a RegistryObject that will be populated with the created entry automatically.
+ *
+ * @param name The new entry's name, it will automatically have the modid prefixed.
+ * @param sup A factory for the new entry, it should return a new instance every time it is called.
+ * @return A RegistryObject that will be updated with when the entries in the registry change.
+ */
+ @SuppressWarnings("unchecked")
+ public RegistryObject register(final String name, final Supplier sup) {
+ Objects.requireNonNull(name);
+ Objects.requireNonNull(sup);
+ final Identifier key = new Identifier(modid, name);
+ RegistryObject ret = RegistryObject.of(key, this.type);
+
+ if (entries.putIfAbsent((RegistryObject) ret, () -> (T) sup.get().setRegistryName(key)) != null) {
+ throw new IllegalArgumentException("Duplicate registration " + name);
+ }
+
+ return ret;
+ }
+
+ /**
+ * Adds our event handler to the specified event bus, this MUST be called in order for this class to function.
+ * See the example usage.
+ *
+ * @param bus The Mod Specific event bus.
+ */
+ public void register(IEventBus bus) {
+ bus.addListener(this::addEntries);
+ }
+
+ /**
+ * @return The unmodifiable view of registered entries. Useful for bulk operations on all values.
+ */
+ public Collection> getEntries() {
+ return entriesView;
+ }
+
+ private void addEntries(RegistryEvent.Register event) {
+ if (event.getGenericType() == this.type.getRegistrySuperType()) {
+ @SuppressWarnings("unchecked")
+ IForgeRegistry reg = (IForgeRegistry) event.getRegistry();
+
+ for (Entry, Supplier> e : entries.entrySet()) {
+ reg.register(e.getValue().get());
+ e.getKey().updateReference(reg);
+ }
+ }
+ }
+}
diff --git a/patchwork-registries/src/main/java/net/minecraftforge/registries/ForgeRegistryEntry.java b/patchwork-registries/src/main/java/net/minecraftforge/registries/ForgeRegistryEntry.java
index 9a77918d..02ccfab0 100644
--- a/patchwork-registries/src/main/java/net/minecraftforge/registries/ForgeRegistryEntry.java
+++ b/patchwork-registries/src/main/java/net/minecraftforge/registries/ForgeRegistryEntry.java
@@ -21,24 +21,24 @@
import net.minecraft.util.Identifier;
-public abstract class ForgeRegistryEntry implements IForgeRegistryEntry {
+public abstract class ForgeRegistryEntry> implements IForgeRegistryEntry {
private Identifier registryName;
@Override
- public final IForgeRegistryEntry setRegistryName(Identifier name) {
+ public final V setRegistryName(Identifier name) {
return setRegistryName(name.toString());
}
- public final IForgeRegistryEntry setRegistryName(String name) {
+ public final V setRegistryName(String name) {
if (getRegistryName() != null) {
throw new IllegalStateException("Attempted to set registry name with existing registry name! New: " + name + " Old: " + getRegistryName());
}
this.registryName = GameData.checkPrefix(name, true);
- return this;
+ return (V) this;
}
- public final IForgeRegistryEntry setRegistryName(String modID, String name) {
+ public final V setRegistryName(String modID, String name) {
return setRegistryName(modID + ":" + name);
}
diff --git a/patchwork-registries/src/main/java/net/minecraftforge/registries/IForgeRegistryEntry.java b/patchwork-registries/src/main/java/net/minecraftforge/registries/IForgeRegistryEntry.java
index 9834ab7f..6a79c353 100644
--- a/patchwork-registries/src/main/java/net/minecraftforge/registries/IForgeRegistryEntry.java
+++ b/patchwork-registries/src/main/java/net/minecraftforge/registries/IForgeRegistryEntry.java
@@ -39,7 +39,7 @@ public interface IForgeRegistryEntry