Updated WorldGuard to catch a missing WorldEdit.

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

CHANGELOG.txt

@@ -0,0 +1,147 @@
+2.0beta2:
+- Fixed a NullPointerException in the damage hook.
+
+2.0beta1:
+- Added area protection. Use /region or /rg to define regions.
+
+1.8.1
+- Fixed NullPointerException.
+
+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
+    can run for MySQL can be found in blacklist_table.sql.
+- Improved plugin compatibility with the block lag fix. For maximum
+    compatibility, you must now list WorldGuard as the first plugin in
+    server.properties and you cannot reload or enable the plugin
+    while the server is up. This is for bad plugins that unnecessarily
+    use the "critical" priority for its hooks like the LWC. Most plugins
+    don't do that though, so this won't apply for most people.
+- Fixed signs being blank if they were denied via the blacklist.
+- Added on-break event to the blacklist.
+- Added comments and messages. Comments are only for your own use and they
+    are printed with the log and notify actions of the blacklist. The
+    message replaces the message that is shown the user and it is optional.
+- The blacklist notification messages are now more compact and are
+    light grey instead of light purple.
+- The notify, log, and tell actions will now trigger every time for the
+    on-break, on-create, on-drop events rather than wait 3 seconds between
+    events for the same item or block for a player.
+
+1.2
+- /stopfire and /allowfire disable and enable fire spreading globally.
+- Block lag fix slightly improved in accuracy for item drops.
+- Sponge updated to remove water when the sponge block is set. Sponge radius
+    can now be controlled using the 'sponge-radius' parameter and the
+    default is now set to simulate Classic.
+- Updated for a newer build of "b126," meaning that lava spread control
+    now works well!
+- A new summary of the status of some core protections is now printed
+    on start. Disable this with 'summary-on-start'.
+- Blacklist system has been overhauled. Check README.txt for changed
+    configuration settings!
+- The blacklist's method of preventing notification repeats is now better,
+    instead waiting 3 seconds before notifying again (before it didn't
+    notify again at all unless the user started using another blocked
+    action).
+- To give users the ability to receive notifications, the command to give
+    permission to has been changed to /worldguardnotify, although the
+    old one (that was never mentioned anywhere) still works.
+- Water and lava buckets are now psuedo-blocked using an unreliable
+    method that risks the stability of your server (no other plugin
+    does it better though). Use it as your own risk.
+- Added on item drop and on item use (i.e. chest) events.
+- Chests, signs, and furnaces can now be blocked better with the
+    blacklist system.
+- The event names in the blacklist configuration have changed but the old
+    event names should still work. The new names should make "more sense."
+- A new "ban" action has been added to the blacklist.
+- Action messages have been improved, now longer saying "destroyed"
+    for everything.
+- Logging to file has been completely changed, allowing you to use
+    the date and time and the player's username in the log filename. It
+    no longer rotates log files based on size, however.
+- Logging to database is now supported.
+- Tools can now be destroyed on drop to alleviate the durability cheat.
+    You can do this with either with the blacklist or with the
+    'item-drop-blacklist' configuration option. The configuration option
+    prints more friendly messages than the 'tell' action of blacklists.
+
+1.1.2
+- Block lag fix: Snow and glass should no longer drop items.
+- Block lag fix: Block object now reset after hook call.
+
+1.1.1
+- Fixed redstone wire dropping wood blocks with the block lag fix.
+- The block lag fix now consults other plugins so that ALL protection
+    mechanisms and plugins should work.
+
+1.1
+- Added block lag fix.
+
+1.0
+- Initial release.

INSTALL.txt

@@ -5,11 +5,11 @@ This plugin requires Hey0's server modification.
 
   1. Create a "plugins" folder inside your "bin" folder.
 
-  2. Copy WorldProtect.jar into "plugins".
+  2. Copy WorldGuard.jar into "plugins".
 
-  3. Add "WorldProtect" to the "plugins" line of your server.properties file.
+  3. Add "WorldGuard" to the "plugins" line of your server.properties file.
      If it's not already there, add the line. The line should look like this:
   
-         plugins=WorldProtect
+         plugins=WorldGuard
      
      If you have multiple plugins, separate plugin names with commas.

README.txt

@@ -1,11 +1,11 @@
-WorldProtect
+WorldGuard
 Copyright (c) 2010 sk89q <http://www.sk89q.com>
 Licensed under the GNU Lesser General Public License v3
 
 Introduction
 ------------
 
