Updated for 1.7.

- The blacklist's method of preventing notification repeats is now better, instead waiting 3 seconds before notifying again (before it didn't notify again at all unless the user started using another blocked action).
- To give users the ability to receive notifications, the command to give permission to has been changed to /worldguardnotify, although the old one (that was never mentioned anywhere) still works.
- Water and lava buckets are now psuedo-blocked using an unreliable method that risks the stability of your server (no other plugin does it better though). Use it as your own risk.
- Added on item drop and on item use (i.e. chest) events.
- Chests, signs, and furnaces can now be blocked better with the blacklist system.
- The event names in the blacklist configuration have changed but the old event names should still work. The new names should make "more sense."
- A new "ban" action has been added to the blacklist.
- Action messages have been improved, now longer saying "destroyed" for everything.
- Logging to file has been completely changed, allowing you to use the date and time and the player's username in the log filename. It no longer rotates log files based on size, however.
- Logging to database is now supported.

CHANGELOG.txt

@@ -1,3 +1,119 @@
+1.7
+- Updated for v0.2.6_02 and hMod b129.
+- Added option to prevent water from damaging particular blocks
+    (Redstone wire, Minecart tracks, etc.). See disable-water-damage-blocks.
+- /reload WorldGuard should now reload WorldGuard's configuration.
+- Added wg-invincible and wg-amphibious groups that let you give certain
+    players invincibility or underwater breathing.
+- Added the ability to disable fall, water, lava, and/or fire damage.
+- Water/lava bucket blocking should now be more reliable.
+- Added /stack (alias /;) commands to stack items in your inventory into
+    piles up to 64 items in size. Even unstackable items like signs can be
+    stacked.
+- /god mode should now let you gain health.
+- /god mode should now work more reliably.
+- Caught an error message for when the configuration file does not exist.
+
+1.6
+- Added spawn protection that prevents damage when a player spawns.
+- Added login protection that prevents damage when a player joins.
+- Added /god. /god can be used on others, provided that the /godother
+    permission is set for the command's user.
+
+1.5.1
+- Removed the 'java.lang.NoSuchMethodError: Item.setDamage(I)V' error
+    generated.
+
+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.
+- Sponge updated to remove water when the sponge block is set. Sponge radius
+    can now be controlled using the 'sponge-radius' parameter and the
+    default is now set to simulate Classic.
+- Updated for a newer build of "b126," meaning that lava spread control
+    now works well!
+- A new summary of the status of some core protections is now printed
+    on start. Disable this with 'summary-on-start'.
+- Blacklist system has been overhauled. Check README.txt for changed
+    configuration settings!
+- The blacklist's method of preventing notification repeats is now better,
+    instead waiting 3 seconds before notifying again (before it didn't
+    notify again at all unless the user started using another blocked
+    action).
+- To give users the ability to receive notifications, the command to give
+    permission to has been changed to /worldguardnotify, although the
+    old one (that was never mentioned anywhere) still works.
+- Water and lava buckets are now psuedo-blocked using an unreliable
+    method that risks the stability of your server (no other plugin
+    does it better though). Use it as your own risk.
+- Added on item drop and on item use (i.e. chest) events.
+- Chests, signs, and furnaces can now be blocked better with the
+    blacklist system.
+- The event names in the blacklist configuration have changed but the old
+    event names should still work. The new names should make "more sense."
+- A new "ban" action has been added to the blacklist.
+- Action messages have been improved, now longer saying "destroyed"
+    for everything.
+- Logging to file has been completely changed, allowing you to use
+    the date and time and the player's username in the log filename. It
+    no longer rotates log files based on size, however.
+- Logging to database is now supported.
+- Tools can now be destroyed on drop to alleviate the durability cheat.
+    You can do this with either with the blacklist or with the
+    'item-drop-blacklist' configuration option. The configuration option
+    prints more friendly messages than the 'tell' action of blacklists.
+
+1.1.2
+- Block lag fix: Snow and glass should no longer drop items.
+- Block lag fix: Block object now reset after hook call.
+
 1.1.1
 - Fixed redstone wire dropping wood blocks with the block lag fix.
 - The block lag fix now consults other plugins so that ALL protection

README.txt

@@ -13,17 +13,20 @@ use or not:
 - Block TNT explosions.
 - Block lighters from setting fires.
 - Block all fires.
+- Disable fall damage, lava damage, fire damage, and/or water damage.
 - Allow fire but prevent it from burning certain blocks.
 - Prevent lava from starting fires.
 - Restrict lava spreading to only some block types.
 - Simulate classic-esque water by letting water infinitely expand in
     area (only if there is a block underneath).
-- Simulate the sponge.
-- Block the use, destruction and/or placement of some items or block types.
-- Notify admins when a certain block type or item is used, destroyed,
-    or place.
-- Log the use, destruction, and/or placement of some blocks/items.
-- Kick for the use, destruction, and/or placement of some blocks.
+- Prevent water from destroying blocks like Redstone wire and flowers.
+- Simulate the function of the sponge from Minecraft Classic.
+- Notify admins, block, log, kick or ban for the use of certain block types
+    or items.
+- Temporarily stop fire globally with some commands.
+- Destroy tools on drop to alleviate the durability cheat.
+- Prevent gravel and sand from falling.
+- Allow portal blocks to be placed anywhere.
 
 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,50 +57,47 @@ 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)
-    Toggle simulation of the sponge. The sponge only prevents water
-    from spreading. It will not take away existing water. Simulation of
-    the sponge requires iterating over a 9x9x9 cuboid around the water
-    block and the resource impact of this has not been quantified.
+- simulate-sponge (def. true)
+    Toggle simulation of the sponge from Classic. It blocks water from
+    flowing near the sponge.
+
+- sponge-radius (def. 3)
+    The radius of the sponge's effect. The default is that of Classic,
+    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
     an informative message. The inventory will have been saved before
     the new session starts.
