Updated CHANGELOG.

CHANGELOG.txt

@@ -1,3 +1,50 @@
+1.5
+- Removed the block lag fix.
+- WorldGuard now conditionally loads features so you can use any up-to-date
+    build of hMod and the unsupported features won't break the entire
+    plugin. When WG loads, check the server console for a report of
+    features that are not supported by your version of hMod.
+- Changed some configuration defaults:
+    disable-lava-fire=true
+    simulate-sponge=true
+    item-durability=false
+
+1.4.1
+- Fixed issue with the block lag fix dropping item stacks of 0 quantity.
+
+1.4
+- New on-acquire hook. This does both a total inventory check on inventory
+    change and item pick up denial. The item pick up denial is largely
+    thanks to Dinnerbone for fulfilling my request to add a particular hook.
+- Item durability can now be toggled with item-durability. Thanks to
+    Dinnerbone for figuring this out while filfilling my request. The
+    default setting is to fix item durability.
+- New no-physics-gravel and no-physics-sand options allow you to
+    prevent gravel and sand from falling.
+- New allow-portal-anywhere option allows you to create portal blocks
+    anywhere.
+    
+1.3
+- UPGRADE WARNING: If you are using database logging, you must add a
+    NULL 'comment' VARCHAR field to the table. The line of SQL that you
+    can run for MySQL can be found in blacklist_table.sql.
+- Improved plugin compatibility with the block lag fix. For maximum
+    compatibility, you must now list WorldGuard as the first plugin in
+    server.properties and you cannot reload or enable the plugin
+    while the server is up. This is for bad plugins that unnecessarily
+    use the "critical" priority for its hooks like the LWC. Most plugins
+    don't do that though, so this won't apply for most people.
+- Fixed signs being blank if they were denied via the blacklist.
+- Added on-break event to the blacklist.
+- Added comments and messages. Comments are only for your own use and they
+    are printed with the log and notify actions of the blacklist. The
+    message replaces the message that is shown the user and it is optional.
+- The blacklist notification messages are now more compact and are
+    light grey instead of light purple.
+- The notify, log, and tell actions will now trigger every time for the
+    on-break, on-create, on-drop events rather than wait 3 seconds between
+    events for the same item or block for a player.
+
 1.2
 - /stopfire and /allowfire disable and enable fire spreading globally.
 - Block lag fix slightly improved in accuracy for item drops.

README.txt

@@ -22,8 +22,11 @@ use or not:
 - Notify admins, block, log, kick or ban for the use of certain block types
     or items.
 - Temporarily stop fire globally with some commands.
-- Fix the block lag.
 - Destroy tools on drop to alleviate the durability cheat.
+- OR just fix the durability bug. *Requires special version of hMod
+- Prevent gravel and sand from falling. *Requires special version of hMod
+- Allow portal blocks to be placed anywhere.
+  *Requires special version of hMod
 
 hMod is required as WorldGuard is a plugin for hMod.
 
@@ -34,6 +37,18 @@ A "worldguard.properties" will be created the first the time that you load
 WorldGuard on your server. You can either restart your server or use
 /reloadplugin WorldGuard to reload the configuraton file after editing it.
 
+NOTE: Some features may require a custom version of hMod. When the server
+is loaded with the plugin, WorldGuard will tell you the features
+unsupported by your version of hMod.
+
+- summary-on-start (def. true)
+    Print a summary of WorldGuard's protection settings at-a-glance when
+    the plugin is loaded.
+
+- item-durability (def. false)
+    **Requires special version of hMod
+    Enables item durability.
+
 - classic-water (def. false)
     Toggle use of classic water. Be foreward that your world may be
     flooded if you are not careful. If you have WorldEdit, you can use
@@ -42,7 +57,7 @@ WorldGuard on your server. You can either restart your server or use
     ground, but if there are air blocks underneath, the water will not
     spread (preventing waterfalls from becoming tsunamis).
 
-- simulate-sponge (def. false)
+- simulate-sponge (def. true)
     Toggle simulation of the sponge from Classic. It blocks water from
     flowing near the sponge.
 
@@ -51,6 +66,18 @@ WorldGuard on your server. You can either restart your server or use
     creating a 5x5x5 cuboid free of water. Increasing the number will
     increase server load exponentially, although 3-5 has fairly low impact.
 
+- no-physics-gravel (def. false)
+    **Requires special version of hMod
+    Prevents gravel from falling due to gravity.
+
+- no-physics-sand (def. false)
+    **Requires special version of hMod
+    Prevents sand from falling due to gravity.
+
+- allow-portal-anywhere (def. false)
+    **Requires special version of hMod
+    Allows you to place portal blocks anywhere.
+
 - enforce-single-session (def. true)
     Enforce single sessions. If the player is already found to be on
     the server when s/he logs in, the other player will be kicked with
@@ -67,9 +94,10 @@ WorldGuard on your server. You can either restart your server or use
     command; it is only used for permissions.
 
 - block-creepers (def. false)
-    Block creeper explosions. They will not explode client-side.
+    Block creeper explosions from destroying terrain (and possibly from
+    causing damage).
 
-- disable-lava-fire (def. false)
+- disable-lava-fire (def. true)
     Prevent lava from starting fires.
 
 - allowed-lava-spread-blocks (no default)
@@ -91,9 +119,6 @@ WorldGuard on your server. You can either restart your server or use
     this is an easier way to do it (this way also prints a more
     friendly message than if you used the 'tell' action of the blacklist).
 
-- block-lag-fix (def. false)
-    Attempts to fix block lag.
-
 - log-console (def. true)
     For blacklist log actions, print to console.
 
@@ -174,3 +199,15 @@ certain rules apply to only some groups.
 
 Edit the included worldguard-blacklist.txt file and follow the
 instructions inside. The file comes with the download for WorldGuard.
+
+Thanks
+------
+
+While I would like to thank everyone for their support, I would like to
+say thanks to the following individuals for their direct
+contributions to WorldGuard:
+
+- Sturmeh, for contributing the original durability workaround
+- Meaglin, for changing the on flow hook at my request
+- Dinnerbone, for implementing the on item pick up hook at my request,
+    and also for figuring out the durability bug in the process

blacklist_table.sql

@@ -12,5 +12,10 @@ CREATE TABLE `blacklist_events` (
   `z` int(11) NOT NULL,
   `item` int(11) NOT NULL,
   `time` int(11) NOT NULL,
+  `comment` varchar(255) NULL,
   PRIMARY KEY (`id`)
 );
+
+-- Required update if you have an older version of the table:
+
+ALTER TABLE `blacklist_events` ADD `comment` VARCHAR( 255 ) NULL 

manifest.mf

@@ -1,2 +1,2 @@
 Manifest-Version: 1.0
-WorldGuard-Version: 1.2
+WorldGuard-Version: 1.5