-WorldProtect has a number of features, any of which you can choose to
+WorldGuard has a number of features, any of which you can choose to
 use or not:
 
 - Enforce only one session for a player on a server (can't login twice).
@@ -13,26 +13,41 @@ use or not:
 - Block TNT explosions.
 - Block lighters from setting fires.
 - Block all fires.
+- Disable fall damage, lava damage, fire damage, and/or water damage.
 - Allow fire but prevent it from burning certain blocks.
 - Prevent lava from starting fires.
 - Restrict lava spreading to only some block types.
 - Simulate classic-esque water by letting water infinitely expand in
     area (only if there is a block underneath).
-- Simulate the sponge.
-- Block the use, destruction and/or placement of some items or block types.
-- Notify admins when a certain block type or item is used, destroyed,
-    or place.
-- Log the use, destruction, and/or placement of some blocks/items.
-- Kick for the use, destruction, and/or placement of some blocks.
+- Prevent water from destroying blocks like Redstone wire and flowers.
+- Simulate the function of the sponge from Minecraft Classic.
+- Notify admins, block, log, kick or ban for the use of certain block types
+    or items.
+- Temporarily stop fire globally with some commands.
+- Destroy tools on drop to alleviate the durability cheat.
+- Prevent gravel and sand from falling.
+- Allow portal blocks to be placed anywhere.
 
-hMod is required as WorldProtect is a plugin for hMod.
+hMod is required as WorldGuard is a plugin for hMod.
 
 Configuration
 -------------
 
-A "worldprotect.properties" will be created the first the time that you load
-WorldProtect on your server. You can either restart your server or use
-/reloadplugin WorldProtect to reload the configuraton file after editing it.
+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
@@ -42,50 +57,47 @@ WorldProtect on your server. You can either restart your server or use
     ground, but if there are air blocks underneath, the water will not
     spread (preventing waterfalls from becoming tsunamis).
 
-- simulate-sponge (def. false)
-    Toggle simulation of the sponge. The sponge only prevents water
-    from spreading. It will not take away existing water. Simulation of
-    the sponge requires iterating over a 9x9x9 cuboid around the water
-    block and the resource impact of this has not been quantified.
+- simulate-sponge (def. true)
+    Toggle simulation of the sponge from Classic. It blocks water from
+    flowing near the sponge.
+
+- sponge-radius (def. 3)
+    The radius of the sponge's effect. The default is that of Classic,
+    creating a 5x5x5 cuboid free of water. Increasing the number will
+    increase server load exponentially, although 3-5 has fairly low impact.
+
+- no-physics-gravel (def. false)
+    **Requires special version of hMod
+    Prevents gravel from falling due to gravity.
+
+- no-physics-sand (def. false)
+    **Requires special version of hMod
+    Prevents sand from falling due to gravity.
+
+- allow-portal-anywhere (def. false)
+    **Requires special version of hMod
+    Allows you to place portal blocks anywhere.
 
 - enforce-single-session (def. true)
     Enforce single sessions. If the player is already found to be on
     the server when s/he logs in, the other player will be kicked with
     an informative message. The inventory will have been saved before
     the new session starts.
-
-- blacklist-log-console (def. true)
-    For log actions, print to console as well.
-
-- blacklist-log-file (no default)
-    File to log to. Log files are automatically rotated based on size, and
-    you can use these patterns in the path:
-        %t the system temporary directory
-        %h the value of the "user.home" system property
-        %g the generation number to distinguish rotated logs
-        %u a unique number to resolve conflicts
-        %% translates to a single percent sign "%"
-    There is no way to put the date in the filename or rotate by date.
-
-- blacklist-log-file-limit (def. 5242880)
-    Size in bytes before the log file is rotated.
-
-- blacklist-log-file-count (def. 10)
-    Number of log files to keep in rotation at maximum.
-
+    
 - block-tnt (def. false)
     Block TNT explosions. TNT will still explode client-side but the blocks
     will be "restored" in a few seconds afterwards.
-
+    
 - block-lighter (def. false)
     Block flint and steel fires. Those with access to the commands
     /uselighter or /lighter can bypass this. /uselighter is not a real
     command; it is only used for permissions.
 
 - block-creepers (def. false)
-    Block creeper explosions. They will not explode client-side.
+    Block creeper explosions from destroying terrain (and possibly from
+    causing damage).
 
-- disable-lava-fire (def. false)
+- disable-lava-fire (def. true)
     Prevent lava from starting fires.
 
 - allowed-lava-spread-blocks (no default)
@@ -100,8 +112,140 @@ WorldProtect 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
+    durability. You can also enforce this with the blacklist but
+    this is an easier way to do it (this way also prints a more
+    friendly message than if you used the 'tell' action of the blacklist).
+
+- login-protection (def. 3)
+    Number of seconds to keep a player invincible when the player joins.
+
+- spawn-protection (def. 0)
+    Number of seconds to keep a player invincible when the player spawns.
+    This does not apply to players joining the server.
+
+- kick-on-death (def. false)
+    Kick players when they die (and respawn). This is to work around the
+    issues of invisible players when players die.
+    
+- disable-fall-damage (def. false)
+- disable-lava-damage (def. false)
+- disable-fire-damage (def. false)
+- disable-water-damage (def. false)
+    Disable various types of damage.
+    
+- log-console (def. true)
+    For blacklist log actions, print to console.
+
+- log-file (def. false)
+    For blacklist log actions, log to file.
+    
+- log-file-path (def. "worldguard/logs/%Y-%m-%d.log")
+    Log blacklist events to file. You can use these patterns in the path:
+        %Y the year (YYYY)
+        %m the month (MM)
+        %d the day (DD)
+        %W the week of the year (00-52)
+        %H 24-hour time (HH)
+        %h 12-hour time (HH)
+        %i the minute (mm)
+        %s the second (ss)
+        %u the user's name
+        %% translates to a single percent sign "%"
+    The files are not automatically rotated if they get large so you should
+    perhaps put a week in the filename at least.
+    
+    Escape backslashes with another backslash, like so:
+    C:\path\to\log.txt -> C:\\path\\to\\log.txt
+
+- log-file-open-files (def. 10)
+    The number of log files to keep open at once. Unless you use dynamic
+    patterns in the path, the value of this variable won't matter. However,
+    if, for example, you use a player's username in the filename and you
+    have many users who cause logged events to occur, files would have
+    to be opened for each user and this parameter would matter.
+
+- log-database (def. false)
+    Log blacklist events to database.
+
+- log-database-dsn (def. "jdbc:mysql://localhost:3306/minecraft")
+    Connection string. A string to use for MySQL would be:
+    jdbc:mysql://localhost:3306/minecraft
+    The "minecraft" part at the end is the database name.
+    
+    Escape colons with a backslash, like so:
+    jdbc:mysql://localhost:3306/minecraft
+    ->
+    jdbc\:mysql\://localhost\:3306/minecraft
+
+- log-database-user (def. "root")
+    Database username.
+
+- log-database-pass (def. "")
+    Database password.
+
+- log-database-table (def. "blacklist_events")
+    Database table to use.
+
+Commands
+--------
+
+- /stopfire and /allowfire
+    Disables and enables fire spread globally. Both commands require the
+    permission to use only "/stopfire. Re-enabling fire spread with this
+    command will not override other fire spread control features of
+    WorldGuard. Note that disabling fire does not disable fire damage
+    but fire at least won't spread.
+
+- /god
+    Toggles your invincibility. Players must have permission to use "/god"
+    to be able to use this command. You can also use this command to
+    toggle the invincibility of others although you must have the
+    "/godother" permission.
+
+Server Commands
+---------------
+
+- fire-stop and fire-allow
+    Disables and enables fire spread globally. Re-enabling fire spread
+    with this command will not override other fire spread control features
+    of WorldGuard. Note that disabling fire does not disable fire damage
+    but fire at least won't spread.
+
 Blacklists
 ----------
 
-Edit the included worldprotect-blacklist.txt file and follow the
-instructions inside.
+Blacklists let you control the use of blocks and items. You can have
+certain rules apply to only some groups.
+
+Edit the included worldguard-blacklist.txt file and follow the
+instructions inside. The file comes with the download for WorldGuard.
+
+Other Features
+--------------
+
+To give someone invincibility every time s/he joins the server, create
+a wg-invincible group and add the group to the user or have the user's
+group inherit this group.
+
+To give someone the ability to breathe under water, create
+a wg-amphibious group and add the group to the user or have the user's
+group inherit this group.
+
+Thanks
+------
+
+While I would like to thank everyone for their support, I would like to
+say thanks to the following individuals for their direct
+contributions to WorldGuard:
+
+- Sturmeh, for contributing the original durability workaround
+- Meaglin, for changing the on flow hook at my request
+- Dinnerbone, for implementing the on item pick up hook at my request,
+    and also for figuring out the durability bug in the process

blacklist_table.sql

@@ -0,0 +1,21 @@
+-- Blacklist table for MySQL.
+-- You must still configure WorldGuard to use your database.
+-- If you do not plan on using a database for logging blacklist events,
+-- you do not need to do anything with this file.
+
+CREATE TABLE `blacklist_events` (
+  `id` int(11) NOT NULL AUTO_INCREMENT,
+  `event` varchar(25) NOT NULL,
+  `player` varchar(16) NOT NULL,
+  `x` int(11) NOT NULL,
+  `y` int(11) NOT NULL,
+  `z` int(11) NOT NULL,
+  `item` int(11) NOT NULL,
+  `time` int(11) NOT NULL,
+  `comment` varchar(255) NULL,
+  PRIMARY KEY (`id`)
+);
+
+-- Required update if you have an older version of the table:
+
+ALTER TABLE `blacklist_events` ADD `comment` VARCHAR( 255 ) NULL 

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="WorldEdit.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
-WorldProtect-Version: 1.0

src/Blacklist.java

@@ -0,0 +1,418 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.io.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class Blacklist {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    
+    /**
+     * List of entries by block ID.
+     */
+    private Map<Integer,List<BlacklistEntry>> blacklist
+            = new HashMap<Integer,List<BlacklistEntry>>();
+    /**
+     * Logger.
+     */
+    private BlacklistLogger blacklistLogger = new BlacklistLogger();
+
+    /**
+     * Blacklist contains on-acquire events.
+     */
+    private boolean hasOnAcquire;
+
+    /**
+     * Returns whether the list is empty.
+     * 
+     * @return
+     */
+    public boolean isEmpty() {
+        return blacklist.isEmpty();
+    }
+
+    /**
+     * Get the entries for an item or list.
+     */
+    public List<BlacklistEntry> getEntries(int id) {
+        return blacklist.get(id);
+    }
+    
+    /**
+     * Get the logger.
+     * 
+     * @return
+     */
+    public BlacklistLogger getLogger() {
+        return blacklistLogger;
+    }
+
+    /**
+     * Called on block destruction. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onDestroy(final Block block, final Player player) {
+        List<BlacklistEntry> entries = getEntries(block.getType());
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onDestroy(block, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on block break. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onBreak(final Block block, final Player player) {
+        List<BlacklistEntry> entries = getEntries(block.getType());
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onBreak(block, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on left click. Returns true to let the action pass through.
+     *
+     * @param item
+     * @param player
+     * @return
+     */
+    public boolean onDestroyWith(int item, Player player) {
+        List<BlacklistEntry> entries = getEntries(item);
+        if (entries == null) {
+            return true;
+        }
+        boolean ret = true;
+        for (BlacklistEntry entry : entries) {
+            if (!entry.onDestroyWith(item, player)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Called on 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)) {
+                ret = false;
+            }
+        }
+        return ret;
+    }
+
+    /**
+     * Load the blacklist.
+     *
+     * @param file
+     * @return
+     * @throws IOException
+     */
+    public void load(File file) throws IOException {
+        FileReader input = null;
+        Map<Integer,List<BlacklistEntry>> blacklist =
+                new HashMap<Integer,List<BlacklistEntry>>();
+
+        try {
+            input = new FileReader(file);
+            BufferedReader buff = new BufferedReader(input);
+
+            hasOnAcquire = false;
+
+            String line;
+            List<BlacklistEntry> currentEntries = null;
+            while ((line = buff.readLine()) != null) {
+                line = line.trim();
+
+                // Blank line
+                if (line.length() == 0) {
+                    continue;
+                } else if (line.charAt(0) == ';' || line.charAt(0) == '#') {
+                    continue;
+                }
+
+                if (line.matches("^\\[.*\\]$")) {
+                    String[] items = line.substring(1, line.length() - 1).split(",");
+                    currentEntries = new ArrayList<BlacklistEntry>();
+
+                    for (String item : items) {
+                        int id = 0;
+
+                        try {
+                            id = Integer.parseInt(item.trim());
+                        } catch (NumberFormatException e) {
+                            id = etc.getDataSource().getItem(item.trim());
+                            if (id == 0) {
+                                logger.log(Level.WARNING, "WorldGuard: Unknown block name: "
+                                        + item);
+                                break;
+                            }
+                        }
+
+                        BlacklistEntry entry = new BlacklistEntry(this);
+                        if (blacklist.containsKey(id)) {
+                            blacklist.get(id).add(entry);
+                        } else {
+                            List<BlacklistEntry> entries = new ArrayList<BlacklistEntry>();
+                            entries.add(entry);
+                            blacklist.put(id, entries);
+                        }
+                        currentEntries.add(entry);
+                    }
+                } else if (currentEntries != null) {
+                    String[] parts = line.split("=");
+
+                    if (parts.length == 1) {
+                        logger.log(Level.WARNING, "Found option with no value "
+                                + file.getName() + " for '" + line + "'");
+                        continue;
+                    }
+
+                    boolean unknownOption = false;
+
+                    for (BlacklistEntry entry : currentEntries) {
+                        if (parts[0].equalsIgnoreCase("ignore-groups")) {
+                            entry.setIgnoreGroups(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-destroy")) {
+                            entry.setDestroyActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-break")) {
+                            entry.setBreakActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-left")
+                                || parts[0].equalsIgnoreCase("on-destroy-with")) {
+                            entry.setDestroyWithActions(parts[1].split(","));
+                        } else if (parts[0].equalsIgnoreCase("on-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")) {
+                            entry.setComment(parts[1].trim());
+                        } else {
+                            unknownOption = true;
+                        }
+                    }
+
+                    if (unknownOption) {
+                        logger.log(Level.WARNING, "Unknown option '" + parts[0]
+                                + "' in " + file.getName() + " for '" + line + "'");
+                    }
+                } else {
+                    logger.log(Level.WARNING, "Found option with no heading "
+                            + file.getName() + " for '" + line + "'");
+                }
+            }
+
+            this.blacklist = blacklist;
+        } finally {
+            try {
+                if (input != null) {
+                    input.close();
+                }
+            } catch (IOException e2) {
+            }
+        }
+    }
+
+    /**
+     * Blacklist contains on-acquire events.
+     * 
+     * @return
+     */
+    public boolean hasOnAcquire() {
+        return hasOnAcquire;
+    }
+}

src/BlacklistEntry.java

@@ -1,6 +1,6 @@
 // $Id$
 /*
- * WorldProtect
+ * WorldGuard
  * Copyright (C) 2010 sk89q <http://www.sk89q.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -17,8 +17,6 @@
  * 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.Set;
 import java.util.HashSet;
 import java.util.Map;
@@ -32,12 +30,12 @@ public class BlacklistEntry {
     /**
      * Used to prevent spamming.
      */
-    private static Map<String,Integer> lastAffected =
-            new HashMap<String,Integer>();
+    private static Map<String,BlacklistTrackedEvent> lastAffected =
+            new HashMap<String,BlacklistTrackedEvent>();
     /**
-     * Logger.
+     * Parent blacklist entry.
      */
-    private static final Logger logger = Logger.getLogger("WorldProtect.Blacklist");
+    private Blacklist blacklist;
     /**
      * List of groups to not affect.
      */
@@ -46,14 +44,62 @@ public class BlacklistEntry {
      * List of actions to perform on destruction.
      */
     private String[] destroyActions;
+    /**
+     * List of actions to perform on break.
+     */
+    private String[] breakActions;
     /**
      * List of actions to perform on left click.
      */
-    private String[] leftClickActions;
+    private String[] destroyWithActions;
     /**
-     * List of actions to perform on right click.
+     * 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
@@ -74,45 +120,143 @@ public class BlacklistEntry {
     }
 
     /**
-     * @return the destroyActions
+     * @return
      */
     public String[] getDestroyActions() {
         return destroyActions;
     }
 
     /**
-     * @param destroyActions the destroyActions to set
+     * @param actions
      */
-    public void setDestroyActions(String[] destroyActions) {
-        this.destroyActions = destroyActions;
+    public void setDestroyActions(String[] actions) {
+        this.destroyActions = actions;
     }
 
     /**
-     * @return the leftClickActions
+     * @return
      */
-    public String[] getLeftClickActions() {
-        return leftClickActions;
+    public String[] getBreakActions() {
+        return breakActions;
     }
 
     /**
-     * @param leftClickActions the leftClickActions to set
+     * @param actions
      */
-    public void setLeftClickActions(String[] leftClickActions) {
-        this.leftClickActions = leftClickActions;
+    public void setBreakActions(String[] actions) {
+        this.breakActions = actions;
     }
 
     /**
-     * @return the rightClickActions
+     * @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 rightClickActions the rightClickActions to set
+     * @param actions
      */
-    public void setRightClickActions(String[] rightClickActions) {
-        this.rightClickActions = rightClickActions;
+    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;
     }
 
     /**
@@ -141,19 +285,25 @@ public class BlacklistEntry {
      */
     public void notifyAdmins(String str) {
         for (Player player : etc.getServer().getPlayerList()) {
-            if (player.canUseCommand("/wprotectalerts")) {
-                player.sendMessage(Colors.LightPurple + "WorldProtect: " + str);
+            if (player.canUseCommand("/wprotectalerts")
+                    || player.canUseCommand("/worldguardnotify")) {
+                player.sendMessage(Colors.LightGray + "WG: " + str);
             }
         }
     }
 
     /**
-     * Log a message.
+     * Ban a player.
      * 
-     * @param message
+     * @param player
+     * @param msg
      */
-    public void log(String message) {
-        logger.log(Level.INFO, message);
+    public void banPlayer(Player player, String msg) {
+        etc.getServer().ban(player.getName());
+        etc.getLoader().callHook(PluginLoader.Hook.BAN, new Object[]{
+            player.getUser(), player.getUser(), msg
+        });
+        player.kick(msg);
     }
 
     /**
@@ -164,13 +314,70 @@ public class BlacklistEntry {
      * @param player
      * @return
      */
-    public boolean onDestroy(Block block, Player player) {
+    public boolean onDestroy(final Block block, final Player player) {
         if (destroyActions == null) {
             return true;
         }
-        boolean ret = process(block.getType(), player, destroyActions);
-        lastAffected.put(player.getName(), block.getType());
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logDestroyAttempt(player, block, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You are not allowed to destroy " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You are not allowed to destroy " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (destroy) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You are not allowed to destroy " + itemName + ".");
+            }
+        };
+
+        return process(block.getType(), player, destroyActions, handler, false, false);
+    }
+
+    /**
+     * Called on block break. Returns true to let the action pass
+     * through.
+     *
+     * @param block
+     * @param player
+     * @return
+     */
+    public boolean onBreak(final Block block, final Player player) {
+        if (breakActions == null) {
+            return true;
+        }
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logBreakAttempt(player, block, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You are not allowed to break " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You are not allowed to break " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (break) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You are not allowed to break " + itemName + ".");
+            }
+        };
+
+        return process(block.getType(), player, breakActions, handler, true, false);
     }
 
     /**
@@ -180,29 +387,243 @@ public class BlacklistEntry {
      * @param player
      * @return
      */
-    public boolean onLeftClick(int item, Player player) {
-        if (leftClickActions == null) {
+    public boolean onDestroyWith(final int item, final Player player) {
+        if (destroyWithActions == null) {
             return true;
         }
-        boolean ret = process(item, player, leftClickActions);
-        lastAffected.put(player.getName(), item);
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().logDestroyWithAttempt(player, item, comment);
+            }
+            public void kick(String itemName) {
+                player.kick("You can't destroy with " + itemName);
+            }
+            public void ban(String itemName) {
+                entry.banPlayer(player, "Banned: You can't destroy with " + itemName);
+            }
+            public void notifyAdmins(String itemName) {
+                entry.notifyAdmins(player.getName() + " (destroy w/) " + itemName
+                        + (comment != null ? " (" + comment + ")" : "") + ".");
+            }
+            public void tell(String itemName) {
+                player.sendMessage(Colors.Yellow + "You can't destroy with " + itemName + ".");
+            }
+        };
+
+        return process(item, player, destroyWithActions, handler, false, false);
     }
 
     /**
-     * Called on right right. Returns true to let the action pass through.
+     * Called on block placement. Returns true to let the action pass through.
      *
      * @param item
      * @param player
      * @return
      */
-    public boolean onRightClick(int item, Player player) {
-        if (rightClickActions == null) {
+    public boolean onPlace(final int item, final Player player) {
+        if (placeActions == null) {
             return true;
         }
-        boolean ret = process(item, player, rightClickActions);
-        lastAffected.put(player.getName(), item);
-        return ret;
+
+        final BlacklistEntry entry = this;
+
+        ActionHandler handler = new ActionHandler() {
+            public void log(String itemName) {
+                blacklist.getLogger().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);
     }
 
     /**
@@ -211,35 +632,82 @@ public class BlacklistEntry {
      * @param id
      * @param player
      * @param actions
+     * @param handler
+     * @param allowRepeat
+     * @param silent
      * @return
      */
-    private boolean process(int id, Player player, String[] actions) {
+    private boolean process(int id, Player player, String[] actions,
+            ActionHandler handler, boolean allowRepeat, boolean silent) {
+
         if (shouldIgnore(player)) {
             return true;
         }
 
         String name = player.getName();
-        boolean repeating = lastAffected.containsKey(name)
-                && lastAffected.get(name) == id;
+        long now = System.currentTimeMillis();
+        boolean repeating = false;
+
+        // Check to see whether this event is being repeated
+        BlacklistTrackedEvent tracked = lastAffected.get(name);
+        if (tracked != null) {
+            if (tracked.getId() == id && tracked.getTime() > now - 3000) {
+                repeating = true;
+            } else {
+                tracked.setTime(now);
+                tracked.setId(id);
+            }
+        } else {
+            lastAffected.put(name, new BlacklistTrackedEvent(id, now));
+        }
 
         boolean ret = true;
         
         for (String action : actions) {
+            // Deny
             if (action.equalsIgnoreCase("deny")) {
+                if (silent) {
+                    return false;
+                }
                 ret = false;
+
+            // Kick
             } else if (action.equalsIgnoreCase("kick")) {
-                player.kick("Performed disallowed action with "
-                        + etc.getDataSource().getItem(id) + ".");
-            } else if (!repeating) {
+                if (this.message != null) {
+                    player.kick(String.format(this.message,
+                            etc.getDataSource().getItem(id)));
+                } else {
+                    handler.kick(etc.getDataSource().getItem(id));
+                }
+
+            // Ban
+            } else if (action.equalsIgnoreCase("ban")) {
+                handler.ban(etc.getDataSource().getItem(id));
+                if (this.message != null) {
+                    banPlayer(player, "Banned: " + String.format(this.message,
+                            etc.getDataSource().getItem(id)));
+                } else {
+                    handler.ban(etc.getDataSource().getItem(id));
+                }
+            
+            } else if (!repeating || allowRepeat) {
+                // Notify
                 if (action.equalsIgnoreCase("notify")) {
-                    notifyAdmins(player.getName() + " on destroy: "
-                            + etc.getDataSource().getItem(id));
+                    handler.notifyAdmins(etc.getDataSource().getItem(id));
+                
+                // Log
                 } else if (action.equalsIgnoreCase("log")) {
-                    log(player.getName() + " on destroy: "
-                            + etc.getDataSource().getItem(id));
-                } else if (!repeating && action.equalsIgnoreCase("tell")) {
-                    player.sendMessage("Can't do that with "
-                            + etc.getDataSource().getItem(id) + ".");
+                    handler.log(etc.getDataSource().getItem(id));
+
+                // Tell
+                } else if (action.equalsIgnoreCase("tell")) {
+                    if (this.message != null) {
+                        player.sendMessage(Colors.Yellow +
+                                String.format(message, etc.getDataSource().getItem(id))
+                                + ".");
+                    } else {
+                        handler.tell(etc.getDataSource().getItem(id));
+                    }
                 }
             }
         }
@@ -262,6 +730,17 @@ public class BlacklistEntry {
      * @param player
      */
     public static void forgetAllPlayers() {
-        lastAffected = new HashMap<String,Integer>();
+        lastAffected.clear();
+    }
+
+    /**
+     * Gets called for actions.
+     */
+    private static interface ActionHandler {
+        public void log(String itemName);
+        public void kick(String itemName);
+        public void ban(String itemName);
+        public void notifyAdmins(String itemName);
+        public void tell(String itemName);
     }
 }

src/BlacklistLogger.java

@@ -0,0 +1,165 @@
+// $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

@@ -0,0 +1,86 @@
+// $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/BlacklistTrackedEvent.java

@@ -0,0 +1,66 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ *
+ * @author sk89q
+ */
+public class BlacklistTrackedEvent {
+    private int id;
+    private long time;
+
+    /**
+     * Construct the object.
+     * 
+     * @param id
+     * @param time
+     */
+    public BlacklistTrackedEvent(int id, long time) {
+        this.id = id;
+        this.time = time;
+    }
+
+    /**
+     * @return the id
+     */
+    public int getId() {
+        return id;
+    }
+
+    /**
+     * @param id the id to set
+     */
+    public void setId(int id) {
+        this.id = id;
+    }
+
+    /**
+     * @return the time
+     */
+    public long getTime() {
+        return time;
+    }
+
+    /**
+     * @param time the time to set
+     */
+    public void setTime(long time) {
+        this.time = time;
+    }
+}

src/ConsoleLoggerHandler.java

@@ -0,0 +1,143 @@
+// $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/DatabaseLoggerHandler.java

@@ -0,0 +1,227 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.PreparedStatement;
+
+/**
+ *
+ * @author sk89q
+ */
+public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+
+    /**
+     * DSN.
+     */
+    private String dsn;
+    /**
+     * Username.
+     */
+    private String user;
+    /**
+     * Password.
+     */
+    private String pass;
+    /**
+     * Table.
+     */
+    private String table;
+    /**
+     * Database connection.
+     */
+    private Connection conn;
+
+    /**
+     * Construct the object.
+     * 
+     * @param dsn
+     * @param user
+     * @param pass
+     */
+    public DatabaseLoggerHandler(String dsn, String user, String pass, String table) {
+        this.dsn = dsn;
+        this.user = user;
+        this.pass = pass;
+        this.table = table;
+    }
+
+    /**
+     * Gets the database connection.
+     * 
+     * @return
+     * @throws SQLException
+     */
+    private Connection getConnection() throws SQLException {
+        if (conn == null || conn.isClosed()) {
+            conn = DriverManager.getConnection(dsn, user, pass);
+        }
+        return conn;
+    }
+
+    /**
+     * Log an event to the database.
+     * 
+     * @param event
+     * @param name
+     * @param x
+     * @param y
+     * @param z
+     * @param item
+     * @param comment
+     */
+    private void logEvent(String event, String name, int x, int y, int z, int item,
+            String comment) {
+        try {
+            Connection conn = getConnection();
+            PreparedStatement stmt = conn.prepareStatement(
+                    "INSERT INTO " + table
+                  + "(event, player, x, y, z, item, time, comment) VALUES "
+                  + "(?, ?, ?, ?, ?, ?, ?, ?)");
+            stmt.setString(1, event);
+            stmt.setString(2, name);
+            stmt.setInt(3, x);
+            stmt.setInt(4, y);
+            stmt.setInt(5, z);
+            stmt.setInt(6, item);
+            stmt.setInt(7, (int)(System.currentTimeMillis() / 1000));
+            stmt.setString(8, comment);
+            stmt.executeUpdate();
+        } catch (SQLException e) {
+            logger.log(Level.SEVERE, "Failed to log blacklist event to database: "
+                    + e.getMessage());
+        }
+    }
+
+    /**
+     * Log a block destroy attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logDestroyAttempt(Player player, Block block, String comment) {
+        logEvent("DESTROY", player.getName(),
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
+    }
+
+    /**
+     * Log a block break attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void logBreakAttempt(Player player, Block block, String comment) {
+        logEvent("BREAK", player.getName(),
+                block.getX(), block.getY(), block.getZ(), block.getType(),
+                comment);
+    }
+
+    /**
+     * Log a right click on attempt.
+     *
+     * @param player
+     * @param block
+     */
+    public void 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.
+     *
+     * @param player
+     * @param item
+     */
+    public void logDestroyWithAttempt(Player player, int item, String comment) {
+        logEvent("DESTROY_WITH", player.getName(),
+                (int)Math.floor(player.getX()), (int)Math.floor(player.getY()),
+                (int)Math.floor(player.getZ()), item, comment);
+    }
+
+    /**
+     * Log a 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);
+    }
+
+    /**
+     * Close the connection.
+     */
+    public void close() {
+        try {
+            if (conn != null && !conn.isClosed()) {
+                conn.close();
+            }
+        } catch (SQLException e) {
+            
+        }
+    }
+}

src/FileLoggerHandler.java

@@ -0,0 +1,326 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import java.util.logging.Logger;
+import java.util.logging.Level;
+import java.io.*;
+import java.util.regex.*;
+import java.util.Map;
+import java.util.Date;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.TreeMap;
+import java.util.Iterator;
+import java.text.SimpleDateFormat;
+
+/**
+ *
+ * @author sk89q
+ */
+public class FileLoggerHandler implements BlacklistLoggerHandler {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    /**
+     * Regex for patterns in the path.
+     */
+    private static Pattern pattern = Pattern.compile("%.");
+    /**
+     * Date format.
+     */
+    private static SimpleDateFormat dateFormat =
+            new SimpleDateFormat("yyyyy-MM-dd HH:mm:ss");
+
+    /**
+     * Number of files to keep open at a time.
+     */
+    private int cacheSize = 10;
+    /**
+     * Path pattern.
+     */
+    private String pathPattern;
+    /**
+     * Cache of writers.
+     */
+    private TreeMap<String,FileLoggerWriter> writers =
+            new TreeMap<String,FileLoggerWriter>();
+
+    /**
+     * Construct the object.
+     *
+     * @param pathPattern
+     */
+    public FileLoggerHandler(String pathPattern) {
+        this.pathPattern = pathPattern;
+    }
+
+    /**
+     * Construct the object.
+     *
+     * @param pathPattern
+     * @param cacheSize
+     */
+    public FileLoggerHandler(String pathPattern, int cacheSize) {
+        if (cacheSize < 1) {
+            throw new IllegalArgumentException("Cache size cannot be less than 1");
+        }
+        this.pathPattern = pathPattern;
+        this.cacheSize = cacheSize;
+    }
+
+    /**
+     * Build the path.
+     * 
+     * @return
+     */
+    private String buildPath(String playerName) {
+        GregorianCalendar calendar = new GregorianCalendar();
+
+        Matcher m = pattern.matcher(pathPattern);
+        StringBuffer buffer = new StringBuffer();
+
+        // Pattern replacements
+        while (m.find()) {
+            String group = m.group();
+            String rep = "?";
+
+            if (group.matches("%%")) {
+                rep = "%";
+            } else if (group.matches("%u")) {
+                rep = playerName.toLowerCase().replaceAll("[^A-Za-z0-9_]", "_");
+                if (rep.length() > 32) { // Actual max length is 16
+                    rep = rep.substring(0, 32);
+                }
+
+            // Date and time
+            } else if (group.matches("%Y")) {
+                rep = String.valueOf(calendar.get(Calendar.YEAR));
+            } else if (group.matches("%m")) {
+                rep = String.format("%02d", calendar.get(Calendar.MONTH));
+            } else if (group.matches("%d")) {
+                rep = String.format("%02d", calendar.get(Calendar.DAY_OF_MONTH));
+            } else if (group.matches("%W")) {
+                rep = String.format("%02d", calendar.get(Calendar.WEEK_OF_YEAR));
+            } else if (group.matches("%H")) {
+                rep = String.format("%02d", calendar.get(Calendar.HOUR_OF_DAY));
+            } else if (group.matches("%h")) {
+                rep = String.format("%02d", calendar.get(Calendar.HOUR));
+            } else if (group.matches("%i")) {
+                rep = String.format("%02d", calendar.get(Calendar.MINUTE));
+            } else if (group.matches("%s")) {
+                rep = String.format("%02d", calendar.get(Calendar.SECOND));
+            }
+            
+            m.appendReplacement(buffer, rep);
+        }
+
+        m.appendTail(buffer);
+        
+        return buffer.toString();
+    }
+
+    /**
+     * Log a message.
+     * 
+     * @param player
+     * @param message
+     */
+    private void log(Player player, String message, String comment) {
+        String path = buildPath(player.getName());
+        try {
+            String date = dateFormat.format(new Date());
+            String line = "[" + date + "] " + player.getName() + ": " + message
+                    + (comment != null ? " (" + comment + ")" : "") + "\r\n";
+            
+            FileLoggerWriter writer = writers.get(path);
+
+            // Writer already exists!
+            if (writer != null) {
+                try {
+                    BufferedWriter out = writer.getWriter();
+                    out.write(line);
+                    out.flush();
+                    writer.updateLastUse();
+                    return;
+                } catch (IOException e) {
+                    // Failed initial rewrite... let's re-open
+                }
+            }
+
+            // Make parent directory
+            File file = new File(path);
+            File parent = file.getParentFile();
+            if (parent != null && !parent.exists()) {
+                parent.mkdirs();
+            }
+            
+            FileWriter stream = new FileWriter(path, true);
+            BufferedWriter out = new BufferedWriter(stream);
+            out.write(line);
+            out.flush();
+            writer = new FileLoggerWriter(path, out);
+            writers.put(path, writer);
+
+            // Check to make sure our cache doesn't get too big!
+            if (writers.size() > cacheSize) {
+                Iterator<Map.Entry<String,FileLoggerWriter>> it =
+                        writers.entrySet().iterator();
+
+                // Remove some entries
+                for (; it.hasNext(); ) {
+                    Map.Entry<String,FileLoggerWriter> entry = it.next();
+                    try {
+                        entry.getValue().getWriter().close();
+                    } catch (IOException e) {
+                    }
+                    it.remove();
+
+                    // Trimmed enough
+                    if (writers.size() <= cacheSize) {
+                        break;
+                    }
+                }
+            }
+
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Failed to log blacklist event to '"
+                    + path + "': " + e.getMessage());
+        }
+    }
+
+    /**
+     * 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.
+     *
+     * @param player
+     * @param block
+     */
+    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);
+    }
+
+    /**
+     * Get an item's friendly name with its ID.
+     *
+     * @param id
+     */
+    private static String getFriendlyItemName(int id) {
+        return etc.getDataSource().getItem(id) + " (#" + id + ")";
+    }
+
+    /**
+     * Close handles.
+     */
+    public void close() {
+        for (Map.Entry<String,FileLoggerWriter> entry : writers.entrySet()) {
+            try {
+                entry.getValue().getWriter().close();
+            } catch (IOException e) {
+            }
+        }
+
+        writers.clear();
+    }
+}

src/FileLoggerWriter.java

@@ -0,0 +1,98 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import java.io.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
+    /**
+     * Path.
+     */
+    public String path;
+    /**
+     * Writer.
+     */
+    private BufferedWriter writer;
+    /**
+     * Last use.
+     */
+    private long lastUse;
+
+    /**
+     * Construct the object.
+     * 
+     * @param writer
+     */
+    public FileLoggerWriter(String path, BufferedWriter writer) {
+        this.path = path;
+        this.writer = writer;
+        lastUse = System.currentTimeMillis();
+    }
+
+    /**
+     * File path.
+     * 
+     * @return
+     */
+    public String getPath() {
+        return path;
+    }
+
+    /**
+     * @return the writer
+     */
+    public BufferedWriter getWriter() {
+        return writer;
+    }
+
+    /**
+     * @return the lastUse
+     */
+    public long getLastUse() {
+        return lastUse;
+    }
+    
+    /**
+     * Update last use time.
+     * 
+     * @return
+     */
+    public void updateLastUse() {
+        lastUse = System.currentTimeMillis();
+    }
+
+    /**
+     * Comparison function.
+     * 
+     * @param other
+     * @return
+     */
+    public int compareTo(FileLoggerWriter other) {
+        if (lastUse > other.lastUse) {
+            return 1;
+        } else if (lastUse < other.lastUse) {
+            return -1;
+        } else {
+            return 0;
+        }
+    }
+}

src/HMPlayer.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/>.
+*/
+
+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);
+    }
+}

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

@@ -1,6 +1,6 @@
 // $Id$
 /*
- * WorldProtect
+ * WorldGuard
  * Copyright (C) 2010 sk89q <http://www.sk89q.com>
  *
  * This program is free software: you can redistribute it and/or modify
@@ -17,31 +17,46 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-package com.sk89q.worldprotect;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.logging.Formatter;
+import java.util.logging.Handler;
 import java.util.logging.LogRecord;
-import java.util.logging.Level;
 
 /**
- * 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

@@ -0,0 +1,202 @@
+// $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() {
+        try {
+            listener = new WorldGuardListener(this);
+        } catch (NoClassDefFoundError e) {
+            logger.severe("*** WORLDGUARD FAILED TO LOAD. ALL PROTECTION IS DISABLED!");
+            logger.severe("*** YOUR SERVER WILL BE SAVED AND STOPPED TO PREVENT DAMAGE TO YOUR WORLD. DISABLE WORLDGUARD OR CORRECT THE PROBLEM.");
+            logger.severe("*** WorldEdit must be placed into the plugins/ directory");
+            etc.getServer().useConsoleCommand("stop");
+        }
+    }
+
+    /**
+     * Initializes the plugin.
+     */
+    @Override
+    public void initialize() {
+        if (listener == null) {
+            return;
+        }
+        
+        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() {
+        if (listener == null) {
+            return;
+        }
+        
+        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/WorldProtect.java

@@ -1,102 +0,0 @@
-// $Id$
-/*
- * WorldProtect
- * 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.net.URL;
-import java.io.*;
-
-/**
- * Entry point for the plugin for hey0's mod.
- *
- * @author sk89q
- */
-public class WorldProtect extends Plugin {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldProtect");
-    /**
-     * Listener for the plugin system.
-     */
-    private static final WorldProtectListener listener =
-            new WorldProtectListener();
-
-    /**
-     * Initializes the plugin.
-     */
-    @Override
-    public void initialize() {
-        PluginLoader loader = etc.getLoader();
-
-        loader.addListener(PluginLoader.Hook.EXPLODE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.IGNITE, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.FLOW, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.LOGINCHECK, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_CREATED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.BLOCK_DESTROYED, listener, this,
-                PluginListener.Priority.HIGH);
-        loader.addListener(PluginLoader.Hook.DISCONNECT, listener, this,
-                PluginListener.Priority.HIGH);
-    }
-
-    /**
-     * Enables the plugin.
-     */
-    @Override
-    public void enable() {
-        listener.loadConfiguration();
-
-        logger.log(Level.INFO, "WorldProtect version " + getVersion() + " loaded");
-    }
-
-    /**
-     * Disables the plugin.
-     */
-    @Override
-    public void disable() {
-        BlacklistEntry.forgetAllPlayers();
-    }
-
-    /**
-     * Get the WorldProtect version.
-     *
-     * @return
-     */
-    private String getVersion() {
-        try {
-            String classContainer = WorldProtect.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("WorldProtect-Version");
-            return ver != null ? ver : "(unavailable)";
-        } catch (IOException e) {
-            return "(unknown)";
-        }
-    }
-}

src/WorldProtectListener.java

@@ -1,434 +0,0 @@
-// $Id$
-/*
- * WorldProtect
- * 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.logging.Handler;
-import java.util.logging.ConsoleHandler;
-import java.util.Set;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.HashMap;
-import java.util.List;
-import java.util.ArrayList;
-import java.io.*;
-import com.sk89q.worldprotect.*;
-import java.util.logging.FileHandler;
-
-/**
- * Event listener for Hey0's server mod.
- *
- * @author sk89q
- */
-public class WorldProtectListener extends PluginListener {
-    /**
-     * Logger.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldProtect");
-    /**
-     * Properties file for CraftBook.
-     */
-    private PropertiesFile properties = new PropertiesFile("worldprotect.properties");
-
-    private boolean enforceOneSession;
-    private boolean blockCreepers;
-    private boolean blockTNT;
-    private boolean blockLighter;
-    private boolean preventLavaFire;
-    private boolean disableAllFire;
-    private boolean simulateSponge;
-    private Set<Integer> fireNoSpreadBlocks;
-    private Set<Integer> allowedLavaSpreadOver;
-    private boolean classicWater;
-    private Map<Integer,BlacklistEntry> blacklist;
-
-    /**
-     * Convert a comma-delimited list to a set of integers.
-     * 
-     * @param str
-     * @return
-     */
-    private static Set<Integer> toBlockIDSet(String str) {
-        if (str.trim().length() == 0) {
-            return null;
-        }
-        
-        String[] items = str.split(",");
-        Set<Integer> result = new HashSet<Integer>();
-
-        for (String item : items) {
-            try {
-                result.add(Integer.parseInt(item.trim()));
-            } catch (NumberFormatException e) {
-                int id = etc.getDataSource().getItem(item.trim());
-                if (id != 0) {
-                    result.add(id);
-                } else {
-                    logger.log(Level.WARNING, "WorldProtect: Unknown block name: "
-                            + item);
-                }
-            }
-        }
-
-        return result;
-    }
-
-    /**
-     * Load the configuration
-     */
-    public void loadConfiguration() {
-        properties.load();
-
-        enforceOneSession = properties.getBoolean("enforce-single-session", true);
-        blockCreepers = properties.getBoolean("block-creepers", false);
-        blockTNT = properties.getBoolean("block-tnt", false);
-        blockLighter = properties.getBoolean("block-lighter", false);
-        preventLavaFire = properties.getBoolean("disable-lava-fire", false);
-        disableAllFire = properties.getBoolean("disable-all-fire-spread", false);
-        fireNoSpreadBlocks = toBlockIDSet(properties.getString("disallowed-fire-spread-blocks", ""));
-        allowedLavaSpreadOver = toBlockIDSet(properties.getString("allowed-lava-spread-blocks", ""));
-        classicWater = properties.getBoolean("classic-water", false);
-        simulateSponge = properties.getBoolean("simulate-sponge", false);
-
-        try {
-            blacklist = loadBlacklist(new File("worldprotect-blacklist.txt"));
-        } catch (FileNotFoundException e) {
-            logger.log(Level.WARNING, "WorldProtect blacklist does not exist.");
-        } catch (IOException e) {
-            logger.log(Level.WARNING, "Could not load WorldProtect blacklist: "
-                    + e.getMessage());
-        }
-
-        Logger blacklistLogger = Logger.getLogger("WorldProtect.Blacklist");
-        blacklistLogger.setUseParentHandlers(false);
-        for (Handler handler : blacklistLogger.getHandlers()) {
-            blacklistLogger.removeHandler(handler);
-        }
-
-        // Blacklist log to console
-        if (properties.getBoolean("blacklist-log-console", true)) {
-            Handler handler = new ConsoleHandler();
-            handler.setFormatter(new ConsoleLogFormat());
-            blacklistLogger.addHandler(handler);
-        }
-
-        // Blacklist log file
-        String logFile = properties.getString("blacklist-log-file", "").trim();
-        int limit = properties.getInt("blacklist-log-file-limit", 1024 * 1024 * 5);
-        int count = properties.getInt("blacklist-log-file-count", 10);
-        if (logFile.length() > 0) {
-            try {
-                Handler handler = new FileHandler(logFile, limit, count, true);
-                handler.setFormatter(new SimpleLogFormat());
-                blacklistLogger.addHandler(handler);
-            } catch (IOException e) {
-                logger.log(Level.WARNING, "Could not open blacklist log file: "
-                        + e.getMessage());
-            }
-        }
-    }
-    
-    /**
-     * Called during the early login process to check whether or not to kick the
-     * player
-     *
-     * @param user
-     * @return kick reason. null if you don't want to kick the player.
-     */
-    public String onLoginChecks(String user) {
-        if (enforceOneSession) {
-            for (Player player : etc.getServer().getPlayerList()) {
-                if (player.getName().equalsIgnoreCase(user)) {
-                    player.kick("Logged in from another location.");
-                }
-            }
-        }
-
-        return null;
-    }
-
-    /**
-     * Called when someone presses right click. If they right clicked with a
-     * block you can return true to cancel that. You can intercept this to add
-     * your own right click actions to different item types (see itemInHand)
-     *
-     * @param player
-     * @param blockPlaced
-     * @param blockClicked
-     * @param itemInHand
-     * @return false if you want the action to go through
-     */
-    public boolean onBlockCreate(Player player, Block blockPlaced, Block blockClicked,
-            int itemInHand) {
-        if (blacklist != null) {
-            BlacklistEntry entry = blacklist.get(itemInHand);
-            if (entry != null) {
-                if (!entry.onRightClick(itemInHand, player)) {
-                    return true;
-                }
-            }
-        }
-        
-        return false;
-    }
-
-    /**
-     * Called when a person left clicks a block.
-     *
-     * @param player
-     * @param block
-     * @return
-     */
-    public boolean onBlockDestroy(Player player, Block block) {
-        if (blacklist != null) {
-            BlacklistEntry entry = blacklist.get(player.getItemInHand());
-            if (entry != null) {
-                if (entry.onLeftClick(player.getItemInHand(), player)) {
-                    return true;
-                }
-            }
-            
-            entry = blacklist.get(block.getType());
-            if (entry != null) {
-                if (!entry.onDestroy(block, player)) {
-                    return true;
-                }
-            }
-        }
-        
-        return false;
-    }
-
-    /*
-     * Called when either a lava block or a lighter tryes to light something on fire.
-     * block status depends on the light source:
-     * 1 = lava.
-     * 2 = lighter (flint + steel).
-     * 3 = spread (dynamic spreading of fire).
-     * @param block
-     *          block that the fire wants to spawn in.
-     *
-     * @return true if you dont want the fire to ignite.
-     */
-    public boolean onIgnite(Block block, Player player) {
-        if (preventLavaFire && block.getStatus() == 1) {
-            return true;
-        }
-        
-        if (blockLighter && block.getStatus() == 2) {
-            return !player.canUseCommand("/uselighter")
-                    && !player.canUseCommand("/lighter");
-        }
-
-        if (disableAllFire && block.getStatus() == 3) {
-            return true;
-        }
-
-        if (fireNoSpreadBlocks != null && block.getStatus() == 3) {
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
-            if (fireNoSpreadBlocks.contains(etc.getServer().getBlockIdAt(x, y - 1, z))
-                    || fireNoSpreadBlocks.contains(etc.getServer().getBlockIdAt(x + 1, y, z))
-                    || fireNoSpreadBlocks.contains(etc.getServer().getBlockIdAt(x - 1, y, z))
-                    || fireNoSpreadBlocks.contains(etc.getServer().getBlockIdAt(x, y, z - 1))
-                    || fireNoSpreadBlocks.contains(etc.getServer().getBlockIdAt(x, y, z + 1))) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /*
-     * Called when a dynamite block or a creeper is triggerd.
-     * block status depends on explosive compound:
-     * 1 = dynamite.
-     * 2 = creeper.
-     * @param block
-     *          dynamite block/creeper location block.
-     *
-     * @return true if you dont the block to explode.
-     */
-    public boolean onExplode(Block block) {
-        if (blockCreepers && block.getStatus() == 2) {
-            return true;
-        }
-
-        if (blockTNT && block.getStatus() == 1) {
-            return true;
-        }
-
-        return false;
-    }
-
-    /*
-     * Called when lava wants to flow to a certain block.
-     * block status represents the type that wants to flow.
-     * (10 & 11 for lava and 8 & 9 for water)
-     *
-     * @param block
-     *          the block beneath where the substance wants to flow to.
-     *
-     * for example:
-     * lava want to flow to block x,y,z then the param block is the block x,y-1,z.
-     *
-     * @return true if you dont want the substance to flow.
-     */
-    public boolean onFlow(Block block) {
-        if (simulateSponge && (block.getStatus() == 8 || block.getStatus() == 9)) {
-            int ox = block.getX();
-            int oy = block.getY() + 1;
-            int oz = block.getZ();
-
-            Server server = etc.getServer();
-
-            for (int x = -4; x <= 4; x++) {
-                for (int y = -4; y <= 4; y++) {
-                    for (int z = -4; z <= 4; z++) {
-                        if (server.getBlockIdAt(ox + x, oy + y, oz + z) == 19) {
-                            return true;
-                        }
-                    }
-                }
-            }
-        }
-
-        if (classicWater && (block.getStatus() == 8 || block.getStatus() == 9)) {
-            int blockBelow = etc.getServer().getBlockIdAt(block.getX(), block.getY(), block.getZ());
-            if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
-                etc.getServer().setBlockAt(9, block.getX(), block.getY() + 1, block.getZ());
-                return false;
-            }
-        }
-
-        if (allowedLavaSpreadOver != null && (block.getStatus() == 10 || block.getStatus() == 11)) {
-            if (!allowedLavaSpreadOver.contains(block.getType())) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Called on player disconnect
-     *
-     * @param player
-     */
-    public void onDisconnect(Player player) {
-        BlacklistEntry.forgetPlayer(player);
-    }
-
-    /**
-     * Load the blacklist.
-     * 
-     * @param file
-     * @return
-     * @throws IOException
-     */
-    public Map<Integer,BlacklistEntry> loadBlacklist(File file)
-            throws IOException {
-        FileReader input = null;
-        Map<Integer,BlacklistEntry> blacklist = new HashMap<Integer,BlacklistEntry>();
-
-        try {
-            input = new FileReader(file);
-            BufferedReader buff = new BufferedReader(input);
-
-            String line;
-            List<BlacklistEntry> entries = null;
-            while ((line = buff.readLine()) != null) {
-                line = line.trim();
-
-                // Blank line
-                if (line.length() == 0) {
-                    continue;
-                } else if (line.charAt(0) == ';' || line.charAt(0) == '#') {
-                    continue;
-                }
-
-                if (line.matches("^\\[.*\\]$")) {
-                    String[] items = line.substring(1, line.length() - 1).split(",");
-                    entries = new ArrayList<BlacklistEntry>();
-
-                    for (String item : items) {
-                        int id = 0;
-
-                        try {
-                            id = Integer.parseInt(item.trim());
-                        } catch (NumberFormatException e) {
-                            id = etc.getDataSource().getItem(item.trim());
-                            if (id == 0) {
-                                logger.log(Level.WARNING, "WorldProtect: Unknown block name: "
-                                        + item);
-                                break;
-                            }
-                        }
-
-                        BlacklistEntry entry = new BlacklistEntry();
-                        blacklist.put(id, entry);
-                        entries.add(entry);
-                    }
-                } else if (entries != null) {
-                    String[] parts = line.split("=");
-
-                    if (parts.length == 1) {
-                        logger.log(Level.WARNING, "Found option with no value "
-                                + file.getName() + " for '" + line + "'");
-                        continue;
-                    }
-
-                    boolean unknownOption = false;
-
-                    for (BlacklistEntry entry : entries) {
-                        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-left")) {
-                            entry.setLeftClickActions(parts[1].split(","));
-                        } else if(parts[0].equalsIgnoreCase("on-right")) {
-                            entry.setRightClickActions(parts[1].split(","));
-                        } else {
-                            unknownOption = true;
-                        }
-                    }
-
-                    if (unknownOption) {
-                        logger.log(Level.WARNING, "Unknown option '" + parts[0]
-                                + "' in " + file.getName() + " for '" + line + "'");
-                    }
-                } else {
-                    logger.log(Level.WARNING, "Found option with no heading "
-                            + file.getName() + " for '" + line + "'");
-                }
-            }
-
-            return blacklist.isEmpty() ? null : blacklist;
-        } finally {
-            try {
-                if (input != null) {
-                    input.close();
-                }
-            } catch (IOException e2) {
-            }
-        }
-    }
-}

src/au/com/bytecode/opencsv/CSVParser.java

@@ -0,0 +1,307 @@
+package au.com.bytecode.opencsv;
+
+/**
+ Copyright 2005 Bytecode Pty Ltd.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A very simple CSV parser released under a commercial-friendly license.
+ * This just implements splitting a single line into fields.
+ * 
+ * @author Glen Smith
+ * @author Rainer Pruy
+ * 
+ */
+public class CSVParser {
+
+    private final char separator;
+
+    private final char quotechar;
+    
+    private final char escape;
+
+    private final boolean strictQuotes;
+
+    private String pending;
+    private boolean inField = false;
+
+    private final boolean ignoreLeadingWhiteSpace;
+    
+    /** The default separator to use if none is supplied to the constructor. */
+    public static final char DEFAULT_SEPARATOR = ',';
+
+    public static final int INITIAL_READ_SIZE = 128;
+
+    /**
+     * The default quote character to use if none is supplied to the
+     * constructor.
+     */
+    public static final char DEFAULT_QUOTE_CHARACTER = '"';
+    
+
+    /**
+     * The default escape character to use if none is supplied to the
+     * constructor.
+     */
+    public static final char DEFAULT_ESCAPE_CHARACTER = '\\';
+
+   /**
+    * The default strict quote behavior to use if none is supplied to the
+    * constructor
+    */
+    public static final boolean DEFAULT_STRICT_QUOTES = false;
+    
+    /**
+     * The default leading whitespace behavior to use if none is supplied to the
+     * constructor
+     */
+    public static final boolean DEFAULT_IGNORE_LEADING_WHITESPACE = true;
+    
+    /**
+     * Constructs CSVParser using a comma for the separator.
+     */
+    public CSVParser() {
+        this(DEFAULT_SEPARATOR, DEFAULT_QUOTE_CHARACTER, DEFAULT_ESCAPE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVParser with supplied separator.
+     * @param separator
+     *            the delimiter to use for separating entries.
+     */
+    public CSVParser(char separator) {
+        this(separator, DEFAULT_QUOTE_CHARACTER, DEFAULT_ESCAPE_CHARACTER);
+    }
+    
+    
+
+    /**
+     * Constructs CSVParser with supplied separator and quote char.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     */
+    public CSVParser(char separator, char quotechar) {
+        this(separator, quotechar, DEFAULT_ESCAPE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     */
+    public CSVParser(char separator, char quotechar, char escape) {
+        this(separator, quotechar, escape, DEFAULT_STRICT_QUOTES);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * Allows setting the "strict quotes" flag
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     * @param strictQuotes
+     *            if true, characters outside the quotes are ignored
+     */
+    public CSVParser(char separator, char quotechar, char escape, boolean strictQuotes) {
+        this(separator, quotechar, escape, strictQuotes, DEFAULT_IGNORE_LEADING_WHITESPACE);
+    }
+    
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * Allows setting the "strict quotes" and "ignore leading whitespace" flags
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     * @param strictQuotes
+     *            if true, characters outside the quotes are ignored
+     * @param ignoreLeadingWhiteSpace
+     *            if true, white space in front of a quote in a field is ignored
+     */
+    public CSVParser(char separator, char quotechar, char escape, boolean strictQuotes, boolean ignoreLeadingWhiteSpace) {
+        this.separator = separator;
+        this.quotechar = quotechar;
+        this.escape = escape;
+        this.strictQuotes = strictQuotes;
+        this.ignoreLeadingWhiteSpace = ignoreLeadingWhiteSpace;
+    }
+    /**
+     * 
+     * @return true if something was left over from last call(s)
+     */
+    public boolean isPending() {
+    	return pending != null;
+    }
+
+    public String[] parseLineMulti(String nextLine) throws IOException {
+    	return parseLine(nextLine, true);
+    }
+    
+    public String[]  parseLine(String nextLine) throws IOException {
+    	return parseLine(nextLine, false);
+    }
+    /**
+     * Parses an incoming String and returns an array of elements.
+     * 
+     * @param nextLine
+     *            the string to parse
+     * @param multi
+     * @return the comma-tokenized list of elements, or null if nextLine is null
+     * @throws IOException if bad things happen during the read
+     */
+    private String[] parseLine(String nextLine, boolean multi) throws IOException {
+
+    	if (!multi && pending != null) {
+    		pending = null;
+    	}
+    	
+        if (nextLine == null) {
+        	if (pending != null) {
+        		String s = pending;
+        		pending = null;
+        		return new String[] {s};
+        	} else {
+        		return null;
+        	}
+        }
+
+        List<String>tokensOnThisLine = new ArrayList<String>();
+        StringBuilder sb = new StringBuilder(INITIAL_READ_SIZE);
+        boolean inQuotes = false;
+        if (pending != null) {
+        	sb.append(pending);
+        	pending = null;
+        	inQuotes = true;
+        }
+        for (int i = 0; i < nextLine.length(); i++) {
+        	
+        	char c = nextLine.charAt(i);
+        	if (c == this.escape) {
+        		if( isNextCharacterEscapable(nextLine, inQuotes || inField, i) ){
+        			sb.append(nextLine.charAt(i+1));
+        			i++;
+        		}
+        	} else if (c == quotechar) {
+        		if( isNextCharacterEscapedQuote(nextLine, inQuotes || inField, i) ){
+        			sb.append(nextLine.charAt(i+1));
+        			i++;
+        		}else{
+        			inQuotes = !inQuotes;
+
+        			// the tricky case of an embedded quote in the middle: a,bc"d"ef,g
+                    if (!strictQuotes) {
+                        if(i>2 //not on the beginning of the line
+                                && nextLine.charAt(i-1) != this.separator //not at the beginning of an escape sequence
+                                && nextLine.length()>(i+1) &&
+                                nextLine.charAt(i+1) != this.separator //not at the	end of an escape sequence
+                        ){
+
+                            if (ignoreLeadingWhiteSpace && sb.length() > 0 && isAllWhiteSpace(sb)) {
+                                sb = new StringBuilder(INITIAL_READ_SIZE);  //discard white space leading up to quote
+                            } else {
+                                sb.append(c);
+                            }
+  
+                        }
+                    }
+        		}
+                inField = !inField;
+        	} else if (c == separator && !inQuotes) {
+        		tokensOnThisLine.add(sb.toString());
+        		sb = new StringBuilder(INITIAL_READ_SIZE); // start work on next token
+                inField = false;
+        	} else {
+                if (!strictQuotes || inQuotes){
+                    sb.append(c);
+                    inField = true;
+                }
+        	}
+        }
+        // line is done - check status
+        if (inQuotes) {
+        	if (multi) {
+        		// continuing a quoted section, re-append newline
+        		sb.append("\n");
+        		pending = sb.toString();
+        		sb = null; // this partial content is not to be added to field list yet
+        	} else {
+        		throw new IOException("Un-terminated quoted field at end of CSV line");
+        	}
+        }
+        if (sb != null) {
+        	tokensOnThisLine.add(sb.toString());
+        }
+        return tokensOnThisLine.toArray(new String[tokensOnThisLine.size()]);
+        
+    }
+    
+    /**  
+     * precondition: the current character is a quote or an escape
+	 * @param nextLine the current line
+	 * @param inQuotes true if the current context is quoted
+	 * @param i current index in line
+	 * @return true if the following character is a quote
+	 */
+	private boolean isNextCharacterEscapedQuote(String nextLine, boolean inQuotes, int i) {
+		return inQuotes  // we are in quotes, therefore there can be escaped quotes in here.
+		    && nextLine.length() > (i+1)  // there is indeed another character to check.
+		    && nextLine.charAt(i+1) == quotechar;
+	}
+
+	/**  
+	 * precondition: the current character is an escape
+	 * @param nextLine the current line
+	 * @param inQuotes true if the current context is quoted
+	 * @param i current index in line
+	 * @return true if the following character is a quote
+	 */
+	protected boolean isNextCharacterEscapable(String nextLine, boolean inQuotes, int i) {
+		return inQuotes  // we are in quotes, therefore there can be escaped quotes in here.
+		    && nextLine.length() > (i+1)  // there is indeed another character to check.
+		    && ( nextLine.charAt(i+1) == quotechar || nextLine.charAt(i+1) == this.escape);
+	}
+	
+	/**
+	 * precondition: sb.length() > 0
+	 * @param sb A sequence of characters to examine
+	 * @return true if every character in the sequence is whitespace
+	 */
+    protected boolean isAllWhiteSpace(CharSequence sb) {
+        boolean result = true;
+        for (int i = 0; i < sb.length(); i++) {
+            char c = sb.charAt(i);
+
+            if ( !Character.isWhitespace(c) ) {
+                return false;
+            }
+        }
+        return result;
+    }
+}

src/au/com/bytecode/opencsv/CSVReader.java

@@ -0,0 +1,282 @@
+package au.com.bytecode.opencsv;
+
+/**
+ Copyright 2005 Bytecode Pty Ltd.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import java.io.BufferedReader;
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A very simple CSV reader released under a commercial-friendly license.
+ * 
+ * @author Glen Smith
+ * 
+ */
+public class CSVReader implements Closeable {
+
+    private BufferedReader br;
+
+    private boolean hasNext = true;
+
+    private CSVParser parser;
+    
+    private int skipLines;
+
+    private boolean linesSkiped;
+
+    /**
+     * The default line to start reading.
+     */
+    public static final int DEFAULT_SKIP_LINES = 0;
+
+    /**
+     * Constructs CSVReader using a comma for the separator.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     */
+    public CSVReader(Reader reader) {
+        this(reader, CSVParser.DEFAULT_SEPARATOR, CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries.
+     */
+    public CSVReader(Reader reader, char separator) {
+        this(reader, separator, CSVParser.DEFAULT_QUOTE_CHARACTER, CSVParser.DEFAULT_ESCAPE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     */
+    public CSVReader(Reader reader, char separator, char quotechar) {
+        this(reader, separator, quotechar, CSVParser.DEFAULT_ESCAPE_CHARACTER, DEFAULT_SKIP_LINES, CSVParser.DEFAULT_STRICT_QUOTES);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator, quote char and quote handling
+     * behavior.
+     *
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param strictQuotes
+     *            sets if characters outside the quotes are ignored
+     */
+    public CSVReader(Reader reader, char separator, char quotechar, boolean strictQuotes) {
+        this(reader, separator, quotechar, CSVParser.DEFAULT_ESCAPE_CHARACTER, DEFAULT_SKIP_LINES, strictQuotes);
+    }
+
+   /**
+     * Constructs CSVReader with supplied separator and quote char.
+     *
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     */
+
+    public CSVReader(Reader reader, char separator,
+			char quotechar, char escape) {
+        this(reader, separator, quotechar, escape, DEFAULT_SKIP_LINES, CSVParser.DEFAULT_STRICT_QUOTES);
+	}
+    
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param line
+     *            the line number to skip for start reading 
+     */
+    public CSVReader(Reader reader, char separator, char quotechar, int line) {
+        this(reader, separator, quotechar, CSVParser.DEFAULT_ESCAPE_CHARACTER, line, CSVParser.DEFAULT_STRICT_QUOTES);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     *
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     * @param line
+     *            the line number to skip for start reading
+     */
+    public CSVReader(Reader reader, char separator, char quotechar, char escape, int line) {
+        this(reader, separator, quotechar, escape, line, CSVParser.DEFAULT_STRICT_QUOTES);
+    }
+    
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     * @param line
+     *            the line number to skip for start reading
+     * @param strictQuotes
+     *            sets if characters outside the quotes are ignored
+     */
+    public CSVReader(Reader reader, char separator, char quotechar, char escape, int line, boolean strictQuotes) {
+        this(reader, separator, quotechar, escape, line, strictQuotes, CSVParser.DEFAULT_IGNORE_LEADING_WHITESPACE);
+    }
+
+    /**
+     * Constructs CSVReader with supplied separator and quote char.
+     * 
+     * @param reader
+     *            the reader to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escape
+     *            the character to use for escaping a separator or quote
+     * @param line
+     *            the line number to skip for start reading
+     * @param strictQuotes
+     *            sets if characters outside the quotes are ignored
+     * @param ignoreLeadingWhiteSpace
+     *            it true, parser should ignore white space before a quote in a field
+     */
+    public CSVReader(Reader reader, char separator, char quotechar, char escape, int line, boolean strictQuotes, boolean ignoreLeadingWhiteSpace) {
+        this.br = new BufferedReader(reader);
+        this.parser = new CSVParser(separator, quotechar, escape, strictQuotes, ignoreLeadingWhiteSpace);
+        this.skipLines = line;
+    }
+
+	/**
+     * Reads the entire file into a List with each element being a String[] of
+     * tokens.
+     * 
+     * @return a List of String[], with each String[] representing a line of the
+     *         file.
+     * 
+     * @throws IOException
+     *             if bad things happen during the read
+     */
+    public List<String[]> readAll() throws IOException {
+
+        List<String[]> allElements = new ArrayList<String[]>();
+        while (hasNext) {
+            String[] nextLineAsTokens = readNext();
+            if (nextLineAsTokens != null)
+                allElements.add(nextLineAsTokens);
+        }
+        return allElements;
+
+    }
+
+    /**
+     * Reads the next line from the buffer and converts to a string array.
+     * 
+     * @return a string array with each comma-separated element as a separate
+     *         entry.
+     * 
+     * @throws IOException
+     *             if bad things happen during the read
+     */
+    public String[] readNext() throws IOException {
+    	
+    	String[] result = null;
+    	do {
+    		String nextLine = getNextLine();
+    		if (!hasNext) {
+    			return result; // should throw if still pending?
+    		}
+    		String[] r = parser.parseLineMulti(nextLine);
+    		if (r.length > 0) {
+    			if (result == null) {
+    				result = r;
+    			} else {
+    				String[] t = new String[result.length+r.length];
+    				System.arraycopy(result, 0, t, 0, result.length);
+    				System.arraycopy(r, 0, t, result.length, r.length);
+    				result = t;
+    			}
+    		}
+    	} while (parser.isPending());
+    	return result;
+    }
+
+    /**
+     * Reads the next line from the file.
+     * 
+     * @return the next line from the file without trailing newline
+     * @throws IOException
+     *             if bad things happen during the read
+     */
+    private String getNextLine() throws IOException {
+    	if (!this.linesSkiped) {
+            for (int i = 0; i < skipLines; i++) {
+                br.readLine();
+            }
+            this.linesSkiped = true;
+        }
+        String nextLine = br.readLine();
+        if (nextLine == null) {
+            hasNext = false;
+        }
+        return hasNext ? nextLine : null;
+    }
+
+    /**
+     * Closes the underlying reader.
+     * 
+     * @throws IOException if the close fails
+     */
+    public void close() throws IOException{
+    	br.close();
+    }
+    
+}

src/au/com/bytecode/opencsv/CSVWriter.java

@@ -0,0 +1,302 @@
+package au.com.bytecode.opencsv;
+
+/**
+ Copyright 2005 Bytecode Pty Ltd.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.Writer;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.List;
+
+/**
+ * A very simple CSV writer released under a commercial-friendly license.
+ *
+ * @author Glen Smith
+ *
+ */
+public class CSVWriter implements Closeable {
+    
+    public static final int INITIAL_STRING_SIZE = 128;
+
+	private Writer rawWriter;
+
+    private PrintWriter pw;
+
+    private char separator;
+
+    private char quotechar;
+    
+    private char escapechar;
+    
+    private String lineEnd;
+
+    /** The character used for escaping quotes. */
+    public static final char DEFAULT_ESCAPE_CHARACTER = '"';
+
+    /** The default separator to use if none is supplied to the constructor. */
+    public static final char DEFAULT_SEPARATOR = ',';
+
+    /**
+     * The default quote character to use if none is supplied to the
+     * constructor.
+     */
+    public static final char DEFAULT_QUOTE_CHARACTER = '"';
+    
+    /** The quote constant to use when you wish to suppress all quoting. */
+    public static final char NO_QUOTE_CHARACTER = '\u0000';
+    
+    /** The escape constant to use when you wish to suppress all escaping. */
+    public static final char NO_ESCAPE_CHARACTER = '\u0000';
+    
+    /** Default line terminator uses platform encoding. */
+    public static final String DEFAULT_LINE_END = "\n";
+
+    private ResultSetHelper resultService = new ResultSetHelperService();
+    
+    /**
+     * Constructs CSVWriter using a comma for the separator.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     */
+    public CSVWriter(Writer writer) {
+        this(writer, DEFAULT_SEPARATOR);
+    }
+
+    /**
+     * Constructs CSVWriter with supplied separator.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries.
+     */
+    public CSVWriter(Writer writer, char separator) {
+        this(writer, separator, DEFAULT_QUOTE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVWriter with supplied separator and quote char.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     */
+    public CSVWriter(Writer writer, char separator, char quotechar) {
+    	this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER);
+    }
+
+    /**
+     * Constructs CSVWriter with supplied separator and quote char.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escapechar
+     *            the character to use for escaping quotechars or escapechars
+     */
+    public CSVWriter(Writer writer, char separator, char quotechar, char escapechar) {
+        this(writer, separator, quotechar, escapechar, DEFAULT_LINE_END);
+    }
+    
+    
+    /**
+     * Constructs CSVWriter with supplied separator and quote char.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param lineEnd
+     * 			  the line feed terminator to use
+     */
+    public CSVWriter(Writer writer, char separator, char quotechar, String lineEnd) {
+        this(writer, separator, quotechar, DEFAULT_ESCAPE_CHARACTER, lineEnd);
+    }   
+    
+    
+    
+    /**
+     * Constructs CSVWriter with supplied separator, quote char, escape char and line ending.
+     *
+     * @param writer
+     *            the writer to an underlying CSV source.
+     * @param separator
+     *            the delimiter to use for separating entries
+     * @param quotechar
+     *            the character to use for quoted elements
+     * @param escapechar
+     *            the character to use for escaping quotechars or escapechars
+     * @param lineEnd
+     * 			  the line feed terminator to use
+     */
+    public CSVWriter(Writer writer, char separator, char quotechar, char escapechar, String lineEnd) {
+        this.rawWriter = writer;
+        this.pw = new PrintWriter(writer);
+        this.separator = separator;
+        this.quotechar = quotechar;
+        this.escapechar = escapechar;
+        this.lineEnd = lineEnd;
+    }
+    
+    /**
+     * Writes the entire list to a CSV file. The list is assumed to be a
+     * String[]
+     *
+     * @param allLines
+     *            a List of String[], with each String[] representing a line of
+     *            the file.
+     */
+    public void writeAll(List<String[]> allLines)  {
+    	for (String[] line : allLines) {
+			writeNext(line);
+		}
+    }
+
+    protected void writeColumnNames(ResultSet rs)
+    	throws SQLException {
+
+    	writeNext(resultService.getColumnNames(rs));
+    }
+    
+    /**
+     * Writes the entire ResultSet to a CSV file.
+     *
+     * The caller is responsible for closing the ResultSet.
+     *
+     * @param rs the recordset to write
+     * @param includeColumnNames true if you want column names in the output, false otherwise
+     *
+     * @throws java.io.IOException thrown by getColumnValue
+     * @throws java.sql.SQLException thrown by getColumnValue
+     */
+    public void writeAll(java.sql.ResultSet rs, boolean includeColumnNames)  throws SQLException, IOException {
+    	
+    	
+    	if (includeColumnNames) {
+			writeColumnNames(rs);
+		}
+    	
+    	while (rs.next())
+    	{
+    		writeNext(resultService.getColumnValues(rs));
+    	}
+    }
+
+    
+    /**
+     * Writes the next line to the file.
+     *
+     * @param nextLine
+     *            a string array with each comma-separated element as a separate
+     *            entry.
+     */
+    public void writeNext(String[] nextLine) {
+    	
+    	if (nextLine == null)
+    		return;
+    	
+        StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
+        for (int i = 0; i < nextLine.length; i++) {
+
+            if (i != 0) {
+                sb.append(separator);
+            }
+
+            String nextElement = nextLine[i];
+            if (nextElement == null)
+                continue;
+            if (quotechar !=  NO_QUOTE_CHARACTER)
+            	sb.append(quotechar);
+            
+            sb.append(stringContainsSpecialCharacters(nextElement) ? processLine(nextElement) : nextElement);
+
+            if (quotechar != NO_QUOTE_CHARACTER)
+            	sb.append(quotechar);
+        }
+        
+        sb.append(lineEnd);
+        pw.write(sb.toString());
+
+    }
+
+	private boolean stringContainsSpecialCharacters(String line) {
+	    return line.indexOf(quotechar) != -1 || line.indexOf(escapechar) != -1;
+    }
+
+	protected StringBuilder processLine(String nextElement)
+    {
+		StringBuilder sb = new StringBuilder(INITIAL_STRING_SIZE);
+	    for (int j = 0; j < nextElement.length(); j++) {
+	        char nextChar = nextElement.charAt(j);
+	        if (escapechar != NO_ESCAPE_CHARACTER && nextChar == quotechar) {
+	        	sb.append(escapechar).append(nextChar);
+	        } else if (escapechar != NO_ESCAPE_CHARACTER && nextChar == escapechar) {
+	        	sb.append(escapechar).append(nextChar);
+	        } else {
+	            sb.append(nextChar);
+	        }
+	    }
+	    
+	    return sb;
+    }
+
+    /**
+     * Flush underlying stream to writer.
+     * 
+     * @throws IOException if bad things happen
+     */
+    public void flush() throws IOException {
+
+        pw.flush();
+
+    } 
+
+    /**
+     * Close the underlying stream writer flushing any buffered content.
+     *
+     * @throws IOException if bad things happen
+     *
+     */
+    public void close() throws IOException {
+        flush();
+        pw.close();
+        rawWriter.close();
+    }
+
+    /**
+     *  Checks to see if the there has been an error in the printstream. 
+     */
+    public boolean checkError() {
+        return pw.checkError();
+    }
+
+    public void setResultService(ResultSetHelper resultService) {
+        this.resultService = resultService;
+    }
+
+}

src/au/com/bytecode/opencsv/ResultSetHelper.java

@@ -0,0 +1,33 @@
+package au.com.bytecode.opencsv;
+/**
+ Copyright 2005 Bytecode Pty Ltd.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+
+import java.io.IOException;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+/**
+ * 
+ * 
+ * 
+ * 
+ * 
+ */
+public interface ResultSetHelper {
+    public String[] getColumnNames(ResultSet rs) throws SQLException;
+
+    public String[] getColumnValues(ResultSet rs) throws SQLException, IOException;
+}

src/au/com/bytecode/opencsv/ResultSetHelperService.java

@@ -0,0 +1,183 @@
+package au.com.bytecode.opencsv;
+/**
+ Copyright 2005 Bytecode Pty Ltd.
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ */
+import java.io.IOException;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.sql.*;
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 
+ * 
+ *  helper class for processing JDBC ResultSet objects
+ * 
+ * 
+ */
+public class ResultSetHelperService implements ResultSetHelper {
+    public static final int CLOBBUFFERSIZE = 2048;
+    
+    // note: we want to maintain compatibility with Java 5 VM's
+    // These types don't exist in Java 5
+	private static final int NVARCHAR = -9;
+	private static final int NCHAR = -15; 
+	private static final int LONGNVARCHAR = -16;
+	private static final int NCLOB = 2011;
+
+    public String[] getColumnNames(ResultSet rs) throws SQLException {
+        List<String> names = new ArrayList<String>();
+        ResultSetMetaData metadata = rs.getMetaData();
+
+        for (int i = 0; i < metadata.getColumnCount(); i++) {
+            names.add(metadata.getColumnName(i+1));
+        }
+
+        String[] nameArray = new String[names.size()];
+        return names.toArray(nameArray);
+    }
+
+    public String[] getColumnValues(ResultSet rs) throws SQLException, IOException {
+
+        List<String> values = new ArrayList<String>();
+        ResultSetMetaData metadata = rs.getMetaData();
+
+        for (int i = 0; i < metadata.getColumnCount(); i++) {
+            values.add(getColumnValue(rs, metadata.getColumnType(i + 1), i + 1));
+        }
+
+        String[] valueArray = new String[values.size()];
+        return values.toArray(valueArray);
+    }
+
+    private String handleObject(Object obj){
+        return obj == null ? "" : String.valueOf(obj);
+    }
+
+    private String handleBigDecimal(BigDecimal decimal) {
+        return decimal == null ? "" : decimal.toString();
+    }
+
+    private String handleLong(ResultSet rs, int columnIndex) throws SQLException {
+        long lv = rs.getLong(columnIndex);
+        return rs.wasNull() ? "" : Long.toString(lv);
+    }
+
+    private String handleInteger(ResultSet rs, int columnIndex) throws SQLException {
+        int i = rs.getInt(columnIndex);
+        return rs.wasNull() ? "" : Integer.toString(i);
+    }
+
+    private String handleDate(ResultSet rs, int columnIndex) throws SQLException {
+        java.sql.Date date = rs.getDate(columnIndex);
+        String value = null;
+        if (date != null) {
+            SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy");
+            value =  dateFormat.format(date);
+        }
+        return value;
+    }
+
+    private String handleTime(Time time) {
+        return time == null ? null : time.toString();
+    }
+
+    private String handleTimestamp(Timestamp timestamp) {
+        SimpleDateFormat timeFormat = new SimpleDateFormat("dd-MMM-yyyy HH:mm:ss");
+        return timestamp == null ? null : timeFormat.format(timestamp);
+    }
+
+    private String getColumnValue(ResultSet rs, int colType, int colIndex)
+    		throws SQLException, IOException {
+
+    	String value = "";
+
+		switch (colType)
+		{
+			case Types.BIT:
+            case Types.JAVA_OBJECT:
+				value = handleObject(rs.getObject(colIndex));
+			    break;
+			case Types.BOOLEAN:
+				boolean b = rs.getBoolean(colIndex);
+				value = Boolean.valueOf(b).toString();
+			    break;
+			case NCLOB: // todo : use rs.getNClob
+			case Types.CLOB:
+				Clob c = rs.getClob(colIndex);
+				if (c != null) {
+					value = read(c);
+				}
+			    break;
+			case Types.BIGINT:
+				value = handleLong(rs, colIndex);
+				break;
+			case Types.DECIMAL:
+			case Types.DOUBLE:
+			case Types.FLOAT:
+			case Types.REAL:
+			case Types.NUMERIC:
+				value = handleBigDecimal(rs.getBigDecimal(colIndex));
+			    break;
+			case Types.INTEGER:
+			case Types.TINYINT:
+			case Types.SMALLINT:
+                value = handleInteger(rs, colIndex);
+			    break;
+			case Types.DATE:
+				value = handleDate(rs, colIndex);
+			    break;
+			case Types.TIME:
+				value = handleTime(rs.getTime(colIndex));
+			    break;
+			case Types.TIMESTAMP:
+				value = handleTimestamp(rs.getTimestamp(colIndex));
+			    break;
+			case NVARCHAR: // todo : use rs.getNString
+			case NCHAR: // todo : use rs.getNString
+			case LONGNVARCHAR: // todo : use rs.getNString
+			case Types.LONGVARCHAR:
+			case Types.VARCHAR:
+			case Types.CHAR:
+				value = rs.getString(colIndex);
+			    break;
+			default:
+				value = "";
+		}
+
+
+		if (value == null)
+		{
+			value = "";
+		}
+
+		return value;
+
+    }
+
+    private static String read(Clob c) throws SQLException, IOException
+	{
+		StringBuilder sb = new StringBuilder( (int) c.length());
+		Reader r = c.getCharacterStream();
+		char[] cbuf = new char[CLOBBUFFERSIZE];
+		int n;
+		while ((n = r.read(cbuf, 0, cbuf.length)) != -1) {
+				sb.append(cbuf, 0, n);
+		}
+		return sb.toString();
+	}
+}

src/com/sk89q/worldguard/LocalPlayer.java

@@ -0,0 +1,51 @@
+// $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;
+
+public abstract class LocalPlayer {
+    /**
+     * Get a player's name.
+     * 
+     * @return
+     */
+    public abstract String getName();
+    
+    /**
+     * Returns true if the player is inside a group.
+     * 
+     * @param group
+     * @return
+     */
+    public abstract boolean hasGroup(String group);
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof LocalPlayer)) {
+            return false;
+        }
+        
+        return ((LocalPlayer)obj).getName().equals(getName());
+    }
+    
+    @Override
+    public int hashCode() {
+        return getName().hashCode();
+    }
+}

src/com/sk89q/worldguard/domains/DefaultDomain.java

@@ -0,0 +1,108 @@
+// $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.domains;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.LinkedHashSet;
+import java.util.Set;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class DefaultDomain implements Domain {
+    private Set<String> groups;
+    private Set<String> players;
+    
+    public DefaultDomain() {
+        this.groups = new LinkedHashSet<String>();
+        this.players = new HashSet<String>();
+    }
+    
+    public void addPlayer(String name) {
+        players.add(name.toLowerCase());
+    }
+    
+    public void addPlayer(LocalPlayer player) {
+        players.add(player.getName().toLowerCase());
+    }
+    
+    public void removePlayer(String name) {
+        players.remove(name.toLowerCase());
+    }
+    
+    public void removePlayer(LocalPlayer player) {
+        players.remove(player.getName().toLowerCase());
+    }
+    
+    public void addGroup(String name) {
+        groups.add(name.toLowerCase());
+    }
+    
+    public void removeGroup(String name) {
+        groups.remove(name.toLowerCase());
+    }
+    
+    public Set<String> getGroups() {
+        return groups;
+    }
+    
+    public Set<String> getPlayers() {
+        return players;
+    }
+
+    public boolean contains(LocalPlayer player) {
+        if (players.contains(player.getName().toLowerCase())) {
+            return true;
+        }
+        
+        for (String group : groups) {
+            if (player.hasGroup(group)) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    public int size() {
+        return groups.size();
+    }
+    
+    public String toPlayersString() {
+        StringBuilder str = new StringBuilder();
+        for (Iterator<String> it = players.iterator(); it.hasNext(); ) {
+            str.append(it.next());
+            if (it.hasNext()) {
+                str.append(", ");
+            }
+        }
+        return str.toString();
+    }
+    
+    public String toGroupsString() {
+        StringBuilder str = new StringBuilder();
+        for (Iterator<String> it = groups.iterator(); it.hasNext(); ) {
+            str.append(it.next());
+            if (it.hasNext()) {
+                str.append(", ");
+            }
+        }
+        return str.toString();
+    }
+}

src/com/sk89q/worldguard/domains/Domain.java

@@ -0,0 +1,13 @@
+package com.sk89q.worldguard.domains;
+
+import com.sk89q.worldguard.LocalPlayer;
+
+public interface Domain {
+    /**
+     * Returns true if a domain contains a player.
+     * 
+     * @param player
+     * @return
+     */
+    public boolean contains(LocalPlayer player);
+}

src/com/sk89q/worldguard/domains/DomainCollection.java

@@ -0,0 +1,55 @@
+// $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.domains;
+
+import java.util.Set;
+import java.util.LinkedHashSet;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class DomainCollection implements Domain {
+    private Set<Domain> domains;
+    
+    public DomainCollection() {
+        domains = new LinkedHashSet<Domain>();
+    }
+    
+    public void add(Domain domain) {
+        domains.add(domain);
+    }
+    
+    public void remove(Domain domain) {
+        domains.remove(domain);
+    }
+    
+    public int size() {
+        return domains.size();
+    }
+
+    public boolean contains(LocalPlayer player) {
+        for (Domain domain : domains) {
+            if (domain.contains(player)) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+
+}

src/com/sk89q/worldguard/domains/GroupDomain.java

@@ -0,0 +1,56 @@
+// $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.domains;
+
+import java.util.Arrays;
+import java.util.Set;
+import java.util.LinkedHashSet;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class GroupDomain implements Domain {
+    private Set<String> groups;
+    
+    public GroupDomain() {
+        this.groups = new LinkedHashSet<String>();
+    }
+    
+    public GroupDomain(String[] groups) {
+        this.groups = new LinkedHashSet<String>(Arrays.asList(groups));
+    }
+    
+    public void addGroup(String name) {
+        groups.add(name);
+    }
+
+    public boolean contains(LocalPlayer player) {
+        for (String group : groups) {
+            if (player.hasGroup(group)) {
+                return true;
+            }
+        }
+        
+        return false;
+    }
+    
+    public int size() {
+        return groups.size();
+    }
+
+}

src/com/sk89q/worldguard/domains/PlayerDomain.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.domains;
+
+import java.util.Set;
+import java.util.HashSet;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class PlayerDomain implements Domain {
+    private Set<String> players;
+    
+    public PlayerDomain() {
+        this.players = new HashSet<String>();
+    }
+    
+    public PlayerDomain(String[] players) {
+        this.players = new HashSet<String>();
+        
+        for (String name : players) {
+            this.players.add(name.toLowerCase());
+        }
+    }
+    
+    public void addPlayer(String name) {
+        players.add(name.toLowerCase());
+    }
+    
+    public boolean contains(LocalPlayer player) {
+        return players.contains(player.getName().toLowerCase());
+    }
+    
+    public int size() {
+        return players.size();
+    }
+
+}

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

@@ -0,0 +1,125 @@
+// $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;
+
+import java.util.Map;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.protection.AreaFlags.State;
+
+/**
+ * Represents a set of regions and their rules as applied to one point.
+ * 
+ * @author sk89q
+ */
+public class ApplicableRegionSet {
+    private Vector pt;
+    private Map<String,ProtectedRegion> regions;
+    
+    public ApplicableRegionSet(Vector pt, Map<String,ProtectedRegion> regions) {
+        this.pt = pt;
+        this.regions = regions;
+    }
+    
+    public boolean canBuild(LocalPlayer player) {
+        boolean allowed = false;
+        boolean found = false;
+        
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowBuild == State.DENY) return false;
+            
+            found = true;
+
+            if (!allowed && region.getFlags().allowBuild == State.ALLOW) {
+                allowed = true;
+            }
+            
+            if (!allowed && region.getOwners().contains(player)) {
+                allowed = true;
+            }
+        }
+        
+        return found ? allowed : true;
+    }
+    
+    public boolean allowsPvP() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowBuild == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsMobDamage() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowMobDamage == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsCreeperExplosions() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowCreeperExplosions == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsTNT() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowTNT == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsLighter() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowLighter == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsFireSpread() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowFireSpread == State.DENY) return false;
+        }
+        
+        return true;
+    }
+    
+    public boolean allowsLavaFire() {
+        for (ProtectedRegion region : regions.values()) {
+            if (!region.contains(pt)) continue;
+            if (region.getFlags().allowLavaFire == State.DENY) return false;
+        }
+        
+        return true;
+    }
+}

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

@@ -0,0 +1,59 @@
+// $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;
+
+/**
+ * 
+ * @author sk89q
+ */
+public class AreaFlags {
+    public enum State {
+        NONE,
+        ALLOW,
+        DENY,
+    };
+
+    public State allowBuild = State.NONE;
+    public State allowPvP = State.NONE;
+    public State allowMobDamage = State.NONE;
+    public State allowCreeperExplosions = State.NONE;
+    public State allowTNT = State.NONE;
+    public State allowLighter = State.NONE;
+    public State allowFireSpread = State.NONE;
+    public State allowLavaFire = State.NONE;
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AreaFlags)) {
+            return false;
+        }
+        
+        AreaFlags other = (AreaFlags)obj;
+        
+        return other.allowBuild == allowBuild
+                && other.allowPvP == allowPvP
+                && other.allowMobDamage == allowMobDamage
+                && other.allowCreeperExplosions == allowCreeperExplosions
+                && other.allowTNT == allowTNT
+                && other.allowLighter == allowLighter
+                && other.allowFireSpread == allowFireSpread
+                && other.allowLavaFire == allowLavaFire;
+    }
+}

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

@@ -0,0 +1,333 @@
+// $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;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import java.io.*;
+
+import au.com.bytecode.opencsv.CSVReader;
+import au.com.bytecode.opencsv.CSVWriter;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldguard.domains.DefaultDomain;
+import com.sk89q.worldguard.protection.AreaFlags.State;
+
+/**
+ * Represents a protected area database that uses CSV files.
+ * 
+ * @author sk89q
+ */
+public class CSVDatabase implements ProtectionDatabase {
+    private static Logger logger = Logger.getLogger("Minecraft.WorldGuard");
+    
+    /**
+     * References the CSV file.
+     */
+    private File file;
+    /**
+     * Holds the list of regions.
+     */
+    private Map<String,ProtectedRegion> regions;
+    
+    /**
+     * Construct the database with a path to a file. No file is read or
+     * written at this time.
+     * 
+     * @param file
+     */
+    public CSVDatabase(File file) {
+        this.file = file;
+    }
+
+    /**
+     * Saves the database.
+     */
+    @Override
+    public void save() throws IOException {
+        CSVWriter writer = new CSVWriter(new FileWriter(file));
+        
+        try {
+            for (Map.Entry<String,ProtectedRegion> entry : regions.entrySet()) {
+                String id = entry.getKey();
+                ProtectedRegion region = entry.getValue();
+                
+                if (!(region instanceof ProtectedCuboidRegion)) {
+                    logger.warning("The CSV database only supports cuboid regions.");
+                    continue;
+                }
+                
+                ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion)region;
+                BlockVector min = cuboid.getMinimumPoint();
+                BlockVector max = cuboid.getMaximumPoint();
+                
+                writer.writeNext(new String[] {
+                        id,
+                        "cuboid",
+                        String.valueOf(min.getBlockX()),
+                        String.valueOf(min.getBlockY()),
+                        String.valueOf(min.getBlockZ()),
+                        String.valueOf(max.getBlockX()),
+                        String.valueOf(max.getBlockY()),
+                        String.valueOf(max.getBlockZ()),
+                        String.valueOf(cuboid.getPriority()),
+                        writeDomains(cuboid.getOwners()),
+                        writeFlags(cuboid.getFlags()),
+                        cuboid.getEnterMessage(),
+                        });
+            }
+        } finally {
+            try {
+                writer.close();
+            } catch (IOException e) {
+            }
+        }
+    }
+
+    /**
+     * Load the database from file.
+     */
+    @Override
+    public void load() throws IOException {
+        Map<String,ProtectedRegion> regions =
+                new HashMap<String,ProtectedRegion>();
+        
+        CSVReader reader = new CSVReader(new FileReader(file));
+        
+        try {
+            String[] line;
+            
+            while ((line = reader.readNext()) != null) {
+                if (line.length >= 12) {
+                    String type = line[1];
+                    if (!type.equalsIgnoreCase("cuboid")) {
+                        logger.warning("Only cuboid region types are supported: "
+                                + line);
+                        break;
+                        
+                    }
+                    
+                    String id = line[0];
+                    BlockVector min = new BlockVector(
+                            Integer.parseInt(line[2]),
+                            Integer.parseInt(line[3]),
+                            Integer.parseInt(line[4]));
+                    BlockVector max = new BlockVector(
+                            Integer.parseInt(line[5]),
+                            Integer.parseInt(line[6]),
+                            Integer.parseInt(line[7]));
+                    int priority = Integer.parseInt(line[8]);
+                    String ownersData = line[9];
+                    String flagsData = line[10];
+                    String enterMessage = line[11];
+                    
+                    ProtectedRegion region = new ProtectedCuboidRegion(min, max);
+                    region.setPriority(priority);
+                    region.setOwners(this.parseDomains(ownersData));
+                    region.setEnterMessage(enterMessage);
+                    region.setFlags(parseFlags(flagsData));
+                    regions.put(id, region);
+                } else {
+                    logger.warning("Line has invalid: " + line);
+                }
+            }
+        } finally {
+            try {
+                reader.close();
+            } catch (IOException e) {
+            }
+        }
+        
+        this.regions = regions;
+    }
+
+    /**
+     * Load the list of regions into a region manager.
+     * 
+     * @throws IOException
+     */
+    public void load(RegionManager manager) throws IOException {
+        load();
+        manager.setRegions(regions);
+    }
+    
+    /**
+     * Save the list of regions from a region manager.
+     * 
+     * @throws IOException
+     */
+    public void save(RegionManager manager) throws IOException {
+        regions = manager.getRegions();
+        save();
+    }
+    
+    /**
+     * Used to parse the specified domain in the CSV file.
+     * 
+     * @param data
+     * @return
+     */
+    private DefaultDomain parseDomains(String data) {
+        DefaultDomain domain = new DefaultDomain();
+        Pattern pattern = Pattern.compile("^([A-Za-z]):(.*)$");
+        
+        String[] parts = data.split(",");
+        
+        for (String part : parts) {
+            Matcher matcher = pattern.matcher(part);
+            
+            if (!matcher.matches()) {
+                logger.warning("Invalid owner specification: " + part);
+                continue;
+            }
+
+            String type = matcher.group(1);
+            String id = matcher.group(2);
+
+            if (type.equals("u")) {
+                domain.addPlayer(id);
+            } else if (type.equals("g")) {
+                domain.addGroup(id);
+            } else {
+                logger.warning("Unknown owner specification: " + type);
+            }
+        }
+        
+        return domain;
+    }
+    
+    /**
+     * Used to parse the list of flags.
+     * 
+     * @param data
+     * @return
+     */
+    private AreaFlags parseFlags(String data) {
+        AreaFlags flags = new AreaFlags();
+        State curState = State.ALLOW;
+        
+        for (int i = 0; i < data.length(); i++) {
+            char flag = data.charAt(i);
+            if (flag == '+') {
+                curState = State.ALLOW;
+            } else if (flag == '-') {
+                curState = State.DENY;
+            } else if (flag == 'b') {
+                flags.allowBuild = curState;
+            } else if (flag == 'p') {
+                flags.allowPvP = curState;
+            } else if (flag == 'm') {
+                flags.allowMobDamage = curState;
+            } else if (flag == 'c') {
+                flags.allowCreeperExplosions = curState;
+            } else if (flag == 't') {
+                flags.allowTNT = curState;
+            } else if (flag == 'l') {
+                flags.allowLighter = curState;
+            } else if (flag == 'f') {
+                flags.allowFireSpread = curState;
+            } else if (flag == 'F') {
+                flags.allowLavaFire = curState;
+            } else {
+                logger.warning("Unknown area flag/flag modifier: " + flag);
+            }
+        }
+        
+        return flags;
+    }
+    
+    /**
+     * Used to write the list of domains.
+     * 
+     * @param domain
+     * @return
+     */
+    private String writeDomains(DefaultDomain domain) {
+        StringBuilder str = new StringBuilder();
+        
+        for (String player : domain.getPlayers()) {
+            str.append("u:" + player + ",");
+        }
+        
+        for (String group : domain.getGroups()) {
+            str.append("g:" + group + ",");
+        }
+        
+        return str.length() > 0 ?
+                str.toString().substring(0, str.length() - 1) : "";
+    }
+    
+    /**
+     * Helper method to prepend '+' or '-' in front of a flag according
+     * to the flag's state.
+     * 
+     * @param state
+     * @param flag
+     * @return
+     */
+    private String writeFlag(State state, String flag) {
+        if (state == State.ALLOW) {
+            return "+" + flag;
+        } else if (state == State.DENY) {
+            return "-" + flag;
+        }
+        
+        return "";
+    }
+    
+    /**
+     * Used to write the list of flags.
+     * 
+     * @param flags
+     * @return
+     */
+    private String writeFlags(AreaFlags flags) {
+        StringBuilder str = new StringBuilder();
+        str.append(writeFlag(flags.allowBuild, "b"));
+        str.append(writeFlag(flags.allowPvP, "p"));
+        str.append(writeFlag(flags.allowMobDamage, "m"));
+        str.append(writeFlag(flags.allowCreeperExplosions, "c"));
+        str.append(writeFlag(flags.allowTNT, "t"));
+        str.append(writeFlag(flags.allowLighter, "l"));
+        str.append(writeFlag(flags.allowFireSpread, "f"));
+        str.append(writeFlag(flags.allowLavaFire, "F"));
+        return str.toString();
+    }
+
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions() {
+        return regions;
+    }
+
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions) {
+        this.regions = regions;
+    }
+}

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

@@ -0,0 +1,41 @@
+// $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;
+
+/**
+ * Caches the results of the protection to prevent necessary lookups.
+ * 
+ * @author sk89q
+ */
+public class CacheManager {
+    /**
+     * Region manager.
+     */
+    private RegionManager manager;
+    
+    /**
+     * Construct the object.
+     * 
+     * @param manager
+     */
+    public CacheManager(RegionManager manager) {
+        this.manager = manager;
+    }
+}

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

@@ -0,0 +1,140 @@
+// $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;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.LinkedHashMap;
+import com.sk89q.worldedit.Vector;
+
+/**
+ * A very simple implementation of the region manager that uses a flat list
+ * and iterates through the list to identify applicable regions. This method
+ * is not very efficient.
+ * 
+ * @author sk89q
+ */
+public class FlatRegionManager implements RegionManager {
+    /**
+     * List of protected regions.
+     */
+    private Map<String,ProtectedRegion> regions;
+    
+    /**
+     * Construct the manager.
+     */
+    public FlatRegionManager() {
+        regions = new LinkedHashMap<String,ProtectedRegion>();
+    }
+    
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions() {
+        return regions;
+    }
+    
+    /**
+     * Adds a region.
+     * 
+     * @param id
+     * @param region
+     */
+    public void addRegion(String id, ProtectedRegion region) {
+        regions.put(id, region);
+    }
+    
+    /**
+     * Removes a region.
+     * 
+     * @param id
+     */
+    public void removeRegion(String id) {
+        regions.remove(id);
+    }
+    
+    /**
+     * Return whether a region exists by an ID.
+     * 
+     * @param id
+     * @return
+     */
+    public boolean hasRegion(String id) {
+        return regions.containsKey(id);
+    }
+    
+    /**
+     * Get a region by its ID.
+     * 
+     * @param id
+     */
+    public ProtectedRegion getRegion(String id) {
+        return regions.get(id);
+    }
+    
+    /**
+     * Set a list of protected regions.
+     *
+     * @return
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions) {
+        this.regions = regions;
+    }
+    
+    /**
+     * Get an object for a point for rules to be applied with.
+     * 
+     * @param pt
+     * @return
+     */
+    public ApplicableRegionSet getApplicableRegions(Vector pt) {
+        return new ApplicableRegionSet(pt, regions);
+    }
+    
+    /**
+     * Get a list of region IDs that contain a point.
+     * 
+     * @param pt
+     * @return
+     */
+    public List<String> getApplicableRegionsIDs(Vector pt) {
+        List<String> applicable = new ArrayList<String>();
+        
+        for (Map.Entry<String,ProtectedRegion> entry : regions.entrySet()) {
+            if (entry.getValue().contains(pt)) {
+                applicable.add(entry.getKey());
+            }
+        }
+        
+        return applicable;
+    }
+    
+    /**
+     * Get the number of regions.
+     * 
+     * @return
+     */
+    public int size() {
+        return regions.size();
+    }
+}

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

@@ -0,0 +1,97 @@
+// $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;
+
+import com.sk89q.worldedit.*;
+
+/**
+ * Represents a cuboid region that can be protected.
+ *
+ * @author sk89q
+ */
+public class ProtectedCuboidRegion extends ProtectedRegion {
+    /**
+     * Store the first point.
+     */
+    private BlockVector min;
+    /**
+     * Store the second point.
+     */
+    private BlockVector max;
+
+    /**
+     * Construct a new instance of this cuboid region.
+     *
+     * @param pos1
+     * @param pos2
+     * @param priority
+     */
+    public ProtectedCuboidRegion(BlockVector min, BlockVector max) {
+        super();
+        this.min = min;
+        this.max = max;
+    }
+
+    /**
+     * Get the lower point of the cuboid.
+     *
+     * @return min point
+     */
+    public BlockVector getMinimumPoint() {
+        return min;
+    }
+
+    /**
+     * Set the lower point of the cuboid.
+     *
+     * @param pt
+     */
+    public void setMinimumPoint(BlockVector pt) {
+        min = pt;
+    }
+
+    /**
+     * Get the upper point of the cuboid.
+     *
+     * @return max point
+     */
+    public BlockVector getMaximumPoint() {
+        return max;
+    }
+
+    /**
+     * Set the upper point of the cuboid.
+     *
+     * @param pt
+     */
+    public void setMaximumPoint(BlockVector pt) {
+        max = pt;
+    }
+
+    @Override
+    public boolean contains(Vector pt) {
+        int x = pt.getBlockX();
+        int y = pt.getBlockY();
+        int z = pt.getBlockZ();
+        return x >= min.getBlockX() && x <= max.getBlockX()
+                && y >= min.getBlockY() && y <= max.getBlockY()
+                && z >= min.getBlockZ() && z <= max.getBlockZ();
+    }
+}

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

@@ -0,0 +1,128 @@
+// $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;
+
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.domains.DefaultDomain;
+
+/**
+ * Represents a region of any shape and size that can be protected.
+ * 
+ * @author sk89q
+ */
+public abstract class ProtectedRegion {
+    /**
+     * Area message.
+     */
+    private String enterMessage;
+    /**
+     * List of owners.
+     */
+    private DefaultDomain owners = new DefaultDomain();
+    /**
+     * Priority.
+     */
+    private int priority = 0;
+    /**
+     * Area flags.
+     */
+    private AreaFlags flags = new AreaFlags();
+
+    /**
+     * Construct a new instance of this cuboid region.
+     *
+     * @param id
+     * @param priority
+     * @param owners
+     * @param enterMessage
+     */
+    public ProtectedRegion() {
+        this.priority = 0;
+        this.owners = new DefaultDomain();
+        this.enterMessage = null;
+    }
+
+    /**
+     * @return the priority
+     */
+    public int getPriority() {
+        return priority;
+    }
+
+    /**
+     * @param priority the priority to set
+     */
+    public void setPriority(int priority) {
+        this.priority = priority;
+    }
+    
+    /**
+     * Se flags.
+     * @param flags
+     */
+    public void setFlags(AreaFlags flags) {
+        this.flags = flags;
+    }
+    
+    /**
+     * @return the enterMessage
+     */
+    public String getEnterMessage() {
+        return enterMessage;
+    }
+
+    /**
+     * @param enterMessage the enterMessage to set
+     */
+    public void setEnterMessage(String enterMessage) {
+        this.enterMessage = enterMessage;
+    }
+
+    /**
+     * @return the owners
+     */
+    public DefaultDomain getOwners() {
+        return owners;
+    }
+
+    /**
+     * @param owners the owners to set
+     */
+    public void setOwners(DefaultDomain owners) {
+        this.owners = owners;
+    }
+
+    /**
+     * Get flags.
+     * 
+     * @return
+     */
+    public AreaFlags getFlags() {
+        return flags;
+    }
+    
+    /**
+     * Check to see if a point is inside this region.
+     * 
+     * @param pt
+     * @return
+     */
+    public abstract boolean contains(Vector pt);
+}

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

@@ -0,0 +1,68 @@
+// $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;
+
+import java.io.IOException;
+import java.util.Map;
+
+/**
+ * Represents a database to read and write lists of regions from and to.
+ * 
+ * @author sk89q
+ */
+public interface ProtectionDatabase {
+    /**
+     * Load the list of regions. The method should not modify the list returned
+     * by getRegions() unless the load finishes successfully.
+     * 
+     * @throws IOException
+     */
+    public void load() throws IOException;
+    /**
+     * Save the list of regions.
+     * 
+     * @throws IOException
+     */
+    public void save() throws IOException;
+    /**
+     * Load the list of regions into a region manager.
+     * 
+     * @throws IOException
+     */
+    public void load(RegionManager manager) throws IOException;
+    /**
+     * Save the list of regions from a region manager.
+     * 
+     * @throws IOException
+     */
+    public void save(RegionManager manager) throws IOException;
+    /**
+     * Get a list of regions.
+     * 
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions();
+    /**
+     * Set the list of regions.
+     * 
+     * @param regions
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions);
+}

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

@@ -0,0 +1,101 @@
+// $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;
+
+import java.util.List;
+import java.util.Map;
+import com.sk89q.worldedit.Vector;
+
+/**
+ * An interface for getting, setting, and looking up regions. The most
+ * simple implementation uses a flat list and iterates through the entire
+ * list to look for applicable regions, but a more complicated (and more
+ * efficient) implementation may use space partitioning techniques.
+ *
+ * @author sk89q
+ */
+public interface RegionManager {
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions();
+    
+    /**
+     * Set a list of protected regions.
+     *
+     * @return
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions);
+    
+    /**
+     * Adds a region.
+     * 
+     * @param id
+     * @param region
+     */
+    public void addRegion(String id, ProtectedRegion region);
+    
+    /**
+     * Return whether a region exists by an ID.
+     * 
+     * @param id
+     * @return
+     */
+    public boolean hasRegion(String id);
+    
+    /**
+     * Get a region by its ID.
+     * 
+     * @param id
+     */
+    public ProtectedRegion getRegion(String id);
+    
+    /**
+     * Removes a region.
+     * 
+     * @param id
+     */
+    public void removeRegion(String id);
+
+    /**
+     * Get an object for a point for rules to be applied with.
+     * 
+     * @param pt
+     * @return
+     */
+    public ApplicableRegionSet getApplicableRegions(Vector pt);
+    
+    /**
+     * Get a list of region IDs that contain a point.
+     * 
+     * @param pt
+     * @return
+     */
+    public List<String> getApplicableRegionsIDs(Vector pt);
+    
+    /**
+     * Get the number of regions.
+     * 
+     * @return
+     */
+    public int size();
+}

src/com/sk89q/worldprotect/ConsoleLogFormat.java

@@ -1,64 +0,0 @@
-// $Id$
-/*
- * WorldProtect
- * 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.worldprotect;
-
-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();
-    }
-}

tests/com/sk89q/worldguard/TestPlayer.java

@@ -0,0 +1,47 @@
+// $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.Set;
+import java.util.HashSet;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class TestPlayer extends LocalPlayer {
+    private String name;
+    private Set<String> groups = new HashSet<String>();
+    
+    public TestPlayer(String name) {
+        this.name = name;
+    }
+    
+    public void addGroup(String group) {
+        groups.add(group.toLowerCase());
+    }
+
+    @Override
+    public String getName() {
+        return name;
+    }
+
+    @Override
+    public boolean hasGroup(String group) {
+        return groups.contains(group.toLowerCase());
+    }
+}

tests/com/sk89q/worldguard/protection/ApplicableRegionSetTest.java

@@ -0,0 +1,130 @@
+// $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;
+
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.TestPlayer;
+import com.sk89q.worldguard.domains.DefaultDomain;
+
+public class ApplicableRegionSetTest {
+    static String COURTYARD_ID = "courtyard";
+    static String FOUNTAIN_ID = "fountain";
+    static String MEMBER_GROUP = "member";
+    static String COURTYARD_GROUP = "courtyard";
+
+    Vector inFountain = new Vector(2, 2, 2);
+    Vector inCourtyard = new Vector(7, 7, 7);
+    Vector outside = new Vector(15, 15, 15);
+    RegionManager manager;
+    TestPlayer player1;
+    TestPlayer player2;
+
+    @Before
+    public void setUp() throws Exception {
+        manager = new FlatRegionManager();
+
+        setUpPlayers();
+        setUpCourtyardRegion();
+        setUpFountainRegion();
+    }
+    
+    void setUpPlayers() {
+        player1 = new TestPlayer("tetsu");
+        player1.addGroup(MEMBER_GROUP);
+        player1.addGroup(COURTYARD_GROUP);
+
+        player2 = new TestPlayer("alex");
+        player2.addGroup(MEMBER_GROUP);
+    }
+    
+    void setUpCourtyardRegion() {
+        DefaultDomain domain = new DefaultDomain();
+        domain.addGroup(COURTYARD_GROUP);
+        
+        ProtectedRegion region = new ProtectedCuboidRegion(
+                new BlockVector(0, 0, 0), new BlockVector(10, 10, 10));
+        AreaFlags flags = new AreaFlags();
+        flags.allowBuild = AreaFlags.State.NONE;
+        flags.allowFireSpread = AreaFlags.State.ALLOW;
+        region.setFlags(flags);
+        region.setOwners(domain);
+        manager.addRegion(COURTYARD_ID, region);
+    }
+    
+    void setUpFountainRegion() {
+        ProtectedRegion region = new ProtectedCuboidRegion(
+                new BlockVector(0, 0, 0), new BlockVector(5, 5, 5));
+        AreaFlags flags = new AreaFlags();
+        flags.allowBuild = AreaFlags.State.ALLOW;
+        flags.allowFireSpread = AreaFlags.State.DENY;
+        region.setFlags(flags);
+        manager.addRegion(FOUNTAIN_ID, region);
+    }
+    
+    @Test
+    public void testNonBuildFlag() {        
+        ApplicableRegionSet appl;
+        
+        // Outside
+        appl = manager.getApplicableRegions(outside);
+        assertTrue(appl.allowsFireSpread());
+        // Inside courtyard
+        appl = manager.getApplicableRegions(inCourtyard);
+        assertTrue(appl.allowsFireSpread());
+        // Inside fountain
+        appl = manager.getApplicableRegions(inFountain);
+        assertFalse(appl.allowsFireSpread());
+    }
+    
+    @Test
+    public void testPlayer1BuildAccess() {        
+        ApplicableRegionSet appl;
+        
+        // Outside
+        appl = manager.getApplicableRegions(outside);
+        assertTrue(appl.canBuild(player1));
+        // Inside courtyard
+        appl = manager.getApplicableRegions(inCourtyard);
+        assertTrue(appl.canBuild(player1));
+        // Inside fountain
+        appl = manager.getApplicableRegions(inFountain);
+        assertTrue(appl.canBuild(player1));
+    }
+    
+    @Test
+    public void testPlayer2BuildAccess() {        
+        ApplicableRegionSet appl;
+        
+        // Outside
+        appl = manager.getApplicableRegions(outside);
+        assertTrue(appl.canBuild(player2));
+        // Inside courtyard
+        appl = manager.getApplicableRegions(inCourtyard);
+        assertFalse(appl.canBuild(player2));
+        // Inside fountain
+        appl = manager.getApplicableRegions(inFountain);
+        assertTrue(appl.canBuild(player2));
+    }
+
+}

tests/com/sk89q/worldguard/protection/CSVDatabaseTest.java

@@ -0,0 +1,124 @@
+// $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;
+
+import java.io.*;
+import java.util.Map;
+import java.util.HashMap;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldguard.domains.DefaultDomain;
+
+public class CSVDatabaseTest {
+    @Before
+    public void setUp() throws Exception {
+    }
+
+    @After
+    public void tearDown() throws Exception {
+    }
+
+    @Test
+    public void testLoadSave() throws Exception {
+        File temp = File.createTempFile("worldguard_csv_test", ".tmp"); 
+        temp.deleteOnExit();
+        
+        Map<String,ProtectedRegion> regions =
+                new HashMap<String,ProtectedRegion>();
+        regions.put("test1", getTestRegion1());
+        regions.put("test2", getTestRegion2());
+        
+        CSVDatabase writeDB = new CSVDatabase(temp);
+        writeDB.setRegions(regions);
+        writeDB.save();
+        
+        CSVDatabase readDB = new CSVDatabase(temp);
+        readDB.load();
+
+        Map<String,ProtectedRegion> loaded = readDB.getRegions();
+        
+        ProtectedRegion region1 = loaded.get("test1");
+        checkTestRegion1(region1);
+    }
+    
+    private void checkTestRegion1(ProtectedRegion region) {
+        AreaFlags flags = new AreaFlags();
+        flags.allowFireSpread = AreaFlags.State.ALLOW;
+        flags.allowPvP = AreaFlags.State.DENY;
+        flags.allowLighter = AreaFlags.State.DENY;
+        region.setFlags(flags);
+        
+        assertEquals(region.getFlags(), flags);
+    }
+    
+    private ProtectedRegion getTestRegion1() {
+        BlockVector min = new BlockVector(1, 2, 3);
+        BlockVector max = new BlockVector(4, 5, 6);
+        
+        ProtectedRegion region = new ProtectedCuboidRegion(min, max);
+        
+        AreaFlags flags = new AreaFlags();
+        flags.allowFireSpread = AreaFlags.State.ALLOW;
+        flags.allowPvP = AreaFlags.State.DENY;
+        flags.allowLighter = AreaFlags.State.DENY;
+        region.setFlags(flags);
+        
+        DefaultDomain domain = new DefaultDomain();
+        domain.addGroup("members");
+        domain.addGroup("sturmehs");
+        domain.addPlayer("hollie");
+        domain.addPlayer("chad");
+        domain.addPlayer("tetsu");
+        region.setOwners(domain);
+        
+        region.setEnterMessage("hello there!");
+        region.setPriority(444);
+        
+        return region;
+    }
+    
+    private ProtectedRegion getTestRegion2() {
+        BlockVector min = new BlockVector(7, 8, 9);
+        BlockVector max = new BlockVector(10, 11, 12);
+        
+        ProtectedRegion region = new ProtectedCuboidRegion(min, max);
+        
+        AreaFlags flags = new AreaFlags();
+        flags.allowFireSpread = AreaFlags.State.DENY;
+        flags.allowPvP = AreaFlags.State.ALLOW;
+        flags.allowMobDamage = AreaFlags.State.DENY;
+        region.setFlags(flags);
+        
+        DefaultDomain domain = new DefaultDomain();
+        domain.addGroup("admins");
+        domain.addPlayer("jon");
+        domain.addPlayer("ester");
+        domain.addPlayer("amy");
+        region.setOwners(domain);
+        
+        region.setEnterMessage("Testing");
+        region.setPriority(555);
+        
+        return region;
+    }
+}

worldguard-blacklist.txt

@@ -0,0 +1,90 @@
+#
+# This is the blacklist for WorldGuard. Comments start with # and they
+# are ignored so you can put your own notes.
+#
+# Format:
+# [item1,item2]
+# option1=options
+# event1=whatToDo1,whatToDo2,whatToDo3
+# event2=whatToDo1,whatToDo2
+#
+# Example to block ore and catch some events:
+# [coalore,goldore,ironore]
+# on-destroy-with=deny,log,kick
+# on-place=deny,tell
+#
+# Options:
+# - ignore-groups (comma-delimited list of groups to not affect)
+# - comment (message for yourself that is printed with 'log' and 'notify')
+# - message (optional message to show the user instead; %s is the item name)
+#
+# Events:
+# - on-destroy (when a block of this type is being destroyed)
+# - on-break (when a block of this type is about to be broken)
+# - on-destroy-with (the item/block held by the user while destroying)
+# - on-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)
+# - notify (notify admins)
+# - log (log to console/file/database)
+# - tell (tell a player that that's not allowed)
+# - 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.
+#
+# -------------
+#
+# You can have the same block or item used in two different sections and
+# they will both apply:
+#
+# [goldblock]
+# ignore-groups=vip
+# on-destroy=deny
+# [goldblock]
+# ignore-groups=admins
+# on-destroy=tell
+#
+# However, some events override others. For example, if you disable both
+# usage of the diamond pickaxe (with the on-destroy-with event) and
+# destruction of gold blocks (with the on-destroy event) and a player tries
+# to destroy a gold block with a diamond pickaxe, because the
+# on-destroy-with event comes first, the rules for the gold block
+# will not be applied (but the player will be denied nevertheless).
+#
+# -------------
+#
+# Some examples follow. Remember to remove # in front if you want them
+# to work for you!
+
+# Deny lava buckets
+#[lavabucket]
+#ignore-groups=admins,mods
+#on-use=deny,tell
+
+# Deny lighter usage
+#[259]
+#on-use=deny,tell
+
+# Deny some ore
+#[coalore,goldore,ironore]
+#ignore-groups=admins,mods
+#on-destroy=notify,deny,log
+
+#[cobblestone]
+#on-place=deny,tell,log
+
+#[lever]
+#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

worldprotect-blacklist.txt

@@ -1,32 +0,0 @@
-#
-# This is the blacklist for WorldProtect. Comments start with # and they
-# are ignored so you can put your own notes.
-#
-# Format:
-# [item1,item2,itemN]
-# option1=options
-# event1=action1,action2,actionN
-# eventN=action1,action2,actionN
-#
-# Events/Options:
-# - ignore-groups (comma-delimited list of groups to not affect)
-# - on-destroy (when a block of this type is destroyed)
-# - on-left (when this item is held and the player is left clicking)
-# - on-right (when this item is held and the player is right clicking)
-#
-# Actions:
-# - deny (deny completely)
-# - notify (notify admins)
-# - log (log to console/file)
-# - kick (kick player)
-# - tell (tell a player that that's not allowed)
-#
-# Some examples follow.
-#
-#[lavabucket]
-#on-left=deny,log,kick
-#on-right=deny,tell
-#[coalore,goldore,ironore]
-#on-destroy=notify,deny,log
-#[cobblestone]
-#on-right=deny,tell,log