WorldGuard & Residence hooks, fix TConstruct traits (#4)

HaHaWTH · web-flow · commit d23732e75057 · 2025-02-23T01:24:42.000+08:00
* WorldGuard hook, fix Residence hooks, fix TConstruct traits, and detailed errors
Prepare for 0.1.0

* Include WorldGuard jar
diff --git a/README.md b/README.md
@@ -17,6 +17,7 @@ Provide bugfixes, optimizations and utilities for Forge+Bukkit server environmen
 - Fix Twilight Forest entities(e.g. Naga) can break blocks in protected areas
 - Fix Twilight Forest Chain with Block can break blocks in protected areas
 - Fix Thaumcraft 6 taint can spread into protected areas
+- Fix trait effects in Tinkers' Construct can bypass damage protection
 
 ## Features
 
@@ -30,6 +31,13 @@ Provide bugfixes, optimizations and utilities for Forge+Bukkit server environmen
 
 Configuration file is under `${minecraftDir}/config/hybridfix.cfg`
 
+## Plugin Hooks
+Thanks to HybridFix internal plugin, we can hook into plugins from Forge side to provide more fixes.
+
+Currently patched plugins:
+- Residence[(SpigotMC)](https://www.spigotmc.org/resources/residence-1-7-10-up-to-1-21.11480/)[(GitHub)](https://github.com/Zrips/Residence)
+- WorldGuard[(BukkitDev)](https://dev.bukkit.org/projects/worldguard)[(GitHub)](https://github.com/EngineHub/WorldGuard)
+
 ## Commands
 
 - `/hybridfix dumpitem` - Show details of the item in hand.
diff --git a/build.gradle b/build.gradle
@@ -125,13 +125,18 @@ dependencies {
     compileOnly 'org.spigotmc:spigot:1.12.2-R0.1-SNAPSHOT'
 
     compileOnly files("libs/Residence5.1.6.4.jar")
+    compileOnly files("libs/worldguard-bukkit-6.2.2.jar")
 
     // The twilight forest
     compileOnly rfg.deobf("curse.maven:the-twilight-forest-227639:3051450")
 
     // Thaumcraft 6
     compileOnly rfg.deobf('curse.maven:thaumcraft-223628:2629023')
     compileOnly rfg.deobf('curse.maven:baubles-227083:2518667')
+
+    // Tinkers Construct
+    compileOnly rfg.deobf("curse.maven:tinkers-construct-74072:2902483")
+    compileOnly rfg.deobf("curse.maven:mantle-74924:2713386")
     if (propertyBool('use_modern_java_syntax')) {
         annotationProcessor 'com.github.bsideup.jabel:jabel-javac-plugin:1.0.0'
         // Workaround for https://github.com/bsideup/jabel/issues/174
diff --git a/gradle.properties b/gradle.properties
@@ -101,7 +101,7 @@ mixin_booter_version = 10.5
 # You should change package root once they are generated
 generate_mixins_json = true
 # Delimit configs with spaces. Should only put configs name instead of full file name
-mixin_configs = fix.respawn thaumcraft.taint twilight_forest.item twilight_forest.entity twilight_forest.sapling bridge.duck bridge.explosion.mohist fix.respawn.mohist perf.eventbus perf.server perf.timings.v1 misc.command bukkit.plugin
+mixin_configs = fix.respawn tconstruct.tools thaumcraft.taint twilight_forest.item twilight_forest.entity twilight_forest.sapling bridge.duck bridge.explosion.mohist fix.respawn.mohist perf.eventbus perf.server perf.timings.v1 misc.command bukkit.plugin
 # A refmap is a json that denotes mapping conversions, this json is generated automatically, with the name `mixins.mod_id.refmap.json`
 # Use the property `mixin_refmap` if you want it to use a different name, only one name is accepted
 mixin_refmap = mixins.${mod_id}.refmap.json
diff --git a/libs/worldguard-bukkit-6.2.2.jar b/libs/worldguard-bukkit-6.2.2.jar
diff --git a/src/main/java/io/wdsj/hybridfix/HybridFix.java b/src/main/java/io/wdsj/hybridfix/HybridFix.java
@@ -24,9 +24,6 @@ public void onPreInit(FMLPreInitializationEvent event) {
             LOGGER.warn("HybridFix requires a Forge+Bukkit server environment to work properly, disabling.");
             return;
         }
-        if (HAS_CLEANROOM) {
-            return;
-        }
         HybridFixServer.preInit();
     }
 
diff --git a/src/main/java/io/wdsj/hybridfix/HybridFixLateLoader.java b/src/main/java/io/wdsj/hybridfix/HybridFixLateLoader.java
@@ -27,6 +27,8 @@ public class HybridFixLateLoader implements ILateMixinLoader {
             put("mixins.twilight_forest.entity.json", () -> isModLoaded("twilightforest") && Settings.modPatchSettings.patchTwilightForestEntityEvent);
             // Thaumcraft patches
             put("mixins.thaumcraft.taint.json", () -> isModLoaded("thaumcraft") && Settings.modPatchSettings.patchThaumcraftTaintSpread);
+            // Tconstruct patches
+            put("mixins.tconstruct.tools.json", () -> isModLoaded("tconstruct") && Settings.modPatchSettings.patchTconstructToolDamage);
         }
     });
 
diff --git a/src/main/java/io/wdsj/hybridfix/HybridFixServer.java b/src/main/java/io/wdsj/hybridfix/HybridFixServer.java
@@ -9,14 +9,22 @@
 import io.wdsj.hybridfix.util.Utils;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.server.permission.PermissionAPI;
+import org.bukkit.Bukkit;
+import org.bukkit.craftbukkit.v1_12_R1.CraftCrashReport;
+
+import java.util.logging.Level;
+
+import static io.wdsj.hybridfix.HybridFix.HAS_CLEANROOM;
 
 public class HybridFixServer {
     public static void preInit() {
-        if (Settings.passExplosionEventToBukkit) {
-            MinecraftForge.EVENT_BUS.register(new ExplosionHandler());
-        }
-        if (Settings.bridgeForgePermissionsToBukkit) {
-            PermissionAPI.setPermissionHandler(new BukkitForgePermissionHandler());
+        if (!HAS_CLEANROOM) {
+            if (Settings.passExplosionEventToBukkit) {
+                MinecraftForge.EVENT_BUS.register(new ExplosionHandler());
+            }
+            if (Settings.bridgeForgePermissionsToBukkit) {
+                PermissionAPI.setPermissionHandler(new BukkitForgePermissionHandler());
+            }
         }
     }
 
@@ -39,4 +47,9 @@ public static void onStartComplete() {
             });
         }
     }
+
+    public static void createServerDump(Throwable t) {
+        HybridFix.LOGGER.error("--- REPORT THIS TO YOUR SERVER SOFTWARE - If you think this is a HybridFix bug, please report it at https://github.com/HaHaWTH/HybridFix/issues - THIS IS NOT A CRASH - {} ---", Bukkit.getServer().getVersion());
+        HybridFix.LOGGER.error(t);
+    }
 }
