Updated CHANGELOG.txt.

CHANGELOG.txt

@@ -1,43 +1,6 @@
-5.2.2:
-- Changed configuration saving so empty lists will be added to
-    the configuration files.
-
-5.2.1:
-- Add region bounds to /region info
-- Added the ability to add owners/members to the global region for
-    handling guest groups. Now if there's owners or members on the global
-    region, then those  that are not on the list cannot build.
-- Fixed some flag algorithm issues.
-- API: Fixed DefaultDomain.size() not counting players.
-- API: Undeprecated ApplicableRegionSet.allows(StateFlag).
-
-5.2:
-- Gave the ability to use color colors and macros in greeting
-    and farewell messages.
-- Added disable-ice-melting, disable-snow-formation, disable-mushroom-spread,
-    disable-snow-melting, disable-ice-formation.
-- Added paintings to blacklist support.
-- Added default.disable-health-regain.
-- Added auto-invincible-permission setting, which lets you use the permission
-    'worldguard.auto-invincible' to become invincible on join automatically.
-- Flames won't appear if you are /god'ed now. 
-- Added blocked-cmds region flag to block commands.
-- Added allowed-cmds region flag to whitelist commands.
-- Added entry region flag to block entry. Use entry-group to determine who
-    this affects.
-- Added exit region flag to block exit. Use exit-group to determine who
-    this affects.
-- Made negative healing possible via the healing flag.
-- Changed the configuration header messages to be more helpful to new users.
-- Added a warning about modifying region files by hand.
-- Improved the API for plugin developers.
-
-5.1:
-- A lot of changes.
-
-4.0-alpha1:
-- This release is only to fix WorldGuard for Bukkit. Ignore the 4.0
-    label. Just move along. Nothing to see.
+3.2.3:
+- Updated for recent Bukkit builds. Thank Zenexer for changes.
+- Added suppress-tick-sync-warnings.
 
 3.2.2:
 - Changed disable-water-damage to disable-drowning-damage.

README.html

@@ -1,116 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<title>WorldGuard ${version}</title>
-<style>
-body {
-  margin: 0;
-  padding: 20px;
-  background: #efefef;
-  color: #333;
-}
-#wrapper {
-  margin: 20px auto 20px auto;
-  width: 600px;
-  background: #fff;
-  padding: 40px;
-  border: 1px solid #fff;
-  border-radius: 10px;
-  -moz-border-radius: 10px;
-  -webkit-border-radius: 10px;
-  box-shadow: 0 0 2px #999;
-  -webkit-box-shadow: 0 0 3px #999;
-}
-a img {
-  border: 0;
-}
-body, th, td, input {
-  font: 13px/17px "Lucida Grande", "Lucida Sans Unicode", Arial, Verdana, sans-serif;
-}
-a:link, a:visited {
-  color: #00688f;
-  text-decoration: underline;
-}
-a:hover, a:active {
-  color: #000;
-  border: 0;
-}
-h1 {
-  font: 170% "Trebuchet MS", Georgia, serif;
-  font-weight: bold;
-  color: #b90000;
-  margin: 15px 0 5px 0;
-}
-h2 {
-  font: 130% "Trebuchet MS", Georgia, serif;
-  font-weight: bold;
-  color: #6a45ac;
-  margin: 50px 0 5px 0;
-  padding: 0 0 3px 0;
-  border-bottom: 1px solid #ccc;
-}
-.warning {
-  background: #fffedf;
-  padding: 8px;
-  border: 1px dashed #ccc;
-  border-radius: 4px;
-  -moz-border-radius: 4px;
-  -webkit-border-radius: 4px;
-  font-size: 90%;
-}
-.subtle {
-  color: #999;
-}
-.optional {
-  background: none repeat scroll 0 0 #FFE081;
-  border-radius: 3px 3px 3px 3px;
-  font-size: 80%;
-	font-weight: normal;
-  padding: 1px 4px;
-}
-</style>
-</head>
-<body>
-
-<div id="wrapper">
-
-<h1>WorldGuard ${version}</h1>
-<p>Thanks for choosing WorldGuard!</p>
-<h2>Getting Started</h2>
-
-<p>Now, to begin, you want to:</p>
-<ol>
-  <li><strong>Install the plugin:</strong> Copy WorldGuard.jar into your Bukkit server's &quot;plugins&quot; directory.</li>
-  <li><strong>Change the configuration:</strong> Run your server once (with WorldGuard) to generate the default configuration files. There are <em>two</em> types of configuration files:
-    <ul>
-      <li>The main config.yml file  inside &quot;plugins/WorldGuard&quot; is the main configuration. </li>
-      <li>Each world has a configuration file in &quot;plugins/WorldGuard/worlds&quot; that you can use to override any setting in the main configuration file for that specific world.</li>
-    </ul>
-  </li>
-  Use <em>/wg reload</em> in the console to reload the configuration.
-  <li><strong>Learn how to use WorldGuard:</strong> Check <a href="http://wiki.sk89q.com/wiki/WorldGuard">out the wiki</a> to learn how to disable things like fire and to protect regions.</li>
-</ol>
-<p class="warning"><strong>Note:</strong> <a href="http://www.sk89q.com/projects/worldedit/">WorldEdit</a> must be installed, but if you do not want it,  put WorldEdit.jar into your Bukkit root folder (outside of plugins/). Note that region protection  requires WorldEdit in plugins/.</p>
-<p>Be sure to:</p>
-<ul>
-  <li>Subscribe to <a href="http://minecraftnews.sk89q.com/">SK's Minecraft blog</a> for news about WorldGuard</li>
-  <li>Idle with us in IRC at <a href="http://skq.me/irc/irc.esper.net/worldguard">irc.esper.net in #worldguard</a></li>
-</ul>
-<h2>Getting Help</h2>
-<p>If you need help, the best two ways to ask are:</p>
-<ul>
-  <li><a href="http://forum.sk89q.com/">Visit the WorldGuard forum</a></li>
-  <li>Ask in IRC chat on <a href="http://skq.me/irc/irc.esper.net/worldguard">irc.esper.net in #worldguard</a> (idle with us!)</li>
-  <li>Submit bug reports and suggestions to the <a href="http://redmine.sk89q.com/projects/worldguard/issues">issue tracker</a></li>
-</ul>
-<h2>Contributing</h2>
-<p>WorldGuard is entirely open source! You can download all of the plugin code to learn from it, modify it for your own self, or even contribute back!</p>
-<ul>
-  <li><a href="https://github.com/sk89q/worldguard">Download WorldGuard code from GitHub</a></li>
-  <li>You can also <a href="http://www.sk89q.com/donate/">donate</a></li>
-  </ul>
-<p>The code is covered under the GNU General Public License v3.</p>
-<p class="subtle">Maven information: ${groupId}/${artifactId}/${version}</p>
-</div>
-</body>
-</html>

README.md