src/Blacklist.java

@@ -45,6 +45,11 @@ public class Blacklist {
      */
     private BlacklistLogger blacklistLogger = new BlacklistLogger();
 
+    /**
+     * Blacklist contains on-acquire events.
+     */
+    private boolean hasOnAcquire;
+
     /**
      * Returns whether the list is empty.
      * 
@@ -92,6 +97,28 @@ public class Blacklist {
         return ret;
     }
 
+    /**
+     * Called on block break. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onBreak(final Block block, final Player player) {
+        List<BlacklistEntry> entries = getEntries(block.getType());
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onBreak(block, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
     /**
      * Called on left click. Returns true to let the action pass through.
      *
@@ -197,6 +224,48 @@ public class Blacklist {
         return ret;
     }
 
+    /**
+     * Called on acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onAcquire(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onAcquire(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onSilentAcquire(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onSilentAcquire(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
     /**
      * Load the blacklist.
      *
@@ -213,6 +282,8 @@ public class Blacklist {
             input = new FileReader(file);
             BufferedReader buff = new BufferedReader(input);
 
+            hasOnAcquire = false;
+
             String line;
             List<BlacklistEntry> currentEntries = null;
             while ((line = buff.readLine()) != null) {
@@ -269,6 +340,8 @@ public class Blacklist {
                             entry.setIgnoreGroups(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-destroy")) {
                             entry.setDestroyActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-break")) {
+                            entry.setBreakActions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-left")
                                 || parts[0].equalsIgnoreCase("on-destroy-with")) {
                             entry.setDestroyWithActions(parts[1].split(","));
@@ -280,6 +353,13 @@ public class Blacklist {
                             entry.setUseActions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-drop")) {
                             entry.setDropActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-acquire")) {
+                            hasOnAcquire = true;
+                            entry.setAcquireActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("message")) {
+                            entry.setMessage(parts[1].trim());
+                        } else if (parts[0].equalsIgnoreCase("comment")) {
+                            entry.setComment(parts[1].trim());
                         } else {
                             unknownOption = true;
                         }
@@ -305,4 +385,13 @@ public class Blacklist {
             }
         }
     }
+
+    /**
+     * Blacklist contains on-acquire events.
+     * 
+     * @return
+     */
+    public boolean hasOnAcquire() {
+        return hasOnAcquire;
+    }
 }

src/BlacklistEntry.java

