Updated build file to copy sample worldguard.properties.

CHANGELOG.txt

@@ -1,3 +1,67 @@
+1.8:
+- Updated for Minecraft beta.
+- Blacklist hooks have CHANGED. The new hooks are work better. on-create has
+    been replaced with on-place (for block placement) and on-use
+    (for item usage, light buckets and lighters). The old on-use is now
+    on-right-click although it currently does nothing.
+- Added coordinates to blacklist file logger.
+- Added suffocation damage prevention.
+
+1.7.1:
+- Updated for v0.2.8.
+
+1.7
+- Updated for v0.2.6_02 and hMod b129.
+- Added option to prevent water from damaging particular blocks
+    (Redstone wire, Minecart tracks, etc.). See disable-water-damage-blocks.
+- /reload WorldGuard should now reload WorldGuard's configuration.
+- Added wg-invincible and wg-amphibious groups that let you give certain
+    players invincibility or underwater breathing.
+- Added the ability to disable fall, water, lava, and/or fire damage.
+- Water/lava bucket blocking should now be more reliable.
+- Added /stack (alias /;) commands to stack items in your inventory into
+    piles up to 64 items in size. Even unstackable items like signs can be
+    stacked.
+- /god mode should now let you gain health.
+- /god mode should now work more reliably.
+- Caught an error message for when the configuration file does not exist.
+
+1.6
+- Added spawn protection that prevents damage when a player spawns.
+- Added login protection that prevents damage when a player joins.
+- Added /god. /god can be used on others, provided that the /godother
+    permission is set for the command's user.
+
+1.5.1
+- Removed the 'java.lang.NoSuchMethodError: Item.setDamage(I)V' error
+    generated.
+
+1.5
+- Removed the block lag fix.
+- WorldGuard now conditionally loads features so you can use any up-to-date
+    build of hMod and the unsupported features won't break the entire
+    plugin. When WG loads, check the server console for a report of
+    features that are not supported by your version of hMod.
+- Changed some configuration defaults:
+    disable-lava-fire=true
+    simulate-sponge=true
+    item-durability=false
+
+1.4.1
+- Fixed issue with the block lag fix dropping item stacks of 0 quantity.
+
+1.4
+- New on-acquire hook. This does both a total inventory check on inventory
+    change and item pick up denial. The item pick up denial is largely
+    thanks to Dinnerbone for fulfilling my request to add a particular hook.
+- Item durability can now be toggled with item-durability. Thanks to
+    Dinnerbone for figuring this out while filfilling my request. The
+    default setting is to fix item durability.
+- New no-physics-gravel and no-physics-sand options allow you to
+    prevent gravel and sand from falling.
+- New allow-portal-anywhere option allows you to create portal blocks
+    anywhere.
+    
 1.3
 - UPGRADE WARNING: If you are using database logging, you must add a
     NULL 'comment' VARCHAR field to the table. The line of SQL that you

README.txt

@@ -13,17 +13,20 @@ use or not:
 - Block TNT explosions.
 - Block lighters from setting fires.
 - Block all fires.
+- Disable fall damage, lava damage, fire damage, and/or water damage.
 - Allow fire but prevent it from burning certain blocks.
 - Prevent lava from starting fires.
 - Restrict lava spreading to only some block types.
 - Simulate classic-esque water by letting water infinitely expand in
     area (only if there is a block underneath).
+- Prevent water from destroying blocks like Redstone wire and flowers.
 - Simulate the function of the sponge from Minecraft Classic.
 - Notify admins, block, log, kick or ban for the use of certain block types
     or items.
 - Temporarily stop fire globally with some commands.
-- Fix the block lag.
 - Destroy tools on drop to alleviate the durability cheat.
+- Prevent gravel and sand from falling.
+- Allow portal blocks to be placed anywhere.
 
 hMod is required as WorldGuard is a plugin for hMod.
 
@@ -34,6 +37,18 @@ A "worldguard.properties" will be created the first the time that you load
 WorldGuard on your server. You can either restart your server or use
 /reloadplugin WorldGuard to reload the configuraton file after editing it.
 
+NOTE: Some features may require a custom version of hMod. When the server
+is loaded with the plugin, WorldGuard will tell you the features
+unsupported by your version of hMod.
+
+- summary-on-start (def. true)
+    Print a summary of WorldGuard's protection settings at-a-glance when
+    the plugin is loaded.
+
+- item-durability (def. false)
+    **Requires special version of hMod
+    Enables item durability.
+
 - classic-water (def. false)
     Toggle use of classic water. Be foreward that your world may be
     flooded if you are not careful. If you have WorldEdit, you can use
@@ -42,7 +57,7 @@ WorldGuard on your server. You can either restart your server or use
     ground, but if there are air blocks underneath, the water will not
     spread (preventing waterfalls from becoming tsunamis).
 
-- simulate-sponge (def. false)
+- simulate-sponge (def. true)
     Toggle simulation of the sponge from Classic. It blocks water from
     flowing near the sponge.
 
@@ -51,6 +66,18 @@ WorldGuard on your server. You can either restart your server or use
     creating a 5x5x5 cuboid free of water. Increasing the number will
     increase server load exponentially, although 3-5 has fairly low impact.
 
+- no-physics-gravel (def. false)
+    **Requires special version of hMod
+    Prevents gravel from falling due to gravity.
+
+- no-physics-sand (def. false)
+    **Requires special version of hMod
+    Prevents sand from falling due to gravity.
+
+- allow-portal-anywhere (def. false)
+    **Requires special version of hMod
+    Allows you to place portal blocks anywhere.
+
 - enforce-single-session (def. true)
     Enforce single sessions. If the player is already found to be on
     the server when s/he logs in, the other player will be kicked with
