Release 1.5.

1) Remove FastEvents. 2) Add BlockFromToEvent and PlayerInteractEvent.
gamerforEA · Feb 23, 2016 · 4da606b · 4da606b
1 parent 8290d5e
commit 4da606b
Show file tree

Hide file tree

Showing 12 changed files with 193 additions and 135 deletions.
diff --git a/build.gradle b/build.gradle
@@ -15,28 +15,43 @@ buildscript {
 	}
 }
 
+repositories {
+	flatDir {
+		dirs 'lib'
+	}
+}
+
 apply plugin: 'forge'
 
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
 
-version = "1.4"
+version = "1.5"
 group= "com.gamerforea"
 archivesBaseName = "EventHelper"
 
 minecraft {
-	version = "1.7.10-10.13.4.1492-1.7.10"
+	version = "1.7.10-10.13.4.1614-1.7.10"
 	runDir = "eclipse"
+	replace "@VERSION@", project.version
 }
 
 dependencies {
-	compile fileTree(dir: 'lib', include: '*.jar')
+	compile name: 'bukkit-1.7.10'
+	compile name: 'worldedit-6.1'
+	compile name: 'worldguard-6.1'
 }
 
 task devJar(type: Jar) {
 	classifier = 'dev'
 	from sourceSets.main.output
 }
 
+task sourcesJar(type: Jar) {
+	classifier = 'sources'
+	from sourceSets.main.allSource
+}
+
 artifacts {
 	archives devJar
+	archives sourcesJar
 }
diff --git a/lib/bukkit-1.7.10-sources.jar b/lib/bukkit-1.7.10-sources.jar
diff --git a/lib/bukkit-1.7.10.jar b/lib/bukkit-1.7.10.jar
diff --git a/lib/cauldron-api-1.7.10-SNAPSHOT.jar b/lib/cauldron-api-1.7.10-SNAPSHOT.jar
diff --git a/lib/worldedit-6.1-sources.jar b/lib/worldedit-6.1-sources.jar
diff --git a/lib/worldguard-6.1-sources.jar b/lib/worldguard-6.1-sources.jar
diff --git a/src/main/java/com/gamerforea/eventhelper/EventHelper.java b/src/main/java/com/gamerforea/eventhelper/EventHelper.java
@@ -24,22 +24,22 @@
 import net.minecraftforge.common.config.Configuration;
 
 @SideOnly(Side.SERVER)