@@ -46,6 +46,10 @@ public class BlacklistEntry {
      * List of actions to perform on destruction.
      */
     private String[] destroyActions;
+    /**
+     * List of actions to perform on break.
+     */
+    private String[] breakActions;
     /**
      * List of actions to perform on left click.
      */
@@ -62,6 +66,29 @@ public class BlacklistEntry {
      * List of actions to perform on drop.
      */
     private String[] dropActions;
+    /**
+     * List of actions to perform on drop.
+     */
+    private String[] acquireActions;
+    /**
+     * Message for users.
+     */
+    private String message;
+    /**
+     * Comment for administrators.
+     */
+    private String comment;
+
+    /**
+     * Used to ignore messages.
+     */
+    private static ActionHandler silentHandler = new ActionHandler() {
+            public void log(String itemName) {}
+            public void kick(String itemName) {}
+            public void ban(String itemName) {}
+            public void notifyAdmins(String itemName) {}
+            public void tell(String itemName) {}
+        };
 
     /**
      * Construct the object.
@@ -104,6 +131,20 @@ public class BlacklistEntry {
         this.destroyActions = actions;
     }
 
+    /**
+     * @return
+     */
+    public String[] getBreakActions() {
+        return breakActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setBreakActions(String[] actions) {
+        this.breakActions = actions;
+    }
+
     /**
      * @return
      */
@@ -160,6 +201,48 @@ public class BlacklistEntry {
         this.dropActions = actions;
     }
 
+    /**
+     * @return
+     */
+    public String[] getAcquireActions() {
+        return acquireActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setAcquireActions(String[] actions) {
+        this.acquireActions = actions;
+    }
+
+    /**
+     * @return the message
+     */
+    public String getMessage() {
+        return message;
+    }
+
+    /**
+     * @param message the message to set
+     */
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    /**
+     * @return the comment
+     */
+    public String getComment() {
+        return comment;
+    }
+
+    /**
+     * @param comment the comment to set
+     */
+    public void setComment(String comment) {
+        this.comment = comment;
+    }
+
     /**
      * Returns true if this player should be ignored.
      *
@@ -188,7 +271,7 @@ public class BlacklistEntry {
         for (Player player : etc.getServer().getPlayerList()) {
             if (player.canUseCommand("/wprotectalerts")
                     || player.canUseCommand("/worldguardnotify")) {
-                player.sendMessage(Colors.LightPurple + "WorldGuard: " + str);
+                player.sendMessage(Colors.LightGray + "WG: " + str);
             }
         }
     }
@@ -224,7 +307,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logDestroyAttempt(player, block);
+                blacklist.getLogger().logDestroyAttempt(player, block, comment);
             }
             public void kick(String itemName) {
                 player.kick("You are not allowed to destroy " + itemName);
@@ -233,14 +316,52 @@ public class BlacklistEntry {
                 entry.banPlayer(player, "Banned: You are not allowed to destroy " + itemName);
             }
             public void notifyAdmins(String itemName) {
-                entry.notifyAdmins(player.getName() + " tried to destroy " + itemName + ".");
+                entry.notifyAdmins(player.getName() + " (destroy) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
             }
             public void tell(String itemName) {
                 player.sendMessage(Colors.Yellow + "You are not allowed to destroy " + itemName + ".");
             }
         };
 
-        return process(block.getType(), player, destroyActions, handler);
+        return process(block.getType(), player, destroyActions, handler, false, false);
+    }
+
+    /**
+     * Called on block break. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onBreak(final Block block, final Player player) {
+        if (breakActions == null) {
+            return true;
+        }
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logBreakAttempt(player, block, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You are not allowed to break " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You are not allowed to break " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (break) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You are not allowed to break " + itemName + ".");
+            }
+        };
+
+        return process(block.getType(), player, breakActions, handler, true, false);
     }
 
     /**
@@ -259,7 +380,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logDestroyWithAttempt(player, item);
+                blacklist.getLogger().logDestroyWithAttempt(player, item, comment);
             }
             public void kick(String itemName) {
                 player.kick("You can't destroy with " + itemName);
@@ -268,14 +389,15 @@ public class BlacklistEntry {
                 entry.banPlayer(player, "Banned: You can't destroy with " + itemName);
             }
             public void notifyAdmins(String itemName) {
-                entry.notifyAdmins(player.getName() + " tried to destroyed with " + itemName + ".");
+                entry.notifyAdmins(player.getName() + " (destroy w/) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
             }
             public void tell(String itemName) {
                 player.sendMessage(Colors.Yellow + "You can't destroy with " + itemName + ".");
             }
         };
 
-        return process(item, player, destroyWithActions, handler);
+        return process(item, player, destroyWithActions, handler, false, false);
     }
 
     /**
@@ -294,23 +416,24 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logCreateAttempt(player, item);
+                blacklist.getLogger().logCreateAttempt(player, item, comment);
             }
             public void kick(String itemName) {
-                player.kick("You can't create " + itemName);
+                player.kick("You can't place " + itemName);
             }
             public void ban(String itemName) {
-                entry.banPlayer(player, "Banned: You can't create " + itemName);
+                entry.banPlayer(player, "Banned: You can't place " + itemName);
             }
             public void notifyAdmins(String itemName) {
-                entry.notifyAdmins(player.getName() + " tried to create " + itemName + ".");
+                entry.notifyAdmins(player.getName() + " (place) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
             }
             public void tell(String itemName) {
-                player.sendMessage(Colors.Yellow + "You can't create " + itemName + ".");
+                player.sendMessage(Colors.Yellow + "You can't place " + itemName + ".");
             }
         };
 
-        return process(item, player, createActions, handler);
+        return process(item, player, createActions, handler, true, false);
     }
 
     /**
@@ -329,7 +452,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logUseAttempt(player, block);
+                blacklist.getLogger().logUseAttempt(player, block, comment);
             }
             public void kick(String itemName) {
                 player.kick("You can't use " + itemName);
@@ -338,14 +461,15 @@ public class BlacklistEntry {
                 entry.banPlayer(player, "Banned: You can't use " + itemName);
             }
             public void notifyAdmins(String itemName) {
-                entry.notifyAdmins(player.getName() + " tried to use " + itemName + ".");
+                entry.notifyAdmins(player.getName() + " (use) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
             }
             public void tell(String itemName) {
                 player.sendMessage(Colors.Yellow + "You're not allowed to use " + itemName + ".");
             }
         };
 
-        return process(block.getType(), player, useActions, handler);
+        return process(block.getType(), player, useActions, handler, false, false);
     }
 
     /**
@@ -360,20 +484,7 @@ public class BlacklistEntry {
             return true;
         }
 
-        ActionHandler handler = new ActionHandler() {
-            public void log(String itemName) {
-            }
-            public void kick(String itemName) {
-            }
-            public void ban(String itemName) {
-            }
-            public void notifyAdmins(String itemName) {
-            }
-            public void tell(String itemName) {
-            }
-        };
-
-        return process(block.getType(), player, useActions, handler);
+        return process(block.getType(), player, useActions, silentHandler, false, true);
     }
 
     /**
@@ -392,7 +503,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logDropAttempt(player, item);
+                blacklist.getLogger().logDropAttempt(player, item, comment);
             }
             public void kick(String itemName) {
                 player.kick("You can't drop " + itemName);
@@ -401,14 +512,66 @@ public class BlacklistEntry {
                 entry.banPlayer(player, "Banned: You can't drop " + itemName);
             }
             public void notifyAdmins(String itemName) {
-                entry.notifyAdmins(player.getName() + " tried to drop " + itemName + ".");
+                entry.notifyAdmins(player.getName() + " (drop) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
             }
             public void tell(String itemName) {
                 player.sendMessage(Colors.Yellow + "You're not allowed to drop " + itemName + ".");
             }
         };
 
-        return process(item, player, dropActions, handler);
+        return process(item, player, dropActions, handler, true, false);
+    }
+
+    /**
+     * Called on item acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onAcquire(final int item, final Player player) {
+        if (acquireActions == null) {
+            return true;
+        }
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logAcquireAttempt(player, item, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't acquire " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't acquire " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (acquire) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You're not allowed to acquire " + itemName + ".");
+            }
+        };
+
+        return process(item, player, acquireActions, handler, true, false);
+    }
+
+    /**
+     * Called on item acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onSilentAcquire(final int item, final Player player) {
+        if (acquireActions == null) {
+            return true;
+        }
+
+        return process(item, player, acquireActions, silentHandler, false, true);
     }
 
     /**
@@ -417,9 +580,14 @@ public class BlacklistEntry {
      * @param id
      * @param player
      * @param actions
+     * @param handler
+     * @param allowRepeat
+     * @param silent
      * @return
      */
-    private boolean process(int id, Player player, String[] actions, ActionHandler handler) {
+    private boolean process(int id, Player player, String[] actions,
+            ActionHandler handler, boolean allowRepeat, boolean silent) {
+
         if (shouldIgnore(player)) {
             return true;
         }
@@ -444,19 +612,50 @@ public class BlacklistEntry {
         boolean ret = true;
         
         for (String action : actions) {
+            // Deny
             if (action.equalsIgnoreCase("deny")) {
+                if (silent) {
+                    return false;
+                }
                 ret = false;
+
+            // Kick
             } else if (action.equalsIgnoreCase("kick")) {
-                handler.kick(etc.getDataSource().getItem(id));
+                if (this.message != null) {
+                    player.kick(String.format(this.message,
+                            etc.getDataSource().getItem(id)));
+                } else {
+                    handler.kick(etc.getDataSource().getItem(id));
+                }
+
+            // Ban
             } else if (action.equalsIgnoreCase("ban")) {
                 handler.ban(etc.getDataSource().getItem(id));
-            } else if (!repeating) {
+                if (this.message != null) {
+                    banPlayer(player, "Banned: " + String.format(this.message,
+                            etc.getDataSource().getItem(id)));
+                } else {
+                    handler.ban(etc.getDataSource().getItem(id));
+                }
+            
+            } else if (!repeating || allowRepeat) {
+                // Notify
                 if (action.equalsIgnoreCase("notify")) {
                     handler.notifyAdmins(etc.getDataSource().getItem(id));
+                
+                // Log
                 } else if (action.equalsIgnoreCase("log")) {
                     handler.log(etc.getDataSource().getItem(id));
-                } else if (!repeating && action.equalsIgnoreCase("tell")) {
-                    handler.tell(etc.getDataSource().getItem(id));
+
+                // Tell
+                } else if (action.equalsIgnoreCase("tell")) {
+                    if (this.message != null) {
+                        player.sendMessage(Colors.Yellow +
+                                String.format(message, etc.getDataSource().getItem(id))
+                                + ".");
+                    } else {
+                        handler.tell(etc.getDataSource().getItem(id));
+                    }
                 }
             }
         }

src/BlacklistLogger.java

@@ -64,9 +64,21 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logDestroyAttempt(Player player, Block block) {
+    public void logDestroyAttempt(Player player, Block block, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logDestroyAttempt(player, block);
+            handler.logDestroyAttempt(player, block, comment);
+        }
+    }
+
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logBreakAttempt(player, block, comment);
         }
     }
 
@@ -76,9 +88,9 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block) {
+    public void logUseAttempt(Player player, Block block, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logUseAttempt(player, block);
+            handler.logUseAttempt(player, block, comment);
         }
     }
 
@@ -88,9 +100,9 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDestroyWithAttempt(Player player, int item) {
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logDestroyWithAttempt(player, item);
+            handler.logDestroyWithAttempt(player, item, comment);
         }
     }
 
@@ -100,21 +112,33 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item) {
+    public void logCreateAttempt(Player player, int item, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logCreateAttempt(player, item);
+            handler.logCreateAttempt(player, item, comment);
         }
     }
 
     /**
-     * Log a right click attempt.
+     * Log a drop attempt.
      *
      * @param player
      * @param item
      */
-    public void logDropAttempt(Player player, int item) {
+    public void logDropAttempt(Player player, int item, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logDropAttempt(player, item);
+            handler.logDropAttempt(player, item, comment);
+        }
+    }
+
+    /**
+     * Log an acquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logAcquireAttempt(player, item, comment);
         }
     }
 

src/BlacklistLoggerHandler.java

@@ -29,35 +29,49 @@ public interface BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logDestroyAttempt(Player player, Block block);
+    public void logDestroyAttempt(Player player, Block block, String comment);
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment);
     /**
      * Log a right click on attempt.
      * 
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block);
+    public void logUseAttempt(Player player, Block block, String comment);
     /**
      * Right a left click attempt.
      * 
      * @param player
      * @param item
      */
-    public void logDestroyWithAttempt(Player player, int item);
+    public void logDestroyWithAttempt(Player player, int item, String comment);
     /**
      * Log a right click attempt.
      * 
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item);
+    public void logCreateAttempt(Player player, int item, String comment);
     /**
      * Log a drop attempt.
      *
      * @param player
      * @param item
      */
-    public void logDropAttempt(Player player, int item);
+    public void logDropAttempt(Player player, int item, String comment);
+    /**
+     * Log an acquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment);
     /**
      * Close the logger.
      */

src/ConsoleLoggerHandler.java

@@ -29,16 +29,29 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * Logger.
      */
     private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
+
     /**
      * Log a block destroy attempt.
      *
      * @param player
      * @param block
      */
-    public void logDestroyAttempt(Player player, Block block) {
+    public void logDestroyAttempt(Player player, Block block, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to destroy " + getFriendlyItemName(block.getType()));
+                + " tried to destroy " + getFriendlyItemName(block.getType())
+                + (comment != null ? " (" + comment + ")" : ""));
+    }
+
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " tried to break " + getFriendlyItemName(block.getType())
+                + (comment != null ? " (" + comment + ")" : ""));
     }
 
     /**
@@ -47,9 +60,10 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block) {
+    public void logUseAttempt(Player player, Block block, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to use " + getFriendlyItemName(block.getType()));
+                + " tried to use " + getFriendlyItemName(block.getType())
+                + (comment != null ? " (" + comment + ")" : ""));
     }
     
     /**
@@ -58,9 +72,10 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDestroyWithAttempt(Player player, int item) {
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to destroy with " + getFriendlyItemName(item));
+                + " tried to destroy with " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
     }
 
     /**
@@ -69,9 +84,10 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item) {
+    public void logCreateAttempt(Player player, int item, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to create " + getFriendlyItemName(item));
+                + " tried to create " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
     }
 
     /**
@@ -80,9 +96,22 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDropAttempt(Player player, int item) {
+    public void logDropAttempt(Player player, int item, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to drop " + getFriendlyItemName(item));
+                + " tried to drop " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
+    }
+
+    /**
+     * Log an acquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " tried to acquire " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
     }
 
     /**

src/DatabaseLoggerHandler.java

@@ -91,14 +91,16 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param y
      * @param z
      * @param item
+     * @param comment
      */