@@ -67,9 +94,10 @@ WorldGuard on your server. You can either restart your server or use
     command; it is only used for permissions.
 
 - block-creepers (def. false)
-    Block creeper explosions. They will not explode client-side.
+    Block creeper explosions from destroying terrain (and possibly from
+    causing damage).
 
-- disable-lava-fire (def. false)
+- disable-lava-fire (def. true)
     Prevent lava from starting fires.
 
 - allowed-lava-spread-blocks (no default)
@@ -84,6 +112,10 @@ WorldGuard on your server. You can either restart your server or use
     to disable this feature. Enabling disable-all-fire-spread will
     override this function.
 
+- disable-water-damage-blocks (no default)
+    List of blocks that should not be destroyed by water (Redstone wire,
+    minecart tracks, flowers, etc.).
+
 - item-drop-blacklist (no default)
     List of block names/IDs to destroy on drop. This can alleviate the
     durability cheat that allows you to drop your tools to fix their
@@ -91,14 +123,23 @@ WorldGuard on your server. You can either restart your server or use
     this is an easier way to do it (this way also prints a more
     friendly message than if you used the 'tell' action of the blacklist).
 
-- block-lag-fix (def. false)
-    Attempts to fix block lag. For maximum compatibility with other plugins,
-    you must list WorldGuard as the first plugin in server.properties and
-    you cannot reload or enable WorldGuard while the server is up.
-    This is for bad plugins that unnecessarily use the "critical" priority
-    for its hooks like the LWC. Most plugins, the popular protection ones
-    included, don't do that though so this won't apply for most people.
+- login-protection (def. 3)
+    Number of seconds to keep a player invincible when the player joins.
 
+- spawn-protection (def. 0)
+    Number of seconds to keep a player invincible when the player spawns.
+    This does not apply to players joining the server.
+
+- kick-on-death (def. false)
+    Kick players when they die (and respawn). This is to work around the
+    issues of invisible players when players die.
+    
+- disable-fall-damage (def. false)
+- disable-lava-damage (def. false)
+- disable-fire-damage (def. false)
+- disable-water-damage (def. false)
+    Disable various types of damage.
+    
 - log-console (def. true)
     For blacklist log actions, print to console.
 
@@ -162,6 +203,12 @@ Commands
     WorldGuard. Note that disabling fire does not disable fire damage
     but fire at least won't spread.
 
+- /god
+    Toggles your invincibility. Players must have permission to use "/god"
+    to be able to use this command. You can also use this command to
+    toggle the invincibility of others although you must have the
+    "/godother" permission.
+
 Server Commands
 ---------------
 
@@ -179,3 +226,26 @@ certain rules apply to only some groups.
 
 Edit the included worldguard-blacklist.txt file and follow the
 instructions inside. The file comes with the download for WorldGuard.
+
+Other Features
+--------------
+
+To give someone invincibility every time s/he joins the server, create
+a wg-invincible group and add the group to the user or have the user's
+group inherit this group.
+
+To give someone the ability to breathe under water, create
+a wg-amphibious group and add the group to the user or have the user's
+group inherit this group.
+
+Thanks
+------
+
+While I would like to thank everyone for their support, I would like to
+say thanks to the following individuals for their direct
+contributions to WorldGuard:
+
+- Sturmeh, for contributing the original durability workaround
+- Meaglin, for changing the on flow hook at my request
+- Dinnerbone, for implementing the on item pick up hook at my request,
+    and also for figuring out the durability bug in the process

build.xml

@@ -0,0 +1,86 @@
+<project name="WorldGuard" default="dist" basedir=".">
+  <description>WorldGuard fixes bugs with Minecraft SMP and provides for
+    protection.</description>
+  
+  <property name="src.dir" location="src"/>
+  <property name="build.dir" location="build"/>
+  <property name="dist.dir" location="dist"/>
+  <property name="release.dir" location="release"/>
+  <property name="lib.dir" location="lib"/>
+
+  <target name="init">
+    <mkdir dir="${build.dir}"/>
+  </target>
+
+  <!-- Compile the source files -->
+  <target name="compile" depends="init">
+    <javac srcdir="${src.dir}" deprecation="true" includeantruntime="true" destdir="${build.dir}" debug="true">
+      <classpath>
+        <fileset dir="${lib.dir}">
+          <include name="*.jar"/>
+        </fileset>
+      </classpath>
+    </javac>
+  </target>
+
+  <!-- Build the .jar -->
+  <target name="jar" depends="compile">
+    <mkdir dir="${dist.dir}"/>
+    <manifest file="manifest.mf" mode="replace">
+      <attribute name="Implementation-Title" value="WorldGuard"/>
+      <attribute name="Implementation-Version" value="${version}"/>
+      <attribute name="WorldGuard-Version" value="${version}"/>
+      <attribute name="Class-Path" value="WorldGuard.jar"/>
+    </manifest>
+    <jar jarfile="${dist.dir}/WorldGuard.jar" basedir="${build.dir}" manifest="manifest.mf"/>
+  </target>
+
+  <!-- Create the .jar -->
+  <target name="dist">
+    <property name="version" value="nightly"/>
+    <antcall target="jar"/>
+  </target>
+
+  <!-- Build a release -->
+  <target name="release">
+    <input message="Enter version:" addproperty="version"/>
+    <antcall target="jar"/>
+    <delete dir="${release.dir}"/>
+    <mkdir dir="${release.dir}"/>
+    <copy todir="${release.dir}">
+      <fileset dir="."/>
+      <globmapper from="*.txt" to="*.txt"/>
+    </copy>
+    <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"/>
+    <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"/>
+  </target>
+
+  <!-- Clean the output -->
+  <target name="clean">
+    <delete dir="${build.dir}"/>
+    <delete dir="${dist.dir}"/>
+    <delete dir="${release.dir}"/>
+  </target>
+  
+  <!--<target name="-get-version-git" if="git-revision">
+    <sequential>
+      <exec executable="git" failifexecutionfails="false" outputproperty="git-revision">
+        <arg value="rev-parse"/>
+        <arg value="HEAD"/>
+      </exec>
+      <exec executable="git" outputproperty="git-revision-dirty">
+        <arg value="diff"/>
+        <arg value="- -shortstat"/>
+      </exec>
+      <condition else="dev-${git-revision}-modified" property="version" value="dev-${git-revision}">
+        <equals arg1="" arg2="${git-revision-dirty}"/>
+      </condition>
+    </sequential>
+  </target>-->
+</project>