-@Mod(modid = "EventHelper", name = "EventHelper", version = "1.4", acceptableRemoteVersions = "*")
+@Mod(modid = "EventHelper", name = "EventHelper", version = "@VERSION@", acceptableRemoteVersions = "*")
 public final class EventHelper
 {
 	public static final File cfgDir = new File(Loader.instance().getConfigDir(), "Events");
 	public static final List<RegisteredListener> listeners = Lists.newArrayList();
+	public static String craftPackage = "org/bukkit/craftbukkit/v1_7_R4";
 	public static boolean debug = false;
-	public static boolean fastEvents = false;
 
 	@EventHandler
 	public final void serverStarted(FMLServerStartedEvent event)
 	{
 		Configuration cfg = FastUtils.getConfig("EventHelper");
 		String[] plugins = cfg.getStringList("plugins", CATEGORY_GENERAL, new String[] { "WorldGuard" }, "Plugins for sending events");
 		boolean wgHooking = cfg.getBoolean("wgHooking", CATEGORY_GENERAL, true, "Hooking WorldGuard plugin (allow checking regions)");
+		craftPackage = cfg.getString("craftPackage", CATEGORY_GENERAL, craftPackage, "CraftBukkit package (for reflection)");
 		debug = cfg.getBoolean("debug", CATEGORY_GENERAL, debug, "Debugging enabled");
-		fastEvents = cfg.getBoolean("fastEvents", CATEGORY_GENERAL, fastEvents, "Fast events enabled (not recommended, work only on WorldGuard)");
 		cfg.save();
 
 		PluginManager plManager = Bukkit.getPluginManager();

diff --git a/src/main/java/com/gamerforea/eventhelper/util/ConvertUtils.java b/src/main/java/com/gamerforea/eventhelper/util/ConvertUtils.java
@@ -3,40 +3,76 @@
 import java.lang.reflect.Method;
 
 import org.bukkit.Bukkit;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
 
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
 public final class ConvertUtils
 {
 	private static final Method getBukkitEntity;
+	private static final Method asCraftMirror;
 
 	public static final org.bukkit.entity.Entity toBukkitEntity(Entity entity) throws Exception
 	{
 		return (org.bukkit.entity.Entity) getBukkitEntity.invoke(entity);
 	}
 
-	public static final org.bukkit.entity.Player toBukkitEntity(EntityPlayer player) throws Exception
+	public static final Player toBukkitEntity(EntityPlayer player) throws Exception
 	{
-		return (org.bukkit.entity.Player) getBukkitEntity.invoke(player);
+		return (Player) getBukkitEntity.invoke(player);
 	}
 
 	public static final org.bukkit.World toBukkitWorld(World world)
 	{
 		return Bukkit.getWorld(world.getWorldInfo().getWorldName());
 	}
 
+	public static final org.bukkit.inventory.ItemStack toBukkitItemStackMirror(ItemStack stack) throws Exception
+	{
+		return (org.bukkit.inventory.ItemStack) asCraftMirror.invoke(null, stack);
+	}
+
+	public static final BlockFace toBukkitFace(ForgeDirection direction)
+	{
+		switch (direction)
+		{
+			case DOWN:
+				return BlockFace.DOWN;
+			case UP:
+				return BlockFace.UP;
+			case NORTH:
+				return BlockFace.NORTH;
+			case SOUTH:
+				return BlockFace.SOUTH;
+			case WEST:
+				return BlockFace.WEST;
+			case EAST:
+				return BlockFace.EAST;
+			case UNKNOWN:
+				return BlockFace.SELF;
+			default:
+				return BlockFace.SELF;
+		}
+	}
+
 	static
 	{
 		try
 		{
 			getBukkitEntity = Entity.class.getDeclaredMethod("getBukkitEntity");
 			getBukkitEntity.setAccessible(true);
+
+			asCraftMirror = CraftUtils.getCraftClass("inventory/CraftItemStack").getDeclaredMethod("asCraftMirror", ItemStack.class);
+			asCraftMirror.setAccessible(true);
 		}
 		catch (Throwable throwable)
 		{
-			throw new RuntimeException("Failed hooking Entity.getBukkitEntity() method!", throwable);
+			throw new RuntimeException("Failed hooking CraftBukkit methods!", throwable);
 		}
 	}
 }
diff --git a/src/main/java/com/gamerforea/eventhelper/util/CraftUtils.java b/src/main/java/com/gamerforea/eventhelper/util/CraftUtils.java
@@ -0,0 +1,11 @@
+package com.gamerforea.eventhelper.util;
+
+import com.gamerforea.eventhelper.EventHelper;
+
+public final class CraftUtils
+{
+	public static final Class<?> getCraftClass(String name) throws ClassNotFoundException
+	{
+		return Class.forName((EventHelper.craftPackage + '/' + name).replace("//", ".").replace('/', '.'));
+	}
+}
diff --git a/src/main/java/com/gamerforea/eventhelper/util/EventUtils.java b/src/main/java/com/gamerforea/eventhelper/util/EventUtils.java
@@ -1,100 +1,127 @@
 package com.gamerforea.eventhelper.util;
 
 import static com.gamerforea.eventhelper.util.ConvertUtils.toBukkitEntity;
+import static com.gamerforea.eventhelper.util.ConvertUtils.toBukkitFace;
+import static com.gamerforea.eventhelper.util.ConvertUtils.toBukkitItemStackMirror;
 import static com.gamerforea.eventhelper.util.ConvertUtils.toBukkitWorld;
 
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.Action;
 import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockFromToEvent;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerInteractEvent;
 
 import com.gamerforea.eventhelper.EventHelper;
-import com.gamerforea.eventhelper.wg.WGFastEvents;
 import com.gamerforea.eventhelper.wg.WGRegionChecker;
 
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
 import net.minecraft.util.MathHelper;
 import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
 
 public final class EventUtils
 {
 	public static final boolean cantBreak(EntityPlayer player, int x, int y, int z)
 	{
-		if (!EventHelper.fastEvents)
-			try
-			{
-				BlockBreakEvent event = new BlockBreakEvent(toBukkitWorld(player.worldObj).getBlockAt(x, y, z), toBukkitEntity(player));
-				EventHelper.callEvent(event);
-				return event.isCancelled();
-			}
-			catch (Throwable throwable)
-			{
-				System.err.println(String.format("Failed call BlockBreakEvent: [Player: %s, X:%d, Y:%d, Z:%d]", player.toString(), x, y, z));
-				if (EventHelper.debug)
-					throwable.printStackTrace();
-				return true;
-			}
-		else
-			try
-			{
-				return !WGFastEvents.hasAccess(toBukkitEntity(player), x, y, z, false);
-			}
-			catch (Throwable throwable)
-			{
-				System.err.println(String.format("Failed use fast hasAccess(): [Player: %s, X:%d, Y:%d, Z:%d]", player.toString(), x, y, z));
-				if (EventHelper.debug)
-					throwable.printStackTrace();
-				return true;
-			}
+		try
+		{
+			Player bPlayer = toBukkitEntity(player);
+			BlockBreakEvent event = new BlockBreakEvent(bPlayer.getWorld().getBlockAt(x, y, z), bPlayer);
+			EventHelper.callEvent(event);
+			return event.isCancelled();
+		}
+		catch (Throwable throwable)
+		{
+			err("Failed call BlockBreakEvent: [Player: %s, X:%d, Y:%d, Z:%d]", String.valueOf(player), x, y, z);
+			if (EventHelper.debug)
+				throwable.printStackTrace();
+			return true;
+		}
 	}
 
 	public static final boolean cantDamage(Entity damager, Entity damagee)
 	{
-		if (!EventHelper.fastEvents)
-			try
-			{
-				EntityDamageByEntityEvent event = new EntityDamageByEntityEvent(toBukkitEntity(damager), toBukkitEntity(damagee), DamageCause.ENTITY_ATTACK, 0D);
-				EventHelper.callEvent(event);
-				return event.isCancelled();
-			}
-			catch (Throwable throwable)
-			{
-				System.err.println(String.format("Failed call EntityDamageByEntityEvent: [Damager: %s, Damagee: %s]", damager.toString(), damagee.toString()));
-				if (EventHelper.debug)
-					throwable.printStackTrace();
-				return true;
-			}
-		else
-			try
-			{
-				if (damager instanceof EntityPlayer)
-				{
-					int x = MathHelper.floor_double(damagee.posX);
-					int y = MathHelper.floor_double(damagee.posY);
-					int z = MathHelper.floor_double(damagee.posZ);
-					return !WGFastEvents.hasAccess(toBukkitEntity((EntityPlayer) damager), x, y, z, true);
-				}
-				else
-					return isInPrivate(damagee);
-			}
-			catch (Throwable throwable)
-			{
-				System.err.println(String.format("Failed use fast hasAccess(): [Damager: %s, Damagee: %s]", damager.toString(), damagee.toString()));
-				if (EventHelper.debug)
-					throwable.printStackTrace();
-				return true;
-			}
+		try
+		{
+			EntityDamageByEntityEvent event = new EntityDamageByEntityEvent(toBukkitEntity(damager), toBukkitEntity(damagee), DamageCause.ENTITY_ATTACK, 0D);
+			EventHelper.callEvent(event);
+			return event.isCancelled();
+		}
+		catch (Throwable throwable)
+		{
+			err("Failed call EntityDamageByEntityEvent: [Damager: %s, Damagee: %s]", String.valueOf(damager), String.valueOf(damagee));
+			if (EventHelper.debug)
+				throwable.printStackTrace();
+			return true;
+		}
+	}
+
+	public static final boolean cantInteract(EntityPlayer player, ItemStack stack, int x, int y, int z, ForgeDirection side)
+	{
+		try
+		{
+			org.bukkit.entity.Player bPlayer = toBukkitEntity(player);
+			PlayerInteractEvent event = new PlayerInteractEvent(bPlayer, Action.RIGHT_CLICK_BLOCK, toBukkitItemStackMirror(stack), bPlayer.getWorld().getBlockAt(x, y, z), toBukkitFace(side));
+			return event.isCancelled();
+		}
+		catch (Throwable throwable)
+		{
+			err("Failed call PlayerInteractEvent: [Player: %s, Item: %s, X:%d, Y:%d, Z:%d, Side: %s]", String.valueOf(player), String.valueOf(stack), x, y, z, String.valueOf(side));
+			if (EventHelper.debug)
+				throwable.printStackTrace();
+			return true;
+		}
+	}
+
+	public static final boolean cantFromTo(World world, int fromX, int fromY, int fromZ, int toX, int toY, int toZ)
+	{
+		try
+		{
+			org.bukkit.World bWorld = toBukkitWorld(world);
+			BlockFromToEvent event = new BlockFromToEvent(bWorld.getBlockAt(fromX, fromY, fromZ), bWorld.getBlockAt(toX, toY, toZ));
+			EventHelper.callEvent(event);
+			return event.isCancelled();
+		}
+		catch (Throwable throwable)
+		{
+			err("Failed call BlockFromToEvent: [FromX: %d, FromY: %d, FromZ: %d, ToX: %d, ToY: %d, ToZ: %d]", fromX, fromY, fromZ, toX, toY, toZ);
+			if (EventHelper.debug)
+				throwable.printStackTrace();
+			return true;
+		}
+	}
+
+	public static final boolean cantFromTo(World world, int fromX, int fromY, int fromZ, ForgeDirection direction)
+	{
+		try
+		{
+			org.bukkit.World bWorld = toBukkitWorld(world);
+			BlockFromToEvent event = new BlockFromToEvent(bWorld.getBlockAt(fromX, fromY, fromZ), toBukkitFace(direction));
+			EventHelper.callEvent(event);
+			return event.isCancelled();
+		}
+		catch (Throwable throwable)
+		{
+			err("Failed call BlockFromToEvent: [FromX: %d, FromY: %d, FromZ: %d, Direction: %s]", fromX, fromY, fromZ, String.valueOf(direction));
+			if (EventHelper.debug)
+				throwable.printStackTrace();
+			return true;
+		}
 	}
 
 	public static final boolean isInPrivate(World world, int x, int y, int z)
 	{
 		try
 		{
-			return WGRegionChecker.isInPrivate(ConvertUtils.toBukkitWorld(world), x, y, z);
+			return WGRegionChecker.isInPrivate(toBukkitWorld(world), x, y, z);
 		}
 		catch (Throwable throwable)
 		{
-			System.err.println(String.format("Failed check private: [World: %s, X: %d, Y: %d, Z: %d]", world.getWorldInfo().getWorldName(), x, y, z));
+			err("Failed check private: [World: %s, X: %d, Y: %d, Z: %d]", world.getWorldInfo().getWorldName(), x, y, z);
 			if (EventHelper.debug)
 				throwable.printStackTrace();
 			return true;
@@ -108,4 +135,9 @@ public static final boolean isInPrivate(Entity entity)
 		int z = MathHelper.floor_double(entity.posZ);
 		return isInPrivate(entity.worldObj, x, y, z);
 	}
+
+	private static final void err(String format, Object... args)
+	{
+		System.err.println(String.format(format, args));
+	}
 }