-    private void logEvent(String event, String name, int x, int y, int z, int item) {
+    private void logEvent(String event, String name, int x, int y, int z, int item,
+            String comment) {
         try {
             Connection conn = getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                     "INSERT INTO " + table
-                  + "(event, player, x, y, z, item, time) VALUES "
-                  + "(?, ?, ?, ?, ?, ?, ?)");
+                  + "(event, player, x, y, z, item, time, comment) VALUES "
+                  + "(?, ?, ?, ?, ?, ?, ?, ?)");
             stmt.setString(1, event);
             stmt.setString(2, name);
             stmt.setInt(3, x);
@@ -106,22 +108,36 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
             stmt.setInt(5, z);
             stmt.setInt(6, item);
             stmt.setInt(7, (int)(System.currentTimeMillis() / 1000));
+            stmt.setString(8, comment);
             stmt.executeUpdate();
         } catch (SQLException e) {
             logger.log(Level.SEVERE, "Failed to log blacklist event to database: "
                     + e.getMessage());
         }
     }
-    
+
     /**
      * Log a block destroy attempt.
      *
      * @param player
      * @param block
      */
-    public void logDestroyAttempt(Player player, Block block) {
+    public void logDestroyAttempt(Player player, Block block, String comment) {
         logEvent("DESTROY", player.getName(),
-                block.getX(), block.getY(), block.getZ(), block.getType());
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
+    }
+
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment) {
+        logEvent("BREAK", player.getName(),
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
     }
 
     /**
@@ -130,9 +146,10 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block) {
+    public void logUseAttempt(Player player, Block block, String comment) {
         logEvent("USE", player.getName(),
-                block.getX(), block.getY(), block.getZ(), block.getType());
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
     }
     
     /**
@@ -141,10 +158,10 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDestroyWithAttempt(Player player, int item) {
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
         logEvent("DESTROY_WITH", player.getName(),
                 (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
-                (int)Math.floor(player.getZ()), item);
+                (int)Math.floor(player.getZ()), item, comment);
     }
 
     /**
@@ -153,10 +170,10 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item) {
+    public void logCreateAttempt(Player player, int item, String comment) {
         logEvent("CREATE", player.getName(),
                 (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
-                (int)Math.floor(player.getZ()), item);
+                (int)Math.floor(player.getZ()), item, comment);
     }
 
     /**
@@ -165,10 +182,22 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDropAttempt(Player player, int item) {
+    public void logDropAttempt(Player player, int item, String comment) {
         logEvent("DROP", player.getName(),
                 (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
-                (int)Math.floor(player.getZ()), item);
+                (int)Math.floor(player.getZ()), item, comment);
+    }
+
+    /**
+     * Log an aquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        logEvent("AQUIRE", player.getName(),
+                (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
+                (int)Math.floor(player.getZ()), item, comment);
     }
 
     /**

src/FileLoggerHandler.java

@@ -143,11 +143,12 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param message
      */
-    private void log(Player player, String message) {
+    private void log(Player player, String message, String comment) {
         String path = buildPath(player.getName());
         try {
             String date = dateFormat.format(new Date());
-            String line = "[" + date + "] " + player.getName() + ": " + message + "\r\n";
+            String line = "[" + date + "] " + player.getName() + ": " + message
+                    + (comment != null ? " (" + comment + ")" : "") + "\r\n";
             
             FileLoggerWriter writer = writers.get(path);
 
@@ -211,8 +212,20 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logDestroyAttempt(Player player, Block block) {
-        log(player, "Tried to destroy " + getFriendlyItemName(block.getType()));
+    public void logDestroyAttempt(Player player, Block block, String comment) {
+        log(player, "Tried to destroy " + getFriendlyItemName(block.getType()),
+                comment);
+    }
+
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment) {
+        log(player, "Tried to break " + getFriendlyItemName(block.getType()),
+                comment);
     }
 
     /**
@@ -221,8 +234,9 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block) {
-        log(player, "Tried to use " + getFriendlyItemName(block.getType()));
+    public void logUseAttempt(Player player, Block block, String comment) {
+        log(player, "Tried to use " + getFriendlyItemName(block.getType()),
+                comment);
     }
 
     /**
@@ -231,8 +245,8 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDestroyWithAttempt(Player player, int item) {
-        log(player, "Tried to destroy with " + getFriendlyItemName(item));
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
+        log(player, "Tried to destroy with " + getFriendlyItemName(item), comment);
     }
 
     /**
@@ -241,8 +255,8 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item) {
-        log(player, "Tried to create " + getFriendlyItemName(item));
+    public void logCreateAttempt(Player player, int item, String comment) {
+        log(player, "Tried to create " + getFriendlyItemName(item), comment);
     }
 
     /**
@@ -251,8 +265,18 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logDropAttempt(Player player, int item) {
-        log(player, "Tried to drop " + getFriendlyItemName(item));
+    public void logDropAttempt(Player player, int item, String comment) {
+        log(player, "Tried to drop " + getFriendlyItemName(item), comment);
+    }
+
+    /**
+     * Log an acquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        log(player, "Tried to acquire " + getFriendlyItemName(item), comment);
     }
 
     /**

src/WorldGuard.java

@@ -21,8 +21,11 @@ import java.util.logging.Logger;
 import java.util.logging.Level;
 import java.util.jar.Manifest;
 import java.util.jar.Attributes;
+import java.util.List;
+import java.util.ArrayList;
 import java.net.URL;
 import java.io.*;
+import java.lang.reflect.*;
 
 /**
  * Entry point for the plugin for hey0's mod.
@@ -53,32 +56,73 @@ public class WorldGuard extends Plugin {
     public void initialize() {
         PluginLoader loader = etc.getLoader();
 
-        loader.addListener(PluginLoader.Hook.COMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.SERVERCOMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.EXPLODE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.IGNITE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.FLOW, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGINCHECK, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGIN, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.BLOCK_CREATED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_DESTROYED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.DISCONNECT, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.ITEM_DROP , listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_CHANGE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_SEND, listener, this,
-                PluginListener.Priority.HIGH);
+        List<String> missingFeatures = new ArrayList<String>();
+
+        registerHook("COMMAND", PluginListener.Priority.MEDIUM);
+        registerHook("SERVERCOMMAND", PluginListener.Priority.MEDIUM);
+        if (!registerHook("EXPLODE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("disabling TNT or creeper explosions");
+        }
+        if (!registerHook("IGNITE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("disabling fire or lava fire");
+        }
+        if (!registerHook("FLOW", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("controlling lava flow");
+            missingFeatures.add("sponge simulation");
+        }
+        registerHook("LOGINCHECK", PluginListener.Priority.HIGH);
+        registerHook("LOGIN", PluginListener.Priority.MEDIUM);
+        registerHook("BLOCK_CREATED", PluginListener.Priority.HIGH);
+        registerHook("BLOCK_DESTROYED", PluginListener.Priority.CRITICAL);
+        registerHook("BLOCK_BROKEN", PluginListener.Priority.HIGH);
+        registerHook("DISCONNECT", PluginListener.Priority.HIGH);
+        registerHook("ITEM_DROP", PluginListener.Priority.HIGH);
+        if (!registerHook("ITEM_PICK_UP", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("denying item pickups");
+            missingFeatures.add("the item durability fix");
+        } else {
+            try {
+                Method method = 
+                        Item.class.getDeclaredMethod("setDamage", new Class[]{ Integer.class });
+                if (method == null) {
+                    missingFeatures.add("the item durability fix");
+                }
+            } catch (NoSuchMethodException e) {
+                missingFeatures.add("the item durability fix");
+            }
+        }
+        registerHook("COMPLEX_BLOCK_CHANGE", PluginListener.Priority.HIGH);
+        registerHook("COMPLEX_BLOCK_SEND", PluginListener.Priority.HIGH);
+        registerHook("INVENTORY_CHANGE", PluginListener.Priority.HIGH);
+        if (!registerHook("BLOCK_PHYSICS", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("controlling the physics of gravel, sand, or portal blocks");
+        }
+
+        if (missingFeatures.size() > 0) {
+            logger.log(Level.WARNING, "WorldGuard: Your version of hMod does not support "
+                    + concatMissingFeatures(missingFeatures) + ".");
+        } else {
+            logger.log(Level.INFO, "WorldGuard: Your version of hMod appears to"
+                    + " support all features.");
+        }
+    }
+
+    /**
+     * Conditionally registers a hook.
+     *
+     * @param name
+     * @param priority
+     * @return where the hook was registered correctly
+     */
+    public boolean registerHook(String name, PluginListener.Priority priority) {
+        try {
+            PluginLoader.Hook hook = PluginLoader.Hook.valueOf(name);
+            etc.getLoader().addListener(hook, listener, this, priority);
+            return true;
+        } catch (IllegalArgumentException e) {
+            //logger.log(Level.WARNING, "WorldGuard: Missing hook " + name + "!");
+            return false;
+        }
     }
 
     /**
@@ -126,4 +170,38 @@ public class WorldGuard extends Plugin {
             return "(unknown)";
         }
     }
+
+    /**
+     * Joins a string from an array of strings.
+     *
+     * @param str
+     * @param delimiter
+     * @return
+     */
+    private static String concatMissingFeatures(List<String> str) {
+        if (str.isEmpty()) {
+            return "";
+        }
+
+        int size = str.size();
+        StringBuilder buffer = new StringBuilder();
+        buffer.append("(1) ");
+        buffer.append(str.get(0));
+        for (int i = 1; i < size; i++) {
+            if (i == size - 1) {
+                buffer.append(" or ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            } else {
+                buffer.append(", ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            }
+        }
+        return buffer.toString();
+    }
 }

src/WorldGuardListener.java

@@ -21,15 +21,10 @@ import java.util.Timer;
 import java.util.TimerTask;
 import java.util.logging.Logger;
 import java.util.logging.Level;
-import java.util.logging.Handler;
-import java.util.logging.ConsoleHandler;
 import java.util.Set;
 import java.util.HashSet;
-import java.util.LinkedList;
 import java.util.Random;
 import java.io.*;
-import java.util.logging.FileHandler;
-import com.sk89q.worldguard.*;
 
 /**
  * Event listener for Hey0's server mod.
@@ -58,10 +53,6 @@ public class WorldGuardListener extends PluginListener {
      * Properties file for WorldGuard.
      */
     private PropertiesFile properties = new PropertiesFile("worldguard.properties");
-    /**
-     * List of blocks to remove when possible.
-     */
-    private LinkedList<int[]> blockRemoveQueue = new LinkedList<int[]>();
 
     /**
      * Stop fire spread mode.
@@ -76,11 +67,14 @@ public class WorldGuardListener extends PluginListener {
     private boolean disableAllFire;
     private boolean simulateSponge;
     private int spongeRadius;
-    private boolean blockLagFix;
+    private boolean itemDurability;
     private Set<Integer> fireNoSpreadBlocks;
     private Set<Integer> allowedLavaSpreadOver;
     private Set<Integer> itemDropBlacklist;
     private boolean classicWater;
+    private boolean noPhysicsGravel;
+    private boolean noPhysicsSand;
+    private boolean allowPortalAnywhere;
     private Blacklist blacklist;
 
     /**
@@ -134,15 +128,18 @@ public class WorldGuardListener extends PluginListener {
         blockCreepers = properties.getBoolean("block-creepers", false);
         blockTNT = properties.getBoolean("block-tnt", false);
         blockLighter = properties.getBoolean("block-lighter", false);
-        preventLavaFire = properties.getBoolean("disable-lava-fire", false);
+        preventLavaFire = properties.getBoolean("disable-lava-fire", true);
         disableAllFire = properties.getBoolean("disable-all-fire-spread", false);
         itemDropBlacklist = toBlockIDSet(properties.getString("item-drop-blacklist", ""));
         fireNoSpreadBlocks = toBlockIDSet(properties.getString("disallowed-fire-spread-blocks", ""));
         allowedLavaSpreadOver = toBlockIDSet(properties.getString("allowed-lava-spread-blocks", ""));
         classicWater = properties.getBoolean("classic-water", false);
-        simulateSponge = properties.getBoolean("simulate-sponge", false);
+        simulateSponge = properties.getBoolean("simulate-sponge", true);
         spongeRadius = Math.max(1, properties.getInt("sponge-radius", 3)) - 1;
-        blockLagFix = properties.getBoolean("block-lag-fix", false);
+        itemDurability = properties.getBoolean("item-durability", false);
+        noPhysicsGravel = properties.getBoolean("no-physics-gravel", false);
+        noPhysicsSand = properties.getBoolean("no-physics-sand", false);
+        allowPortalAnywhere = properties.getBoolean("allow-portal-anywhere", false);
 
         // Console log configuration
         boolean logConsole = properties.getBoolean("log-console", true);
@@ -167,18 +164,18 @@ public class WorldGuardListener extends PluginListener {
             }
 
             // First load the blacklist data from worldguard-blacklist.txt
-            Blacklist blacklist = new Blacklist();
-            blacklist.load(new File("worldguard-blacklist.txt"));
+            Blacklist blist = new Blacklist();
+            blist.load(new File("worldguard-blacklist.txt"));
 
             // If the blacklist is empty, then set the field to null
             // and save some resources
-            if (blacklist.isEmpty()) {
+            if (blist.isEmpty()) {
                 this.blacklist = null;
             } else {
-                this.blacklist = blacklist;
+                this.blacklist = blist;
                 logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
 
-                BlacklistLogger blacklistLogger = blacklist.getLogger();
+                BlacklistLogger blacklistLogger = blist.getLogger();
 
                 if (logDatabase) {
                     blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table));
@@ -231,6 +228,7 @@ public class WorldGuardListener extends PluginListener {
      * @param user
      * @return kick reason. null if you don't want to kick the player.
      */
+    @Override
     public String onLoginChecks(String user) {
         if (enforceOneSession) {
             for (Player player : etc.getServer().getPlayerList()) {
@@ -248,6 +246,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @param player
      */
+    @Override
     public void onLogin(Player player) {
         if (stopFireSpread) {
             player.sendMessage(Colors.Yellow + "Fire spread is currently globally disabled.");
@@ -262,6 +261,7 @@ public class WorldGuardListener extends PluginListener {
      * @param split
      * @return false if you want the command to be parsed.
      */
+    @Override
     public boolean onCommand(Player player, String[] split) {
         if (split[0].equalsIgnoreCase("/stopfire") &&
                 player.canUseCommand("/stopfire")) {
@@ -295,6 +295,7 @@ public class WorldGuardListener extends PluginListener {
      * @param split
      * @return false if you want the command to be parsed.
      */
+    @Override
     public boolean onConsoleCommand(String[] split) {
         if (split[0].equalsIgnoreCase("fire-stop")) {
             if (!stopFireSpread) {
@@ -331,6 +332,7 @@ public class WorldGuardListener extends PluginListener {
      * @return true if you don't want the dropped item to be spawned in the
      *         world
      */
+    @Override
     public boolean onItemDrop(Player player, Item item) {
         if (itemDropBlacklist != null) {
             int n = item.getItemId();
@@ -346,6 +348,63 @@ public class WorldGuardListener extends PluginListener {
             }
         }
 
+        if (!itemDurability) {
+            try {
+                item.setDamage(0);
+            } catch (java.lang.NoSuchMethodError e) {
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Called when a player picks up an item.
+     *
+     * @param player
+     *            player who picked up the item
+     * @param item
+     *            item that was picked up
+     * @return true if you want to leave the item where it was
+     */
+    @Override
+    public boolean onItemPickUp(Player player, Item item) {
+        if (blacklist != null && blacklist.hasOnAcquire()) {
+            if (!blacklist.onSilentAcquire(item.getItemId(), player)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Called when a player's inventory is modified.
+     *
+     * @param player
+     *            player who's inventory was modified
+     * @return true if you want any changes to be reverted
+     */
+    @Override
+    public boolean onInventoryChange(Player player) {
+        if (blacklist != null && blacklist.hasOnAcquire()) {
+            hl[] items = player.getInventory().getArray();
+            boolean needUpdate = false;
+
+            for (int i = 0; i < items.length; i++) {
+                if (items[i] != null) {
+                    if (!blacklist.onAcquire(items[i].c, player)) {
+                        items[i] = null;
+                        needUpdate = true;
+                    }
+                }
+            }
+
+            if (needUpdate) {
+                player.getInventory().updateInventory();
+            }
+        }
+        
         return false;
     }
 
@@ -360,6 +419,7 @@ public class WorldGuardListener extends PluginListener {
      * @param itemInHand
      * @return false if you want the action to go through
      */
+    @Override
     public boolean onBlockCreate(Player player, Block blockPlaced, Block blockClicked,
             int itemInHand) {
         if (blacklist != null) {
@@ -418,6 +478,7 @@ public class WorldGuardListener extends PluginListener {
      * @param block
      * @return
      */
+    @Override
     public boolean onBlockDestroy(Player player, Block block) {
         int type = block.getType();
         
@@ -430,90 +491,25 @@ public class WorldGuardListener extends PluginListener {
                 return true;
             }
         }
+        
+        return false;
+    }
 
-        if (blockLagFix
-                && type != 7 // Bedrock
-                && type != 46 // TNT
-                && type != 50 // Torch
-                && type != 51 // Fire
-                && type != 59 // Crops
-                && type != 62 // Burning furnace
-                && type != 64 // Wooden door
-                && type != 69 // Lever
-                && type != 71 // Iron door
-                && type != 75 // Redstone torch
-                && type != 76 // Redstone torch
-                && type != 77 // Stone button
-                ) {
-
-            // Check other plugins first to see if this block can be
-            // destroyed. Since this causes the hook to eventually call
-            // twice, we try to nullify it below
-            if (canDestroyBlock(player, block)) {
-                if (block.getStatus() == 3) {
-                    int dropItem = type;
-                    int count = 1;
-
-                    if (type == 1) { dropItem = 4; } // Stone
-                    else if (type == 2) { dropItem = 3; } // Grass
-                    else if (type == 16) { dropItem = 263; } // Coal ore
-                    else if (type == 18) { // Leaves
-                        if (rand.nextDouble() > 0.95) {
-                            dropItem = 6;
-                        } else {
-                            dropItem = 0;
-                        }
-                    }
-                    else if (type == 20) { dropItem = 0; } // Glass
-                    else if (type == 43) { dropItem = 44; } // Double step
-                    else if (type == 47) { dropItem = 0; } // Bookshelves
-                    else if (type == 52) { dropItem = 0; } // Mob spawner
-                    else if (type == 53) { dropItem = 5; } // Wooden stairs
-                    else if (type == 55) { dropItem = 331; } // Redstone wire
-                    else if (type == 56) { dropItem = 264; } // Diamond ore
-                    else if (type == 60) { dropItem = 3; } // Soil
-                    else if (type == 63) { dropItem = 323; } // Sign post
-                    else if (type == 67) { dropItem = 4; } // Cobblestone stairs
-                    else if (type == 68) { dropItem = 323; } // Wall sign
-                    else if (type == 73) { dropItem = 331; count = 4; } // Redstone ore
-                    else if (type == 74) { dropItem = 331; count = 4; } // Glowing redstone ore
-                    else if (type == 78) { dropItem = 0; } // Snow
-                    else if (type == 79) { dropItem = 0; } // Ice
-                    else if (type == 82) { dropItem = 337; count = 4; } // Clay
-                    else if (type == 83) { dropItem = 338; } // Reed
-                    else if (type == 89) { dropItem = 348; } // Lightstone
-
-                    etc.getServer().setBlockAt(0, block.getX(), block.getY(), block.getZ());
-
-                    if (dropItem > 0) {
-                        for (int i = 0; i < count; i++) {
-                            etc.getServer().dropItem(block.getX(), block.getY(), block.getZ(),
-                                    dropItem, i);
-                        }
-
-                        // Drop flint with gravel
-                        if (type == 13) {
-                            if (rand.nextDouble() >= 0.9) {
-                                etc.getServer().dropItem(block.getX(), block.getY(), block.getZ(),
-                                        318, 1);
-                            }
-                        }
-                    }
-
-                    // Now loop this hook back through!
-                    block.setStatus(3); // Block is destroyed
-                    canDestroyBlock(player, block);
-                }
-
+    /**
+     * Called when a person actually breaks the block.
+     *
+     * @param player
+     * @param block
+     * @return
+     */
+    @Override
+    public boolean onBlockBreak(Player player, Block block) {
+        if (blacklist != null) {
+            if (!blacklist.onBreak(block, player)) {
                 return true;
             }
-
-            // So we don't have double hook calls caused by the
-            // plugin/protection check
-            block.setType(0);
-            block.setStatus(2);
         }
-        
+
         return false;
     }
 
@@ -526,6 +522,7 @@ public class WorldGuardListener extends PluginListener {
      *            complex block that changed
      * @return true if you want any changes to be reverted
      */
+    @Override
     public boolean onComplexBlockChange(Player player, ComplexBlock complexBlock) {
         if (blacklist != null) {
             if (complexBlock instanceof Chest) {
@@ -568,6 +565,7 @@ public class WorldGuardListener extends PluginListener {
      *            complex block that's being sent
      * @return true if you want the chest, furnace or sign to be empty
      */
+    @Override
     public boolean onSendComplexBlock(Player player, ComplexBlock complexBlock) {
         if (blacklist != null) {
             if (complexBlock instanceof Chest) {
@@ -583,15 +581,6 @@ public class WorldGuardListener extends PluginListener {
                 Block block = new Block(id, complexBlock.getX(),
                         complexBlock.getY(), complexBlock.getZ());
 
-                if (!blacklist.onSilentUse(block, player)) {
-                    return true;
-                }
-            } else if (complexBlock instanceof Sign) {
-                int id = etc.getServer().getBlockIdAt(complexBlock.getX(),
-                        complexBlock.getY(), complexBlock.getZ());
-                Block block = new Block(id, complexBlock.getX(),
-                        complexBlock.getY(), complexBlock.getZ());
-
                 if (!blacklist.onSilentUse(block, player)) {
                     return true;
                 }
@@ -612,6 +601,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont want the fire to ignite.
      */
+    @Override
     public boolean onIgnite(Block block, Player player) {
         if (preventLavaFire && block.getStatus() == 1) {
             return true;
@@ -656,6 +646,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont the block to explode.
      */
+    @Override
     public boolean onExplode(Block block) {
         if (blockCreepers && block.getStatus() == 2) {
             return true;
@@ -681,6 +672,7 @@ public class WorldGuardListener extends PluginListener {
      *
      * @return true if you dont want the substance to flow.
      */
+    @Override
     public boolean onFlow(Block blockFrom, Block blockTo) {
         int x = blockFrom.getX();
         int y = blockFrom.getY();
@@ -726,34 +718,44 @@ public class WorldGuardListener extends PluginListener {
         return false;
     }
 
+    /**
+     * Called when the game is checking the physics for a certain block.
+     * This method is called frequently whenever a nearby block is changed,
+     * or if the block has just been placed.
+     * Currently the only supported blocks are sand, gravel and portals.
+     *
+     * @param block Block which requires special physics
+     * @param boolean true if this block has just been placed
+     * @return true if you do want to stop the default physics for this block
+     */
+    public boolean onBlockPhysics(Block block, boolean placed) {
+        int id = block.getType();
+
+        if (id == 13 && noPhysicsGravel) {
+            return true;
+        }
+
+        if (id == 12 && noPhysicsSand) {
+            return true;
+        }
+
+        if (id == 90 && allowPortalAnywhere) {
+            return true;
+        }
+        
+    	return false;
+    }
+
     /**
      * Called on player disconnect
      *
      * @param player
      */
+    @Override
     public void onDisconnect(Player player) {
         BlacklistEntry.forgetPlayer(player);
     }
 
-    /**
-     * Checks if a block can be destroyed.
-     * 
-     * @param player
-     * @param block
-     * @return
-     */
-    public boolean canDestroyBlock(Player player, Block block) {
-        plugin.toggleEnabled(); // Prevent infinite loop
-        try {
-            return !(Boolean)etc.getLoader().callHook(PluginLoader.Hook.BLOCK_DESTROYED,
-                    new Object[]{ player.getUser(), block });
-        } catch (Throwable t) {
-            return true;
-        } finally {
-            plugin.toggleEnabled();
-        }
-    }
-
     /**
      * Call to disable the plugin.
      */

src/com/sk89q/worldguard/ConsoleLogFormat.java

@@ -1,64 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard;
-
-import java.util.logging.Formatter;
-import java.util.logging.LogRecord;
-import java.util.logging.Level;
-import java.io.PrintWriter;
-import java.io.StringWriter;
-
-/**
- * Used for formatting.
- *
- * @author sk89q
- */
-public class ConsoleLogFormat extends Formatter {
-    public String format(LogRecord record) {
-        StringBuilder text = new StringBuilder();
-        Level level = record.getLevel();
-
-        if (level == Level.FINEST) {
-            text.append("[FINEST] ");
-        } else if (level == Level.FINER) {
-            text.append("[FINER] ");
-        } else if (level == Level.FINE) {
-            text.append("[FINE] ");
-        } else if (level == Level.INFO) {
-            text.append("[INFO] ");
-        } else if (level == Level.WARNING) {
-            text.append("[WARNING] ");
-        } else if (level == Level.SEVERE) {
-            text.append("[SEVERE] ");
-        }
-
-        text.append(record.getMessage());
-        text.append("\r\n");
-
-        Throwable t = record.getThrown();
-        if (t != null) {
-            StringWriter writer = new StringWriter();
-            t.printStackTrace(new PrintWriter(writer));
-            text.append(writer.toString());
-        }
-        
-        return text.toString();
-    }
-}

src/com/sk89q/worldguard/SimpleLogFormat.java

@@ -1,47 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.logging.Formatter;
-import java.util.logging.LogRecord;
-import java.util.logging.Level;
-
-/**
- * Used for formatting.
- *
- * @author sk89q
- */
-public class SimpleLogFormat extends Formatter {
-    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-    public String format(LogRecord record) {
-        StringBuilder text = new StringBuilder();
-        Level level = record.getLevel();
-
-        text.append("[");
-        text.append(dateFormat.format(new Date(record.getMillis())));
-        text.append("] ");
-        text.append(record.getMessage());
-        text.append("\r\n");
-        
-        return text.toString();
-    }
-}

worldguard-blacklist.txt

@@ -15,13 +15,17 @@
 #
 # Options:
 # - ignore-groups (comma-delimited list of groups to not affect)
+# - comment (message for yourself that is printed with 'log' and 'notify')
+# - message (optional message to show the user instead; %s is the item name)
 #
 # Events:
 # - on-destroy (when a block of this type is being destroyed)
+# - on-break (when a block of this type is about to be broken)
 # - on-destroy-with (the item/block held by the user while destroying)
 # - on-create (the item/block in the user's inventory is being created)
 # - on-use (the block is right clicked)
 # - on-drop (the item is being dropped from the player's inventory)
+# - on-acquire (the item enters a player's inventory via some method)
 #
 # Actions (for events):
 # - deny (deny completely)
@@ -31,6 +35,13 @@
 # - kick (kick player)
 # - ban (ban player)
 #
+# With the on-acquire event, it will completely block item pick ups
+# (the item will still be on the ground) if you use 'deny' but the other
+# actions (notify, log, etc.) won't do anything. However, if the player
+# receives the item via a different method (i.e. from a chest), all actions
+# will work although the item is removed after a short delay rather than
+# blocked from the beginning (as it is part client-side).
+#
 # Users with the /worldguardnotify permission will be receive notifications.
 #
 # -------------
@@ -67,4 +78,14 @@
 #on-destroy=notify,deny,log
 
 #[cobblestone]
-#on-create=deny,tell,log
+#on-create=deny,tell,log
+
+#[lever]
+#on-break=deny
+
+# This is an example of the 'durability cheat' workaround that destroys your
+# tool when you drop it
+#[256,257,258,259,267,268,269,270,271,272,273,274,275,276,277,278,279,283,284,285,286,290,291,292,293,294,346]
+#on-drop=deny,tell
+#comment=Durability Hacks
+#message=Your tool was destroyed

worldguard.properties

@@ -0,0 +1,50 @@
+# This is a starter copy of WorldGuard's configuration so you can configure
+# WorldGuard right from the beginning. Copy it into your server folder
+# (into where server.properties resides) and edit the file as your desire.
+# These comments will be lost whenever WorldGuard updates this file.
+# More detailed descriptions of the options can be found in README.txt!
+
+summary-on-start=true
+
+# Toggle the item durabiltiy fix
+item-durability=true
+
+# Simulate sponge
+simulate-sponge=false
+sponge-radius=3
+
+# Simulate classic water
+classic-water=false
+
+# Adjust physics
+allow-portal-anywhere=false
+no-physics-gravel=false
+no-physics-sand=false
+
+# Protection
+enforce-single-session=true
+item-drop-blacklist=
+
+# Simple prevention
+block-creepers=false
+block-lighter=false
+block-tnt=false
+
+# Control fire
+disable-all-fire-spread=false
+disallowed-fire-spread-blocks=
+
+# Disable lava fire and spread
+disable-lava-fire=false
+allowed-lava-spread-blocks=
+
+# Log/blacklist
+log-console=true
+log-database-dsn=jdbc\:mysql\://localhost\:3306/minecraft
+log-database-pass=
+log-database-table=blacklist_events
+log-database-user=root
+log-database=false
+log-file-open-files=10
+log-file-path=worldguard/logs/%Y-%m-%d.log
+log-file=false