diff --git a/src/main/java/io/wdsj/hybridfix/config/Settings.java b/src/main/java/io/wdsj/hybridfix/config/Settings.java
@@ -75,13 +75,17 @@ public static class ModPatchSettings {
         @Config.Comment("Patch taint in thaumcraft spread event.")
         @Config.RequiresMcRestart
         public boolean patchThaumcraftTaintSpread = true;
+
+        @Config.Comment("Patch Tinkers Construct tool damage,\nUseful for some traits that adds extra effects and disarming, etc.\nYou can use property -Dhybridfix.tconstruct.supersedeVanillaEvent=true to prevent calling original damage event.")
+        @Config.RequiresMcRestart
+        public boolean patchTconstructToolDamage = false;
     }
     @Config.Comment("Configuration for HybridFix built-in bukkit plugin.")
     @Config.RequiresMcRestart
     public static BukkitPluginSettings bukkitPluginConfig = new BukkitPluginSettings();
 
     public static class BukkitPluginSettings {
-        @Config.Comment("Enable HybridFix built-in bukkit plugin.(All bukkit plugin features in this section won't work if you disabled this!)")
+        @Config.Comment("Enable HybridFix built-in bukkit plugin.\n***All bukkit plugin features in this section won't work if you disabled this!***")
         @Config.RequiresMcRestart
         public boolean enable = false;
 
@@ -93,6 +97,10 @@ public static class BukkitPluginSettings {
         @Config.RequiresMcRestart
         public boolean hookResidence = false;
 
+        @Config.Comment("Enable HybridFix WorldGuard hook.")
+        @Config.RequiresMcRestart
+        public boolean hookWorldGuard = false;
+
         @Config.Comment("Worlds that AntiExplode should protect.")
         @Config.RequiresMcRestart
         public String[] antiExplodeWorlds = new String[]{"world", "DIM-1", "DIM1"};
diff --git a/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/residence/ResHookBlockFormListener.java b/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/residence/ResHookBlockFormListener.java
@@ -3,6 +3,9 @@
 import com.bekvon.bukkit.residence.Residence;
 import com.bekvon.bukkit.residence.containers.Flags;
 import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import org.bukkit.Material;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Snowman;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -17,6 +20,13 @@ public void onForm(BlockFormEvent event) {
         Residence plugin = Residence.getInstance();
         if (plugin == null) return;
         if (plugin.isDisabledWorldListener(event.getBlock().getWorld())) return;
+        // Skip checks that have already been done by Residence
+        if (((EntityBlockFormEvent) event).getEntity() instanceof Snowman) return;
+        final BlockState newState = event.getNewState();
+        Material newType = newState.getType();
+        if (newType == Material.SNOW || newType == Material.ICE || newType == Material.FROSTED_ICE) return;
+        // End
+
         FlagPermissions perms = plugin.getPermsByLoc(event.getBlock().getLocation());
         if (!perms.has(Flags.spread, true)) {
             event.setCancelled(true);
diff --git a/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/residence/ResHookEntityChangeBlockListener.java b/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/residence/ResHookEntityChangeBlockListener.java
@@ -3,6 +3,8 @@
 import com.bekvon.bukkit.residence.Residence;
 import com.bekvon.bukkit.residence.containers.Flags;
 import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
@@ -15,6 +17,12 @@ public void onChangeBlock(EntityChangeBlockEvent event) {
         if (plugin == null) return;
         // disabling event on world
         if (plugin.isDisabledWorldListener(event.getBlock().getWorld())) return;
+        // Skip checks that have already been done by Residence
+        Entity entity = event.getEntity();
+        EntityType type = entity.getType();
+        if (type == EntityType.ENDERMAN || type == EntityType.WITHER) return;
+        // End
+
         FlagPermissions perms = plugin.getPermsByLoc(event.getBlock().getLocation());
         if (!perms.has(Flags.destroy, true)) {
             event.setCancelled(true);
diff --git a/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/worldguard/WGHookEntityChangeBlockListener.java b/src/main/java/io/wdsj/hybridfix/entry/bukkit/hook/worldguard/WGHookEntityChangeBlockListener.java
@@ -0,0 +1,42 @@
+package io.wdsj.hybridfix.entry.bukkit.hook.worldguard;
+
+import com.sk89q.worldguard.bukkit.ConfigurationManager;
+import com.sk89q.worldguard.bukkit.WorldConfiguration;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Enderman;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Wither;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityBreakDoorEvent;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
+
+public class WGHookEntityChangeBlockListener implements Listener {
+
+    @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+    public void onChange(EntityChangeBlockEvent event) {
+        WorldGuardPlugin plugin = WorldGuardPlugin.inst();
+        if (plugin == null) return;
+        Entity ent = event.getEntity();
+        Block block = event.getBlock();
+        Location location = block.getLocation();
+        if (event instanceof EntityBreakDoorEvent || ent instanceof Enderman || ent instanceof Wither) return; // Don't check these entities as WG has already done that.
+
+        ConfigurationManager cfg = plugin.getGlobalStateManager();
+        WorldConfiguration wcfg = cfg.get(ent.getWorld());
+        if (wcfg.disableMobDamage) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (wcfg.useRegions) {
+            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.MOB_DAMAGE, location)) {
+                event.setCancelled(true);
+            }
+        }
+    }
+}
diff --git a/src/main/java/io/wdsj/hybridfix/mixin/bukkit/plugin/DedicatedServerMixin.java b/src/main/java/io/wdsj/hybridfix/mixin/bukkit/plugin/DedicatedServerMixin.java
@@ -4,6 +4,7 @@
 import io.wdsj.hybridfix.config.Settings;
 import io.wdsj.hybridfix.entry.bukkit.HybridFixInternalPlugin;
 import io.wdsj.hybridfix.entry.bukkit.hook.residence.ResHookBlockFormListener;
+import io.wdsj.hybridfix.entry.bukkit.hook.worldguard.WGHookEntityChangeBlockListener;
 import io.wdsj.hybridfix.entry.bukkit.listener.ExplodeListener;
 import io.wdsj.hybridfix.entry.bukkit.hook.residence.ResHookEntityChangeBlockListener;
 import io.wdsj.hybridfix.entry.bukkit.util.ListenerUtils;
@@ -47,5 +48,14 @@ public void onInit(CallbackInfoReturnable<Boolean> cir) {
                 HybridFix.LOGGER.warn("[HybridFix] Residence not found, check your installation.");
             }
         }
+        if (Settings.bukkitPluginConfig.hookWorldGuard) {
+            final String wg = "WorldGuard";
+            if (Bukkit.getPluginManager().isPluginEnabled(wg)) {
+                ListenerUtils.registerListenerToTargetPlugin(WGHookEntityChangeBlockListener.class, wg);
+                HybridFix.LOGGER.info("{}[HybridFix] Hooked into WorldGuard.", ChatColor.LIGHT_PURPLE);
+            } else {
+                HybridFix.LOGGER.warn("[HybridFix] WorldGuard not found, check your installation.");
+            }
+        }
     }
 }
diff --git a/src/main/java/io/wdsj/hybridfix/mixin/late/tconstruct/tools/ToolHelperMixin.java b/src/main/java/io/wdsj/hybridfix/mixin/late/tconstruct/tools/ToolHelperMixin.java
@@ -0,0 +1,43 @@
+package io.wdsj.hybridfix.mixin.late.tconstruct.tools;
+
+import io.wdsj.hybridfix.duck.bridge.IEntityGetter;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.SharedMonsterAttributes;
+import net.minecraft.item.ItemStack;
+import org.bukkit.Bukkit;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.spongepowered.asm.mixin.Mixin;
+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 slimeknights.tconstruct.library.tools.ToolCore;
+import slimeknights.tconstruct.library.utils.ToolHelper;
+
+@Mixin(ToolHelper.class)
+public abstract class ToolHelperMixin {
+    @Unique
+    private static final boolean hybridFix$supersedeVanillaEvent = Boolean.getBoolean("hybridfix.tconstruct.supersedeVanillaEvent");
+    @Inject(
+            method = "attackEntity(Lnet/minecraft/item/ItemStack;Lslimeknights/tconstruct/library/tools/ToolCore;Lnet/minecraft/entity/EntityLivingBase;Lnet/minecraft/entity/Entity;Lnet/minecraft/entity/Entity;Z)Z",
+            at = @At(
+                    value = "INVOKE",
+                    target = "Lslimeknights/tconstruct/library/utils/TinkerUtil;getTraitsOrdered(Lnet/minecraft/item/ItemStack;)Ljava/util/List;"
+            ),
+            remap = false,
+            cancellable = true
+    )
+    private static void callEvent(ItemStack stack, ToolCore tool, EntityLivingBase attacker, Entity targetEntity, Entity projectileEntity, boolean applyCooldown, CallbackInfoReturnable<Boolean> cir) {
+        org.bukkit.entity.Entity damager = ((IEntityGetter) attacker).getBukkitEntity();
+        org.bukkit.entity.Entity victim = ((IEntityGetter) targetEntity).getBukkitEntity();
+        float base = (float) attacker.getEntityAttribute(SharedMonsterAttributes.ATTACK_DAMAGE).getAttributeValue();
+        // noinspection deprecation
+        EntityDamageByEntityEvent event = new EntityDamageByEntityEvent(damager, victim, EntityDamageEvent.DamageCause.ENTITY_ATTACK, base); // Damage doesn't matter, we just need to check if it's cancelled
+        Bukkit.getPluginManager().callEvent(event);
+        if (event.isCancelled()) {
+            cir.setReturnValue(hybridFix$supersedeVanillaEvent);
+        }
+    }
+}
diff --git a/src/main/java/io/wdsj/hybridfix/util/hybrid/HybridReflectionUtils.java b/src/main/java/io/wdsj/hybridfix/util/hybrid/HybridReflectionUtils.java
@@ -1,6 +1,8 @@
 package io.wdsj.hybridfix.util.hybrid;
 
+import com.google.common.base.Preconditions;
 import io.wdsj.hybridfix.HybridFix;
+import io.wdsj.hybridfix.HybridFixServer;
 import net.minecraft.block.BlockSapling;
 import net.minecraft.world.World;
 import net.minecraftforge.common.util.BlockSnapshot;
@@ -18,19 +20,22 @@ public class HybridReflectionUtils {
     private static final MethodHandle CONSTRUCTOR_CRAFT_BLOCK_STATE = getConstructorHandle(CraftBlockState.class, BlockSnapshot.class);
 
     public static void setCaptureTreeGeneration(World world, boolean value) {
+        Preconditions.checkNotNull(FIELD_WORLD_CAPTURE_TREE_GENERATION);
         setBooleanField(FIELD_WORLD_CAPTURE_TREE_GENERATION, world, value);
     }
 
     public static TreeType getTreeType() { // Currently unused
+        Preconditions.checkNotNull(FIELD_BLOCK_SAPLING_TREE_TYPE);
         return (TreeType) getFieldValue(FIELD_BLOCK_SAPLING_TREE_TYPE, null);
     }
 
     public static void setTreeType(TreeType treeType) {
+        Preconditions.checkNotNull(FIELD_BLOCK_SAPLING_TREE_TYPE);
         setField(FIELD_BLOCK_SAPLING_TREE_TYPE, null, treeType);
     }
 
     public static CraftBlockState newBlockStateFromBlockSnapshot(BlockSnapshot snapshot) {
-        assert CONSTRUCTOR_CRAFT_BLOCK_STATE != null;
+        Preconditions.checkNotNull(CONSTRUCTOR_CRAFT_BLOCK_STATE);
         try {
             return (CraftBlockState) CONSTRUCTOR_CRAFT_BLOCK_STATE.invokeExact(snapshot);
         } catch (Throwable e) {
@@ -44,6 +49,8 @@ private static <T> MethodHandle getConstructorHandle(Class<T> clazz, Class<?>...
             c.setAccessible(true);
             return MethodHandles.lookup().unreflectConstructor(c);
         } catch (Exception e) {
+            HybridFix.LOGGER.warn("Error occurred while getting constructor {}", clazz.getName());
+            HybridFixServer.createServerDump(e);
             return null;
         }
     }
@@ -53,6 +60,8 @@ private static Field getField(Class<?> clazz, String fieldName) {
             f.setAccessible(true);
             return f;
         } catch (Exception e) {
+            HybridFix.LOGGER.warn("Error occurred while getting field {}", fieldName);
+            HybridFixServer.createServerDump(e);
             return null;
         }
     }
@@ -61,7 +70,7 @@ private static Object getFieldValue(Field field, Object instance) {
         try {
             return field.get(instance);
         } catch (Exception e) {
-            HybridFix.LOGGER.warn("Error occurred while getting field {}", field.getName(), e);
+            HybridFix.LOGGER.warn("Error occurred while getting value of field {}", field.getName(), e);
             return null;
         }
     }
@@ -70,15 +79,15 @@ private static void setField(Field field, Object instance, Object value) {
         try {
             field.set(instance, value);
         } catch (Exception e) {
-            HybridFix.LOGGER.warn("Error occurred while setting field {}", field.getName(), e);
+            HybridFix.LOGGER.warn("Error occurred while setting value of field {}", field.getName(), e);
         }
     }
 
     private static void setBooleanField(Field field, Object instance, boolean value) {
         try {
             field.setBoolean(instance, value);
         } catch (Exception e) {
-            HybridFix.LOGGER.warn("Error occurred while setting field {}", field.getName(), e);
+            HybridFix.LOGGER.warn("Error occurred while setting boolean value of field {}", field.getName(), e);
         }
     }
 }
diff --git a/src/main/resources/mixins.tconstruct.tools.json b/src/main/resources/mixins.tconstruct.tools.json
@@ -0,0 +1,11 @@
+{
+  "package": "io.wdsj.hybridfix.mixin.late.tconstruct.tools",
+  "required": true,
+  "refmap": "${mixin_refmap}",
+  "target": "@env(DEFAULT)",
+  "minVersion": "0.8",
+  "compatibilityLevel": "JAVA_8",
+  "mixins": [
+    "ToolHelperMixin"
+  ]
+}

Original file line number	Diff line number	Diff line change
`@@ -24,9 +24,6 @@ public void onPreInit(FMLPreInitializationEvent event) {`
`24`	`24`	`LOGGER.warn("HybridFix requires a Forge+Bukkit server environment to work properly, disabling.");`
`25`	`25`	`return;`
`26`	`26`	`}`
`27`		`- if (HAS_CLEANROOM) {`
`28`		`- return;`
`29`		`- }`
`30`	`27`	`HybridFixServer.preInit();`
`31`	`28`	`}`
`32`	`29`
Original file line number	Diff line number	Diff line change
`@@ -27,6 +27,8 @@ public class HybridFixLateLoader implements ILateMixinLoader {`
`27`	`27`	`put("mixins.twilight_forest.entity.json", () -> isModLoaded("twilightforest") && Settings.modPatchSettings.patchTwilightForestEntityEvent);`
`28`	`28`	`// Thaumcraft patches`
`29`	`29`	`put("mixins.thaumcraft.taint.json", () -> isModLoaded("thaumcraft") && Settings.modPatchSettings.patchThaumcraftTaintSpread);`
	`30`	`+ // Tconstruct patches`
	`31`	`+ put("mixins.tconstruct.tools.json", () -> isModLoaded("tconstruct") && Settings.modPatchSettings.patchTconstructToolDamage);`
`30`	`32`	`}`
`31`	`33`	`});`
`32`	`34`