-
-- blacklist-log-console (def. true)
-    For log actions, print to console as well.
-
-- blacklist-log-file (no default)
-    File to log to. Log files are automatically rotated based on size, and
-    you can use these patterns in the path:
-        %t the system temporary directory
-        %h the value of the "user.home" system property
-        %g the generation number to distinguish rotated logs
-        %u a unique number to resolve conflicts
-        %% translates to a single percent sign "%"
-    There is no way to put the date in the filename or rotate by date.
-
-- blacklist-log-file-limit (def. 5242880)
-    Size in bytes before the log file is rotated.
-
-- blacklist-log-file-count (def. 10)
-    Number of log files to keep in rotation at maximum.
-
+    
 - block-tnt (def. false)
     Block TNT explosions. TNT will still explode client-side but the blocks
     will be "restored" in a few seconds afterwards.
-
+    
 - block-lighter (def. false)
     Block flint and steel fires. Those with access to the commands
     /uselighter or /lighter can bypass this. /uselighter is not a real
     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)
@@ -100,11 +112,140 @@ WorldGuard on your server. You can either restart your server or use
     to disable this feature. Enabling disable-all-fire-spread will
     override this function.
 
-- block-lag-fix (def. false)
-    Attempts to fix block lag.
+- disable-water-damage-blocks (no default)
+    List of blocks that should not be destroyed by water (Redstone wire,
+    minecart tracks, flowers, etc.).
+
+- item-drop-blacklist (no default)
+    List of block names/IDs to destroy on drop. This can alleviate the
+    durability cheat that allows you to drop your tools to fix their
+    durability. You can also enforce this with the blacklist but
+    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).
+
+- login-protection (def. 3)
+    Number of seconds to keep a player invincible when the player joins.
+
+- spawn-protection (def. 0)
+    Number of seconds to keep a player invincible when the player spawns.
+    This does not apply to players joining the server.
+
+- kick-on-death (def. false)
+    Kick players when they die (and respawn). This is to work around the
+    issues of invisible players when players die.
+    
+- disable-fall-damage (def. false)
+- disable-lava-damage (def. false)
+- disable-fire-damage (def. false)
+- disable-water-damage (def. false)
+    Disable various types of damage.
+    
+- log-console (def. true)
+    For blacklist log actions, print to console.
+
+- log-file (def. false)
+    For blacklist log actions, log to file.
+    
+- log-file-path (def. "worldguard/logs/%Y-%m-%d.log")
+    Log blacklist events to file. You can use these patterns in the path:
+        %Y the year (YYYY)
+        %m the month (MM)
+        %d the day (DD)
+        %W the week of the year (00-52)
+        %H 24-hour time (HH)
+        %h 12-hour time (HH)
+        %i the minute (mm)
+        %s the second (ss)
+        %u the user's name
+        %% translates to a single percent sign "%"
+    The files are not automatically rotated if they get large so you should
+    perhaps put a week in the filename at least.
+    
+    Escape backslashes with another backslash, like so:
+    C:\path\to\log.txt -> C:\\path\\to\\log.txt
+
+- log-file-open-files (def. 10)
+    The number of log files to keep open at once. Unless you use dynamic
+    patterns in the path, the value of this variable won't matter. However,
+    if, for example, you use a player's username in the filename and you
+    have many users who cause logged events to occur, files would have
+    to be opened for each user and this parameter would matter.
+
+- log-database (def. false)
+    Log blacklist events to database.
+
+- log-database-dsn (def. "jdbc:mysql://localhost:3306/minecraft")
+    Connection string. A string to use for MySQL would be:
+    jdbc:mysql://localhost:3306/minecraft
+    The "minecraft" part at the end is the database name.
+    
+    Escape colons with a backslash, like so:
+    jdbc:mysql://localhost:3306/minecraft
+    ->
+    jdbc\:mysql\://localhost\:3306/minecraft
+
+- log-database-user (def. "root")
+    Database username.
+
+- log-database-pass (def. "")
+    Database password.
+
+- log-database-table (def. "blacklist_events")
+    Database table to use.
+
+Commands
+--------
+
+- /stopfire and /allowfire
+    Disables and enables fire spread globally. Both commands require the
+    permission to use only "/stopfire. Re-enabling fire spread with this
+    command will not override other fire spread control features of
+    WorldGuard. Note that disabling fire does not disable fire damage
+    but fire at least won't spread.
+
+- /god
+    Toggles your invincibility. Players must have permission to use "/god"
+    to be able to use this command. You can also use this command to
+    toggle the invincibility of others although you must have the
+    "/godother" permission.
+
+Server Commands
+---------------
+
+- fire-stop and fire-allow
+    Disables and enables fire spread globally. Re-enabling fire spread
+    with this command will not override other fire spread control features
+    of WorldGuard. Note that disabling fire does not disable fire damage
+    but fire at least won't spread.
 
 Blacklists
 ----------
 
+Blacklists let you control the use of blocks and items. You can have
+certain rules apply to only some groups.
+
 Edit the included worldguard-blacklist.txt file and follow the
-instructions inside.
+instructions inside. The file comes with the download for WorldGuard.
+
+Other Features
+--------------
+
+To give someone invincibility every time s/he joins the server, create
+a wg-invincible group and add the group to the user or have the user's
+group inherit this group.
+
+To give someone the ability to breathe under water, create
+a wg-amphibious group and add the group to the user or have the user's
+group inherit this group.
+
+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

