+ Added framework based on opensource works for player movement modification.

+ Added support for the builders ring to toggle Sneak on and Sprinting off while worn.
+ Added PlayerAPI.
% Moved COFH api files into the same package as PlayerAPI.

28 files changed, 38340 insertions, 0 deletions

diff --git a/src/Java/api/cofh/energy/EnergyStorage.java b/src/Java/api/cofh/energy/EnergyStorage.java
new file mode 100644
index 0000000000..a6ec363709
--- /dev/null
+++ b/src/Java/api/cofh/energy/EnergyStorage.java
@@ -0,0 +1,129 @@
+package api.cofh.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+
+public class EnergyStorage
+  implements IEnergyStorage
+{
+  protected int energy;
+  protected int capacity;
+  protected int maxReceive;
+  protected int maxExtract;
+  
+  public EnergyStorage(int capacity)
+  {
+    this(capacity, capacity, capacity);
+  }
+  
+  public EnergyStorage(int capacity, int maxTransfer)
+  {
+    this(capacity, maxTransfer, maxTransfer);
+  }
+  
+  public EnergyStorage(int capacity, int maxReceive, int maxExtract)
+  {
+    this.capacity = capacity;
+    this.maxReceive = maxReceive;
+    this.maxExtract = maxExtract;
+  }
+  
+  public EnergyStorage readFromNBT(NBTTagCompound nbt)
+  {
+    this.energy = nbt.getInteger("Energy");
+    if (this.energy > this.capacity) {
+      this.energy = this.capacity;
+    }
+    return this;
+  }
+  
+  public NBTTagCompound writeToNBT(NBTTagCompound nbt)
+  {
+    if (this.energy < 0) {
+      this.energy = 0;
+    }
+    nbt.setInteger("Energy", this.energy);
+    return nbt;
+  }
+  
+  public void setCapacity(int capacity)
+  {
+    this.capacity = capacity;
+    if (this.energy > capacity) {
+      this.energy = capacity;
+    }
+  }
+  
+  public void setMaxTransfer(int maxTransfer)
+  {
+    setMaxReceive(maxTransfer);
+    setMaxExtract(maxTransfer);
+  }
+  
+  public void setMaxReceive(int maxReceive)
+  {
+    this.maxReceive = maxReceive;
+  }
+  
+  public void setMaxExtract(int maxExtract)
+  {
+    this.maxExtract = maxExtract;
+  }
+  
+  public int getMaxReceive()
+  {
+    return this.maxReceive;
+  }
+  
+  public int getMaxExtract()
+  {
+    return this.maxExtract;
+  }
+  
+  public void setEnergyStored(int energy)
+  {
+    this.energy = energy;
+    if (this.energy > this.capacity) {
+      this.energy = this.capacity;
+    } else if (this.energy < 0) {
+      this.energy = 0;
+    }
+  }
+  
+  public void modifyEnergyStored(int energy)
+  {
+    this.energy += energy;
+    if (this.energy > this.capacity) {
+      this.energy = this.capacity;
+    } else if (this.energy < 0) {
+      this.energy = 0;
+    }
+  }
+  
+  public int receiveEnergy(int maxReceive, boolean simulate)
+  {
+    int energyReceived = Math.min(this.capacity - this.energy, Math.min(this.maxReceive, maxReceive));
+    if (!simulate) {
+      this.energy += energyReceived;
+    }
+    return energyReceived;
+  }
+  
+  public int extractEnergy(int maxExtract, boolean simulate)
+  {
+    int energyExtracted = Math.min(this.energy, Math.min(this.maxExtract, maxExtract));
+    if (!simulate) {
+      this.energy -= energyExtracted;
+    }
+    return energyExtracted;
+  }
+  
+  public int getEnergyStored()
+  {
+    return this.energy;
+  }
+  
+  public int getMaxEnergyStored()
+  {
+    return this.capacity;
+  }
+}
diff --git a/src/Java/api/cofh/energy/IEnergyConnection.java b/src/Java/api/cofh/energy/IEnergyConnection.java
new file mode 100644
index 0000000000..6351f7702d
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyConnection.java
@@ -0,0 +1,8 @@
+package api.cofh.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public abstract interface IEnergyConnection
+{
+  public abstract boolean canConnectEnergy(ForgeDirection paramForgeDirection);
+}
diff --git a/src/Java/api/cofh/energy/IEnergyContainerItem.java b/src/Java/api/cofh/energy/IEnergyContainerItem.java
new file mode 100644
index 0000000000..1f2b8c3c52
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyContainerItem.java
@@ -0,0 +1,14 @@
+package api.cofh.energy;
+
+import net.minecraft.item.ItemStack;
+
+public abstract interface IEnergyContainerItem
+{
+  public abstract int receiveEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean);
+  
+  public abstract int extractEnergy(ItemStack paramItemStack, int paramInt, boolean paramBoolean);
+  
+  public abstract int getEnergyStored(ItemStack paramItemStack);
+  
+  public abstract int getMaxEnergyStored(ItemStack paramItemStack);
+}
diff --git a/src/Java/api/cofh/energy/IEnergyHandler.java b/src/Java/api/cofh/energy/IEnergyHandler.java
new file mode 100644
index 0000000000..9d3385c4c0
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyHandler.java
@@ -0,0 +1,15 @@
+package api.cofh.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public abstract interface IEnergyHandler
+  extends IEnergyProvider, IEnergyReceiver
+{
+  public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean);
+  
+  public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean);
+  
+  public abstract int getEnergyStored(ForgeDirection paramForgeDirection);
+  
+  public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection);
+}
diff --git a/src/Java/api/cofh/energy/IEnergyProvider.java b/src/Java/api/cofh/energy/IEnergyProvider.java
new file mode 100644
index 0000000000..ace09db65e
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyProvider.java
@@ -0,0 +1,13 @@
+package api.cofh.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public abstract interface IEnergyProvider
+  extends IEnergyConnection
+{
+  public abstract int extractEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean);
+  
+  public abstract int getEnergyStored(ForgeDirection paramForgeDirection);
+  
+  public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection);
+}
diff --git a/src/Java/api/cofh/energy/IEnergyReceiver.java b/src/Java/api/cofh/energy/IEnergyReceiver.java
new file mode 100644
index 0000000000..68b071b028
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyReceiver.java
@@ -0,0 +1,13 @@
+package api.cofh.energy;
+
+import net.minecraftforge.common.util.ForgeDirection;
+
+public abstract interface IEnergyReceiver
+  extends IEnergyConnection
+{
+  public abstract int receiveEnergy(ForgeDirection paramForgeDirection, int paramInt, boolean paramBoolean);
+  
+  public abstract int getEnergyStored(ForgeDirection paramForgeDirection);
+  
+  public abstract int getMaxEnergyStored(ForgeDirection paramForgeDirection);
+}
diff --git a/src/Java/api/cofh/energy/IEnergyStorage.java b/src/Java/api/cofh/energy/IEnergyStorage.java
new file mode 100644
index 0000000000..bf999f8670
--- /dev/null
+++ b/src/Java/api/cofh/energy/IEnergyStorage.java
@@ -0,0 +1,12 @@
+package api.cofh.energy;
+
+public abstract interface IEnergyStorage
+{
+  public abstract int receiveEnergy(int paramInt, boolean paramBoolean);
+  
+  public abstract int extractEnergy(int paramInt, boolean paramBoolean);
+  
+  public abstract int getEnergyStored();
+  
+  public abstract int getMaxEnergyStored();
+}
diff --git a/src/Java/api/cofh/energy/ItemEnergyContainer.java b/src/Java/api/cofh/energy/ItemEnergyContainer.java
new file mode 100644
index 0000000000..f4da898919
--- /dev/null
+++ b/src/Java/api/cofh/energy/ItemEnergyContainer.java
@@ -0,0 +1,98 @@
+package api.cofh.energy;
+
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public class ItemEnergyContainer
+  extends Item
+  implements IEnergyContainerItem
+{
+  protected int capacity;
+  protected int maxReceive;
+  protected int maxExtract;
+  
+  public ItemEnergyContainer() {}
+  
+  public ItemEnergyContainer(int capacity)
+  {
+    this(capacity, capacity, capacity);
+  }
+  
+  public ItemEnergyContainer(int capacity, int maxTransfer)
+  {
+    this(capacity, maxTransfer, maxTransfer);
+  }
+  
+  public ItemEnergyContainer(int capacity, int maxReceive, int maxExtract)
+  {
+    this.capacity = capacity;
+    this.maxReceive = maxReceive;
+    this.maxExtract = maxExtract;
+  }
+  
+  public ItemEnergyContainer setCapacity(int capacity)
+  {
+    this.capacity = capacity;
+    return this;
+  }
+  
+  public void setMaxTransfer(int maxTransfer)
+  {
+    setMaxReceive(maxTransfer);
+    setMaxExtract(maxTransfer);
+  }
+  
+  public void setMaxReceive(int maxReceive)
+  {
+    this.maxReceive = maxReceive;
+  }
+  
+  public void setMaxExtract(int maxExtract)
+  {
+    this.maxExtract = maxExtract;
+  }
+  
+  public int receiveEnergy(ItemStack container, int maxReceive, boolean simulate)
+  {
+    if (container.stackTagCompound == null) {
+      container.stackTagCompound = new NBTTagCompound();
+    }
+    int energy = container.stackTagCompound.getInteger("Energy");
+    int energyReceived = Math.min(this.capacity - energy, Math.min(this.maxReceive, maxReceive));
+    if (!simulate)
+    {
+      energy += energyReceived;
+      container.stackTagCompound.setInteger("Energy", energy);
+    }
+    return energyReceived;
+  }
+  
+  public int extractEnergy(ItemStack container, int maxExtract, boolean simulate)
+  {
+    if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) {
+      return 0;
+    }
+    int energy = container.stackTagCompound.getInteger("Energy");
+    int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
+    if (!simulate)
+    {
+      energy -= energyExtracted;
+      container.stackTagCompound.setInteger("Energy", energy);
+    }
+    return energyExtracted;
+  }
+  
+  public int getEnergyStored(ItemStack container)
+  {
+    if ((container.stackTagCompound == null) || (!container.stackTagCompound.hasKey("Energy"))) {
+      return 0;
+    }
+    return container.stackTagCompound.getInteger("Energy");
+  }
+  
+  public int getMaxEnergyStored(ItemStack container)
+  {
+    return this.capacity;
+  }
+}
diff --git a/src/Java/api/cofh/energy/TileEnergyHandler.java b/src/Java/api/cofh/energy/TileEnergyHandler.java
new file mode 100644
index 0000000000..606b0ba44b
--- /dev/null
+++ b/src/Java/api/cofh/energy/TileEnergyHandler.java
@@ -0,0 +1,49 @@
+package api.cofh.energy;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraftforge.common.util.ForgeDirection;
+
+public class TileEnergyHandler
+  extends TileEntity
+  implements IEnergyHandler
+{
+  protected EnergyStorage storage = new EnergyStorage(32000);
+  
+  public void readFromNBT(NBTTagCompound nbt)
+  {
+    super.readFromNBT(nbt);
+    this.storage.readFromNBT(nbt);
+  }
+  
+  public void writeToNBT(NBTTagCompound nbt)
+  {
+    super.writeToNBT(nbt);
+    this.storage.writeToNBT(nbt);
+  }
+  
+  public boolean canConnectEnergy(ForgeDirection from)
+  {
+    return true;
+  }
+  
+  public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
+  {
+    return this.storage.receiveEnergy(maxReceive, simulate);
+  }
+  
+  public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
+  {
+    return this.storage.extractEnergy(maxExtract, simulate);
+  }
+  
+  public int getEnergyStored(ForgeDirection from)
+  {
+    return this.storage.getEnergyStored();
+  }
+  
+  public int getMaxEnergyStored(ForgeDirection from)
+  {
+    return this.storage.getMaxEnergyStored();
+  }
+}
diff --git a/src/Java/api/player/client/ClientPlayerAPI.java b/src/Java/api/player/client/ClientPlayerAPI.java
new file mode 100644
index 0000000000..d421868b9a
--- /dev/null
+++ b/src/Java/api/player/client/ClientPlayerAPI.java
@@ -0,0 +1,7354 @@
+// ==================================================================
+// This file is part of Player API.
+//
+// Player API 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, either version 3 of the
+// License, or (at your option) any later version.
+//
+// Player API 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 and the GNU General Public License along with Player API.
+// If not, see <http://www.gnu.org/licenses/>.
+// ==================================================================
+
+package api.player.client;
+
+import java.io.*;
+import java.text.*;
+import java.util.*;
+import java.util.logging.*;
+import java.lang.reflect.*;
+
+public final class ClientPlayerAPI
+{
+	private final static Class<?>[] Class = new Class[] { ClientPlayerAPI.class };
+	private final static Class<?>[] Classes = new Class[] { ClientPlayerAPI.class, String.class };
+
+	private static boolean isCreated;
+	private static final Logger logger = Logger.getLogger("ClientPlayerAPI");
+
+	private static void log(String text)
+	{
+		System.out.println(text);
+		logger.fine(text);
+	}
+
+	public static void register(String id, Class<?> baseClass)
+	{
+		register(id, baseClass, null);
+	}
+
+	public static void register(String id, Class<?> baseClass, ClientPlayerBaseSorting baseSorting)
+	{
+		try
+		{
+			register(baseClass, id, baseSorting);
+		}
+		catch(RuntimeException exception)
+		{
+			if(id != null)
+				log("Client Player: failed to register id '" + id + "'");
+			else
+				log("Client Player: failed to register ClientPlayerBase");
+
+			throw exception;
+		}
+	}
+
+	private static void register(Class<?> baseClass, String id, ClientPlayerBaseSorting baseSorting)
+	{
+		if(!isCreated)
+		{
+			try
+			{
+				Method mandatory = net.minecraft.client.entity.EntityPlayerSP.class.getMethod("getClientPlayerBase", String.class);
+				if (mandatory.getReturnType() != ClientPlayerBase.class)
+					throw new NoSuchMethodException(ClientPlayerBase.class.getName() + " " + net.minecraft.client.entity.EntityPlayerSP.class.getName() + ".getClientPlayerBase(" + String.class.getName() + ")");
+			}
+			catch(NoSuchMethodException exception)
+			{
+				String[] errorMessageParts = new String[]
+				{
+					"========================================",
+					"The API \"Client Player\" version " + api.player.forge.PlayerAPIPlugin.Version + " of the mod \"Player API Core " + api.player.forge.PlayerAPIPlugin.Version + "\" can not be created!",
+					"----------------------------------------",
+					"Mandatory member method \"{0} getClientPlayerBase({3})\" not found in class \"{1}\".",
+					"There are three scenarios this can happen:",
+					"* Minecraft Forge is missing a Player API Core which Minecraft version matches its own.",
+					"  Download and install the latest Player API Core for the Minecraft version you were trying to run.",
+					"* The code of the class \"{2}\" of Player API Core has been modified beyond recognition by another Minecraft Forge coremod.",
+					"  Try temporary deinstallation of other core mods to find the culprit and deinstall it permanently to fix this specific problem.",
+					"* Player API Core has not been installed correctly.",
+					"  Deinstall Player API Core and install it again following the installation instructions in the readme file.",
+					"========================================"
+				};
+
+				String baseEntityPlayerSPClassName = ClientPlayerBase.class.getName();
+				String targetClassName = net.minecraft.client.entity.EntityPlayerSP.class.getName();
+				String targetClassFileName = targetClassName.replace(".", File.separator);
+				String stringClassName = String.class.getName();
+
+				for(int i=0; i<errorMessageParts.length; i++)
+					errorMessageParts[i] = MessageFormat.format(errorMessageParts[i], baseEntityPlayerSPClassName, targetClassName, targetClassFileName, stringClassName);
+
+				for(String errorMessagePart : errorMessageParts)
+					logger.severe(errorMessagePart);
+
+				for(String errorMessagePart : errorMessageParts)
+					System.err.println(errorMessagePart);
+
+				String errorMessage = "\n\n";
+				for(String errorMessagePart : errorMessageParts)
+					errorMessage += "\t" + errorMessagePart + "\n";
+
+				throw new RuntimeException(errorMessage, exception);
+			}
+
+			log("Client Player " + api.player.forge.PlayerAPIPlugin.Version + " Created");
+			isCreated = true;
+		}
+
+		if(id == null)
+			throw new NullPointerException("Argument 'id' can not be null");
+		if(baseClass == null)
+			throw new NullPointerException("Argument 'baseClass' can not be null");
+
+		Constructor<?> allreadyRegistered = allBaseConstructors.get(id);
+		if(allreadyRegistered != null)
+			throw new IllegalArgumentException("The class '" + baseClass.getName() + "' can not be registered with the id '" + id + "' because the class '" + allreadyRegistered.getDeclaringClass().getName() + "' has allready been registered with the same id");
+
+		Constructor<?> baseConstructor;
+		try
+		{
+			baseConstructor = baseClass.getDeclaredConstructor(Classes);
+		}
+		catch (Throwable t)
+		{
+			try
+			{
+				baseConstructor = baseClass.getDeclaredConstructor(Class);
+			}
+			catch(Throwable s)
+			{
+				throw new IllegalArgumentException("Can not find necessary constructor with one argument of type '" + ClientPlayerAPI.class.getName() + "' and eventually a second argument of type 'String' in the class '" + baseClass.getName() + "'", t);
+			}
+		}
+
+		allBaseConstructors.put(id, baseConstructor);
+
+		if(baseSorting != null)
+		{
+			addSorting(id, allBaseBeforeLocalConstructingSuperiors, baseSorting.getBeforeLocalConstructingSuperiors());
+			addSorting(id, allBaseBeforeLocalConstructingInferiors, baseSorting.getBeforeLocalConstructingInferiors());
+			addSorting(id, allBaseAfterLocalConstructingSuperiors, baseSorting.getAfterLocalConstructingSuperiors());
+			addSorting(id, allBaseAfterLocalConstructingInferiors, baseSorting.getAfterLocalConstructingInferiors());
+
+			addDynamicSorting(id, allBaseBeforeDynamicSuperiors, baseSorting.getDynamicBeforeSuperiors());
+			addDynamicSorting(id, allBaseBeforeDynamicInferiors, baseSorting.getDynamicBeforeInferiors());
+			addDynamicSorting(id, allBaseOverrideDynamicSuperiors, baseSorting.getDynamicOverrideSuperiors());
+			addDynamicSorting(id, allBaseOverrideDynamicInferiors, baseSorting.getDynamicOverrideInferiors());
+			addDynamicSorting(id, allBaseAfterDynamicSuperiors, baseSorting.getDynamicAfterSuperiors());
+			addDynamicSorting(id, allBaseAfterDynamicInferiors, baseSorting.getDynamicAfterInferiors());
+
+			addSorting(id, allBaseBeforeAddExhaustionSuperiors, baseSorting.getBeforeAddExhaustionSuperiors());
+			addSorting(id, allBaseBeforeAddExhaustionInferiors, baseSorting.getBeforeAddExhaustionInferiors());
+			addSorting(id, allBaseOverrideAddExhaustionSuperiors, baseSorting.getOverrideAddExhaustionSuperiors());
+			addSorting(id, allBaseOverrideAddExhaustionInferiors, baseSorting.getOverrideAddExhaustionInferiors());
+			addSorting(id, allBaseAfterAddExhaustionSuperiors, baseSorting.getAfterAddExhaustionSuperiors());
+			addSorting(id, allBaseAfterAddExhaustionInferiors, baseSorting.getAfterAddExhaustionInferiors());
+
+			addSorting(id, allBaseBeforeAddMovementStatSuperiors, baseSorting.getBeforeAddMovementStatSuperiors());
+			addSorting(id, allBaseBeforeAddMovementStatInferiors, baseSorting.getBeforeAddMovementStatInferiors());
+			addSorting(id, allBaseOverrideAddMovementStatSuperiors, baseSorting.getOverrideAddMovementStatSuperiors());
+			addSorting(id, allBaseOverrideAddMovementStatInferiors, baseSorting.getOverrideAddMovementStatInferiors());
+			addSorting(id, allBaseAfterAddMovementStatSuperiors, baseSorting.getAfterAddMovementStatSuperiors());
+			addSorting(id, allBaseAfterAddMovementStatInferiors, baseSorting.getAfterAddMovementStatInferiors());
+
+			addSorting(id, allBaseBeforeAddStatSuperiors, baseSorting.getBeforeAddStatSuperiors());
+			addSorting(id, allBaseBeforeAddStatInferiors, baseSorting.getBeforeAddStatInferiors());
+			addSorting(id, allBaseOverrideAddStatSuperiors, baseSorting.getOverrideAddStatSuperiors());
+			addSorting(id, allBaseOverrideAddStatInferiors, baseSorting.getOverrideAddStatInferiors());
+			addSorting(id, allBaseAfterAddStatSuperiors, baseSorting.getAfterAddStatSuperiors());
+			addSorting(id, allBaseAfterAddStatInferiors, baseSorting.getAfterAddStatInferiors());
+
+			addSorting(id, allBaseBeforeAttackEntityFromSuperiors, baseSorting.getBeforeAttackEntityFromSuperiors());
+			addSorting(id, allBaseBeforeAttackEntityFromInferiors, baseSorting.getBeforeAttackEntityFromInferiors());
+			addSorting(id, allBaseOverrideAttackEntityFromSuperiors, baseSorting.getOverrideAttackEntityFromSuperiors());
+			addSorting(id, allBaseOverrideAttackEntityFromInferiors, baseSorting.getOverrideAttackEntityFromInferiors());
+			addSorting(id, allBaseAfterAttackEntityFromSuperiors, baseSorting.getAfterAttackEntityFromSuperiors());
+			addSorting(id, allBaseAfterAttackEntityFromInferiors, baseSorting.getAfterAttackEntityFromInferiors());
+
+			addSorting(id, allBaseBeforeAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getBeforeAttackTargetEntityWithCurrentItemSuperiors());
+			addSorting(id, allBaseBeforeAttackTargetEntityWithCurrentItemInferiors, baseSorting.getBeforeAttackTargetEntityWithCurrentItemInferiors());
+			addSorting(id, allBaseOverrideAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getOverrideAttackTargetEntityWithCurrentItemSuperiors());
+			addSorting(id, allBaseOverrideAttackTargetEntityWithCurrentItemInferiors, baseSorting.getOverrideAttackTargetEntityWithCurrentItemInferiors());
+			addSorting(id, allBaseAfterAttackTargetEntityWithCurrentItemSuperiors, baseSorting.getAfterAttackTargetEntityWithCurrentItemSuperiors());
+			addSorting(id, allBaseAfterAttackTargetEntityWithCurrentItemInferiors, baseSorting.getAfterAttackTargetEntityWithCurrentItemInferiors());
+
+			addSorting(id, allBaseBeforeCanBreatheUnderwaterSuperiors, baseSorting.getBeforeCanBreatheUnderwaterSuperiors());
+			addSorting(id, allBaseBeforeCanBreatheUnderwaterInferiors, baseSorting.getBeforeCanBreatheUnderwaterInferiors());
+			addSorting(id, allBaseOverrideCanBreatheUnderwaterSuperiors, baseSorting.getOverrideCanBreatheUnderwaterSuperiors());
+			addSorting(id, allBaseOverrideCanBreatheUnderwaterInferiors, baseSorting.getOverrideCanBreatheUnderwaterInferiors());
+			addSorting(id, allBaseAfterCanBreatheUnderwaterSuperiors, baseSorting.getAfterCanBreatheUnderwaterSuperiors());
+			addSorting(id, allBaseAfterCanBreatheUnderwaterInferiors, baseSorting.getAfterCanBreatheUnderwaterInferiors());
+
+			addSorting(id, allBaseBeforeCanHarvestBlockSuperiors, baseSorting.getBeforeCanHarvestBlockSuperiors());
+			addSorting(id, allBaseBeforeCanHarvestBlockInferiors, baseSorting.getBeforeCanHarvestBlockInferiors());
+			addSorting(id, allBaseOverrideCanHarvestBlockSuperiors, baseSorting.getOverrideCanHarvestBlockSuperiors());
+			addSorting(id, allBaseOverrideCanHarvestBlockInferiors, baseSorting.getOverrideCanHarvestBlockInferiors());
+			addSorting(id, allBaseAfterCanHarvestBlockSuperiors, baseSorting.getAfterCanHarvestBlockSuperiors());
+			addSorting(id, allBaseAfterCanHarvestBlockInferiors, baseSorting.getAfterCanHarvestBlockInferiors());
+
+			addSorting(id, allBaseBeforeCanPlayerEditSuperiors, baseSorting.getBeforeCanPlayerEditSuperiors());
+			addSorting(id, allBaseBeforeCanPlayerEditInferiors, baseSorting.getBeforeCanPlayerEditInferiors());
+			addSorting(id, allBaseOverrideCanPlayerEditSuperiors, baseSorting.getOverrideCanPlayerEditSuperiors());
+			addSorting(id, allBaseOverrideCanPlayerEditInferiors, baseSorting.getOverrideCanPlayerEditInferiors());
+			addSorting(id, allBaseAfterCanPlayerEditSuperiors, baseSorting.getAfterCanPlayerEditSuperiors());
+			addSorting(id, allBaseAfterCanPlayerEditInferiors, baseSorting.getAfterCanPlayerEditInferiors());
+
+			addSorting(id, allBaseBeforeCanTriggerWalkingSuperiors, baseSorting.getBeforeCanTriggerWalkingSuperiors());
+			addSorting(id, allBaseBeforeCanTriggerWalkingInferiors, baseSorting.getBeforeCanTriggerWalkingInferiors());
+			addSorting(id, allBaseOverrideCanTriggerWalkingSuperiors, baseSorting.getOverrideCanTriggerWalkingSuperiors());
+			addSorting(id, allBaseOverrideCanTriggerWalkingInferiors, baseSorting.getOverrideCanTriggerWalkingInferiors());
+			addSorting(id, allBaseAfterCanTriggerWalkingSuperiors, baseSorting.getAfterCanTriggerWalkingSuperiors());
+			addSorting(id, allBaseAfterCanTriggerWalkingInferiors, baseSorting.getAfterCanTriggerWalkingInferiors());
+
+			addSorting(id, allBaseBeforeCloseScreenSuperiors, baseSorting.getBeforeCloseScreenSuperiors());
+			addSorting(id, allBaseBeforeCloseScreenInferiors, baseSorting.getBeforeCloseScreenInferiors());
+			addSorting(id, allBaseOverrideCloseScreenSuperiors, baseSorting.getOverrideCloseScreenSuperiors());
+			addSorting(id, allBaseOverrideCloseScreenInferiors, baseSorting.getOverrideCloseScreenInferiors());
+			addSorting(id, allBaseAfterCloseScreenSuperiors, baseSorting.getAfterCloseScreenSuperiors());
+			addSorting(id, allBaseAfterCloseScreenInferiors, baseSorting.getAfterCloseScreenInferiors());
+
+			addSorting(id, allBaseBeforeDamageEntitySuperiors, baseSorting.getBeforeDamageEntitySuperiors());
+			addSorting(id, allBaseBeforeDamageEntityInferiors, baseSorting.getBeforeDamageEntityInferiors());
+			addSorting(id, allBaseOverrideDamageEntitySuperiors, baseSorting.getOverrideDamageEntitySuperiors());
+			addSorting(id, allBaseOverrideDamageEntityInferiors, baseSorting.getOverrideDamageEntityInferiors());
+			addSorting(id, allBaseAfterDamageEntitySuperiors, baseSorting.getAfterDamageEntitySuperiors());
+			addSorting(id, allBaseAfterDamageEntityInferiors, baseSorting.getAfterDamageEntityInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIBrewingStandSuperiors, baseSorting.getBeforeDisplayGUIBrewingStandSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIBrewingStandInferiors, baseSorting.getBeforeDisplayGUIBrewingStandInferiors());
+			addSorting(id, allBaseOverrideDisplayGUIBrewingStandSuperiors, baseSorting.getOverrideDisplayGUIBrewingStandSuperiors());
+			addSorting(id, allBaseOverrideDisplayGUIBrewingStandInferiors, baseSorting.getOverrideDisplayGUIBrewingStandInferiors());
+			addSorting(id, allBaseAfterDisplayGUIBrewingStandSuperiors, baseSorting.getAfterDisplayGUIBrewingStandSuperiors());
+			addSorting(id, allBaseAfterDisplayGUIBrewingStandInferiors, baseSorting.getAfterDisplayGUIBrewingStandInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIChestSuperiors, baseSorting.getBeforeDisplayGUIChestSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIChestInferiors, baseSorting.getBeforeDisplayGUIChestInferiors());
+			addSorting(id, allBaseOverrideDisplayGUIChestSuperiors, baseSorting.getOverrideDisplayGUIChestSuperiors());
+			addSorting(id, allBaseOverrideDisplayGUIChestInferiors, baseSorting.getOverrideDisplayGUIChestInferiors());
+			addSorting(id, allBaseAfterDisplayGUIChestSuperiors, baseSorting.getAfterDisplayGUIChestSuperiors());
+			addSorting(id, allBaseAfterDisplayGUIChestInferiors, baseSorting.getAfterDisplayGUIChestInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIDispenserSuperiors, baseSorting.getBeforeDisplayGUIDispenserSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIDispenserInferiors, baseSorting.getBeforeDisplayGUIDispenserInferiors());
+			addSorting(id, allBaseOverrideDisplayGUIDispenserSuperiors, baseSorting.getOverrideDisplayGUIDispenserSuperiors());
+			addSorting(id, allBaseOverrideDisplayGUIDispenserInferiors, baseSorting.getOverrideDisplayGUIDispenserInferiors());
+			addSorting(id, allBaseAfterDisplayGUIDispenserSuperiors, baseSorting.getAfterDisplayGUIDispenserSuperiors());
+			addSorting(id, allBaseAfterDisplayGUIDispenserInferiors, baseSorting.getAfterDisplayGUIDispenserInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIEditSignSuperiors, baseSorting.getBeforeDisplayGUIEditSignSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIEditSignInferiors, baseSorting.getBeforeDisplayGUIEditSignInferiors());
+			addSorting(id, allBaseOverrideDisplayGUIEditSignSuperiors, baseSorting.getOverrideDisplayGUIEditSignSuperiors());
+			addSorting(id, allBaseOverrideDisplayGUIEditSignInferiors, baseSorting.getOverrideDisplayGUIEditSignInferiors());
+			addSorting(id, allBaseAfterDisplayGUIEditSignSuperiors, baseSorting.getAfterDisplayGUIEditSignSuperiors());
+			addSorting(id, allBaseAfterDisplayGUIEditSignInferiors, baseSorting.getAfterDisplayGUIEditSignInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIEnchantmentSuperiors, baseSorting.getBeforeDisplayGUIEnchantmentSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIEnchantmentInferiors, baseSorting.getBeforeDisplayGUIEnchantmentInferiors());
+			addSorting(id, allBaseOverrideDisplayGUIEnchantmentSuperiors, baseSorting.getOverrideDisplayGUIEnchantmentSuperiors());
+			addSorting(id, allBaseOverrideDisplayGUIEnchantmentInferiors, baseSorting.getOverrideDisplayGUIEnchantmentInferiors());
+			addSorting(id, allBaseAfterDisplayGUIEnchantmentSuperiors, baseSorting.getAfterDisplayGUIEnchantmentSuperiors());
+			addSorting(id, allBaseAfterDisplayGUIEnchantmentInferiors, baseSorting.getAfterDisplayGUIEnchantmentInferiors());
+
+			addSorting(id, allBaseBeforeDisplayGUIFurnaceSuperiors, baseSorting.getBeforeDisplayGUIFurnaceSuperiors());
+			addSorting(id, allBaseBeforeDisplayGUIFurnaceInferiors, ba