Fixed configuration file not being reloaded.

CHANGELOG.txt

@@ -1,3 +1,12 @@
+2.1:
+- Improved Bukkit support.
+
+2.0beta3:
+- Fixed NullPointerException inside the ignite hook.
+
+2.0beta2:
+- Fixed a NullPointerException in the damage hook.
+
 2.0beta1:
 - Added area protection. Use /region or /rg to define regions.
 

INSTALL.txt

@@ -1,7 +1,20 @@
 Installation
 ------------
 
-This plugin requires Hey0's server modification.
+Bukkit:
+
+** Make sure you first install the WorldEdit plugin. **
+
+  1. Create a "plugins" folder inside your server folder.
+
+  2. Copy WorldGuard.jar into "plugins".
+  
+  3. Restart your server.
+
+You may want to copy config.yml into plugins/WorldGuard/config.yml
+(you will have to create that folder). Edit it to fit your needs.
+
+hMod:
 
   1. Create a "plugins" folder inside your "bin" folder.
 

build.xml

@@ -32,6 +32,7 @@
       <attribute name="WorldGuard-Version" value="${version}"/>
       <attribute name="Class-Path" value="WorldEdit.jar"/>
     </manifest>
+    <copy tofile="${build.dir}/plugin.yml" file="plugin.yml"/>
     <jar jarfile="${dist.dir}/WorldGuard.jar" basedir="${build.dir}" manifest="manifest.mf"/>
   </target>
 
@@ -51,14 +52,19 @@
       <fileset dir="."/>
       <globmapper from="*.txt" to="*.txt"/>
     </copy>
+    <copy tofile="${release.dir}/worldguard.updatr" file="worldguard.updatr"/>
+    <replace file="${release.dir}/worldguard.updatr" token="%version%" value="${version}"/>
+    <copy tofile="${release.dir}/plugin.yml" file="plugin.yml"/>
+    <copy tofile="${release.dir}/config.yml" file="config.yml"/>
+    <replace file="${release.dir}/plugin.yml" token="WGVERSIONMACRO" value="${version}"/>
     <copy file="worldguard.properties" todir="${release.dir}"/>
     <copy tofile="${release.dir}/WorldGuard.jar" file="${dist.dir}/WorldGuard.jar"/>
-    <zip destfile="${release.dir}/worldguard-${version}.zip" basedir="${release.dir}" excludes="*.zip"/>
+    <zip destfile="${release.dir}/worldguard-${version}.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
     <mkdir dir="${release.dir}/src"/>
     <copy todir="${release.dir}/src">
       <fileset dir="${src.dir}"/>
     </copy>
-    <zip destfile="${release.dir}/worldguard-${version}-source.zip" basedir="${release.dir}" excludes="*.zip"/>
+    <zip destfile="${release.dir}/worldguard-${version}-src.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
   </target>
 
   <!-- Clean the output -->

config.yml

@@ -0,0 +1,63 @@
+summary-on-start: true
+protection:
+    enforce-single-session: true
+    item-durability: true
+simulation:
+    classic-water: false
+    sponge:
+        enable: true
+        radius: 3
+physics:
+    # Doesn't work in Bukkit yet
+    no-physics-gravel: false
+    no-physics-sand: false
+    allow-portal-anywhere: false
+    disable-water-damage-blocks: []
+ignition:
+    block-tnt: false
+    block-lighter: false
+fire:
+    disable-all-fire-spread: false
+    disable-fire-spread-blocks: []
+    disable-lava-fire-spread: true
+    lava-spread-blocks: []
+mobs:
+    # Doesn't work in Bukkit yet
+    block-creeper-explosions: false
+spawn:
+    # Doesn't work in Bukkit yet
+    login-protection: 3
+    spawn-protection: 0
+    kick-on-death: false
+    exact-respawn: false
+    teleport-to-home-on-death: false
+player-damage:
+    # Doesn't work in Bukkit yet
+    disable-fall-damage: true
+    disable-lava-damage: true
+    disable-fire-damage: true
+    disable-drowning-damage: true
+    disable-suffocation-damage: true
+    teleport-on-suffocation: true
+regions:
+    enable: true
+    wand: 287
+blacklist:
+    logging:
+        console:
+            enable: true
+        database:
+            enable: false
+            dsn: jdbc:mysql://localhost:3306/minecraft
+            user: root
+            password: pass
+            table: blacklist_events
+        file:
+            enable: true
+            path: worldguard/logs/%Y-%m-%d.log
+            open-files: 10
+permissions:
+    groups:
+        default:
+            permissions:
+    users:

plugin.yml

@@ -0,0 +1,3 @@
+name: WorldGuard
+main: com.sk89q.worldguard.bukkit.WorldGuardPlugin
+version: WGVERSIONMACRO

src/BlacklistEntry.java