@@ -0,0 +1,21 @@
+-- Blacklist table for MySQL.
+-- You must still configure WorldGuard to use your database.
+-- If you do not plan on using a database for logging blacklist events,
+-- you do not need to do anything with this file.
+
+CREATE TABLE `blacklist_events` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `event` varchar(25) NOT NULL,
+  `player` varchar(16) NOT NULL,
+  `x` int(11) NOT NULL,
+  `y` int(11) NOT NULL,
+  `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.1.1
+WorldGuard-Version: 1.7

src/Blacklist.java

@@ -0,0 +1,397 @@
+// $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/>.
+*/
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.io.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class Blacklist {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    
+    /**
+     * List of entries by block ID.
+     */
+    private Map<Integer,List<BlacklistEntry>> blacklist
+            = new HashMap<Integer,List<BlacklistEntry>>();
+    /**
+     * Logger.
+     */
+    private BlacklistLogger blacklistLogger = new BlacklistLogger();
+
+    /**
+     * Blacklist contains on-acquire events.
+     */
+    private boolean hasOnAcquire;
+
+    /**
+     * Returns whether the list is empty.
+     * 
+     * @return
+     */
+    public boolean isEmpty() {
+        return blacklist.isEmpty();
+    }
+
+    /**
+     * Get the entries for an item or list.
+     */
+    public List<BlacklistEntry> getEntries(int id) {
+        return blacklist.get(id);
+    }
+    
+    /**
+     * Get the logger.
+     * 
+     * @return
+     */
+    public BlacklistLogger getLogger() {
+        return blacklistLogger;
+    }
+
+    /**
+     * Called on block destruction. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onDestroy(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.onDestroy(block, player)) {
+                ret = false;
+            }
+        }
+        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.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onDestroyWith(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onDestroyWith(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on right click. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onCreate(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onCreate(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on right click upon. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onUse(Block block, Player player) {
+        List<BlacklistEntry> entries = getEntries(block.getType());
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onUse(block, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on right click upon. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onSilentUse(Block block, Player player) {
+        List<BlacklistEntry> entries = getEntries(block.getType());
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onSilentUse(block, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on drop. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onDrop(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onDrop(item, player)) {
+                ret = false;
+            }
+        }
+        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.
+     *
+     * @param file
+     * @return
+     * @throws IOException
+     */
+    public void load(File file) throws IOException {
+        FileReader input = null;
+        Map<Integer,List<BlacklistEntry>> blacklist =
+                new HashMap<Integer,List<BlacklistEntry>>();
+
+        try {
+            input = new FileReader(file);
+            BufferedReader buff = new BufferedReader(input);
+
+            hasOnAcquire = false;
+
+            String line;
+            List<BlacklistEntry> currentEntries = null;
+            while ((line = buff.readLine()) != null) {
+                line = line.trim();
+
+                // Blank line
+                if (line.length() == 0) {
+                    continue;
+                } else if (line.charAt(0) == ';' || line.charAt(0) == '#') {
+                    continue;
+                }
+
+                if (line.matches("^\\[.*\\]$")) {
+                    String[] items = line.substring(1, line.length() - 1).split(",");
+                    currentEntries = new ArrayList<BlacklistEntry>();
+
+                    for (String item : items) {
+                        int id = 0;
+
+                        try {
+                            id = Integer.parseInt(item.trim());
+                        } catch (NumberFormatException e) {
+                            id = etc.getDataSource().getItem(item.trim());
+                            if (id == 0) {
+                                logger.log(Level.WARNING, "WorldGuard: Unknown block name: "
+                                        + item);
+                                break;
+                            }
+                        }
+
+                        BlacklistEntry entry = new BlacklistEntry(this);
+                        if (blacklist.containsKey(id)) {
+                            blacklist.get(id).add(entry);
+                        } else {
+                            List<BlacklistEntry> entries = new ArrayList<BlacklistEntry>();
+                            entries.add(entry);
+                            blacklist.put(id, entries);
+                        }
+                        currentEntries.add(entry);
+                    }
+                } else if (currentEntries != null) {
+                    String[] parts = line.split("=");
+
+                    if (parts.length == 1) {
+                        logger.log(Level.WARNING, "Found option with no value "
+                                + file.getName() + " for '" + line + "'");
+                        continue;
+                    }
+
+                    boolean unknownOption = false;
+
+                    for (BlacklistEntry entry : currentEntries) {
+                        if (parts[0].equalsIgnoreCase("ignore-groups")) {
+                            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(","));
+                        } else if (parts[0].equalsIgnoreCase("on-right")
+                                || parts[0].equalsIgnoreCase("on-create")) {
+                            entry.setCreateActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-right-on")
+                                || parts[0].equalsIgnoreCase("on-use")) {
+                            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;
+                        }
+                    }
+
+                    if (unknownOption) {
+                        logger.log(Level.WARNING, "Unknown option '" + parts[0]
+                                + "' in " + file.getName() + " for '" + line + "'");
+                    }
+                } else {
+                    logger.log(Level.WARNING, "Found option with no heading "
+                            + file.getName() + " for '" + line + "'");
+                }
+            }
+
+            this.blacklist = blacklist;
+        } finally {
+            try {
+                if (input != null) {
+                    input.close();
+                }
+            } catch (IOException e2) {
+            }
+        }
+    }
+
+    /**
+     * Blacklist contains on-acquire events.
+     * 
+     * @return
+     */
+    public boolean hasOnAcquire() {
+        return hasOnAcquire;
+    }
+}

src/BlacklistEntry.java

@@ -32,12 +32,12 @@ public class BlacklistEntry {
     /**
      * Used to prevent spamming.
      */
-    private static Map<String,Integer> lastAffected =
-            new HashMap<String,Integer>();
+    private static Map<String,BlacklistTrackedEvent> lastAffected =
+            new HashMap<String,BlacklistTrackedEvent>();
     /**
-     * Logger.
+     * Parent blacklist entry.
      */
-    private static final Logger logger = Logger.getLogger("WorldGuard.Blacklist");
+    private Blacklist blacklist;
     /**
      * List of groups to not affect.
      */
@@ -46,14 +46,58 @@ 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.
      */
-    private String[] leftClickActions;
+    private String[] destroyWithActions;
     /**
      * List of actions to perform on right click.
      */
-    private String[] rightClickActions;
+    private String[] createActions;
+    /**
+     * List of actions to perform on right click upon.
+     */
+    private String[] useActions;
+    /**
+     * 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.
+     * 
+     * @param blacklist
+     */
+    public BlacklistEntry(Blacklist blacklist) {
+        this.blacklist = blacklist;
+    }
 
     /**
      * @return the ignoreGroups
@@ -74,45 +118,129 @@ public class BlacklistEntry {
     }
 
     /**
-     * @return the destroyActions
+     * @return
      */
     public String[] getDestroyActions() {
         return destroyActions;
     }
 
     /**
-     * @param destroyActions the destroyActions to set
+     * @param actions
      */
-    public void setDestroyActions(String[] destroyActions) {
-        this.destroyActions = destroyActions;
+    public void setDestroyActions(String[] actions) {
+        this.destroyActions = actions;
     }
 
     /**
-     * @return the leftClickActions
+     * @return
      */
-    public String[] getLeftClickActions() {
-        return leftClickActions;
+    public String[] getBreakActions() {
+        return breakActions;
     }
 
     /**
-     * @param leftClickActions the leftClickActions to set
+     * @param actions
      */
-    public void setLeftClickActions(String[] leftClickActions) {
-        this.leftClickActions = leftClickActions;
+    public void setBreakActions(String[] actions) {
+        this.breakActions = actions;
+    }
+
+    /**
+     * @return
+     */
+    public String[] getDestroyWithActions() {
+        return destroyWithActions;
+    }
+
+    /**
+     * @param action
+     */
+    public void setDestroyWithActions(String[] actions) {
+        this.destroyWithActions = actions;
     }
 
     /**
      * @return the rightClickActions
      */
-    public String[] getRightClickActions() {
-        return rightClickActions;
+    public String[] getCreateActions() {
+        return createActions;
     }
 
     /**
-     * @param rightClickActions the rightClickActions to set
+     * @param actions
      */
-    public void setRightClickActions(String[] rightClickActions) {
-        this.rightClickActions = rightClickActions;
+    public void setCreateActions(String[] actions) {
+        this.createActions = actions;
+    }
+
+    /**
+     * @return
+     */
+    public String[] getUseActions() {
+        return useActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setUseActions(String[] actions) {
+        this.useActions = actions;
+    }
+
+    /**
+     * @return
+     */
+    public String[] getDropActions() {
+        return dropActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setDropActions(String[] actions) {
+        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;
     }
 
     /**
@@ -141,19 +269,25 @@ public class BlacklistEntry {
      */
     public void notifyAdmins(String str) {
         for (Player player : etc.getServer().getPlayerList()) {
-            if (player.canUseCommand("/wprotectalerts")) {
-                player.sendMessage(Colors.LightPurple + "WorldGuard: " + str);
+            if (player.canUseCommand("/wprotectalerts")
+                    || player.canUseCommand("/worldguardnotify")) {
+                player.sendMessage(Colors.LightGray + "WG: " + str);
             }
         }
     }
 
     /**
-     * Log a message.
+     * Ban a player.
      * 
-     * @param message
+     * @param player
+     * @param msg
      */
-    public void log(String message) {
-        logger.log(Level.INFO, message);
+    public void banPlayer(Player player, String msg) {
+        etc.getServer().ban(player.getName());
+        etc.getLoader().callHook(PluginLoader.Hook.BAN, new Object[]{
+            player.getUser(), player.getUser(), msg
+        });
+        player.kick(msg);
     }
 
     /**
@@ -164,13 +298,70 @@ public class BlacklistEntry {
      * @param player
      * @return
      */
-    public boolean onDestroy(Block block, Player player) {
+    public boolean onDestroy(final Block block, final Player player) {
         if (destroyActions == null) {
             return true;
         }
-        boolean ret = process(block.getType(), player, destroyActions);
-        lastAffected.put(player.getName(), block.getType());
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logDestroyAttempt(player, block, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You are not allowed to destroy " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You are not allowed to destroy " + itemName);
+            }
+            public void notifyAdmins(String 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, 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);
     }
 
     /**
@@ -180,29 +371,207 @@ public class BlacklistEntry {
      * @param player
      * @return
      */
-    public boolean onLeftClick(int item, Player player) {
-        if (leftClickActions == null) {
+    public boolean onDestroyWith(final int item, final Player player) {
+        if (destroyWithActions == null) {
             return true;
         }
-        boolean ret = process(item, player, leftClickActions);
-        lastAffected.put(player.getName(), item);
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logDestroyWithAttempt(player, item, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't destroy with " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't destroy with " + itemName);
+            }
+            public void notifyAdmins(String 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, false, false);
     }
 
     /**
-     * Called on right right. Returns true to let the action pass through.
+     * Called on right click. Returns true to let the action pass through.
      *
      * @param item
      * @param player
      * @return
      */
-    public boolean onRightClick(int item, Player player) {
-        if (rightClickActions == null) {
+    public boolean onCreate(final int item, final Player player) {
+        if (createActions == null) {
             return true;
         }
-        boolean ret = process(item, player, rightClickActions);
-        lastAffected.put(player.getName(), item);
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logCreateAttempt(player, item, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't place " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't place " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (place) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You can't place " + itemName + ".");
+            }
+        };
+
+        return process(item, player, createActions, handler, true, false);
+    }
+
+    /**
+     * Called on right click upon. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onUse(final Block block, final Player player) {
+        if (useActions == null) {
+            return true;
+        }
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logUseAttempt(player, block, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't use " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't use " + itemName);
+            }
+            public void notifyAdmins(String 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, false, false);
+    }
+
+    /**
+     * Called on right click upon. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onSilentUse(final Block block, final Player player) {
+        if (useActions == null) {
+            return true;
+        }
+
+        return process(block.getType(), player, useActions, silentHandler, false, true);
+    }
+
+    /**
+     * Called on item drop. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onDrop(final int item, final Player player) {
+        if (dropActions == null) {
+            return true;
+        }
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logDropAttempt(player, item, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't drop " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't drop " + itemName);
+            }
+            public void notifyAdmins(String 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, 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);
     }
 
     /**
@@ -211,35 +580,82 @@ 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) {
+    private boolean process(int id, Player player, String[] actions,
+            ActionHandler handler, boolean allowRepeat, boolean silent) {
+
         if (shouldIgnore(player)) {
             return true;
         }
 
         String name = player.getName();
-        boolean repeating = lastAffected.containsKey(name)
-                && lastAffected.get(name) == id;
+        long now = System.currentTimeMillis();
+        boolean repeating = false;
+
+        // Check to see whether this event is being repeated
+        BlacklistTrackedEvent tracked = lastAffected.get(name);
+        if (tracked != null) {
+            if (tracked.getId() == id && tracked.getTime() > now - 3000) {
+                repeating = true;
+            } else {
+                tracked.setTime(now);
+                tracked.setId(id);
+            }
+        } else {
+            lastAffected.put(name, new BlacklistTrackedEvent(id, now));
+        }
 
         boolean ret = true;
         
         for (String action : actions) {
+            // Deny
             if (action.equalsIgnoreCase("deny")) {
+                if (silent) {
+                    return false;
+                }
                 ret = false;
+
+            // Kick
             } else if (action.equalsIgnoreCase("kick")) {
-                player.kick("Performed disallowed action with "
-                        + etc.getDataSource().getItem(id) + ".");
-            } else if (!repeating) {
+                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));
+                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")) {
-                    notifyAdmins(player.getName() + " on destroy: "
-                            + etc.getDataSource().getItem(id));
+                    handler.notifyAdmins(etc.getDataSource().getItem(id));
+                
+                // Log
                 } else if (action.equalsIgnoreCase("log")) {
-                    log(player.getName() + " on destroy: "
-                            + etc.getDataSource().getItem(id));
-                } else if (!repeating && action.equalsIgnoreCase("tell")) {
-                    player.sendMessage("Can't do that with "
-                            + etc.getDataSource().getItem(id) + ".");
+                    handler.log(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));
+                    }
                 }
             }
         }
@@ -262,6 +678,17 @@ public class BlacklistEntry {
      * @param player
      */
     public static void forgetAllPlayers() {
-        lastAffected = new HashMap<String,Integer>();
+        lastAffected.clear();
+    }
+
+    /**
+     * Gets called for actions.
+     */
+    private static interface 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);
     }
 }

src/BlacklistLogger.java

@@ -0,0 +1,153 @@
+// $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/>.
+*/
+
+import java.util.Set;
+import java.util.HashSet;
+
+/**
+ *
+ * @author sk89q
+ */
+public class BlacklistLogger implements BlacklistLoggerHandler {
+    /**
+     * List of logger handlers.
+     */
+    private Set<BlacklistLoggerHandler> handlers
+            = new HashSet<BlacklistLoggerHandler>();
+
+    /**
+     * Add a handler.
+     *
+     * @param handler
+     */
+    public void addHandler(BlacklistLoggerHandler handler) {
+        handlers.add(handler);
+    }
+
+    /**
+     * Add a handler.
+     *
+     * @param handler
+     */
+    public void removeHandler(BlacklistLoggerHandler handler) {
+        handlers.remove(handler);
+    }
+
+    /**
+     * Add a handler.
+     *
+     * @param handler
+     */
+    public void clearHandlers() {
+        handlers.clear();
+    }
+
+    /**
+     * Log a block destroy attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logDestroyAttempt(Player player, Block block, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            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);
+        }
+    }
+
+    /**
+     * Log a right click on attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logUseAttempt(Player player, Block block, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logUseAttempt(player, block, comment);
+        }
+    }
+
+    /**
+     * Right a left click attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logDestroyWithAttempt(player, item, comment);
+        }
+    }
+
+    /**
+     * Log a right click attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logCreateAttempt(Player player, int item, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logCreateAttempt(player, item, comment);
+        }
+    }
+
+    /**
+     * Log a drop attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDropAttempt(Player player, int item, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            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);
+        }
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.close();
+        }
+    }
+}

src/BlacklistLoggerHandler.java

@@ -0,0 +1,79 @@
+// $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/>.
+*/
+
+/**
+ * Interface for loggers for the blacklist.
+ *
+ * @author sk89q
+ */
+public interface BlacklistLoggerHandler {
+    /**
+     * Log a block destroy attempt.
+     *
+     * @param player
+     * @param 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, String comment);
+    /**
+     * Right a left click attempt.
+     * 
+     * @param player
+     * @param 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, String comment);
+    /**
+     * Log a drop attempt.
+     *
+     * @param player
+     * @param 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.
+     */
+    public void close();
+}

src/BlacklistTrackedEvent.java

@@ -0,0 +1,66 @@
+// $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/>.
+*/
+
+/**
+ *
+ * @author sk89q
+ */
+public class BlacklistTrackedEvent {
+    private int id;
+    private long time;
+
+    /**
+     * Construct the object.
+     * 
+     * @param id
+     * @param time
+     */
+    public BlacklistTrackedEvent(int id, long time) {
+        this.id = id;
+        this.time = time;
+    }
+
+    /**
+     * @return the id
+     */
+    public int getId() {
+        return id;
+    }
+
+    /**
+     * @param id the id to set
+     */
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    /**
+     * @return the time
+     */
+    public long getTime() {
+        return time;
+    }
+
+    /**
+     * @param time the time to set
+     */
+    public void setTime(long time) {
+        this.time = time;
+    }
+}

src/ConsoleLoggerHandler.java

@@ -0,0 +1,131 @@
+// $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/>.
+*/
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+
+/**
+ *
+ * @author sk89q
+ */
+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, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " 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 + ")" : ""));
+    }
+
+    /**
+     * Log a right click on attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logUseAttempt(Player player, Block block, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " tried to use " + getFriendlyItemName(block.getType())
+                + (comment != null ? " (" + comment + ")" : ""));
+    }
+    
+    /**
+     * Log an attempt to destroy with an item.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " tried to destroy with " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
+    }
+
+    /**
+     * Log a block creation attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logCreateAttempt(Player player, int item, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " tried to create " + getFriendlyItemName(item)
+                + (comment != null ? " (" + comment + ")" : ""));
+    }
+
+    /**
+     * Log a drop attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDropAttempt(Player player, int item, String comment) {
+        logger.log(Level.INFO, "WorldGuard: " + player.getName()
+                + " 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 + ")" : ""));
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     * 
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        return etc.getDataSource().getItem(id) + " (#" + id + ")";
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+    }
+}

src/DatabaseLoggerHandler.java

@@ -0,0 +1,215 @@
+// $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/>.
+*/
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+
+/**
+ *
+ * @author sk89q
+ */
+public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+
+    /**
+     * DSN.
+     */
+    private String dsn;
+    /**
+     * Username.
+     */
+    private String user;
+    /**
+     * Password.
+     */
+    private String pass;
+    /**
+     * Table.
+     */
+    private String table;
+    /**
+     * Database connection.
+     */
+    private Connection conn;
+
+    /**
+     * Construct the object.
+     * 
+     * @param dsn
+     * @param user
+     * @param pass
+     */
+    public DatabaseLoggerHandler(String dsn, String user, String pass, String table) {
+        this.dsn = dsn;
+        this.user = user;
+        this.pass = pass;
+        this.table = table;
+    }
+
+    /**
+     * Gets the database connection.
+     * 
+     * @return
+     * @throws SQLException
+     */
+    private Connection getConnection() throws SQLException {
+        if (conn == null || conn.isClosed()) {
+            conn = DriverManager.getConnection(dsn, user, pass);
+        }
+        return conn;
+    }
+
+    /**
+     * Log an event to the database.
+     * 
+     * @param event
+     * @param name
+     * @param x
+     * @param y
+     * @param z
+     * @param item
+     * @param comment
+     */
+    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, comment) VALUES "
+                  + "(?, ?, ?, ?, ?, ?, ?, ?)");
+            stmt.setString(1, event);
+            stmt.setString(2, name);
+            stmt.setInt(3, x);
+            stmt.setInt(4, y);
+            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, String comment) {
+        logEvent("DESTROY", player.getName(),
+                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);
+    }
+
+    /**
+     * Log a right click on attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logUseAttempt(Player player, Block block, String comment) {
+        logEvent("USE", player.getName(),
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
+    }
+    
+    /**
+     * Right a left click attempt.
+     *
+     * @param player
+     * @param 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, comment);
+    }
+
+    /**
+     * Log a right click attempt.
+     *
+     * @param player
+     * @param 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, comment);
+    }
+
+    /**
+     * Log a drop attempt.
+     *
+     * @param player
+     * @param 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, 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);
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+        try {
+            if (conn != null && !conn.isClosed()) {
+                conn.close();
+            }
+        } catch (SQLException e) {
+            
+        }
+    }
+}

src/FileLoggerHandler.java

@@ -0,0 +1,304 @@
+// $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/>.
+*/
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.io.*;
+import java.util.regex.*;
+import java.util.Map;
+import java.util.Date;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.TreeMap;
+import java.util.Iterator;
+import java.text.SimpleDateFormat;
+
+/**
+ *
+ * @author sk89q
+ */
+public class FileLoggerHandler implements BlacklistLoggerHandler {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    /**
+     * Regex for patterns in the path.
+     */
+    private static Pattern pattern = Pattern.compile("%.");
+    /**
+     * Date format.
+     */
+    private static SimpleDateFormat dateFormat =
+            new SimpleDateFormat("yyyyy-MM-dd HH:mm:ss");
+
+    /**
+     * Number of files to keep open at a time.
+     */
+    private int cacheSize = 10;
+    /**
+     * Path pattern.
+     */
+    private String pathPattern;
+    /**
+     * Cache of writers.
+     */
+    private TreeMap<String,FileLoggerWriter> writers =
+            new TreeMap<String,FileLoggerWriter>();
+
+    /**
+     * Construct the object.
+     *
+     * @param pathPattern
+     */
+    public FileLoggerHandler(String pathPattern) {
+        this.pathPattern = pathPattern;
+    }
+
+    /**
+     * Construct the object.
+     *
+     * @param pathPattern
+     * @param cacheSize
+     */
+    public FileLoggerHandler(String pathPattern, int cacheSize) {
+        if (cacheSize < 1) {
+            throw new IllegalArgumentException("Cache size cannot be less than 1");
+        }
+        this.pathPattern = pathPattern;
+        this.cacheSize = cacheSize;
+    }
+
+    /**
+     * Build the path.
+     * 
+     * @return
+     */
+    private String buildPath(String playerName) {
+        GregorianCalendar calendar = new GregorianCalendar();
+
+        Pattern p = Pattern.compile("%.");
+        Matcher m = p.matcher(pathPattern);
+        StringBuffer buffer = new StringBuffer();
+
+        // Pattern replacements
+        while (m.find()) {
+            String group = m.group();
+            String rep = "?";
+
+            if (group.matches("%%")) {
+                rep = "%";
+            } else if (group.matches("%u")) {
+                rep = playerName.toLowerCase().replaceAll("[^A-Za-z0-9_]", "_");
+                if (rep.length() > 32) { // Actual max length is 16
+                    rep = rep.substring(0, 32);
+                }
+
+            // Date and time
+            } else if (group.matches("%Y")) {
+                rep = String.valueOf(calendar.get(Calendar.YEAR));
+            } else if (group.matches("%m")) {
+                rep = String.format("%02d", calendar.get(Calendar.MONTH));
+            } else if (group.matches("%d")) {
+                rep = String.format("%02d", calendar.get(Calendar.DAY_OF_MONTH));
+            } else if (group.matches("%W")) {
+                rep = String.format("%02d", calendar.get(Calendar.WEEK_OF_YEAR));
+            } else if (group.matches("%H")) {
+                rep = String.format("%02d", calendar.get(Calendar.HOUR_OF_DAY));
+            } else if (group.matches("%h")) {
+                rep = String.format("%02d", calendar.get(Calendar.HOUR));
+            } else if (group.matches("%i")) {
+                rep = String.format("%02d", calendar.get(Calendar.MINUTE));
+            } else if (group.matches("%s")) {
+                rep = String.format("%02d", calendar.get(Calendar.SECOND));
+            }
+            
+            m.appendReplacement(buffer, rep);
+        }
+
+        m.appendTail(buffer);
+        
+        return buffer.toString();
+    }
+
+    /**
+     * Log a message.
+     * 
+     * @param player
+     * @param 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
+                    + (comment != null ? " (" + comment + ")" : "") + "\r\n";
+            
+            FileLoggerWriter writer = writers.get(path);
+
+            // Writer already exists!
+            if (writer != null) {
+                try {
+                    BufferedWriter out = writer.getWriter();
+                    out.write(line);
+                    out.flush();
+                    writer.updateLastUse();
+                    return;
+                } catch (IOException e) {
+                    // Failed initial rewrite... let's re-open
+                }
+            }
+
+            // Make parent directory
+            File file = new File(path);
+            File parent = file.getParentFile();
+            if (parent != null && !parent.exists()) {
+                parent.mkdirs();
+            }
+            
+            FileWriter stream = new FileWriter(path, true);
+            BufferedWriter out = new BufferedWriter(stream);
+            out.write(line);
+            out.flush();
+            writer = new FileLoggerWriter(path, out);
+            writers.put(path, writer);
+
+            // Check to make sure our cache doesn't get too big!
+            if (writers.size() > cacheSize) {
+                Iterator<Map.Entry<String,FileLoggerWriter>> it =
+                        writers.entrySet().iterator();
+
+                // Remove some entries
+                for (; it.hasNext(); ) {
+                    Map.Entry<String,FileLoggerWriter> entry = it.next();
+                    try {
+                        entry.getValue().getWriter().close();
+                    } catch (IOException e) {
+                    }
+                    it.remove();
+
+                    // Trimmed enough
+                    if (writers.size() <= cacheSize) {
+                        break;
+                    }
+                }
+            }
+
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to log blacklist event to '"
+                    + path + "': " + e.getMessage());
+        }
+    }
+
+    /**
+     * Log a block destroy attempt.
+     *
+     * @param player
+     * @param block
+     */
+    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);
+    }
+
+    /**
+     * Log a right click on attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logUseAttempt(Player player, Block block, String comment) {
+        log(player, "Tried to use " + getFriendlyItemName(block.getType()),
+                comment);
+    }
+
+    /**
+     * Log an attempt to destroy with an item.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
+        log(player, "Tried to destroy with " + getFriendlyItemName(item), comment);
+    }
+
+    /**
+     * Log a block creation attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logCreateAttempt(Player player, int item, String comment) {
+        log(player, "Tried to create " + getFriendlyItemName(item), comment);
+    }
+
+    /**
+     * Log a drop attempt.
+     *
+     * @param player
+     * @param 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);
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     *
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        return etc.getDataSource().getItem(id) + " (#" + id + ")";
+    }
+
+    /**
+     * Close handles.
+     */
+    public void close() {
+        for (Map.Entry<String,FileLoggerWriter> entry : writers.entrySet()) {
+            try {
+                entry.getValue().getWriter().close();
+            } catch (IOException e) {
+            }
+        }
+
+        writers.clear();
+    }
+}

src/FileLoggerWriter.java

@@ -0,0 +1,98 @@
+// $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/>.
+*/
+
+import java.io.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
+    /**
+     * Path.
+     */
+    public String path;
+    /**
+     * Writer.
+     */
+    private BufferedWriter writer;
+    /**
+     * Last use.
+     */
+    private long lastUse;
+
+    /**
+     * Construct the object.
+     * 
+     * @param writer
+     */
+    public FileLoggerWriter(String path, BufferedWriter writer) {
+        this.path = path;
+        this.writer = writer;
+        lastUse = System.currentTimeMillis();
+    }
+
+    /**
+     * File path.
+     * 
+     * @return
+     */
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * @return the writer
+     */
+    public BufferedWriter getWriter() {
+        return writer;
+    }
+
+    /**
+     * @return the lastUse
+     */
+    public long getLastUse() {
+        return lastUse;
+    }
+    
+    /**
+     * Update last use time.
+     * 
+     * @return
+     */
+    public void updateLastUse() {
+        lastUse = System.currentTimeMillis();
+    }
+
+    /**
+     * Comparison function.
+     * 
+     * @param other
+     * @return
+     */
+    public int compareTo(FileLoggerWriter other) {
+        if (lastUse > other.lastUse) {
+            return 1;
+        } else if (lastUse < other.lastUse) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+}

src/LoggerToChatHandler.java

@@ -17,31 +17,48 @@
  * 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.Logger;
 import java.util.logging.Level;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
 
 /**
- * Used for formatting.
+ * Sends all logger messages to a player.
  *
  * @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();
+public class LoggerToChatHandler extends Handler {
+    /**
+     * Player.
+     */
+    private Player player;
 
-        text.append("[");
-        text.append(dateFormat.format(new Date(record.getMillis())));
-        text.append("] ");
-        text.append(record.getMessage());
-        text.append("\r\n");
-        
-        return text.toString();
+    /**
+     * Construct the object.
+     * 
+     * @param player
+     */
+    public LoggerToChatHandler(Player player) {
+        this.player = player;
+    }
+
+    /**
+     * Close the handler.
+     */
+    public void close() {
+    }
+
+    /**
+     * Flush the output.
+     */
+    public void flush() {
+    }
+
+    /**
+     * Publish a log record.
+     */
+    public void publish(LogRecord record) {
+        player.sendMessage(Colors.LightGray + record.getLevel().getName() + ": "
+                + Colors.White + record.getMessage());
     }
 }

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,20 +56,86 @@ public class WorldGuard extends Plugin {
     public void initialize() {
         PluginLoader loader = etc.getLoader();
 
-        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.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);
+        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("BLOCK_PLACE", PluginListener.Priority.HIGH);
+        registerHook("DISCONNECT", PluginListener.Priority.HIGH);
+        registerHook("ITEM_DROP", PluginListener.Priority.HIGH);
+        if (!registerHook("ITEM_USE", PluginListener.Priority.HIGH)) {
+            missingFeatures.add("denying use of the lava or water buckets");
+        }
+        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 (!registerHook("HEALTH_CHANGE", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("god mode");
+        }
+        if (!registerHook("DAMAGE", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("disabling fall, water, lava, and fire damage");
+        }
+        if (!registerHook("LIQUID_DESTROY", PluginListener.Priority.MEDIUM)) {
+            missingFeatures.add("disabling water damage");
+        }
+
+        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;
+        }
     }
 
     /**
@@ -74,9 +143,11 @@ public class WorldGuard extends Plugin {
      */
     @Override
     public void enable() {
+        logger.log(Level.INFO, "WorldGuard version " + getVersion() + " loaded");
         listener.loadConfiguration();
 
-        logger.log(Level.INFO, "WorldGuard version " + getVersion() + " loaded");
+        etc.getInstance().addCommand("/stopfire", "Globally stop fire spread");
+        etc.getInstance().addCommand("/allowfire", "Globally re-enable fire spread");
     }
 
     /**
@@ -84,7 +155,14 @@ public class WorldGuard extends Plugin {
      */
     @Override
     public void disable() {
-        BlacklistEntry.forgetAllPlayers();
+        try {
+            listener.disable();
+            BlacklistEntry.forgetAllPlayers();
+        } catch (Throwable t) {
+        }
+
+        etc.getInstance().removeCommand("/stopfire");
+        etc.getInstance().removeCommand("/allowfire");
     }
 
     /**
@@ -105,4 +183,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/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();
-    }
-}

worldguard-blacklist.txt

@@ -3,30 +3,89 @@
 # are ignored so you can put your own notes.
 #
 # Format:
-# [item1,item2,itemN]
+# [item1,item2]
 # option1=options
-# event1=action1,action2,actionN
-# eventN=action1,action2,actionN
+# event1=whatToDo1,whatToDo2,whatToDo3
+# event2=whatToDo1,whatToDo2
 #
-# Events/Options:
+# Example to block ore and catch some events:
+# [coalore,goldore,ironore]
+# on-destroy-with=deny,log,kick
+# on-create=deny,tell
+#
+# Options:
 # - ignore-groups (comma-delimited list of groups to not affect)
-# - on-destroy (when a block of this type is destroyed)
-# - on-left (when this item is held and the player is left clicking)
-# - on-right (when this item is held and the player is right clicking)
+# - comment (message for yourself that is printed with 'log' and 'notify')
+# - message (optional message to show the user instead; %s is the item name)
 #
-# Actions:
+# 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)
 # - notify (notify admins)
-# - log (log to console/file)
-# - kick (kick player)
+# - log (log to console/file/database)
 # - tell (tell a player that that's not allowed)
+# - kick (kick player)
+# - ban (ban player)
 #
-# Some examples follow.
+# 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.
+#
+# -------------
+#
+# You can have the same block or item used in two different sections and
+# they will both apply:
+#
+# [goldblock]
+# ignore-groups=vip
+# on-destroy=deny
+# [goldblock]
+# ignore-groups=admins
+# on-destroy=tell
+#
+# However, some events override others. For example, if you disable both
+# usage of the diamond pickaxe (with the on-destroy-with event) and
+# destruction of gold blocks (with the on-destroy event) and a player tries
+# to destroy a gold block with a diamond pickaxe, because the
+# on-destroy-with event comes first, the rules for the gold block
+# will not be applied (but the player will be denied nevertheless).
+#
+# -------------
+#
+# Some examples follow. Remember to remove # in front if you want them
+# to work for you!
+
 #[lavabucket]
-#on-left=deny,log,kick
-#on-right=deny,tell
+#ignore-groups=admins,mods
+#on-destroy-with=deny,log,kick
+#on-create=deny,tell
+
 #[coalore,goldore,ironore]
+#ignore-groups=admins,mods,vip
 #on-destroy=notify,deny,log
+
 #[cobblestone]
-#on-right=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,97 @@
+#
+# WorldGuard configuration
+#
+# 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.
+#
+
+# Display a summary of WorldGuard's core protection features (lava fire
+# disable and others) when Worldguard starts up.
+summary-on-start=true
+
+# Toggle the item durabiltiy fix
+item-durability=true
+
+# Simulate the sponge from Classic. It removes water and prevents water from
+# flowing into an area containing sponges. Use this to protect circuits
+# or to assist in underwater projects.
+simulate-sponge=false
+sponge-radius=3
+
+# Simulate classic water. Water will spread infinitely. Be aware that this
+# may likely flood your server.
+classic-water=false
+
+# Allow the placement of portal blocks anyway.
+allow-portal-anywhere=false
+
+# Prevent gravel from falling.
+no-physics-gravel=false
+
+# Prevent sand from falling.
+no-physics-sand=false
+
+# Kick the older player if a player attempts to join again without first
+# logging out the first instance.
+enforce-single-session=true
+
+# List of items to destroy on drop. You can also accomplish this using
+# the blacklist.
+item-drop-blacklist=
+
+# Simple prevention
+block-creepers=false
+block-lighter=false
+block-tnt=false
+
+# Login protection prevents players from getting any damage for a few
+# seconds after joining the server.
+login-protection=3
+
+# Spawn protection prevents players from getting any damage after spawning
+# (after dying).
+spawn-protection=0
+
+# This is an deprecated feature to fix a bug. This kicks a user once the
+# player dies and attemtps to respawn. The player can then still rejoin
+# and be alive.
+kick-on-death=false
+
+# Disable various ways of damage. If you want to give someone invincibility
+# or the ability to breathe under water, create the groups wg-invincible
+# and wg-amphibious respectively and apply them to users as needed.
+disable-fall-damage=false
+disable-lava-damage=false
+disable-fire-damage=false
+disable-water-damage=false
+
+# Disable fire spreading between blocks. Note that this does not prevent
+# fire damage -- it only prevents fire spread.
+disable-all-fire-spread=false
+
+# List blocks that fire should not spread to or between. Cloth and wood
+# are some good examples.
+disallowed-fire-spread-blocks=
+
+# Prevent lava from starting fires.
+disable-lava-fire=true
+
+# List of blocks that lava is allowed to spread onto.
+allowed-lava-spread-blocks=
+
+# List of blocks that should not be destroyed by water (Redstone wire,
+# minecart tracks, flowers, etc.).
+disable-water-damage-blocks=
+
+# Control where to log blacklist events to. You can use multiple log
+# methods as you please.
+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