@@ -1,25 +0,0 @@
-WorldGuard
-==========
-
-WorldGuard protects your Minecraft server. As Minecraft's oldest surviving world protection mod, you know you're in safe hands.
-
-Compiling
----------
-
-You need to have Maven installed (http://maven.apache.org). Once installed,
-simply run:
-
-    mvn clean install
-    
-Maven will automatically download dependencies for you. Note: For that to work,
-be sure to add Maven to your "PATH".
-
-Contributing
-------------
-
-We happily accept contributions. The best way to do this is to fork WorldGuard
-on GitHub, add your changes, and then submit a pull request. We'll look at it,
-make comments, and merge it into WorldGuard if everything works out.
-
-By submitting code, you agree to place to license your code under the 
-GNU General Public License v3.

README.txt

@@ -0,0 +1,23 @@
+WorldGuard
+Copyright (c) 2010, 2011 sk89q <http://www.sk89q.com>
+Licensed under the GNU Lesser General Public License v3
+
+Introduction
+------------
+
+WorldGuard protects your server!
+
+Documentation can be found at:
+http://wiki.sk89q.com/wiki/WorldGuard
+
+Thanks
+------
+
+While I would like to thank everyone for their support, I would like to
+say thanks to the following individuals for their direct
+contributions to WorldGuard:
+
+- Sturmeh, for contributing the original durability workaround
+- Meaglin, for changing the on flow hook at my request
+- Dinnerbone, for implementing the on item pick up hook at my request,
+    and also for figuring out the durability bug in the process

blacklist.txt

@@ -0,0 +1,84 @@
+#
+# This is the blacklist for WorldGuard. The blacklist allows you to perform
+# actions depending on an item or block ID. Comments start with # and they
+# are ignored so you can put your own notes.
+#
+# --------------------------------------------------------------------------
+#
+# WARNING:
+# Remember to check the compatibility spreadsheet for WorldGuard to see
+# if any events or actions are currently broken in your version of Bukkit.
+#
+# --------------------------------------------------------------------------
+#
+# Format:
+# [item1,item2]
+# option1=options
+# event1=whatToDo1,whatToDo2,whatToDo3
+# event2=whatToDo1,whatToDo2
+#
+# Example to block some ore mining and placement:
+# [coalore,goldore,ironore]
+# on-break=deny,log,kick
+# on-place=deny,tell
+#
+# Options:
+# - ignore-groups (comma-separated 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-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 flint and steel or a bucket is being used)
+# - on-interact (when a block in used (doors, chests, etc.))
+# - on-drop (an item is being dropped from the player's inventory)
+# - on-acquire (an 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)
+#
+# Users with the /worldguardnotify permission will 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-break=deny
+# [goldblock]
+# ignore-groups=admins
+# on-break=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-break 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: If a line has # in front, it will be ignored.
+#
+# --------------------------------------------------------------------------
+
+# Deny lava buckets
+#[lavabucket]
+#ignore-groups=admins,mods
+#on-use=deny,tell
+
+# Deny some ore
+#[coalore,goldore,ironore]
+#ignore-groups=admins,mods
+#on-break=notify,deny,log

blacklist_table.sql

@@ -6,7 +6,6 @@
 CREATE TABLE `blacklist_events` (
   `id` int(11) NOT NULL AUTO_INCREMENT,
   `event` varchar(25) NOT NULL,
-  `world` varchar(32) NOT NULL,
   `player` varchar(16) NOT NULL,
   `x` int(11) NOT NULL,
   `y` int(11) NOT NULL,
@@ -19,6 +18,4 @@ CREATE TABLE `blacklist_events` (
 
 -- Required update if you have an older version of the table:
 
-ALTER TABLE `blacklist_events` ADD `comment` VARCHAR( 255 ) NULL 
-
-ALTER TABLE `blacklist_events` ADD `world` VARCHAR( 32 ) NOT NULL 
+ALTER TABLE `blacklist_events` ADD `comment` VARCHAR( 255 ) NULL 

build.xml

@@ -0,0 +1,110 @@
+<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"/>
+  <property name="docs.dir" location="docs"/>
+
+  <fileset id="libs" dir="${lib.dir}">
+    <include name="truezip.jar" />
+    <include name="Bukkit.jar" />
+    <include name="Craftbukkit.jar" />
+    <include name="WorldEdit.jar" />
+    <include name="prtree.jar" />
+  </fileset>
+
+  <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 refid="libs"/>
+      </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 WorldGuard/WorldEdit.jar"/>
+    </manifest>
+    <delete file="${build.dir}/plugin.yml"/>
+    <copy tofile="${build.dir}/plugin.yml" file="plugin.yml"/>
+    <replace file="${build.dir}/plugin.yml" token="WGVERSIONMACRO" value="${version}"/>
+    <mkdir dir="${build.dir}/defaults"/>
+    <copy tofile="${build.dir}/defaults/config.yml" file="config.yml"/>
+    <copy tofile="${build.dir}/defaults/blacklist.txt" file="blacklist.txt"/>
+    <jar jarfile="${dist.dir}/WorldGuard.jar" basedir="${build.dir}" manifest="manifest.mf">
+        <zipgroupfileset dir="lib" includes="prtree.jar" />
+    </jar>
+  </target>
+
+  <!-- Create the .jar -->
+  <target name="dist">
+    <property name="version" value="nightly"/>
+    <antcall target="jar"/>
+  </target>
+
+  <!-- Build a release -->
+  <target name="release" depends="clean">
+    <input message="Enter version:" addproperty="version"/>
+    <antcall target="jar"/>
+    <delete dir="${release.dir}"/>
+    <mkdir dir="${release.dir}"/>
+    <copy tofile="${release.dir}/README.txt" file="README.txt"/>
+    <copy tofile="${release.dir}/LICENSE.txt" file="LICENSE.txt"/>
+    <copy tofile="${release.dir}/CHANGELOG.txt" file="CHANGELOG.txt"/>
+    <copy tofile="${release.dir}/blacklist_table.sql" file="blacklist_table.sql"/>
+    <copy tofile="${release.dir}/WorldGuard.jar" file="${dist.dir}/WorldGuard.jar"/>
+    <zip destfile="${release.dir}/worldguard-${version}.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
+    <mkdir dir="${release.dir}/src"/>
+    <copy todir="${release.dir}/src">
+      <fileset dir="${src.dir}"/>
+    </copy>
+    <zip destfile="${release.dir}/worldguard-${version}-src.zip" basedir="${release.dir}" excludes="*.zip plugin.yml"/>
+  </target>
+
+  <!-- Javadoc -->
+  <target name="javadoc">
+    <javadoc access="public" author="true" destdir="${docs.dir}" doctitle="WorldGuard API" nodeprecated="false" nodeprecatedlist="false" noindex="false" nonavbar="false" notree="false" source="1.6" sourcepath="src" splitindex="true" use="true" version="true">
+      <classpath>
+        <fileset refid="libs"/>
+      </classpath>
+    </javadoc>
+  </target>
+  
+  <!-- Clean the output -->
+  <target name="clean">
+    <delete dir="${build.dir}"/>
+    <delete dir="${dist.dir}"/>
+    <delete dir="${release.dir}"/>
+    <delete dir="${docs.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>

config.yml

@@ -0,0 +1,101 @@
+#
+# WorldGuard's configuration file
+#
+# About editing this file:
+# - DO NOT USE TABS. You MUST use spaces or Bukkit will complain. If
+#   you use an editor like Notepad++ (recommended for Windows users), you
+#   must configure it to "replace tabs with spaces." In Notepad++, this can
+#   be changed in Settings > Preferences > Language Menu.
+# - Don't get rid of the indents. They are indented so some entries are
+#   in categories (like "enforce-single-session" is in the "protection"
+#   category.
+# - If you want to check the format of this file before putting it
+#   into WorldGuard, paste it into http://yaml-online-parser.appspot.com/
+#   and see if it gives "ERROR:".
+# - Lines starting with # are commentsand so they are ignored.
+#
+# WARNING:
+# Remember to check the compatibility spreadsheet for WorldGuard to see
+# if any features are currently broken in your version of Bukkit.
+#
+
+summary-on-start: on
+
+suppress-tick-sync-warnings: false
+
+protection:
+    enforce-single-session: on
+    item-durability: on
+
+simulation:
+    sponge:
+        enable: on
+        redstone: off
+        radius: 3
+
+physics:
+    no-physics-gravel: off
+    no-physics-sand: off
+    allow-portal-anywhere: off
+    disable-water-damage-blocks: []
+
+ignition:
+    block-tnt: off
+    block-lighter: off
+
+fire:
+    disable-all-fire-spread: off
+    disable-fire-spread-blocks: []
+    disable-lava-fire-spread: on
+    lava-spread-blocks: []
+
+mobs:
+    block-creeper-explosions: off
+    block-creeper-block-damage: off
+
+spawn:
+    login-protection: 3
+    spawn-protection: 0
+    kick-on-death: off
+    exact-respawn: off
+    teleport-to-home-on-death: off
+
+player-damage:
+    disable-fall-damage: off
+    disable-lava-damage: off
+    disable-fire-damage: off
+    disable-drowning-damage: off
+    disable-suffocation-damage: off
+    disable-contact-damage: off
+    teleport-on-suffocation: off
+
+regions:
+    enable: on
+    wand: 287
+    default:
+        build: true
+        chest-access: false
+        pvp: true
+
+blacklist:
+    logging:
+        console:
+            enable: on
+        database:
+            enable: off
+            dsn: jdbc:mysql://localhost:3306/minecraft
+            user: root
+            password: pass
+            table: blacklist_events
+        file:
+            enable: on
+            path: worldguard/logs/%Y-%m-%d.log
+            open-files: 10
+
+# See http://wiki.sk89q.com/wiki/WorldGuard/Permissions/Bukkit
+permissions:
+    users:
+        sk89q:
+            permissions:
+                - /region
+                - /reloadwg

javadoc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<project default="javadoc">
+    <target name="javadoc">
+        <javadoc access="public" author="true" classpath="P:\Projects\Minecraft\Libraries\GroupUsers.jar;P:\Projects\Minecraft\Libraries\jnbt.jar;P:\Projects\Minecraft\hMod\build\classes;P:\Projects\Minecraft\WorldEdit\build\classes;P:\Projects\Minecraft\Libraries\snakeyaml.jar;P:\Projects\Minecraft\Libraries\jopt-simple-3.2.jar;P:\Projects\Minecraft\Libraries\Permissions.jar;C:\Program Files\eclipse\plugins\org.hamcrest.core_1.1.0.v20090501071000.jar;P:\Projects\Minecraft\Libraries\json_simple-1.1.jar;P:\Projects\Minecraft\CraftBukkit\bin;P:\Projects\Minecraft\Libraries\truezip.jar;C:\Program Files\eclipse\plugins\org.junit_4.8.1.v4_8_1_v20100427-1100\junit.jar;P:\Projects\Minecraft\Bukkit\bin;P:\Projects\Minecraft\mc-dev" destdir="doc" doctitle="Worldguard API" nodeprecated="false" nodeprecatedlist="false" noindex="false" nonavbar="false" notree="false" packagenames="com.sk89q.worldguard.blacklist,com.sk89q.worldguard.domains,com.sk89q.worldguard.bukkit,com.sk89q.worldguard.protection,com.sk89q.worldguard.util,au.com.bytecode.opencsv,com.sk89q.worldguard,com.sk89q.worldguard.blacklist.loggers,com.sk89q.worldguard.blacklist.events" source="1.6" sourcepath="tests;src" splitindex="true" use="true" version="true"/>
+    </target>
+</project>

plugin.yml

@@ -1,6 +1,6 @@
 name: WorldGuard
 main: com.sk89q.worldguard.bukkit.WorldGuardPlugin
-version: "${project.version}"
+version: WGVERSIONMACRO
 commands:
     stopfire:
         description: Halts all fire spread until it is disabled or the server is restarted
@@ -8,34 +8,26 @@ commands:
     allowfire:
         description: Re-enables fire spread if he has been disabled with /stopfire
         usage: /<command>
-    halt-activity:
-        aliases: [stoplag, haltactivity]
-        description: Attempts to stop all intensive operations (toggle)
-        usage: /<command> [-c]
     god:
-        description: Enable god mode
-        usage: /<command> [player]
-    ungod:
-        description: Disable god mode
-        usage: /<command> [player]
+        description: Toggles god mode
+        usage: /<command> [other player]
     heal:
         description: Heal yourself or another
-        usage: /<command> [player]
+        usage: /<command> [other player]
     slay:
         description: Slay yourself or another
-        usage: /<command> [player]
+        usage: /<command> [other player]
     stack:
         description: Stacks items in the player's inventory
         usage: /<command>
         aliases: ;
     region:
         description: Adjust protected regions
-        usage: /<command> <action> ...
-        aliases: [rg, regions]
+        usage: /<command> <define|claim|setparent|flag|delete|info|addowner|removeowner|addmember|removemember|list|save|load> ...
+        aliases: rg, regions
     locate:
         description: Set your compass towards a person
         usage: /<command> <target>
-    worldguard:
-        description: WorldGuard commands
-        aliases: wg
+    reloadwg:
+        description: Reload WorldGuard's configuration
         usage: /<command>

pom.xml

@@ -1,186 +0,0 @@
-<!--
-  Maven build file for WorldGuard
-  Copyright (c) 2011 sk89q <http://www.sk89q.com> 
-  CommandBook is available under the GNU General Public License v3
--->
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-  <modelVersion>4.0.0</modelVersion>
-  <groupId>com.sk89q</groupId>
-  <artifactId>worldguard</artifactId>
-  <version>5.2.2</version>
-  <name>WorldGuard</name>
-  <description>WorldGuard protects your Minecraft servers</description>
-
-  <scm>
-    <connection>scm:git:git://github.com/sk89q/worldguard.git</connection>
-    <url>https://github.com/sk89q/worldguard</url>
-    <developerConnection>scm:git:git@github.com:sk89q/worldguard.git</developerConnection>
-  </scm>
-
-  <repositories>
-    <!-- Repository for other dependencies of SK's -->
-    <repository>
-      <id>sk89q-mvn2</id>
-      <url>http://mvn2.sk89q.com/repo</url>
-    </repository>
-    <!-- Repository for Bukkit -->
-    <repository>
-      <id>bukkit-repo</id>
-      <url>http://repo.bukkit.org/artifactory/repo</url>
-    </repository>
-  </repositories>
-
-  <dependencies>
-    <!-- Required component -->
-    <dependency>
-      <groupId>com.sk89q</groupId>
-      <artifactId>worldedit</artifactId>
-      <version>4.4.2</version>
-    </dependency>
-    
-    <!-- Bukkit -->
-    <dependency>
-      <groupId>org.bukkit</groupId>
-      <artifactId>bukkit</artifactId>
-      <version>0.0.1-SNAPSHOT</version>
-    </dependency>
-    
-    <!-- Additional libraries -->
-    <dependency>
-      <groupId>com.nijikokun</groupId>
-      <artifactId>iconomy</artifactId>
-      <version>5.0</version>
-    </dependency>
-    <dependency>
-      <groupId>org.khelekore</groupId>
-      <artifactId>prtree</artifactId>
-      <version>1.4</version>
-    </dependency>
-    <dependency>
-      <groupId>net.sf.opencsv</groupId>
-      <artifactId>opencsv</artifactId>
-      <version>2.0</version>
-    </dependency>
-  </dependencies>
-
-  <build>
-    <sourceDirectory>${basedir}/src/main/java</sourceDirectory>
-
-    <!-- Resources -->
-    <resources>
-      <resource>
-        <targetPath>.</targetPath>
-        <filtering>true</filtering>
-        <directory>${basedir}/src/main/resources/</directory>
-        <includes>
-          <include>plugin.yml</include>
-        </includes>
-      </resource>
-      <resource>
-        <targetPath>defaults/</targetPath>
-        <filtering>true</filtering>
-        <directory>${basedir}/src/main/resources/</directory>
-        <includes>
-          <include>config.yml</include>
-          <include>config_world.yml</include>
-          <include>blacklist.txt</include>
-        </includes>
-      </resource>
-    </resources>
-
-    <plugins>
-      <!-- Compile plugin -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-compiler-plugin</artifactId>
-        <version>2.3.2</version>
-      </plugin>
-
-      <!-- JAR creation plugin -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-jar-plugin</artifactId>
-        <version>2.3.1</version>
-        <configuration>
-          <archive>
-            <addMavenDescriptor>true</addMavenDescriptor>
-            <manifest>
-              <addDefaultSpecificationEntries>true</addDefaultSpecificationEntries>
-              <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
-            </manifest>
-            <manifestEntries>
-              <Class-Path>WorldEdit.jar WorldGuard/WorldEdit.jar lib/WorldEdit.jar ../lib/WorldEdit.jar ../WorldEdit.jar</Class-Path>
-            </manifestEntries>
-          </archive>
-        </configuration>
-      </plugin>
-
-      <!-- Shade -->
-      <!-- We want to bundle in some dependencies -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-shade-plugin</artifactId>
-        <version>1.4</version>
-        <executions>
-          <execution>
-            <phase>package</phase>
-            <goals>
-              <goal>shade</goal>
-            </goals>
-            <configuration>
-              <artifactSet>
-                <!-- We want to bundle in the modified CSV library -->
-                <includes>
-                  <include>net.sf.opencsv:opencsv</include>
-                </includes>
-              </artifactSet>
-            </configuration>
-          </execution>
-        </executions>
-      </plugin>
-
-      <!-- Assembly -->
-      <plugin>
-        <artifactId>maven-assembly-plugin</artifactId>
-        <version>2.2.1</version>
-        <configuration>
-          <descriptor>${basedir}/src/main/assembly/default.xml</descriptor>
-        </configuration>
-        <executions>
-          <execution>
-            <id>release</id>
-            <phase>package</phase>
-            <goals>
-              <goal>single</goal>
-            </goals>
-          </execution>
-        </executions>
-      </plugin>
-
-      <!-- Release -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-release-plugin</artifactId>
-        <version>2.1</version>
-        <configuration>
-          <preparationGoals>assembly:assembly</preparationGoals>
-          <goals>assembly:assembly</goals>
-        </configuration>
-      </plugin>
-    </plugins>
-  </build>
-  
-  <reporting>
-    <plugins>
-      <!-- Javadocs -->
-      <!-- TODO: Get Doclava working -->
-      <plugin>
-        <groupId>org.apache.maven.plugins</groupId>
-        <artifactId>maven-javadoc-plugin</artifactId>
-        <version>2.8</version>
-        <configuration>
-        </configuration>
-      </plugin>
-    </plugins>
-  </reporting>
-</project>

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

@@ -0,0 +1,307 @@
+/**
+ 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.
+ */
+
+package au.com.bytecode.opencsv;
+
+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 @@
+/**
+ 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.
+ */
+
+package au.com.bytecode.opencsv;
+
+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 @@
+/**
+ 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.
+ */
+
+package au.com.bytecode.opencsv;
+
+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,34 @@
+/**
+ 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.
+ */
+
+package au.com.bytecode.opencsv;
+
+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,185 @@
+/**
+ 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.
+ */
+
+package au.com.bytecode.opencsv;
+
+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

@@ -72,14 +72,6 @@ public abstract class LocalPlayer {
      */
     public abstract String[] getGroups();
     
-    /**
-     * Returns whether a player has permission.
-     * 
-     * @param perm 
-     * @return 
-     */
-    public abstract boolean hasPermission(String perm);
-    
     @Override
     public boolean equals(Object obj) {
         if (!(obj instanceof LocalPlayer)) {

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

@@ -60,14 +60,6 @@ public abstract class Blacklist {
     Map<String,BlacklistTrackedEvent> lastAffected =
             new HashMap<String,BlacklistTrackedEvent>();
 
-
-    private boolean useAsWhitelist;
-
-    public Blacklist(Boolean useAsWhitelist)
-    {
-        this.useAsWhitelist = useAsWhitelist;
-    }
-
     /**
      * Returns whether the list is empty.
      * 
@@ -79,32 +71,11 @@ public abstract class Blacklist {
 
     /**
      * Get the entries for an item or list.
-     * 
-     * @param id 
-     * @return 
      */
     public List<BlacklistEntry> getEntries(int id) {
         return blacklist.get(id);
     }
     
-    /**
-     * Get the number of individual items that have blacklist entries.
-     * 
-     * @return
-     */
-    public int getItemCount() {
-        return blacklist.size();
-    }
-    
-    /**
-     * Returns whether the blacklist is used as a whitelist.
-     * 
-     * @return
-     */
-    public boolean isWhitelist() {
-        return useAsWhitelist;
-    }
-    
     /**
      * Get the logger.
      * 
@@ -129,7 +100,7 @@ public abstract class Blacklist {
         }
         boolean ret = true;
         for (BlacklistEntry entry : entries) {
-            if (!entry.check(useAsWhitelist, event, forceRepeat, silent)) {
+            if (!entry.check(event, forceRepeat, silent)) {
                 ret = false;
             }
         }
@@ -140,6 +111,7 @@ public abstract class Blacklist {
      * Load the blacklist.
      *
      * @param file
+     * @return
      * @throws IOException
      */
     public void load(File file) throws IOException {
@@ -205,8 +177,6 @@ public abstract class Blacklist {
                     for (BlacklistEntry entry : currentEntries) {
                         if (parts[0].equalsIgnoreCase("ignore-groups")) {
                             entry.setIgnoreGroups(parts[1].split(","));
-                        } else if (parts[0].equalsIgnoreCase("ignore-perms")) {
-                            entry.setIgnorePermissions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-break")) {
                             entry.setBreakActions(parts[1].split(","));
                         } else if (parts[0].equalsIgnoreCase("on-destroy-with")) {
@@ -264,7 +234,6 @@ public abstract class Blacklist {
      * Notify administrators.
      * 
      * @param event
-     * @param comment 
      */
     public void notify(BlacklistEvent event, String comment) {
         lastEvent = event;
@@ -295,6 +264,8 @@ public abstract class Blacklist {
 
     /**
      * Forget all players.
+     *
+     * @param player
      */
     public void forgetAllPlayers() {
         lastAffected.clear();

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

@@ -42,16 +42,10 @@ public class BlacklistEntry {
      * Parent blacklist entry.
      */
     private Blacklist blacklist;
-
     /**
      * List of groups to not affect.
      */
     private Set<String> ignoreGroups;
-
-    /**
-     * List of permissions to not affect.
-     */
-    private Set<String> ignorePermissions;
     
     private String[] breakActions;
     private String[] destroyWithActions;
@@ -80,13 +74,6 @@ public class BlacklistEntry {
         return ignoreGroups.toArray(new String[ignoreGroups.size()]);
     }
 
-    /**
-     * @return the ignoreGroups
-     */
-    public String[] getIgnorePermissions() {
-        return ignorePermissions.toArray(new String[ignorePermissions.size()]);
-    }
-
     /**
      * @param ignoreGroups the ignoreGroups to set
      */
@@ -98,17 +85,6 @@ public class BlacklistEntry {
         this.ignoreGroups = ignoreGroupsSet;
     }
 
-    /**
-     * @param ignorePermissions the ignorePermissions to set
-     */
-    public void setIgnorePermissions(String[] ignorePermissions) {
-        Set<String> ignorePermissionsSet = new HashSet<String>();
-        for (String perm : ignorePermissions) {
-            ignorePermissionsSet.add(perm);
-        }
-        this.ignorePermissions = ignorePermissionsSet;
-    }
-
     /**
      * @return
      */
@@ -131,7 +107,7 @@ public class BlacklistEntry {
     }
 
     /**
-     * @param actions
+     * @param action
      */
     public void setDestroyWithActions(String[] actions) {
         this.destroyWithActions = actions;
@@ -242,19 +218,12 @@ public class BlacklistEntry {
      * @return
      */
     public boolean shouldIgnore(LocalPlayer player) {
-        if (ignoreGroups != null) {
-            for (String group : player.getGroups()) {
-                if (ignoreGroups.contains(group.toLowerCase())) {
-                    return true;
-                }
-            }
+        if (ignoreGroups == null) {
+            return false;
         }
-
-        if (ignorePermissions != null) {
-            for (String perm : ignorePermissions) {
-                if (player.hasPermission(perm)) {
-                    return true;
-                }
+        for (String group : player.getGroups()) {
+            if (ignoreGroups.contains(group.toLowerCase())) {
+                return true;
             }
         }
 
@@ -297,13 +266,12 @@ public class BlacklistEntry {
     /**
      * Method to handle the event.
      * 
-     * @param useAsWhitelist 
      * @param event
      * @param forceRepeat
      * @param silent
      * @return
      */
-    public boolean check(boolean useAsWhitelist, BlacklistEvent event, boolean forceRepeat, boolean silent) {
+    public boolean check(BlacklistEvent event, boolean forceRepeat, boolean silent) {
         LocalPlayer player = event.getPlayer();
         
         if (shouldIgnore(player)) {
@@ -325,13 +293,11 @@ public class BlacklistEntry {
         }
 
         String actions[] = getActions(event);
-
-        
-        boolean ret = useAsWhitelist ? false : true;
+        boolean ret = true;
         
         // Nothing to do
         if (actions == null) {
-            return useAsWhitelist ? false : true;
+            return true;
         }
         
         for (String action : actions) {
@@ -343,14 +309,6 @@ public class BlacklistEntry {
                 
                 ret = false;
 
-            // Allow
-            } else if (action.equalsIgnoreCase("allow")) {
-                if (silent) {
-                    return true;
-                }
-
-                ret = true;
-
             // Kick
             } else if (action.equalsIgnoreCase("kick")) {
                 if (silent) {

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

@@ -55,6 +55,8 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
 
     /**
      * Add a handler.
+     *
+     * @param handler
      */
     public void clearHandlers() {
         handlers.clear();
@@ -63,6 +65,7 @@ public class BlacklistLogger implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
+     * @param player
      * @param event
      */
     public void logEvent(BlacklistEvent event, String comment) {

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

@@ -32,7 +32,7 @@ public class BlacklistTrackedEvent {
     /**
      * Construct the object.
      * 
-     * @param event 
+     * @param id
      * @param time
      */
     public BlacklistTrackedEvent(BlacklistEvent event, long time) {

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

@@ -32,7 +32,6 @@ public class BlockBreakBlacklistEvent extends BlockBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "break";
     }

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

@@ -32,7 +32,6 @@ public class BlockInteractBlacklistEvent extends BlockBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "interact with";
     }

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

@@ -32,7 +32,6 @@ public class BlockPlaceBlacklistEvent extends BlockBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "place";
     }

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

@@ -32,7 +32,6 @@ public class DestroyWithBlacklistEvent extends BlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "destroy with";
     }

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

@@ -32,7 +32,6 @@ public class ItemAcquireBlacklistEvent extends ItemBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "acquire";
     }

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

@@ -32,7 +32,6 @@ public class ItemDropBlacklistEvent extends ItemBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "drop";
     }

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

@@ -32,7 +32,6 @@ public class ItemUseBlacklistEvent extends ItemBlacklistEvent {
      * 
      * @return
      */
-    @Override
     public String getDescription() {
         return "use";
     }

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

@@ -34,72 +34,65 @@ public class ConsoleLoggerHandler implements BlacklistLoggerHandler {
      */
     private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
     
-    
-    private String worldName;
-    
-    public ConsoleLoggerHandler(String worldName)
-    {
-       this.worldName = worldName;    
-    }
-
     /**
      * Log an event.
      *
+     * @param player
      * @param event
      */
     public void logEvent(BlacklistEvent event, String comment) {
         // Block break
         if (event instanceof BlockBreakBlacklistEvent) {
             BlockBreakBlacklistEvent evt = (BlockBreakBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to break " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Block place
         } else if (event instanceof BlockPlaceBlacklistEvent) {
             BlockPlaceBlacklistEvent evt = (BlockPlaceBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to place " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Block interact
         } else if (event instanceof BlockInteractBlacklistEvent) {
             BlockInteractBlacklistEvent evt = (BlockInteractBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to interact with " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Destroy with
         } else if (event instanceof DestroyWithBlacklistEvent) {
             DestroyWithBlacklistEvent evt = (DestroyWithBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to destroy with " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Acquire
         } else if (event instanceof ItemAcquireBlacklistEvent) {
             ItemAcquireBlacklistEvent evt = (ItemAcquireBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to acquire " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Drop
         } else if (event instanceof ItemDropBlacklistEvent) {
             ItemDropBlacklistEvent evt = (ItemDropBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to drop " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Use
         } else if (event instanceof ItemUseBlacklistEvent) {
             ItemUseBlacklistEvent evt = (ItemUseBlacklistEvent)event;
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " tried to use " + getFriendlyItemName(evt.getType())
                     + (comment != null ? " (" + comment + ")" : ""));
         
         // Unknown
         } else {
-            logger.log(Level.INFO, "WorldGuard: [" + worldName + "] " + event.getPlayer().getName()
+            logger.log(Level.INFO, "WorldGuard: " + event.getPlayer().getName()
                     + " caught unknown event: " + event.getClass().getCanonicalName());
         }
     }

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

@@ -61,10 +61,6 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * Table.
      */
     private String table;
-    /**
-     * World name.
-     */
-    private String worldName;
     /**
      * Database connection.
      */
@@ -76,15 +72,12 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
      * @param dsn
      * @param user
      * @param pass
-     * @param table 
-     * @param worldName 
      */
-    public DatabaseLoggerHandler(String dsn, String user, String pass, String table, String worldName) {
+    public DatabaseLoggerHandler(String dsn, String user, String pass, String table) {
         this.dsn = dsn;
         this.user = user;
         this.pass = pass;
         this.table = table;
-        this.worldName = worldName;
     }
 
     /**
@@ -117,17 +110,16 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
             Connection conn = getConnection();
             PreparedStatement stmt = conn.prepareStatement(
                     "INSERT INTO " + table
-                  + "(event, world, player, x, y, z, item, time, comment) VALUES "
-                  + "(?, ?, ?, ?, ?, ?, ?, ?, ?)");
+                  + "(event, player, x, y, z, item, time, comment) VALUES "
+                  + "(?, ?, ?, ?, ?, ?, ?, ?)");
             stmt.setString(1, event);
-            stmt.setString(2, worldName);
-            stmt.setString(3, player.getName());
-            stmt.setInt(4, pos.getBlockX());
-            stmt.setInt(5, pos.getBlockY());
-            stmt.setInt(6, pos.getBlockZ());
-            stmt.setInt(7, item);
-            stmt.setInt(8, (int)(System.currentTimeMillis() / 1000));
-            stmt.setString(9, comment);
+            stmt.setString(2, player.getName());
+            stmt.setInt(3, pos.getBlockX());
+            stmt.setInt(4, pos.getBlockY());
+            stmt.setInt(5, pos.getBlockZ());
+            stmt.setInt(6, item);
+            stmt.setInt(7, (int)(System.currentTimeMillis() / 1000));
+            stmt.setString(8, comment);
             stmt.executeUpdate();
         } catch (SQLException e) {
             logger.log(Level.SEVERE, "Failed to log blacklist event to database: "
@@ -138,6 +130,7 @@ public class DatabaseLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
+     * @param player
      * @param event
      */
     public void logEvent(BlacklistEvent event, String comment) {

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

@@ -57,10 +57,6 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * Path pattern.
      */
     private String pathPattern;
-    /**
-     * World name.
-     */
-    private String worldName;
     /**
      * Cache of writers.
      */
@@ -71,11 +67,9 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      * Construct the object.
      *
      * @param pathPattern
-     * @param worldName 
      */
-    public FileLoggerHandler(String pathPattern, String worldName) {
+    public FileLoggerHandler(String pathPattern) {
         this.pathPattern = pathPattern;
-        this.worldName = worldName;
     }
 
     /**
@@ -83,15 +77,13 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
      *
      * @param pathPattern
      * @param cacheSize
-     * @param worldName 
      */
-    public FileLoggerHandler(String pathPattern, int cacheSize, String worldName) {
+    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;
-        this.worldName = worldName;
     }
 
     /**
@@ -118,12 +110,6 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
                     rep = rep.substring(0, 32);
                 }
 
-            }else if (group.matches("%w")) {
-                rep = worldName.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));
@@ -238,6 +224,7 @@ public class FileLoggerHandler implements BlacklistLoggerHandler {
     /**
      * Log an event.
      *
+     * @param player
      * @param event
      */
     public void logEvent(BlacklistEvent event, String comment) {

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

@@ -42,7 +42,6 @@ public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
     /**
      * Construct the object.
      * 
-     * @param path 
      * @param writer
      */
     public FileLoggerWriter(String path, BufferedWriter writer) {
@@ -76,6 +75,8 @@ public class FileLoggerWriter implements Comparable<FileLoggerWriter> {
     
     /**
      * Update last use time.
+     * 
+     * @return
      */
     public void updateLastUse() {
         lastUse = System.currentTimeMillis();

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

@@ -19,19 +19,22 @@
 
 package com.sk89q.worldguard.bukkit;
 
+import org.bukkit.entity.Player;
 import com.sk89q.worldguard.blacklist.Blacklist;
 
 public class BukkitBlacklist extends Blacklist {
     private WorldGuardPlugin plugin;
     
-    public BukkitBlacklist(Boolean useAsWhitelist, WorldGuardPlugin plugin) {
-        super(useAsWhitelist);
+    public BukkitBlacklist(WorldGuardPlugin plugin) {
         this.plugin = plugin;
     }
     
-    @Override
     public void broadcastNotification(String msg) {
-        plugin.broadcastNotification(msg);
+        for (Player player : plugin.getServer().getOnlinePlayers()) {
+            if (plugin.hasPermission(player, "/worldguardnotify")) {
+                player.sendMessage(msg);
+            }
+        }
     }
 
 }

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

@@ -69,9 +69,4 @@ public class BukkitPlayer extends LocalPlayer {
         player.sendMessage(msg);
     }
 
-    @Override
-    public boolean hasPermission(String perm) {
-        return plugin.hasPermission(player, perm);
-    }
-
 }

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

@@ -0,0 +1,53 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import java.util.List;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.Vector;
+
+public class BukkitUtil {
+    private BukkitUtil()  {
+    }
+    
+    public static BlockVector toVector(Block block) {
+        return new BlockVector(block.getX(), block.getY(), block.getZ());
+    }
+    
+    public static Vector toVector(Location loc) {
+        return new Vector(loc.getX(), loc.getY(), loc.getZ());
+    }
+    
+    public static Vector toVector(org.bukkit.util.Vector vector) {
+        return new Vector(vector.getX(), vector.getY(), vector.getZ());
+    }
+    
+    public static Player matchSinglePlayer(Server server, String name) {
+        List<Player> players = server.matchPlayer(name);
+        if (players.size() == 0) {
+            return null;
+        }
+        return players.get(0);
+    }
+}

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

@@ -22,7 +22,7 @@ package com.sk89q.worldguard.bukkit;
 import java.util.logging.Handler;
 import java.util.logging.LogRecord;
 import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 
 /**
  * Sends all logger messages to a player.
@@ -33,35 +33,32 @@ public class LoggerToChatHandler extends Handler {
     /**
      * Player.
      */
-    private CommandSender player;
+    private Player player;
 
     /**
      * Construct the object.
      * 
      * @param player
      */
-    public LoggerToChatHandler(CommandSender player) {
+    public LoggerToChatHandler(Player player) {
         this.player = player;
     }
 
     /**
      * Close the handler.
      */
-    @Override
     public void close() {
     }
 
     /**
      * Flush the output.
      */
-    @Override
     public void flush() {
     }
 
     /**
      * Publish a log record.
      */
-    @Override
     public void publish(LogRecord record) {
         player.sendMessage(ChatColor.GRAY + record.getLevel().getName() + ": "
                 + ChatColor.WHITE + record.getMessage());

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

@@ -0,0 +1,476 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import java.util.Iterator;
+import java.util.List;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockDamageLevel;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.World;
+import org.bukkit.event.block.*;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+import org.bukkit.inventory.ItemStack;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.blacklist.events.*;
+import com.sk89q.worldguard.protection.ApplicableRegionSet;
+import com.sk89q.worldguard.protection.AreaFlags;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+public class WorldGuardBlockListener extends BlockListener {
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+    
+    /**
+     * Construct the object;
+     * 
+     * @param plugin
+     */
+    public WorldGuardBlockListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Called when a block is damaged (or broken)
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockDamage(BlockDamageEvent event) {
+        Player player = event.getPlayer();
+
+        if (!plugin.itemDurability && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            ItemStack held = player.getItemInHand();
+            if (held.getTypeId() > 0) {
+                held.setDurability((short) -1);
+                player.setItemInHand(held);
+            }
+        }
+        
+        if (plugin.useRegions && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            Vector pt = BukkitUtil.toVector(event.getBlock());
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null && event.getDamageLevel() == BlockDamageLevel.BROKEN) {
+            if (!plugin.blacklist.check(
+                    new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
+                            toVector(event.getBlock()),
+                            event.getBlock().getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+
+            if (!plugin.blacklist.check(
+                    new DestroyWithBlacklistEvent(plugin.wrapPlayer(player),
+                            toVector(event.getBlock()),
+                            player.getItemInHand().getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a block flows (water/lava)
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockFlow(BlockFromToEvent event) {
+        World world = event.getBlock().getWorld();
+        Block blockFrom = event.getBlock();
+        Block blockTo = event.getToBlock();
+        
+        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
+        boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
+
+        if (plugin.simulateSponge && isWater) {
+            int ox = blockTo.getX();
+            int oy = blockTo.getY();
+            int oz = blockTo.getZ();
+
+            for (int cx = -plugin.spongeRadius; cx <= plugin.spongeRadius; cx++) {
+                for (int cy = -plugin.spongeRadius; cy <= plugin.spongeRadius; cy++) {
+                    for (int cz = -plugin.spongeRadius; cz <= plugin.spongeRadius; cz++) {
+                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
+                        if (sponge.getTypeId() == 19
+                                && (!plugin.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
+                            event.setCancelled(true);
+                            return;
+                        }
+                    }
+                }
+            }
+        }
+
+        /*if (plugin.classicWater && isWater) {
+            int blockBelow = blockFrom.getRelative(0, -1, 0).getTypeId();
+            if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
+                blockFrom.setTypeId(9);
+                if (blockTo.getTypeId() == 0) {
+                    blockTo.setTypeId(9);
+                }
+                return;
+            }
+        }*/
+
+        if (plugin.preventWaterDamage.size() > 0 && isWater) {
+            int targetId = world.getBlockTypeIdAt(
+                    blockTo.getX(), blockTo.getY(), blockTo.getZ());
+            if (plugin.preventWaterDamage.contains(targetId)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (plugin.allowedLavaSpreadOver.size() > 0 && isLava) {
+            int targetId = world.getBlockTypeIdAt(
+                    blockTo.getX(), blockTo.getY() - 1, blockTo.getZ());
+            if (!plugin.allowedLavaSpreadOver.contains(targetId)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a block gets ignited
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockIgnite(BlockIgniteEvent event) {
+        IgniteCause cause = event.getCause();
+        Block block = event.getBlock();
+        //Player player = event.getPlayer();
+        World world = block.getWorld();
+        boolean isFireSpread = cause == IgniteCause.SPREAD;
+        
+        if (plugin.preventLavaFire && cause == IgniteCause.LAVA) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.disableFireSpread && isFireSpread) {
+            event.setCancelled(true);
+            return;
+        }
+        
+        if (plugin.blockLighter && cause == IgniteCause.FLINT_AND_STEEL) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.fireSpreadDisableToggle && isFireSpread) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
+            int x = block.getX();
+            int y = block.getY();
+            int z = block.getZ();
+            
+            if (plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
+                    || plugin.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        /*if (plugin.useRegions) {
+            Vector pt = toVector(block);
+            
+            if (player != null && !plugin.hasPermission(player, "/regionbypass")) {
+                LocalPlayer localPlayer = plugin.wrapPlayer(player);
+                
+                if (cause == IgniteCause.FLINT_AND_STEEL
+                        && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                    event.setCancelled(true);
+                    return;
+                }
+                
+                if (cause == IgniteCause.FLINT_AND_STEEL
+                        && !plugin.regionManager.getApplicableRegions(pt)
+                        .allowsFlag(AreaFlags.FLAG_LIGHTER)) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+            
+            f (isFireSpread && !plugin.regionManager.getApplicableRegions(pt)
+                    .allowsFlag(AreaFlags.FLAG_FIRE_SPREAD)) {
+                event.setCancelled(true);
+                return;
+            }
+            
+            if (cause == IgniteCause.LAVA && !plugin.regionManager.getApplicableRegions(pt)
+                    .allowsFlag(AreaFlags.FLAG_LAVA_FIRE)) {
+                event.setCancelled(true);
+                return;
+            }
+        }*/
+    }
+
+    /**
+     * Called when a block is destroyed from burning
+     *
+     * @param event Relevant event details
+     */
+    public void onBlockBurn(BlockBurnEvent event) {
+        if (plugin.disableFireSpread) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.fireSpreadDisableToggle) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (plugin.disableFireSpreadBlocks.size() > 0) {
+            Block block = event.getBlock();
+
+            if (plugin.disableFireSpreadBlocks.contains(block.getTypeId())) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when block physics occurs
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockPhysics(BlockPhysicsEvent event) {
+        int id = event.getChangedTypeId();
+
+        if (id == 13 && plugin.noPhysicsGravel) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (id == 12 && plugin.noPhysicsSand) {
+            event.setCancelled(true);
+            return;
+        }
+
+        if (id == 90 && plugin.allowPortalAnywhere) {
+            event.setCancelled(true);
+            return;
+        }
+    }
+    
+    /**
+     * Called when a block is interacted with
+     * 
+     * @param event Relevant event details
+     */
+    public void onBlockInteract(BlockInteractEvent event) {
+        Block block = event.getBlock();
+        LivingEntity entity = event.getEntity();
+        
+        if (entity instanceof Player
+                && (block.getType() == Material.CHEST
+                        || block.getType() == Material.DISPENSER
+                        || block.getType() == Material.FURNACE
+                        || block.getType() == Material.BURNING_FURNACE
+                        || block.getType() == Material.NOTE_BLOCK)) {
+            Player player = (Player)entity;
+            if (plugin.useRegions) {
+                Vector pt = toVector(block);
+                LocalPlayer localPlayer = plugin.wrapPlayer(player);
+    
+                if (!plugin.hasPermission(player, "/regionbypass")
+                        && !plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_CHEST_ACCESS)
+                        && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                    player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+        
+        if (plugin.blacklist != null && entity instanceof Player) {
+            Player player = (Player)entity;
+            
+            if (!plugin.blacklist.check(
+                    new BlockInteractBlacklistEvent(plugin.wrapPlayer(player), toVector(block),
+                            block.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a player places a block
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Block blockPlaced = event.getBlock();
+        Player player = event.getPlayer();
+        World world = blockPlaced.getWorld();
+        
+        if (plugin.useRegions) {
+            Vector pt = toVector(blockPlaced);
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null) {
+            if (!plugin.blacklist.check(
+                    new BlockPlaceBlacklistEvent(plugin.wrapPlayer(player), toVector(blockPlaced),
+                            blockPlaced.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+
+        if (plugin.simulateSponge && blockPlaced.getTypeId() == 19) {
+            if (plugin.redstoneSponges && blockPlaced.isBlockIndirectlyPowered()) {
+                return;
+            }
+            
+            int ox = blockPlaced.getX();
+            int oy = blockPlaced.getY();
+            int oz = blockPlaced.getZ();
+
+            clearSpongeWater(world, ox, oy, oz);
+        }
+    }
+
+    /**
+     * Called when a player right clicks a block
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockRightClick(BlockRightClickEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.useRegions && event.getItemInHand().getTypeId() == plugin.regionWand) {
+            Vector pt = toVector(event.getBlock());
+            ApplicableRegionSet app = plugin.regionManager.getApplicableRegions(pt);
+            List<String> regions = plugin.regionManager.getApplicableRegionsIDs(pt);
+            
+            if (regions.size() > 0) {
+                player.sendMessage(ChatColor.YELLOW + "Can you build? "
+                        + (app.canBuild(plugin.wrapPlayer(player)) ? "Yes" : "No"));
+                
+                StringBuilder str = new StringBuilder();
+                for (Iterator<String> it = regions.iterator(); it.hasNext(); ) {
+                    str.append(it.next());
+                    if (it.hasNext()) {
+                        str.append(", ");
+                    }
+                }
+                
+                player.sendMessage(ChatColor.YELLOW + "Applicable regions: " + str.toString());
+            } else {
+                player.sendMessage(ChatColor.YELLOW + "WorldGuard: No defined regions here!");
+            }
+        }
+    }
+
+
+    /**
+     * Called when redstone changes
+     * From: the source of the redstone change
+     * To: The redstone dust that changed
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onBlockRedstoneChange(BlockRedstoneEvent event) {
+        World world = event.getBlock().getWorld();
+        Block blockTo = event.getBlock();
+
+        if (plugin.simulateSponge && plugin.redstoneSponges) {
+            int ox = blockTo.getX();
+            int oy = blockTo.getY();
+            int oz = blockTo.getZ();
+            
+            for (int cx = -1; cx <= 1; cx++) {
+                for (int cy = -1; cy <= 1; cy++) {
+                    for (int cz = -1; cz <= 1; cz++) {
+                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
+                        if (sponge.getTypeId() == 19
+                                && sponge.isBlockIndirectlyPowered()) {
+                            clearSpongeWater(world, ox + cx, oy + cy, oz + cz);
+                        }
+                    }
+                }
+            }
+            
+            return;
+        }
+    }
+    
+    /**
+     * Remove water around a sponge.
+     * 
+     * @param world
+     * @param ox
+     * @param oy
+     * @param oz
+     */
+    private void clearSpongeWater(World world, int ox, int oy, int oz) {
+        for (int cx = -plugin.spongeRadius; cx <= plugin.spongeRadius; cx++) {
+            for (int cy = -plugin.spongeRadius; cy <= plugin.spongeRadius; cy++) {
+                for (int cz = -plugin.spongeRadius; cz <= plugin.spongeRadius; cz++) {
+                    Block block = world.getBlockAt(ox + cx, oy + cy, oz + cz);
+                    int id = block.getTypeId();
+                    if (id == 8 || id == 9) {
+                        world.getBlockAt(ox + cx, oy + cy, oz + cz)
+                                .setTypeId(0);
+                    }
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,273 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.sk89q.worldguard.bukkit;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.*;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldedit.blocks.BlockType;
+import com.sk89q.worldguard.protection.AreaFlags;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+
+public class WorldGuardEntityListener extends EntityListener
+{
+	/**
+	 * Plugin.
+	 */
+	private WorldGuardPlugin plugin;
+
+	/**
+	 * Construct the object;
+	 *
+	 * @param plugin
+	 */
+	public WorldGuardEntityListener(WorldGuardPlugin plugin)
+	{
+		this.plugin = plugin;
+	}
+
+	@Override
+	public void onEntityDamage(EntityDamageEvent event)
+	{
+		Entity defender = event.getEntity();
+		DamageCause type = event.getCause();
+
+		if (defender instanceof Player)
+		{
+			Player player = (Player)defender;
+
+			if (plugin.invinciblePlayers.contains(player.getName()))
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.disableLavaDamage && type == DamageCause.LAVA)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.disableContactDamage && type == DamageCause.CONTACT)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (type == DamageCause.ENTITY_ATTACK)
+			{
+				Entity attacker = ((EntityDamageByEntityEvent)event).getDamager();
+
+				if (plugin.invinciblePlayers.contains(player.getName()))
+				{
+					event.setCancelled(true);
+					return;
+				}
+
+				if (attacker != null && attacker instanceof Player)
+				{
+					if (plugin.useRegions)
+					{
+						Vector pt = toVector(defender.getLocation());
+
+						if (!plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_PVP))
+						{
+							((Player)attacker).sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
+							event.setCancelled(true);
+							return;
+						}
+					}
+				}
+
+				if (attacker != null && attacker instanceof Monster)
+				{
+					if (attacker instanceof Creeper && plugin.blockCreeperExplosions)
+					{
+						event.setCancelled(true);
+						return;
+					}
+
+					if (plugin.useRegions)
+					{
+						Vector pt = toVector(defender.getLocation());
+
+						if (!plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_MOB_DAMAGE))
+						{
+							event.setCancelled(true);
+							return;
+						}
+
+						if (attacker instanceof Creeper)
+						{
+							if (!plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_CREEPER_EXPLOSION))
+							{
+								event.setCancelled(true);
+								return;
+							}
+						}
+					}
+				}
+			}
+
+			if (plugin.disableFallDamage && type == DamageCause.FALL)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.disableFireDamage && (type == DamageCause.FIRE
+											 || type == DamageCause.FIRE_TICK))
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.disableDrowningDamage && type == DamageCause.DROWNING)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.teleportOnSuffocation && type == DamageCause.SUFFOCATION)
+			{
+				findFreePosition(player);
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.disableSuffocationDamage && type == DamageCause.SUFFOCATION)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (type == DamageCause.DROWNING
+				&& plugin.amphibiousPlayers.contains(player.getName()))
+			{
+				event.setCancelled(true);
+				return;
+			}
+		}
+	}
+
+	@Override
+	public void onEntityExplode(EntityExplodeEvent event)
+	{
+		if (event.getEntity() instanceof LivingEntity)
+		{
+			if (plugin.blockCreeperBlockDamage)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.blockCreeperExplosions)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.useRegions)
+			{
+				Vector pt = toVector(event.getEntity().getLocation());
+
+				if (!plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_CREEPER_EXPLOSION))
+				{
+					event.setCancelled(true);
+					return;
+				}
+			}
+		}
+		else
+		{ // Shall assume that this is TNT
+			if (plugin.blockTNT)
+			{
+				event.setCancelled(true);
+				return;
+			}
+
+			if (plugin.useRegions && event.getEntity() != null)
+			{
+				Vector pt = toVector(event.getEntity().getLocation());
+
+				if (!plugin.regionManager.getApplicableRegions(pt).allowsFlag(AreaFlags.FLAG_TNT))
+				{
+					event.setCancelled(true);
+					return;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Find a position for the player to stand that is not inside a block.
+	 * Blocks above the player will be iteratively tested until there is
+	 * a series of two free blocks. The player will be teleported to
+	 * that free position.
+	 *
+	 * @param player
+	 */
+	public void findFreePosition(Player player)
+	{
+		Location loc = player.getLocation();
+		int x = loc.getBlockX();
+		int y = Math.max(0, loc.getBlockY());
+		int origY = y;
+		int z = loc.getBlockZ();
+		World world = player.getWorld();
+
+		byte free = 0;
+
+		while (y <= 129)
+		{
+			if (BlockType.canPassThrough(world.getBlockTypeIdAt(x, y, z)))
+			{
+				free++;
+			}
+			else
+			{
+				free = 0;
+			}
+
+			if (free == 2)
+			{
+				if (y - 1 != origY)
+				{
+					loc.setX(x + 0.5);
+					loc.setY(y);
+					loc.setZ(z + 0.5);
+					player.teleportTo(loc);
+				}
+
+				return;
+			}
+
+			y++;
+		}
+	}
+}

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

@@ -0,0 +1,161 @@
+// $Id$
+/*
+ * WorldGuard
+ * Copyright (C) 2010 sk89q <http://www.sk89q.com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+package com.sk89q.worldguard.bukkit;
+
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.*;
+import org.bukkit.inventory.ItemStack;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.*;
+import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
+import com.sk89q.worldguard.protection.AreaFlags;
+import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
+
+/**
+ * Handles all events thrown in relation to a Player
+ */
+public class WorldGuardPlayerListener extends PlayerListener {
+    /**
+     * Plugin.
+     */
+    private WorldGuardPlugin plugin;
+    
+    /**
+     * Construct the object;
+     * 
+     * @param plugin
+     */
+    public WorldGuardPlayerListener(WorldGuardPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Called when a player joins a server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerJoin(PlayerEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.fireSpreadDisableToggle) {
+            player.sendMessage(ChatColor.YELLOW
+                    + "Fire spread is currently globally disabled.");
+        }
+
+        if (plugin.inGroup(player, "wg-invincible")) {
+            plugin.invinciblePlayers.add(player.getName());
+        }
+
+        if (plugin.inGroup(player, "wg-amphibious")) {
+            plugin.amphibiousPlayers.add(player.getName());
+        }
+    }
+
+    /**
+     * Called when a player leaves a server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerQuit(PlayerEvent event) {
+        Player player = event.getPlayer();
+        plugin.invinciblePlayers.remove(player.getName());
+        plugin.amphibiousPlayers.remove(player.getName());
+        if (plugin.blacklist != null) {
+            plugin.blacklist.forgetPlayer(plugin.wrapPlayer(player));
+        }
+    }
+    
+    /**
+     * Called when a player uses an item
+     * 
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerItem(PlayerItemEvent event) {
+        Player player = event.getPlayer();
+        Block block = event.getBlockClicked();
+        ItemStack item = event.getItem();
+
+        if (!plugin.itemDurability) {
+            // Hoes
+            if (item.getTypeId() >= 290 && item.getTypeId() <= 294) {
+                item.setDurability((byte)-1);
+                player.setItemInHand(item);
+            }
+        }
+        
+        if (plugin.useRegions && !event.isBlock() && block != null) {
+            Vector pt = toVector(block.getRelative(event.getBlockFace()));
+            LocalPlayer localPlayer = plugin.wrapPlayer(player);
+            
+            if (!plugin.hasPermission(player, "/regionbypass")
+                    && !plugin.regionManager.getApplicableRegions(pt).canBuild(localPlayer)) {
+                player.sendMessage(ChatColor.DARK_RED
+                        + "You don't have permission for this area.");
+                event.setCancelled(true);
+                return;
+            }
+        }
+        
+        if (plugin.blacklist != null && item != null && block != null) {
+            if (!plugin.blacklist.check(
+                    new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
+                            toVector(block.getRelative(event.getBlockFace())),
+                            item.getTypeId()), false, false)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    
+        if (plugin.useRegions && item != null && block != null && item.getTypeId() == 259) {
+            Vector pt = toVector(block.getRelative(event.getBlockFace()));
+            
+            if (!plugin.regionManager.getApplicableRegions(pt)
+                    .allowsFlag(AreaFlags.FLAG_LIGHTER)) {
+                event.setCancelled(true);
+                return;
+            }
+        }
+    }
+
+    /**
+     * Called when a player attempts to log in to the server
+     *
+     * @param event Relevant event details
+     */
+    @Override
+    public void onPlayerLogin(PlayerLoginEvent event) {
+        Player player = event.getPlayer();
+        
+        if (plugin.enforceOneSession) {
+            String name = player.getName();
+            
+            for (Player pl : plugin.getServer().getOnlinePlayers()) {
+                if (pl.getName().equalsIgnoreCase(name)) {
+                    pl.kickPlayer("Logged in from another location.");
+                }
+            }
+        }
+    }
+}

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

@@ -81,7 +81,7 @@ public class DefaultDomain implements Domain {
     }
     
     public int size() {
-        return groups.size() + players.size();
+        return groups.size();
     }
     
     public String toPlayersString() {

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

@@ -0,0 +1,186 @@
+// $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.HashSet;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Set;
+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 GlobalFlags global;
+    private Vector pt;
+    private Iterator<ProtectedRegion> applicable;
+    
+    /**
+     * Construct the object.
+     * 
+     * @param pt
+     * @param regions
+     * @param global
+     */
+    public ApplicableRegionSet(Vector pt, Iterator<ProtectedRegion> applicable,
+            GlobalFlags global) {
+        this.pt = pt;
+        this.applicable = applicable;
+        this.global = global;
+    }
+    
+    /**
+     * Checks if a player can build in an area.
+     * 
+     * @param player
+     * @return
+     */
+    public boolean canBuild(LocalPlayer player) {
+        return isFlagAllowed(AreaFlags.FLAG_BUILD, global.canBuild, player);
+    }
+    
+    /**
+     * Checks a flag.
+     * 
+     * @param player
+     * @return
+     */
+    public boolean allowsFlag(String flag) {
+        boolean def = true;
+
+        if (flag.equals(AreaFlags.FLAG_CHEST_ACCESS)) {
+            def = global.canAccessChests;
+        } else if (flag.equals(AreaFlags.FLAG_PVP)) {
+            def = global.canPvP;
+        }
+        
+        return isFlagAllowed(flag, def, null);
+    }
+    
+    /**
+     * Checks to see if a flag is permitted.
+     * 
+     * @param def default state if there are no regions defined
+     * @param player null to not check owners and members
+     * @return
+     */
+    private boolean isFlagAllowed(String flag, boolean def, LocalPlayer player) {
+        boolean found = false;
+        boolean allowed = false; // Used for ALLOW override
+        if (player == null) {
+            allowed = def;
+        }
+        int lastPriority = 0;
+
+        // The algorithm is as follows:
+        // While iterating through the list of regions, if an entry disallows
+        // the flag, then put it into the needsClear set. If an entry allows
+        // the flag and it has a parent, then its parent is put into hasCleared.
+        // In the situation that the child is reached before the parent, upon
+        // the parent being reached, even if the parent disallows, because the
+        // parent will be in hasCleared, permission will be allowed. In the
+        // other case, where the parent is reached first, if it does not allow
+        // permissions, it will be placed into needsClear. If a child of
+        // the parent is reached later, the parent will be removed from
+        // needsClear. At the end, if needsClear is not empty, that means that
+        // permission should not be given. If a parent has multiple children
+        // and one child does not allow permissions, then it will be placed into
+        // needsClear just like as if was a parent.
+        
+        Set<ProtectedRegion> needsClear = new HashSet<ProtectedRegion>();
+        Set<ProtectedRegion> hasCleared = new HashSet<ProtectedRegion>();
+        
+        while (applicable.hasNext()) {
+            ProtectedRegion region = applicable.next();
+            
+            // Ignore non-build regions
+            if (player != null && region.getFlags().get(AreaFlags.FLAG_PASSTHROUGH) == State.ALLOW) {
+                continue;
+            }
+            
+            // Forget about regions that are not covered
+            if (!region.contains(pt)) {
+                continue;
+            }
+            
+            // Allow DENY to override everything
+            if (region.getFlags().get(flag) == State.DENY) {
+                return false;
+            }
+            
+            // Forget about regions that allow it, although make sure the
+            // default state is now to allow
+            if (region.getFlags().get(flag) == State.ALLOW) {
+                allowed = true;
+                found = true;
+                continue;
+            }
+            
+            // Ignore lower priority regions
+            if (found && region.getPriority() < lastPriority) {
+                break;
+            }
+            
+            if (player != null) {
+                if (hasCleared.contains(region)) {
+                    // Already cleared, so do nothing
+                } else {
+                    if (!region.isMember(player)) {
+                        needsClear.add(region);
+                    } else {
+                        // Need to clear all parents
+                        clearParents(needsClear, hasCleared, region);
+                    }
+                }
+            }
+            
+            found = true;
+            lastPriority = region.getPriority();
+        }
+        
+        return (found == false ? def : allowed)
+                || (player != null && needsClear.size() == 0);
+    }
+    
+    /**
+     * Clear a region's parents for isFlagAllowed().
+     * 
+     * @param needsClear
+     * @param hasCleared
+     * @param region
+     */
+    private void clearParents(Set<ProtectedRegion> needsClear,
+            Set<ProtectedRegion> hasCleared, ProtectedRegion region) {
+        ProtectedRegion parent = region.getParent();
+        
+        while (parent != null) {
+            if (!needsClear.remove(parent)) {
+                hasCleared.add(parent);
+            }
+            
+            parent = parent.getParent();
+        }
+    }
+}

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

@@ -0,0 +1,145 @@
+// $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.Set;
+
+/**
+ * Holds the flags for a region.
+ * 
+ * @author sk89q
+ */
+public class AreaFlags {
+    public enum State {
+        NONE,
+        ALLOW,
+        DENY,
+    };
+
+    public static final String FLAG_PASSTHROUGH = "z";
+    public static final String FLAG_BUILD = "b";
+    public static final String FLAG_PVP = "p";
+    public static final String FLAG_MOB_DAMAGE = "m";
+    public static final String FLAG_CREEPER_EXPLOSION = "c";
+    public static final String FLAG_TNT = "t";
+    public static final String FLAG_LIGHTER = "l";
+    public static final String FLAG_FIRE_SPREAD = "f";
+    public static final String FLAG_LAVA_FIRE = "F";
+    public static final String FLAG_CHEST_ACCESS = "C";
+    
+    /**
+     * Get the user-friendly name of a flag. If a name isn't known, then
+     * the flag is returned unchanged.
+     * 
+     * @param flag
+     * @return
+     */
+    public static String getFlagName(String flag) {
+        if (flag.equals(FLAG_PASSTHROUGH)) {
+            return "passthrough";
+        } else if (flag.equals(FLAG_BUILD)) {
+            return "build";
+        } else if (flag.equals(FLAG_PVP)) {
+            return "PvP";
+        } else if (flag.equals(FLAG_MOB_DAMAGE)) {
+            return "mob damage";
+        } else if (flag.equals(FLAG_CREEPER_EXPLOSION)) {
+            return "creeper explosion";
+        } else if (flag.equals(FLAG_TNT)) {
+            return "TNT";
+        } else if (flag.equals(FLAG_LIGHTER)) {
+            return "lighter";
+        } else if (flag.equals(FLAG_FIRE_SPREAD)) {
+            return "fire spread";
+        } else if (flag.equals(FLAG_LAVA_FIRE)) {
+            return "lava fire spread";
+        } else if (flag.equals(FLAG_CHEST_ACCESS)) {
+            return "chest access";
+        } else {
+            return flag;
+        }
+    }
+    
+    /**
+     * Gets a flag from an alias. May return null.
+     * 
+     * @param name
+     * @return
+     */
+    public static String fromAlias(String name) {
+        if (name.equalsIgnoreCase("passthrough")) {
+            return FLAG_PASSTHROUGH;
+        } else if (name.equalsIgnoreCase("build")) {
+            return FLAG_BUILD;
+        } else if (name.equalsIgnoreCase("pvp")) {
+            return FLAG_PVP;
+        } else if (name.equalsIgnoreCase("mobdamage")) {
+            return FLAG_MOB_DAMAGE;
+        } else if (name.equalsIgnoreCase("creeper")) {
+            return FLAG_CREEPER_EXPLOSION;
+        } else if (name.equalsIgnoreCase("tnt")) {
+            return FLAG_TNT;
+        } else if (name.equalsIgnoreCase("lighter")) {
+            return FLAG_LIGHTER;
+        } else if (name.equalsIgnoreCase("firespread")) {
+            return FLAG_FIRE_SPREAD;
+        } else if (name.equalsIgnoreCase("lavafirespread")) {
+            return FLAG_LAVA_FIRE;
+        } else if (name.equalsIgnoreCase("chest")) {
+            return FLAG_CHEST_ACCESS;
+        } else {
+            return null;
+        }
+    }
+    
+    private Map<String, State> states = new HashMap<String, State>();
+    
+    public State get(String flag) {
+        State state = states.get(flag);
+        if (state == null) {
+            return State.NONE;
+        }
+        return state;
+    }
+    
+    public void set(String flag, State state) {
+        if (state == State.NONE) {
+            states.remove(flag);
+        } else {
+            states.put(flag, state);
+        }
+    }
+    
+    public Set<Map.Entry<String, State>> entrySet() {
+        return states.entrySet();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if (!(obj instanceof AreaFlags)) {
+            return false;
+        }
+        
+        AreaFlags other = (AreaFlags)obj;
+        return other.states.equals(this);
+    }
+}

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

@@ -17,12 +17,8 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-package com.sk89q.worldguard.protection.databases;
+package com.sk89q.worldguard.protection;
 
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.flags.StateFlag.State;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -31,11 +27,12 @@ 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.worldedit.Vector;
 import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
+import com.sk89q.worldguard.protection.AreaFlags.State;
+import com.sk89q.worldguard.protection.ProtectedRegion.CircularInheritanceException;
 import com.sk89q.worldguard.util.ArrayReader;
 
 /**
@@ -43,7 +40,7 @@ import com.sk89q.worldguard.util.ArrayReader;
  * 
  * @author sk89q
  */
-public class CSVDatabase extends AbstractProtectionDatabase {
+public class CSVDatabase implements ProtectionDatabase {
     private static Logger logger = Logger.getLogger("Minecraft.WorldGuard");
     
     /**
@@ -68,13 +65,54 @@ public class CSVDatabase extends AbstractProtectionDatabase {
     /**
      * Saves the database.
      */
+    @Override
     public void save() throws IOException {
-        throw new UnsupportedOperationException("CSV format is no longer implemented");
+        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.2",
+                        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()),
+                        cuboid.getParent() != null ? cuboid.getParent().getId() : "",
+                        writeDomains(cuboid.getOwners()),
+                        writeDomains(cuboid.getMembers()),
+                        writeFlags(cuboid.getFlags()),
+                        cuboid.getEnterMessage() != null ? cuboid.getEnterMessage() : "",
+                        cuboid.getLeaveMessage() != null ? cuboid.getLeaveMessage() : "",
+                        });
+            }
+        } 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>();
@@ -92,7 +130,7 @@ public class CSVDatabase extends AbstractProtectionDatabase {
                     continue;
                 }
                 
-                String id = line[0].toLowerCase().replace(".", "");
+                String id = line[0].toLowerCase();
                 String type = line[1];
                 ArrayReader<String> entries = new ArrayReader<String>(line);
                 
@@ -117,12 +155,13 @@ public class CSVDatabase extends AbstractProtectionDatabase {
                     int priority = entries.get(8) == null ? 0 : Integer.parseInt(entries.get(8));
                     String ownersData = entries.get(9);
                     String flagsData = entries.get(10);
-                    //String enterMessage = nullEmptyString(entries.get(11));
+                    String enterMessage = nullEmptyString(entries.get(11));
                     
                     ProtectedRegion region = new ProtectedCuboidRegion(id, min, max);
                     region.setPriority(priority);
-                    parseFlags(region, flagsData);
+                    region.setFlags(parseFlags(flagsData));
                     region.setOwners(this.parseDomains(ownersData));
+                    region.setEnterMessage(enterMessage);
                     regions.put(id, region);
                 } else if (type.equalsIgnoreCase("cuboid.2")) {
                     Vector pt1 = new Vector(
@@ -142,14 +181,16 @@ public class CSVDatabase extends AbstractProtectionDatabase {
                     String ownersData = entries.get(10);
                     String membersData = entries.get(11);
                     String flagsData = entries.get(12);
-                    //String enterMessage = nullEmptyString(entries.get(13));
-                    //String leaveMessage = nullEmptyString(entries.get(14));
+                    String enterMessage = nullEmptyString(entries.get(13));
+                    String leaveMessage = nullEmptyString(entries.get(14));
                     
                     ProtectedRegion region = new ProtectedCuboidRegion(id, min, max);
                     region.setPriority(priority);
-                    parseFlags(region, flagsData);
+                    region.setFlags(parseFlags(flagsData));
                     region.setOwners(this.parseDomains(ownersData));
                     region.setMembers(this.parseDomains(membersData));
+                    region.setEnterMessage(enterMessage);
+                    region.setLeaveMessage(leaveMessage);
                     regions.put(id, region);
                     
                     // Link children to parents later
@@ -181,6 +222,26 @@ public class CSVDatabase extends AbstractProtectionDatabase {
         
         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.
@@ -229,12 +290,14 @@ public class CSVDatabase extends AbstractProtectionDatabase {
      * Used to parse the list of flags.
      * 
      * @param data
+     * @return
      */
-    private void parseFlags(ProtectedRegion region, String data) {
+    private AreaFlags parseFlags(String data) {
         if (data == null) {
-            return;
+            return new AreaFlags();
         }
         
+        AreaFlags flags = new AreaFlags();
         State curState = State.ALLOW;
         
         for (int i = 0; i < data.length(); i++) {
@@ -244,38 +307,31 @@ public class CSVDatabase extends AbstractProtectionDatabase {
             } else if (k == '-') {
                 curState = State.DENY;
             } else {
-                String flagStr;
+                String flag;
                 if (k == '_') {
                     if (i == data.length() - 1) {
                         logger.warning("_ read ahead fail");
                         break;
                     }
-                    flagStr = "_" + data.charAt(i + 1);
+                    flag = "_" + data.charAt(i + 1);
                     i++;
-
-                    logger.warning("_? custom flags are no longer supported");
-                    continue;
                 } else {
-                    flagStr = String.valueOf(k);
-                }
-                
-                StateFlag flag = DefaultFlag.getLegacyFlag(flagStr);
-                if (flag != null) {
-                    region.setFlag(flag, curState);
-                } else {
-                    logger.warning("Legacy flag '" + flagStr + "' is unsupported");
+                    flag = String.valueOf(k);
                 }
+                flags.set(flag, curState);
             }
         }
+        
+        return flags;
     }
-
+    
     /**
      * Used to write the list of domains.
      * 
      * @param domain
      * @return
      */
-/*    private String writeDomains(DefaultDomain domain) {
+    private String writeDomains(DefaultDomain domain) {
         StringBuilder str = new StringBuilder();
         
         for (String player : domain.getPlayers()) {
@@ -288,7 +344,7 @@ public class CSVDatabase extends AbstractProtectionDatabase {
         
         return str.length() > 0 ?
                 str.toString().substring(0, str.length() - 1) : "";
-    }*/
+    }
     
     /**
      * Helper method to prepend '+' or '-' in front of a flag according
@@ -298,7 +354,6 @@ public class CSVDatabase extends AbstractProtectionDatabase {
      * @param flag
      * @return
      */
-/*
     private String writeFlag(State state, String flag) {
         if (state == State.ALLOW) {
             return "+" + flag;
@@ -308,15 +363,14 @@ public class CSVDatabase extends AbstractProtectionDatabase {
         
         return "";
     }
-*/
-
+    
     /**
      * Returns a null if a string is null or empty.
      * 
      * @param str
      * @return
      */
-    protected String nullEmptyString(String str) {
+    private String nullEmptyString(String str) {
         if (str == null) {
             return null;
         } else if (str.length() == 0) {
@@ -325,6 +379,20 @@ public class CSVDatabase extends AbstractProtectionDatabase {
             return str;
         }
     }
+    
+    /**
+     * Used to write the list of flags.
+     * 
+     * @param flags
+     * @return
+     */
+    private String writeFlags(AreaFlags flags) {
+        StringBuilder str = new StringBuilder();
+        for (Map.Entry<String, State> entry : flags.entrySet()) {
+            str.append(writeFlag(entry.getValue(), entry.getKey()));
+        }
+        return str.toString();
+    }
 
     /**
      * Get a list of protected regions.
@@ -337,6 +405,8 @@ public class CSVDatabase extends AbstractProtectionDatabase {
 
     /**
      * Get a list of protected regions.
+     *
+     * @return
      */
     public void setRegions(Map<String,ProtectedRegion> regions) {
         this.regions = regions;

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

@@ -17,21 +17,24 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-package com.sk89q.worldguard.util.yaml;
+package com.sk89q.worldguard.protection;
 
-/**
- * Configuration exception.
- * 
- * @author sk89q
- */
-public class ConfigurationException extends Exception {
-    private static final long serialVersionUID = -2442886939908724203L;
-    
-    public ConfigurationException() {
-        super();
-    }
-    
-    public ConfigurationException(String msg) {
-        super(msg);
+import java.util.Comparator;
+
+class DescendingPriorityComparator implements Comparator<ProtectedRegion> {
+    /**
+     * Compares two regions.
+     * 
+     * @param other
+     * @return
+     */
+    public int compare(ProtectedRegion r1, ProtectedRegion r2) {
+        if (r1.getPriority() == r2.getPriority()) {
+            return 0;
+        } else if (r1.getPriority() > r2.getPriority()) {
+            return -1;
+        } else {
+            return 1;
+        }
     }
 }

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

@@ -0,0 +1,183 @@
+// $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.SortedMap;
+import java.util.TreeMap;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+/**
+ * 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;
+    /**
+     * Global flags.
+     */
+    private GlobalFlags global;
+    
+    /**
+     * Construct the manager.
+     */
+    public FlatRegionManager(GlobalFlags global) {
+        regions = new TreeMap<String,ProtectedRegion>();
+        this.global = global;
+    }
+    
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions() {
+        return regions;
+    }
+    
+    /**
+     * Set a list of protected regions.
+     *
+     * @return
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions) {
+        this.regions = new TreeMap<String,ProtectedRegion>(regions);
+    }
+    
+    /**
+     * Adds a region.
+     * 
+     * @param id
+     * @param region
+     */
+    public void addRegion(ProtectedRegion region) {
+        regions.put(region.getId(), region);
+    }
+    
+    /**
+     * Removes a region and its children.
+     * 
+     * @param id
+     */
+    public void removeRegion(String id) {
+        ProtectedRegion region = regions.get(id);
+        
+        regions.remove(id);
+        
+        if (region != null) {
+            for (Map.Entry<String, ProtectedRegion> entry : regions.entrySet()) {
+                if (entry.getValue().getParent() == region) {
+                    removeRegion(entry.getKey());
+                }
+            }
+        }
+    }
+    
+    /**
+     * 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);
+    }
+    
+    /**
+     * 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.values().iterator(), global);
+    }
+    
+    /**
+     * 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;
+    }
+    
+    /**
+     * Returns true if the provided region overlaps with any other region that
+     * is not owned by the player.
+     * 
+     * @param region
+     * @param player
+     * @return
+     */
+    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player) {
+        for (ProtectedRegion other : regions.values()) {
+            if (other.getOwners().contains(player)) {
+                continue;
+            }
+            
+            try {
+                if (ProtectedRegion.intersects(region, other)) {
+                    return true;
+                }
+            } catch (UnsupportedIntersectionException e) {
+                // TODO: Maybe do something here
+            }
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Get the number of regions.
+     * 
+     * @return
+     */
+    public int size() {
+        return regions.size();
+    }
+}

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

@@ -17,13 +17,15 @@
  * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
-package com.sk89q.worldguard.protection.flags;
+package com.sk89q.worldguard.protection;
 
-public class InvalidFlagFormat extends Exception {
-    
-    private static final long serialVersionUID = 8101615074524004172L;
-
-    public InvalidFlagFormat(String msg) {
-        super(msg);
-    }
+/**
+ * Used for default flags.
+ * 
+ * @author sk89q
+ */
+public class GlobalFlags {
+    public boolean canBuild = true;
+    public boolean canAccessChests = false;
+    public boolean canPvP = true;
 }

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

@@ -0,0 +1,203 @@
+// $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.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+import org.khelekore.prtree.MBRConverter;
+import org.khelekore.prtree.PRTree;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+
+public class PRTreeRegionManager implements RegionManager {
+    private static final int BRANCH_FACTOR = 30;
+
+    /**
+     * List of protected regions.
+     */
+    private Map<String,ProtectedRegion> regions;
+    /**
+     * Global flags.
+     */
+    private GlobalFlags global;
+    
+    /**
+     * Converter to get coordinates of the tree.
+     */
+    private MBRConverter<ProtectedRegion> converter
+            = new ProtectedRegionMBRConverter();
+    
+    /**
+     * Priority R-tree.
+     */
+    private PRTree<ProtectedRegion> tree;
+
+    /**
+     * Construct the manager.
+     */
+    public PRTreeRegionManager(GlobalFlags global) {
+        regions = new TreeMap<String,ProtectedRegion>();
+        tree = new PRTree<ProtectedRegion>(converter, BRANCH_FACTOR);
+        this.global = global;
+    }
+    
+    /**
+     * Get a list of protected regions.
+     *
+     * @return
+     */
+    public Map<String,ProtectedRegion> getRegions() {
+        return regions;
+    }
+    
+    /**
+     * Set a list of protected regions.
+     *
+     * @return
+     */
+    public void setRegions(Map<String,ProtectedRegion> regions) {
+        this.regions = new TreeMap<String,ProtectedRegion>(regions);
+        tree = new PRTree<ProtectedRegion>(converter, BRANCH_FACTOR);
+        tree.load(regions.values());
+    }
+
+    /**
+     * Adds a region.
+     * 
+     * @param id
+     * @param region
+     */
+    public void addRegion(ProtectedRegion region) {
+        regions.put(region.getId(), region);
+        tree = new PRTree<ProtectedRegion>(converter, BRANCH_FACTOR);
+        tree.load(regions.values());
+    }
+
+    /**
+     * 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);
+    }
+    
+    /**
+     * Removes a region and its children.
+     * 
+     * @param id
+     */
+    public void removeRegion(String id) {
+        ProtectedRegion region = regions.get(id);
+        
+        regions.remove(id);
+        
+        if (region != null) {
+            for (Map.Entry<String, ProtectedRegion> entry : regions.entrySet()) {
+                if (entry.getValue().getParent() == region) {
+                    removeRegion(entry.getKey());
+                }
+            }
+        }
+
+        tree = new PRTree<ProtectedRegion>(converter, BRANCH_FACTOR);
+        tree.load(regions.values());
+    }
+
+    /**
+     * 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.values().iterator(), global);
+    }
+
+    /**
+     * 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>();
+
+        int x = pt.getBlockX();
+        int z = pt.getBlockZ();
+        
+        for (ProtectedRegion region : tree.find(x, z, x, z)) {
+            if (region.contains(pt)) {
+                applicable.add(region.getId());
+            }
+        }
+        
+        return applicable;
+    }
+    
+    /**
+     * Returns true if the provided region overlaps with any other region that
+     * is not owned by the player.
+     * 
+     * @param region
+     * @param player
+     * @return
+     */
+    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player) {
+        for (ProtectedRegion other : regions.values()) {
+            if (other.getOwners().contains(player)) {
+                continue;
+            }
+            
+            try {
+                if (ProtectedRegion.intersects(region, other)) {
+                    return true;
+                }
+            } catch (UnsupportedIntersectionException e) {
+                // TODO: Maybe do something here
+            }
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Get the number of regions.
+     * 
+     * @return
+     */
+    public int size() {
+        return regions.size();
+    }
+
+}

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

@@ -0,0 +1,110 @@
+// $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 id
+     * @param pos1
+     * @param pos2
+     * @param priority
+     */
+    public ProtectedCuboidRegion(String id, BlockVector min, BlockVector max) {
+        super(id);
+        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;
+    }
+
+    /**
+     * Checks to see if a point is inside this region.
+     */
+    @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();
+    }
+    
+    /**
+     * Return the type of region as a user-friendly name.
+     * 
+     * @return type of region
+     */
+    public String getTypeName() {
+        return "cuboid";
+    }
+}

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

@@ -1,406 +1,334 @@
-// $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.regions;
-
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.UnsupportedIntersectionException;
-import com.sk89q.worldguard.protection.flags.Flag;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.regex.Pattern;
-
-/**
- * Represents a region of any shape and size that can be protected.
- * 
- * @author sk89q
- */
-public abstract class ProtectedRegion implements Comparable<ProtectedRegion> {
-    
-    private static final Pattern idPattern = Pattern.compile("^[A-Za-z0-9_,'\\-\\+/]{1,}$");
-    
-    /**
-     * Holds the region's ID.
-     */
-    private String id;
-    
-    /**
-     * Priority.
-     */
-    private int priority = 0;
-    
-    /**
-     * Holds the curParent.
-     */
-    private ProtectedRegion parent;
-    
-    /**
-     * List of owners.
-     */
-    private DefaultDomain owners = new DefaultDomain();
-    
-    /**
-     * List of members.
-     */
-    private DefaultDomain members = new DefaultDomain();
-    
-    /**
-     * List of flags.
-     */
-    private Map<Flag<?>, Object> flags = new HashMap<Flag<?>, Object>();
-
-    /**
-     * Construct a new instance of this region.
-     *
-     * @param id
-     */
-    public ProtectedRegion(String id) {
-        this.id = id;
-    }
-
-    /**
-     * @return the id
-     */
-    public String getId() {
-        return id;
-    }
-
-    /**
-     * Get the lower point of the cuboid.
-     *
-     * @return min point
-     */
-    public abstract BlockVector getMinimumPoint();
-
-    /**
-     * Get the upper point of the cuboid.
-     *
-     * @return max point
-     */
-    public abstract BlockVector getMaximumPoint();
-
-    /**
-     * @return the priority
-     */
-    public int getPriority() {
-        return priority;
-    }
-
-    /**
-     * @param priority the priority to setFlag
-     */
-    public void setPriority(int priority) {
-        this.priority = priority;
-    }
-    
-    /**
-     * @return the curParent
-     */
-    public ProtectedRegion getParent() {
-        return parent;
-    }
-
-    /**
-     * Set the curParent. This checks to make sure that it will not result
-     * in circular inheritance.
-     * 
-     * @param parent the curParent to setFlag
-     * @throws CircularInheritanceException 
-     */
-    public void setParent(ProtectedRegion parent) throws CircularInheritanceException {
-        if (parent == null) {
-            this.parent = null;
-            return;
-        }
-        
-        if (parent == this) {
-            throw new CircularInheritanceException();
-        }
-        
-        ProtectedRegion p = parent.getParent();
-        while (p != null) {
-            if (p == this) {
-                throw new CircularInheritanceException();
-            }
-            p = p.getParent();
-        }
-        
-        this.parent = parent;
-    }
-
-
-    /**
-     * @return the owners
-     */
-    public DefaultDomain getOwners() {
-
-        return owners;
-    }
-
-    /**
-     * @param owners the owners to setFlag
-     */
-    public void setOwners(DefaultDomain owners) {
-        this.owners = owners;
-    }
-
-    /**
-     * @return the members
-     */
-    public DefaultDomain getMembers() {
-        return members;
-    }
-
-    /**
-     * @param members the members to setFlag
-     */
-    public void setMembers(DefaultDomain members) {
-        this.members = members;
-    }
-
-    /**
-     * Checks whether a region has members or owners.
-     * 
-     * @return whether there are members or owners
-     */
-    public boolean hasMembersOrOwners() {
-        return owners.size() > 0 || members.size() > 0;
-    }
-    
-    /**
-     * Checks whether a player is an owner of region or any of its parents.
-     * 
-     * @param player player to check
-     * @return whether an owner
-     */
-    public boolean isOwner(LocalPlayer player) {
-        if (owners.contains(player)) {
-            return true;
-        }
-        
-        ProtectedRegion curParent = getParent();
-        while (curParent != null) {
-            if (curParent.getOwners().contains(player)) {
-                return true;
-            }
-            
-            curParent = curParent.getParent();
-        }
-        
-        return false;
-    }
-
-    /**
-     * Checks whether a player is a member OR OWNER of the region
-     * or any of its parents.
-     * 
-     * @param player player to check
-     * @return whether an owner or member
-     */
-    public boolean isMember(LocalPlayer player) {
-        if (owners.contains(player) || members.contains(player)) {
-            return true;
-        }
-        
-        ProtectedRegion curParent = getParent();
-        while (curParent != null) {
-            if (curParent.getOwners().contains(player)
-                    || curParent.getMembers().contains(player)) {
-                return true;
-            }
-            
-            curParent = curParent.getParent();
-        }
-        
-        return false;
-    }
-
-    /**
-     * Checks whether a player is a member of the region
-     * or any of its parents.
-     *
-     * @param player player to check
-     * @return whether an member
-     */
-    public boolean isMemberOnly(LocalPlayer player) {
-        if (members.contains(player)) {
-            return true;
-        }
-
-        ProtectedRegion curParent = getParent();
-        while (curParent != null) {
-            if (curParent.getMembers().contains(player)) {
-                return true;
-            }
-
-            curParent = curParent.getParent();
-        }
-
-        return false;
-    }
-    
-    /**
-     * Get a flag's value.
-     * 
-     * @param <T>
-     * @param <V>
-     * @param flag
-     * @return value or null if isn't defined
-     */
-    @SuppressWarnings("unchecked")
-    public <T extends Flag<V>, V> V getFlag(T flag) {
-        Object obj = flags.get(flag);
-        V val;
-        if (obj != null) {
-            val = (V) obj;
-        } else {
-            return null;
-        }
-        return val;
-    }
-    
-    /**
-     * Set a flag's value.
-     * 
-     * @param <T>
-     * @param <V>
-     * @param flag
-     * @param val
-     */
-    public <T extends Flag<V>, V> void setFlag(T flag, V val) {
-        if (val == null) {
-            flags.remove(flag);
-        } else {
-            flags.put(flag, val);
-        }
-    }
-    
-    /**
-     * Get the map of flags.
-     * 
-     * @return
-     */
-    public Map<Flag<?>, Object> getFlags() {
-        return flags;
-    }
-    
-    /**
-     * Get the map of flags.
-     * 
-     * @param flags 
-     */
-    public void setFlags(Map<Flag<?>, Object> flags) {
-        this.flags = flags;
-    }
-
-    /**
-     * Get the number of blocks in this region
-     * 
-     * @return
-     */
-    public abstract int volume();
-    
-    /**
-     * Check to see if a point is inside this region.
-     * 
-     * @param pt
-     * @return
-     */
-    public abstract boolean contains(Vector pt);
-    
-    /**
-     * Compares to another region.
-     * 
-     * @param other
-     * @return
-     */
-    public int compareTo(ProtectedRegion other) {
-        if (id.equals(other.id)) {
-            return 0;
-        } else if (priority == other.priority) {
-            return 1;
-        } else if (priority > other.priority) {
-            return -1;
-        } else {
-            return 1;
-        }
-    }
-
-    /**
-     * Return the type of region as a user-friendly, lowercase name.
-     * 
-     * @return type of region
-     */
-    public abstract String getTypeName();
-
-    /**
-     * Get a list of intersecting regions.
-     * 
-     * @param regions
-     * @return
-     * @throws UnsupportedIntersectionException
-     */
-    public abstract List<ProtectedRegion> getIntersectingRegions(
-            List<ProtectedRegion> regions)
-            throws UnsupportedIntersectionException;
-    
-    /**
-     * Checks to see if the given ID is accurate.
-     * 
-     * @param id
-     * @return
-     */
-    public static boolean isValidId(String id) {
-        return idPattern.matcher(id).matches();
-    }
-    
-    /**
-     * Returns the hash code.
-     */
-    @Override
-    public int hashCode(){
-        return id.hashCode();
-    }
-    
-    /**
-     * Returns whether this region has the same ID as another region.
-     */
-    @Override
-    public boolean equals(Object obj) {
-        if (!(obj instanceof ProtectedRegion)) {
-            return false;
-        }
-        
-        ProtectedRegion other = (ProtectedRegion) obj;
-        return other.getId().equals(getId());
-    }
-    
-    /**
-     * Thrown when setting a curParent would create a circular inheritance
-     * situation.
-     * 
-     */
-    public static class CircularInheritanceException extends Exception {
-        private static final long serialVersionUID = 7479613488496776022L;
-    }
-}
+// $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.BlockVector;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.domains.DefaultDomain;
+
+/**
+ * Represents a region of any shape and size that can be protected.
+ * 
+ * @author sk89q
+ */
+public abstract class ProtectedRegion implements Comparable<ProtectedRegion> {
+    /**
+     * Holds the region's ID.
+     */
+    private String id;
+    /**
+     * Priority.
+     */
+    private int priority = 0;
+    /**
+     * Parent region.
+     */
+    private ProtectedRegion parent;
+    /**
+     * List of owners.
+     */
+    private DefaultDomain owners = new DefaultDomain();
+    /**
+     * List of members.
+     */
+    private DefaultDomain members = new DefaultDomain();
+    /**
+     * Area flags.
+     */
+    private AreaFlags flags = new AreaFlags();
+    /**
+     * Area message.
+     */
+    private String enterMessage;
+    /**
+     * Area message.
+     */
+    private String leaveMessage;
+
+    /**
+     * Construct a new instance of this region.
+     *
+     * @param id
+     */
+    public ProtectedRegion(String id) {
+        this.id = id;
+    }
+
+    /**
+     * @return the id
+     */
+    public String getId() {
+        return id;
+    }
+
+    /**
+     * Get the lower point of the cuboid.
+     *
+     * @return min point
+     */
+    public abstract BlockVector getMinimumPoint();
+
+    /**
+     * Get the upper point of the cuboid.
+     *
+     * @return max point
+     */
+    public abstract BlockVector getMaximumPoint();
+
+    /**
+     * @return the priority
+     */
+    public int getPriority() {
+        return priority;
+    }
+
+    /**
+     * @param priority the priority to set
+     */
+    public void setPriority(int priority) {
+        this.priority = priority;
+    }
+    
+    /**
+     * @return the parent
+     */
+    public ProtectedRegion getParent() {
+        return parent;
+    }
+
+    /**
+     * Set the parent. This checks to make sure that it will not result
+     * in circular inheritance.
+     * 
+     * @param parent the parent to set
+     * @throws CircularInheritanceException 
+     */
+    public void setParent(ProtectedRegion parent) throws CircularInheritanceException {
+        if (parent == null) {
+            this.parent = null;
+            return;
+        }
+        
+        if (parent == this) {
+            throw new CircularInheritanceException();
+        }
+        
+        ProtectedRegion p = parent.getParent();
+        while (p != null) {
+            if (p == this) {
+                throw new CircularInheritanceException();
+            }
+            p = p.getParent();
+        }
+        
+        this.parent = parent;
+    }
+
+    /**
+     * 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 leaveMessage
+     */
+    public String getLeaveMessage() {
+        return leaveMessage;
+    }
+
+    /**
+     * @param leaveMessage the leaveMessage to set
+     */
+    public void setLeaveMessage(String leaveMessage) {
+        this.leaveMessage = leaveMessage;
+    }
+
+    /**
+     * @return the owners
+     */
+    public DefaultDomain getOwners() {
+        return owners;
+    }
+
+    /**
+     * @param owners the owners to set
+     */
+    public void setOwners(DefaultDomain owners) {
+        this.owners = owners;
+    }
+
+    /**
+     * @return the members
+     */
+    public DefaultDomain getMembers() {
+        return members;
+    }
+
+    /**
+     * @param owners the owners to set
+     */
+    public void setMembers(DefaultDomain members) {
+        this.members = members;
+    }
+    
+    /**
+     * Checks whether a player is an owner of region or any of its parents.
+     * 
+     * @param player
+     * @return
+     */
+    public boolean isOwner(LocalPlayer player) {
+        if (owners.contains(player)) {
+            return true;
+        }
+        
+        ProtectedRegion parent = getParent();
+        while (parent != null) {
+            if (parent.getOwners().contains(player)) {
+                return true;
+            }
+            
+            parent = parent.getParent();
+        }
+        
+        return false;
+    }
+    
+    /**
+     * Checks whether a player is a member of the region or any of its parents.
+     * 
+     * @param player
+     * @return
+     */
+    public boolean isMember(LocalPlayer player) {
+        if (owners.contains(player) || members.contains(player)) {
+            return true;
+        }
+        
+        ProtectedRegion parent = getParent();
+        while (parent != null) {
+            if (parent.getOwners().contains(player)
+                    || parent.getMembers().contains(player)) {
+                return true;
+            }
+            
+            parent = parent.getParent();
+        }
+        
+        return false;
+    }
+
+    /**
+     * 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);
+    
+    /**
+     * Compares to another region.
+     * 
+     * @param other
+     * @return
+     */
+    public int compareTo(ProtectedRegion other) {
+        if (priority == other.priority) {
+            return 0;
+        } else if (priority > other.priority) {
+            return -1;
+        } else {
+            return 1;
+        }
+    }
+    
+    /**
+     * Return the type of region as a user-friendly, lowercase name.
+     * 
+     * @return type of region
+     */
+    public abstract String getTypeName();
+    
+    /**
+     * Checks if two region intersects.
+     * 
+     * @param region1
+     * @param region2
+     * @throws UnsupportedIntersectionException
+     * @return
+     */
+    public static boolean intersects(ProtectedRegion region1, ProtectedRegion region2)
+            throws UnsupportedIntersectionException {
+        if (region1 instanceof ProtectedCuboidRegion
+                && region2 instanceof ProtectedCuboidRegion) {
+            ProtectedCuboidRegion r1 = (ProtectedCuboidRegion)region1;
+            ProtectedCuboidRegion r2 = (ProtectedCuboidRegion)region2;
+            BlockVector min1 = r1.getMinimumPoint();
+            BlockVector max1 = r1.getMaximumPoint();
+            BlockVector min2 = r2.getMinimumPoint();
+            BlockVector max2 = r2.getMaximumPoint(); 
+            
+            return !(min1.getBlockX() > max2.getBlockX()
+                    || min1.getBlockY() > max2.getBlockY()
+                    || min1.getBlockZ() > max2.getBlockZ()
+                    || max1.getBlockX() < min2.getBlockX()
+                    || max1.getBlockY() < min2.getBlockY()
+                    || max1.getBlockZ() < min2.getBlockZ());
+        } else {
+            throw new UnsupportedIntersectionException();
+        }
+    }
+    
+    /**
+     * Thrown when setting a parent would create a circular inheritance
+     * situation.
+     * 
+     */
+    public static class CircularInheritanceException extends Exception {
+        private static final long serialVersionUID = 7479613488496776022L;
+    }
+}

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

@@ -1,41 +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.regions;
-
-import org.khelekore.prtree.MBRConverter;
-
-public class ProtectedRegionMBRConverter implements MBRConverter<ProtectedRegion> {
-    public double getMinX(ProtectedRegion t) {
-        return t.getMinimumPoint().getBlockX();
-    }
-
-    public double getMinY(ProtectedRegion t) {
-        return t.getMinimumPoint().getBlockZ();
-    }
-
-    public double getMaxX(ProtectedRegion t) {
-        return t.getMaximumPoint().getBlockX();
-    }
-
-    public double getMaxY(ProtectedRegion t) {
-        return t.getMaximumPoint().getBlockZ();
-    }
-
-}
+// $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.khelekore.prtree.MBRConverter;
+
+public class ProtectedRegionMBRConverter implements MBRConverter<ProtectedRegion> {
+    public double getMinX(ProtectedRegion t) {
+        return t.getMinimumPoint().getBlockX();
+    }
+
+    public double getMinY(ProtectedRegion t) {
+        return t.getMinimumPoint().getBlockZ();
+    }
+
+    public double getMaxX(ProtectedRegion t) {
+        return t.getMaximumPoint().getBlockX();
+    }
+
+    public double getMaxY(ProtectedRegion t) {
+        return t.getMaximumPoint().getBlockZ();
+    }
+
+}

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

@@ -1,72 +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.databases;
-
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-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.
-     * 
-     * @param manager 
-     * @throws IOException
-     */
-    public void load(RegionManager manager) throws IOException;
-    /**
-     * Save the list of regions from a region manager.
-     * 
-     * @param 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);
-}
+// $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,112 @@
+// $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;
+import com.sk89q.worldguard.LocalPlayer;
+
+/**
+ * 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(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, including inheriting children.
+     * 
+     * @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);
+    
+    /**
+     * Returns true if the provided region overlaps with any other region that
+     * is not owned by the player.
+     * 
+     * @param region
+     * @param player
+     * @return
+     */
+    public boolean overlapsUnownedRegion(ProtectedRegion region, LocalPlayer player);
+    
+    /**
+     * Get the number of regions.
+     * 
+     * @return
+     */
+    public int size();
+}

src/main/assembly/default.xml

@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<assembly
-  xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2"
-  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-  xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.2 http://maven.apache.org/xsd/assembly-1.1.2.xsd">
-  <id>default</id>
-  <includeBaseDirectory>false</includeBaseDirectory>
-  <formats>
-    <format>tar.gz</format>
-    <format>tar.bz2</format>
-    <format>zip</format>
-  </formats>
-  <files>
-    <file>
-      <source>${project.build.directory}/${artifactId}-${project.version}.jar</source>
-      <destName>WorldGuard.jar</destName>
-      <outputDirectory>/</outputDirectory>
-      <filtered>false</filtered>
-    </file>
-    <file>
-      <source>README.html</source>
-      <outputDirectory>/</outputDirectory>
-      <filtered>true</filtered>
-    </file>
-  </files>
-  <fileSets>
-    <fileSet>
-      <includes>
-        <include>LICENSE.txt</include>
-        <include>NOTICE.txt</include>
-        <include>blacklist_table.sql</include>
-      </includes>
-    </fileSet>
-  </fileSets>
-</assembly>

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

@@ -1,222 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import java.util.List;
-
-import com.sk89q.worldedit.blocks.BlockType;
-import org.bukkit.*;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-
-public class BukkitUtil {
-
-
-    private BukkitUtil()  {
-    }
-    
-    /**
-     * Converts the location of a Bukkit block to a WorldEdit vector.
-     * 
-     * @param block
-     * @return
-     */
-    public static BlockVector toVector(Block block) {
-        return new BlockVector(block.getX(), block.getY(), block.getZ());
-    }
-    
-    /**
-     * Converts a Bukkit location to a WorldEdit vector.
-     * 
-     * @param loc
-     * @return
-     */
-    public static Vector toVector(Location loc) {
-        return new Vector(loc.getX(), loc.getY(), loc.getZ());
-    }
-    
-    /**
-     * Converts a Bukkit vector to a WorldEdit vector.
-     * 
-     * @param vector
-     * @return
-     */
-    public static Vector toVector(org.bukkit.util.Vector vector) {
-        return new Vector(vector.getX(), vector.getY(), vector.getZ());
-    }
-
-    /**
-     * Converts a WorldEdit vector to a Bukkit location.
-     * 
-     * @param world
-     * @param vec 
-     * @return
-     */
-    public static Location toLocation(World world, Vector vec) {
-        return new Location(world, vec.getX(), vec.getY(), vec.getZ());
-    }
-    
-    /**
-     * Matches one player based on name.
-     * 
-     * @param server
-     * @param name
-     * @return
-     */
-    public static Player matchSinglePlayer(Server server, String name) {
-        List<Player> players = server.matchPlayer(name);
-        if (players.size() == 0) {
-            return null;
-        }
-        return players.get(0);
-    }
-    
-    /**
-     * Drops a sign item and removes a sign.
-     * 
-     * @param block
-     */
-    public static void dropSign(Block block) {
-        block.setTypeId(0);
-        block.getWorld().dropItemNaturally(block.getLocation(),
-                new ItemStack(Material.SIGN));
-    }
-
-    /**
-     * Sets the given block to fluid water.
-     * Used by addSpongeWater()
-     * 
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     */
-    public static void setBlockToWater(World world, int ox, int oy, int oz) {
-        Block block = world.getBlockAt(ox, oy, oz);
-        int id = block.getTypeId();
-        if (id == 0) {
-            block.setTypeId(8);
-        }
-    }
-
-    /**
-     * Checks if the given block is water
-     * 
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     * @return 
-     */
-    public static boolean isBlockWater(World world, int ox, int oy, int oz) {
-        Block block = world.getBlockAt(ox, oy, oz);
-        int id = block.getTypeId();
-        if (id == 8 || id == 9) {
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Find a position for the player to stand that is not inside a block.
-     * Blocks above the player will be iteratively tested until there is
-     * a series of two free blocks. The player will be teleported to
-     * that free position.
-     *
-     * @param player
-     */
-    public static void findFreePosition(Player player) {
-        Location loc = player.getLocation();
-        int x = loc.getBlockX();
-        int y = Math.max(0, loc.getBlockY());
-        int origY = y;
-        int z = loc.getBlockZ();
-        World world = player.getWorld();
-
-        byte free = 0;
-
-        while (y <= 129) {
-            if (BlockType.canPassThrough(world.getBlockTypeIdAt(x, y, z))) {
-                free++;
-            } else {
-                free = 0;
-            }
-
-            if (free == 2) {
-                if (y - 1 != origY || y == 1) {
-                    loc.setX(x + 0.5);
-                    loc.setY(y);
-                    loc.setZ(z + 0.5);
-                    if (y <= 2 && world.getBlockAt(x,0,z).getType() == Material.AIR) {
-                        world.getBlockAt(x,0,z).setTypeId(20);
-                        loc.setY(2);
-                    }
-                    player.setFallDistance(0F);
-                    player.teleport(loc);
-                }
-                return;
-            }
-
-            y++;
-        }
-    }
-
-    /**
-     * Replace color macros in a string. The macros are in the form of `[char]
-     * where char represents the color. R is for red, Y is for yellow,
-     * G is for green, C is for cyan, B is for blue, and P is for purple.
-     * The uppercase versions of those are the darker shades, while the
-     * lowercase versions are the lighter shades. For white, it's 'w', and
-     * 0-2 are black, dark grey, and grey, respectively.
-     *
-     * @param str
-     * @return color-coded string
-     */
-    public static String replaceColorMacros(String str) {
-        str = str.replace("&r", ChatColor.RED.toString());
-        str = str.replace("&R", ChatColor.DARK_RED.toString());
-
-        str = str.replace("&y", ChatColor.YELLOW.toString());
-        str = str.replace("&Y", ChatColor.GOLD.toString());
-
-        str = str.replace("&g", ChatColor.GREEN.toString());
-        str = str.replace("&G", ChatColor.DARK_GREEN.toString());
-
-        str = str.replace("&c", ChatColor.AQUA.toString());
-        str = str.replace("&C", ChatColor.DARK_AQUA.toString());
-
-        str = str.replace("&b", ChatColor.BLUE.toString());
-        str = str.replace("&B", ChatColor.DARK_BLUE.toString());
-
-        str = str.replace("&p", ChatColor.LIGHT_PURPLE.toString());
-        str = str.replace("&P", ChatColor.DARK_PURPLE.toString());
-
-        str = str.replace("&0", ChatColor.BLACK.toString());
-        str = str.replace("&1", ChatColor.DARK_GRAY.toString());
-        str = str.replace("&2", ChatColor.GRAY.toString());
-        str = str.replace("&w", ChatColor.WHITE.toString());
-
-        return str;
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/ConfigurationManager.java

@@ -1,228 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.Blacklist;
-import java.io.File;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.bukkit.util.config.Configuration;
-
-/**
- * Represents the global configuration and also delegates configuration
- * for individual worlds.
- * 
- * @author sk89q
- * @author Michael
- */
-public class ConfigurationManager {
-    
-    private static final String CONFIG_HEADER = "#\r\n" +
-            "# WorldGuard's main configuration file\r\n" +
-            "#\r\n" +
-            "# This is the global configuration file. Anything placed into here will\r\n" +
-            "# be applied to all worlds. However, each world has its own configuration\r\n" +
-            "# file to allow you to replace any setting in here for that world only.\r\n" +
-            "#\r\n" +
-            "# About editing this file:\r\n" +
-            "# - DO NOT USE TABS. You MUST use spaces or Bukkit will complain. If\r\n" +
-            "#   you use an editor like Notepad++ (recommended for Windows users), you\r\n" +
-            "#   must configure it to \"replace tabs with spaces.\" In Notepad++, this can\r\n" +
-            "#   be changed in Settings > Preferences > Language Menu.\r\n" +
-            "# - Don't get rid of the indents. They are indented so some entries are\r\n" +
-            "#   in categories (like \"enforce-single-session\" is in the \"protection\"\r\n" +
-            "#   category.\r\n" +
-            "# - If you want to check the format of this file before putting it\r\n" +
-            "#   into WorldGuard, paste it into http://yaml-online-parser.appspot.com/\r\n" +
-            "#   and see if it gives \"ERROR:\".\r\n" +
-            "# - Lines starting with # are comments and so they are ignored.\r\n" +
-            "#\r\n";
-
-    /**
-     * Reference to the plugin.
-     */
-    private WorldGuardPlugin plugin;
-    
-    /**
-     * Holds configurations for different worlds.
-     */
-    private Map<String, WorldConfiguration> worlds;
-    
-    /**
-     * List of people with god mode.
-     */
-    private Set<String> hasGodMode = new HashSet<String>();
-    
-    /**
-     * List of people who can breathe underwater.
-     */
-    private Set<String> hasAmphibious = new HashSet<String>();
-    
-    public boolean suppressTickSyncWarnings;
-    public boolean useRegionsScheduler;
-    public boolean activityHaltToggle = false;
-    public boolean autoGodMode;
-
-    /**
-     * Construct the object.
-     * 
-     * @param plugin
-     */
-    public ConfigurationManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-        this.worlds = new HashMap<String, WorldConfiguration>();
-    }
-
-    /**
-     * Load the configuration.
-     */
-    public void load() {
-        // Create the default configuration file
-        WorldGuardPlugin.createDefaultConfiguration(
-                new File(plugin.getDataFolder(), "config.yml"), "config.yml");
-        
-        Configuration config = plugin.getConfiguration();
-        config.load();
-
-        suppressTickSyncWarnings = config.getBoolean(
-                "suppress-tick-sync-warnings", false);
-        useRegionsScheduler = config.getBoolean(
-                "regions.use-scheduler", true);
-        autoGodMode = config.getBoolean(
-                "auto-invincible-permission", false);
-
-        // Load configurations for each world
-        for (World world : plugin.getServer().getWorlds()) {
-            get(world);
-        }
-
-        try {
-            config.setHeader(CONFIG_HEADER);
-        } catch (Throwable t) {
-        }
-
-        config.save();
-    }
-
-    /**
-     * Unload the configuration.
-     */
-    public void unload() {
-        worlds.clear();
-    }
-
-    /**
-     * Get the configuration for a world.
-     * 
-     * @param world
-     * @return
-     */
-    public WorldConfiguration get(World world) {
-        String worldName = world.getName();
-        WorldConfiguration config = worlds.get(worldName);
-        
-        if (config == null) {
-            config = new WorldConfiguration(plugin, worldName);
-            worlds.put(worldName, config);
-        }
-
-        return config;
-    }
-
-    /**
-     * Forget a player.
-     * 
-     * @param player
-     */
-    public void forgetPlayer(LocalPlayer player) {
-        for (Map.Entry<String, WorldConfiguration> entry
-                : worlds.entrySet()) {
-            
-            // The blacklist needs to forget players
-            Blacklist bl = entry.getValue().getBlacklist();
-            if (bl != null) {
-                bl.forgetPlayer(player);
-            }
-        }
-        
-        hasGodMode.remove(player.getName());
-        hasAmphibious.remove(player.getName());
-    }
-    
-    /**
-     * Enable god mode for a player.
-     * 
-     * @param player
-     */
-    public void enableGodMode(Player player) {
-        hasGodMode.add(player.getName());
-    }
-    
-    /**
-     * Disable god mode for a player.
-     * 
-     * @param player
-     */
-    public void disableGodMode(Player player) {
-        hasGodMode.remove(player.getName());
-    }
-    
-    /**
-     * Check to see if god mode is enabled for a player.
-     * 
-     * @param player
-     * @return 
-     */
-    public boolean hasGodMode(Player player) {
-        return hasGodMode.contains(player.getName());
-    }
-    
-    /**
-     * Enable amphibious mode for a player.
-     * 
-     * @param player
-     */
-    public void enableAmphibiousMode(Player player) {
-        hasAmphibious.add(player.getName());
-    }
-    
-    /**
-     * Disable amphibious mode  for a player.
-     * 
-     * @param player
-     */
-    public void disableAmphibiousMode(Player player) {
-        hasAmphibious.remove(player.getName());
-    }
-    
-    /**
-     * Check to see if amphibious mode  is enabled for a player.
-     * 
-     * @param player
-     * @return 
-     */
-    public boolean hasAmphibiousMode(Player player) {
-        return hasAmphibious.contains(player.getName());
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/FlagStateManager.java

@@ -1,169 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import java.util.HashMap;
-import java.util.Map;
-import org.bukkit.entity.Player;
-import org.bukkit.World;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
-
-/**
- * This processes per-player state information and is also meant to be used
- * as a scheduled task.
- * 
- * @author sk89q
- */
-public class FlagStateManager implements Runnable {
-    
-    public static final int RUN_DELAY = 20;
-    
-    private WorldGuardPlugin plugin;
-    private Map<String, PlayerFlagState> states;
-    
-    /**
-     * Construct the object.
-     * 
-     * @param plugin
-     */
-    public FlagStateManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-        
-        states = new HashMap<String, PlayerFlagState>();
-    }
-
-    /**
-     * Run the task.
-     */
-    public void run() {
-        Player[] players = plugin.getServer().getOnlinePlayers();
-        ConfigurationManager config = plugin.getGlobalStateManager();
-
-        for (Player player : players) {
-            WorldConfiguration worldConfig = config.get(player.getWorld());
-            
-            if (!worldConfig.useRegions) {
-                continue;
-            }
-            
-            PlayerFlagState state;
-            
-            synchronized (this) {
-                state = states.get(player.getName());
-                
-                if (state == null) {
-                    state = new PlayerFlagState();
-                    states.put(player.getName(), state);
-                }
-            }
-
-            Vector playerLocation = toVector(player.getLocation());
-            RegionManager regionManager = plugin.getGlobalRegionManager()
-                    .get(player.getWorld());
-            ApplicableRegionSet applicable = regionManager
-                    .getApplicableRegions(playerLocation);
-            
-            processHeal(applicable, player, state);
-        }
-    }
-    
-    /**
-     * Process healing for a player.
-     * 
-     * @param applicable
-     * @param player
-     * @param state
-     */
-    private void processHeal(ApplicableRegionSet applicable, Player player,
-            PlayerFlagState state) {
-        
-        if (player.getHealth() <= 0) {
-            return;
-        }
-        
-        long now = System.currentTimeMillis();
-
-        Integer healAmount = applicable.getFlag(DefaultFlag.HEAL_AMOUNT);
-        Integer healDelay = applicable.getFlag(DefaultFlag.HEAL_DELAY);
-        
-        if (healAmount == null || healDelay == null || healAmount == 0 || healDelay < 0) {
-            return;
-        }
-
-        if (player.getHealth() >= 20 && healAmount > 0) {
-            return;
-        }
-        
-        if (healDelay <= 0 && healAmount > 0) {
-            player.setHealth(20);
-            state.lastHeal = now;
-        } else if (now - state.lastHeal > healDelay * 1000) {
-            player.setHealth(Math.min(20, Math.max(0, player.getHealth() + healAmount)));
-            state.lastHeal = now;
-        }
-    }
-    
-    /**
-     * Forget a player.
-     * 
-     * @param player
-     */
-    public synchronized void forget(Player player) {
-        states.remove(player.getName());
-    }
-    
-    /**
-     * Get a player's flag state.
-     * 
-     * @param player
-     * @return
-     */
-    public synchronized PlayerFlagState getState(Player player) {
-        PlayerFlagState state = states.get(player.getName());
-        
-        if (state == null) {
-            state = new PlayerFlagState();
-            states.put(player.getName(), state);
-        }
-        
-        return state;
-    }
-    
-    /**
-     * Keeps state per player.
-     */
-    public static class PlayerFlagState {
-        public long lastHeal;
-        public String lastGreeting;
-        public String lastFarewell;
-        public Boolean lastExitAllowed = null;
-        public Boolean notifiedForLeave = false;
-        public Boolean notifiedForEnter = false;
-        public World lastWorld;
-        public int lastBlockX;
-        public int lastBlockY;
-        public int lastBlockZ;
-    }
-
-}

src/main/java/com/sk89q/worldguard/bukkit/LegacyWorldGuardMigration.java

@@ -1,152 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import java.io.*;
-import java.util.logging.Logger;
-import org.bukkit.World;
-import com.sk89q.worldguard.protection.databases.CSVDatabase;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-/**
- * Utility methods for porting from legacy versions.
- * 
- * @author sk89q
- */
-public class LegacyWorldGuardMigration {
-    /**
-     * Logger for messages.
-     */
-    protected static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * Port over the blacklist.
-     * 
-     * @param plugin
-     */
-    public static void migrateBlacklist(WorldGuardPlugin plugin) {
-        World mainWorld = plugin.getServer().getWorlds().get(0);
-        String mainWorldName = mainWorld.getName();
-        String newPath = "worlds/" + mainWorldName + "/blacklist.txt";
-        
-        File oldFile = new File(plugin.getDataFolder(), "blacklist.txt");
-        File newFile = new File(plugin.getDataFolder(), newPath);
-        
-        if (!newFile.exists() && oldFile.exists()) {
-            logger.warning("WorldGuard: WorldGuard will now update your blacklist "
-                    + "from an older version of WorldGuard.");
-            
-            // Need to make root directories
-            newFile.getParentFile().mkdirs();
-            
-            if (copyFile(oldFile, newFile)) {
-                oldFile.renameTo(new File(plugin.getDataFolder(),
-                        "blacklist.txt.old"));
-            } else {
-                logger.warning("WorldGuard: blacklist.txt has been converted " +
-                        "for the main world at " + newPath + "");
-                logger.warning("WorldGuard: Your other worlds currently have no " +
-                		"blacklist defined!");
-            }
-            
-        }
-    }
-
-    /**
-     * Migrate region settings.
-     * 
-     * @param plugin
-     */
-    public static void migrateRegions(WorldGuardPlugin plugin) {
-        try {
-            File oldDatabase = new File(plugin.getDataFolder(), "regions.txt");
-            if (!oldDatabase.exists()) return;
-            
-            logger.info("WorldGuard: The regions database has changed in 4.x. "
-                    + "Your old regions database will be converted to the new format "
-                    + "and set as your primarily world's database.");
-
-            World w = plugin.getServer().getWorlds().get(0);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(w);
-
-            // First load up the old database using the CSV loader
-            CSVDatabase db = new CSVDatabase(oldDatabase);
-            db.load();
-            
-            // Then save the new database
-            mgr.setRegions(db.getRegions());
-            mgr.save();
-            
-            oldDatabase.renameTo(new File(plugin.getDataFolder(), "regions.txt.old"));
-
-            logger.info("WorldGuard: Regions database converted!");
-        } catch (FileNotFoundException e) {
-        } catch (IOException e) {
-            logger.warning("WorldGuard: Failed to load regions: "
-                    + e.getMessage());
-        }
-    }
-
-    /**
-     * Copies a file.
-     * 
-     * @param from
-     * @param to
-     * @return true if successful
-     */
-    private static boolean copyFile(File from, File to) {
-        InputStream in = null;
-        OutputStream out = null;
-        
-        try {
-            in = new FileInputStream(from);
-            out = new FileOutputStream(to);
-
-            byte[] buf = new byte[1024];
-            int len;
-            while ((len = in.read(buf)) > 0) {
-                out.write(buf, 0, len);
-            }
-            
-            in.close();
-            out.close();
-            
-            return true;
-        } catch (FileNotFoundException ex) {
-        } catch (IOException e) {
-        } finally {
-            if (in != null) {
-                try {
-                    in.close();
-                } catch (IOException e) {
-                }
-            }
-            
-            if (out != null) {
-                try {
-                    out.close();
-                } catch (IOException e) {
-                }
-            }
-        }
-        
-        return false;
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/ReportWriter.java

@@ -1,335 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.lang.reflect.*;
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import org.bukkit.Server;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.plugin.Plugin;
-import com.sk89q.worldguard.protection.GlobalRegionManager;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.LogListBlock;
-
-public class ReportWriter {
-
-    private static final SimpleDateFormat dateFmt =
-        new SimpleDateFormat("yyyy-MM-dd kk:mm Z");
-    
-    private Date date = new Date();
-    private StringBuilder output = new StringBuilder();
-    
-    public ReportWriter(WorldGuardPlugin plugin) {
-        appendReportHeader(plugin);
-        appendServerInformation(plugin.getServer());
-        appendPluginInformation(plugin.getServer().getPluginManager().getPlugins());
-        appendWorldInformation(plugin.getServer().getWorlds());
-        appendGlobalConfiguration(plugin.getGlobalStateManager());
-        appendWorldConfigurations(plugin, plugin.getServer().getWorlds(),
-                plugin.getGlobalRegionManager(), plugin.getGlobalStateManager());
-        appendln("-------------");
-        appendln("END OF REPORT");
-        appendln();
-    }
-    
-    protected static String repeat(String str, int n) {
-        if(str == null) {
-            return null;
-        }
-        
-        StringBuilder sb = new StringBuilder();
-        for (int i = 0; i < n; i++) {
-            sb.append(str);
-        }
-        
-        return sb.toString();
-    }
-    
-    protected void appendln(String text) {
-        output.append(text);
-        output.append("\r\n");
-    }
-    
-    protected void appendln(String text, Object ... args) {
-        output.append(String.format(text, args));
-        output.append("\r\n");
-    }
-    
-    protected void append(LogListBlock log) {
-        output.append(log.toString());
-    }
-    
-    protected void appendln() {
-        output.append("\r\n");
-    }
-    
-    protected void appendHeader(String text) {
-        String rule = repeat("-", text.length());
-        output.append(rule);
-        output.append("\r\n");
-        appendln(text);
-        output.append(rule);
-        output.append("\r\n");
-        appendln();
-    }
-    
-    private void appendReportHeader(WorldGuardPlugin plugin) {
-        appendln("WorldGuard Configuration Report");
-        appendln("Generated " + dateFmt.format(date));
-        appendln();
-        appendln("Version: " + plugin.getDescription().getVersion());
-        appendln();
-    }
-    
-    private void appendGlobalConfiguration(ConfigurationManager config) {
-        appendHeader("Global Configuration");
-        
-        LogListBlock log = new LogListBlock();
-        LogListBlock configLog = log.putChild("Configuration");
-        
-        Class<? extends ConfigurationManager> cls = config.getClass();
-        for (Field field : cls.getFields()) {
-            try {
-                Object val = field.get(config);
-                configLog.put(field.getName(), val);
-            } catch (IllegalArgumentException e) {
-                e.printStackTrace();
-            } catch (IllegalAccessException e) {
-            }
-        }
-        
-        append(log);
-        appendln();
-    }
-    
-    private void appendServerInformation(Server server) {
-        appendHeader("Server Information");
-        
-        LogListBlock log = new LogListBlock();
-        
-        Runtime runtime = Runtime.getRuntime();
-
-        log.put("Java", "%s %s (%s)",
-                System.getProperty("java.vendor"),
-                System.getProperty("java.version"),
-                System.getProperty("java.vendor.url"));
-        log.put("Operating system", "%s %s (%s)",
-                System.getProperty("os.name"),
-                System.getProperty("os.version"),
-                System.getProperty("os.arch"));
-        log.put("Available processors", runtime.availableProcessors());
-        log.put("Free memory", runtime.freeMemory() / 1024 / 1024 + " MB");
-        log.put("Max memory", runtime.maxMemory() / 1024 / 1024 + " MB");
-        log.put("Total memory", runtime.totalMemory() / 1024 / 1024 + " MB");
-        log.put("Server ID", server.getServerId());
-        log.put("Server name", server.getServerName());
-        log.put("Implementation", server.getVersion());
-        //log.put("Address", server.getIp(), server.getPort());
-        log.put("Player count", "%d/%d",
-                server.getOnlinePlayers().length, server.getMaxPlayers());
-
-        append(log);
-        appendln();
-    }
-    
-    private void appendPluginInformation(Plugin[] plugins) {
-        appendHeader("Plugins");
-        
-        LogListBlock log = new LogListBlock();
-        
-        for (Plugin plugin : plugins) {
-            log.put(plugin.getDescription().getName(), plugin.getDescription().getVersion());
-        }
-
-        append(log);
-        appendln();
-        
-        /*appendHeader("Plugin Information");
-        
-        log = new LogListBlock();
-        
-        for (Plugin plugin : plugins) {
-            log.putChild(plugin.getDescription().getName())
-                .put("Data folder", plugin.getDataFolder())
-                .put("Website", plugin.getDescription().getWebsite())
-                .put("Entry point", plugin.getDescription().getMain());
-        }
-
-        append(log);
-        appendln();*/
-    }
-    
-    private void appendWorldInformation(List<World> worlds) {
-        appendHeader("Worlds");
-        
-        LogListBlock log = new LogListBlock();
-        
-        int i = 0;
-        for (World world : worlds) {
-            int loadedChunkCount = world.getLoadedChunks().length;
-            
-            LogListBlock worldLog = log.putChild(world.getName() + " (" +  i + ")");
-            LogListBlock infoLog = worldLog.putChild("Information");
-            LogListBlock entitiesLog = worldLog.putChild("Entities");
-            
-            infoLog.put("ID", world.getId());
-            infoLog.put("Environment", world.getEnvironment().toString());
-            infoLog.put("Player count", world.getPlayers().size());
-            infoLog.put("Entity count", world.getEntities().size());
-            infoLog.put("Loaded chunk count", loadedChunkCount);
-            infoLog.put("Spawn location", world.getSpawnLocation());
-            infoLog.put("Raw time", world.getFullTime());
-            
-            Map<Class<? extends Entity>, Integer> entityCounts =
-                    new HashMap<Class<? extends Entity>, Integer>();
-            
-            // Collect entities
-            for (Entity entity : world.getEntities()) {
-                Class<? extends Entity> cls = entity.getClass();
-                
-                if (entityCounts.containsKey(cls)) {
-                    entityCounts.put(cls, entityCounts.get(cls) + 1);
-                } else {
-                    entityCounts.put(cls, 1);
-                }
-            }
-            
-            // Print entities
-            for (Map.Entry<Class<? extends Entity>, Integer> entry
-                    : entityCounts.entrySet()) {
-                entitiesLog.put(entry.getKey().getSimpleName(),
-                        "%d [%f]",
-                        entry.getValue(),
-                        (float) (entry.getValue() / (double) loadedChunkCount));
-            }
-            
-            i++;
-        }
-
-        append(log);
-        appendln();
-    }
-    
-    private void appendWorldConfigurations(WorldGuardPlugin plugin, List<World> worlds,
-            GlobalRegionManager regionMgr, ConfigurationManager mgr) {
-        appendHeader("World Configurations");
-        
-        LogListBlock log = new LogListBlock();
-
-        int i = 0;
-        for (World world : worlds) {
-            LogListBlock worldLog = log.putChild(world.getName() + " (" +  i + ")");
-            LogListBlock infoLog = worldLog.putChild("Information");
-            LogListBlock configLog = worldLog.putChild("Configuration");
-            LogListBlock blacklistLog = worldLog.putChild("Blacklist");
-            LogListBlock regionsLog = worldLog.putChild("Region manager");
-
-            infoLog.put("Configuration file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/config.yml")).getAbsoluteFile());
-
-            infoLog.put("Blacklist file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/blacklist.txt")).getAbsoluteFile());
-            infoLog.put("Regions file", (new File(plugin.getDataFolder(), "worlds/"
-                    + world.getName() + "/regions.yml")).getAbsoluteFile());
-            
-            WorldConfiguration config = mgr.get(world);
-            
-            Class<? extends WorldConfiguration> cls = config.getClass();
-            for (Field field : cls.getFields()) {
-                try {
-                    Object val = field.get(config);
-                    configLog.put(field.getName(), String.valueOf(val));
-                } catch (IllegalArgumentException e) {
-                    e.printStackTrace();
-                } catch (IllegalAccessException e) {
-                }
-            }
-            
-            if (config.getBlacklist() == null) {
-                blacklistLog.put("State", "DISABLED");
-            } else {
-                blacklistLog.put("State", "Enabled");
-                blacklistLog.put("Number of items",
-                        config.getBlacklist().getItemCount());
-                blacklistLog.put("Is whitelist",
-                        config.getBlacklist().isWhitelist());
-            }
-
-            RegionManager worldRegions = regionMgr.get(world);
-
-            regionsLog.put("Type", worldRegions.getClass().getCanonicalName());
-            regionsLog.put("Number of regions", worldRegions.getRegions().size());
-            LogListBlock globalRegionLog = regionsLog.putChild("Global region");
-            
-            ProtectedRegion globalRegion = worldRegions.getRegion("__global__");
-            if (globalRegion == null) {
-                globalRegionLog.put("Status", "UNDEFINED");
-            } else {
-                for (Flag<?> flag : DefaultFlag.getFlags()) {
-                    if (flag instanceof StateFlag) {
-                        globalRegionLog.put(flag.getName(),
-                                globalRegion.getFlag(flag));
-                    }
-                }
-            }
-        }
-
-        append(log);
-        appendln();
-    }
-    
-    public void write(File file) throws IOException {
-        FileWriter writer = null;
-        BufferedWriter out;
-        
-        try {
-            writer = new FileWriter(file);
-            out = new BufferedWriter(writer);
-            out.write(output.toString());
-            out.close();
-        } finally {
-            if (writer != null) {
-                try {
-                    writer.close();
-                } catch (IOException e) {
-                }
-            }
-        }
-    }
-    
-    @Override
-    public String toString() {
-        return output.toString();
-    }
-    
-}

src/main/java/com/sk89q/worldguard/bukkit/SpongeUtil.java

@@ -1,124 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
-import org.bukkit.World;
-
-public class SpongeUtil {
-
-    /**
-     * Remove water around a sponge.
-     * 
-     * @param plugin 
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     */
-    public static void clearSpongeWater(WorldGuardPlugin plugin, World world, int ox, int oy, int oz) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
-            for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
-                for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
-                    if (isBlockWater(world, ox + cx, oy + cy, oz + cz)) {
-                        world.getBlockAt(ox + cx, oy + cy, oz + cz).setTypeId(0);
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Add water around a sponge.
-     * 
-     * @param plugin 
-     * @param world
-     * @param ox
-     * @param oy
-     * @param oz
-     */
-    public static void addSpongeWater(WorldGuardPlugin plugin, World world, int ox, int oy, int oz) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        // The negative x edge
-        int cx = ox - wcfg.spongeRadius - 1;
-        for (int cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx + 1, cy, cz);
-                }
-            }
-        }
-
-        // The positive x edge
-        cx = ox + wcfg.spongeRadius + 1;
-        for (int cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx - 1, cy, cz);
-                }
-            }
-        }
-
-        // The negative y edge
-        int cy = oy - wcfg.spongeRadius - 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy + 1, cz);
-                }
-            }
-        }
-
-        // The positive y edge
-        cy = oy + wcfg.spongeRadius + 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (int cz = oz - wcfg.spongeRadius - 1; cz <= oz + wcfg.spongeRadius + 1; cz++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy - 1, cz);
-                }
-            }
-        }
-
-        // The negative z edge
-        int cz = oz - wcfg.spongeRadius - 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy, cz + 1);
-                }
-            }
-        }
-
-        // The positive z edge
-        cz = oz + wcfg.spongeRadius + 1;
-        for (cx = ox - wcfg.spongeRadius - 1; cx <= ox + wcfg.spongeRadius + 1; cx++) {
-            for (cy = oy - wcfg.spongeRadius - 1; cy <= oy + wcfg.spongeRadius + 1; cy++) {
-                if (isBlockWater(world, cx, cy, cz)) {
-                    setBlockToWater(world, cx, cy, cz - 1);
-                }
-            }
-        }
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/WorldConfiguration.java

@@ -1,484 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldguard.blacklist.Blacklist;
-import com.sk89q.worldguard.blacklist.BlacklistLogger;
-import com.sk89q.worldguard.blacklist.loggers.ConsoleLoggerHandler;
-import com.sk89q.worldguard.blacklist.loggers.DatabaseLoggerHandler;
-import com.sk89q.worldguard.blacklist.loggers.FileLoggerHandler;
-import com.sk89q.worldguard.chest.ChestProtection;
-import com.sk89q.worldguard.chest.SignChestProtection;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import org.bukkit.block.Block;
-import org.bukkit.entity.CreatureType;
-import org.bukkit.entity.Player;
-import org.bukkit.util.config.Configuration;
-
-/**
- * Holds the configuration for individual worlds.
- *
- * @author sk89q
- * @author Michael
- */
-public class WorldConfiguration {
-
-    public static final String CONFIG_HEADER = "#\r\n" +
-            "# WorldGuard's world configuration file\r\n" +
-            "#\r\n" +
-            "# This is a world configuration file. Anything placed into here will only\r\n" +
-            "# affect this world. If you don't put anything in this file, then the\r\n" +
-            "# settings will be inherited from the main configuration file.\r\n" +
-            "#\r\n" +
-            "# If you see {} below, that means that there are NO entries in this file.\r\n" +
-            "# Remove the {} and add your own entries.\r\n" +
-            "#\r\n";
-
-    private static final Logger logger = Logger
-            .getLogger("Minecraft.WorldGuard");
-
-    private WorldGuardPlugin plugin;
-
-    private String worldName;
-    private Configuration parentConfig;
-    private Configuration config;
-    private File configFile;
-    private File blacklistFile;
-
-    private Blacklist blacklist;
-    private ChestProtection chestProtection = new SignChestProtection();
-
-    /* Configuration data start */
-    public boolean opPermissions;
-    public boolean fireSpreadDisableToggle;
-    public boolean enforceOneSession;
-    public boolean itemDurability;
-    public boolean classicWater;
-    public boolean simulateSponge;
-    public int spongeRadius;
-    public boolean pumpkinScuba;
-    public boolean redstoneSponges;
-    public boolean noPhysicsGravel;
-    public boolean noPhysicsSand;
-    public boolean allowPortalAnywhere;
-    public Set<Integer> preventWaterDamage;
-    public boolean blockTNT;
-    public boolean blockLighter;
-    public boolean disableFireSpread;
-    public Set<Integer> disableFireSpreadBlocks;
-    public boolean preventLavaFire;
-    public Set<Integer> allowedLavaSpreadOver;
-    public boolean blockCreeperExplosions;
-    public boolean blockCreeperBlockDamage;
-    public int loginProtection;
-    public int spawnProtection;
-    public boolean kickOnDeath;
-    public boolean exactRespawn;
-    public boolean teleportToHome;
-    public boolean disableContactDamage;
-    public boolean disableFallDamage;
-    public boolean disableLavaDamage;
-    public boolean disableFireDamage;
-    public boolean disableLightningDamage;
-    public boolean disableDrowningDamage;
-    public boolean disableSuffocationDamage;
-    public boolean teleportOnSuffocation;
-    public boolean disableVoidDamage;
-    public boolean teleportOnVoid;
-    public boolean disableExplosionDamage;
-    public boolean disableMobDamage;
-    public boolean useRegions;
-    public boolean highFreqFlags;
-    public int regionWand = 287;
-    public Set<CreatureType> blockCreatureSpawn;
-    public boolean useiConomy;
-    public boolean buyOnClaim;
-    public double buyOnClaimPrice;
-    public int maxClaimVolume;
-    public boolean claimOnlyInsideExistingRegions;
-    public int maxRegionCountPerPlayer;
-    public boolean antiWolfDumbness;
-    public boolean signChestProtection;
-    public boolean removeInfiniteStacks;
-    public boolean disableCreatureCropTrampling;
-    public boolean disablePlayerCropTrampling;
-    public boolean preventLightningFire;
-    public Set<Integer> disallowedLightningBlocks;
-    public boolean disableThunder;
-    public boolean disableWeather;
-    public boolean alwaysRaining;
-    public boolean alwaysThundering;
-    public boolean disablePigZap;
-    public boolean disableCreeperPower;
-    public boolean disableHealthRegain;
-    public boolean disableMushroomSpread;
-    public boolean disableIceMelting;
-    public boolean disableSnowMelting;
-    public boolean disableSnowFormation;
-    public boolean disableIceFormation;
-    public boolean disableLeafDecay;
-
-    /* Configuration data end */
-
-    /**
-     * Construct the object.
-     *
-     * @param plugin
-     * @param worldName
-     */
-    public WorldConfiguration(WorldGuardPlugin plugin, String worldName) {
-        File baseFolder = new File(plugin.getDataFolder(), "worlds/" + worldName);
-        configFile = new File(baseFolder, "config.yml");
-        blacklistFile = new File(baseFolder, "blacklist.txt");
-
-        this.plugin = plugin;
-        this.worldName = worldName;
-        this.parentConfig = plugin.getConfiguration();
-
-        WorldGuardPlugin.createDefaultConfiguration(configFile, "config_world.yml");
-        WorldGuardPlugin.createDefaultConfiguration(blacklistFile, "blacklist.txt");
-
-        config = new Configuration(this.configFile);
-        loadConfiguration();
-
-        logger.info("WorldGuard: Loaded configuration for world '" + worldName + '"');
-    }
-
-    private boolean getBoolean(String node, boolean def) {
-        if (config.getProperty(node) != null) {
-            return config.getBoolean(node, def);
-        } else {
-            return parentConfig.getBoolean(node, def);
-        }
-    }
-
-    private String getString(String node, String def) {
-        if (config.getProperty(node) != null) {
-            return config.getString(node, def);
-        } else {
-            return parentConfig.getString(node, def);
-        }
-    }
-
-    private int getInt(String node, int def) {
-        if (config.getProperty(node) != null) {
-            return config.getInt(node, def);
-        } else {
-            return parentConfig.getInt(node, def);
-        }
-    }
-
-    private double getDouble(String node, double def) {
-        if (config.getProperty(node) != null) {
-            return config.getDouble(node, def);
-        } else {
-            return parentConfig.getDouble(node, def);
-        }
-    }
-
-    private List<Integer> getIntList(String node, List<Integer> def) {
-        List<Integer> res;
-
-        if (config.getProperty(node) != null) {
-            res = config.getIntList(node, def);
-        } else {
-            res = parentConfig.getIntList(node, def);
-        }
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<Integer>());
-        }
-
-        return res;
-    }
-
-    private List<String> getStringList(String node, List<String> def) {
-        List<String> res;
-
-        if (config.getProperty(node) != null) {
-            res = config.getStringList(node, def);
-        } else {
-            res = parentConfig.getStringList(node, def);
-        }
-
-        if (res == null || res.size() == 0) {
-            parentConfig.setProperty(node, new ArrayList<String>());
-        }
-
-        return res;
-    }
-
-    /**
-     * Load the configuration.
-     */
-    private void loadConfiguration() {
-        config.load();
-
-        opPermissions = getBoolean("op-permissions", true);
-
-        enforceOneSession = getBoolean("protection.enforce-single-session", true);
-        itemDurability = getBoolean("protection.item-durability", true);
-        removeInfiniteStacks = getBoolean("protection.remove-infinite-stacks", false);
-
-        classicWater = getBoolean("simulation.classic-water", false);
-        simulateSponge = getBoolean("simulation.sponge.enable", true);
-        spongeRadius = Math.max(1, getInt("simulation.sponge.radius", 3)) - 1;
-        redstoneSponges = getBoolean("simulation.sponge.redstone", false);
-
-        pumpkinScuba = getBoolean("pumpkin-scuba", false);
-
-        disableHealthRegain = getBoolean("default.disable-health-regain", false);
-
-        noPhysicsGravel = getBoolean("physics.no-physics-gravel", false);
-        noPhysicsSand = getBoolean("physics.no-physics-sand", false);
-        allowPortalAnywhere = getBoolean("physics.allow-portal-anywhere", false);
-        preventWaterDamage = new HashSet<Integer>(getIntList("physics.disable-water-damage-blocks", null));
-
-        blockTNT = getBoolean("ignition.block-tnt", false);
-        blockLighter = getBoolean("ignition.block-lighter", false);
-
-        preventLavaFire = getBoolean("fire.disable-lava-fire-spread", true);
-        disableFireSpread = getBoolean("fire.disable-all-fire-spread", false);
-        disableFireSpreadBlocks = new HashSet<Integer>(getIntList("fire.disable-fire-spread-blocks", null));
-        allowedLavaSpreadOver = new HashSet<Integer>(getIntList("fire.lava-spread-blocks", null));
-
-        blockCreeperExplosions = getBoolean("mobs.block-creeper-explosions", false);
-        blockCreeperBlockDamage = getBoolean("mobs.block-creeper-block-damage", false);
-        antiWolfDumbness = getBoolean("mobs.anti-wolf-dumbness", false);
-
-        loginProtection = getInt("spawn.login-protection", 3);
-        spawnProtection = getInt("spawn.spawn-protection", 0);
-        kickOnDeath = getBoolean("spawn.kick-on-death", false);
-        exactRespawn = getBoolean("spawn.exact-respawn", false);
-        teleportToHome = getBoolean("spawn.teleport-to-home-on-death", false);
-
-        disableFallDamage = getBoolean("player-damage.disable-fall-damage", false);
-        disableLavaDamage = getBoolean("player-damage.disable-lava-damage", false);
-        disableFireDamage = getBoolean("player-damage.disable-fire-damage", false);
-        disableLightningDamage = getBoolean("player-damage.disable-lightning-damage", false);
-        disableDrowningDamage = getBoolean("player-damage.disable-drowning-damage", false);
-        disableSuffocationDamage = getBoolean("player-damage.disable-suffocation-damage", false);
-        disableContactDamage = getBoolean("player-damage.disable-contact-damage", false);
-        teleportOnSuffocation = getBoolean("player-damage.teleport-on-suffocation", false);
-        disableVoidDamage = getBoolean("player-damage.disable-void-damage", false);
-        teleportOnVoid = getBoolean("player-damage.teleport-on-void-falling", false);
-        disableExplosionDamage = getBoolean("player-damage.disable-explosion-damage", false);
-        disableMobDamage = getBoolean("player-damage.disable-mob-damage", false);
-
-        signChestProtection = getBoolean("chest-protection.enable", false);
-
-        disableCreatureCropTrampling = getBoolean("crops.disable-creature-trampling", false);
-        disablePlayerCropTrampling = getBoolean("crops.disable-player-trampling", false);
-
-        disallowedLightningBlocks = new HashSet<Integer>(getIntList("weather.prevent-lightning-strike-blocks", null));
-        preventLightningFire = getBoolean("weather.disable-lightning-strike-fire", false);
-        disableThunder = getBoolean("weather.disable-thunderstorm", false);
-        disableWeather = getBoolean("weather.disable-weather", false);
-        disablePigZap = getBoolean("weather.disable-pig-zombification", false);
-        disableCreeperPower = getBoolean("weather.disable-powered-creepers", false);
-        alwaysRaining = getBoolean("weather.always-raining", false);
-        alwaysThundering = getBoolean("weather.always-thundering", false);
-
-        disableMushroomSpread = getBoolean("dynamics.disable-mushroom-spread", false);
-        disableIceMelting = getBoolean("dynamics.disable-ice-melting", false);
-        disableSnowMelting = getBoolean("dynamics.disable-snow-melting", false);
-        disableSnowFormation = getBoolean("dynamics.disable-snow-formation", false);
-        disableIceFormation = getBoolean("dynamics.disable-ice-formation", false);
-        disableLeafDecay = getBoolean("dynamics.disable-leaf-decay", false);
-
-        useRegions = getBoolean("regions.enable", true);
-        highFreqFlags = getBoolean("regions.high-frequency-flags", false);
-        regionWand = getInt("regions.wand", 287);
-        maxClaimVolume = getInt("regions.max-claim-volume", 30000);
-        claimOnlyInsideExistingRegions = getBoolean("regions.claim-only-inside-existing-regions", false);
-        maxRegionCountPerPlayer = getInt("regions.max-region-count-per-player", 7);
-
-        useiConomy = getBoolean("iconomy.enable", false);
-        buyOnClaim = getBoolean("iconomy.buy-on-claim", false);
-        buyOnClaimPrice = getDouble("iconomy.buy-on-claim-price", 1.0);
-
-        blockCreatureSpawn = new HashSet<CreatureType>();
-        for (String creatureName : getStringList("mobs.block-creature-spawn", null)) {
-            CreatureType creature = CreatureType.fromName(creatureName);
-
-            if (creature == null) {
-                logger.warning("WorldGuard: Unknown mob type '" + creatureName + "'");
-            } else {
-                blockCreatureSpawn.add(creature);
-            }
-        }
-
-        boolean useBlacklistAsWhitelist = getBoolean("blacklist.use-as-whitelist", false);
-
-        // Console log configuration
-        boolean logConsole = getBoolean("blacklist.logging.console.enable", true);
-
-        // Database log configuration
-        boolean logDatabase = getBoolean("blacklist.logging.database.enable", false);
-        String dsn = getString("blacklist.logging.database.dsn", "jdbc:mysql://localhost:3306/minecraft");
-        String user = getString("blacklist.logging.database.user", "root");
-        String pass = getString("blacklist.logging.database.pass", "");
-        String table = getString("blacklist.logging.database.table", "blacklist_events");
-
-        // File log configuration
-        boolean logFile = getBoolean("blacklist.logging.file.enable", false);
-        String logFilePattern = getString("blacklist.logging.file.path", "worldguard/logs/%Y-%m-%d.log");
-        int logFileCacheSize = Math.max(1, getInt("blacklist.logging.file.open-files", 10));
-
-        // Load the blacklist
-        try {
-            // If there was an existing blacklist, close loggers
-            if (blacklist != null) {
-                blacklist.getLogger().close();
-            }
-
-            // First load the blacklist data from worldguard-blacklist.txt
-            Blacklist blist = new BukkitBlacklist(useBlacklistAsWhitelist, plugin);
-            blist.load(blacklistFile);
-
-            // If the blacklist is empty, then set the field to null
-            // and save some resources
-            if (blist.isEmpty()) {
-                this.blacklist = null;
-            } else {
-                this.blacklist = blist;
-                logger.log(Level.INFO, "WorldGuard: Blacklist loaded.");
-
-                BlacklistLogger blacklistLogger = blist.getLogger();
-
-                if (logDatabase) {
-                    blacklistLogger.addHandler(new DatabaseLoggerHandler(dsn, user, pass, table, worldName));
-                }
-
-                if (logConsole) {
-                    blacklistLogger.addHandler(new ConsoleLoggerHandler(worldName));
-                }
-
-                if (logFile) {
-                    FileLoggerHandler handler =
-                            new FileLoggerHandler(logFilePattern, logFileCacheSize, worldName);
-                    blacklistLogger.addHandler(handler);
-                }
-            }
-        } catch (FileNotFoundException e) {
-            logger.log(Level.WARNING, "WorldGuard blacklist does not exist.");
-        } catch (IOException e) {
-            logger.log(Level.WARNING, "Could not load WorldGuard blacklist: "
-                    + e.getMessage());
-        }
-
-        // Print an overview of settings
-        if (getBoolean("summary-on-start", true)) {
-            logger.log(Level.INFO, enforceOneSession
-                    ? "WorldGuard: (" + worldName + ") Single session is enforced."
-                    : "WorldGuard: (" + worldName + ") Single session is NOT ENFORCED.");
-            logger.log(Level.INFO, blockTNT
-                    ? "WorldGuard: (" + worldName + ") TNT ignition is blocked."
-                    : "WorldGuard: (" + worldName + ") TNT ignition is PERMITTED.");
-            logger.log(Level.INFO, blockLighter
-                    ? "WorldGuard: (" + worldName + ") Lighters are blocked."
-                    : "WorldGuard: (" + worldName + ") Lighters are PERMITTED.");
-            logger.log(Level.INFO, preventLavaFire
-                    ? "WorldGuard: (" + worldName + ") Lava fire is blocked."
-                    : "WorldGuard: (" + worldName + ") Lava fire is PERMITTED.");
-
-            if (disableFireSpread) {
-                logger.log(Level.INFO, "WorldGuard: (" + worldName + ") All fire spread is disabled.");
-            } else {
-                if (disableFireSpreadBlocks.size() > 0) {
-                    logger.log(Level.INFO, "WorldGuard: (" + worldName
-                            + ") Fire spread is limited to "
-                            + disableFireSpreadBlocks.size() + " block types.");
-                } else {
-                    logger.log(Level.INFO, "WorldGuard: (" + worldName
-                            + ") Fire spread is UNRESTRICTED.");
-                }
-            }
-        }
-
-        try {
-            config.setHeader(CONFIG_HEADER);
-        } catch (Throwable t) {
-        }
-
-        config.save();
-    }
-
-    public Blacklist getBlacklist() {
-        return this.blacklist;
-    }
-
-    public String getWorldName() {
-        return this.worldName;
-    }
-    
-    public boolean isChestProtected(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isProtected(block, player);
-    }
-    
-    public boolean isChestProtected(Block block) {
-        if (!signChestProtection) {
-            return false;
-        }
-        return chestProtection.isProtected(block, null);
-    }
-    
-    public boolean isChestProtectedPlacement(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isProtectedPlacement(block, player);
-    }
-
-    public boolean isAdjacentChestProtected(Block block, Player player) {
-        if (!signChestProtection) {
-            return false;
-        }
-        if (plugin.hasPermission(player, "worldguard.chest-protection.override")
-                || plugin.hasPermission(player, "worldguard.override.chest-protection")) {
-            return false;
-        }
-        return chestProtection.isAdjacentChestProtected(block, player);
-    }
-
-    public ChestProtection getChestProtection() {
-        return chestProtection;
-    }
-    
-}

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

@@ -1,780 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import org.bukkit.event.Event.Priority;
-import org.bukkit.event.Event;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.block.Block;
-import org.bukkit.ChatColor;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.World;
-import org.bukkit.event.block.*;
-import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
-import org.bukkit.inventory.ItemStack;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.blocks.BlockType;
-import com.sk89q.worldedit.blocks.ItemType;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.blacklist.events.*;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-
-import java.util.logging.Logger;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.*;
-
-/**
- * The listener for block events.
- * 
- * @author sk89q
- */
-public class WorldGuardBlockListener extends BlockListener {
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object.
-     * 
-     * @param plugin
-     */
-    public WorldGuardBlockListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        PluginManager pm = plugin.getServer().getPluginManager();
-
-        registerEvent("BLOCK_DAMAGE", Priority.High);
-        registerEvent("BLOCK_BREAK", Priority.High);
-        registerEvent("BLOCK_FROMTO", Priority.Normal);
-        registerEvent("BLOCK_IGNITE", Priority.High);
-        registerEvent("BLOCK_PHYSICS", Priority.Normal);
-        registerEvent("BLOCK_PLACE", Priority.High);
-        registerEvent("BLOCK_BURN", Priority.High);
-        registerEvent("SIGN_CHANGE", Priority.High);
-        registerEvent("REDSTONE_CHANGE", Priority.High);
-        registerEvent("SNOW_FORM", Priority.High);
-        registerEvent("LEAVES_DECAY", Priority.High);
-        registerEvent("BLOCK_FORM", Priority.High);
-        registerEvent("BLOCK_SPREAD", Priority.High);
-        registerEvent("BLOCK_FADE", Priority.High);
-    }
-
-    /**
-     * Register an event, but not failing if the event is not implemented.
-     *
-     * @param typeName
-     * @param priority
-     */
-    private void registerEvent(String typeName, Priority priority) {
-        try {
-            Event.Type type = Event.Type.valueOf(typeName);
-            PluginManager pm = plugin.getServer().getPluginManager();
-            pm.registerEvent(type, this, priority, plugin);
-        } catch (IllegalArgumentException e) {
-            logger.info("WorldGuard: Unable to register missing event type " + typeName);
-        }
-    }
-    
-    /**
-     * Get the world configuration given a world.
-     * 
-     * @param world
-     * @return
-     */
-    protected WorldConfiguration getWorldConfig(World world) {
-        return plugin.getGlobalStateManager().get(world);
-    }
-    
-    /**
-     * Get the world configuration given a player.
-     * 
-     * @param player
-     * @return
-     */
-    protected WorldConfiguration getWorldConfig(Player player) {
-        return plugin.getGlobalStateManager().get(player.getWorld());
-    }
-    
-    /**
-     * Called when a block is damaged.
-     */
-    @Override
-    public void onBlockDamage(BlockDamageEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Player player = event.getPlayer();
-        Block blockDamaged = event.getBlock();
-
-        // Cake are damaged and not broken when they are eaten, so we must
-        // handle them a bit separately
-        if (blockDamaged.getType() == Material.CAKE_BLOCK) {
-            if (!plugin.getGlobalRegionManager().canBuild(player, blockDamaged)) {
-                player.sendMessage(ChatColor.DARK_RED + "You're not invited to this tea party!");
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-    
-    /**
-     * Called when a block is broken.
-     */
-    @Override
-    public void onBlockBreak(BlockBreakEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
-
-        if (!wcfg.itemDurability) {
-            ItemStack held = player.getItemInHand();
-            if (held.getTypeId() > 0
-                    && !(ItemType.usesDamageValue(held.getTypeId())
-                    || BlockType.usesData(held.getTypeId()))) {
-                held.setDurability((short) -1);
-                player.setItemInHand(held);
-            }
-        }
-
-        if (!plugin.getGlobalRegionManager().canBuild(player, event.getBlock())) {
-            player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
-                    toVector(event.getBlock()),
-                    event.getBlock().getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (!wcfg.getBlacklist().check(
-                    new DestroyWithBlacklistEvent(plugin.wrapPlayer(player),
-                    toVector(event.getBlock()),
-                    player.getItemInHand().getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        
-        if (wcfg.isChestProtected(event.getBlock(), player)) {
-            player.sendMessage(ChatColor.DARK_RED + "The chest is protected.");
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /**
-     * Called when fluids flow.
-     */
-    @Override
-    public void onBlockFromTo(BlockFromToEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        World world = event.getBlock().getWorld();
-        Block blockFrom = event.getBlock();
-        Block blockTo = event.getToBlock();
-
-        boolean isWater = blockFrom.getTypeId() == 8 || blockFrom.getTypeId() == 9;
-        boolean isLava = blockFrom.getTypeId() == 10 || blockFrom.getTypeId() == 11;
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.simulateSponge && isWater) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
-
-            for (int cx = -wcfg.spongeRadius; cx <= wcfg.spongeRadius; cx++) {
-                for (int cy = -wcfg.spongeRadius; cy <= wcfg.spongeRadius; cy++) {
-                    for (int cz = -wcfg.spongeRadius; cz <= wcfg.spongeRadius; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && (!wcfg.redstoneSponges || !sponge.isBlockIndirectlyPowered())) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                }
-            }
-        }
-
-        /*if (plugin.classicWater && isWater) {
-        int blockBelow = blockFrom.getRelative(0, -1, 0).getTypeId();
-        if (blockBelow != 0 && blockBelow != 8 && blockBelow != 9) {
-        blockFrom.setTypeId(9);
-        if (blockTo.getTypeId() == 0) {
-        blockTo.setTypeId(9);
-        }
-        return;
-        }
-        }*/
-
-        // Check the fluid block (from) whether it is air.
-        // If so and the target block is protected, cancel the event
-        if (wcfg.preventWaterDamage.size() > 0) {
-            int targetId = blockTo.getTypeId();
-            
-            if ((blockFrom.getTypeId() == 0 || isWater) && 
-                    wcfg.preventWaterDamage.contains(targetId)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.allowedLavaSpreadOver.size() > 0 && isLava) {
-            int targetId = blockTo.getRelative(0, -1, 0).getTypeId();
-            
-            if (!wcfg.allowedLavaSpreadOver.contains(targetId)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.highFreqFlags && isWater
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.WATER_FLOW,
-                blockFrom.getLocation())) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.highFreqFlags && isLava
-                && !plugin.getGlobalRegionManager().allows(DefaultFlag.LAVA_FLOW,
-                blockFrom.getLocation())) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /**
-     * Called when a block gets ignited.
-     */
-    @Override
-    public void onBlockIgnite(BlockIgniteEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        IgniteCause cause = event.getCause();
-        Block block = event.getBlock();
-        World world = block.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        boolean isFireSpread = cause == IgniteCause.SPREAD;
-
-        if (wcfg.preventLightningFire && cause == IgniteCause.LIGHTNING) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.preventLavaFire && cause == IgniteCause.LAVA) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread && isFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.blockLighter && cause == IgniteCause.FLINT_AND_STEEL
-                && event.getPlayer() != null
-                && !plugin.hasPermission(event.getPlayer(), "worldguard.override.lighter")) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.fireSpreadDisableToggle && isFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpreadBlocks.size() > 0 && isFireSpread) {
-            int x = block.getX();
-            int y = block.getY();
-            int z = block.getZ();
-
-            if (wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y - 1, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x + 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x - 1, y, z))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z - 1))
-                    || wcfg.disableFireSpreadBlocks.contains(world.getBlockTypeIdAt(x, y, z + 1))) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.useRegions) {
-            Vector pt = toVector(block);
-            Player player = event.getPlayer();
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (player != null && !plugin.getGlobalRegionManager().hasBypass(player, world)) {
-                LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-                if (cause == IgniteCause.FLINT_AND_STEEL) {
-                    if (!set.canBuild(localPlayer)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                    if (!set.allows(DefaultFlag.LIGHTER)
-                            && !plugin.hasPermission(player, "worldguard.override.lighter")) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-
-            if (wcfg.highFreqFlags && isFireSpread
-                    && !set.allows(DefaultFlag.FIRE_SPREAD)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.highFreqFlags && cause == IgniteCause.LAVA
-                    && !set.allows(DefaultFlag.LAVA_FIRE)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-    }
-
-    /**
-     * Called when a block is destroyed from burning.
-     */
-    @Override
-    public void onBlockBurn(BlockBurnEvent event) {
-
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpread) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.fireSpreadDisableToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableFireSpreadBlocks.size() > 0) {
-            Block block = event.getBlock();
-
-            if (wcfg.disableFireSpreadBlocks.contains(block.getTypeId())) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.isChestProtected(event.getBlock())) {
-            event.setCancelled(true);
-            return;
-        }
-        
-        if (wcfg.useRegions) {
-            Block block = event.getBlock();
-            Vector pt = toVector(block);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(block.getWorld());
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.FIRE_SPREAD)) {
-                event.setCancelled(true);
-                return;
-            }
-
-        }
-    }
-
-    /**
-     * Called when block physics occurs.
-     */
-    @Override
-    public void onBlockPhysics(BlockPhysicsEvent event) {
-
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        int id = event.getChangedTypeId();
-
-        if (id == 13 && wcfg.noPhysicsGravel) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 12 && wcfg.noPhysicsSand) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (id == 90 && wcfg.allowPortalAnywhere) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /**
-     * Called when a player places a block.
-     */
-    @Override
-    public void onBlockPlace(BlockPlaceEvent event) {
-
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Block blockPlaced = event.getBlock();
-        Player player = event.getPlayer();
-        World world = blockPlaced.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().canBuild(player, blockPlaced.getLocation())) {
-                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new BlockPlaceBlacklistEvent(plugin.wrapPlayer(player), toVector(blockPlaced),
-                    blockPlaced.getTypeId()), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-        
-        if (wcfg.signChestProtection && wcfg.getChestProtection().isChest(blockPlaced.getType())) {
-            if (wcfg.isAdjacentChestProtected(event.getBlock(), player)) {
-                player.sendMessage(ChatColor.DARK_RED + "This spot is for a chest that you don't have permission for.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.simulateSponge && blockPlaced.getTypeId() == 19) {
-            if (wcfg.redstoneSponges && blockPlaced.isBlockIndirectlyPowered()) {
-                return;
-            }
-
-            int ox = blockPlaced.getX();
-            int oy = blockPlaced.getY();
-            int oz = blockPlaced.getZ();
-
-            SpongeUtil.clearSpongeWater(plugin, world, ox, oy, oz);
-        }
-    }
-
-    /**
-     * Called when redstone changes.
-     */
-    @Override
-    public void onBlockRedstoneChange(BlockRedstoneEvent event) {
-
-        Block blockTo = event.getBlock();
-        World world = blockTo.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.simulateSponge && wcfg.redstoneSponges) {
-            int ox = blockTo.getX();
-            int oy = blockTo.getY();
-            int oz = blockTo.getZ();
-
-            for (int cx = -1; cx <= 1; cx++) {
-                for (int cy = -1; cy <= 1; cy++) {
-                    for (int cz = -1; cz <= 1; cz++) {
-                        Block sponge = world.getBlockAt(ox + cx, oy + cy, oz + cz);
-                        if (sponge.getTypeId() == 19
-                                && sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.clearSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        } else if (sponge.getTypeId() == 19
-                                && !sponge.isBlockIndirectlyPowered()) {
-                            SpongeUtil.addSpongeWater(plugin, world, ox + cx, oy + cy, oz + cz);
-                        }
-                    }
-                }
-            }
-
-            return;
-        }
-    }
-
-    /**
-     * Called when a sign is changed.
-     */
-    @Override
-    public void onSignChange(SignChangeEvent event) {
-
-        Player player = event.getPlayer();
-        WorldConfiguration wcfg = getWorldConfig(player);
-        
-        if (wcfg.signChestProtection) {
-            if (event.getLine(0).equalsIgnoreCase("[Lock]")) {
-                if (wcfg.isChestProtectedPlacement(event.getBlock(), player)) {
-                    player.sendMessage(ChatColor.DARK_RED + "You do not own the adjacent chest.");
-                    dropSign(event.getBlock());
-                    event.setCancelled(true);
-                    return;
-                }
-                
-                if (event.getBlock().getType() != Material.SIGN_POST) {
-                    player.sendMessage(ChatColor.RED
-                            + "The [Lock] sign must be a sign post, not a wall sign.");
-
-                    dropSign(event.getBlock());
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (!event.getLine(1).equalsIgnoreCase(player.getName())) {
-                    player.sendMessage(ChatColor.RED
-                            + "The first owner line must be your name.");
-
-                    dropSign(event.getBlock());
-                    event.setCancelled(true);
-                    return;
-                }
-                
-                Material below = event.getBlock().getRelative(0, -1, 0).getType();
-
-                if (below == Material.TNT || below == Material.SAND
-                        || below == Material.GRAVEL || below == Material.SIGN_POST) {
-                    player.sendMessage(ChatColor.RED
-                            + "That is not a safe block that you're putting this sign on.");
-
-                    dropSign(event.getBlock());
-                    event.setCancelled(true);
-                    return;
-                }
-                
-                event.setLine(0, "[Lock]");
-                player.sendMessage(ChatColor.YELLOW
-                        + "A chest or double chest above is now protected.");
-            }
-        } else {
-            if (event.getLine(0).equalsIgnoreCase("[Lock]")) {
-                player.sendMessage(ChatColor.RED
-                        + "WorldGuard's sign chest protection is disabled.");
-                
-                dropSign(event.getBlock());
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (!plugin.getGlobalRegionManager().canBuild(player, event.getBlock())) {
-            player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-            event.setCancelled(true);
-            return;
-        }
-    }
-    
-    /**
-     * Called when snow is formed.
-     */
-    @Override
-    public void onSnowForm(SnowFormEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableSnowFormation) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.SNOW_FALL,
-                    event.getBlock().getLocation())) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @Override
-    public void onLeavesDecay(LeavesDecayEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableLeafDecay) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().allows(DefaultFlag.LEAF_DECAY,
-                    event.getBlock().getLocation())) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    /**
-     * Called when a block is formed based on world conditions.
-     */
-    public void onBlockForm(BlockFormEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        Material type = event.getNewState().getType();
-
-        if (wcfg.disableIceFormation && type == Material.ICE) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableSnowFormation && type == Material.SNOW) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /**
-     * Called when a block spreads based on world conditions.
-     */
-    public void onBlockSpread(BlockSpreadEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        Material fromType = event.getSource().getType();
-
-        if (wcfg.disableMushroomSpread && (fromType == Material.RED_MUSHROOM
-                || fromType == Material.BROWN_MUSHROOM)) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-    /**
-     * Called when a block fades.
-     */
-    public void onBlockFade(BlockFadeEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getBlock().getWorld());
-
-        Material type = event.getBlock().getType();
-
-        if (wcfg.disableIceMelting && type == Material.ICE) {
-            event.setCancelled(true);
-            return;
-        }
-
-        if (wcfg.disableSnowMelting && type == Material.SNOW) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-}

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

@@ -1,690 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.bukkit;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-
-import com.sk89q.worldguard.blacklist.events.BlockBreakBlacklistEvent;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.*;
-import org.bukkit.event.Event;
-import org.bukkit.event.Event.Priority;
-import org.bukkit.event.entity.*;
-import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
-import org.bukkit.event.painting.PaintingBreakByEntityEvent;
-import org.bukkit.event.painting.PaintingBreakEvent;
-import org.bukkit.event.painting.PaintingPlaceEvent;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.PluginManager;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.blacklist.events.ItemUseBlacklistEvent;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-import java.util.Set;
-import java.util.logging.Logger;
-
-/**
- * Listener for entity related events.
- * 
- * @author sk89q
- */
-public class WorldGuardEntityListener extends EntityListener {
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     * 
-     * @param plugin
-     */
-    public WorldGuardEntityListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        PluginManager pm = plugin.getServer().getPluginManager();
-
-        registerEvent("ENTITY_DAMAGE", Priority.High);
-        registerEvent("ENTITY_COMBUST", Priority.High);
-        registerEvent("ENTITY_EXPLODE", Priority.High);
-        registerEvent("CREATURE_SPAWN", Priority.High);
-        registerEvent("ENTITY_INTERACT", Priority.High);
-        registerEvent("CREEPER_POWER", Priority.High);
-        registerEvent("PIG_ZAP", Priority.High);
-        registerEvent("PAINTING_BREAK", Priority.High);
-        registerEvent("PAINTING_PLACE", Priority.High);
-        registerEvent("ENTITY_REGAIN_HEALTH", Priority.High);
-    }
-
-    /**
-     * Register an event, but not failing if the event is not implemented.
-     *
-     * @param typeName
-     * @param priority
-     */
-    private void registerEvent(String typeName, Priority priority) {
-        try {
-            Event.Type type = Event.Type.valueOf(typeName);
-            PluginManager pm = plugin.getServer().getPluginManager();
-            pm.registerEvent(type, this, priority, plugin);
-        } catch (IllegalArgumentException e) {
-            logger.info("WorldGuard: Unable to register missing event type " + typeName);
-        }
-    }
-
-    /**
-     * Called when an entity interacts with another object.
-     */
-    @Override
-    public void onEntityInteract(EntityInteractEvent event) {
-        //bukkit doesn't actually throw this event yet, someone add a ticket to leaky
-        Entity entity = event.getEntity();
-        Block block = event.getBlock();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(entity.getWorld());
-
-        if (block.getType() == Material.SOIL) {
-            if (entity instanceof Creature && wcfg.disableCreatureCropTrampling) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    /**
-     * Called on entity damage by a block.
-     * 
-     * @param event
-     */
-    private void onEntityDamageByBlock(EntityDamageByBlockEvent event) {
-        Entity defender = event.getEntity();
-        DamageCause type = event.getCause();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
-
-        if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
-            if (wcfg.antiWolfDumbness && !(type == DamageCause.VOID)) {
-                event.setCancelled(true);
-                return;
-            }
-        } else if (defender instanceof Player) {
-            Player player = (Player) defender;
-
-            if (cfg.hasGodMode(player)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableLavaDamage && type == DamageCause.LAVA) {
-                event.setCancelled(true);
-                if (cfg.hasGodMode(player)) player.setFireTicks(0);
-                return;
-            }
-
-            if (wcfg.disableContactDamage && type == DamageCause.CONTACT) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.teleportOnVoid && type == DamageCause.VOID) {
-                BukkitUtil.findFreePosition(player);
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableVoidDamage && type == DamageCause.VOID) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableExplosionDamage && event.getCause() == DamageCause.BLOCK_EXPLOSION) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on entity damage by an entity.
-     * 
-     * @param event
-     */
-    private void onEntityDamageByEntity(EntityDamageByEntityEvent event) {
-        Entity attacker = event.getDamager();
-        Entity defender = event.getEntity();
-        
-        if (attacker instanceof Player) {
-            Player player = (Player) attacker;
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-
-            ItemStack held = player.getInventory().getItemInHand();
-            
-            if (held != null) {
-                if (wcfg.getBlacklist() != null) {
-                    if (!wcfg.getBlacklist().check(
-                            new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
-                                    toVector(player.getLocation()), held.getTypeId()), false, false)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-        }
-
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-            
-            if (cfg.hasGodMode(player)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableLightningDamage && event.getCause() == DamageCause.LIGHTNING) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableExplosionDamage && event.getCause() == DamageCause.ENTITY_EXPLOSION) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (attacker != null && attacker instanceof Player) {
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.PVP)) {
-                        ((Player) attacker).sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-
-            if (attacker != null && attacker instanceof LivingEntity
-                    && !(attacker instanceof Player)) {
-                if (attacker instanceof Creeper && wcfg.blockCreeperExplosions) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.disableMobDamage) {
-                    event.setCancelled(true);
-                    return;
-                }
-
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-                    ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-                    if (!set.allows(DefaultFlag.MOB_DAMAGE)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-
-                    if (attacker instanceof Creeper) {
-                        if (!set.allows(DefaultFlag.CREEPER_EXPLOSION)) {
-                            event.setCancelled(true);
-                            return;
-                        }
-                    }
-                }
-
-            }
-        }
-    }
-
-    /**
-     * Called on entity damage by a projectile.
-     * 
-     * @param event
-     */
-    private void onEntityDamageByProjectile(EntityDamageByProjectileEvent event) {
-        Entity defender = event.getEntity();
-        Entity attacker = event.getDamager();
-
-        if (defender instanceof Player) {
-            Player player = (Player) defender;
-
-            ConfigurationManager cfg = plugin.getGlobalStateManager();
-            WorldConfiguration wcfg = cfg.get(player.getWorld());
-            
-            if (cfg.hasGodMode(player)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (attacker != null && attacker instanceof Player) {
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.PVP)) {
-                        ((Player) attacker).sendMessage(ChatColor.DARK_RED + "You are in a no-PvP area.");
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-            if (attacker != null && attacker instanceof Skeleton) {
-                if (wcfg.disableMobDamage) {
-                    event.setCancelled(true);
-                    return;
-                }
-                if (wcfg.useRegions) {
-                    Vector pt = toVector(defender.getLocation());
-                    RegionManager mgr = plugin.getGlobalRegionManager().get(player.getWorld());
-
-                    if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.MOB_DAMAGE)) {
-                        event.setCancelled(true);
-                        return;
-                    }
-                }
-            }
-        }
-
-    }
-
-    /**
-     * Called on entity damage.
-     */
-    @Override
-    public void onEntityDamage(EntityDamageEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        if (event instanceof EntityDamageByProjectileEvent) {
-            this.onEntityDamageByProjectile((EntityDamageByProjectileEvent) event);
-            return;
-        } else if (event instanceof EntityDamageByEntityEvent) {
-            this.onEntityDamageByEntity((EntityDamageByEntityEvent) event);
-            return;
-        } else if (event instanceof EntityDamageByBlockEvent) {
-            this.onEntityDamageByBlock((EntityDamageByBlockEvent) event);
-            return;
-        }
-
-        Entity defender = event.getEntity();
-        DamageCause type = event.getCause();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(defender.getWorld());
-
-        if (defender instanceof Wolf && ((Wolf) defender).isTamed()) {
-            if (wcfg.antiWolfDumbness) {
-                event.setCancelled(true);
-                return;
-            }
-        } else if (defender instanceof Player) {
-            Player player = (Player) defender;
-
-            if (cfg.hasGodMode(player)) {
-                event.setCancelled(true);
-                player.setFireTicks(0);
-                return;
-            }
-
-            if (type == DamageCause.DROWNING && cfg.hasAmphibiousMode(player)) {
-                player.setRemainingAir(player.getMaximumAir());
-                event.setCancelled(true);
-                return;
-            }
-
-            if (type == DamageCause.DROWNING && wcfg.pumpkinScuba
-                    && (player.getInventory().getHelmet().getType() == Material.PUMPKIN
-                    || player.getInventory().getHelmet().getType() == Material.JACK_O_LANTERN)) {
-                player.setRemainingAir(player.getMaximumAir());
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableFallDamage && type == DamageCause.FALL) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableFireDamage && (type == DamageCause.FIRE
-                    || type == DamageCause.FIRE_TICK)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableDrowningDamage && type == DamageCause.DROWNING) {
-                player.setRemainingAir(player.getMaximumAir());
-                event.setCancelled(true);
-                return;
-            }
-
-           if (wcfg.teleportOnSuffocation && type == DamageCause.SUFFOCATION) {
-                BukkitUtil.findFreePosition(player);
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.disableSuffocationDamage && type == DamageCause.SUFFOCATION) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on entity combust.
-     */
-    @Override
-    public void onEntityCombust(EntityCombustEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        Entity entity = event.getEntity();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-
-        if (entity instanceof Player) {
-            Player player = (Player) entity;
-
-            if (cfg.hasGodMode(player)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on entity explode.
-     */
-    @Override
-    public void onEntityExplode(EntityExplodeEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        Location l = event.getLocation();
-        World world = l.getWorld();
-        WorldConfiguration wcfg = cfg.get(world);
-        Entity ent = event.getEntity();
-
-        if (ent instanceof LivingEntity) {
-            if (wcfg.blockCreeperBlockDamage) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.blockCreeperExplosions) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                Vector pt = toVector(l);
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.CREEPER_EXPLOSION)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        } else if (ent instanceof Fireball) {
-            if (wcfg.useRegions) {
-                Vector pt = toVector(l);
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.GHAST_FIREBALL)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        } else if (ent instanceof TNTPrimed) {
-            if (cfg.activityHaltToggle) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.blockTNT) {
-                event.setCancelled(true);
-                return;
-            }
-
-            if (wcfg.useRegions) {
-                Vector pt = toVector(l);
-                RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-                if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.TNT)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-        
-        if (wcfg.signChestProtection) {
-            for (Block block : event.blockList()) {
-                if (wcfg.isChestProtected(block)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-
-        if (wcfg.useRegions) {
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-
-            // Whoo, for each block
-            for (Block block : event.blockList()) {
-                Vector pt = toVector(block);
-
-                if (!mgr.getApplicableRegions(pt).allows(DefaultFlag.TNT)) {
-                    event.setCancelled(true);
-                    return;
-                }
-            }
-        }
-    }
-
-    /**
-     * Called on creature spawn.
-     */
-    @Override
-    public void onCreatureSpawn(CreatureSpawnEvent event) {
-        if (event.isCancelled()) {
-            return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-
-        if (cfg.activityHaltToggle) {
-            event.setCancelled(true);
-            return;
-        }
-
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
-        CreatureType creaType = event.getCreatureType();
-
-        if (wcfg.blockCreatureSpawn.contains(creaType)) {
-            event.setCancelled(true);
-            return;
-        }
-        
-        Location eventLoc = event.getLocation();
-        
-        if (wcfg.useRegions) {
-            Vector pt = toVector(eventLoc);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(eventLoc.getWorld());
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.MOB_SPAWNING)) {
-                event.setCancelled(true);
-                return;
-            }
-
-            Set<CreatureType> blockTypes = set.getFlag(DefaultFlag.DENY_SPAWN);
-            if (blockTypes != null && blockTypes.contains(creaType)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on pig zap.
-     */
-    @Override
-    public void onPigZap(PigZapEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
-
-        if (wcfg.disablePigZap) {
-            event.setCancelled(true);
-        }
-    }
-
-    /**
-     * Called on creeper power.
-     */
-    @Override
-    public void onCreeperPower(CreeperPowerEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getEntity().getWorld());
-
-        if (wcfg.disableCreeperPower) {
-            event.setCancelled(true);
-        }
-    }
-
-    /**
-     * Called when a painting is removed.
-     */
-    @Override
-    public void onPaintingBreak(PaintingBreakEvent breakEvent) {
-        if (breakEvent.isCancelled()) {
-            return;
-        }
-
-        if (!(breakEvent instanceof PaintingBreakByEntityEvent)) {
-            return;
-        }
-        
-        PaintingBreakByEntityEvent event = (PaintingBreakByEntityEvent) breakEvent;
-        if (!(event.getRemover() instanceof Player)) {
-            return;
-        }
-        
-        Painting painting= event.getPainting();
-        Player player = (Player) event.getRemover();
-        World world = painting.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new BlockBreakBlacklistEvent(plugin.wrapPlayer(player),
-                            toVector(player.getLocation()), 321), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().canBuild(player, painting.getLocation())) {
-                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on painting place.
-     */
-    @Override
-    public void onPaintingPlace(PaintingPlaceEvent event) {
-        Block placedOn = event.getBlock();
-        Player player = event.getPlayer();
-        World world = placedOn.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.getBlacklist() != null) {
-            if (!wcfg.getBlacklist().check(
-                    new ItemUseBlacklistEvent(plugin.wrapPlayer(player),
-                            toVector(player.getLocation()), 321), false, false)) {
-                event.setCancelled(true);
-                return;
-            }
-        }
-
-        if (wcfg.useRegions) {
-            if (!plugin.getGlobalRegionManager().canBuild(player, placedOn.getLocation())) {
-                player.sendMessage(ChatColor.DARK_RED + "You don't have permission for this area.");
-                event.setCancelled(true);
-                return;
-            }
-        }
-    }
-
-    /**
-     * Called on entity health regain.
-     */
-    public void onEntityRegainHealth(EntityRegainHealthEvent event) {
-        Entity ent = event.getEntity();
-        World world = ent.getWorld();
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(world);
-
-        if (wcfg.disableHealthRegain) {
-            event.setCancelled(true);
-            return;
-        }
-    }
-
-}

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

@@ -1,778 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.bukkit;
-
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import org.bukkit.ChatColor;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.World.Environment;
-import org.bukkit.block.Block;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.plugin.java.JavaPlugin;
-import com.sk89q.bukkit.migration.*;
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.TickSyncDelayLoggerFilter;
-import com.sk89q.worldguard.bukkit.commands.GeneralCommands;
-import com.sk89q.worldguard.bukkit.commands.ProtectionCommands;
-import com.sk89q.worldguard.bukkit.commands.ToggleCommands;
-import com.sk89q.worldguard.protection.*;
-import java.io.*;
-import java.util.*;
-import java.util.logging.Filter;
-import java.util.logging.Logger;
-
-/**
- * The main class for WorldGuard as a Bukkit plugin.
- * 
- * @author sk89q
- */
-public class WorldGuardPlugin extends JavaPlugin {
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * Manager for commands. This automatically handles nested commands,
-     * permissions checking, and a number of other fancy command things.
-     * We just set it up and register commands against it.
-     */
-    private final CommandsManager<CommandSender> commands;
-
-    /**
-     * Handles the region databases for all worlds.
-     */
-    private final GlobalRegionManager globalRegionManager;
-    
-    /**
-     * Handles all configuration.
-     */
-    private final ConfigurationManager configuration;
-    
-    /**
-     * Processes queries for permissions information. The permissions manager
-     * is from WorldEdit and it automatically handles looking up permissions
-     * systems and picking the right one. WorldGuard just needs to call
-     * the permission methods.
-     */
-    private PermissionsResolverManager perms;
-    
-    /**
-     * Used for scheduling flags.
-     */
-    private FlagStateManager flagStateManager;
-
-    /**
-     * Construct objects. Actual loading occurs when the plugin is enabled, so
-     * this merely instantiates the objects.
-     */
-    public WorldGuardPlugin() {
-        configuration = new ConfigurationManager(this);
-        globalRegionManager = new GlobalRegionManager(this);
-        
-        final WorldGuardPlugin plugin = this;
-        commands = new CommandsManager<CommandSender>() {
-            @Override
-            public boolean hasPermission(CommandSender player, String perm) {
-                return plugin.hasPermission(player, perm);
-            }
-        };
-        
-        // Register command classes
-        commands.register(ToggleCommands.class);
-        commands.register(ProtectionCommands.class);
-        commands.register(GeneralCommands.class);
-    }
-    
-    /**
-     * Called on plugin enable.
-     */
-    public void onEnable() {
-        // Need to create the plugins/WorldGuard folder
-        getDataFolder().mkdirs();
-
-        // Set up permissions
-        perms = new PermissionsResolverManager(
-                getConfiguration(), getServer(), "WorldGuard", logger);
-        perms.load();
-
-        // This must be done before configuration is laoded
-        LegacyWorldGuardMigration.migrateBlacklist(this);
-        
-        // Load the configuration
-        configuration.load();
-        globalRegionManager.preload();
-        
-        // Migrate regions after the regions were loaded because
-        // the migration code reuses the loaded region managers
-        LegacyWorldGuardMigration.migrateRegions(this);
-
-        // Load permissions
-        (new PermissionsResolverServerListener(perms)).register(this);
-
-        flagStateManager = new FlagStateManager(this);
-        
-        if (configuration.useRegionsScheduler) { 
-            getServer().getScheduler().scheduleAsyncRepeatingTask(this,
-                    flagStateManager, FlagStateManager.RUN_DELAY, FlagStateManager.RUN_DELAY);
-        }
-
-        if (configuration.suppressTickSyncWarnings) {
-            Logger.getLogger("Minecraft").setFilter(
-                    new TickSyncDelayLoggerFilter());
-        } else {
-            Filter filter = Logger.getLogger("Minecraft").getFilter();
-            if (filter != null && filter instanceof TickSyncDelayLoggerFilter) {
-                Logger.getLogger("Minecraft").setFilter(null);
-            }
-        }
-
-        // Register events
-        (new WorldGuardPlayerListener(this)).registerEvents();
-        (new WorldGuardBlockListener(this)).registerEvents();
-        (new WorldGuardEntityListener(this)).registerEvents();
-        (new WorldGuardWeatherListener(this)).registerEvents();
-        (new WorldGuardWorldListener(this)).registerEvents();
-        
-        logger.info("WorldGuard " + this.getDescription().getVersion() + " enabled.");
-    }
-
-    /**
-     * Called on plugin disable.
-     */
-    public void onDisable() {
-        globalRegionManager.unload();
-        configuration.unload();
-
-        logger.info("WorldGuard " + getDescription().getVersion() + " disabled.");
-    }
-    
-    /**
-     * Handle a command.
-     */
-    @Override
-    public boolean onCommand(CommandSender sender, Command cmd, String label,
-            String[] args) {
-        try {
-            commands.execute(cmd.getName(), args, sender, this, sender);
-        } catch (CommandPermissionsException e) {
-            sender.sendMessage(ChatColor.RED + "You don't have permission.");
-        } catch (MissingNestedCommandException e) {
-            sender.sendMessage(ChatColor.RED + e.getUsage());
-        } catch (CommandUsageException e) {
-            sender.sendMessage(ChatColor.RED + e.getMessage());
-            sender.sendMessage(ChatColor.RED + e.getUsage());
-        } catch (WrappedCommandException e) {
-            if (e.getCause() instanceof NumberFormatException) {
-                sender.sendMessage(ChatColor.RED + "Number expected, string received instead.");
-            } else {
-                sender.sendMessage(ChatColor.RED + "An error has occurred. See console.");
-                e.printStackTrace();
-            }
-        } catch (CommandException e) {
-            sender.sendMessage(ChatColor.RED + e.getMessage());
-        }
-        
-        return true;
-    }
-
-    /**
-     * Get the GlobalRegionManager.
-     * 
-     * @return
-     */
-    public GlobalRegionManager getGlobalRegionManager() {
-        return globalRegionManager;
-    }
-
-    /**
-     * Get the WorldGuardConfiguraton.
-     *
-     * @return
-     * @deprecated Use {@link #getGlobalStateManager()} instead
-     */
-    @Deprecated
-    public ConfigurationManager getGlobalConfiguration() {
-        return getGlobalStateManager();
-    }
-    
-    /**
-     * Gets the flag state manager.
-     * 
-     * @return
-     */
-    public FlagStateManager getFlagStateManager() {
-        return flagStateManager;
-    }
-
-    /**
-     * Get the WorldGuardConfiguraton.
-     *
-     * @return
-     */
-    public ConfigurationManager getGlobalStateManager() {
-        return configuration;
-    }
-
-    /**
-     * Check whether a player is in a group.
-     * 
-     * @param player
-     * @param group
-     * @return
-     */
-    public boolean inGroup(Player player, String group) {
-        try {
-            return perms.inGroup(player.getName(), group);
-        } catch (Throwable t) {
-            t.printStackTrace();
-            return false;
-        }
-    }
-
-    /**
-     * Get the groups of a player.
-     * 
-     * @param player
-     * @return
-     */
-    public String[] getGroups(Player player) {
-        try {
-            return perms.getGroups(player.getName());
-        } catch (Throwable t) {
-            t.printStackTrace();
-            return new String[0];
-        }
-    }
-    
-    /**
-     * Gets the name of a command sender. This is a unique name and this
-     * method should never return a "display name".
-     * 
-     * @param sender
-     * @return
-     */
-    public String toUniqueName(CommandSender sender) {
-        if (sender instanceof Player) {
-            return ((Player) sender).getName();
-        } else {
-            return "*Console*";
-        }
-    }
-    
-    /**
-     * Gets the name of a command sender. This play be a display name.
-     * 
-     * @param sender
-     * @return
-     */
-    public String toName(CommandSender sender) {
-        if (sender instanceof Player) {
-            return ((Player) sender).getName();
-        } else {
-            return "*Console*";
-        }
-    }
-    
-    /**
-     * Checks permissions.
-     * 
-     * @param sender
-     * @param perm
-     * @return 
-     */
-    public boolean hasPermission(CommandSender sender, String perm) {
-        if (sender.isOp()) {
-            if (sender instanceof Player) {
-                if (this.getGlobalStateManager().get(((Player) sender).
-                        getWorld()).opPermissions) {
-                    return true;
-                }
-            } else {
-                return true;
-            }
-        }
-        
-        // Invoke the permissions resolver
-        if (sender instanceof Player) {
-            return perms.hasPermission(((Player) sender).getName(), perm);
-        }
-        
-        return false;
-    }
-    
-    /**
-     * Checks permissions and throws an exception if permission is not met.
-     * 
-     * @param sender
-     * @param perm
-     * @throws CommandPermissionsException 
-     */
-    public void checkPermission(CommandSender sender, String perm)
-            throws CommandPermissionsException {
-        if (!hasPermission(sender, perm)) {
-            throw new CommandPermissionsException();
-        }
-    }
-    
-    /**
-     * Checks to see if the sender is a player, otherwise throw an exception.
-     * 
-     * @param sender
-     * @return 
-     * @throws CommandException 
-     */
-    public Player checkPlayer(CommandSender sender)
-            throws CommandException {
-        if (sender instanceof Player) {
-            return (Player) sender;
-        } else {
-            throw new CommandException("A player is expected.");
-        }
-    }
-    
-    /**
-     * Match player names.
-     * 
-     * @param filter
-     * @return
-     */
-    public List<Player> matchPlayerNames(String filter) {
-        Player[] players = getServer().getOnlinePlayers();
-
-        filter = filter.toLowerCase();
-        
-        // Allow exact name matching
-        if (filter.charAt(0) == '@' && filter.length() >= 2) {
-            filter = filter.substring(1);
-            
-            for (Player player : players) {
-                if (player.getName().equalsIgnoreCase(filter)) {
-                    List<Player> list = new ArrayList<Player>();
-                    list.add(player);
-                    return list;
-                }
-            }
-            
-            return new ArrayList<Player>();
-        // Allow partial name matching
-        } else if (filter.charAt(0) == '*' && filter.length() >= 2) {
-            filter = filter.substring(1);
-            
-            List<Player> list = new ArrayList<Player>();
-            
-            for (Player player : players) {
-                if (player.getName().toLowerCase().contains(filter)) {
-                    list.add(player);
-                }
-            }
-            
-            return list;
-        
-        // Start with name matching
-        } else {
-            List<Player> list = new ArrayList<Player>();
-            
-            for (Player player : players) {
-                if (player.getName().toLowerCase().startsWith(filter)) {
-                    list.add(player);
-                }
-            }
-            
-            return list;
-        }
-    }
-    
-    /**
-     * Checks if the given list of players is greater than size 0, otherwise
-     * throw an exception.
-     * 
-     * @param players
-     * @return 
-     * @throws CommandException
-     */
-    protected Iterable<Player> checkPlayerMatch(List<Player> players)
-            throws CommandException {
-        // Check to see if there were any matches
-        if (players.size() == 0) {
-            throw new CommandException("No players matched query.");
-        }
-        
-        return players;
-    }
-    
-    /**
-     * Checks permissions and throws an exception if permission is not met.
-     * 
-     * @param source 
-     * @param filter
-     * @return iterator for players
-     * @throws CommandException no matches found
-     */
-    public Iterable<Player> matchPlayers(CommandSender source, String filter)
-            throws CommandException {
-        
-        if (getServer().getOnlinePlayers().length == 0) {
-            throw new CommandException("No players matched query.");
-        }
-        
-        if (filter.equals("*")) {
-            return checkPlayerMatch(Arrays.asList(getServer().getOnlinePlayers()));
-        }
-
-        // Handle special hash tag groups
-        if (filter.charAt(0) == '#') {
-            // Handle #world, which matches player of the same world as the
-            // calling source
-            if (filter.equalsIgnoreCase("#world")) {
-                List<Player> players = new ArrayList<Player>();
-                Player sourcePlayer = checkPlayer(source);
-                World sourceWorld = sourcePlayer.getWorld();
-                
-                for (Player player : getServer().getOnlinePlayers()) {
-                    if (player.getWorld().equals(sourceWorld)) {
-                        players.add(player);
-                    }
-                }
-
-                return checkPlayerMatch(players);
-            
-            // Handle #near, which is for nearby players.
-            } else if (filter.equalsIgnoreCase("#near")) {
-                List<Player> players = new ArrayList<Player>();
-                Player sourcePlayer = checkPlayer(source);
-                World sourceWorld = sourcePlayer.getWorld();
-                org.bukkit.util.Vector sourceVector
-                        = sourcePlayer.getLocation().toVector();
-                
-                for (Player player : getServer().getOnlinePlayers()) {
-                    if (player.getWorld().equals(sourceWorld)
-                            && player.getLocation().toVector().distanceSquared(
-                                    sourceVector) < 900) {
-                        players.add(player);
-                    }
-                }
-
-                return checkPlayerMatch(players);
-            
-            } else {
-                throw new CommandException("Invalid group '" + filter + "'.");
-            }
-        }
-        
-        List<Player> players = matchPlayerNames(filter);
-        
-        return checkPlayerMatch(players);
-    }
-    
-    /**
-     * Match only a single player.
-     * 
-     * @param sender
-     * @param filter
-     * @return
-     * @throws CommandException
-     */
-    public Player matchSinglePlayer(CommandSender sender, String filter)
-            throws CommandException {
-        // This will throw an exception if there are no matches
-        Iterator<Player> players = matchPlayers(sender, filter).iterator();
-        
-        Player match = players.next();
-        
-        // We don't want to match the wrong person, so fail if if multiple
-        // players were found (we don't want to just pick off the first one,
-        // as that may be the wrong player)
-        if (players.hasNext()) {
-            throw new CommandException("More than one player found! " +
-                        "Use @<name> for exact matching.");
-        }
-        
-        return match;
-    }
-    
-    /**
-     * Match only a single player or console.
-     * 
-     * @param sender
-     * @param filter
-     * @return
-     * @throws CommandException
-     */
-    public CommandSender matchPlayerOrConsole(CommandSender sender, String filter)
-            throws CommandException {
-        
-        // Let's see if console is wanted
-        if (filter.equalsIgnoreCase("#console")
-                || filter.equalsIgnoreCase("*console*")
-                || filter.equalsIgnoreCase("!")) {
-            return new ConsoleCommandSender(getServer());
-        }
-        
-        return matchSinglePlayer(sender, filter);
-    }
-    
-    /**
-     * Get a single player as an iterator for players.
-     * 
-     * @param player
-     * @return iterator for players
-     */
-    public Iterable<Player> matchPlayers(Player player) {
-        return Arrays.asList(new Player[] {player});
-    }
-    
-    /**
-     * Match a world.
-     * @param sender 
-     * 
-     * @param filter
-     * @return
-     * @throws CommandException 
-     */
-    public World matchWorld(CommandSender sender, String filter) throws CommandException {
-        List<World> worlds = getServer().getWorlds();
-
-        // Handle special hash tag groups
-        if (filter.charAt(0) == '#') {
-            // #main for the main world
-            if (filter.equalsIgnoreCase("#main")) {
-                return worlds.get(0);
-            
-            // #normal for the first normal world
-            } else if (filter.equalsIgnoreCase("#normal")) {
-                for (World world : worlds) {
-                    if (world.getEnvironment() == Environment.NORMAL) {
-                        return world;
-                    }
-                }
-
-                throw new CommandException("No normal world found.");
-            
-            // #nether for the first nether world
-            } else if (filter.equalsIgnoreCase("#nether")) {
-                for (World world : worlds) {
-                    if (world.getEnvironment() == Environment.NETHER) {
-                        return world;
-                    }
-                }
-
-                throw new CommandException("No nether world found.");
-
-            // Handle getting a world from a player
-            } else if (filter.matches("^#player$")) {
-                String parts[] = filter.split(":", 2);
-                
-                // They didn't specify an argument for the player!
-                if (parts.length == 1) {
-                    throw new CommandException("Argument expected for #player.");
-                }
-                
-                return matchPlayers(sender, parts[1]).iterator().next().getWorld();
-            } else {
-                throw new CommandException("Invalid identifier '" + filter + "'.");
-            }
-        }
-        
-        for (World world : worlds) {
-            if (world.getName().equals(filter)) {
-                return world;
-            }
-        }
-        
-        throw new CommandException("No world by that exact name found.");
-    }
-
-    /**
-     * Gets a copy of the WorldEdit plugin.
-     * 
-     * @return
-     * @throws CommandException
-     */
-    public WorldEditPlugin getWorldEdit() throws CommandException {
-        Plugin worldEdit = getServer().getPluginManager().getPlugin("WorldEdit");
-        if (worldEdit == null) {
-            throw new CommandException("WorldEdit does not appear to be installed.");
-        }
-        
-        if (worldEdit instanceof WorldEditPlugin) {
-            return (WorldEditPlugin) worldEdit;
-        } else {
-            throw new CommandException("WorldEdit detection failed (report error).");
-        }
-    }
-    
-    /**
-     * Wrap a player as a LocalPlayer.
-     * 
-     * @param player
-     * @return
-     */
-    public LocalPlayer wrapPlayer(Player player) {
-        return new BukkitPlayer(this, player);
-    }
-    
-    /**
-     * Create a default configuration file from the .jar.
-     * 
-     * @param actual 
-     * @param defaultName 
-     */
-    public static void createDefaultConfiguration(File actual,
-            String defaultName) {
-        
-        // Make parent directories
-        File parent = actual.getParentFile();
-        if (!parent.exists()) {
-            parent.mkdirs();
-        }
-
-        if (actual.exists()) {
-            return;
-        }
-
-        InputStream input = WorldGuardPlugin.class
-                .getResourceAsStream("/defaults/" + defaultName);
-        
-        if (input != null) {
-            FileOutputStream output = null;
-
-            try {
-                output = new FileOutputStream(actual);
-                byte[] buf = new byte[8192];
-                int length = 0;
-                while ((length = input.read(buf)) > 0) {
-                    output.write(buf, 0, length);
-                }
-
-                logger.info("WorldGuard: Default configuration file written: "
-                        + actual.getAbsolutePath());
-            } catch (IOException e) {
-                e.printStackTrace();
-            } finally {
-                try {
-                    if (input != null) {
-                        input.close();
-                    }
-                } catch (IOException e) {
-                }
-
-                try {
-                    if (output != null) {
-                        output.close();
-                    }
-                } catch (IOException e) {
-                }
-            }
-        }
-    }
-    
-    /**
-     * Notifies all with the notify permission.
-     * 
-     * @param msg
-     */
-    public void broadcastNotification(String msg) {
-        for (Player player : getServer().getOnlinePlayers()) {
-            if (hasPermission(player, "worldguard.notify")) {
-                player.sendMessage(msg);
-            }
-        }
-    }
-    
-    /**
-     * Forgets a player.
-     * 
-     * @param player
-     */
-    public void forgetPlayer(Player player) {
-        flagStateManager.forget(player);
-    }
-    
-    /**
-     * Checks to see if a player can build at a location. This will return
-     * true if region protection is disabled.
-     * 
-     * @param player
-     * @param loc
-     * @return
-     */
-    public boolean canBuild(Player player, Location loc) {
-        return getGlobalRegionManager().canBuild(player, loc);
-    }
-    
-    /**
-     * Checks to see if a player can build at a location. This will return
-     * true if region protection is disabled.
-     * 
-     * @param player
-     * @param block
-     * @return
-     */
-    public boolean canBuild(Player player, Block block) {
-        return getGlobalRegionManager().canBuild(player, block);
-    }
-
-    /**
-     * Gets the region manager for a world.
-     *
-     * @param world world to get the region manager for
-     * @return the region manager or null if regions are not enabled
-     */
-    public RegionManager getRegionManager(World world) {
-        if (!getGlobalStateManager().get(world).useRegions) {
-            return null;
-        }
-
-        return getGlobalRegionManager().get(world);
-    }
-
-    /**
-     * Replace macros in the text.
-     *
-     * @param sender
-     * @param message
-     * @return
-     */
-    public String replaceMacros(CommandSender sender, String message) {
-        Player[] online = getServer().getOnlinePlayers();
-
-        message = message.replace("%name%", toName(sender));
-        message = message.replace("%id%", toUniqueName(sender));
-        message = message.replace("%online%", String.valueOf(online.length));
-
-        if (sender instanceof Player) {
-            Player player = (Player) sender;
-            World world = player.getWorld();
-
-            message = message.replace("%world%", world.getName());
-            message = message.replace("%health%", String.valueOf(player.getHealth()));
-        }
-
-        return message;
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/WorldGuardWeatherListener.java

@@ -1,149 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.bukkit;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-import org.bukkit.Location;
-import org.bukkit.event.Event;
-import org.bukkit.event.Event.Priority;
-import org.bukkit.event.weather.LightningStrikeEvent;
-import org.bukkit.event.weather.ThunderChangeEvent;
-import org.bukkit.event.weather.WeatherChangeEvent;
-import org.bukkit.event.weather.WeatherListener;
-import org.bukkit.plugin.PluginManager;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-import java.util.logging.Logger;
-
-public class WorldGuardWeatherListener extends WeatherListener {
-
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-
-    /**
-     * Plugin.
-     */
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
-    public WorldGuardWeatherListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    public void registerEvents() {
-        PluginManager pm = plugin.getServer().getPluginManager();
-
-        registerEvent("LIGHTNING_STRIKE", Priority.High);
-        registerEvent("THUNDER_CHANGE", Priority.High);
-        registerEvent("WEATHER_CHANGE", Priority.High);
-    }
-
-    /**
-     * Register an event, but not failing if the event is not implemented.
-     *
-     * @param typeName
-     * @param priority
-     */
-    private void registerEvent(String typeName, Priority priority) {
-        try {
-            Event.Type type = Event.Type.valueOf(typeName);
-            PluginManager pm = plugin.getServer().getPluginManager();
-            pm.registerEvent(type, this, priority, plugin);
-        } catch (IllegalArgumentException e) {
-            logger.info("WorldGuard: Unable to register missing event type " + typeName);
-        }
-    }
-
-    @Override
-    public void onWeatherChange(WeatherChangeEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
-
-        if (event.toWeatherState()) {
-            if (wcfg.disableWeather) {
-                event.setCancelled(true);
-            }
-        } else {
-            if (!wcfg.disableWeather && wcfg.alwaysRaining) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @Override
-    public void onThunderChange(ThunderChangeEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
-
-        if (event.toThunderState()) {
-            if (wcfg.disableThunder) {
-                event.setCancelled(true);
-            }
-        } else {
-            if (!wcfg.disableWeather && wcfg.alwaysThundering) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-    @Override
-    public void onLightningStrike(LightningStrikeEvent event) {
-        if (event.isCancelled()) {
-           return;
-        }
-
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-        WorldConfiguration wcfg = cfg.get(event.getWorld());
-
-        if (wcfg.disallowedLightningBlocks.size() > 0) {
-            int targetId = event.getLightning().getLocation().getBlock().getTypeId();
-            if (wcfg.disallowedLightningBlocks.contains(targetId)) {
-                event.setCancelled(true);
-            }
-        }
-
-        Location loc = event.getLightning().getLocation();
-        if (wcfg.useRegions) {
-            Vector pt = toVector(loc);
-            RegionManager mgr = plugin.getGlobalRegionManager().get(loc.getWorld());
-            ApplicableRegionSet set = mgr.getApplicableRegions(pt);
-
-            if (!set.allows(DefaultFlag.LIGHTNING)) {
-                event.setCancelled(true);
-            }
-        }
-    }
-
-}

src/main/java/com/sk89q/worldguard/bukkit/WorldGuardWorldListener.java

@@ -1,84 +0,0 @@
-// $Id$
-/*
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- * All rights reserved.
-*/
-package com.sk89q.worldguard.bukkit;
-
-import org.bukkit.entity.*;
-import org.bukkit.event.Event;
-import org.bukkit.event.world.ChunkLoadEvent;
-import org.bukkit.event.world.WorldListener;
-import org.bukkit.plugin.PluginManager;
-
-import java.util.logging.Logger;
-
-public class WorldGuardWorldListener extends WorldListener {
-
-    /**
-     * Logger for messages.
-     */
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-
-    private WorldGuardPlugin plugin;
-
-    /**
-     * Construct the object;
-     *
-     * @param plugin
-     */
-    public WorldGuardWorldListener(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-    }
-
-    /**
-     * Register events.
-     */
-    public void registerEvents() {
-        PluginManager pm = plugin.getServer().getPluginManager();
-
-        registerEvent("CHUNK_LOAD", Event.Priority.Normal);
-    }
-
-    /**
-     * Register an event, but not failing if the event is not implemented.
-     *
-     * @param typeName
-     * @param priority
-     */
-    private void registerEvent(String typeName, Event.Priority priority) {
-        try {
-            Event.Type type = Event.Type.valueOf(typeName);
-            PluginManager pm = plugin.getServer().getPluginManager();
-            pm.registerEvent(type, this, priority, plugin);
-        } catch (IllegalArgumentException e) {
-            logger.info("WorldGuard: Unable to register missing event type " + typeName);
-        }
-    }
-
-    /**
-     * Called when a chunk is loaded.
-     */
-    public void onChunkLoad(ChunkLoadEvent event) {
-        ConfigurationManager cfg = plugin.getGlobalStateManager();
-
-        if (cfg.activityHaltToggle) {
-            int removed = 0;
-
-            for (Entity entity : event.getChunk().getEntities()) {
-                if (entity instanceof Item
-                        || (entity instanceof LivingEntity
-                        && !(entity instanceof Tameable)
-                        && !(entity instanceof Player))) {
-                    entity.remove();
-                    removed++;
-                }
-            }
-
-            if (removed > 50) {
-                logger.info("WG Halt-Act: " + removed + " entities (>50) auto-removed from "
-                        + event.getChunk().toString());
-            }
-        }
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/GeneralCommands.java

@@ -1,316 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissions;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldedit.blocks.ItemType;
-
-public class GeneralCommands {
-    
-    @Command(aliases = {"god"},
-            usage = "[player]",
-            desc = "Enable godmode on a player",
-            flags = "s", min = 0, max = 1)
-    public static void god(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        ConfigurationManager config = plugin.getGlobalStateManager();
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god.other");
-        }
-
-        for (Player player : targets) {
-            config.enableGodMode(player);
-            player.setFireTicks(0);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "God mode enabled! Use /ungod to disable.");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "God enabled by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players now have god mode.");
-        }
-    }
-    
-    @Command(aliases = {"ungod"},
-            usage = "[player]",
-            desc = "Disable godmode on a player",
-            flags = "s", min = 0, max = 1)
-    public static void ungod(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        ConfigurationManager config = plugin.getGlobalStateManager();
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.god.other");
-        }
-
-        for (Player player : targets) {
-            config.disableGodMode(player);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "God mode disabled!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "God disabled by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players no longer have god mode.");
-        }
-    }
-    
-    @Command(aliases = {"heal"},
-            usage = "[player]",
-            desc = "Heal a player",
-            flags = "s", min = 0, max = 1)
-    public static void heal(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.heal");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.heal.other");
-        }
-
-        for (Player player : targets) {
-            player.setHealth(20);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "Healed!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Healed by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players healed.");
-        }
-    }
-    
-    @Command(aliases = {"slay"},
-            usage = "[player]",
-            desc = "Slay a player",
-            flags = "s", min = 0, max = 1)
-    public static void slay(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Iterable<Player> targets = null;
-        boolean included = false;
-        
-        // Detect arguments based on the number of arguments provided
-        if (args.argsLength() == 0) {
-            targets = plugin.matchPlayers(plugin.checkPlayer(sender));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.slay");
-        } else if (args.argsLength() == 1) {            
-            targets = plugin.matchPlayers(sender, args.getString(0));
-            
-            // Check permissions!
-            plugin.checkPermission(sender, "worldguard.slay.other");
-        }
-
-        for (Player player : targets) {
-            player.setHealth(0);
-            
-            // Tell the user
-            if (player.equals(sender)) {
-                player.sendMessage(ChatColor.YELLOW + "Slain!");
-                
-                // Keep track of this
-                included = true;
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "Slain by "
-                        + plugin.toName(sender) + ".");
-                
-            }
-        }
-        
-        // The player didn't receive any items, then we need to send the
-        // user a message so s/he know that something is indeed working
-        if (!included && args.hasFlag('s')) {
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Players slain.");
-        }
-    }
-    
-    @Command(aliases = {"locate"},
-            usage = "[player]",
-            desc = "Locate a player",
-            flags = "", min = 0, max = 1)
-    @CommandPermissions({"worldguard.locate"})
-    public static void locate(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        
-        if (args.argsLength() == 0) {
-            player.setCompassTarget(player.getWorld().getSpawnLocation());
-            
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Compass reset to spawn.");
-        } else {
-            Player target = plugin.matchSinglePlayer(sender, args.getString(0));
-            player.setCompassTarget(target.getLocation());
-            
-            sender.sendMessage(ChatColor.YELLOW.toString() + "Compass repointed.");
-        }
-    }
-    
-    @Command(aliases = {"stack"},
-            usage = "",
-            desc = "Stack items",
-            flags = "", min = 0, max = 0)
-    @CommandPermissions({"worldguard.stack"})
-    public static void stack(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        
-        ItemStack[] items = player.getInventory().getContents();
-        int len = items.length;
-
-        int affected = 0;
-        
-        for (int i = 0; i < len; i++) {
-            ItemStack item = items[i];
-
-            // Avoid infinite stacks and stacks with durability
-            if (item == null || item.getAmount() <= 0
-                    || ItemType.shouldNotStack(item.getTypeId())) {
-                continue;
-            }
-
-            // Ignore buckets
-            if (item.getTypeId() >= 325 && item.getTypeId() <= 327) {
-                continue;
-            }
-
-            if (item.getAmount() < 64) {
-                int needed = 64 - item.getAmount(); // Number of needed items until 64
-
-                // Find another stack of the same type
-                for (int j = i + 1; j < len; j++) {
-                    ItemStack item2 = items[j];
-
-                    // Avoid infinite stacks and stacks with durability
-                    if (item2 == null || item2.getAmount() <= 0
-                            || ItemType.shouldNotStack(item.getTypeId())) {
-                        continue;
-                    }
-
-                    // Same type?
-                    // Blocks store their color in the damage value
-                    if (item2.getTypeId() == item.getTypeId() &&
-                            (!ItemType.usesDamageValue(item.getTypeId())
-                                    || item.getDurability() == item2.getDurability())) {
-                        // This stack won't fit in the parent stack
-                        if (item2.getAmount() > needed) {
-                            item.setAmount(64);
-                            item2.setAmount(item2.getAmount() - needed);
-                            break;
-                        // This stack will
-                        } else {
-                            items[j] = null;
-                            item.setAmount(item.getAmount() + item2.getAmount());
-                            needed = 64 - item.getAmount();
-                        }
-
-                        affected++;
-                    }
-                }
-            }
-        }
-
-        if (affected > 0) {
-            player.getInventory().setContents(items);
-        }
-
-        player.sendMessage(ChatColor.YELLOW + "Items compacted into stacks!");
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/ProtectionCommands.java

@@ -1,40 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-public class ProtectionCommands {
-    @Command(aliases = {"region"},
-            desc = "Region management commands")
-    @NestedCommand({RegionCommands.class, RegionMemberCommands.class})
-    public static void region(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-    }
-
-    @Command(aliases = {"worldguard"},
-            desc = "WorldGuard commands")
-    @NestedCommand({WorldGuardCommands.class})
-    public static void worldGuard(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/RegionCommands.java

@@ -1,921 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import java.io.IOException;
-import java.util.Arrays;
-import java.util.Map;
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldedit.bukkit.WorldEditPlugin;
-import com.sk89q.worldedit.bukkit.selections.*;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.ApplicableRegionSet;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.flags.InvalidFlagFormat;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.*;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
-import com.sk89q.worldguard.util.RegionUtil;
-
-public class RegionCommands {
-    
-    @Command(aliases = {"define", "def", "d"},
-            usage = "<id> [<owner1> [<owner2> [<owners...>]]]",
-            desc = "Defines a region",
-            flags = "", min = 1, max = -1)
-    @CommandPermissions({"worldguard.region.define"})
-    public static void define(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        WorldEditPlugin worldEdit = plugin.getWorldEdit();
-        String id = args.getString(0);
-        
-        if (!ProtectedRegion.isValidId(id)) {
-            throw new CommandException("Invalid region ID specified!");
-        }
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("A region cannot be named __global__");
-        }
-        
-        // Attempt to get the player's selection from WorldEdit
-        Selection sel = worldEdit.getSelection(player);
-        
-        if (sel == null) {
-            throw new CommandException("Select a region with WorldEdit first.");
-        }
-        
-        ProtectedRegion region;
-        
-        // Detect the type of region from WorldEdit
-        if (sel instanceof Polygonal2DSelection) {
-            Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
-            int minY = polySel.getNativeMinimumPoint().getBlockY();
-            int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
-        } else if (sel instanceof CuboidSelection) {
-            BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
-            BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
-        } else {
-            throw new CommandException(
-                    "The type of region selected in WorldEdit is unsupported in WorldGuard!");
-        }
-
-        // Get the list of region owners
-        if (args.argsLength() > 1) {
-            region.setOwners(RegionUtil.parseDomainString(args.getSlice(1), 1));
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(sel.getWorld());
-        mgr.addRegion(region);
-        
-        try {
-            mgr.save();
-            sender.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"redefine", "update", "move"},
-            usage = "<id>",
-            desc = "Re-defines the shape of a region",
-            flags = "", min = 1, max = 1)
-    public static void redefine(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        WorldEditPlugin worldEdit = plugin.getWorldEdit();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        String id = args.getString(0);
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("The region cannot be named __global__");
-        }
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion existing = mgr.getRegion(id);
-
-        if (existing == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (existing.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.redefine.own");
-        } else if (existing.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.redefine.member");
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.redefine");
-        } 
-        
-        // Attempt to get the player's selection from WorldEdit
-        Selection sel = worldEdit.getSelection(player);
-        
-        if (sel == null) {
-            throw new CommandException("Select a region with WorldEdit first.");
-        }
-        
-        ProtectedRegion region;
-        
-        // Detect the type of region from WorldEdit
-        if (sel instanceof Polygonal2DSelection) {
-            Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
-            int minY = polySel.getNativeMinimumPoint().getBlockY();
-            int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
-        } else if (sel instanceof CuboidSelection) {
-            BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
-            BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
-        } else {
-            throw new CommandException(
-                    "The type of region selected in WorldEdit is unsupported in WorldGuard!");
-        }
-
-        region.setMembers(existing.getMembers());
-        region.setOwners(existing.getOwners());
-        region.setFlags(existing.getFlags());
-        region.setPriority(existing.getPriority());
-        try {
-            region.setParent(existing.getParent());
-        } catch (CircularInheritanceException e) {
-        }
-        
-        mgr.addRegion(region);
-        
-        sender.sendMessage(ChatColor.YELLOW + "Region updated with new area.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"claim"},
-            usage = "<id> [<owner1> [<owner2> [<owners...>]]]",
-            desc = "Claim a region",
-            flags = "", min = 1, max = -1)
-    @CommandPermissions({"worldguard.region.claim"})
-    public static void claim(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        WorldEditPlugin worldEdit = plugin.getWorldEdit();
-        String id = args.getString(0);
-        
-        if (!ProtectedRegion.isValidId(id)) {
-            throw new CommandException("Invalid region ID specified!");
-        }
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("A region cannot be named __global__");
-        }
-        
-        // Attempt to get the player's selection from WorldEdit
-        Selection sel = worldEdit.getSelection(player);
-        
-        if (sel == null) {
-            throw new CommandException("Select a region with WorldEdit first.");
-        }
-        
-        ProtectedRegion region;
-        
-        // Detect the type of region from WorldEdit
-        if (sel instanceof Polygonal2DSelection) {
-            Polygonal2DSelection polySel = (Polygonal2DSelection) sel;
-            int minY = polySel.getNativeMinimumPoint().getBlockY();
-            int maxY = polySel.getNativeMaximumPoint().getBlockY();
-            region = new ProtectedPolygonalRegion(id, polySel.getNativePoints(), minY, maxY);
-        } else if (sel instanceof CuboidSelection) {
-            BlockVector min = sel.getNativeMinimumPoint().toBlockVector();
-            BlockVector max = sel.getNativeMaximumPoint().toBlockVector();
-            region = new ProtectedCuboidRegion(id, min, max);
-        } else {
-            throw new CommandException(
-                    "The type of region selected in WorldEdit is unsupported in WorldGuard!");
-        }
-
-        // Get the list of region owners
-        if (args.argsLength() > 1) {
-            region.setOwners(RegionUtil.parseDomainString(args.getSlice(1), 1));
-        }
-
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(player.getWorld());
-        RegionManager mgr = plugin.getGlobalRegionManager().get(sel.getWorld());
-        
-        if (!plugin.hasPermission(sender, "worldguard.region.unlimited")) {
-            // Check whether the player has created too many regions 
-            if (wcfg.maxRegionCountPerPlayer >= 0
-                    && mgr.getRegionCountOfPlayer(localPlayer) >= wcfg.maxRegionCountPerPlayer) {
-                throw new CommandException("You own too many regions, delete one first to claim a new one.");
-            }
-        }
-
-        ProtectedRegion existing = mgr.getRegion(id);
-
-        // Check for an existing region
-        if (existing != null) {
-            if (!existing.getOwners().contains(localPlayer)) {
-                throw new CommandException("This region already exists and you don't own it.");
-            }
-        }
-        
-        ApplicableRegionSet regions = mgr.getApplicableRegions(region);
-        
-        // Check if this region overlaps any other region
-        if (regions.size() > 0) {
-            if (!regions.isOwnerOfAll(localPlayer)) {
-                throw new CommandException("This region overlaps with someone else's region.");
-            }
-        } else {
-            if (wcfg.claimOnlyInsideExistingRegions) {
-                throw new CommandException("You may only claim regions inside " +
-                		"existing regions that you or your group own.");
-            }
-        }
-
-        /*if (plugin.getGlobalConfiguration().getiConomy() != null && wcfg.useiConomy && wcfg.buyOnClaim) {
-            if (iConomy.getBank().hasAccount(player.getName())) {
-                Account account = iConomy.getBank().getAccount(player.getName());
-                double balance = account.getBalance();
-                double regionCosts = region.countBlocks() * wcfg.buyOnClaimPrice;
-                if (balance >= regionCosts) {
-                    account.subtract(regionCosts);
-                    player.sendMessage(ChatColor.YELLOW + "You have bought that region for "
-                            + iConomy.getBank().format(regionCosts));
-                    account.save();
-                } else {
-                    player.sendMessage(ChatColor.RED + "You have not enough money.");
-                    player.sendMessage(ChatColor.RED + "The region you want to claim costs "
-                            + iConomy.getBank().format(regionCosts));
-                    player.sendMessage(ChatColor.RED + "You have " + iConomy.getBank().format(balance));
-                    return;
-                }
-            } else {
-                player.sendMessage(ChatColor.YELLOW + "You have not enough money.");
-                return;
-            }
-        }*/
-
-        if (!plugin.hasPermission(sender, "worldguard.region.unlimited")) {
-            if (region.volume() > wcfg.maxClaimVolume) {
-                player.sendMessage(ChatColor.RED + "This region is too large to claim.");
-                player.sendMessage(ChatColor.RED +
-                        "Max. volume: " + wcfg.maxClaimVolume + ", your volume: " + region.volume());
-                return;
-            }
-        }
-
-        region.getOwners().addPlayer(player.getName());
-        mgr.addRegion(region);
-        
-        try {
-            mgr.save();
-            sender.sendMessage(ChatColor.YELLOW + "Region saved as " + id + ".");
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"select", "sel", "s"},
-            usage = "<id>",
-            desc = "Load a region as a WorldEdit selection",
-            flags = "", min = 1, max = 1)
-    public static void select(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        WorldEditPlugin worldEdit = plugin.getWorldEdit();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.select.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.select.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.select." + id.toLowerCase());
-        }
-
-        if (region instanceof ProtectedCuboidRegion) {
-            ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion) region;
-            Vector pt1 = cuboid.getMinimumPoint();
-            Vector pt2 = cuboid.getMaximumPoint();
-            CuboidSelection selection = new CuboidSelection(world, pt1, pt2);
-            worldEdit.setSelection(player, selection);
-            sender.sendMessage(ChatColor.YELLOW + "Region selected as a cuboid.");
-        } else if (region instanceof ProtectedPolygonalRegion) {
-            ProtectedPolygonalRegion poly2d = (ProtectedPolygonalRegion) region;
-            Polygonal2DSelection selection = new Polygonal2DSelection(world, poly2d.getPoints(),
-                    poly2d.getMinimumPoint().getBlockY(), poly2d.getMaximumPoint().getBlockY());
-            worldEdit.setSelection(player, selection);
-            sender.sendMessage(ChatColor.YELLOW + "Region selected as a polygon.");
-        } else if (region instanceof GlobalProtectedRegion) {
-            throw new CommandException("Can't select global regions.");
-        } else {
-            throw new CommandException("Unknown region type: " + region.getClass().getCanonicalName());
-        }
-    }
-    
-    @Command(aliases = {"info", "i"},
-            usage = "[world] <id>",
-            desc = "Get information about a region",
-            flags = "", min = 1, max = 2)
-    public static void info(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-
-        Player player = null;
-        LocalPlayer localPlayer = null;
-        World world;
-        String id;
-        
-        // Get different values based on provided arguments
-        if (args.argsLength() == 1) {
-            player = plugin.checkPlayer(sender);
-            localPlayer = plugin.wrapPlayer(player);
-            world = player.getWorld();
-            id = args.getString(0).toLowerCase();
-        } else {
-            world = plugin.matchWorld(sender, args.getString(0));
-            id = args.getString(1).toLowerCase();
-        }
-        
-        if (!ProtectedRegion.isValidId(id)) {
-            throw new CommandException("Invalid region ID specified!");
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        
-        if (!mgr.hasRegion(id)) {
-            throw new CommandException("A region with ID '" + id + "' doesn't exist.");
-        }
-
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (player != null) {
-            if (region.isOwner(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.info.own");
-            } else if (region.isMember(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.info.member");
-            } else {
-                plugin.checkPermission(sender, "worldguard.region.info");
-            }
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.info");
-        }
-
-        DefaultDomain owners = region.getOwners();
-        DefaultDomain members = region.getMembers();
-
-        sender.sendMessage(ChatColor.YELLOW + "Region: " + id
-                + ChatColor.GRAY + " (type: " + region.getTypeName() + ")");
-        sender.sendMessage(ChatColor.BLUE + "Priority: " + region.getPriority());
-
-        StringBuilder s = new StringBuilder();
-
-        for (Flag<?> flag : DefaultFlag.getFlags()) {
-            Object val = region.getFlag(flag);
-            
-            if (val == null) {
-                continue;
-            }
-            
-            if (s.length() > 0) {
-                s.append(", ");
-            }
-
-            s.append(flag.getName() + ": " + String.valueOf(val));
-        }
-
-        sender.sendMessage(ChatColor.BLUE + "Flags: " + s.toString());
-        sender.sendMessage(ChatColor.BLUE + "Parent: "
-                + (region.getParent() == null ? "(none)" : region.getParent().getId()));
-        sender.sendMessage(ChatColor.LIGHT_PURPLE + "Owners: "
-                + owners.toUserFriendlyString());
-        sender.sendMessage(ChatColor.LIGHT_PURPLE + "Members: "
-                + members.toUserFriendlyString());
-        BlockVector min = region.getMinimumPoint();
-        BlockVector max = region.getMaximumPoint();
-        String c = "(" + min.getBlockX() + "," + min.getBlockY() + "," + min.getBlockZ() + ")";
-        c += " (" +max.getBlockX() + "," + max.getBlockY() + "," + max.getBlockZ() + ")";
-        sender.sendMessage(ChatColor.LIGHT_PURPLE + "Bounds: " + c);
-    }
-    
-    @Command(aliases = {"list"},
-            usage = "[.player] [page] [world]",
-            desc = "Get a list of regions",
-            flags = "", min = 0, max = 3)
-//    @CommandPermissions({"worldguard.region.list"})
-    public static void list(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-
-        World world;
-        int page = 0;
-        int argl = 0;
-        String name = "";
-        boolean own = false;
-        LocalPlayer localPlayer = null;
-        
-        if (args.argsLength() > 0 && args.getString(0).startsWith(".")) {
-            name = args.getString(0).substring(1).toLowerCase();
-            argl = 1;
-            
-            if (name.equals("me") || name.isEmpty() ||
-                    name.equals(plugin.checkPlayer(sender).getDisplayName().toLowerCase())) {
-                plugin.checkPermission(sender, "worldguard.region.list.own");
-                name = plugin.checkPlayer(sender).getDisplayName().toLowerCase();
-                localPlayer = plugin.wrapPlayer(plugin.checkPlayer(sender));
-                own = true;
-            }
-        }
-        if (!own)
-            plugin.checkPermission(sender, "worldguard.region.list");
-        
-        if (args.argsLength() > 0 + argl) {
-            page = Math.max(0, args.getInteger(0 + argl) - 1);
-        }
-        
-        if (args.argsLength() > 1 + argl) {
-            world = plugin.matchWorld(sender, args.getString(1 + argl));
-        } else {
-            world = plugin.checkPlayer(sender).getWorld();
-        }
-        
-        int listSize = 10;
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        Map<String, ProtectedRegion> regions = mgr.getRegions();
-
-        int size = regions.size();
-
-        String[] regionIDList = new String[size];
-        int index = 0;
-        boolean show = false;
-        String prefix = "";
-        for (String id : regions.keySet()) {
-            show = false;
-            prefix = "";
-            if (name.isEmpty()) {
-                show = true;
-            }
-            else {
-                if (own) {
-                    if (regions.get(id).isOwner(localPlayer)) {
-                        show = true;
-                        prefix += "+";
-                    }
-                    else if (regions.get(id).isMember(localPlayer)) {
-                        show = true;
-                        prefix += "-";
-                    }
-                }
-                else {
-                    if (regions.get(id).getOwners().getPlayers().contains(name)) {
-                        show = true;
-                        prefix += "+";
-                    }
-                    if (regions.get(id).getMembers().getPlayers().contains(name)) {
-                        show = true;
-                        prefix += "-";
-                    }
-                }
-            }
-            if (show) {
-                regionIDList[index] = prefix + " " + id;
-                index++;
-            }
-        }
-        if (!name.isEmpty())
-            regionIDList = Arrays.copyOf(regionIDList, index);
-        Arrays.sort(regionIDList);
-        size = index;
-        int pages = (int) Math.ceil(size / (float) listSize);
-
-        sender.sendMessage(ChatColor.RED
-                + (name == "" ? "Regions (page " : "Regions for " + name + " (page ")
-                + (page + 1) + " of " + pages + "):");
-
-        if (page < pages) {
-            for (int i = page * listSize; i < page * listSize + listSize; i++) {
-                if (i >= size) {
-                    break;
-                }
-                sender.sendMessage(ChatColor.YELLOW.toString() + (i + 1) +
-                        "." + regionIDList[i]);
-            }
-        }
-    }
-    
-    @Command(aliases = {"flag", "f"},
-            usage = "<id> <flag> [value]",
-            desc = "Set flags",
-            flags = "", min = 2, max = -1)
-    public static void flag(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-        String flagName = args.getString(1);
-        String value = null;
-
-        if (args.argsLength() >= 3) {
-            value = args.getJoinedStrings(2);
-        }
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            if (id.equalsIgnoreCase("__global__")) {
-                region = new GlobalProtectedRegion(id);
-                mgr.addRegion(region);
-            } else {
-                throw new CommandException("Could not find a region by that ID.");
-            }
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.flag.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.flag.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.flag." + id.toLowerCase());
-        } 
-        
-        Flag<?> foundFlag = null;
-        
-        // Now time to find the flag!
-        for (Flag<?> flag : DefaultFlag.getFlags()) {
-            // Try to detect the flag
-            if (flag.getName().replace("-", "").equalsIgnoreCase(flagName.replace("-", ""))) {
-                foundFlag = flag;
-                break;
-            }
-        }
-        
-        if (foundFlag == null) {
-            StringBuilder list = new StringBuilder();
-            
-            // Need to build a list
-            for (Flag<?> flag : DefaultFlag.getFlags()) {
-                if (list.length() > 0) {
-                    list.append(", ");
-                }
-
-                if (region.isOwner(localPlayer)) {
-                    if (!plugin.hasPermission(sender, "worldguard.region.flag.flags."
-                            + flag.getName() + ".owner." + id.toLowerCase())) {
-                        continue;
-                    }
-                } else if (region.isMember(localPlayer)) {
-                    if (!plugin.hasPermission(sender, "worldguard.region.flag.flags."
-                            + flag.getName() + ".member." + id.toLowerCase())) {
-                        continue;
-                    }
-                } else {
-                    if (!plugin.hasPermission(sender, "worldguard.region.flag.flags."
-                                + flag.getName() + "." + id.toLowerCase())) {
-                        continue;
-                    }
-                } 
-                
-                list.append(flag.getName());
-            }
-
-            player.sendMessage(ChatColor.RED + "Unknown flag specified: " + flagName);
-            player.sendMessage(ChatColor.RED + "Available flags: " + list);
-            return;
-        }
-
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.flag.flags."
-                    + foundFlag.getName() + ".owner." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.flag.flags."
-                    + foundFlag.getName() + ".member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.flag.flags."
-                    + foundFlag.getName() + "." + id.toLowerCase());
-        } 
-        
-        if (value != null) {
-            try {
-                setFlag(region, foundFlag, plugin, sender, value);
-            } catch (InvalidFlagFormat e) {
-                throw new CommandException(e.getMessage());
-            }
-
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Region flag '" + foundFlag.getName() + "' set.");
-        } else {
-            // Clear the flag
-            region.setFlag(foundFlag, null);
-
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Region flag '" + foundFlag.getName() + "' cleared.");
-        }
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    public static <V> void setFlag(ProtectedRegion region,
-            Flag<V> flag, WorldGuardPlugin plugin, CommandSender sender, String value)
-                throws InvalidFlagFormat {
-        region.setFlag(flag, flag.parseInput(plugin, sender, value));
-    }
-    
-    @Command(aliases = {"setpriority", "priority", "pri"},
-            usage = "<id> <priority>",
-            desc = "Set the priority of a region",
-            flags = "", min = 2, max = 2)
-    public static void setPriority(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-        int priority = args.getInteger(1);
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("The region cannot be named __global__");
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.setpriority.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.setpriority.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.setpriority." + id.toLowerCase());
-        } 
-
-        region.setPriority(priority);
-
-        sender.sendMessage(ChatColor.YELLOW
-                + "Priority of '" + region.getId() + "' set to "
-                + priority + ".");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"setparent", "parent", "par"},
-            usage = "<id> [parent-id]",
-            desc = "Set the parent of a region",
-            flags = "", min = 1, max = 2)
-    public static void setParent(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-        
-        if (id.equalsIgnoreCase("__global__")) {
-            throw new CommandException("The region cannot be named __global__");
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-        
-        if (args.argsLength() == 1) {
-            try {
-                region.setParent(null);
-            } catch (CircularInheritanceException e) {
-            }
-    
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Parent of '" + region.getId() + "' cleared.");
-        } else {
-            String parentId = args.getString(1);
-            ProtectedRegion parent = mgr.getRegion(parentId);
-    
-            if (region == null) {
-                throw new CommandException("Could not find a target region by that ID.");
-            }
-    
-            if (parent == null) {
-                throw new CommandException("Could not find the parent region by that ID.");
-            }
-            
-            if (region.isOwner(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.setparent.own." + id.toLowerCase());
-            } else if (region.isMember(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.setparent.member." + id.toLowerCase());
-            } else {
-                plugin.checkPermission(sender, "worldguard.region.setparent." + id.toLowerCase());
-            } 
-            
-            if (parent.isOwner(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.setparent.own." + id.toLowerCase());
-            } else if (parent.isMember(localPlayer)) {
-                plugin.checkPermission(sender, "worldguard.region.setparent.member." + id.toLowerCase());
-            } else {
-                plugin.checkPermission(sender, "worldguard.region.setparent." + id.toLowerCase());
-            }
-            
-            try {
-                region.setParent(parent);
-            } catch (CircularInheritanceException e) {
-                throw new CommandException("Circular inheritance detected!");
-            }
-    
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Parent of '" + region.getId() + "' set to '"
-                    + parent.getId() + "'.");
-        }
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"remove", "delete", "del", "rem"},
-            usage = "<id>",
-            desc = "Remove a region",
-            flags = "", min = 1, max = 1)
-    public static void remove(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.remove.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.remove.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.remove." + id.toLowerCase());
-        }
-        
-        mgr.removeRegion(id);
-        
-        sender.sendMessage(ChatColor.YELLOW
-                + "Region '" + id + "' removed.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"load", "reload"},
-            usage = "[world]",
-            desc = "Reload regions from file",
-            flags = "", min = 0, max = 1)
-    public static void load(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        World world = null;
-        
-        if (args.argsLength() > 0) {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-
-        if (world != null) {
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            
-            try {
-                mgr.load();
-                sender.sendMessage(ChatColor.YELLOW
-                        + "Regions for '" + world.getName() + "' load.");
-            } catch (IOException e) {
-                throw new CommandException("Failed to read regions file: "
-                        + e.getMessage());
-            }
-        } else {
-            for (World w : plugin.getServer().getWorlds()) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(w);
-                
-                try {
-                    mgr.load();
-                } catch (IOException e) {
-                    throw new CommandException("Failed to read regions file: "
-                            + e.getMessage());
-                }
-            }
-            
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Region databases loaded.");
-        }
-    }
-    
-    @Command(aliases = {"save", "write"},
-            usage = "[world]",
-            desc = "Re-save regions to file",
-            flags = "", min = 0, max = 1)
-    public static void save(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        World world = null;
-        
-        if (args.argsLength() > 0) {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-
-        if (world != null) {
-            RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-            
-            try {
-                mgr.save();
-                sender.sendMessage(ChatColor.YELLOW
-                        + "Regions for '" + world.getName() + "' saved.");
-            } catch (IOException e) {
-                throw new CommandException("Failed to write regions file: "
-                        + e.getMessage());
-            }
-        } else {
-            for (World w : plugin.getServer().getWorlds()) {
-                RegionManager mgr = plugin.getGlobalRegionManager().get(w);
-                
-                try {
-                    mgr.save();
-                } catch (IOException e) {
-                    throw new CommandException("Failed to write regions file: "
-                            + e.getMessage());
-                }
-            }
-            
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Region databases saved.");
-        }
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/RegionMemberCommands.java

@@ -1,203 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import java.io.IOException;
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.util.RegionUtil;
-
-// @TODO: A lot of code duplication here! Need to fix.
-
-public class RegionMemberCommands {
-    
-    @Command(aliases = {"addmember", "addmember"},
-            usage = "<id> <members...>",
-            desc = "Add a member to a region",
-            flags = "", min = 2, max = -1)
-    public static void addMember(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.addmember.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.addmember.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.addmember." + id.toLowerCase());
-        }
-
-        RegionUtil.addToDomain(region.getMembers(), args.getPaddedSlice(2, 0), 0);
-
-        sender.sendMessage(ChatColor.YELLOW
-                + "Region '" + id + "' updated.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"addowner", "addowner"},
-            usage = "<id> <owners...>",
-            desc = "Add an owner to a region",
-            flags = "", min = 2, max = -1)
-    public static void addOwner(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.addowner.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.addowner.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.addowner." + id.toLowerCase());
-        }
-
-        RegionUtil.addToDomain(region.getOwners(), args.getPaddedSlice(2, 0), 0);
-
-        sender.sendMessage(ChatColor.YELLOW
-                + "Region '" + id + "' updated.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"removemember", "remmember", "removemem", "remmem"},
-            usage = "<id> <owners...>",
-            desc = "Remove an owner to a region",
-            flags = "", min = 2, max = -1)
-    public static void removeMember(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.removemember.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.removemember.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.removemember." + id.toLowerCase());
-        }
-
-        RegionUtil.removeFromDomain(region.getMembers(), args.getPaddedSlice(2, 0), 0);
-
-        sender.sendMessage(ChatColor.YELLOW
-                + "Region '" + id + "' updated.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-    
-    @Command(aliases = {"removeowner", "remowner"},
-            usage = "<id> <owners...>",
-            desc = "Remove an owner to a region",
-            flags = "", min = 2, max = -1)
-    public static void removeOwner(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        Player player = plugin.checkPlayer(sender);
-        World world = player.getWorld();
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-        
-        String id = args.getString(0);
-
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        ProtectedRegion region = mgr.getRegion(id);
-
-        if (region == null) {
-            throw new CommandException("Could not find a region by that ID.");
-        }
-        
-        if (region.isOwner(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.removeowner.own." + id.toLowerCase());
-        } else if (region.isMember(localPlayer)) {
-            plugin.checkPermission(sender, "worldguard.region.removeowner.member." + id.toLowerCase());
-        } else {
-            plugin.checkPermission(sender, "worldguard.region.removeowner." + id.toLowerCase());
-        }
-
-        RegionUtil.removeFromDomain(region.getOwners(), args.getPaddedSlice(2, 0), 0);
-
-        sender.sendMessage(ChatColor.YELLOW
-                + "Region '" + id + "' updated.");
-        
-        try {
-            mgr.save();
-        } catch (IOException e) {
-            throw new CommandException("Failed to write regions file: "
-                    + e.getMessage());
-        }
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/ToggleCommands.java

@@ -1,143 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import org.bukkit.ChatColor;
-import org.bukkit.World;
-import org.bukkit.command.CommandSender;
-import com.sk89q.minecraft.util.commands.*;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.entity.*;
-
-public class ToggleCommands {
-
-    @Command(aliases = {"stopfire"},
-            usage = "[<world>]", desc = "Disables all fire spread temporarily",
-            flags = "", min = 0, max = 1)
-    @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public static void stopFire(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        World world;
-        
-        if (args.argsLength() == 0) {
-            world = plugin.checkPlayer(sender).getWorld();
-        } else {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-        
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(world);
-
-        if (!wcfg.fireSpreadDisableToggle) {
-            plugin.getServer().broadcastMessage(
-                    ChatColor.YELLOW
-                    + "Fire spread has been globally disabled for '" + world.getName() + "' by "
-                    + plugin.toName(sender) + ".");
-        } else {
-            sender.sendMessage(
-                    ChatColor.YELLOW
-                    + "Fire spread was already globally disabled.");
-        }
-
-        wcfg.fireSpreadDisableToggle = true;
-    }
-
-    @Command(aliases = {"allowfire"},
-            usage = "[<world>]", desc = "Allows all fire spread temporarily",
-            flags = "", min = 0, max = 1)
-    @CommandPermissions({"worldguard.fire-toggle.stop"})
-    public static void allowFire(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        World world;
-        
-        if (args.argsLength() == 0) {
-            world = plugin.checkPlayer(sender).getWorld();
-        } else {
-            world = plugin.matchWorld(sender, args.getString(0));
-        }
-        
-        WorldConfiguration wcfg = plugin.getGlobalStateManager().get(world);
-
-        if (wcfg.fireSpreadDisableToggle) {
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "Fire spread has been globally for '" + world.getName() + "' re-enabled by "
-                    + plugin.toName(sender) + ".");
-        } else {
-            sender.sendMessage(ChatColor.YELLOW
-                    + "Fire spread was already globally enabled.");
-        }
-
-        wcfg.fireSpreadDisableToggle = false;
-    }
-
-    @Command(aliases = {"halt-activity"},
-            usage = "", desc = "Attempts to cease as much activity in order to stop lag",
-            flags = "c", min = 0, max = 0)
-    @CommandPermissions({"worldguard.halt-activity"})
-    public static void stopLag(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-
-        ConfigurationManager configManager = plugin.getGlobalStateManager();
-
-        configManager.activityHaltToggle = !args.hasFlag('c');
-
-        if (configManager.activityHaltToggle) {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.YELLOW
-                        + "ALL intensive server activity halted.");
-            }
-
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "ALL intensive server activity halted by "
-                    + plugin.toName(sender) + ".");
-
-            for (World world : plugin.getServer().getWorlds()) {
-                int removed = 0;
-
-                for (Entity entity : world.getEntities()) {
-                    if (entity instanceof Item
-                            || (entity instanceof LivingEntity
-                            && !(entity instanceof Tameable)
-                            && !(entity instanceof Player))) {
-                        entity.remove();
-                        removed++;
-                    }
-                }
-
-                if (removed > 10) {
-                    sender.sendMessage("" + removed + " entities (>10) auto-removed from "
-                            + world.toString());
-                }
-            }
-
-        } else {
-            if (!(sender instanceof Player)) {
-                sender.sendMessage(ChatColor.YELLOW
-                        + "ALL intensive server activity no longer halted.");
-            }
-
-            plugin.getServer().broadcastMessage(ChatColor.YELLOW
-                    + "ALL intensive server activity is now allowed.");
-        }
-    }
-}

src/main/java/com/sk89q/worldguard/bukkit/commands/WorldGuardCommands.java

@@ -1,125 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.bukkit.commands;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.logging.Level;
-import java.util.logging.Logger;
-import org.bukkit.ChatColor;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import com.sk89q.minecraft.util.commands.Command;
-import com.sk89q.minecraft.util.commands.CommandContext;
-import com.sk89q.minecraft.util.commands.CommandException;
-import com.sk89q.minecraft.util.commands.CommandPermissions;
-import com.sk89q.worldguard.bukkit.LoggerToChatHandler;
-import com.sk89q.worldguard.bukkit.ReportWriter;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.util.PastebinPoster;
-import com.sk89q.worldguard.util.PastebinPoster.PasteCallback;
-
-public class WorldGuardCommands {
-
-    @Command(aliases = {"version"},
-            usage = "",
-            desc = "Get the WorldGuard version",
-            flags = "", min = 0, max = 0)
-    public static void version(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        sender.sendMessage(ChatColor.YELLOW
-                + "WorldGuard " + plugin.getDescription().getVersion());
-        sender.sendMessage(ChatColor.YELLOW
-                + "http://www.sk89q.com");
-    }
-
-    @Command(aliases = {"reload"},
-            usage = "",
-            desc = "Reload WorldGuard configuration",
-            flags = "", min = 0, max = 0)
-    @CommandPermissions({"worldguard.reload"})
-    public static void relload(CommandContext args, WorldGuardPlugin plugin,
-            CommandSender sender) throws CommandException {
-        
-        LoggerToChatHandler handler = null;
-        Logger minecraftLogger = null;
-        
-        if (sender instanceof Player) {
-            handler = new LoggerToChatHandler(sender);
-            handler.setLevel(Level.ALL);
-            minecraftLogger = Logger.getLogger("Minecraft");
-            minecraftLogger.addHandler(handler);
-        }
-
-        try {
-            plugin.getGlobalStateManager().unload();
-            plugin.getGlobalRegionManager().unload();
-            plugin.getGlobalStateManager().load();
-            plugin.getGlobalRegionManager().preload();
-            sender.sendMessage("WorldGuard configuration reloaded.");
-        } catch (Throwable t) {
-            sender.sendMessage("Error while reloading: "
-                    + t.getMessage());
-        } finally {
-            if (minecraftLogger != null) {
-                minecraftLogger.removeHandler(handler);
-            }
-        }
-    }
-    
-    @Command(aliases = {"report"},
-            usage = "",
-            desc = "Writes a report on WorldGuard",
-            flags = "p", min = 0, max = 0)
-    @CommandPermissions({"worldguard.report"})
-    public static void report(CommandContext args, WorldGuardPlugin plugin,
-            final CommandSender sender) throws CommandException {
-        
-        File dest = new File(plugin.getDataFolder(), "report.txt");
-        ReportWriter report = new ReportWriter(plugin);
-        
-        try {
-            report.write(dest);
-            sender.sendMessage(ChatColor.YELLOW + "WorldGuard report written to "
-                    + dest.getAbsolutePath());
-        } catch (IOException e) {
-            throw new CommandException("Failed to write report: " + e.getMessage());
-        }
-        
-        if (args.hasFlag('p')) {
-            plugin.checkPermission(sender, "worldguard.report.pastebin");
-            
-            sender.sendMessage(ChatColor.YELLOW + "Now uploading to Pastebin...");
-            PastebinPoster.paste(report.toString(), new PasteCallback() {
-                
-                public void handleSuccess(String url) {
-                    // Hope we don't have a thread safety issue here
-                    sender.sendMessage(ChatColor.YELLOW + "WorldGuard report (1 hour): " + url);
-                }
-                
-                public void handleError(String err) {
-                    // Hope we don't have a thread safety issue here
-                    sender.sendMessage(ChatColor.YELLOW + "WorldGuard report pastebin error: " + err);
-                }
-            });
-        }
-
-    }
-}

src/main/java/com/sk89q/worldguard/chest/ChestProtection.java

@@ -1,67 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.chest;
-
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-
-/**
- * Interface for chest protection.
- */
-public interface ChestProtection {
-
-    /**
-     * Returns whether a block is protected.
-     * 
-     * @param block
-     * @param player
-     * @return
-     */
-    public boolean isProtected(Block block, Player player);
-
-    /**
-     * Returns whether a location where a chest block is trying to be created 
-     * is protected. 
-     * 
-     * @param block
-     * @param player
-     * @return
-     */
-    public boolean isProtectedPlacement(Block block, Player player);
-
-    /**
-     * Returns whether an adjacent chest is protected.
-     * 
-     * @param searchBlock
-     * @param player
-     * @return
-     */
-    public boolean isAdjacentChestProtected(Block searchBlock, Player player);
-
-    /**
-     * Returns whether a material is a chest.
-     * 
-     * @param material
-     * @return
-     */
-    public boolean isChest(Material material);
-
-}

src/main/java/com/sk89q/worldguard/chest/SignChestProtection.java

@@ -1,156 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.chest;
-
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.Sign;
-import org.bukkit.entity.Player;
-
-/**
- * Sign-based chest protection.
- * 
- * @author sk89q
- */
-public class SignChestProtection implements ChestProtection {
-    
-    public boolean isProtected(Block block, Player player) {
-        if (isChest(block.getType())) {
-            Block below = block.getRelative(0, -1, 0);
-            return isProtectedSignAround(below, player);
-        } else if (block.getType() == Material.SIGN_POST) {
-            return isProtectedSignAndChestBinary(block, player);
-        } else {
-            Block above = block.getRelative(0, 1, 0);
-            Boolean res = isProtectedSign(above, player);
-            if (res != null) return res;
-            return false;
-        }
-    }
-    
-    public boolean isProtectedPlacement(Block block, Player player) {
-        return isProtectedSignAround(block, player);
-    }
-    
-    private boolean isProtectedSignAround(Block searchBlock, Player player) {
-        Block side;
-        Boolean res;
-        
-        side = searchBlock;
-        res = isProtectedSign(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(-1, 0, 0);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(1, 0, 0);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(0, 0, -1);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(0, 0, 1);
-        res = isProtectedSignAndChest(side, player);
-        if (res != null && res == true) return res;
-        
-        return false;
-    }
-    
-    private Boolean isProtectedSign(Sign sign, Player player) {
-        if (sign.getLine(0).equalsIgnoreCase("[Lock]")) {
-            if (player == null) { // No player, no access
-                return true;
-            }
-            
-            String name = player.getName();
-            if (name.equalsIgnoreCase(sign.getLine(1).trim())
-                    || name.equalsIgnoreCase(sign.getLine(2).trim())
-                    || name.equalsIgnoreCase(sign.getLine(3).trim())) {
-                return false;
-            }
-            
-            // No access!
-            return true;
-        }
-        
-        return null;
-    }
-    
-    private Boolean isProtectedSign(Block block, Player player) {
-        BlockState state = block.getState();
-        if (state == null || !(state instanceof Sign)) {
-            return null;
-        }
-        return isProtectedSign((Sign) state, player);
-    }
-    
-    private Boolean isProtectedSignAndChest(Block block, Player player) {
-        if (!isChest(block.getRelative(0, 1, 0).getType())) {
-            return null;
-        }
-        return isProtectedSign(block, player);
-    }
-    
-    private boolean isProtectedSignAndChestBinary(Block block, Player player) {
-        Boolean res = isProtectedSignAndChest(block, player);
-        if (res == null || res == false) {
-            return false;
-        }
-        return true;
-    }
-
-    public boolean isAdjacentChestProtected(Block searchBlock, Player player) {
-        Block side;
-        Boolean res;
-        
-        side = searchBlock;
-        res = isProtected(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(-1, 0, 0);
-        res = isProtected(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(1, 0, 0);
-        res = isProtected(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(0, 0, -1);
-        res = isProtected(side, player);
-        if (res != null && res == true) return res;
-        
-        side = searchBlock.getRelative(0, 0, 1);
-        res = isProtected(side, player);
-        if (res != null && res == true) return res;
-        
-        return false;
-    }
-    
-    public boolean isChest(Material material) {
-        return material == Material.CHEST
-                || material == Material.DISPENSER
-                || material == Material.FURNACE
-                || material == Material.BURNING_FURNACE;
-    }
-}

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

@@ -1,385 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection;
-
-import com.sk89q.worldguard.protection.flags.*;
-import com.sk89q.worldguard.protection.flags.StateFlag.State;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import com.sk89q.worldguard.LocalPlayer;
-
-/**
- * Represents a set of regions for a particular point or area and the rules
- * that are represented by that set. An instance of this can be used to
- * query the value of a flag or check if a player can build in the respective
- * region or point. This object contains the list of applicable regions and so
- * the expensive search of regions that are in the desired area has already
- * been completed.
- * 
- * @author sk89q
- */
-public class ApplicableRegionSet implements Iterable<ProtectedRegion> {
-
-    private Collection<ProtectedRegion> applicable;
-    private ProtectedRegion globalRegion;
-
-    /**
-     * Construct the object.
-     * 
-     * @param applicable
-     * @param globalRegion 
-     */
-    public ApplicableRegionSet(Collection<ProtectedRegion> applicable,
-            ProtectedRegion globalRegion) {
-        this.applicable = applicable;
-        this.globalRegion = globalRegion;
-    }
-    
-    /**
-     * Checks if a player can build in an area.
-     * 
-     * @param player
-     * @return build ability
-     */
-    public boolean canBuild(LocalPlayer player) {
-        return internalGetState(DefaultFlag.BUILD, player, null, null);
-    }
-    
-    /**
-     * Checks if a player can use buttons and such in an area.
-     * 
-     * @param player
-     * @return able to use items
-     */
-    public boolean canUse(LocalPlayer player) {
-        return !allows(DefaultFlag.USE, player)
-                && !canBuild(player);
-    }
-
-    /**
-     * Gets the state of a state flag. This cannot be used for the build flag.
-     *
-     * @param flag flag to check
-     * @return whether it is allowed
-     * @throws IllegalArgumentException if the build flag is given
-     */
-    public boolean allows(StateFlag flag) {
-        if (flag == DefaultFlag.BUILD) {
-            throw new IllegalArgumentException("Can't use build flag with allows()");
-        }
-        return internalGetState(flag, null, null, null);
-    }
-    
-    /**
-     * Gets the state of a state flag. This cannot be used for the build flag.
-     * 
-     * @param flag flag to check
-     * @param player player (used by some flags)
-     * @return whether the state is allows for it
-     * @throws IllegalArgumentException if the build flag is given
-     */
-    public boolean allows(StateFlag flag, LocalPlayer player) {
-        if (flag == DefaultFlag.BUILD) {
-            throw new IllegalArgumentException("Can't use build flag with allows()");
-        }
-        return internalGetState(flag, null, flag.getGroupFlag(), player);
-    }
-    
-    /**
-     * Indicates whether a player is an owner of all regions in this set.
-     * 
-     * @param player player
-     * @return whether the player is an owner of all regions
-     */
-    public boolean isOwnerOfAll(LocalPlayer player) {
-        for (ProtectedRegion region : applicable) {
-            if (!region.isOwner(player)) {
-                return false;
-            }
-        }
-        
-        return true;
-    }
-    
-    /**
-     * Indicates whether a player is an owner or member of all regions in
-     * this set.
-     * 
-     * @param player player
-     * @return whether the player is a member of all regions
-     */
-    public boolean isMemberOfAll(LocalPlayer player) {
-        for (ProtectedRegion region : applicable) {
-            if (!region.isMember(player)) {
-                return false;
-            }
-        }
-        
-        return true;
-    }
-
-    /**
-     * Checks to see if a flag is permitted.
-     * 
-     * @param flag flag to check
-     * @param player null to not check owners and members
-     * @param groupFlag group flag to check
-     * @param groupPlayer player to use for the group flag check
-     * @return
-     */
-    private boolean internalGetState(StateFlag flag, LocalPlayer player,
-                                     RegionGroupFlag groupFlag,
-                                     LocalPlayer groupPlayer) {
-        boolean found = false;
-        boolean hasFlagDefined = false;
-        boolean allowed = false; // Used for ALLOW override
-        boolean def = flag.getDefault();
-        
-        // Handle defaults
-        if (globalRegion != null) {
-            State globalState = globalRegion.getFlag(flag);
-
-            // The global region has this flag set
-            if (globalState != null) {
-                // Build flag is very special
-                if (player != null && globalRegion.hasMembersOrOwners()) {
-                    def = globalRegion.isMember(player) && (globalState == State.ALLOW);
-                } else {
-                    def = (globalState == State.ALLOW);
-                }
-            } else {
-                // Build flag is very special
-                if (player != null && globalRegion.hasMembersOrOwners()) {
-                    def = globalRegion.isMember(player);
-                }
-            }
-        }
-        
-        // The player argument is used if and only if the flag is the build
-        // flag -- in which case, if there are any regions in this area, we
-        // default to FALSE, otherwise true if there are no defined regions.
-        // However, other flags are different -- if there are regions defined,
-        // we default to the global region value. 
-        if (player == null) {
-            allowed = def; 
-        }
-        
-        int lastPriority = Integer.MIN_VALUE;
-
-        // The algorithm is as follows:
-        // While iterating through the list of regions, if an entry disallows
-        // the flag, then put it into the needsClear set. If an entry allows
-        // the flag and it has a parent, then its parent is put into hasCleared.
-        // In the situation that the child is reached before the parent, upon
-        // the parent being reached, even if the parent disallows, because the
-        // parent will be in hasCleared, permission will be allowed. In the
-        // other case, where the parent is reached first, if it does not allow
-        // permissions, it will be placed into needsClear. If a child of
-        // the parent is reached later, the parent will be removed from
-        // needsClear. At the end, if needsClear is not empty, that means that
-        // permission should not be given. If a parent has multiple children
-        // and one child does not allow permissions, then it will be placed into
-        // needsClear just like as if was a parent.
-
-        Set<ProtectedRegion> needsClear = new HashSet<ProtectedRegion>();
-        Set<ProtectedRegion> hasCleared = new HashSet<ProtectedRegion>();
-
-        Iterator<ProtectedRegion> it = applicable.iterator();
-        
-        while (it.hasNext()) {
-            ProtectedRegion region = it.next();
-
-            // Ignore lower priority regions
-            if (hasFlagDefined && region.getPriority() < lastPriority) {
-                break;
-            }
-            
-            lastPriority = region.getPriority();
-
-            // Ignore non-build regions
-            if (player != null
-                    && region.getFlag(DefaultFlag.PASSTHROUGH) == State.ALLOW) {
-                continue;
-            }
-
-            // Check group permissions
-            if (groupPlayer != null && groupFlag != null) {
-                RegionGroupFlag.RegionGroup group = region.getFlag(groupFlag);
-                if (group == null) {
-                    group = groupFlag.getDefault();
-                }
-                if (!RegionGroupFlag.isMember(region, group, groupPlayer)) {
-                    continue;
-                }
-            }
-            
-            State v = region.getFlag(flag);
-
-            // Allow DENY to override everything
-            if (v == State.DENY) {
-                return false;
-            }
-
-            // Forget about regions that allow it, although make sure the
-            // default state is now to allow
-            if (v == State.ALLOW) {
-                allowed = true;
-                found = true;
-                hasFlagDefined = true;
-                continue;
-            }
-
-            // For the build flag, the flags are conditional and are based
-            // on membership, so we have to check for parent-child
-            // relationships
-            if (player != null) {
-                hasFlagDefined = true;
-
-                if (hasCleared.contains(region)) {
-                    // Already cleared, so do nothing
-                } else {
-                    if (!region.isMember(player)) {
-                        needsClear.add(region);
-                    } else {
-                        // Need to clear all parents
-                        clearParents(needsClear, hasCleared, region);
-                    }
-                }
-            }
-
-            found = true;
-        }
-
-        return found == false ? def :
-                (allowed || (player != null && needsClear.size() == 0));
-    }
-
-    /**
-     * Clear a region's parents for isFlagAllowed().
-     * 
-     * @param needsClear
-     * @param hasCleared
-     * @param region
-     */
-    private void clearParents(Set<ProtectedRegion> needsClear,
-            Set<ProtectedRegion> hasCleared, ProtectedRegion region) {
-        ProtectedRegion parent = region.getParent();
-
-        while (parent != null) {
-            if (!needsClear.remove(parent)) {
-                hasCleared.add(parent);
-            }
-
-            parent = parent.getParent();
-        }
-    }
-
-    /**
-     * Gets the value of a flag. Do not use this for state flags
-     * (use {@link #allows(StateFlag, LocalPlayer)} for that).
-     * 
-     * @param flag flag to check
-     * @return value of the flag
-     * @throws IllegalArgumentException if a StateFlag is given
-     */
-    public <T extends Flag<V>, V> V getFlag(T flag) {
-        if (flag instanceof StateFlag) {
-            throw new IllegalArgumentException("Cannot use StateFlag with getFlag()");
-        }
-
-        int lastPriority = 0;
-        boolean found = false;
-
-        Map<ProtectedRegion, V> needsClear = new HashMap<ProtectedRegion, V>();
-        Set<ProtectedRegion> hasCleared = new HashSet<ProtectedRegion>();
-
-        Iterator<ProtectedRegion> it = applicable.iterator();
-
-        while (it.hasNext()) {
-            ProtectedRegion region = it.next();
-
-            // Ignore lower priority regions
-            if (found && region.getPriority() < lastPriority) {
-                break;
-            }
-
-            if (hasCleared.contains(region)) {
-                // Already cleared, so do nothing
-            } else if (region.getFlag(flag) != null){
-                clearParents(needsClear, hasCleared, region);
-                
-                needsClear.put(region, region.getFlag(flag));
-                
-                found = true;
-            }
-
-            lastPriority = region.getPriority();
-        }
-        
-        try {
-            return needsClear.values().iterator().next();
-        } catch (NoSuchElementException e) {
-            return null;
-        }
-    }
-
-    /**
-     * Clear a region's parents for getFlag().
-     * 
-     * @param needsClear
-     * @param hasCleared
-     * @param region
-     */
-    private void clearParents(Map<ProtectedRegion, ?> needsClear,
-            Set<ProtectedRegion> hasCleared, ProtectedRegion region) {
-        ProtectedRegion parent = region.getParent();
-
-        while (parent != null) {
-            if (needsClear.remove(parent) == null) {
-                hasCleared.add(parent);
-            }
-
-            parent = parent.getParent();
-        }
-    }
-    
-    /**
-     * Get the number of regions that are included.
-     * 
-     * @return
-     */
-    public int size() {
-        return applicable.size();
-    }
-    
-    /**
-     * Get an iterator of affected regions.
-     * 
-     * @return
-     */
-    public Iterator<ProtectedRegion> iterator() {
-        return applicable.iterator();
-    }
-}

src/main/java/com/sk89q/worldguard/protection/GlobalRegionManager.java

@@ -1,294 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection;
-
-import static com.sk89q.worldguard.bukkit.BukkitUtil.toVector;
-import com.sk89q.worldguard.LocalPlayer;
-import com.sk89q.worldguard.bukkit.BukkitUtil;
-import com.sk89q.worldguard.bukkit.ConfigurationManager;
-import com.sk89q.worldguard.bukkit.WorldConfiguration;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import com.sk89q.worldguard.protection.databases.YAMLDatabase;
-import com.sk89q.worldguard.protection.flags.StateFlag;
-import com.sk89q.worldguard.protection.managers.FlatRegionManager;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.logging.Logger;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-
-/**
- * This class keeps track of region information for every world. It loads
- * world region information as needed.
- * 
- * @author sk89q
- * @author Redecouverte
- */
-public class GlobalRegionManager {
-
-    private static final Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    /**
-     * Reference to the plugin.
-     */
-    private WorldGuardPlugin plugin;
-    
-    /**
-     * Reference to the global configuration.
-     */
-    private ConfigurationManager config;
-    
-    /**
-     * Map of managers per-world.
-     */
-    private HashMap<String, RegionManager> managers;
-    
-    /**
-     * Stores the list of modification dates for the world files. This allows
-     * WorldGuard to reload files as needed.
-     */
-    private HashMap<String, Long> lastModified;
-
-    /**
-     * Construct the object.
-     * 
-     * @param plugin 
-     */
-    public GlobalRegionManager(WorldGuardPlugin plugin) {
-        this.plugin = plugin;
-        config = plugin.getGlobalStateManager();
-        managers = new HashMap<String, RegionManager>();
-        lastModified = new HashMap<String, Long>();
-    }
-
-    /**
-     * Unload region information.
-     */
-    public void unload() {
-        managers.clear();
-        lastModified.clear();
-    }
-    
-    /**
-     * Get the path for a world's regions file.
-     * 
-     * @param name
-     * @return
-     */
-    protected File getPath(String name) {
-        return new File(plugin.getDataFolder(),
-                "worlds" + File.separator + name + File.separator + "regions.yml");
-    }
-
-    /**
-     * Unload region information for a world.
-     * 
-     * @param name
-     */
-    public void unload(String name) {
-        RegionManager manager = managers.get(name);
-
-        if (manager != null) {
-            managers.remove(name);
-            lastModified.remove(name);
-        }
-    }
-
-    /**
-     * Unload all region information.
-     */
-    public void unloadAll() {
-        managers.clear();
-        lastModified.clear();
-    }
-
-    /**
-     * Load region information for a world.
-     * 
-     * @param world
-     * @return 
-     */
-    public RegionManager load(World world) {
-        String name = world.getName();
-        File file = getPath(name);
-        
-        try {
-            // Create a manager
-            RegionManager manager = new FlatRegionManager(new YAMLDatabase(file));
-            managers.put(name, manager);
-            manager.load();
-
-            logger.info("WorldGuard: " + manager.getRegions().size()
-                    + " regions loaded for '" + name + "'");
-
-            // Store the last modification date so we can track changes
-            lastModified.put(name, file.lastModified());
-            
-            return manager;
-        } catch (FileNotFoundException e) {
-        } catch (IOException e) {
-            logger.warning("WorldGuard: Failed to load regions from file "
-                    + file.getAbsolutePath() + " : " + e.getMessage());
-        }
-        
-        // @TODO: THIS CREATES PROBLEMS!!
-        return null;
-    }
-    
-    /**
-     * Preloads region managers for all worlds.
-     */
-    public void preload() {
-        // Load regions
-        for (World world : plugin.getServer().getWorlds()) {
-            load(world);
-        }
-    }
-
-    /**
-     * Reloads the region information from file when region databases
-     * have changed.
-     */
-    public void reloadChanged() {
-        for (String name : managers.keySet()) {
-            File file = getPath(name);
-
-            Long oldDate = lastModified.get(name);
-            
-            if (oldDate == null) {
-                oldDate = 0L;
-            }
-
-            try {
-                if (file.lastModified() > oldDate) {
-                    World world = plugin.getServer().getWorld(name);
-                    
-                    if (world != null) {
-                        load(world);
-                    }
-                }
-            } catch (Exception e) {
-            }
-        }
-    }
-
-    /**
-     * Get the region manager for a particular world.
-     * 
-     * @param world
-     * @return
-     */
-    public RegionManager get(World world) {
-        RegionManager manager = managers.get(world.getName());
-
-        if (manager == null) {
-            manager = load(world);
-        }
-
-        return manager;
-    }
-
-    /**
-     * Returns whether the player can bypass.
-     *
-     * @param player
-     * @param world
-     * @return
-     */
-    public boolean hasBypass(LocalPlayer player, World world) {
-        return player.hasPermission("worldguard.region.bypass."
-                        + world.getName());
-    }
-    
-    /**
-     * Returns whether the player can bypass.
-     * 
-     * @param player
-     * @param world
-     * @return
-     */
-    public boolean hasBypass(Player player, World world) {
-        return plugin.hasPermission(player, "worldguard.region.bypass."
-                        + world.getName());
-    }
-    
-    /**
-     * Check if a player has permission to build at a block.
-     * 
-     * @param player
-     * @param block 
-     * @return
-     */
-    public boolean canBuild(Player player, Block block) {
-        return canBuild(player, block.getLocation());
-    }
-    
-    /**
-     * Check if a player has permission to build at a location.
-     * 
-     * @param player
-     * @param loc 
-     * @return
-     */
-    public boolean canBuild(Player player, Location loc) {
-        World world = loc.getWorld();
-        WorldConfiguration worldConfig = config.get(world);
-        
-        if (!worldConfig.useRegions) {
-            return true;
-        }
-    
-        LocalPlayer localPlayer = plugin.wrapPlayer(player);
-
-        if (!hasBypass(player, world)) {
-            RegionManager mgr = get(world);
-
-            if (!mgr.getApplicableRegions(BukkitUtil.toVector(loc))
-                    .canBuild(localPlayer)) {
-                return false;
-            }
-        }
-
-        return true;
-    }
-    
-    /**
-     * Checks to see whether a flag is allowed.
-     * 
-     * @param flag
-     * @param loc
-     * @return
-     */
-    public boolean allows(StateFlag flag, Location loc) {
-        World world = loc.getWorld();
-        WorldConfiguration worldConfig = config.get(world);
-        
-        if (!worldConfig.useRegions) {
-            return true;
-        }
-        
-        RegionManager mgr = plugin.getGlobalRegionManager().get(world);
-        return mgr.getApplicableRegions(toVector(loc)).allows(flag);
-    }
-}

src/main/java/com/sk89q/worldguard/protection/databases/AbstractProtectionDatabase.java

@@ -1,47 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection.databases;
-
-import java.io.IOException;
-import com.sk89q.worldguard.protection.managers.RegionManager;
-
-public abstract class AbstractProtectionDatabase implements ProtectionDatabase {
-
-    /**
-     * Load the list of regions into a region manager.
-     * 
-     * @throws IOException
-     */
-    public void load(RegionManager manager) throws IOException {
-        load();
-        manager.setRegions(getRegions());
-    }
-    
-    /**
-     * Save the list of regions from a region manager.
-     * 
-     * @throws IOException
-     */
-    public void save(RegionManager manager) throws IOException {
-        setRegions(manager.getRegions());
-        save();
-    }
-    
-}

src/main/java/com/sk89q/worldguard/protection/databases/RegionDBUtil.java

@@ -1,100 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection.databases;
-
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-import com.sk89q.worldguard.domains.DefaultDomain;
-
-/**
- * Various utility functions for parsing region databases.
- * 
- * @author sk89q
- */
-public class RegionDBUtil {
-    private static Pattern groupPattern = Pattern.compile("^[gG]:(.+)$");
-    
-    private RegionDBUtil() {
-        
-    }
-
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param domain
-     * @param split
-     * @param startIndex
-     */
-    public static void addToDomain(DefaultDomain domain, String[] split,
-            int startIndex) {
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.addGroup(m.group(1));
-            } else {
-                domain.addPlayer(s);
-            }
-        }
-    }
-
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param domain
-     * @param split
-     * @param startIndex
-     */
-    public static void removeFromDomain(DefaultDomain domain, String[] split,
-            int startIndex) {
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.removeGroup(m.group(1));
-            } else {
-                domain.removePlayer(s);
-            }
-        }
-    }
-
-    /**
-     * Parse a group/player DefaultDomain specification for areas.
-     * 
-     * @param split
-     * @param startIndex
-     * @return
-     */
-    public static DefaultDomain parseDomainString(String[] split, int startIndex) {
-        DefaultDomain domain = new DefaultDomain();
-
-        for (int i = startIndex; i < split.length; i++) {
-            String s = split[i];
-            Matcher m = groupPattern.matcher(s);
-            if (m.matches()) {
-                domain.addGroup(m.group(1));
-            } else {
-                domain.addPlayer(s);
-            }
-        }
-
-        return domain;
-    }
-}

src/main/java/com/sk89q/worldguard/protection/databases/YAMLDatabase.java

@@ -1,294 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
-*/
-
-package com.sk89q.worldguard.protection.databases;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.logging.Logger;
-import com.sk89q.worldedit.BlockVector;
-import com.sk89q.worldedit.BlockVector2D;
-import com.sk89q.worldedit.Vector;
-import com.sk89q.worldguard.domains.DefaultDomain;
-import com.sk89q.worldguard.protection.flags.DefaultFlag;
-import com.sk89q.worldguard.protection.flags.Flag;
-import com.sk89q.worldguard.protection.regions.GlobalProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedPolygonalRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion;
-import com.sk89q.worldguard.protection.regions.ProtectedRegion.CircularInheritanceException;
-import com.sk89q.worldguard.util.yaml.Configuration;
-import com.sk89q.worldguard.util.yaml.ConfigurationNode;
-
-public class YAMLDatabase extends AbstractProtectionDatabase {
-    
-    private static Logger logger = Logger.getLogger("Minecraft.WorldGuard");
-    
-    private Configuration config;
-    private Map<String, ProtectedRegion> regions;
-    
-    public YAMLDatabase(File file) {
-        config = new Configuration(file);
-    }
-
-    public void load() throws IOException {
-        config.load();
-        
-        Map<String, ConfigurationNode> regionData = config.getNodes("regions");
-        
-        // No regions are even configured
-        if (regionData == null) {
-            this.regions = new HashMap<String, ProtectedRegion>();
-            return;
-        }
-
-        Map<String,ProtectedRegion> regions =
-            new HashMap<String,ProtectedRegion>();
-        Map<ProtectedRegion,String> parentSets =
-            new LinkedHashMap<ProtectedRegion, String>();
-        
-        for (Map.Entry<String, ConfigurationNode> entry : regionData.entrySet()) {
-            String id = entry.getKey().toLowerCase().replace(".", "");
-            ConfigurationNode node = entry.getValue();
-            
-            String type = node.getString("type");
-            ProtectedRegion region;
-            
-            try {
-                if (type == null) {
-                    logger.warning("Undefined region type for region '" + id + '"');
-                    continue;
-                } else if (type.equals("cuboid")) {
-                    Vector pt1 = checkNonNull(node.getVector("min"));
-                    Vector pt2 = checkNonNull(node.getVector("max"));
-                    BlockVector min = Vector.getMinimum(pt1, pt2).toBlockVector();
-                    BlockVector max = Vector.getMaximum(pt1, pt2).toBlockVector();
-                    region = new ProtectedCuboidRegion(id, min, max);
-                } else if (type.equals("poly2d")) {
-                    Integer minY = checkNonNull(node.getInt("min-y"));
-                    Integer maxY = checkNonNull(node.getInt("max-y"));
-                    List<BlockVector2D> points = node.getBlockVector2dList("points", null);
-                    region = new ProtectedPolygonalRegion(id, points, minY, maxY);
-                } else if (type.equals("global")) {
-                    region = new GlobalProtectedRegion(id);
-                } else {
-                    logger.warning("Unknown region type for region '" + id + '"');
-                    continue;
-                }
-                
-                Integer priority = checkNonNull(node.getInt("priority"));
-                region.setPriority(priority);
-                setFlags(region, node.getNode("flags"));
-                region.setOwners(parseDomain(node.getNode("owners")));
-                region.setMembers(parseDomain(node.getNode("members")));
-                regions.put(id, region);
-                
-                String parentId = node.getString("parent");
-                if (parentId != null) {
-                    parentSets.put(region, parentId);
-                }
-            } catch (NullPointerException e) {
-                logger.warning("Missing data for region '" + id + '"');
-            }
-        }
-        
-        // Relink parents
-        for (Map.Entry<ProtectedRegion, String> entry : parentSets.entrySet()) {
-            ProtectedRegion parent = regions.get(entry.getValue());
-            if (parent != null) {
-                try {
-                    entry.getKey().setParent(parent);
-                } catch (CircularInheritanceException e) {
-                    logger.warning("Circular inheritance detect with '"
-                            + entry.getValue() + "' detected as a parent");
-                }
-            } else {
-                logger.warning("Unknown region parent: " + entry.getValue());
-            }
-        }
-        
-        this.regions = regions;
-    }
-    
-    private <V> V checkNonNull(V val) throws NullPointerException {
-        if (val == null) {
-            throw new NullPointerException();
-        }
-        
-        return val;
-    }
-    
-    private void setFlags(ProtectedRegion region, ConfigurationNode flagsData) {
-        if (flagsData == null) {
-            return;
-        }
-        
-        // @TODO: Make this better
-        for (Flag<?> flag : DefaultFlag.getFlags()) {
-            Object o = flagsData.getProperty(flag.getName());
-            if (o != null) {
-                setFlag(region, flag, o);
-            }
-        }
-    }
-    
-    private <T> void setFlag(ProtectedRegion region, Flag<T> flag, Object rawValue) {
-        T val = flag.unmarshal(rawValue);
-        if (val == null) {
-            logger.warning("Failed to parse flag '" + flag.getName()
-                    + "' with value '" + rawValue.toString() + "'");
-            return;
-        }
-        region.setFlag(flag, val);
-    }
-    
-    private DefaultDomain parseDomain(ConfigurationNode node) {
-        if (node == null) {
-            return new DefaultDomain();
-        }
-        
-        DefaultDomain domain = new DefaultDomain();
-        
-        for (String name : node.getStringList("players", null)) {
-            domain.addPlayer(name);
-        }
-        
-        for (String name : node.getStringList("groups", null)) {
-            domain.addGroup(name);
-        }
-        
-        return domain;
-    }
-
-    public void save() throws IOException {
-        config.clear();
-        
-        for (Map.Entry<String, ProtectedRegion> entry : regions.entrySet()) {
-            ProtectedRegion region = entry.getValue();
-            ConfigurationNode node = config.addNode("regions." + entry.getKey());
-            
-            if (region instanceof ProtectedCuboidRegion) {
-                ProtectedCuboidRegion cuboid = (ProtectedCuboidRegion) region;
-                node.setProperty("type", "cuboid");
-                node.setProperty("min", cuboid.getMinimumPoint());
-                node.setProperty("max", cuboid.getMaximumPoint());
-            } else if (region instanceof ProtectedPolygonalRegion) {
-                ProtectedPolygonalRegion poly = (ProtectedPolygonalRegion) region;
-                node.setProperty("type", "poly2d");
-                node.setProperty("min-y", poly.getMinimumPoint().getBlockY());
-                node.setProperty("max-y", poly.getMaximumPoint().getBlockY());
-                
-                List<Map<String, Object>> points = new ArrayList<Map<String,Object>>();
-                for (BlockVector2D point : poly.getPoints()) {
-                    Map<String, Object> data = new HashMap<String, Object>();
-                    data.put("x", point.getBlockX());
-                    data.put("z", point.getBlockZ());
-                    points.add(data);
-                }
-                
-                node.setProperty("points", points);
-            } else if (region instanceof GlobalProtectedRegion) {
-                node.setProperty("type", "global");
-            } else {
-                node.setProperty("type", region.getClass().getCanonicalName());
-            }
-
-            node.setProperty("priority", region.getPriority());
-            node.setProperty("flags", getFlagData(region));
-            node.setProperty("owners", getDomainData(region.getOwners()));
-            node.setProperty("members", getDomainData(region.getMembers()));
-            ProtectedRegion parent = region.getParent();
-            if (parent != null) {
-                node.setProperty("parent", parent.getId());
-            }
-        }
-        
-        config.setHeader("#\r\n" +
-                "# WorldGuard regions file\r\n" +
-                "#\r\n" +
-                "# WARNING: THIS FILE IS AUTOMATICALLY GENERATED. If you modify this file by\r\n" +
-                "# hand, be aware that A SINGLE MISTYPED CHARACTER CAN CORRUPT THE FILE. If\r\n" +
-                "# WorldGuard is unable to parse the file, your regions will FAIL TO LOAD and\r\n" +
-                "# the contents of this file will reset. Please use a YAML validator such as\r\n" +
-                "# http://yaml-online-parser.appspot.com (for smaller files).\r\n" +
-                "#\r\n" +
-                "# REMEMBER TO KEEP PERIODICAL BACKUPS.\r\n" +
-                "#");
-        config.save();
-    }
-    
-    private Map<String, Object> getFlagData(ProtectedRegion region) {
-        Map<String, Object> flagData = new HashMap<String, Object>();
-        
-        for (Map.Entry<Flag<?>, Object> entry : region.getFlags().entrySet()) {
-            Flag<?> flag = entry.getKey();
-            addMarshalledFlag(flagData, flag, entry.getValue());
-        }
-        
-        return flagData;
-    }
-    
-    @SuppressWarnings("unchecked")
-    private <V> void addMarshalledFlag(Map<String, Object> flagData,
-            Flag<V> flag, Object val) {
-        if (val == null) {
-            return;
-        }
-        flagData.put(flag.getName(), flag.marshal((V) val));
-    }
-    
-    private Map<String, Object> getDomainData(DefaultDomain domain) {
-        Map<String, Object> domainData = new HashMap<String, Object>();
-
-        setDomainData(domainData, "players", domain.getPlayers());
-        setDomainData(domainData, "groups", domain.getGroups());
-        
-        return domainData;
-    }
-    
-    private void setDomainData(Map<String, Object> domainData,
-            String key, Set<String> domain) {
-        if (domain.size() == 0) {
-            return;
-        }
-        
-        List<String> list = new ArrayList<String>();
-        
-        for (String str : domain) {
-            list.add(str);
-        }
-        
-        domainData.put(key, list);
-    }
-
-    public Map<String, ProtectedRegion> getRegions() {
-        return regions;
-    }
-
-    public void setRegions(Map<String, ProtectedRegion> regions) {
-        this.regions = regions;
-    }
-    
-}

src/main/java/com/sk89q/worldguard/protection/flags/BooleanFlag.java

@@ -1,70 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- */
-public class BooleanFlag extends Flag<Boolean> {
-    
-    public BooleanFlag(String name, char legacyCode) {
-        super(name, legacyCode);
-    }
-
-    public BooleanFlag(String name) {
-        super(name);
-    }
-
-    @Override
-    public Boolean parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat {
-        input = input.trim();
-        
-        if (input.equalsIgnoreCase("true") || input.equalsIgnoreCase("yes")
-                || input.equalsIgnoreCase("on")
-                || input.equalsIgnoreCase("1")) {
-            return true;
-        } else if (input.equalsIgnoreCase("false") || input.equalsIgnoreCase("no")
-                || input.equalsIgnoreCase("off")
-                || input.equalsIgnoreCase("0")) {
-            return false;
-        } else {
-            throw new InvalidFlagFormat("Not a yes/no value: " + input);
-        }
-    }
-
-    @Override
-    public Boolean unmarshal(Object o) {
-        if (o instanceof Boolean) {
-            return (Boolean) o;
-        } else {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(Boolean o) {
-        return o;
-    }
-    
-}

src/main/java/com/sk89q/worldguard/protection/flags/CommandStringFlag.java

@@ -1,62 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- */
-public class CommandStringFlag extends Flag<String> {
-    
-    public CommandStringFlag(String name, char legacyCode) {
-        super(name, legacyCode);
-    }
-
-    public CommandStringFlag(String name) {
-        super(name);
-    }
-
-    @Override
-    public String parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat {
-        input = input.trim();
-        if (!input.startsWith("/")) {
-            input = "/" + input;
-        }
-        return input.toLowerCase();
-    }
-
-    @Override
-    public String unmarshal(Object o) {
-        if (o instanceof String) {
-            return (String) o;
-        } else {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(String o) {
-        return o;
-    }
-    
-}

src/main/java/com/sk89q/worldguard/protection/flags/CreatureTypeFlag.java

@@ -1,56 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-import org.bukkit.entity.CreatureType;
-
-/**
- * Represents a creature type.
- *
- * @author sk89q
- */
-public class CreatureTypeFlag extends EnumFlag<CreatureType> {
-
-    public CreatureTypeFlag(String name, char legacyCode) {
-        super(name, legacyCode, CreatureType.class);
-    }
-
-    public CreatureTypeFlag(String name) {
-        super(name, CreatureType.class);
-    }
-
-    @Override
-    public CreatureType detectValue(String input) {
-        CreatureType lowMatch = null;
-
-        for (CreatureType type : CreatureType.values()) {
-            if (type.name().equalsIgnoreCase(input.trim())) {
-                return type;
-            }
-
-            if (type.name().toLowerCase().startsWith(input.toLowerCase().trim())) {
-                lowMatch = type;
-            }
-        }
-
-        return lowMatch;
-    }
-}

src/main/java/com/sk89q/worldguard/protection/flags/DefaultFlag.java

@@ -1,106 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.entity.CreatureType;
-
-/**
- *
- * @author sk89q
- */
-public final class DefaultFlag {
-    
-    public static final StateFlag PASSTHROUGH = new StateFlag("passthrough", 'z', false);
-    public static final StateFlag BUILD = new StateFlag("build", 'b', true);
-    public static final StateFlag PVP = new StateFlag("pvp", 'p', true);
-    public static final StateFlag MOB_DAMAGE = new StateFlag("mob-damage", 'm', true);
-    public static final StateFlag MOB_SPAWNING = new StateFlag("mob-spawning", true);
-    public static final StateFlag CREEPER_EXPLOSION = new StateFlag("creeper-explosion", 'c', true);
-    public static final StateFlag GHAST_FIREBALL = new StateFlag("ghast-fireball", true);
-    public static final StateFlag SLEEP = new StateFlag("sleep", true);
-    public static final StateFlag TNT = new StateFlag("tnt", 't', true);
-    public static final StateFlag LIGHTER = new StateFlag("lighter", 'l', true);
-    public static final StateFlag FIRE_SPREAD = new StateFlag("fire-spread", 'f', true);
-    public static final StateFlag LAVA_FIRE = new StateFlag("lava-fire", 'F', true);
-    public static final StateFlag LIGHTNING = new StateFlag("lightning", true);
-    public static final StateFlag CHEST_ACCESS = new StateFlag("chest-access", 'C', false);
-    public static final StateFlag WATER_FLOW = new StateFlag("water-flow", true);
-    public static final StateFlag LAVA_FLOW = new StateFlag("lava-flow", true);
-    public static final StateFlag USE = new StateFlag("use", true);
-    public static final StateFlag PLACE_VEHICLE = new StateFlag("vehicle-place", false);
-    public static final StateFlag SNOW_FALL = new StateFlag("snow-fall", true);
-    public static final StateFlag LEAF_DECAY = new StateFlag("leaf-decay", true);
-    public static final StateFlag ENTRY = new StateFlag("entry", true);
-    public static final RegionGroupFlag ENTRY_PERM = new RegionGroupFlag("entry-group", RegionGroupFlag.RegionGroup.NON_MEMBERS);
-    public static final StateFlag EXIT = new StateFlag("exit", true);
-    public static final RegionGroupFlag EXIT_PERM = new RegionGroupFlag("exit-group", RegionGroupFlag.RegionGroup.NON_MEMBERS);
-    public static final StringFlag GREET_MESSAGE = new StringFlag("greeting");
-    public static final StringFlag FAREWELL_MESSAGE = new StringFlag("farewell");
-    public static final BooleanFlag NOTIFY_ENTER = new BooleanFlag("notify-enter");
-    public static final BooleanFlag NOTIFY_LEAVE = new BooleanFlag("notify-leave");
-    public static final SetFlag<CreatureType> DENY_SPAWN = new SetFlag<CreatureType>("deny-spawn", new CreatureTypeFlag(null));
-    public static final IntegerFlag HEAL_DELAY = new IntegerFlag("heal-delay");
-    public static final IntegerFlag HEAL_AMOUNT = new IntegerFlag("heal-amount");
-    public static final VectorFlag TELE_LOC = new VectorFlag("teleport");
-    public static final RegionGroupFlag TELE_PERM = new RegionGroupFlag("teleport-group", RegionGroupFlag.RegionGroup.MEMBERS);
-    public static final VectorFlag SPAWN_LOC = new VectorFlag("spawn");
-    public static final RegionGroupFlag SPAWN_PERM = new RegionGroupFlag("spawn-group", RegionGroupFlag.RegionGroup.MEMBERS);
-    public static final BooleanFlag BUYABLE = new BooleanFlag("buyable");
-    public static final DoubleFlag PRICE = new DoubleFlag("price");
-    public static final SetFlag<String> BLOCKED_CMDS = new SetFlag<String>("blocked-cmds", new CommandStringFlag(null));
-    public static final SetFlag<String> ALLOWED_CMDS = new SetFlag<String>("allowed-cmds", new CommandStringFlag(null));
-
-    public static final Flag<?>[] flagsList = new Flag<?>[] {
-        PASSTHROUGH, BUILD, PVP, MOB_DAMAGE, MOB_SPAWNING, CREEPER_EXPLOSION, SLEEP,
-        TNT, LIGHTER, FIRE_SPREAD, LAVA_FIRE, CHEST_ACCESS, WATER_FLOW, LAVA_FLOW,
-        USE, PLACE_VEHICLE, GREET_MESSAGE, FAREWELL_MESSAGE, NOTIFY_ENTER,
-        NOTIFY_LEAVE, DENY_SPAWN, HEAL_DELAY, HEAL_AMOUNT, TELE_LOC,
-        TELE_PERM, SPAWN_LOC, SPAWN_PERM, BUYABLE, PRICE, SNOW_FALL, LEAF_DECAY,
-        GHAST_FIREBALL, BLOCKED_CMDS, ALLOWED_CMDS, ENTRY, ENTRY_PERM, EXIT, EXIT_PERM
-    };
-
-    static {
-        ENTRY.setGroupFlag(ENTRY_PERM);
-        EXIT.setGroupFlag(EXIT_PERM);
-    }
-    
-    private DefaultFlag() {
-    }
-    
-    public static Flag<?>[] getFlags() {
-        return flagsList;
-    }
-    
-    /**
-     * Get the legacy flag.
-     * 
-     * @param flagString
-     * @return null if not found
-     */
-    public static StateFlag getLegacyFlag(String flagString) {
-        for (Flag<?> flag : flagsList) {
-            if (flag instanceof StateFlag && flagString.equals(String.valueOf(flag.getLegacyCode()))) {
-                return (StateFlag) flag;
-            }
-        }
-        
-        return null;
-    }
-}

src/main/java/com/sk89q/worldguard/protection/flags/DoubleFlag.java

@@ -1,63 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- */
-public class DoubleFlag extends Flag<Double> {
-    
-    public DoubleFlag(String name, char legacyCode) {
-        super(name, legacyCode);
-    }
-
-    public DoubleFlag(String name) {
-        super(name);
-    }
-
-    @Override
-    public Double parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat {
-        input = input.trim();
-        
-        try {
-            return Double.parseDouble(input);
-        } catch (NumberFormatException e) {
-            throw new InvalidFlagFormat("Not a number: " + input);
-        }
-    }
-
-    @Override
-    public Double unmarshal(Object o) {
-        if (o instanceof Double) {
-            return (Double) o;
-        } else {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(Double o) {
-        return o;
-    }
-}

src/main/java/com/sk89q/worldguard/protection/flags/EnumFlag.java

@@ -1,91 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- */
-public class EnumFlag<T extends Enum<T>> extends Flag<T> {
-
-    private Class<T> enumClass;
-    
-    public EnumFlag(String name, char legacyCode, Class<T> enumClass) {
-        super(name, legacyCode);
-        this.enumClass = enumClass;
-    }
-
-    public EnumFlag(String name, Class<T> enumClass) {
-        super(name);
-        this.enumClass = enumClass;
-    }
-
-    private T findValue(String input) throws IllegalArgumentException {
-        try {
-            return Enum.valueOf(enumClass, input);
-        } catch (IllegalArgumentException e) {
-            T val = detectValue(input);
-
-            if (val != null) {
-                return val;
-            }
-
-            throw e;
-        }
-    }
-
-    /**
-     * Fuzzy detect the value if the value is not found.
-     *
-     * @param input string input
-     * @return value or null
-     */
-    public T detectValue(String input) {
-        return null;
-    }
-
-    @Override
-    public T parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat {
-        try {
-            return findValue(input);
-        } catch (IllegalArgumentException e) {
-            throw new InvalidFlagFormat("Unknown value '" + input + "' in "
-                    + enumClass.getName());
-        }
-    }
-
-    @Override
-    public T unmarshal(Object o) {
-        try {
-            return Enum.valueOf(enumClass, String.valueOf(o));
-        } catch (IllegalArgumentException e) {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(T o) {
-        return o.name();
-    }
-    
-}

src/main/java/com/sk89q/worldguard/protection/flags/Flag.java

@@ -1,58 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- * @param <T> 
- */
-public abstract class Flag<T> {
-    
-    private String name;
-    private Character legacyCode;
-    
-    public Flag(String name, char legacyCode) {
-        this.name = name;
-        this.legacyCode = legacyCode;
-    }
-    
-    public Flag(String name) {
-        this.name = name;
-        this.legacyCode = null;
-    }
-    
-    public String getName() {
-        return name;
-    }
-    
-    public Character getLegacyCode() {
-        return legacyCode;
-    }
-    
-    public abstract T parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat;
-    
-    public abstract T unmarshal(Object o);
-    
-    public abstract Object marshal(T o);
-}

src/main/java/com/sk89q/worldguard/protection/flags/IntegerFlag.java

@@ -1,63 +0,0 @@
-// $Id$
-/*
- * WorldGuard
- * Copyright (C) 2010 sk89q <http://www.sk89q.com>
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.sk89q.worldguard.protection.flags;
-
-import org.bukkit.command.CommandSender;
-import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
-
-/**
- *
- * @author sk89q
- */
-public class IntegerFlag extends Flag<Integer> {
-    
-    public IntegerFlag(String name, char legacyCode) {
-        super(name, legacyCode);
-    }
-
-    public IntegerFlag(String name) {
-        super(name);
-    }
-
-    @Override
-    public Integer parseInput(WorldGuardPlugin plugin, CommandSender sender,
-            String input) throws InvalidFlagFormat {
-        input = input.trim();
-        
-        try {
-            return Integer.parseInt(input);
-        } catch (NumberFormatException e) {
-            throw new InvalidFlagFormat("Not a number: " + input);
-        }
-    }
-
-    @Override
-    public Integer unmarshal(Object o) {
-        if (o instanceof Integer) {
-            return (Integer) o;
-        } else {
-            return null;
-        }
-    }
-
-    @Override
-    public Object marshal(Integer o) {
-        return o;
-    }
-}