manifest.mf

@@ -1,2 +0,0 @@
-Manifest-Version: 1.0
-WorldGuard-Version: 1.3

src/Blacklist.java

@@ -45,6 +45,11 @@ public class Blacklist {
      */
     private BlacklistLogger blacklistLogger = new BlacklistLogger();
 
+    /**
+     * Blacklist contains on-acquire events.
+     */
+    private boolean hasOnAcquire;
+
     /**
      * Returns whether the list is empty.
      * 
@@ -136,20 +141,20 @@ public class Blacklist {
     }
 
     /**
-     * Called on right click. Returns true to let the action pass through.
+     * Called on place. Returns true to let the action pass through.
      *
      * @param item
      * @param player
      * @return
      */
-    public boolean onCreate(int item, Player player) {
+    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.onCreate(item, player)) {
+            if (!entry.onPlace(item, player)) {
                 ret = false;
             }
         }
@@ -159,18 +164,39 @@ public class Blacklist {
     /**
      * Called on right click upon. Returns true to let the action pass through.
      *
-     * @param item
+     * @param block
      * @param player
      * @return
      */
-    public boolean onUse(Block block, Player player) {
+    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.onUse(block, player)) {
+            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;
             }
         }
@@ -219,6 +245,48 @@ public class Blacklist {
         return ret;
     }
 
+    /**
+     * Called on acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onAcquire(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onAcquire(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on acquire. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onSilentAcquire(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onSilentAcquire(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
     /**
      * Load the blacklist.
      *
@@ -235,6 +303,8 @@ public class Blacklist {
             input = new FileReader(file);
             BufferedReader buff = new BufferedReader(input);
 
+            hasOnAcquire = false;
+
             String line;
             List<BlacklistEntry> currentEntries = null;
             while ((line = buff.readLine()) != null) {
@@ -296,14 +366,17 @@ public class Blacklist {
                         } else if (parts[0].equalsIgnoreCase("on-left")
                                 || parts[0].equalsIgnoreCase("on-destroy-with")) {
                             entry.setDestroyWithActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-right")
-                                || parts[0].equalsIgnoreCase("on-create")) {
-                            entry.setCreateActions(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("on-right-on")
-                                || parts[0].equalsIgnoreCase("on-use")) {
+                        } else if (parts[0].equalsIgnoreCase("on-place")) {
+                            entry.setPlaceActions(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());
                         } else if (parts[0].equalsIgnoreCase("comment")) {
@@ -333,4 +406,13 @@ public class Blacklist {
             }
         }
     }
+
+    /**
+     * Blacklist contains on-acquire events.
+     * 
+     * @return
+     */
+    public boolean hasOnAcquire() {
+        return hasOnAcquire;
+    }
 }

src/BlacklistEntry.java