@@ -1,746 +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/>.
-*/
-
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.HashMap;
-
-/**
- *
- * @author sk89q
- */
-public class BlacklistEntry {
-    /**
-     * Used to prevent spamming.
-     */
-    private static Map<String,BlacklistTrackedEvent> lastAffected =
-            new HashMap<String,BlacklistTrackedEvent>();
-    /**
-     * Parent blacklist entry.
-     */
-    private Blacklist blacklist;
-    /**
-     * List of groups to not affect.
-     */
-    private Set<String> ignoreGroups;
-    /**
-     * 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[] destroyWithActions;
-    /**
-     * List of actions to perform on block placement.
-     */
-    private String[] placeActions;
-    /**
-     * List of actions to perform on item use.
-     */
-    private String[] useActions;
-    /**
-     * List of actions to perform on right click upon.
-     */
-    private String[] rightClickActions;
-    /**
-     * 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
-     */
-    public String[] getIgnoreGroups() {
-        return ignoreGroups.toArray(new String[ignoreGroups.size()]);
-    }
-
-    /**
-     * @param ignoreGroups the ignoreGroups to set
-     */
-    public void setIgnoreGroups(String[] ignoreGroups) {
-        Set<String> ignoreGroupsSet = new HashSet<String>();
-        for (String group : ignoreGroups) {
-            ignoreGroupsSet.add(group.toLowerCase());
-        }
-        this.ignoreGroups = ignoreGroupsSet;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getDestroyActions() {
-        return destroyActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setDestroyActions(String[] actions) {
-        this.destroyActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getBreakActions() {
-        return breakActions;
-    }
-
-    /**
-     * @param actions
-     */
-    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
-     */
-    public String[] getPlaceActions() {
-        return placeActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setPlaceActions(String[] actions) {
-        this.placeActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getUseActions() {
-        return useActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setUseActions(String[] actions) {
-        this.useActions = actions;
-    }
-
-    /**
-     * @return
-     */
-    public String[] getRightClickActions() {
-        return rightClickActions;
-    }
-
-    /**
-     * @param actions
-     */
-    public void setRightClickActions(String[] actions) {
-        this.rightClickActions = 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;
-    }
-
-    /**
-     * Returns true if this player should be ignored.
-     *
-     * @param player
-     * @return
-     */
-    public boolean shouldIgnore(Player player) {
-        if (ignoreGroups == null) {
-            return false;
-        }
-        for (String group : player.getGroups()) {
-            if (ignoreGroups.contains(group.toLowerCase())) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Announces a message to all administrators.
-     * 
-     * @param str
-     */
-    public void notifyAdmins(String str) {
-        for (Player player : etc.getServer().getPlayerList()) {
-            if (player.canUseCommand("/wprotectalerts")
-                    || player.canUseCommand("/worldguardnotify")) {
-                player.sendMessage(Colors.LightGray + "WG: " + str);
-            }
-        }
-    }
-
-    /**
-     * Ban a player.
-     * 
-     * @param player
-     * @param msg
-     */
-    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);
-    }
-
-    /**
-     * 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) {
-        if (destroyActions == null) {
-            return true;
-        }
-
-        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);
-    }
-
-    /**
-     * Called on left click. Returns true to let the action pass through.
-     *
-     * @param item
-     * @param player
-     * @return
-     */
-    public boolean onDestroyWith(final int item, final Player player) {
-        if (destroyWithActions == null) {
-            return true;
-        }
-
-        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 block placement. Returns true to let the action pass through.
-     *
-     * @param item
-     * @param player
-     * @return
-     */
-    public boolean onPlace(final int item, final Player player) {
-        if (placeActions == null) {
-            return true;
-        }
-
-        final BlacklistEntry entry = this;
-
-        ActionHandler handler = new ActionHandler() {
-            public void log(String itemName) {
-                blacklist.getLogger().logPlaceAttempt(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, placeActions, handler, true, false);
-    }
-
-    /**
-     * Called on use. Returns true to let the action pass through.
-     *
-     * @param item
-     * @param player
-     * @return
-     */
-    public boolean onUse(final int item, 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, item, 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(item, 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 onRightClick(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().logRightClickAttempt(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);
-    }
-
-    /**
-     * Internal method to handle the actions.
-     * 
-     * @param id
-     * @param player
-     * @param actions
-     * @param handler
-     * @param allowRepeat
-     * @param silent
-     * @return
-     */
-    private boolean process(int id, Player player, String[] actions,
-            ActionHandler handler, boolean allowRepeat, boolean silent) {
-
-        if (shouldIgnore(player)) {
-            return true;
-        }
-
-        String name = player.getName();
-        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")) {
-                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")) {
-                    handler.notifyAdmins(etc.getDataSource().getItem(id));
-                
-                // Log
-                } else if (action.equalsIgnoreCase("log")) {
-                    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));
-                    }
-                }
-            }
-        }
-
-        return ret;
-    }
-
-    /**
-     * Forget a player.
-     *
-     * @param player
-     */
-    public static void forgetPlayer(Player player) {
-        lastAffected.remove(player.getName());
-    }
-
-    /**
-     * Forget all players.
-     *
-     * @param player
-     */
-    public static void forgetAllPlayers() {
-        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

@@ -1,165 +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/>.
-*/
-
-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, int item, String comment) {
-        for (BlacklistLoggerHandler handler : handlers) {
-            handler.logUseAttempt(player, item, comment);
-        }
-    }
-
-    /**
-     * Log a right click on attempt.
-     *
-     * @param player
-     * @param block
-     */
-    public void logRightClickAttempt(Player player, Block block, String comment) {
-        for (BlacklistLoggerHandler handler : handlers) {
-            handler.logRightClickAttempt(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 place attempt.
-     *
-     * @param player
-     * @param item
-     */
-    public void logPlaceAttempt(Player player, int item, String comment) {
-        for (BlacklistLoggerHandler handler : handlers) {
-            handler.logPlaceAttempt(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

@@ -1,86 +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/>.
-*/
-
-/**
- * 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 use attempt.
-     * 
-     * @param player
-     * @param block
-     */
-    public void logUseAttempt(Player player, int item, String comment);
-    /**
-     * Right a left click attempt.
-     * 
-     * @param player
-     * @param item
-     */
-    public void logDestroyWithAttempt(Player player, int item, String comment);
-    /**
-     * Log a place attempt.
-     * 
-     * @param player
-     * @param item
-     */
-    public void logPlaceAttempt(Player player, int item, String comment);
-    /**
-     * Log a right click on attempt.
-     * 
-     * @param player
-     * @param item
-     */
-    public void logRightClickAttempt(Player player, Block block, 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/ConsoleLoggerHandler.java

@@ -1,143 +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/>.
-*/
-
-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 logRightClickAttempt(Player player, Block block, String comment) {
-        logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to right click " + 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 logPlaceAttempt(Player player, int item, String comment) {
-        logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to place " + getFriendlyItemName(item)
-                + (comment != null ? " (" + comment + ")" : ""));
-    }
-
-    /**
-     * Log a use attempt.
-     *
-     * @param player
-     * @param item
-     */
-    public void logUseAttempt(Player player, int item, String comment) {
-        logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to use " + 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/WorldGuard.java

@@ -1,187 +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/>.
-*/
-
-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.*;
-
-/**
- * Entry point for the plugin for hey0's mod.
- *
- * @author sk89q
- */
-public class WorldGuard extends Plugin {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    /**
-     * Listener for the plugin system.
-     */
-    private WorldGuardListener listener;
-
-    /**
-     * Initialize the plugin.
-     */
-    public WorldGuard() {
-        listener = new WorldGuardListener(this);
-    }
-
-    /**
-     * Initializes the plugin.
-     */
-    @Override
-    public void initialize() {
-        List<String> missingFeatures = new ArrayList<String>();
-
-        registerHook("COMMAND", PluginListener.Priority.MEDIUM);
-        registerHook("SERVERCOMMAND", PluginListener.Priority.MEDIUM);
-        registerHook("EXPLODE", PluginListener.Priority.HIGH);
-        registerHook("IGNITE", PluginListener.Priority.HIGH);
-        registerHook("FLOW", PluginListener.Priority.HIGH);
-        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);
-        registerHook("ITEM_USE", PluginListener.Priority.HIGH);
-        registerHook("ITEM_PICK_UP", PluginListener.Priority.HIGH);
-        registerHook("SIGN_CHANGE", PluginListener.Priority.HIGH);
-        registerHook("OPEN_INVENTORY", PluginListener.Priority.HIGH);
-        registerHook("BLOCK_PHYSICS", PluginListener.Priority.MEDIUM);
-        registerHook("HEALTH_CHANGE", PluginListener.Priority.MEDIUM);
-        registerHook("DAMAGE", PluginListener.Priority.MEDIUM);
-        registerHook("LIQUID_DESTROY", PluginListener.Priority.MEDIUM);
-        registerHook("BLOCK_RIGHTCLICKED", PluginListener.Priority.MEDIUM);
-
-        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;
-        }
-    }
-
-    /**
-     * Enables the plugin.
-     */
-    @Override
-    public void enable() {
-        logger.log(Level.INFO, "WorldGuard version " + getVersion() + " loaded");
-        listener.loadConfiguration();
-
-        etc.getInstance().addCommand("/stopfire", "Globally stop fire spread");
-        etc.getInstance().addCommand("/allowfire", "Globally re-enable fire spread");
-    }
-
-    /**
-     * Disables the plugin.
-     */
-    @Override
-    public void disable() {
-        try {
-            listener.disable();
-            BlacklistEntry.forgetAllPlayers();
-        } catch (Throwable t) {
-        }
-
-        etc.getInstance().removeCommand("/stopfire");
-        etc.getInstance().removeCommand("/allowfire");
-    }
-
-    /**
-     * Get the WorldGuard version.
-     *
-     * @return
-     */
-    private String getVersion() {
-        try {
-            String classContainer = WorldGuard.class.getProtectionDomain()
-                    .getCodeSource().getLocation().toString();
-            URL manifestUrl = new URL("jar:" + classContainer + "!/META-INF/MANIFEST.MF");
-            Manifest manifest = new Manifest(manifestUrl.openStream());
-            Attributes attrib = manifest.getMainAttributes();
-            String ver = (String)attrib.getValue("WorldGuard-Version");
-            return ver != null ? ver : "(unavailable)";
-        } catch (IOException e) {
-            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/LocalPlayer.java

@@ -19,6 +19,9 @@
 
 package com.sk89q.worldguard;
 
+import java.util.List;
+import com.sk89q.worldedit.Vector;
+
 public abstract class LocalPlayer {
     /**
      * Get a player's name.
@@ -35,6 +38,41 @@ public abstract class LocalPlayer {
      */
     public abstract boolean hasGroup(String group);
     
+    /**
+     * Get the player's position.
+     * 
+     * @return
+     */
+    public abstract Vector getPosition();
+    
+    /**
+     * Kick the player.
+     * 
+     * @param msg
+     */
+    public abstract void kick(String msg);
+    
+    /**
+     * Ban the player.
+     * 
+     * @param msg
+     */
+    public abstract void ban(String msg);
+    
+    /**
+     * Send the player a message;
+     * 
+     * @param msg
+     */
+    public abstract void printRaw(String msg);
+    
+    /**
+     * Get the player's list of groups.
+     * 
+     * @return
+     */
+    public abstract List<String> getGroups();
+    
     @Override
     public boolean equals(Object obj) {
         if (!(obj instanceof LocalPlayer)) {

src/com/sk89q/worldguard/blacklist/Blacklist.java

@@ -17,6 +17,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
+package com.sk89q.worldguard.blacklist;
+
 import java.util.Map;
 import java.util.HashMap;
 import java.util.List;
@@ -24,12 +26,16 @@ import java.util.ArrayList;
 import java.util.logging.Logger;
 import java.util.logging.Level;
 import java.io.*;
+import org.bukkit.ChatColor;
+import com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
 
 /**
  *
  * @author sk89q
  */
-public class Blacklist {
+public abstract class Blacklist {
     /**
      * Logger.
      */
@@ -44,11 +50,15 @@ public class Blacklist {
      * Logger.
      */
     private BlacklistLogger blacklistLogger = new BlacklistLogger();
-
     /**
-     * Blacklist contains on-acquire events.
+     * Last event.
      */
-    private boolean hasOnAcquire;
+    private BlacklistEvent lastEvent;
+    /**
+     * Used to prevent flooding.
+     */
+    Map<String,BlacklistTrackedEvent> lastAffected =
+            new HashMap<String,BlacklistTrackedEvent>();
 
     /**
      * Returns whether the list is empty.
@@ -76,211 +86,21 @@ public class Blacklist {
     }
 
     /**
-     * Called on block destruction. Returns true to let the action pass
-     * through.
-     *
-     * @param block
-     * @param player
+     * Method to handle the event.
+     * 
+     * @param event
+     * @param forceRepeat
+     * @param silent
      * @return
      */
-    public boolean onDestroy(final Block block, final Player player) {
-        List<BlacklistEntry> entries = getEntries(block.getType());
+    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
+        List<BlacklistEntry> entries = getEntries(event.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 place. Returns true to let the action pass through.
-     *
-     * @param item
-     * @param player
-     * @return
-     */
-    public boolean onPlace(int item, Player player) {
-        List<BlacklistEntry> entries = getEntries(item);
-        if (entries == null) {
-            return true;
-        }
-        boolean ret = true;
-        for (BlacklistEntry entry : entries) {
-            if (!entry.onPlace(item, player)) {
-                ret = false;
-            }
-        }
-        return ret;
-    }
-
-    /**
-     * Called on right click upon. Returns true to let the action pass through.
-     *
-     * @param block
-     * @param player
-     * @return
-     */
-    public boolean onRightClick(Block block, Player player) {
-        List<BlacklistEntry> entries = getEntries(block.getType());
-        if (entries == null) {
-            return true;
-        }
-        boolean ret = true;
-        for (BlacklistEntry entry : entries) {
-            if (!entry.onRightClick(block, player)) {
-                ret = false;
-            }
-        }
-        return ret;
-    }
-
-    /**
-     * Called on item use. Returns true to let the action pass through.
-     *
-     * @param item
-     * @param player
-     * @return
-     */
-    public boolean onUse(int item, Player player) {
-        List<BlacklistEntry> entries = getEntries(item);
-        if (entries == null) {
-            return true;
-        }
-        boolean ret = true;
-        for (BlacklistEntry entry : entries) {
-            if (!entry.onUse(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 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)) {
+            if (!entry.check(event, forceRepeat, silent)) {
                 ret = false;
             }
         }
@@ -303,8 +123,6 @@ public class Blacklist {
             input = new FileReader(file);
             BufferedReader buff = new BufferedReader(input);
 
-            hasOnAcquire = false;
-
             String line;
             List<BlacklistEntry> currentEntries = null;
             while ((line = buff.readLine()) != null) {
@@ -327,7 +145,7 @@ public class Blacklist {
                         try {
                             id = Integer.parseInt(item.trim());
                         } catch (NumberFormatException e) {
-                            id = etc.getDataSource().getItem(item.trim());
+                            id = getItemID(item.trim());
                             if (id == 0) {
                                 logger.log(Level.WARNING, "WorldGuard: Unknown block name: "
                                         + item);
@@ -359,23 +177,19 @@ public class Blacklist {
                     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")) {
+                        } else if (parts[0].equalsIgnoreCase("on-destroy-with")) {
                             entry.setDestroyWithActions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-place")) {
                             entry.setPlaceActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-interact")) {
+                            entry.setInteractActions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-use")) {
                             entry.setUseActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-right-click")) {
-                            entry.setRightClickActions(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());
@@ -406,13 +220,82 @@ public class Blacklist {
             }
         }
     }
-
+    
     /**
-     * Blacklist contains on-acquire events.
+     * Get the last event.
      * 
      * @return
      */
-    public boolean hasOnAcquire() {
-        return hasOnAcquire;
+    public BlacklistEvent getLastEvent() {
+        return lastEvent;
+    }
+    
+    /**
+     * Notify administrators.
+     * 
+     * @param event
+     */
+    public void notify(BlacklistEvent event, String comment) {
+        lastEvent = event;
+        
+        broadcastNotification(ChatColor.GRAY + "WG: " 
+                + ChatColor.LIGHT_PURPLE + event.getPlayer().getName()
+                + ChatColor.GOLD + " (" + event.getDescription() + ") "
+                + ChatColor.WHITE
+                + getFriendlyItemName(event.getType())
+                + (comment != null ? " (" + comment + ")" : "") + ".");
+    }
+    
+    /**
+     * Sends a notification to all subscribing users.
+     * 
+     * @param msg
+     */
+    public abstract void broadcastNotification(String msg);
+
+    /**
+     * Forget a player.
+     *
+     * @param player
+     */
+    public void forgetPlayer(LocalPlayer player) {
+        lastAffected.remove(player.getName());
+    }
+
+    /**
+     * Forget all players.
+     *
+     * @param player
+     */
+    public void forgetAllPlayers() {
+        lastAffected.clear();
+    }
+
+    /**
+     * Get an item's ID from its name.
+     * 
+     * @param name
+     */
+    private static int getItemID(String name) {
+        ItemType type = ItemType.lookup(name);
+        if (type != null) {
+            return type.getID();
+        } else {
+            return -1;
+        }
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     * 
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        ItemType type = ItemType.fromID(id);
+        if (type != null) {
+            return type.getName() + " (#" + id + ")";
+        } else {
+            return "#" + id + "";
+        }
     }
 }

src/com/sk89q/worldguard/blacklist/BlacklistEntry.java

@@ -0,0 +1,383 @@
+// $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.blacklist;
+
+import java.util.Set;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.HashMap;
+import org.bukkit.ChatColor;
+import com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.BlockInteractBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemAcquireBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemDropBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
+
+/**
+ *
+ * @author sk89q
+ */
+public class BlacklistEntry {
+    /**
+     * Parent blacklist entry.
+     */
+    private Blacklist blacklist;
+    /**
+     * List of groups to not affect.
+     */
+    private Set<String> ignoreGroups;
+    
+    private String[] breakActions;
+    private String[] destroyWithActions;
+    private String[] placeActions;
+    private String[] interactActions;
+    private String[] useActions;
+    private String[] dropActions;
+    private String[] acquireActions;
+    
+    private String message;
+    private String comment;
+
+    /**
+     * Construct the object.
+     * 
+     * @param blacklist
+     */
+    public BlacklistEntry(Blacklist blacklist) {
+        this.blacklist = blacklist;
+    }
+
+    /**
+     * @return the ignoreGroups
+     */
+    public String[] getIgnoreGroups() {
+        return ignoreGroups.toArray(new String[ignoreGroups.size()]);
+    }
+
+    /**
+     * @param ignoreGroups the ignoreGroups to set
+     */
+    public void setIgnoreGroups(String[] ignoreGroups) {
+        Set<String> ignoreGroupsSet = new HashSet<String>();
+        for (String group : ignoreGroups) {
+            ignoreGroupsSet.add(group.toLowerCase());
+        }
+        this.ignoreGroups = ignoreGroupsSet;
+    }
+
+    /**
+     * @return
+     */
+    public String[] getBreakActions() {
+        return breakActions;
+    }
+
+    /**
+     * @param actions
+     */
+    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
+     */
+    public String[] getPlaceActions() {
+        return placeActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setPlaceActions(String[] actions) {
+        this.placeActions = actions;
+    }
+
+    /**
+     * @return
+     */
+    public String[] getInteractActions() {
+        return interactActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setInteractActions(String[] actions) {
+        this.interactActions = 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;
+    }
+
+    /**
+     * Returns true if this player should be ignored.
+     *
+     * @param player
+     * @return
+     */
+    public boolean shouldIgnore(LocalPlayer player) {
+        if (ignoreGroups == null) {
+            return false;
+        }
+        for (String group : player.getGroups()) {
+            if (ignoreGroups.contains(group.toLowerCase())) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+    
+    /**
+     * Get the associated actions with an event.
+     * 
+     * @param event
+     * @return
+     */
+    private String[] getActions(BlacklistEvent event) {
+        if (event instanceof BlockBreakBlacklistEvent) {
+            return breakActions;
+            
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            return placeActions;
+            
+        } else if (event instanceof BlockInteractBlacklistEvent) {
+            return interactActions;
+            
+        } else if (event instanceof DestroyWithBlacklistEvent) {
+            return destroyWithActions;
+            
+        } else if (event instanceof ItemAcquireBlacklistEvent) {
+            return acquireActions;
+            
+        } else if (event instanceof ItemDropBlacklistEvent) {
+            return dropActions;
+            
+        } else if (event instanceof ItemUseBlacklistEvent) {
+            return useActions;
+            
+        } else {
+            return null;
+        }
+    }
+
+    /**
+     * Method to handle the event.
+     * 
+     * @param event
+     * @param forceRepeat
+     * @param silent
+     * @return
+     */
+    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
+        LocalPlayer player = event.getPlayer();
+        
+        if (shouldIgnore(player)) {
+            return true;
+        }
+
+        String name = player.getName();
+        long now = System.currentTimeMillis();
+        boolean repeating = false;
+
+        // Check to see whether this event is being repeated
+        BlacklistTrackedEvent tracked = blacklist.lastAffected.get(name);
+        if (tracked != null) {
+            if (tracked.matches(event, now)) {
+                repeating = true;
+            }
+        } else {
+            blacklist.lastAffected.put(name, new BlacklistTrackedEvent(event, now));
+        }
+
+        String actions[] = getActions(event);
+        boolean ret = true;
+        
+        // Nothing to do
+        if (actions == null) {
+            return true;
+        }
+        
+        for (String action : actions) {
+            // Deny
+            if (action.equalsIgnoreCase("deny")) {
+                if (silent) {
+                    return false;
+                }
+                
+                ret = false;
+
+            // Kick
+            } else if (action.equalsIgnoreCase("kick")) {
+                if (silent) {
+                    continue;
+                }
+                
+                if (this.message != null) {
+                    player.kick(String.format(this.message,
+                            getFriendlyItemName(event.getType())));
+                } else {
+                    player.kick("You can't " + event.getDescription() + " "
+                            + getFriendlyItemName(event.getType()));
+                }
+
+            // Ban
+            } else if (action.equalsIgnoreCase("ban")) {
+                if (silent) {
+                    continue;
+                }
+                
+                if (this.message != null) {
+                    player.ban("Banned: " + String.format(this.message,
+                            getFriendlyItemName(event.getType())));
+                } else {
+                    player.ban("Banned: You can't "
+                            + event.getDescription() + " "
+                            + getFriendlyItemName(event.getType()));
+                }
+            
+            } else if (!silent && (!repeating || forceRepeat)) {
+                // Notify
+                if (action.equalsIgnoreCase("notify")) {
+                    blacklist.notify(event, comment);
+                
+                // Log
+                } else if (action.equalsIgnoreCase("log")) {
+                    blacklist.getLogger().logEvent(event, comment);
+
+                // Tell
+                } else if (action.equalsIgnoreCase("tell")) {
+                    if (this.message != null) {
+                        player.printRaw(ChatColor.YELLOW +
+                                String.format(message, getFriendlyItemName(event.getType()))
+                                + ".");
+                    } else {
+                        player.printRaw(ChatColor.YELLOW + "You're not allowed to "
+                                + event.getDescription() + " "
+                                + getFriendlyItemName(event.getType()) + ".");
+                    }
+                }
+            }
+        }
+
+        return ret;
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     * 
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        ItemType type = ItemType.fromID(id);
+        if (type != null) {
+            return type.getName() + " (#" + id + ")";
+        } else {
+            return "#" + id + "";
+        }
+    }
+}

src/com/sk89q/worldguard/blacklist/BlacklistLogger.java

@@ -0,0 +1,85 @@
+// $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.blacklist;
+
+import java.util.Set;
+import java.util.HashSet;
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
+import com.sk89q.worldguard.blacklist.loggers.BlacklistLoggerHandler;
+
+/**
+ *
+ * @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 an event.
+     *
+     * @param player
+     * @param event
+     */
+    public void logEvent(BlacklistEvent event, String comment) {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.logEvent(event, comment);
+        }
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+        for (BlacklistLoggerHandler handler : handlers) {
+            handler.close();
+        }
+    }
+}

src/com/sk89q/worldguard/blacklist/BlacklistTrackedEvent.java

@@ -1,3 +1,6 @@
+package com.sk89q.worldguard.blacklist;
+
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
 // $Id$
 /*
  * WorldGuard
@@ -22,7 +25,7 @@
  * @author sk89q
  */
 public class BlacklistTrackedEvent {
-    private int id;
+    private BlacklistEvent event;
     private long time;
 
     /**
@@ -31,36 +34,14 @@ public class BlacklistTrackedEvent {
      * @param id
      * @param time
      */
-    public BlacklistTrackedEvent(int id, long time) {
-        this.id = id;
+    public BlacklistTrackedEvent(BlacklistEvent event, long time) {
+        this.event = event;
         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;
+    public boolean matches(BlacklistEvent other, long now) {
+        return other.getType() == event.getType()
+                && time > now - 3000
+                && other.getClass() == event.getClass();
     }
 }

src/com/sk89q/worldguard/blacklist/events/BlacklistEvent.java

@@ -0,0 +1,85 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+/**
+ * Represents a blacklist event.
+ * 
+ * @author sk89q
+ */
+public abstract class BlacklistEvent {
+    private Vector pos;
+    private int type;
+    
+    /**
+     * Holds the player that triggered the event.
+     */
+    private LocalPlayer player;
+    
+    /**
+     * Construct the object.
+     * 
+     * @param player
+     * @param pos
+     * @param type
+     */
+    public BlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        this.player = player;
+        this.pos = pos;
+        this.type = type;
+    }
+    
+    /**
+     * Get the player.
+     * 
+     * @return
+     */
+    public LocalPlayer getPlayer() {
+        return player;
+    }
+    
+    /**
+     * Get the position.
+     * 
+     * @return
+     */
+    public Vector getPosition() {
+        return pos;
+    }
+    
+    /**
+     * Get the type.
+     * 
+     * @return
+     */
+    public int getType() {
+        return type;
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public abstract String getDescription();
+}

src/com/sk89q/worldguard/blacklist/events/BlockBlacklistEvent.java

@@ -17,22 +17,13 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
+package com.sk89q.worldguard.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
 import com.sk89q.worldguard.LocalPlayer;
 
-public class HMPlayer extends LocalPlayer {
-    private Player player;
-    
-    public HMPlayer(Player player) {
-        this.player = player;
-    }
-
-    @Override
-    public String getName() {
-        return player.getName();
-    }
-
-    @Override
-    public boolean hasGroup(String group) {
-        return player.isInGroup(group);
+public abstract class BlockBlacklistEvent extends BlacklistEvent {
+    public BlockBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
     }
 }

src/com/sk89q/worldguard/blacklist/events/BlockBreakBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class BlockBreakBlacklistEvent extends BlockBlacklistEvent {
+    public BlockBreakBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "break";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/BlockInteractBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class BlockInteractBlacklistEvent extends BlockBlacklistEvent {
+    public BlockInteractBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "interact with";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/BlockPlaceBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class BlockPlaceBlacklistEvent extends BlockBlacklistEvent {
+    public BlockPlaceBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "place";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/DestroyWithBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class DestroyWithBlacklistEvent extends BlacklistEvent {
+    public DestroyWithBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "destroy with";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/ItemAcquireBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class ItemAcquireBlacklistEvent extends ItemBlacklistEvent {
+    public ItemAcquireBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "acquire";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/ItemBlacklistEvent.java

@@ -0,0 +1,29 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public abstract class ItemBlacklistEvent extends BlacklistEvent {
+    public ItemBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+}

src/com/sk89q/worldguard/blacklist/events/ItemDropBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class ItemDropBlacklistEvent extends ItemBlacklistEvent {
+    public ItemDropBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "drop";
+    }
+}

src/com/sk89q/worldguard/blacklist/events/ItemUseBlacklistEvent.java

@@ -0,0 +1,38 @@
+// $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.blacklist.events;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class ItemUseBlacklistEvent extends ItemBlacklistEvent {
+    public ItemUseBlacklistEvent(LocalPlayer player, Vector pos, int type) {
+        super(player, pos, type);
+    }
+    
+    /**
+     * Get a short description such as "break" or "destroy with."
+     * 
+     * @return
+     */
+    public String getDescription() {
+        return "use";
+    }
+}

src/com/sk89q/worldguard/blacklist/loggers/BlacklistLoggerHandler.java

@@ -1,43 +1,42 @@
-// $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/>.
-*/
-
-/**
- * Inventory related functions.
- * 
- * @author sk89q
- */
-public class ItemArrayUtil {
-    /**
-     * Set the contents of an ItemArray.
-     * 
-     * @param itemArray
-     * @param contents
-     */
-    public static void setContents(ItemArray<?> itemArray, Item[] contents) {
-        int size = itemArray.getContentsSize();
-
-        for (int i = 0; i < size; i++) {
-            if (contents[i] == null) {
-                itemArray.removeItem(i);
-            } else {
-                itemArray.setSlot(contents[i], i);
-            }
-        }
-    }
-}
+// $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.blacklist.loggers;
+
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
+
+/**
+ * Interface for loggers for the blacklist.
+ *
+ * @author sk89q
+ */
+public interface BlacklistLoggerHandler {
+    /**
+     * Log an event.
+     *
+     * @param event
+     * @param comment
+     */
+    public void logEvent(BlacklistEvent event, String comment);
+    
+    /**
+     * Close the logger.
+     */
+    public void close();
+}

src/com/sk89q/worldguard/blacklist/loggers/ConsoleLoggerHandler.java

@@ -0,0 +1,118 @@
+package com.sk89q.worldguard.blacklist.loggers;
+// $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 com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldguard.blacklist.events.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    
+    /**
+     * Log an event.
+     *
+     * @param player
+     * @param event
+     */
+    public void logEvent(BlacklistEvent event, String comment) {
+        // Block break
+        if (event instanceof BlockBreakBlacklistEvent) {
+            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to break " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Block place
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to place " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Block interact
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to interact with " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Destroy with
+        } else if (event instanceof DestroyWithBlacklistEvent) {
+            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to destroy with " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Acquire
+        } else if (event instanceof ItemAcquireBlacklistEvent) {
+            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to acquire " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Drop
+        } else if (event instanceof ItemDropBlacklistEvent) {
+            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to drop " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Use
+        } else if (event instanceof ItemUseBlacklistEvent) {
+            ItemUseBlacklistEvent evt = (ItemUseBlacklistEvent)event;
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " tried to use " + getFriendlyItemName(evt.getType())
+                    + (comment != null ? " (" + comment + ")" : ""));
+        
+        // Unknown
+        } else {
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
+                    + " caught unknown event: " + event.getClass().getCanonicalName());
+        }
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     * 
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        ItemType type = ItemType.fromID(id);
+        if (type != null) {
+            return type.getName() + " (#" + id + ")";
+        } else {
+            return "#" + id + "";
+        }
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+    }
+}

src/com/sk89q/worldguard/blacklist/loggers/DatabaseLoggerHandler.java

@@ -17,12 +17,23 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
+package com.sk89q.worldguard.blacklist.loggers;
+
 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;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.BlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.BlockPlaceBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.DestroyWithBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemAcquireBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemDropBlacklistEvent;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
 
 /**
  *
@@ -93,7 +104,7 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param item
      * @param comment
      */
-    private void logEvent(String event, String name, int x, int y, int z, int item,
+    private void logEvent(String event, LocalPlayer player, Vector pos, int item,
             String comment) {
         try {
             Connection conn = getConnection();
@@ -102,10 +113,10 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
                   + "(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.setString(2, player.getName());
+            stmt.setInt(3, pos.getBlockX());
+            stmt.setInt(4, pos.getBlockY());
+            stmt.setInt(5, pos.getBlockZ());
             stmt.setInt(6, item);
             stmt.setInt(7, (int)(System.currentTimeMillis() / 1000));
             stmt.setString(8, comment);
@@ -115,101 +126,61 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
                     + 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 logRightClickAttempt(Player player, Block block, String comment) {
-        logEvent("RIGHT_CLICK", player.getName(),
-                block.getX(), block.getY(), block.getZ(), block.getType(),
-                comment);
-    }
     
     /**
-     * Right a left click attempt.
+     * Log an event.
      *
      * @param player
-     * @param item
+     * @param event
      */
-    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 place attempt.
-     *
-     * @param player
-     * @param item
-     */
-    public void logPlaceAttempt(Player player, int item, String comment) {
-        logEvent("PLACE", player.getName(),
-                (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
-                (int)Math.floor(player.getZ()), item, comment);
-    }
-
-    /**
-     * Log a use attempt.
-     *
-     * @param player
-     * @param item
-     */
-    public void logUseAttempt(Player player, int item, String comment) {
-        logEvent("USE", 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);
+    public void logEvent(BlacklistEvent event, String comment) {
+        // Block break
+        if (event instanceof BlockBreakBlacklistEvent) {
+            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
+            logEvent("BREAK", evt.getPlayer(), evt.getPosition(),
+                    evt.getType(), comment);
+        
+        // Block place
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
+            logEvent("PLACE", evt.getPlayer(), evt.getPosition(),
+                    evt.getType(), comment);
+            
+        // Block interact
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
+            logEvent("INTERACT", evt.getPlayer(), evt.getPosition(),
+                    evt.getType(), comment);
+        
+        // Destroy with
+        } else if (event instanceof DestroyWithBlacklistEvent) {
+            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
+            logEvent("DESTROY_WITH", evt.getPlayer(), evt.getPosition(),
+                    evt.getType(), comment);
+        
+        // Acquire
+        } else if (event instanceof ItemAcquireBlacklistEvent) {
+            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
+            logEvent("ACQUIRE", evt.getPlayer(), evt.getPlayer().getPosition(),
+                    evt.getType(), comment);
+        
+        // Drop
+        } else if (event instanceof ItemDropBlacklistEvent) {
+            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
+            logEvent("DROP", evt.getPlayer(), evt.getPlayer().getPosition(),
+                    evt.getType(), comment);
+        
+        // Use
+        } else if (event instanceof ItemUseBlacklistEvent) {
+            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
+            logEvent("USE", evt.getPlayer(), evt.getPlayer().getPosition(),
+                    evt.getType(), comment);
+        
+        // Unknown
+        } else {
+            logEvent("UNKNOWN", event.getPlayer(), event.getPlayer().getPosition(),
+                    -1, comment);
+        }
     }
 
     /**

src/com/sk89q/worldguard/blacklist/loggers/FileLoggerHandler.java

@@ -17,17 +17,18 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
+package com.sk89q.worldguard.blacklist.loggers;
+
 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.util.*;
 import java.text.SimpleDateFormat;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.*;
 
 /**
  *
@@ -142,7 +143,7 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param message
      */
-    private void log(Player player, String message, String comment) {
+    private void log(LocalPlayer player, String message, String comment) {
         String path = buildPath(player.getName());
         try {
             String date = dateFormat.format(new Date());
@@ -206,99 +207,67 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
     }
 
     /**
-     * Gets the coordinates of a block in text form for the log.
+     * Gets the coordinates in text form for the log.
      * 
-     * @param block
+     * @param pos
      * @return
      */
-    private String getCoordinates(Block block) {
-        return "@" + block.getX() + "," + block.getY() + "," + block.getZ();
+    private String getCoordinates(Vector pos) {
+        return "@" + pos.getBlockX() + "," + pos.getBlockY() + "," + pos.getBlockZ();
     }
-
+    
+    private void logEvent(BlacklistEvent event, String text, int id, Vector pos, String comment) {
+        log(event.getPlayer(), "Tried to " + text + " " + getFriendlyItemName(id)
+                + " " + getCoordinates(pos), comment);
+    }
+    
     /**
-     * Log a block destroy attempt.
+     * Log an event.
      *
      * @param player
-     * @param block
+     * @param event
      */
-    public void logDestroyAttempt(Player player, Block block, String comment) {
-        log(player, "Tried to destroy " + getFriendlyItemName(block.getType())
-                + " " + getCoordinates(block),
-                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())
-                + " " + getCoordinates(block),
-                comment);
-    }
-
-    /**
-     * Log a right click on attempt.
-     *
-     * @param player
-     * @param block
-     */
-    public void logRightClickAttempt(Player player, Block block, String comment) {
-        log(player, "Tried to right click " + getFriendlyItemName(block.getType())
-                + " " + getCoordinates(block),
-                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 logPlaceAttempt(Player player, int item, String comment) {
-        log(player, "Tried to place " + getFriendlyItemName(item), comment);
-    }
-
-    /**
-     * Log a block use attempt.
-     *
-     * @param player
-     * @param item
-     */
-    public void logUseAttempt(Player player, int item, String comment) {
-        log(player, "Tried to use " + 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);
+    public void logEvent(BlacklistEvent event, String comment) {
+        // Block break
+        if (event instanceof BlockBreakBlacklistEvent) {
+            BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
+            logEvent(event, "break", evt.getType(), evt.getPosition(), comment);
+        
+        // Block place
+        } else if (event instanceof BlockPlaceBlacklistEvent) {
+            BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
+            logEvent(event, "place", evt.getType(), evt.getPosition(), comment);
+        
+        // Block interact
+        } else if (event instanceof BlockInteractBlacklistEvent) {
+            BlockInteractBlacklistEvent evt = (BlockInteractBlacklistEvent)event;
+            logEvent(event, "interact with", evt.getType(), evt.getPosition(), comment);
+        
+        // Destroy with
+        } else if (event instanceof DestroyWithBlacklistEvent) {
+            DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
+            logEvent(event, "destroy with", evt.getType(), evt.getPosition(), comment);
+            
+        // Acquire
+        } else if (event instanceof ItemAcquireBlacklistEvent) {
+            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
+            logEvent(event, "acquire", evt.getType(), evt.getPosition(), comment);
+        
+        // Drop
+        } else if (event instanceof ItemDropBlacklistEvent) {
+            ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
+            logEvent(event, "drop", evt.getType(), evt.getPosition(), comment);
+            
+        // Use
+        } else if (event instanceof ItemUseBlacklistEvent) {
+            ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
+            logEvent(event, "use", evt.getType(), evt.getPosition(), comment);
+        
+        // Unknown
+        } else {
+            log(event.getPlayer(), "Unknown event: "
+                    + event.getClass().getCanonicalName(), comment);
+        }
     }
 
     /**
@@ -307,7 +276,12 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param id
      */
     private static String getFriendlyItemName(int id) {
-        return etc.getDataSource().getItem(id) + " (#" + id + ")";
+        ItemType type = ItemType.fromID(id);
+        if (type != null) {
+            return type.getName() + " (#" + id + ")";
+        } else {
+            return "#" + id + "";
+        }
     }
 
     /**

src/com/sk89q/worldguard/blacklist/loggers/FileLoggerWriter.java

@@ -17,6 +17,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
+package com.sk89q.worldguard.blacklist.loggers;
+
 import java.io.*;
 
 /**

src/com/sk89q/worldguard/bukkit/BukkitBlacklist.java

@@ -0,0 +1,40 @@
+// $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.bukkit;
+
+import org.bukkit.entity.Player;
+import com.sk89q.worldguard.blacklist.Blacklist;
+
+public class BukkitBlacklist extends Blacklist {
+    private WorldGuardPlugin plugin;
+    
+    public BukkitBlacklist(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+    
+    public void broadcastNotification(String msg) {
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            if (plugin.hasPermission(player, "/worldguardnotify")) {
+                player.sendMessage(msg);
+            }
+        }
+    }
+
+}

src/com/sk89q/worldguard/bukkit/BukkitPlayer.java

@@ -0,0 +1,73 @@
+// $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.bukkit;
+
+import java.util.List;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class BukkitPlayer extends LocalPlayer {
+    private Player player;
+    private WorldGuardPlugin plugin;
+    
+    public BukkitPlayer(WorldGuardPlugin plugin, Player player) {
+        this.plugin = plugin;
+        this.player = player;
+    }
+
+    @Override
+    public String getName() {
+        return player.getName();
+    }
+
+    @Override
+    public boolean hasGroup(String group) {
+        return plugin.inGroup(player, group);
+    }
+
+    @Override
+    public Vector getPosition() {
+        Location loc = player.getLocation();
+        return new Vector(loc.getX(), loc.getY(), loc.getZ());
+    }
+
+    @Override
+    public void kick(String msg) {
+        player.kickPlayer(msg);
+    }
+
+    @Override
+    public void ban(String msg) {
+        player.kickPlayer(msg);
+    }
+
+    @Override
+    public List<String> getGroups() {
+        return plugin.getGroups(player);
+    }
+
+    @Override
+    public void printRaw(String msg) {
+        player.sendMessage(msg);
+    }
+
+}

src/com/sk89q/worldguard/bukkit/BukkitUtil.java

@@ -0,0 +1,53 @@
+// $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.bukkit;
+
+import java.util.List;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.Vector;
+
+public class BukkitUtil {
+    private BukkitUtil()  {
+    }
+    
+    public static BlockVector toVector(Block block) {
+        return new BlockVector(block.getX(), block.getY(), block.getZ());
+    }
+    
+    public static Vector toVector(Location loc) {
+        return new Vector(loc.getX(), loc.getY(), loc.getZ());
+    }
+    
+    public static Vector toVector(org.bukkit.util.Vector vector) {
+        return new Vector(vector.getX(), vector.getY(), vector.getZ());
+    }
+    
+    public static Player matchSinglePlayer(Server server, String name) {
+        List<Player> players = server.matchPlayer(name);
+        if (players.size() == 0) {
+            return null;
+        }
+        return players.get(0);
+    }
+}

src/com/sk89q/worldguard/bukkit/LoggerToChatHandler.java

@@ -1,3 +1,4 @@
+package com.sk89q.worldguard.bukkit;
 // $Id$
 /*
  * WorldGuard
@@ -19,6 +20,8 @@
 
 import java.util.logging.Handler;
 import java.util.logging.LogRecord;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
 
 /**
  * Sends all logger messages to a player.
@@ -56,7 +59,7 @@ public class LoggerToChatHandler extends Handler {
      * Publish a log record.
      */
     public void publish(LogRecord record) {
-        player.sendMessage(Colors.LightGray + record.getLevel().getName() + ": "
-                + Colors.White + record.getMessage());
+        player.sendMessage(ChatColor.GRAY + record.getLevel().getName() + ": "
+                + ChatColor.WHITE + record.getMessage());
     }
 }

src/com/sk89q/worldguard/bukkit/WorldGuardBlockListener.java

@@ -0,0 +1,371 @@
+// $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.bukkit;
+
+import java.util.Iterator;
+import java.util.List;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockDamageLevel;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.World;
+import org.bukkit.event.block.*;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+import org.bukkit.inventory.ItemStack;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.*;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+public class WorldGuardBlockListener extends BlockListener {
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+    
+    /**
+     * Construct the object;
+     * 
+     * @param plugin
+     */
+    public WorldGuardBlockListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Called when a block is damaged (or broken)
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockDamage(BlockDamageEvent event) {
+        Player player = event.getPlayer();
+
+        if (!plugin.itemDurability && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            ItemStack held = player.getItemInHand();
+            held.setDamage((byte)-1);
+            player.setItemInHand(held);
+        }
+        
+        if (plugin.useRegions && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            Vector pt = BukkitUtil.toVector(event.getBlock());
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            if (!plugin.blacklist.check(
+                    new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
+                            toVector(event.getBlock()),
+                            event.getBlock().getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (!plugin.blacklist.check(
+                    new DestroyWithBlacklistEvent(plugin.wrapPlayer(player),
+                            toVector(event.getBlock()),
+                            player.getItemInHand().getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a block flows (water/lava)
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockFlow(BlockFromToEvent event) {
+        World world = event.getBlock().getWorld();
+        Block blockFrom = event.getBlock();
+        Block blockTo = event.getToBlock();
+        
+        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
+        boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
+
+        if (plugin.simulateSponge && isWater) {
+            int ox = blockTo.getX();
+            int oy = blockTo.getY();
+            int oz = blockTo.getZ();
+
+            for (int cx = -plugin.spongeRadius; cx <= plugin.spongeRadius; cx++) {
+                for (int cy = -plugin.spongeRadius; cy <= plugin.spongeRadius; cy++) {
+                    for (int cz = -plugin.spongeRadius; cz <= plugin.spongeRadius; cz++) {
+                        if (world.getBlockTypeIdAt(ox + cx, oy + cy, oz + cz) == 19) {
+                            event.setCancelled(true);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        if (plugin.classicWater && isWater) {
+            int blockBelow = world.getBlockTypeIdAt(blockFrom.getX(), blockFrom.getY() - 1, blockFrom.getZ());
+            if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
+                world.getBlockAt(blockFrom.getX(), blockFrom.getY(), blockFrom.getZ()).setTypeId(9);
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (plugin.preventWaterDamage.size() > 0 && isWater) {
+            int targetId = world.getBlockTypeIdAt(
+                    blockTo.getX(), blockTo.getY(), blockTo.getZ());
+            if (plugin.preventWaterDamage.contains(targetId)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (plugin.allowedLavaSpreadOver.size() > 0 && isLava) {
+            int targetId = world.getBlockTypeIdAt(
+                    blockTo.getX(), blockTo.getY() - 1, blockTo.getZ());
+            if (!plugin.allowedLavaSpreadOver.contains(targetId)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a block gets ignited
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockIgnite(BlockIgniteEvent event) {
+        IgniteCause cause = event.getCause();
+        Block block = event.getBlock();
+        Player player = event.getPlayer();
+        World world = block.getWorld();
+        boolean isFireSpread = cause == IgniteCause.SLOW_SPREAD
+                || cause == IgniteCause.SPREAD;
+        
+        if (plugin.preventLavaFire && cause == IgniteCause.LAVA) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.disableFireSpread) {
+            event.setCancelled(true);
+            return;
+        }
+        
+        if (plugin.blockLighter && cause == IgniteCause.FLINT_AND_STEEL) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.fireSpreadDisableToggle && isFireSpread) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
+            int x = block.getX();
+            int y = block.getY();
+            int z = block.getZ();
+            
+            if (plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.useRegions && player != null && !plugin.hasPermission(player, "/regionbypass")) {
+            Vector pt = toVector(block);
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            
+            if (cause == IgniteCause.FLINT_AND_STEEL
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                event.setCancelled(true);
+                return;
+            }
+            
+            if (cause == IgniteCause.FLINT_AND_STEEL
+                    && !plugin.regionManager.getApplicableRegions(pt).allowsLighter()) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when block physics occurs
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        int id = event.getChangedTypeId();
+
+        if (id == 13 && plugin.noPhysicsGravel) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (id == 12 && plugin.noPhysicsSand) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (id == 90 && plugin.allowPortalAnywhere) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+    
+    /**
+     * Called when a block is interacted with
+     * 
+     * @param event Relevant event details
+     */
+    public void onBlockInteract(BlockInteractEvent event) {
+        Block block = event.getBlock();
+        LivingEntity entity = event.getEntity();
+        
+        if (entity instanceof Player && block.getType() == Material.CHEST) {
+            Player player = (Player)entity;
+            if (plugin.useRegions) {
+                Vector pt = toVector(block);
+                LocalPlayer localPlayer = plugin.wrapPlayer(player);
+    
+                if (!plugin.hasPermission(player, "/regionbypass")
+                        && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                    player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+        
+        if (plugin.blacklist != null && entity instanceof Player) {
+            Player player = (Player)entity;
+            
+            if (!plugin.blacklist.check(
+                    new BlockInteractBlacklistEvent(plugin.wrapPlayer(player), toVector(block),
+                            block.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a player places a block
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Block blockPlaced = event.getBlock();
+        Player player = event.getPlayer();
+        World world = blockPlaced.getWorld();
+        
+        if (plugin.useRegions) {
+            Vector pt = toVector(blockPlaced);
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null) {
+            if (!plugin.blacklist.check(
+                    new BlockPlaceBlacklistEvent(plugin.wrapPlayer(player), toVector(blockPlaced),
+                            blockPlaced.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (plugin.simulateSponge && blockPlaced.getTypeId() == 19) {
+            int ox = blockPlaced.getX();
+            int oy = blockPlaced.getY();
+            int oz = blockPlaced.getZ();
+
+            for (int cx = -plugin.spongeRadius; cx <= plugin.spongeRadius; cx++) {
+                for (int cy = -plugin.spongeRadius; cy <= plugin.spongeRadius; cy++) {
+                    for (int cz = -plugin.spongeRadius; cz <= plugin.spongeRadius; cz++) {
+                        int id = world.getBlockTypeIdAt(ox + cx, oy + cy, oz + cz);
+                        if (id == 8 || id == 9) {
+                            world.getBlockAt(ox + cx, oy + cy, oz + cz)
+                                    .setTypeId(0);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Called when a player right clicks a block
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockRightClick(BlockRightClickEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.useRegions && event.getItemInHand().getTypeId() == plugin.regionWand) {
+            Vector pt = toVector(event.getBlock());
+            ApplicableRegionSet app = plugin.regionManager.getApplicableRegions(pt);
+            List<String> regions = plugin.regionManager.getApplicableRegionsIDs(pt);
+            
+            if (regions.size() > 0) {
+                player.sendMessage(ChatColor.YELLOW + "Can you build? "
+                        + (app.canBuild(plugin.wrapPlayer(player)) ? "Yes" : "No"));
+                
+                StringBuilder str = new StringBuilder();
+                for (Iterator<String> it = regions.iterator(); it.hasNext(); ) {
+                    str.append(it.next());
+                    if (it.hasNext()) {
+                        str.append(", ");
+                    }
+                }
+                
+                player.sendMessage(ChatColor.YELLOW + "Applicable regions: " + str.toString());
+            } else {
+                player.sendMessage(ChatColor.YELLOW + "WorldGuard: No defined regions here!");
+            }
+        }
+    }
+}

src/com/sk89q/worldguard/bukkit/WorldGuardEntityListener.java

@@ -0,0 +1,113 @@
+// $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.bukkit;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.*;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import com.sk89q.worldedit.Vector;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+public class WorldGuardEntityListener extends EntityListener {
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+    
+    /**
+     * Construct the object;
+     * 
+     * @param plugin
+     */
+    public WorldGuardEntityListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void onEntityDamageByBlock(EntityDamageByBlockEvent event) {
+        Entity defender = event.getEntity();
+        DamageCause type = event.getCause();
+        
+        if (defender instanceof Player) {
+            Player player = (Player)defender;
+
+            if (plugin.invinciblePlayers.contains(player.getName())) {
+                event.setCancelled(true);
+                return;
+            }
+            
+            if (plugin.disableFallDamage && type == DamageCause.FALL) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (plugin.disableLavaDamage && type == DamageCause.LAVA) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (plugin.disableFireDamage && (type == DamageCause.FIRE
+                    || type == DamageCause.FIRE_TICK)) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (plugin.disableDrowningDamage && type == DamageCause.DROWNING) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (type == DamageCause.DROWNING
+                    && plugin.amphibiousPlayers.contains(player.getName())) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    @Override
+    public void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
+        Entity attacker = event.getDamager();
+        Entity defender = event.getEntity();
+        
+        if (defender instanceof Player) {
+            Player player = (Player)defender;
+
+            if (plugin.invinciblePlayers.contains(player.getName())) {
+                event.setCancelled(true);
+                return;
+            }
+            
+            if (attacker != null && attacker instanceof Player) {
+                if (plugin.useRegions) {
+                    Vector pt = toVector(defender.getLocation());
+                    
+                    if (!plugin.regionManager.getApplicableRegions(pt).allowsPvP()) {
+                        player.sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+            }
+        }
+    }
+}

src/com/sk89q/worldguard/bukkit/WorldGuardPlayerListener.java

@@ -0,0 +1,788 @@
+// $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.bukkit;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.*;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.plugin.Plugin;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.blocks.ItemType;
+import com.sk89q.worldedit.bukkit.WorldEditAPI;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.regions.Region;
+import com.sk89q.worldedit.IncompleteRegionException;
+import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.*;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
+import com.sk89q.worldguard.domains.*;
+import com.sk89q.worldguard.protection.*;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+/**
+ * Handles all events thrown in relation to a Player
+ */
+public class WorldGuardPlayerListener extends PlayerListener {
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+    /**
+     * Group pattern used to specify groups for the region command.
+     */
+    private static Pattern groupPattern = Pattern.compile("^[gG]:(.+)$");
+
+    private static int CMD_LIST_SIZE = 9;
+    
+    /**
+     * Construct the object;
+     * 
+     * @param plugin
+     */
+    public WorldGuardPlayerListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Called when a player joins a server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerJoin(PlayerEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.fireSpreadDisableToggle) {
+            player.sendMessage(ChatColor.YELLOW
+                    + "Fire spread is currently globally disabled.");
+        }
+
+        if (plugin.inGroup(player, "wg-invincible")) {
+            plugin.invinciblePlayers.add(player.getName());
+        }
+
+        if (plugin.inGroup(player, "wg-amphibious")) {
+            plugin.amphibiousPlayers.add(player.getName());
+        }
+    }
+
+    /**
+     * Called when a player leaves a server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerQuit(PlayerEvent event) {
+        Player player = event.getPlayer();
+        plugin.invinciblePlayers.remove(player.getName());
+        plugin.amphibiousPlayers.remove(player.getName());
+        if (plugin.blacklist != null) {
+            plugin.blacklist.forgetPlayer(plugin.wrapPlayer(player));
+        }
+    }
+    
+    /**
+     * Called when a player uses an item
+     * 
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerItem(PlayerItemEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getBlockClicked();
+        
+        if (plugin.useRegions && !event.isBlock() && event.getBlockClicked() != null) {
+            Vector pt = toVector(block.getRelative(event.getBlockFace()));
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED
+                        + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null) {
+            if (!plugin.blacklist.check(
+                    new ItemUseBlacklistEvent(plugin.wrapPlayer(player), toVector(block),
+                            block.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a player attempts to log in to the server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerLogin(PlayerLoginEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.enforceOneSession) {
+            String name = player.getName();
+            
+            for (Player pl : plugin.getServer().getOnlinePlayers()) {
+                if (pl.getName().equalsIgnoreCase(name)) {
+                    pl.kickPlayer("Logged in from another location.");
+                }
+            }
+        }
+    }
+
+    /**
+     * Called when a player attempts to use a command
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerCommand(PlayerChatEvent event) {
+        if (handleCommand(event)) {
+            event.setCancelled(true);
+        }
+    }
+
+    /**
+     * Called when a player attempts to use a command
+     *
+     * @param event Relevant event details
+     */
+    public boolean handleCommand(PlayerChatEvent event) {
+        Player player = event.getPlayer();
+        String[] split = event.getMessage().split(" ");
+        
+        if (split[0].equalsIgnoreCase("/stopfire") &&
+                plugin.hasPermission(player, "/stopfire")) {
+            if (!plugin.fireSpreadDisableToggle) {
+                plugin.getServer().broadcastMessage(ChatColor.YELLOW
+                        + "Fire spread has been globally disabled by " + player.getName() + ".");
+            } else {
+                player.sendMessage(ChatColor.YELLOW + "Fire spread was already globally disabled.");
+            }
+            
+            plugin.fireSpreadDisableToggle = true;
+        } else if (split[0].equalsIgnoreCase("/allowfire")
+                    && plugin.hasPermission(player, "/stopfire")) {
+            if (plugin.fireSpreadDisableToggle) {
+                plugin.getServer().broadcastMessage(ChatColor.YELLOW
+                        + "Fire spread has been globally re-enabled by " + player.getName() + ".");
+            } else {
+                player.sendMessage(ChatColor.YELLOW + "Fire spread was already globally enabled.");
+            }
+            
+            plugin.fireSpreadDisableToggle = false;
+        } else if (split[0].equalsIgnoreCase("/god")
+                    && plugin.hasPermission(player, "/god")) {
+            // Allow setting other people invincible
+            if (split.length > 1) {
+                if (!plugin.hasPermission(player, "/godother")) {
+                    player.sendMessage(ChatColor.RED + "You don't have permission to make others invincible.");
+                    return true;
+                }
+
+                Player other = matchSinglePlayer(plugin.getServer(), split[1]);
+                if (other == null) {
+                    player.sendMessage(ChatColor.RED + "Player not found.");
+                } else {
+                    if (!plugin.invinciblePlayers.contains(other.getName())) {
+                        plugin.invinciblePlayers.add(other.getName());
+                        player.sendMessage(ChatColor.YELLOW + other.getName() + " is now invincible!");
+                        other.sendMessage(ChatColor.YELLOW + player.getName() + " has made you invincible!");
+                    } else {
+                        plugin.invinciblePlayers.remove(other.getName());
+                        player.sendMessage(ChatColor.YELLOW + other.getName() + " is no longer invincible.");
+                        other.sendMessage(ChatColor.YELLOW + player.getName() + " has taken away your invincibility.");
+                    }
+                }
+            // Invincibility for one's self
+            } else {
+                if (!plugin.invinciblePlayers.contains(player.getName())) {
+                    plugin.invinciblePlayers.add(player.getName());
+                    player.sendMessage(ChatColor.YELLOW + "You are now invincible!");
+                } else {
+                    plugin.invinciblePlayers.remove(player.getName());
+                    player.sendMessage(ChatColor.YELLOW + "You are no longer invincible.");
+                }
+            }
+        } else if ((split[0].equalsIgnoreCase("/stack")
+                || split[0].equalsIgnoreCase("/;"))
+                    && plugin.hasPermission(player, "/stack")) {
+            ItemStack[] items = player.getInventory().getContents();
+            int len = items.length;
+
+            int affected = 0;
+            
+            for (int i = 0; i < len; i++) {
+                ItemStack item = items[i];
+
+                // Avoid infinite stacks and stacks with durability
+                if (item == null || item.getAmount() <= 0
+                        || ItemType.shouldNotStack(item.getTypeId())) {
+                    continue;
+                }
+
+                // Ignore buckets
+                if (item.getTypeId() >= 325 && item.getTypeId() <= 327) {
+                    continue;
+                }
+
+                if (item.getAmount() < 64) {
+                    int needed = 64 - item.getAmount(); // Number of needed items until 64
+
+                    // Find another stack of the same type
+                    for (int j = i + 1; j < len; j++) {
+                        ItemStack item2 = items[j];
+
+                        // Avoid infinite stacks and stacks with durability
+                        if (item2 == null || item2.getAmount() <= 0
+                                || ItemType.shouldNotStack(item.getTypeId())) {
+                            continue;
+                        }
+
+                        // Same type?
+                        // Blocks store their color in the damage value
+                        if (item2.getTypeId() == item.getTypeId() &&
+                                (!ItemType.usesDamageValue(item.getTypeId())
+                                        || item.getDamage() == item2.getDamage())) {
+                            // This stack won't fit in the parent stack
+                            if (item2.getAmount() > needed) {
+                                item.setAmount(64);
+                                item2.setAmount(item2.getAmount() - needed);
+                                break;
+                            // This stack will
+                            } else {
+                                items[j] = null;
+                                item.setAmount(item.getAmount() + item2.getAmount());
+                                needed = 64 - item.getAmount();
+                            }
+
+                            affected++;
+                        }
+                    }
+                }
+            }
+
+            if (affected > 0) {
+                player.getInventory().setContents(items);
+            }
+
+            player.sendMessage(ChatColor.YELLOW + "Items compacted into stacks!");
+        } else if (split[0].equalsIgnoreCase("/rg")
+                || split[0].equalsIgnoreCase("/region")) {
+            if (split.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region <define|flag|delete|info|add|remove|list|save|load> ...");
+                return true;
+            }
+            
+            String action = split[1];
+            String[] args = new String[split.length - 1];
+            System.arraycopy(split, 1, args, 0, split.length - 1);
+            
+            handleRegionCommand(player, action, args);
+        } else if (split[0].equalsIgnoreCase("/reload")
+                && plugin.hasPermission(player, "/reload")
+                && split.length > 1) {
+            if (split[1].equalsIgnoreCase("WorldGuard")) {
+                LoggerToChatHandler handler = new LoggerToChatHandler(player);
+                handler.setLevel(Level.ALL);
+                Logger minecraftLogger = Logger.getLogger("Minecraft");
+                minecraftLogger.addHandler(handler);
+
+                try {
+                    plugin.loadConfiguration();
+                    plugin.postReload();
+                    player.sendMessage("WorldGuard configuration reloaded.");
+                } catch (Throwable t) {
+                    player.sendMessage("Error while reloading: "
+                            + t.getMessage());
+                } finally {
+                    minecraftLogger.removeHandler(handler);
+                }
+
+                return true;
+            }
+        } else {
+            return false;
+        }
+
+        return true;
+    }
+    
+    /**
+     * Handles a region command.
+     * 
+     * @param player
+     * @param action
+     * @param args
+     */
+    private void handleRegionCommand(Player player, String action, String[] args) {
+        if (!plugin.useRegions) {
+            player.sendMessage(ChatColor.RED + "Regions are disabled.");
+            return;
+        }
+        
+        if (action.equalsIgnoreCase("define")) {
+            if (!canUseRegionCommand(player, "/regiondefine")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
+                return;
+            }
+            
+            if (args.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region define <id> [owner1 [owner2 [owners...]]]");
+                return;
+            }
+            
+            try {
+                String id = args[1].toLowerCase();
+                Plugin wePlugin = plugin.getServer().getPluginManager().getPlugin("WorldEdit");
+                if (plugin == null) {
+                    player.sendMessage(ChatColor.RED + "WorldEdit must be installed and enabled as a plugin.");
+                    return;
+                }
+                
+                WorldEditPlugin worldEdit = (WorldEditPlugin)wePlugin;
+                WorldEditAPI api = worldEdit.getAPI();
+                
+                LocalSession session = api.getSession(player);
+                Region weRegion = session.getRegion();
+                
+                BlockVector min = weRegion.getMinimumPoint().toBlockVector();
+                BlockVector max = weRegion.getMaximumPoint().toBlockVector();
+                
+                ProtectedRegion region = new ProtectedCuboidRegion(min, max);
+                if (args.length >= 3) {
+                    region.setOwners(parseDomainString(args, 2));
+                }
+                plugin.regionManager.addRegion(id, region);
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
+            } catch (IncompleteRegionException e) {
+                player.sendMessage(ChatColor.RED + "You must first define an area in WorldEdit.");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("claim")) {
+            if (!canUseRegionCommand(player, "/regionclaim")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regionclaim permission.");
+                return;
+            }
+            
+            if (args.length < 1) {
+                player.sendMessage(ChatColor.RED + "/region claim <id>");
+                return;
+            }
+            
+            try {
+                String id = args[1].toLowerCase();
+                Plugin wePlugin = plugin.getServer().getPluginManager().getPlugin("WorldEdit");
+                if (plugin == null) {
+                    player.sendMessage(ChatColor.RED + "WorldEdit must be installed and enabled as a plugin.");
+                    return;
+                }
+
+                ProtectedRegion existing = plugin.regionManager.getRegion(id);
+                
+                if (existing != null) {
+                    if (!existing.getOwners().contains(plugin.wrapPlayer(player))) {
+                        player.sendMessage(ChatColor.RED + "You don't own this region.");
+                        return;
+                    }
+                }
+                
+                WorldEditPlugin worldEdit = (WorldEditPlugin)wePlugin;
+                WorldEditAPI api = worldEdit.getAPI();
+                
+                LocalSession session = api.getSession(player);
+                Region weRegion = session.getRegion();
+                
+                BlockVector min = weRegion.getMinimumPoint().toBlockVector();
+                BlockVector max = weRegion.getMaximumPoint().toBlockVector();
+                
+                ProtectedRegion region = new ProtectedCuboidRegion(min, max);
+                
+                if (plugin.regionManager.overlapsUnownedRegion(region, plugin.wrapPlayer(player))) {
+                    player.sendMessage(ChatColor.RED + "This region overlaps with someone else's region.");
+                    return;
+                }
+                
+                region.getOwners().addPlayer(player.getName());
+                
+                plugin.regionManager.addRegion(id, region);
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
+            } catch (IncompleteRegionException e) {
+                player.sendMessage(ChatColor.RED + "You must first define an area in WorldEdit.");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("flag")) {
+            if (!canUseRegionCommand(player, "/regiondefine")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
+                return;
+            }
+            
+            if (args.length < 4) {
+                player.sendMessage(ChatColor.RED + "/region flag <id> <lighter> <none|allow|deny>");
+                player.sendMessage(ChatColor.RED + "Other flags not supported in Bukkit at the moment.");
+                return;
+            }
+            
+            try {
+                String id = args[1].toLowerCase();
+                String flagStr = args[2];
+                String stateStr = args[3];
+                ProtectedRegion region = plugin.regionManager.getRegion(id);
+                
+                if (region == null) {
+                    player.sendMessage(ChatColor.RED + "Could not find a region by that ID.");
+                    return;
+                }
+                
+                AreaFlags.State state = null;
+    
+                if (stateStr.equalsIgnoreCase("allow")) {
+                    state = AreaFlags.State.ALLOW;
+                } else if (stateStr.equalsIgnoreCase("deny")) {
+                    state = AreaFlags.State.DENY;
+                } else if (stateStr.equalsIgnoreCase("none")) {
+                    state = AreaFlags.State.NONE;
+                } else {
+                    player.sendMessage(ChatColor.RED + "Acceptable states: allow, deny, none");
+                    return;
+                }
+                
+                AreaFlags flags = region.getFlags();
+                
+                /*if (flagStr.equalsIgnoreCase("build")) {
+                    flags.allowBuild = state;
+                } else if (flagStr.equalsIgnoreCase("pvp")) {
+                    flags.allowPvP = state;
+                } else if (flagStr.equalsIgnoreCase("tnt")) {
+                    flags.allowTNT = state;
+                } else*/ if (flagStr.equalsIgnoreCase("lighter")) {
+                    flags.allowLighter = state;
+                } else {
+                    player.sendMessage(ChatColor.RED + "Acceptable flags: build, pvp, tnt, lighter");
+                    return;
+                }
+                
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region '" + id + "' updated.");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("info")) {
+            if (!canUseRegionCommand(player, "/regioninfo")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regioninfo permission.");
+                return;
+            }
+            
+            if (args.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region info <id>");
+                return;
+            }
+    
+            String id = args[1].toLowerCase();
+            if (!plugin.regionManager.hasRegion(id)) {
+                player.sendMessage(ChatColor.RED + "A region with ID '"
+                        + id + "' doesn't exist.");
+                return;
+            }
+    
+            ProtectedRegion region = plugin.regionManager.getRegion(id);
+            AreaFlags flags = region.getFlags();
+            DefaultDomain domain = region.getOwners();
+            
+            player.sendMessage(ChatColor.YELLOW + "Region ID: " + id);
+            player.sendMessage(ChatColor.GRAY + "Type: " + region.getClass().getCanonicalName());
+            player.sendMessage(ChatColor.BLUE + "Build: " + flags.allowBuild.name());
+            player.sendMessage(ChatColor.BLUE + "PvP: " + flags.allowPvP.name());
+            player.sendMessage(ChatColor.BLUE + "TNT: " + flags.allowTNT.name());
+            player.sendMessage(ChatColor.BLUE + "Lighter: " + flags.allowLighter.name());
+            player.sendMessage(ChatColor.LIGHT_PURPLE + "Players: " + domain.toPlayersString());
+            player.sendMessage(ChatColor.LIGHT_PURPLE + "Groups: " + domain.toGroupsString());
+        } else if (action.equalsIgnoreCase("addowner")) {
+            if (!canUseRegionCommand(player, "/regiondefine")
+                    && !canUseRegionCommand(player, "/regionclaim")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
+                return;
+            }
+            
+            if (args.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region addowner <id>");
+                return;
+            }
+    
+            try {
+                String id = args[1].toLowerCase();
+                if (!plugin.regionManager.hasRegion(id)) {
+                    player.sendMessage(ChatColor.RED + "A region with ID '"
+                            + id + "' doesn't exist.");
+                    return;
+                }
+                
+                ProtectedRegion existing = plugin.regionManager.getRegion(id);
+                
+                if (!canUseRegionCommand(player, "/regiondefine")
+                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
+                    player.sendMessage(ChatColor.RED + "You don't own this region.");
+                    return;
+                }
+                
+                addToDomain(existing.getOwners(), args, 2);
+                
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region updated!");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("removeowner")) {
+            if (!canUseRegionCommand(player, "/regiondefine")
+                    && !canUseRegionCommand(player, "/regionclaim")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
+                return;
+            }
+            
+            if (args.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region removeowner <id>");
+                return;
+            }
+    
+            try {
+                String id = args[1].toLowerCase();
+                if (!plugin.regionManager.hasRegion(id)) {
+                    player.sendMessage(ChatColor.RED + "A region with ID '"
+                            + id + "' doesn't exist.");
+                    return;
+                }
+                
+                ProtectedRegion existing = plugin.regionManager.getRegion(id);
+                
+                if (!canUseRegionCommand(player, "/regiondefine")
+                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
+                    player.sendMessage(ChatColor.RED + "You don't own this region.");
+                    return;
+                }
+                
+                removeFromDomain(existing.getOwners(), args, 2);
+                
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region updated!");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("list")) {
+            if (!canUseRegionCommand(player, "/regiondefine")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondefine permission.");
+                return;
+            }
+            
+            int page = 0;
+            
+            if (args.length >= 2) {
+                try {
+                    page = Math.max(0, Integer.parseInt(args[1]) - 1);
+                } catch (NumberFormatException e) {
+                    page = 0;
+                }
+            }
+    
+            Map<String,ProtectedRegion> regions = plugin.regionManager.getRegions();
+            int size = regions.size();
+            int pages = (int)Math.ceil(size / (float)CMD_LIST_SIZE);
+            
+            String[] regionIDList = new String[size];
+            int index = 0;
+            for (String id : regions.keySet()) {
+                regionIDList[index] = id;
+                index++;
+            }
+            Arrays.sort(regionIDList);
+            
+            
+            player.sendMessage(ChatColor.RED + "Regions (page "
+                    + (page + 1) + " of " + pages + "):");
+            
+            if (page < pages) {
+                for (int i = page * CMD_LIST_SIZE; i < page * CMD_LIST_SIZE + CMD_LIST_SIZE; i++) {
+                    if (i >= size) break;
+                    player.sendMessage(ChatColor.YELLOW.toString() + (i + 1) + ". " + regionIDList[i]);
+                }
+            }
+        } else if (action.equalsIgnoreCase("delete")) {
+            if (!canUseRegionCommand(player, "/regiondelete")
+                    && !canUseRegionCommand(player, "/regionclaim")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regiondelete permission.");
+                return;
+            }
+            
+            if (args.length < 2) {
+                player.sendMessage(ChatColor.RED + "/region delete <id>");
+                return;
+            }
+    
+            try {
+                String id = args[1].toLowerCase();
+                if (!plugin.regionManager.hasRegion(id)) {
+                    player.sendMessage(ChatColor.RED + "A region with ID '"
+                            + id + "' doesn't exist.");
+                    return;
+                }
+
+                ProtectedRegion existing = plugin.regionManager.getRegion(id);
+                
+                if (!canUseRegionCommand(player, "/regiondelete")
+                        && !existing.getOwners().contains(plugin.wrapPlayer(player))) {
+                    player.sendMessage(ChatColor.RED + "You don't own this region.");
+                    return;
+                }
+                
+                plugin.regionManager.removeRegion(id);
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region removed!");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("save")) {
+            if (!canUseRegionCommand(player, "/regionsave")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regionsave permission.");
+                return;
+            }
+            
+            try {
+                plugin.regionLoader.save(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region database saved to file!");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to save: "
+                        + e.getMessage());
+            }
+        } else if (action.equalsIgnoreCase("load")) {
+            if (!canUseRegionCommand(player, "/regionload")) {
+                player.sendMessage(ChatColor.RED + "You don't have the /regionload permission.");
+                return;
+            }
+            
+            try {
+                plugin.regionLoader.load(plugin.regionManager);
+                player.sendMessage(ChatColor.YELLOW + "Region database loaded from file!");
+            } catch (IOException e) {
+                player.sendMessage(ChatColor.RED + "Region database failed to load: "
+                        + e.getMessage());
+            }
+        } else {
+            player.sendMessage(ChatColor.RED + "/region <define|claim|flag|delete|info|addowner|removeowner|list|save|load> ...");
+        }
+    }
+    
+    /**
+     * Checks for the command or /region.
+     * 
+     * @param player
+     * @param cmd
+     * @return
+     */
+    private boolean canUseRegionCommand(Player player, String cmd) {
+        return plugin.hasPermission(player, "/region")
+                || plugin.hasPermission(player, cmd);
+    }
+    
+    /**
+     * Parse a group/player DefaultDomain specification for areas.
+     * 
+     * @param domain
+     * @param split
+     * @param startIndex
+     */
+    private static void addToDomain(DefaultDomain domain,
+            String[] split, int startIndex) {        
+        for (int i = startIndex; i < split.length; i++) {
+            String s = split[i];
+            Matcher m = groupPattern.matcher(s);
+            if (m.matches()) {
+                domain.addGroup(m.group(1));
+            } else {
+                domain.addPlayer(s);
+            }
+        }
+    }
+    
+    /**
+     * Parse a group/player DefaultDomain specification for areas.
+     * 
+     * @param domain
+     * @param split
+     * @param startIndex
+     */
+    private static void removeFromDomain(DefaultDomain domain,
+            String[] split, int startIndex) {        
+        for (int i = startIndex; i < split.length; i++) {
+            String s = split[i];
+            Matcher m = groupPattern.matcher(s);
+            if (m.matches()) {
+                domain.removeGroup(m.group(1));
+            } else {
+                domain.removePlayer(s);
+            }
+        }
+    }
+    
+    /**
+     * Parse a group/player DefaultDomain specification for areas.
+     * 
+     * @param split
+     * @param startIndex
+     * @return
+     */
+    private static DefaultDomain parseDomainString(String[] split, int startIndex) {
+        DefaultDomain domain = new DefaultDomain();
+        
+        for (int i = startIndex; i < split.length; i++) {
+            String s = split[i];
+            Matcher m = groupPattern.matcher(s);
+            if (m.matches()) {
+                domain.addGroup(m.group(1));
+            } else {
+                domain.addPlayer(s);
+            }
+        }
+        
+        return domain;
+    }
+}

src/com/sk89q/worldguard/bukkit/WorldGuardPlugin.java

@@ -0,0 +1,327 @@
+// $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.bukkit;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.entity.Player;
+import org.bukkit.Server;
+import org.bukkit.event.Event.Priority;
+import org.bukkit.event.Event;
+import org.bukkit.event.Listener;
+import org.bukkit.plugin.PluginDescriptionFile;
+import org.bukkit.plugin.PluginLoader;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.util.config.Configuration;
+import com.sk89q.bukkit.migration.ConfigurationPermissionsResolver;
+import com.sk89q.worldguard.blacklist.Blacklist;
+import com.sk89q.worldguard.blacklist.BlacklistLogger;
+import com.sk89q.worldguard.blacklist.loggers.*;
+import com.sk89q.worldguard.protection.*;
+
+/**
+ * Plugin for Bukkit.
+ * 
+ * @author sk89qs
+ */
+public class WorldGuardPlugin extends JavaPlugin {
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    
+    private final WorldGuardPlayerListener playerListener =
+        new WorldGuardPlayerListener(this);
+    private final WorldGuardBlockListener blockListener =
+        new WorldGuardBlockListener(this);
+    private final WorldGuardEntityListener entityListener =
+        new WorldGuardEntityListener(this);
+    private final ConfigurationPermissionsResolver perms;
+    
+    Blacklist blacklist;
+
+    RegionManager regionManager = new FlatRegionManager();
+    ProtectionDatabase regionLoader;
+    
+    Set<String> invinciblePlayers = new HashSet<String>();
+    Set<String> amphibiousPlayers = new HashSet<String>();
+    boolean fireSpreadDisableToggle;
+    
+    // Configuration follows
+    
+    boolean enforceOneSession;
+    boolean itemDurability;
+
+    boolean classicWater;
+    boolean simulateSponge;
+    int spongeRadius;
+
+    boolean noPhysicsGravel;
+    boolean noPhysicsSand;
+    boolean allowPortalAnywhere;
+    Set<Integer> preventWaterDamage;
+
+    boolean blockTNT;
+    boolean blockLighter;
+
+    boolean disableFireSpread;
+    Set<Integer> disableFireSpreadBlocks;
+    boolean preventLavaFire;
+    Set<Integer> allowedLavaSpreadOver;
+    
+    boolean blockCreeperExplosions;
+
+    int loginProtection;
+    int spawnProtection;
+    boolean kickOnDeath;
+    boolean exactRespawn;
+    boolean teleportToHome;
+    
+    boolean disableFallDamage;
+    boolean disableLavaDamage;
+    boolean disableFireDamage;
+    boolean disableDrowningDamage;
+    boolean disableSuffocationDamage;
+    boolean teleportOnSuffocation;
+
+    boolean useRegions;
+    int regionWand = 287; 
+    
+    public WorldGuardPlugin(PluginLoader pluginLoader, Server instance,
+            PluginDescriptionFile desc, File folder, File plugin, ClassLoader cLoader) {
+        super(pluginLoader, instance, desc, folder, plugin, cLoader);
+
+        logger.info("WorldGuard " + desc.getVersion() + " loaded.");
+        
+        folder.mkdirs();
+
+        regionLoader = new CSVDatabase(new File(folder, "regions.txt"));
+        perms = new ConfigurationPermissionsResolver(getConfiguration());
+        loadConfiguration();
+        postReload();
+        registerEvents();
+    }
+
+    public void onEnable() {
+    }
+
+    public void onDisable() {
+    }
+
+    private void registerEvents() {
+        registerEvent(Event.Type.BLOCK_DAMAGED, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_FLOW, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_IGNITE, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_PHYSICS, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_INTERACT, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_PLACED, blockListener, Priority.Normal);
+        registerEvent(Event.Type.BLOCK_RIGHTCLICKED, blockListener, Priority.Normal);
+
+        registerEvent(Event.Type.ENTITY_DAMAGEDBY_BLOCK, entityListener, Priority.Normal);
+        registerEvent(Event.Type.ENTITY_DAMAGEDBY_ENTITY, entityListener, Priority.Normal);
+
+        registerEvent(Event.Type.PLAYER_COMMAND, playerListener, Priority.Normal);
+        registerEvent(Event.Type.PLAYER_ITEM, playerListener, Priority.Normal);
+        registerEvent(Event.Type.PLAYER_JOIN, playerListener, Priority.Normal);
+        registerEvent(Event.Type.PLAYER_LOGIN, playerListener, Priority.Normal);
+        registerEvent(Event.Type.PLAYER_QUIT, playerListener, Priority.Normal);
+    }
+    
+    private void registerEvent(Event.Type type, Listener listener, Priority priority) {
+        getServer().getPluginManager().registerEvent(type, listener, priority, this);
+    }
+
+    /**
+     * Load the configuration
+     */
+    public void loadConfiguration() {
+        Configuration config = getConfiguration();
+        config.load();
+
+        enforceOneSession = config.getBoolean("protection.enforce-single-session", true);
+        itemDurability = config.getBoolean("protection.item-durability", true);
+        
+        classicWater = config.getBoolean("simulation.classic-water", false);
+        simulateSponge = config.getBoolean("simulation.sponge.enable", true);
+        spongeRadius = Math.max(1, config.getInt("simulation.sponge.radius", 3)) - 1;
+        
+        noPhysicsGravel = config.getBoolean("physics.no-physics-gravel", false);
+        noPhysicsSand = config.getBoolean("physics.no-physics-sand", false);
+        allowPortalAnywhere = config.getBoolean("physics.allow-portal-anywhere", false);
+        preventWaterDamage = new HashSet<Integer>(config.getIntList("physics.disable-water-damage-blocks", null));
+        
+        blockTNT = config.getBoolean("ignition.block-tnt", false);
+        blockLighter = config.getBoolean("ignition.block-lighter", false);
+        
+        preventLavaFire = config.getBoolean("fire.disable-lava-fire-spread", true);
+        disableFireSpread = config.getBoolean("fire.disable-all-fire-spread", false);
+        disableFireSpreadBlocks = new HashSet<Integer>(config.getIntList("fire.disable-fire-spread-blocks", null));
+        allowedLavaSpreadOver = new HashSet<Integer>(config.getIntList("fire.lava-spread-blocks", null));
+        
+        blockCreeperExplosions = config.getBoolean("mobs.block-creeper-explosions", false);
+        
+        loginProtection = config.getInt("spawn.login-protection", 3);
+        spawnProtection = config.getInt("spawn.spawn-protection", 0);
+        kickOnDeath = config.getBoolean("spawn.kick-on-death", false);
+        exactRespawn = config.getBoolean("spawn.exact-respawn", false);
+        teleportToHome = config.getBoolean("spawn.teleport-to-home-on-death", false);
+        
+        disableFallDamage = config.getBoolean("player-damage.disable-fall-damage", false);
+        disableLavaDamage = config.getBoolean("player-damage.disable-lava-damage", false);
+        disableFireDamage = config.getBoolean("player-damage.disable-fire-damage", false);
+        disableDrowningDamage = config.getBoolean("player-damage.disable-water-damage", false);
+        disableSuffocationDamage = config.getBoolean("player-damage.disable-suffocation-damage", false);
+        teleportOnSuffocation = config.getBoolean("player-damage.teleport-on-suffocation", false);
+        
+        useRegions = config.getBoolean("regions.enable", true);
+        regionWand = config.getInt("regions.wand", 287);
+
+        try {
+            regionLoader.load();
+            regionManager.setRegions(regionLoader.getRegions());
+        } catch (IOException e) {
+            logger.warning("WorldGuard: Failed to load regions: "
+                    + e.getMessage());
+        }
+        
+        // Console log configuration
+        boolean logConsole = config.getBoolean("blacklist.logging.console.enable", true);
+
+        // Database log configuration
+        boolean logDatabase = config.getBoolean("blacklist.logging.database.enable", false);
+        String dsn = config.getString("blacklist.logging.database.dsn", "jdbc:mysql://localhost:3306/minecraft");
+        String user = config.getString("blacklist.logging.database.user", "root");
+        String pass = config.getString("blacklist.logging.database.pass", "");
+        String table = config.getString("blacklist.logging.database.table", "blacklist_events");
+
+        // File log configuration
+        boolean logFile = config.getBoolean("blacklist.logging.file.enable", false);
+        String logFilePattern = config.getString("blacklist.logging.file.path", "worldguard/logs/%Y-%m-%d.log");
+        int logFileCacheSize = Math.max(1, config.getInt("blacklist.logging.file.open-files", 10));
+        
+        // Load the blacklist
+        try {
+            // If there was an existing blacklist, close loggers
+            if (blacklist != null) {
+                blacklist.getLogger().close();
+            }
+
+            // First load the blacklist data from worldguard-blacklist.txt
+            Blacklist blist = new BukkitBlacklist(this);
+            blist.load(new File(getDataFolder(), "blacklist.txt"));
+
+            // If the blacklist is empty, then set the field to null
+            // and save some resources
+            if (blist.isEmpty()) {
+                this.blacklist = null;
+            } else {
+                this.blacklist = blist;
+                logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
+
+                BlacklistLogger blacklistLogger = blist.getLogger();
+
+                if (logDatabase) {
+                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table));
+                }
+
+                if (logConsole) {
+                    blacklistLogger.addHandler(new ConsoleLoggerHandler());
+                }
+
+                if (logFile) {
+                    FileLoggerHandler handler =
+                            new FileLoggerHandler(logFilePattern, logFileCacheSize);
+                    blacklistLogger.addHandler(handler);
+                }
+            }
+        } catch (FileNotFoundException e) {
+            logger.log(Level.WARNING, "WorldGuard blacklist does not exist.");
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Could not load WorldGuard blacklist: "
+                    + e.getMessage());
+        }
+
+        // Print an overview of settings
+        if (config.getBoolean("summary-on-start", true)) {
+            logger.log(Level.INFO, enforceOneSession ? "WorldGuard: Single session is enforced."
+                    : "WorldGuard: Single session is NOT ENFORCED.");
+            logger.log(Level.INFO, blockTNT ? "WorldGuard: TNT ignition is blocked."
+                    : "WorldGuard: TNT ignition is PERMITTED.");
+            logger.log(Level.INFO, blockLighter ? "WorldGuard: Lighters are blocked."
+                    : "WorldGuard: Lighters are PERMITTED.");
+            logger.log(Level.INFO, preventLavaFire ? "WorldGuard: Lava fire is blocked."
+                    : "WorldGuard: Lava fire is PERMITTED.");
+            if (disableFireSpread) {
+                logger.log(Level.INFO, "WorldGuard: All fire spread is disabled.");
+            } else {
+                if (disableFireSpreadBlocks != null) {
+                    logger.log(Level.INFO, "WorldGuard: Fire spread is limited to "
+                            + disableFireSpreadBlocks.size() + " block types.");
+                } else {
+                    logger.log(Level.INFO, "WorldGuard: Fire spread is UNRESTRICTED.");
+                }
+            }
+        }
+        
+        // Temporary
+        perms.load();
+    }
+    
+    /**
+     * Populates various lists.
+     */
+    public void postReload() {
+        invinciblePlayers.clear();
+        amphibiousPlayers.clear();
+
+        try {
+            for (Player player : getServer().getOnlinePlayers()) {
+                if (inGroup(player, "wg-invincible")) {
+                    invinciblePlayers.add(player.getName());
+                }
+
+                if (inGroup(player, "wg-amphibious")) {
+                    amphibiousPlayers.add(player.getName());
+                }
+            }
+        } catch (NullPointerException e) { // Thrown if loaded too early
+        }
+    }
+    
+    boolean inGroup(Player player, String group) {
+        return perms.inGroup(player.getName(), group);
+    }
+    
+    boolean hasPermission(Player player, String perm) {
+        return perms.hasPermission(player.getName(), perm);
+    }
+    
+    List<String> getGroups(Player player) {
+        return new ArrayList<String>();
+    }
+
+    BukkitPlayer wrapPlayer(Player player) {
+        return new BukkitPlayer(this, player);
+    }
+}

src/com/sk89q/worldguard/protection/FlatRegionManager.java

@@ -24,6 +24,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.LinkedHashMap;
 import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
 
 /**
  * A very simple implementation of the region manager that uses a flat list
@@ -129,6 +130,32 @@ public class FlatRegionManager implements RegionManager {
         return applicable;
     }
     
+    /**
+     * Returns true if the provided region overlaps with any other region that
+     * is not owned by the player.
+     * 
+     * @param region
+     * @param player
+     * @return
+     */
+    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player) {
+        for (ProtectedRegion other : regions.values()) {
+            if (other.getOwners().contains(player)) {
+                continue;
+            }
+            
+            try {
+                if (ProtectedRegion.intersects(region, other)) {
+                    return true;
+                }
+            } catch (UnsupportedIntersectionException e) {
+                // TODO: Maybe do something here
+            }
+        }
+        
+        return false;
+    }
+    
     /**
      * Get the number of regions.
      * 

src/com/sk89q/worldguard/protection/ProtectedRegion.java

@@ -19,6 +19,7 @@
 
 package com.sk89q.worldguard.protection;
 
+import com.sk89q.worldedit.BlockVector;
 import com.sk89q.worldedit.Vector;
 import com.sk89q.worldguard.domains.DefaultDomain;
 
@@ -125,4 +126,34 @@ public abstract class ProtectedRegion {
      * @return
      */
     public abstract boolean contains(Vector pt);
+    
+    /**
+     * Checks if two region intersects.
+     * 
+     * @param region1
+     * @param region2
+     * @throws UnsupportedIntersectionException
+     * @return
+     */
+    public static boolean intersects(ProtectedRegion region1, ProtectedRegion region2)
+            throws UnsupportedIntersectionException {
+        if (region1 instanceof ProtectedCuboidRegion
+                && region2 instanceof ProtectedCuboidRegion) {
+            ProtectedCuboidRegion r1 = (ProtectedCuboidRegion)region1;
+            ProtectedCuboidRegion r2 = (ProtectedCuboidRegion)region2;
+            BlockVector min1 = r1.getMinimumPoint();
+            BlockVector max1 = r1.getMaximumPoint();
+            BlockVector min2 = r2.getMinimumPoint();
+            BlockVector max2 = r2.getMaximumPoint(); 
+            
+            return !(min1.getBlockX() > max2.getBlockX()
+                    || min1.getBlockY() > max2.getBlockY()
+                    || min1.getBlockZ() > max2.getBlockZ()
+                    || max1.getBlockX() < min2.getBlockX()
+                    || max1.getBlockY() < min2.getBlockY()
+                    || max1.getBlockZ() < min2.getBlockZ());
+        } else {
+            throw new UnsupportedIntersectionException();
+        }
+    }
 }

src/com/sk89q/worldguard/protection/RegionManager.java

@@ -22,6 +22,7 @@ package com.sk89q.worldguard.protection;
 import java.util.List;
 import java.util.Map;
 import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
 
 /**
  * An interface for getting, setting, and looking up regions. The most
@@ -92,6 +93,16 @@ public interface RegionManager {
      */
     public List<String> getApplicableRegionsIDs(Vector pt);
     
+    /**
+     * Returns true if the provided region overlaps with any other region that
+     * is not owned by the player.
+     * 
+     * @param region
+     * @param player
+     * @return
+     */
+    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player);
+    
     /**
      * Get the number of regions.
      * 

src/com/sk89q/worldguard/protection/UnsupportedIntersectionException.java

@@ -0,0 +1,24 @@
+// $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.protection;
+
+public class UnsupportedIntersectionException extends Exception {
+    private static final long serialVersionUID = 6423189392345575148L;
+}

worldguard.updatr

@@ -0,0 +1,5 @@
+name = WorldGuard
+version = %version%
+url = updatr.update.sk89q.com/worldguard.updatr
+file = cloud.github.com/downloads/sk89q/worldguard/worldguard-%version%.zip
+notes =