@@ -55,23 +55,45 @@ public class BlacklistEntry {
      */
     private String[] destroyWithActions;
     /**
-     * List of actions to perform on right click.
+     * List of actions to perform on block placement.
      */
-    private String[] createActions;
+    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[] useActions;
+    private String[] rightClickActions;
     /**
      * List of actions to perform on drop.
      */
     private String[] dropActions;
     /**
-     * Comment for the log.
+     * 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.
      * 
@@ -142,17 +164,17 @@ public class BlacklistEntry {
     }
 
     /**
-     * @return the rightClickActions
+     * @return
      */
-    public String[] getCreateActions() {
-        return createActions;
+    public String[] getPlaceActions() {
+        return placeActions;
     }
 
     /**
      * @param actions
      */
-    public void setCreateActions(String[] actions) {
-        this.createActions = actions;
+    public void setPlaceActions(String[] actions) {
+        this.placeActions = actions;
     }
 
     /**
@@ -169,6 +191,20 @@ public class BlacklistEntry {
         this.useActions = actions;
     }
 
+    /**
+     * @return
+     */
+    public String[] getRightClickActions() {
+        return rightClickActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setRightClickActions(String[] actions) {
+        this.rightClickActions = actions;
+    }
+
     /**
      * @return
      */
@@ -183,6 +219,20 @@ public class BlacklistEntry {
         this.dropActions = actions;
     }
 
+    /**
+     * @return
+     */
+    public String[] getAcquireActions() {
+        return acquireActions;
+    }
+
+    /**
+     * @param actions
+     */
+    public void setAcquireActions(String[] actions) {
+        this.acquireActions = actions;
+    }
+
     /**
      * @return the message
      */
@@ -292,7 +342,7 @@ public class BlacklistEntry {
             }
         };
 
-        return process(block.getType(), player, destroyActions, handler, false);
+        return process(block.getType(), player, destroyActions, handler, false, false);
     }
 
     /**
@@ -329,7 +379,7 @@ public class BlacklistEntry {
             }
         };
 
-        return process(block.getType(), player, breakActions, handler, true);
+        return process(block.getType(), player, breakActions, handler, true, false);
     }
 
     /**
@@ -365,18 +415,18 @@ public class BlacklistEntry {
             }
         };
 
-        return process(item, player, destroyWithActions, handler, false);
+        return process(item, player, destroyWithActions, handler, false, false);
     }
 
     /**
-     * Called on right click. Returns true to let the action pass through.
+     * Called on block placement. Returns true to let the action pass through.
      *
      * @param item
      * @param player
      * @return
      */
-    public boolean onCreate(final int item, final Player player) {
-        if (createActions == null) {
+    public boolean onPlace(final int item, final Player player) {
+        if (placeActions == null) {
             return true;
         }
 
@@ -384,7 +434,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logCreateAttempt(player, item, comment);
+                blacklist.getLogger().logPlaceAttempt(player, item, comment);
             }
             public void kick(String itemName) {
                 player.kick("You can't place " + itemName);
@@ -401,17 +451,17 @@ public class BlacklistEntry {
             }
         };
 
-        return process(item, player, createActions, handler, true);
+        return process(item, player, placeActions, handler, true, false);
     }
 
     /**
-     * Called on right click upon. Returns true to let the action pass through.
+     * Called on use. Returns true to let the action pass through.
      *
      * @param item
      * @param player
      * @return
      */
-    public boolean onUse(final Block block, final Player player) {
+    public boolean onUse(final int item, final Player player) {
         if (useActions == null) {
             return true;
         }
@@ -420,7 +470,7 @@ public class BlacklistEntry {
 
         ActionHandler handler = new ActionHandler() {
             public void log(String itemName) {
-                blacklist.getLogger().logUseAttempt(player, block, comment);
+                blacklist.getLogger().logUseAttempt(player, item, comment);
             }
             public void kick(String itemName) {
                 player.kick("You can't use " + itemName);
@@ -437,7 +487,43 @@ public class BlacklistEntry {
             }
         };
 
-        return process(block.getType(), player, useActions, handler, false);
+        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);
     }
 
     /**
@@ -452,20 +538,7 @@ public class BlacklistEntry {
             return true;
         }
 
-        ActionHandler handler = new ActionHandler() {
-            public void log(String itemName) {
-            }
-            public void kick(String itemName) {
-            }
-            public void ban(String itemName) {
-            }
-            public void notifyAdmins(String itemName) {
-            }
-            public void tell(String itemName) {
-            }
-        };
-
-        return process(block.getType(), player, useActions, handler, false);
+        return process(block.getType(), player, useActions, silentHandler, false, true);
     }
 
     /**
@@ -501,7 +574,58 @@ public class BlacklistEntry {
             }
         };
 
-        return process(item, player, dropActions, handler, true);
+        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);
     }
 
     /**
@@ -512,10 +636,11 @@ public class BlacklistEntry {
      * @param actions
      * @param handler
      * @param allowRepeat
+     * @param silent
      * @return
      */
     private boolean process(int id, Player player, String[] actions,
-            ActionHandler handler, boolean allowRepeat) {
+            ActionHandler handler, boolean allowRepeat, boolean silent) {
 
         if (shouldIgnore(player)) {
             return true;
@@ -543,6 +668,9 @@ public class BlacklistEntry {
         for (String action : actions) {
             // Deny
             if (action.equalsIgnoreCase("deny")) {
+                if (silent) {
+                    return false;
+                }
                 ret = false;
 
             // Kick

src/BlacklistLogger.java

@@ -88,9 +88,21 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block, String comment) {
+    public void logUseAttempt(Player player, int item, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logUseAttempt(player, block, comment);
+            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);
         }
     }
 
@@ -107,19 +119,19 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
     }
 
     /**
-     * Log a right click attempt.
+     * Log a place attempt.
      *
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item, String comment) {
+    public void logPlaceAttempt(Player player, int item, String comment) {
         for (BlacklistLoggerHandler handler : handlers) {
-            handler.logCreateAttempt(player, item, comment);
+            handler.logPlaceAttempt(player, item, comment);
         }
     }
 
     /**
-     * Log a right click attempt.
+     * Log a drop attempt.
      *
      * @param player
      * @param item
@@ -130,6 +142,18 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
         }
     }
 
+    /**
+     * 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.
      */

src/BlacklistLoggerHandler.java

@@ -38,12 +38,12 @@ public interface BlacklistLoggerHandler {
      */
     public void logBreakAttempt(Player player, Block block, String comment);
     /**
-     * Log a right click on attempt.
+     * Log a use attempt.
      * 
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block, String comment);
+    public void logUseAttempt(Player player, int item, String comment);
     /**
      * Right a left click attempt.
      * 
@@ -52,12 +52,19 @@ public interface BlacklistLoggerHandler {
      */
     public void logDestroyWithAttempt(Player player, int item, String comment);
     /**
-     * Log a right click attempt.
+     * Log a place attempt.
      * 
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item, String comment);
+    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.
      *
@@ -65,6 +72,13 @@ public interface BlacklistLoggerHandler {
      * @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.
      */

src/ConsoleLoggerHandler.java

@@ -60,9 +60,9 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block, String comment) {
+    public void logRightClickAttempt(Player player, Block block, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to use " + getFriendlyItemName(block.getType())
+                + " tried to right click " + getFriendlyItemName(block.getType())
                 + (comment != null ? " (" + comment + ")" : ""));
     }
     
@@ -84,9 +84,21 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item, String comment) {
+    public void logPlaceAttempt(Player player, int item, String comment) {
         logger.log(Level.INFO, "WorldGuard: " + player.getName()
-                + " tried to create " + getFriendlyItemName(item)
+                + " 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 + ")" : ""));
     }
 
@@ -102,6 +114,18 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
                 + (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.
      * 

src/DatabaseLoggerHandler.java

@@ -146,8 +146,8 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block, String comment) {
-        logEvent("USE", player.getName(),
+    public void logRightClickAttempt(Player player, Block block, String comment) {
+        logEvent("RIGHT_CLICK", player.getName(),
                 block.getX(), block.getY(), block.getZ(), block.getType(),
                 comment);
     }
@@ -165,13 +165,25 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
     }
 
     /**
-     * Log a right click attempt.
+     * Log a place attempt.
      *
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item, String comment) {
-        logEvent("CREATE", player.getName(),
+    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);
     }
@@ -188,6 +200,18 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
                 (int)Math.floor(player.getZ()), item, comment);
     }
 
+    /**
+     * Log an aquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        logEvent("AQUIRE", player.getName(),
+                (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
+                (int)Math.floor(player.getZ()), item, comment);
+    }
+
     /**
      * Close the connection.
      */

src/FileLoggerHandler.java

@@ -206,6 +206,16 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
         }
     }
 
+    /**
+     * Gets the coordinates of a block in text form for the log.
+     * 
+     * @param block
+     * @return
+     */
+    private String getCoordinates(Block block) {
+        return "@" + block.getX() + "," + block.getY() + "," + block.getZ();
+    }
+
     /**
      * Log a block destroy attempt.
      *
@@ -213,7 +223,8 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param block
      */
     public void logDestroyAttempt(Player player, Block block, String comment) {
-        log(player, "Tried to destroy " + getFriendlyItemName(block.getType()),
+        log(player, "Tried to destroy " + getFriendlyItemName(block.getType())
+                + " " + getCoordinates(block),
                 comment);
     }
 
@@ -224,7 +235,8 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param block
      */
     public void logBreakAttempt(Player player, Block block, String comment) {
-        log(player, "Tried to break " + getFriendlyItemName(block.getType()),
+        log(player, "Tried to break " + getFriendlyItemName(block.getType())
+                + " " + getCoordinates(block),
                 comment);
     }
 
@@ -234,8 +246,9 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param block
      */
-    public void logUseAttempt(Player player, Block block, String comment) {
-        log(player, "Tried to use " + getFriendlyItemName(block.getType()),
+    public void logRightClickAttempt(Player player, Block block, String comment) {
+        log(player, "Tried to right click " + getFriendlyItemName(block.getType())
+                + " " + getCoordinates(block),
                 comment);
     }
 
@@ -255,8 +268,18 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * @param player
      * @param item
      */
-    public void logCreateAttempt(Player player, int item, String comment) {
-        log(player, "Tried to create " + getFriendlyItemName(item), comment);
+    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);
     }
 
     /**
@@ -269,6 +292,16 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
         log(player, "Tried to drop " + getFriendlyItemName(item), comment);
     }
 
+    /**
+     * Log an acquire attempt.
+     *
+     * @param player
+     * @param item
+     */
+    public void logAcquireAttempt(Player player, int item, String comment) {
+        log(player, "Tried to acquire " + getFriendlyItemName(item), comment);
+    }
+
     /**
      * Get an item's friendly name with its ID.
      *

src/ItemArrayUtil.java

@@ -0,0 +1,43 @@
+// $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);
+            }
+        }
+    }
+}

src/LoggerToChatHandler.java

@@ -17,31 +17,48 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-package com.sk89q.worldguard;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.logging.Formatter;
-import java.util.logging.LogRecord;
+import java.util.logging.Logger;
 import java.util.logging.Level;
+import java.util.logging.Handler;
+import java.util.logging.LogRecord;
 
 /**
- * Used for formatting.
+ * Sends all logger messages to a player.
  *
  * @author sk89q
  */
-public class SimpleLogFormat extends Formatter {
-    private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
-    public String format(LogRecord record) {
-        StringBuilder text = new StringBuilder();
-        Level level = record.getLevel();
+public class LoggerToChatHandler extends Handler {
+    /**
+     * Player.
+     */
+    private Player player;
 
-        text.append("[");
-        text.append(dateFormat.format(new Date(record.getMillis())));
-        text.append("] ");
-        text.append(record.getMessage());
-        text.append("\r\n");
-        
-        return text.toString();
+    /**
+     * Construct the object.
+     * 
+     * @param player
+     */
+    public LoggerToChatHandler(Player player) {
+        this.player = player;
+    }
+
+    /**
+     * Close the handler.
+     */
+    public void close() {
+    }
+
+    /**
+     * Flush the output.
+     */
+    public void flush() {
+    }
+
+    /**
+     * Publish a log record.
+     */
+    public void publish(LogRecord record) {
+        player.sendMessage(Colors.LightGray + record.getLevel().getName() + ": "
+                + Colors.White + record.getMessage());
     }
 }

src/WorldGuard.java

@@ -21,8 +21,11 @@ import java.util.logging.Logger;
 import java.util.logging.Level;
 import java.util.jar.Manifest;
 import java.util.jar.Attributes;
+import java.util.List;
+import java.util.ArrayList;
 import java.net.URL;
 import java.io.*;
+import java.lang.reflect.*;
 
 /**
  * Entry point for the plugin for hey0's mod.
@@ -53,34 +56,56 @@ public class WorldGuard extends Plugin {
     public void initialize() {
         PluginLoader loader = etc.getLoader();
 
-        loader.addListener(PluginLoader.Hook.COMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.SERVERCOMMAND, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.EXPLODE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.IGNITE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.FLOW, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGINCHECK, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGIN, listener, this,
-                PluginListener.Priority.MEDIUM);
-        loader.addListener(PluginLoader.Hook.BLOCK_CREATED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_DESTROYED, listener, this,
-                PluginListener.Priority.CRITICAL);
-        loader.addListener(PluginLoader.Hook.BLOCK_BROKEN, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.DISCONNECT, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.ITEM_DROP , listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_CHANGE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.COMPLEX_BLOCK_SEND, listener, this,
-                PluginListener.Priority.HIGH);
+        List<String> missingFeatures = new ArrayList<String>();
+
+        registerHook("COMMAND", PluginListener.Priority.MEDIUM);
+        registerHook("SERVERCOMMAND", PluginListener.Priority.MEDIUM);
+        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("INVENTORY_CHANGE", 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);
+
+        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;
+        }
     }
 
     /**
@@ -128,4 +153,38 @@ public class WorldGuard extends Plugin {
             return "(unknown)";
         }
     }
+
+    /**
+     * Joins a string from an array of strings.
+     *
+     * @param str
+     * @param delimiter
+     * @return
+     */
+    private static String concatMissingFeatures(List<String> str) {
+        if (str.isEmpty()) {
+            return "";
+        }
+
+        int size = str.size();
+        StringBuilder buffer = new StringBuilder();
+        buffer.append("(1) ");
+        buffer.append(str.get(0));
+        for (int i = 1; i < size; i++) {
+            if (i == size - 1) {
+                buffer.append(" or ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            } else {
+                buffer.append(", ");
+                buffer.append("(");
+                buffer.append(i + 1);
+                buffer.append(") ");
+                buffer.append(str.get(i));
+            }
+        }
+        return buffer.toString();
+    }
 }

src/com/sk89q/worldedit/blocks/BlockType.java

@@ -0,0 +1,271 @@
+// $Id$
+/*
+ * WorldEdit
+ * 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.worldedit.blocks;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.EnumSet;
+
+/**
+ * Block types.
+ *
+ * @author sk89q
+ */
+public enum BlockType {
+    AIR(0, "Air", "air"),
+    STONE(1, "Stone", new String[]{"stone", "rock"}),
+    GRASS(2, "Grass", "grass"),
+    DIRT(3, "Dirt", "dirt"),
+    COBBLESTONE(4, "Cobblestone", "cobblestone"),
+    WOOD(5, "Wood", "wood"),
+    SAPLING(6, "Sapling", "sapling"),
+    BEDROCK(7, "Bedrock", "bedrock"),
+    WATER(8, "Water", "watermoving"),
+    STATIONARY_WATER(9, "Water (stationary)", "water"),
+    LAVA(10, "Lava", "lavamoving"),
+    STATIONARY_LAVA(11, "Lava (stationary)", "lava"),
+    SAND(12,    "Sand", "sand"),
+    GRAVEL(13, "Gravel", "gravel"),
+    GOLD_ORE(14, "Gold ore", "goldore"),
+    IRON_ORE(15, "Iron ore", "ironore"),
+    COAL_ORE(16, "Coal ore", "coalore"),
+    LOG(17, "Log", "log"),
+    LEAVES(18, "Leaves", "leaves"),
+    SPONGE(19, "Sponge", "sponge"),
+    GLASS(20, "Glass", "glass"),
+    CLOTH(35, "Cloth", "cloth"),
+    YELLOW_FLOWER(37, "Yellow flower", "yellowflower"),
+    RED_FLOWER(38, "Red rose", new String[]{"redflower", "redrose"}),
+    BROWN_MUSHROOM(39, "Brown mushroom", "brownmushroom"),
+    RED_MUSHROOM(40, "Red mushroom", "redmushroom"),
+    GOLD_BLOCK(41, "Gold block", new String[]{"gold", "goldblock"}),
+    IRON_BLOCK(42, "Iron block", new String[]{"iron", "ironblock"}),
+    DOUBLE_STEP(43, "Double step", "doublestep"),
+    STEP(44, "Step", "step"),
+    BRICK(45, "Brick", "brick"),
+    TNT(46, "TNT", "tnt"),
+    BOOKCASE(47, "Bookcase", new String[]{"bookshelf", "bookshelf"}),
+    MOSSY_COBBLESTONE(48, "Cobblestone (mossy)", "mossycobblestone"),
+    OBSIDIAN(49, "Obsidian", "obsidian"),
+    TORCH(50, "Torch", "torch"),
+    FIRE(51, "Fire", "fire"),
+    MOB_SPAWNER(52, "Mob spawner", "mobspawner"),
+    WOODEN_STAIRS(53, "Wooden stairs", "woodstairs"),
+    CHEST(54, "Chest", "chest"),
+    REDSTONE_WIRE(55, "Redstone wire", "redstone"),
+    DIAMOND_ORE(56, "Diamond ore", "diamondore"),
+    DIAMOND_BLOCK(57, "Diamond block", new String[]{"diamond", "diamondblock"}),
+    WORKBENCH(58, "Workbench", "workbench"),
+    CROPS(59, "Crops", "crops"),
+    SOIL(60, "Soil", "soil"),
+    FURNACE(61, "Furnace", "furnace"),
+    BURNING_FURNACE(62, "Furnace (burning)", "burningfurnace"),
+    SIGN_POST(63, "Sign post", new String[]{"sign", "signpost"}),
+    WOODEN_DOOR(64, "Wooden door", "wooddoor"),
+    LADDER(65, "Ladder", "ladder"),
+    MINECART_TRACKS(66, "Minecart tracks", new String[]{"track", "tracks"}),
+    COBBLESTONE_STAIRS(67, "Cobblestone stairs", "cobblestonestairs"),
+    WALL_SIGN(68, "Wall sign", "wallsign"),
+    LEVER(69, "Lever", "level"),
+    STONE_PRESSURE_PLATE(70, "Stone pressure plate", "stonepressureplate"),
+    IRON_DOOR(71, "Iron Door", "irondoor"),
+    WOODEN_PRESSURE_PLATE(72, "Wooden pressure plate", "woodpressureplate"),
+    REDSTONE_ORE(73, "Redstone ore", "redstoneore"),
+    GLOWING_REDSTONE_ORE(74, "Glowing redstone ore", "glowingredstoneore"),
+    REDSTONE_TORCH_OFF(75, "Redstone torch (off)",
+            new String[]{"redstonetorch"," redstonetorchon"}),
+    REDSTONE_TORCH_ON(76, "Redstone torch (on)", "redstonetorchon"),
+    STONE_BUTTON(77, "Stone Button", "stonebutton"),
+    SNOW(78, "Snow", "snow"),
+    ICE(79, "Ice", "ice"),
+    SNOW_BLOCK(80, "Snow block", "snowblock"),
+    CACTUS(81, "Cactus", "cactus"),
+    CLAY(82, "Clay", "clay"),
+    REED(83, "Reed", "reed"),
+    JUKEBOX(84, "Jukebox", "jukebox"),
+    FENCE(85, "Fence", "fence"),
+    PUMPKIN(86, "Pumpkin", "pumpkin"),
+    RED_BLOCK(87, "Cobblestone (red mossy)", new String[]{"redmossycobblestone", "redcobblestone"}),
+    HELL_DIRT(88, "Mud", "mud"),
+    HELL_GOLD(89, "Brittle gold", "brittlegold"),
+    PORTAL(90, "Portal", "portal"),
+    LIGHTED_PUMPKIN(91, "Pumpkin (on)", new String[]{"pumpkinlighted", "pumpkinon", "litpumpkin"});
+
+    /**
+     * Stores a map of the IDs for fast access.
+     */
+    private static final Map<Integer,BlockType> ids = new HashMap<Integer,BlockType>();
+    /**
+     * Stores a map of the names for fast access.
+     */
+    private static final Map<String,BlockType> lookup = new HashMap<String,BlockType>();
+
+    private final int id;
+    private final String name;
+    private final String[] lookupKeys;
+
+    static {
+        for(BlockType type : EnumSet.allOf(BlockType.class)) {
+            ids.put(type.id, type);
+            for (String key : type.lookupKeys) {
+                lookup.put(key, type);
+            }
+        }
+    }
+
+
+    /**
+     * Construct the type.
+     *
+     * @param id
+     * @param name
+     */
+    BlockType(int id, String name, String lookupKey) {
+        this.id = id;
+        this.name = name;
+        this.lookupKeys = new String[]{lookupKey};
+    }
+
+    /**
+     * Construct the type.
+     *
+     * @param id
+     * @param name
+     */
+    BlockType(int id, String name, String[] lookupKeys) {
+        this.id = id;
+        this.name = name;
+        this.lookupKeys = lookupKeys;
+    }
+
+    /**
+     * Return type from ID. May return null.
+     *
+     * @param id
+     * @return
+     */
+    public static BlockType fromID(int id) {
+        return ids.get(id);
+    }
+
+    /**
+     * Return type from name. May return null.
+     *
+     * @param name
+     * @return
+     */
+    public static BlockType lookup(String name) {
+        return lookup.get(name.toLowerCase());
+    }
+
+    /**
+     * Get block numeric ID.
+     *
+     * @return
+     */
+    public int getID() {
+        return id;
+    }
+
+    /**
+     * Get user-friendly block name.
+     *
+     * @return
+     */
+    public String getName() {
+        return name;
+    }
+
+    /**
+     * Checks to see whether a block should be placed last.
+     *
+     * @param id
+     * @return
+     */
+    public boolean shouldPlaceLast() {
+        return shouldPlaceLast(id);
+    }
+
+    /**
+     * Checks to see whether a block should be placed last.
+     * 
+     * @param id
+     * @return
+     */
+    public static boolean shouldPlaceLast(int id) {
+        return id == 6 // Saplings
+                || id == 37 // Yellow flower
+                || id == 38 // Red flower
+                || id == 39 // Brown mushroom
+                || id == 40 // Red mush room
+                || id == 50 // Torch
+                || id == 51 // Fire
+                || id == 55 // Redstone wire
+                || id == 59 // Crops
+                || id == 63 // Sign post
+                || id == 64 // Wooden door
+                || id == 65 // Ladder
+                || id == 66 // Minecart tracks
+                || id == 68 // Wall sign
+                || id == 69 // Lever
+                || id == 70 // Stone pressure plate
+                || id == 71 // Iron door
+                || id == 72 // Wooden pressure plate
+                || id == 75 // Redstone torch (off)
+                || id == 76 // Redstone torch (on)
+                || id == 77 // Stone button
+                || id == 78 // Snow
+                || id == 81 // Cactus
+                || id == 83 // Reed
+                || id == 90; // Portal
+    }
+
+    /**
+     * Checks whether a block can be passed through.
+     *
+     * @param id
+     * @return
+     */
+    public static boolean canPassThrough(int id) {
+        return id == 0 // Air
+                || id == 6 // Saplings
+                || id == 37 // Yellow flower
+                || id == 38 // Red flower
+                || id == 39 // Brown mushroom
+                || id == 40 // Red mush room
+                || id == 50 // Torch
+                || id == 51 // Fire
+                || id == 55 // Redstone wire
+                || id == 59 // Crops
+                || id == 63 // Sign post
+                || id == 65 // Ladder
+                || id == 66 // Minecart tracks
+                || id == 68 // Wall sign
+                || id == 69 // Lever
+                || id == 70 // Stone pressure plate
+                || id == 72 // Wooden pressure plate
+                || id == 75 // Redstone torch (off)
+                || id == 76 // Redstone torch (on)
+                || id == 77 // Stone button
+                || id == 78 // Snow
+                || id == 83 // Reed
+                || id == 90; // Portal
+    }
+}

src/com/sk89q/worldguard/ConsoleLogFormat.java

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

worldguard-blacklist.txt

@@ -11,7 +11,7 @@
 # Example to block ore and catch some events:
 # [coalore,goldore,ironore]
 # on-destroy-with=deny,log,kick
-# on-create=deny,tell
+# on-place=deny,tell
 #
 # Options:
 # - ignore-groups (comma-delimited list of groups to not affect)
@@ -22,9 +22,11 @@
 # - on-destroy (when a block of this type is being destroyed)
 # - on-break (when a block of this type is about to be broken)
 # - on-destroy-with (the item/block held by the user while destroying)
-# - on-create (the item/block in the user's inventory is being created)
-# - on-use (the block is right clicked)
+# - on-place (a block is being placed)
+# - on-use (an item like a lighter is being used)
+# - on-right-click (the block is right clicked -- curently INEFFECTIVE)
 # - on-drop (the item is being dropped from the player's inventory)
+# - on-acquire (the item enters a player's inventory via some method)
 #
 # Actions (for events):
 # - deny (deny completely)
@@ -34,6 +36,13 @@
 # - kick (kick player)
 # - ban (ban player)
 #
+# With the on-acquire event, it will completely block item pick ups
+# (the item will still be on the ground) if you use 'deny' but the other
+# actions (notify, log, etc.) won't do anything. However, if the player
+# receives the item via a different method (i.e. from a chest), all actions
+# will work although the item is removed after a short delay rather than
+# blocked from the beginning (as it is part client-side).
+#
 # Users with the /worldguardnotify permission will be receive notifications.
 #
 # -------------
@@ -60,22 +69,22 @@
 # Some examples follow. Remember to remove # in front if you want them
 # to work for you!
 
+# Deny lava buckets
 #[lavabucket]
 #ignore-groups=admins,mods
-#on-destroy-with=deny,log,kick
-#on-create=deny,tell
+#on-use=deny,tell
 
+# Deny lighter usage
+#[259]
+#on-use=deny,tell
+
+# Deny some ore
 #[coalore,goldore,ironore]
-#ignore-groups=admins,mods,vip
+#ignore-groups=admins,mods
 #on-destroy=notify,deny,log
 
 #[cobblestone]
-#on-create=deny,tell,log
+#on-place=deny,tell,log
 
 #[lever]
-#on-break=deny
-
-#[diamondpickaxe,woodpickaxe]
-#on-drop=deny
-#comment=durability cheat
-#message=Your item was destroyed
+#on-break=deny,tell

worldguard.properties

@@ -0,0 +1,108 @@
+#
+# WorldGuard configuration
+#
+# This is a starter copy of WorldGuard's configuration so you can configure
+# WorldGuard right from the beginning. Copy it into your server folder
+# (into where server.properties resides) and edit the file as your desire.
+#
+
+# Display a summary of WorldGuard's core protection features (lava fire
+# disable and others) when Worldguard starts up.
+summary-on-start=true
+
+# Toggle the item durabiltiy fix
+item-durability=true
+
+# Simulate the sponge from Classic. It removes water and prevents water from
+# flowing into an area containing sponges. Use this to protect circuits
+# or to assist in underwater projects.
+simulate-sponge=false
+sponge-radius=3
+
+# Simulate classic water. Water will spread infinitely. Be aware that this
+# may likely flood your server.
+classic-water=false
+
+# Allow the placement of portal blocks anyway.
+allow-portal-anywhere=false
+
+# Prevent gravel from falling.
+no-physics-gravel=false
+
+# Prevent sand from falling.
+no-physics-sand=false
+
+# Kick the older player if a player attempts to join again without first
+# logging out the first instance.
+enforce-single-session=true
+
+# List of items to destroy on drop. You can also accomplish this using
+# the blacklist.
+item-drop-blacklist=
+
+# Simple prevention
+block-creepers=false
+block-lighter=false
+block-tnt=false
+
+# Login protection prevents players from getting any damage for a few
+# seconds after joining the server.
+login-protection=3
+
+# Spawn protection prevents players from getting any damage after spawning
+# (after dying).
+spawn-protection=0
+
+# This is an deprecated feature to fix a bug. This kicks a user once the
+# player dies and attemtps to respawn. The player can then still rejoin
+# and be alive.
+kick-on-death=false
+
+# Disable various ways of damage. If you want to give someone invincibility
+# or the ability to breathe under water, create the groups wg-invincible
+# and wg-amphibious respectively and apply them to users as needed.
+disable-fall-damage=false
+disable-lava-damage=false
+disable-fire-damage=false
+disable-water-damage=false
+disable-suffocation-damage=false
+
+# Teleports player when s/he is suffocating. This can be abused to get
+# through ceilings.
+teleport-on-suffocation=false
+
+# Disable fire spreading between blocks. Note that this does not prevent
+# fire damage -- it only prevents fire spread.
+disable-all-fire-spread=false
+
+# List blocks that fire should not spread to or between. Cloth and wood
+# are some good examples.
+disallowed-fire-spread-blocks=
+
+# Prevent lava from starting fires.
+disable-lava-fire=true
+
+# List of blocks that lava is allowed to spread onto.
+allowed-lava-spread-blocks=
+
+# List of blocks that should not be destroyed by water (Redstone wire,
+# minecart tracks, flowers, etc.).
+disable-water-damage-blocks=
+
+# Control where to log blacklist events to. You can use multiple log
+# methods as you please.
+log-console=true
+log-database-dsn=jdbc\:mysql\://localhost\:3306/minecraft
+log-database-pass=
+log-database-table=blacklist_events
+log-database-user=root
+log-database=false
+log-file-open-files=10
+log-file-path=worldguard/logs/%Y-%m-%d.log
+log-file=false
+
+# On death options.
+teleport-to-home-on-death=false
+exact-respawn=false
+
+#EOF